repair

git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/svn-server-sync/jogl/branches/JOGL_2_SANDBOX@1872 232f8b59-042b-4e1e-8c03-345bb8c30851

193 files changed, 42589 insertions, 0 deletions

diff --git a/src/jogl/classes/com/sun/opengl/impl/DRIHack.java b/src/jogl/classes/com/sun/opengl/impl/DRIHack.java
new file mode 100755
index 000000000..5478bd2f3
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/DRIHack.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl;
+
+import java.io.*;
+import java.security.*;
+import com.sun.gluegen.runtime.*;
+
+/**
+ * Helper class for working around problems with open-source DRI
+ * drivers. In the current DRI implementation it is required that the
+ * symbols in libGL.so.1.2 be globally visible to be accessible from
+ * other libraries that are dynamically loaded by the implementation.
+ * Applications may typically satisfy this need either by linking
+ * against libGL.so on the command line (-lGL) or by dlopen'ing
+ * libGL.so.1.2 with the RTLD_GLOBAL flag. The JOGL implementation
+ * links against libGL on all platforms rather than forcing all OpenGL
+ * entry points to be called through a function pointer. This allows
+ * the JOGL library to link directly to core 1.1 OpenGL entry points
+ * like glVertex3f, while calling through function pointers for entry
+ * points from later OpenGL versions as well as from
+ * extensions. However, because libjogl.so (which links against
+ * libGL.so) is loaded by the JVM, and because the JVM implicitly uses
+ * RTLD_LOCAL in the implementation of System.loadLibrary(), this
+ * means via transitivity that the symbols for libGL.so have only
+ * RTLD_LOCAL visibility to the rest of the application, so the DRI
+ * drivers can not find the symbols required. <P>
+ *
+ * There are at least two possible solutions. One would be to change
+ * the JOGL implementation to call through function pointers uniformly
+ * so that it does not need to link against libGL.so. This is
+ * possible, but requires changes to GlueGen and also is not really
+ * necessary in any other situation than with the DRI drivers. Another
+ * solution is to force the first load of libGL.so.1.2 to be done
+ * dynamically with RTLD_GLOBAL before libjogl.so is loaded and causes
+ * libGL.so.1.2 to be loaded again. The NativeLibrary class in the
+ * GlueGen runtime has this property, and we use it to implement this
+ * workaround.
+ */
+
+public class DRIHack {
+  private static final boolean DEBUG = Debug.debug("DRIHack");
+  private static boolean driHackNeeded;
+  private static NativeLibrary oglLib;
+
+  public static void begin() {
+    AccessController.doPrivileged(new PrivilegedAction() {
+        public Object run() {
+          String os = System.getProperty("os.name").toLowerCase();
+          // Do DRI hack on all Linux distributions for best robustness
+          driHackNeeded =
+            (os.startsWith("linux") ||
+             new File("/usr/lib/dri").exists() ||
+             new File("/usr/X11R6/lib/modules/dri").exists());
+          // Allow manual overriding for now as a workaround for
+          // problems seen in some situations -- needs more investigation
+          if (System.getProperty("jogl.drihack.disable") != null) {
+            driHackNeeded = false;
+          }
+          return null;
+        }
+      });
+
+    if (driHackNeeded) {
+      if (DEBUG) {
+        System.err.println("Beginning DRI hack");
+      }
+
+      // Try a few different variants for best robustness
+      // In theory probably only the first is necessary
+      oglLib = NativeLibrary.open("libGL.so.1", null);
+      if (DEBUG && oglLib != null) System.err.println(" Found libGL.so.1");
+      if (oglLib == null) {
+        oglLib = NativeLibrary.open("/usr/lib/libGL.so.1", null);
+        if (DEBUG && oglLib != null) System.err.println(" Found /usr/lib/libGL.so.1");
+      }
+    }
+  }
+
+  public static void end() {
+    if (oglLib != null) {
+      if (DEBUG) {
+        System.err.println("Ending DRI hack");
+      }
+
+      oglLib.close();
+      oglLib = null;
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/Debug.java b/src/jogl/classes/com/sun/opengl/impl/Debug.java
new file mode 100644
index 000000000..9faa04fa7
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/Debug.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2003-2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl;
+
+import java.security.*;
+
+/** Helper routines for logging and debugging. */
+
+public class Debug {
+  // Some common properties
+  private static boolean verbose;
+  private static boolean debugAll;
+  
+  static {
+    verbose = isPropertyDefined("jogl.verbose");
+    debugAll = isPropertyDefined("jogl.debug");
+    if (verbose) {
+       Package p = Package.getPackage("javax.media.opengl");
+       System.err.println("JOGL specification version " + p.getSpecificationVersion());
+       System.err.println("JOGL implementation version " + p.getImplementationVersion());
+       System.err.println("JOGL implementation vendor " + p.getImplementationVendor());
+    }
+  }
+
+  public static boolean getBooleanProperty(final String property) {
+    Boolean b = (Boolean) AccessController.doPrivileged(new PrivilegedAction() {
+        public Object run() {
+          boolean val = Boolean.getBoolean(property);
+          return (val ? Boolean.TRUE : Boolean.FALSE);
+        }
+      });
+    return b.booleanValue();
+  }
+
+  public static boolean isPropertyDefined(final String property) {
+    Boolean b = (Boolean) AccessController.doPrivileged(new PrivilegedAction() {
+        public Object run() {
+          String val = System.getProperty(property);
+          return (val != null ? Boolean.TRUE : Boolean.FALSE);
+        }
+      });
+    return b.booleanValue();
+  }
+
+  public static boolean verbose() {
+    return verbose;
+  }
+
+  public static boolean debugAll() {
+    return debugAll;
+  }
+
+  public static boolean debug(String subcomponent) {
+    return debugAll() || isPropertyDefined("jogl.debug." + subcomponent);
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/ExtensionAvailabilityCache.java b/src/jogl/classes/com/sun/opengl/impl/ExtensionAvailabilityCache.java
new file mode 100644
index 000000000..23ce26154
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/ExtensionAvailabilityCache.java
@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl;
+
+import javax.media.opengl.*;
+import java.util.*;
+// FIXME: refactor Java SE dependencies
+//import java.util.regex.*;
+import java.lang.reflect.*;
+
+/**
+ * A utility object intended to be used by implementations to act as a cache
+ * of which OpenGL extensions are currently available on both the host machine
+ * and display.
+ */
+public final class ExtensionAvailabilityCache {
+  private static final boolean DEBUG = Debug.debug("ExtensionAvailabilityCache");
+
+  ExtensionAvailabilityCache(GLContextImpl context)
+  {
+    this.context = context;
+  }
+
+  /**
+   * Flush the cache. The cache will be rebuilt lazily as calls to {@link
+   * #isExtensionAvailable(String)} are received.
+   */
+  public void flush()
+  {
+    availableExtensionCache.clear();
+  }
+
+  public boolean isExtensionAvailable(String glExtensionName) {
+    initAvailableExtensions();
+    return availableExtensionCache.contains(mapGLExtensionName(glExtensionName));
+  }
+
+  protected void initAvailableExtensions() {
+    // if hash is empty (meaning it was flushed), pre-cache it with the list
+    // of extensions that are in the GL_EXTENSIONS string
+    if (availableExtensionCache.isEmpty()) {
+      GL gl = context.getGL();
+      if (DEBUG) {
+        System.err.println("!!! Pre-caching extension availability");
+      }
+      String allAvailableExtensions =
+        gl.glGetString(GL.GL_EXTENSIONS) + " " + context.getPlatformExtensionsString();
+      if (DEBUG) {
+        System.err.println("!!! Available extensions: " + allAvailableExtensions);
+        System.err.println("!!! GL vendor: " + gl.glGetString(GL.GL_VENDOR));
+      }
+      StringTokenizer tok = new StringTokenizer(allAvailableExtensions);
+      while (tok.hasMoreTokens()) {
+        String availableExt = tok.nextToken().trim();
+        availableExt = availableExt.intern();
+        availableExtensionCache.add(availableExt);
+        if (DEBUG) {
+          System.err.println("!!!   Available: " + availableExt);
+        }
+      }
+
+      // Put GL version strings in the table as well
+      Version version = new Version(gl.glGetString(GL.GL_VERSION));
+      if (version.isValid()) {
+        int major = version.getMajor();
+        int minor = version.getMinor();
+        // FIXME: this needs to be adjusted when the major rev changes
+        // beyond the known ones
+        while (major > 0) {
+          while (minor >= 0) {
+            availableExtensionCache.add("GL_VERSION_" + major + "_" + minor);
+            if (DEBUG) {
+              System.err.println("!!! Added GL_VERSION_" + major + "_" + minor + " to known extensions");
+            }
+            --minor;
+          }
+
+          switch (major) {
+          case 2:
+            // Restart loop at version 1.5
+            minor = 5;
+            break;
+          case 1:
+            break;
+          }
+
+          --major;
+        }
+      }
+
+      // put a dummy var in here so that the cache is no longer empty even if
+      // no extensions are in the GL_EXTENSIONS string
+      availableExtensionCache.add("<INTERNAL_DUMMY_PLACEHOLDER>");
+    }
+  }
+
+  // FIXME: hack to re-enable GL_NV_vertex_array_range extension after
+  // recent upgrade to new wglext.h and glxext.h headers
+  private static String mapGLExtensionName(String extensionName) {
+    if (extensionName != null &&
+        (extensionName.equals("WGL_NV_vertex_array_range") ||
+         extensionName.equals("GLX_NV_vertex_array_range"))) 
+      return "GL_NV_vertex_array_range";
+    return extensionName;
+  }
+
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+
+  private HashSet availableExtensionCache = new HashSet(50);
+  private GLContextImpl context;
+
+  /**
+   * A class for storing and comparing OpenGL version numbers.
+   * This only works for desktop OpenGL at the moment.
+   */
+  private static class Version implements Comparable
+  {
+    private boolean valid;
+    private int major, minor, sub;
+    public Version(int majorRev, int minorRev, int subMinorRev)
+    {
+      major = majorRev;
+      minor = minorRev;
+      sub = subMinorRev;
+    }
+
+    /**
+     * @param versionString must be of the form "GL_VERSION_X" or
+     * "GL_VERSION_X_Y" or "GL_VERSION_X_Y_Z" or "X.Y", where X, Y,
+     * and Z are integers.
+     *
+     * @exception IllegalArgumentException if the argument is not a valid
+     * OpenGL version identifier
+     */
+    public Version(String versionString)
+    {
+      try 
+      {
+        if (versionString.startsWith("GL_VERSION_"))
+        {
+          StringTokenizer tok = new StringTokenizer(versionString, "_");
+
+          tok.nextToken(); // GL_
+          tok.nextToken(); // VERSION_ 
+          if (!tok.hasMoreTokens()) { major = 0; return; }
+          major = Integer.valueOf(tok.nextToken()).intValue();
+          if (!tok.hasMoreTokens()) { minor = 0; return; }
+          minor = Integer.valueOf(tok.nextToken()).intValue();
+          if (!tok.hasMoreTokens()) { sub = 0; return; }
+          sub = Integer.valueOf(tok.nextToken()).intValue();
+        }
+        else
+        {
+          int radix = 10;
+          if (versionString.length() > 2) {
+            if (Character.isDigit(versionString.charAt(0)) &&
+                versionString.charAt(1) == '.' &&
+                Character.isDigit(versionString.charAt(2))) {
+              major = Character.digit(versionString.charAt(0), radix);
+              minor = Character.digit(versionString.charAt(2), radix);
+
+              // See if there's version-specific information which might
+              // imply a more recent OpenGL version
+              StringTokenizer tok = new StringTokenizer(versionString, " ");
+              if (tok.hasMoreTokens()) {
+                tok.nextToken();
+                if (tok.hasMoreTokens()) {
+                  String token = tok.nextToken();
+                  int i = 0;
+                  while (i < token.length() && !Character.isDigit(token.charAt(i))) {
+                    i++;
+                  }
+                  if (i < token.length() - 2 &&
+                      Character.isDigit(token.charAt(i)) &&
+                      token.charAt(i+1) == '.' &&
+                      Character.isDigit(token.charAt(i+2))) {
+                    int altMajor = Character.digit(token.charAt(i), radix);
+                    int altMinor = Character.digit(token.charAt(i+2), radix);
+                    // Avoid possibly confusing situations by putting some
+                    // constraints on the upgrades we do to the major and
+                    // minor versions
+                    if ((altMajor == major && altMinor > minor) ||
+                        altMajor == major + 1) {
+                      major = altMajor;
+                      minor = altMinor;
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+        valid = true;
+      }
+      catch (Exception e)
+      {
+        // FIXME: refactor desktop OpenGL dependencies and make this
+        // class work properly for OpenGL ES
+        System.err.println("FunctionAvailabilityCache.Version.<init>: "+e);
+        major = 1;
+        minor = 0;
+        /*
+        throw (IllegalArgumentException)
+          new IllegalArgumentException(
+            "Illegally formatted version identifier: \"" + versionString + "\"")
+              .initCause(e);
+        */
+      }
+    }
+
+    public boolean isValid() {
+      return valid;
+    }
+
+    public int compareTo(Object o)
+    {
+      Version vo = (Version)o;
+      if (major > vo.major) return 1; 
+      else if (major < vo.major) return -1; 
+      else if (minor > vo.minor) return 1; 
+      else if (minor < vo.minor) return -1; 
+      else if (sub > vo.sub) return 1; 
+      else if (sub < vo.sub) return -1; 
+
+      return 0; // they are equal
+    }
+
+    public int getMajor() {
+      return major;
+    }
+
+    public int getMinor() {
+      return minor;
+    }
+    
+  } // end class Version
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/GLArrayHandler.java b/src/jogl/classes/com/sun/opengl/impl/GLArrayHandler.java
new file mode 100644
index 000000000..d34e04b10
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/GLArrayHandler.java
@@ -0,0 +1,12 @@
+
+package com.sun.opengl.impl;
+
+import javax.media.opengl.*;
+import javax.media.opengl.sub.*;
+
+public interface GLArrayHandler {
+
+  public void enableBuffer(GL gl, boolean enable);
+
+}
+
diff --git a/src/jogl/classes/com/sun/opengl/impl/GLBufferSizeTracker.java b/src/jogl/classes/com/sun/opengl/impl/GLBufferSizeTracker.java
new file mode 100755
index 000000000..53fcc2de1
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/GLBufferSizeTracker.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl;
+
+import java.util.*;
+import javax.media.opengl.*;
+
+/**
+ * Tracks as closely as possible the sizes of allocated OpenGL buffer
+ * objects. When glMapBuffer or glMapBufferARB is called, in order to
+ * turn the resulting base address into a java.nio.ByteBuffer, we need
+ * to know the size in bytes of the allocated OpenGL buffer object.
+ * Previously we would compute this size by using
+ * glGetBufferParameterivARB with a pname of GL_BUFFER_SIZE, but
+ * it appears doing so each time glMapBuffer is called is too costly
+ * on at least Apple's new multithreaded OpenGL implementation. <P>
+ *
+ * Instead we now try to track the sizes of allocated buffer objects.
+ * We watch calls to glBindBuffer to see which buffer is bound to
+ * which target and to glBufferData to see how large the buffer's
+ * allocated size is. When glMapBuffer is called, we consult our table
+ * of buffer sizes to see if we can return an answer without a glGet
+ * call. <P>
+ *
+ * We share the GLBufferSizeTracker objects among all GLContexts for
+ * which sharing is enabled, because the namespace for buffer objects
+ * is the same for these contexts. <P>
+ *
+ * Tracking the state of which buffer objects are bound is done in the
+ * GLBufferStateTracker and is not completely trivial. In the face of
+ * calls to glPushClientAttrib / glPopClientAttrib we currently punt
+ * and re-fetch the bound buffer object for the state in question;
+ * see, for example, glVertexPointer and the calls down to
+ * GLBufferStateTracker.getBoundBufferObject(). Note that we currently
+ * ignore new binding targets such as GL_TRANSFORM_FEEDBACK_BUFFER_NV;
+ * the fact that new binding targets may be added in the future makes
+ * it impossible to cache state for these new targets. <P>
+ *
+ * Ignoring new binding targets, the primary situation in which we may
+ * not be able to return a cached answer is in the case of an error,
+ * where glBindBuffer may not have been called before trying to call
+ * glBufferData. Also, if external native code modifies a buffer
+ * object, we may return an incorrect answer. (FIXME: this case
+ * requires more thought, and perhaps stochastic and
+ * exponential-fallback checking. However, note that it can only occur
+ * in the face of external native code which requires that the
+ * application be signed anyway, so there is no security risk in this
+ * area.)
+ */
+
+public class GLBufferSizeTracker {
+  // Map from buffer names to sizes.
+  // Note: should probably have some way of shrinking this map, but
+  // can't just make it a WeakHashMap because nobody holds on to the
+  // keys; would have to always track creation and deletion of buffer
+  // objects, which is probably sub-optimal. The expected usage
+  // pattern of buffer objects indicates that the fact that this map
+  // never shrinks is probably not that bad.
+  private Map/*<Integer,Integer>*/ bufferSizeMap =
+    Collections.synchronizedMap(new HashMap/*<Integer,Integer>*/());
+
+  private static final boolean DEBUG = Debug.debug("GLBufferSizeTracker");
+
+  public GLBufferSizeTracker() {
+  }
+
+  public void setBufferSize(GLBufferStateTracker bufferStateTracker,
+                            int target,
+                            GL caller,
+                            int size) {
+    // Need to do some similar queries to getBufferSize below
+    int buffer = bufferStateTracker.getBoundBufferObject(target, caller);
+    boolean valid = bufferStateTracker.isBoundBufferObjectKnown(target);
+    if (valid) {
+      if (buffer == 0) {
+        // FIXME: this really should not happen if we know what's
+        // going on. Very likely there is an OpenGL error in the
+        // application if we get here. Could silently return 0, but it
+        // seems better to get an early warning that something is
+        // wrong.
+        throw new GLException("Error: no OpenGL buffer object appears to be bound to target 0x" +
+                              Integer.toHexString(target));
+      }
+      bufferSizeMap.put(new Integer(buffer), new Integer(size));
+    }
+    // We don't know the current buffer state. Note that the buffer
+    // state tracker will have made the appropriate OpenGL query if it
+    // didn't know what was going on, so at this point we have nothing
+    // left to do except drop this piece of information on the floor.
+  }
+
+  public int getBufferSize(GLBufferStateTracker bufferStateTracker,
+                           int target,
+                           GL caller) {
+    // See whether we know what buffer is currently bound to the given
+    // state
+    int buffer = bufferStateTracker.getBoundBufferObject(target, caller);
+    boolean valid = bufferStateTracker.isBoundBufferObjectKnown(target);
+    if (valid) {
+      if (buffer == 0) {
+        // FIXME: this really should not happen if we know what's
+        // going on. Very likely there is an OpenGL error in the
+        // application if we get here. Could silently return 0, but it
+        // seems better to get an early warning that something is
+        // wrong.
+        throw new GLException("Error: no OpenGL buffer object appears to be bound to target 0x" +
+                              Integer.toHexString(target));
+      }
+      // See whether we know the size of this buffer object; at this
+      // point we almost certainly should if the application is
+      // written correctly
+      Integer key = new Integer(buffer);
+      Integer sz = (Integer) bufferSizeMap.get(key);
+      if (sz == null) {
+        // For robustness, try to query this value from the GL as we used to
+        int[] tmp = new int[1];
+        caller.glGetBufferParameteriv(target, GL.GL_BUFFER_SIZE, tmp, 0);
+        if (tmp[0] == 0) {
+          // Assume something is wrong rather than silently going along
+          throw new GLException("Error: buffer size returned by glGetBufferParameteriv was zero; probably application error");
+        }
+        // Assume we just don't know what's happening
+        sz = new Integer(tmp[0]);
+        bufferSizeMap.put(key, sz);
+        if (DEBUG) {
+          System.err.println("GLBufferSizeTracker.getBufferSize(): made slow query to cache size " +
+                             tmp[0] +
+                             " for buffer " +
+                             buffer);
+        }
+      }
+      return sz.intValue();
+    }
+    // We don't know what's going on in this case; query the GL for an answer
+    int[] tmp = new int[1];
+    caller.glGetBufferParameteriv(target, GL.GL_BUFFER_SIZE, tmp, 0);
+    if (DEBUG) {
+      System.err.println("GLBufferSizeTracker.getBufferSize(): no cached buffer information");
+    }
+    return tmp[0];
+  }
+
+  // This should be called on any major event where we might start
+  // producing wrong answers, such as OpenGL context creation and
+  // destruction if we don't know whether there are other currently-
+  // created contexts that might be keeping the buffer objects alive
+  // that we're dealing with
+  public void clearCachedBufferSizes() {
+    bufferSizeMap.clear();
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/GLBufferStateTracker.java b/src/jogl/classes/com/sun/opengl/impl/GLBufferStateTracker.java
new file mode 100755
index 000000000..ddc82eba2
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/GLBufferStateTracker.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl;
+
+import java.util.*;
+import javax.media.opengl.*;
+
+/**
+ * Tracks as closely as possible which OpenGL buffer object is bound
+ * to which binding target in the current OpenGL context.
+ * GLBufferStateTracker objects are allocated on a per-GLImpl basis,
+ * which is basically identical to a per-OpenGL-context basis
+ * (assuming correct usage of the GLImpl objects, which is checked by
+ * the DebugGL). This class is used to verify that e.g. the vertex
+ * buffer object extension is in use when the glVertexPointer variant
+ * taking a long as argument is called. <P>
+ * 
+ * Note that because the enumerated value used for the binding of a
+ * buffer object (e.g. GL_ARRAY_BUFFER) is different than that used to
+ * query the binding using glGetIntegerv (e.g.
+ * GL_ARRAY_BUFFER_BINDING), then in the face of new binding targets
+ * being added to the GL (e.g. GL_TRANSFORM_FEEDBACK_BUFFER_NV) it is
+ * impossible to set up a query of the buffer object currently bound
+ * to a particular state. It turns out that for some uses, such as
+ * finding the size of the currently bound buffer, this doesn't
+ * matter, though of course without knowing the buffer object we can't
+ * re-associate the queried size with the buffer object ID. <P>
+ *
+ * Because the namespace of buffer objects is the unsigned integers
+ * with 0 reserved by the GL, and because we have to be able to return
+ * both 0 and other integers as valid answers from
+ * getBoundBufferObject(), we need a second query, which is to ask
+ * whether we know the state of the binding for a given target. For
+ * "unknown" targets such as GL_TRANSFORM_FEEDBACK_BUFFER_NV we return
+ * false from this, but we also clear the valid bit and later refresh
+ * the binding state if glPushClientAttrib / glPopClientAttrib are
+ * called, since we don't want the complexity of tracking stacks of
+ * these attributes.
+ *
+ */
+
+public class GLBufferStateTracker {
+  private static final boolean DEBUG = Debug.debug("GLBufferStateTracker");
+
+  private static final Integer arrayBufferEnum        = new Integer(GL.GL_ARRAY_BUFFER);
+  private static final Integer elementArrayBufferEnum = new Integer(GL.GL_ELEMENT_ARRAY_BUFFER);
+  private static final Integer pixelPackBufferEnum    = new Integer(GL2.GL_PIXEL_PACK_BUFFER);
+  private static final Integer pixelUnpackBufferEnum  = new Integer(GL2.GL_PIXEL_UNPACK_BUFFER);
+  private static final Integer zero                   = new Integer(0);
+
+  // Maps binding targets to buffer objects. A null value indicates
+  // that the binding is unknown. A zero value indicates that it is
+  // known that no buffer is bound to the target.
+  private Map/*<Integer,Integer>*/ bindingMap = new HashMap/*<Integer,Integer>*/();
+
+  private int[] bufTmp = new int[1];
+
+  public GLBufferStateTracker() {
+    // Start with known unbound targets for known keys
+    bindingMap.put(arrayBufferEnum,        zero);
+    bindingMap.put(elementArrayBufferEnum, zero);
+    bindingMap.put(pixelPackBufferEnum,    zero);
+    bindingMap.put(pixelUnpackBufferEnum,  zero);
+  }
+
+  public void setBoundBufferObject(int target, int buffer) {
+    Integer key = box(target);
+    bindingMap.put(key, box(buffer));
+  }
+
+  /** Note: returns an unspecified value if the binding for the
+      specified target (e.g. GL_ARRAY_BUFFER) is currently unknown.
+      You must use isBoundBufferObjectKnown() to see whether the
+      return value is valid. */
+  public int getBoundBufferObject(int target, GL caller) {
+    Integer key = box(target);
+    Integer value = (Integer) bindingMap.get(key);
+    if (value == null) {
+      // User probably either called glPushClientAttrib /
+      // glPopClientAttrib or is querying an unknown target. See
+      // whether we know how to fetch this state.
+      boolean gotQueryTarget = true;
+      int queryTarget = 0;
+      switch (target) {
+        case GL.GL_ARRAY_BUFFER:          queryTarget = GL.GL_ARRAY_BUFFER_BINDING;         break;
+        case GL.GL_ELEMENT_ARRAY_BUFFER:  queryTarget = GL.GL_ELEMENT_ARRAY_BUFFER_BINDING; break;
+        case GL2.GL_PIXEL_PACK_BUFFER:    queryTarget = GL2.GL_PIXEL_PACK_BUFFER_BINDING;    break;
+        case GL2.GL_PIXEL_UNPACK_BUFFER:  queryTarget = GL2.GL_PIXEL_UNPACK_BUFFER_BINDING;  break;
+        default:                          gotQueryTarget = false; break;
+      }
+      if (gotQueryTarget) {
+        caller.glGetIntegerv(queryTarget, bufTmp, 0);
+        if (DEBUG) {
+          System.err.println("GLBufferStateTracker.getBoundBufferObject(): queried bound buffer " +
+                             bufTmp[0] +
+                             " for query target 0x" + Integer.toHexString(queryTarget));
+        }
+        setBoundBufferObject(target, bufTmp[0]);
+        // Try once more
+        return getBoundBufferObject(target, caller);
+      }
+      return 0;
+    }
+    return value.intValue();
+  }
+
+  /** Indicates whether the binding state for the specified target is
+      currently known. Should be called after getBoundBufferObject()
+      because that method may change the answer for a given target. */
+  public boolean isBoundBufferObjectKnown(int target) {
+    return (bindingMap.get(box(target)) != null);
+  }
+
+  /** Clears out the known/unknown state of the various buffer object
+      binding states. These will be refreshed later on an as-needed
+      basis. This is called by the implementations of
+      glPushClientAttrib / glPopClientAttrib. Might want to call this
+      from GLContext.makeCurrent() in the future to possibly increase
+      the robustness of these caches in the face of external native
+      code manipulating OpenGL state. */
+  public void clearBufferObjectState() {
+    bindingMap.clear();
+  }
+
+  // FIXME: could largely remove this and use Integer.valueOf() in JDK 5
+  private static Integer box(int key) {
+    switch (key) {
+      case 0:                          return zero;
+      case GL.GL_ARRAY_BUFFER:         return arrayBufferEnum;
+      case GL.GL_ELEMENT_ARRAY_BUFFER: return elementArrayBufferEnum;
+      case GL2.GL_PIXEL_PACK_BUFFER:   return pixelPackBufferEnum;
+      case GL2.GL_PIXEL_UNPACK_BUFFER: return pixelUnpackBufferEnum;
+      default:                         return new Integer(key);
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/GLContextImpl.java b/src/jogl/classes/com/sun/opengl/impl/GLContextImpl.java
new file mode 100644
index 000000000..01e639ac6
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/GLContextImpl.java
@@ -0,0 +1,500 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl;
+
+import java.nio.*;
+import java.lang.reflect.*;
+
+import javax.media.opengl.*;
+import com.sun.nwi.impl.NWReflection;
+import com.sun.gluegen.runtime.*;
+import com.sun.gluegen.runtime.opengl.*;
+
+public abstract class GLContextImpl extends GLContext {
+  protected GLContextLock lock = new GLContextLock();
+  protected static final boolean DEBUG = Debug.debug("GLContext");
+  protected static final boolean VERBOSE = Debug.verbose();
+  protected static final boolean NO_FREE = Debug.isPropertyDefined("jogl.GLContext.nofree");
+  // NOTE: default sense of GLContext optimization disabled in JSR-231
+  // 1.0 beta 5 due to problems on X11 platforms (both Linux and
+  // Solaris) when moving and resizing windows. Apparently GLX tokens
+  // get sent to the X server under the hood (and out from under the
+  // cover of the AWT lock) in these situations. Users requiring
+  // multi-screen X11 applications can manually enable this flag. It
+  // basically had no tangible effect on the Windows or Mac OS X
+  // platforms anyway in particular with the disabling of the
+  // GLWorkerThread which we found to be necessary in 1.0 beta 4.
+  protected boolean optimizationEnabled = Debug.isPropertyDefined("jogl.GLContext.optimize");
+
+  // Cache of the functions that are available to be called at the current
+  // moment in time
+  protected ExtensionAvailabilityCache extensionAvailability;
+  // Table that holds the addresses of the native C-language entry points for
+  // OpenGL functions.
+  private ProcAddressTable glProcAddressTable;
+
+  // Tracks creation and initialization of buffer objects to avoid
+  // repeated glGet calls upon glMapBuffer operations
+  private GLBufferSizeTracker bufferSizeTracker;
+
+  protected GL gl;
+
+  public GLContextImpl(GLContext shareWith) {
+    extensionAvailability = new ExtensionAvailabilityCache(this);
+    if (shareWith != null) {
+      GLContextShareSet.registerSharing(this, shareWith);
+    }
+    GLContextShareSet.registerForBufferObjectSharing(shareWith, this);
+    // This must occur after the above calls into the
+    // GLContextShareSet, which set up state needed by the GL object
+    setGL(createGL());
+  }
+
+  public GLDrawableImpl getDrawableImpl() {
+    return (GLDrawableImpl) getGLDrawable();
+  }
+
+  public int makeCurrent() throws GLException {
+    // Support calls to makeCurrent() over and over again with
+    // different contexts without releasing them
+    // Could implement this more efficiently without explicit
+    // releasing of the underlying context; would require more error
+    // checking during the makeCurrentImpl phase
+    GLContext current = getCurrent();
+    if (current != null) {
+      if (current == this) {
+        // Assume we don't need to make this context current again
+        // For Mac OS X, however, we need to update the context to track resizes
+        update();
+        return CONTEXT_CURRENT;
+      } else {
+        current.release();
+      }
+    }
+
+    if (GLWorkerThread.isStarted() &&
+        !GLWorkerThread.isWorkerThread()) {
+      // Kick the GLWorkerThread off its current context
+      GLWorkerThread.invokeLater(new Runnable() { public void run() {} });
+    }
+
+    lock.lock();
+    int res = 0;
+    try {
+      res = makeCurrentImpl();
+
+      /* FIXME: refactor dependence on Java 2D / JOGL bridge
+      if ((tracker != null) &&
+          (res == CONTEXT_CURRENT_NEW)) {
+        // Increase reference count of GLObjectTracker
+        tracker.ref();
+      }
+      */
+    } catch (GLException e) {
+      lock.unlock();
+      throw(e);
+    }
+    if (res == CONTEXT_NOT_CURRENT) {
+      lock.unlock();
+    } else {
+      setCurrent(this);
+
+      /* FIXME: refactor dependence on Java 2D / JOGL bridge
+
+      // Try cleaning up any stale server-side OpenGL objects
+      // FIXME: not sure what to do here if this throws
+      if (deletedObjectTracker != null) {
+        deletedObjectTracker.clean(getGL());
+      }
+      */
+    }
+    return res;
+  }
+
+  protected abstract int makeCurrentImpl() throws GLException;
+
+  public void release() throws GLException {
+    if (!lock.isHeld()) {
+      throw new GLException("Context not current on current thread");
+    }
+    setCurrent(null);
+    try {
+      releaseImpl();
+    } finally {
+      lock.unlock();
+    }
+  }
+
+  protected abstract void releaseImpl() throws GLException;
+
+  public void destroy() {
+    if (lock.isHeld()) {
+        // release current context 
+        release();
+    }
+
+    /* FIXME: refactor dependence on Java 2D / JOGL bridge
+    if (tracker != null) {
+      // Don't need to do anything for contexts that haven't been
+      // created yet
+      if (isCreated()) {
+        // If we are tracking creation and destruction of server-side
+        // OpenGL objects, we must decrement the reference count of the
+        // GLObjectTracker upon context destruction.
+        //
+        // Note that we can only eagerly delete these server-side
+        // objects if there is another context currrent right now
+        // which shares textures and display lists with this one.
+        tracker.unref(deletedObjectTracker);
+      }
+    }
+    */
+
+    // Because we don't know how many other contexts we might be
+    // sharing with (and it seems too complicated to implement the
+    // GLObjectTracker's ref/unref scheme for the buffer-related
+    // optimizations), simply clear the cache of known buffers' sizes
+    // when we destroy contexts
+    if (bufferSizeTracker != null) {
+        bufferSizeTracker.clearCachedBufferSizes();
+    }
+
+    // Must hold the lock around the destroy operation to make sure we
+    // don't destroy the context out from under another thread rendering to it
+    lock.lock();
+    try {
+      destroyImpl();
+    } finally {
+      lock.unlock();
+    }
+  }
+
+  protected abstract void destroyImpl() throws GLException;
+
+  // This is only needed for Mac OS X on-screen contexts
+  protected void update() throws GLException {
+  }
+
+  public boolean isSynchronized() {
+    return !lock.getFailFastMode();
+  }
+
+  public void setSynchronized(boolean isSynchronized) {
+    lock.setFailFastMode(!isSynchronized);
+  }
+
+  public final GL getGL() {
+    return gl;
+  }
+
+  public void setGL(GL gl) {
+    if(DEBUG) {
+        String sgl1 = (null!=this.gl)?this.gl.getClass().toString()+", "+this.gl.toString():new String("<null>");
+        String sgl2 = (null!=gl)?gl.getClass().toString()+", "+gl.toString():new String("<null>");
+        Exception e = new Exception("setGL: "+Thread.currentThread()+", "+sgl1+" -> "+sgl2);
+        e.printStackTrace();
+    }
+    this.gl = gl;
+  }
+
+  public abstract Object getPlatformGLExtensions();
+
+  //----------------------------------------------------------------------
+  // Helpers for various context implementations
+  //
+
+  private Object createInstance(String suffix, Class[] cstrArgTypes, Object[] cstrArgs) {
+    return NWReflection.createInstance(GLProfile.getGLImplBaseClassName()+suffix, cstrArgTypes, cstrArgs);
+  }
+
+  /** Create the GL for this context. */
+  protected GL createGL() {
+    GL gl = (GL) createInstance("Impl", new Class[] { GLContextImpl.class }, new Object[] { this } );
+
+    /* FIXME: refactor dependence on Java 2D / JOGL bridge
+    if (tracker != null) {
+      gl.setObjectTracker(tracker);
+    }
+    */
+    return gl;
+  }
+  
+  public final ProcAddressTable getGLProcAddressTable() {
+    return glProcAddressTable;
+  }
+  
+  /**
+   * Shall return the platform extension ProcAddressTable,
+   * ie for GLXExt, EGLExt, ..
+   */
+  public abstract ProcAddressTable getPlatformExtProcAddressTable();
+
+  /**
+   * Pbuffer support; given that this is a GLContext associated with a
+   * pbuffer, binds this pbuffer to its texture target.
+   */
+  public abstract void bindPbufferToTexture();
+
+  /**
+   * Pbuffer support; given that this is a GLContext associated with a
+   * pbuffer, releases this pbuffer from its texture target.
+   */
+  public abstract void releasePbufferFromTexture();
+
+  public abstract ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3);
+
+  /*
+   * Sets the swap interval for onscreen OpenGL contexts. Has no
+   * effect for offscreen contexts.
+   */
+  public void setSwapInterval(final int interval) {
+  }
+
+  /** Maps the given "platform-independent" function name to a real function
+      name. Currently this is only used to map "glAllocateMemoryNV" and
+      associated routines to wglAllocateMemoryNV / glXAllocateMemoryNV. */
+  protected abstract String mapToRealGLFunctionName(String glFunctionName);
+
+  /** Maps the given "platform-independent" extension name to a real
+      function name. Currently this is only used to map
+      "GL_ARB_pbuffer" and "GL_ARB_pixel_format" to "WGL_ARB_pbuffer"
+      and "WGL_ARB_pixel_format" (not yet mapped to X11). */
+  protected abstract String mapToRealGLExtensionName(String glExtensionName);
+
+  /** Helper routine which resets a ProcAddressTable generated by the
+      GLEmitter by looking up anew all of its function pointers. */
+  protected void resetProcAddressTable(Object table) {
+    GLProcAddressHelper.resetProcAddressTable(table, getDrawableImpl().getFactoryImpl());
+  }
+
+  /** Indicates whether the underlying OpenGL context has been
+      created. This is used to manage sharing of display lists and
+      textures between contexts. */
+  public abstract boolean isCreated();
+
+  /**
+   * Resets the cache of which GL functions are available for calling through this
+   * context. See {@link #isFunctionAvailable(String)} for more information on
+   * the definition of "available".
+   */
+  protected void resetGLFunctionAvailability() {
+    // In order to be able to allow the user to uniformly install the
+    // debug and trace pipelines in their GLEventListener.init()
+    // method (for both GLCanvas and GLJPanel), we need to reset the
+    // actual GL object in the GLDrawable as well
+    setGL(createGL());
+
+    extensionAvailability.flush();
+    if (DEBUG) {
+      System.err.println(getThreadName() + ": !!! Initializing OpenGL extension address table for " + this);
+    }
+    if (glProcAddressTable == null) {
+      glProcAddressTable = (ProcAddressTable) createInstance("ProcAddressTable", new Class[0], null);
+      // FIXME: cache ProcAddressTables by capability bits so we can
+      // share them among contexts with the same capabilities
+    }
+    resetProcAddressTable(getGLProcAddressTable());
+  }
+
+  /**
+   * Returns true if the specified OpenGL core- or extension-function can be
+   * successfully called using this GL context given the current host (OpenGL
+   * <i>client</i>) and display (OpenGL <i>server</i>) configuration.
+   *
+   * See {@link GL#isFunctionAvailable(String)} for more details.
+   *
+   * @param glFunctionName the name of the OpenGL function (e.g., use
+   * "glPolygonOffsetEXT" or "glPolygonOffset" to check if the {@link
+   * javax.media.opengl.GL#glPolygonOffset(float,float)} is available).
+   */
+  public boolean isFunctionAvailable(String glFunctionName) {
+    if(isCreated()) {
+        // Check GL 1st (cached)
+        ProcAddressTable pTable = getGLProcAddressTable();
+        try {
+            if(0!=pTable.getAddressFor(glFunctionName)) {
+                return true;
+            }
+        } catch (Exception e) {}
+
+        // Check platform extensions 2nd (cached)
+        pTable = getPlatformExtProcAddressTable();
+        try {
+            if(0!=pTable.getAddressFor(glFunctionName)) {
+                return true;
+            }
+        } catch (Exception e) {}
+    }
+    // dynamic function lookup at last incl name aliasing (not cached)
+    GLDrawableFactoryImpl factoryImpl = getDrawableImpl().getFactoryImpl();
+    String tmpBase = GLExtensionNames.normalizeVEN(GLExtensionNames.normalizeARB(glFunctionName, true), true);
+    long addr = 0;
+    int  variants = GLExtensionNames.getFuncNamePermutationNumber(tmpBase);
+    for(int i = 0; 0==addr && i < variants; i++) {
+        String tmp = GLExtensionNames.getFuncNamePermutation(tmpBase, i);
+        try {
+            addr = factoryImpl.dynamicLookupFunction(tmp);
+        } catch (Exception e) { }
+    }
+    if(0!=addr) {
+        return true;
+    }
+    return false;
+  }
+
+  /**
+   * Returns true if the specified OpenGL extension can be
+   * successfully called using this GL context given the current host (OpenGL
+   * <i>client</i>) and display (OpenGL <i>server</i>) configuration.
+   *
+   * See {@link GL#isExtensionAvailable(String)} for more details.
+   *
+   * @param glExtensionName the name of the OpenGL extension (e.g.,
+   * "GL_VERTEX_PROGRAM_ARB").
+   */
+  public boolean isExtensionAvailable(String glExtensionName) {
+      return extensionAvailability.isExtensionAvailable(mapToRealGLExtensionName(glExtensionName));
+  }
+
+  /** Indicates which floating-point pbuffer implementation is in
+      use. Returns one of GLPbuffer.APPLE_FLOAT, GLPbuffer.ATI_FLOAT,
+      or GLPbuffer.NV_FLOAT. */
+  public int getFloatingPointMode() throws GLException {
+    throw new GLException("Not supported on non-pbuffer contexts");
+  }
+
+  /** On some platforms the mismatch between OpenGL's coordinate
+      system (origin at bottom left) and the window system's
+      coordinate system (origin at top left) necessitates a vertical
+      flip of pixels read from offscreen contexts. */
+  public abstract boolean offscreenImageNeedsVerticalFlip();
+
+  /** Only called for offscreen contexts; needed by glReadPixels */
+  public abstract int getOffscreenContextPixelDataType();
+
+  protected static String getThreadName() {
+    return Thread.currentThread().getName();
+  }
+
+  public static String toHexString(long hex) {
+    return "0x" + Long.toHexString(hex);
+  }
+
+  //----------------------------------------------------------------------
+  // Helpers for buffer object optimizations
+  
+  public void setBufferSizeTracker(GLBufferSizeTracker bufferSizeTracker) {
+    this.bufferSizeTracker = bufferSizeTracker;
+  }
+
+  public GLBufferSizeTracker getBufferSizeTracker() {
+    return bufferSizeTracker;
+  }
+
+  //---------------------------------------------------------------------------
+  // Helpers for context optimization where the last context is left
+  // current on the OpenGL worker thread
+  //
+
+  public boolean isOptimizable() {
+    return optimizationEnabled;
+  }
+
+  public boolean hasWaiters() {
+    return lock.hasWaiters();
+  }
+
+  /* FIXME: needed only by the Java 2D / JOGL bridge; refactor
+
+  public GLContextImpl(GLContext shareWith) {
+    this(shareWith, false);
+  }
+  
+  public GLContextImpl(GLContext shareWith, boolean dontShareWithJava2D) {
+    extensionAvailability = new ExtensionAvailabilityCache(this);
+    GLContext shareContext = shareWith;
+    if (!dontShareWithJava2D) {
+      shareContext = Java2D.filterShareContext(shareWith);
+    }
+    if (shareContext != null) {
+      GLContextShareSet.registerSharing(this, shareContext);
+    }
+    // Always indicate real behind-the-scenes sharing to track deleted objects
+    if (shareContext == null) {
+      shareContext = Java2D.filterShareContext(shareWith);
+    }
+    GLContextShareSet.registerForObjectTracking(shareWith, this, shareContext);
+    GLContextShareSet.registerForBufferObjectSharing(shareWith, this);
+    // This must occur after the above calls into the
+    // GLContextShareSet, which set up state needed by the GL object
+    setGL(createGL());
+  }
+
+  //---------------------------------------------------------------------------
+  // Helpers for integration with Java2D/OpenGL pipeline when FBOs are
+  // being used
+  //
+
+  public void setObjectTracker(GLObjectTracker tracker) {
+    this.tracker = tracker;
+  }
+  
+  public GLObjectTracker getObjectTracker() {
+    return tracker;
+  }
+
+  public void setDeletedObjectTracker(GLObjectTracker deletedObjectTracker) {
+    this.deletedObjectTracker = deletedObjectTracker;
+  }
+
+  public GLObjectTracker getDeletedObjectTracker() {
+    return deletedObjectTracker;
+  }
+
+  // Tracks creation and deletion of server-side OpenGL objects when
+  // the Java2D/OpenGL pipeline is active and using FBOs to render
+  private GLObjectTracker tracker;
+  // Supports deletion of these objects when no other context is
+  // current which can support immediate deletion of them
+  private GLObjectTracker deletedObjectTracker;
+
+  */
+
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/GLContextLock.java b/src/jogl/classes/com/sun/opengl/impl/GLContextLock.java
new file mode 100644
index 000000000..753ef14f8
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/GLContextLock.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl;
+
+import javax.media.opengl.*;
+
+/** Implements the makeCurrent / release locking behavior of the
+    GLContext class. When "fail fast mode" is enabled, attempts to
+    lock the same GLContextLock on more than one thread cause
+    GLException to be raised. This lock is not recursive. Attempts to
+    lock it more than once on a given thread will cause GLException to
+    be raised. */
+
+public class GLContextLock {
+  private Object lock = new Object();
+  private Thread owner;
+  private boolean failFastMode = true;
+  private volatile int waiters;
+
+  /** Locks this GLContextLock on the current thread. If fail fast
+      mode is enabled and the GLContextLock is already owned by
+      another thread, throws GLException. */
+  public void lock() throws GLException {
+    synchronized(lock) {
+      Thread current = Thread.currentThread();
+      if (owner == null) {
+        owner = current;
+      } else if (owner != current) {
+        while (owner != null) {
+          if (failFastMode) {
+            throw new GLException("Attempt to make context current on thread " + current +
+                                  " which is already current on thread " + owner);
+          } else {
+            try {
+              ++waiters;
+              lock.wait();
+            } catch (InterruptedException e) {
+              throw new GLException(e);
+            } finally {
+              --waiters;
+            }
+          }
+        }
+        owner = current;
+      } else {
+        throw new GLException("Attempt to make the same context current twice on thread " + current);
+      }
+    }
+  }
+
+  /** Unlocks this GLContextLock. */
+  public void unlock() throws GLException {
+    synchronized (lock) {
+      Thread current = Thread.currentThread();
+      if (owner == current) {
+        owner = null;
+        lock.notifyAll();
+      } else {
+        if (owner != null) {
+          throw new GLException("Attempt by thread " + current +
+                                " to release context owned by thread " + owner);
+        } else {
+          throw new GLException("Attempt by thread " + current +
+                                " to release unowned context");
+        }
+      }
+    }
+  }
+
+  /** Indicates whether this lock is held by the current thread. */
+  public boolean isHeld() {
+    synchronized(lock) {
+      Thread current = Thread.currentThread();
+      return (owner == current);
+    }
+  }
+
+  public void setFailFastMode(boolean onOrOff) {
+    failFastMode = onOrOff;
+  }
+
+  public boolean getFailFastMode() {
+    return failFastMode;
+  }
+
+  public boolean hasWaiters() {
+    return (waiters != 0);
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/GLContextShareSet.java b/src/jogl/classes/com/sun/opengl/impl/GLContextShareSet.java
new file mode 100644
index 000000000..d02b8c8a6
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/GLContextShareSet.java
@@ -0,0 +1,294 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl;
+
+// FIXME: refactor Java SE dependencies
+// import java.awt.GraphicsConfiguration;
+// import java.awt.GraphicsDevice;
+// import java.awt.GraphicsEnvironment;
+import java.lang.ref.*;
+import java.util.*;
+import javax.media.opengl.*;
+
+/** Provides a mechanism by which OpenGL contexts can share textures
+    and display lists in the face of multithreading and asynchronous
+    context creation as is inherent in the AWT and Swing. */
+
+public class GLContextShareSet {
+  // FIXME: refactor Java SE dependencies
+  //  private static boolean forceTracking = Debug.isPropertyDefined("jogl.glcontext.forcetracking");
+  private static final boolean DEBUG = Debug.debug("GLContextShareSet");
+
+  // This class is implemented with a WeakHashMap that goes from the
+  // contexts as keys to a complex data structure as value that tracks
+  // context creation and deletion.
+
+  private static Map/*<GLContext, ShareSet>*/ shareMap = new WeakHashMap();
+  private static Object dummyValue = new Object();
+
+  private static class ShareSet {
+    private Map allShares       = new WeakHashMap();
+    private Map createdShares   = new WeakHashMap();
+    private Map destroyedShares = new WeakHashMap();
+
+    public void add(GLContext ctx) {
+      if (allShares.put(ctx, dummyValue) == null) {
+        // FIXME: downcast to GLContextImpl undesirable
+        if (((GLContextImpl) ctx).isCreated()) {
+          createdShares.put(ctx, dummyValue);
+        } else {
+          destroyedShares.put(ctx, dummyValue);
+        }
+      }      
+    }
+
+    public GLContext getCreatedShare(GLContext ignore) {
+      for (Iterator iter = createdShares.keySet().iterator(); iter.hasNext(); ) {
+        GLContext ctx = (GLContext) iter.next();
+        if (ctx != ignore) {
+          return ctx;
+        }
+      }
+      return null;
+    }
+
+    public void contextCreated(GLContext ctx) {
+      Object res = destroyedShares.remove(ctx);
+      assert res != null : "State of ShareSet corrupted; thought context " +
+        ctx + " should have been in destroyed set but wasn't";
+      res = createdShares.put(ctx, dummyValue);
+      assert res == null : "State of ShareSet corrupted; thought context " +
+        ctx + " shouldn't have been in created set but was";
+    }
+
+    public void contextDestroyed(GLContext ctx) {
+      Object res = createdShares.remove(ctx);
+      assert res != null : "State of ShareSet corrupted; thought context " +
+        ctx + " should have been in created set but wasn't";
+      res = destroyedShares.put(ctx, dummyValue);
+      assert res == null : "State of ShareSet corrupted; thought context " +
+        ctx + " shouldn't have been in destroyed set but was";
+    }
+  }
+
+  /** Indicate that contexts <code>share1</code> and
+      <code>share2</code> will share textures and display lists. Both
+      must be non-null. */
+  public static synchronized void registerSharing(GLContext share1, GLContext share2) {
+    if (share1 == null || share2 == null) {
+      throw new IllegalArgumentException("Both share1 and share2 must be non-null");
+    }
+    ShareSet share = entryFor(share1);
+    if (share == null) {
+      share = entryFor(share2);
+    }
+    if (share == null) {
+      share = new ShareSet();
+    }
+    share.add(share1);
+    share.add(share2);
+    addEntry(share1, share);
+    addEntry(share2, share);
+  }
+
+  public static synchronized GLContext getShareContext(GLContext contextToCreate) {
+    ShareSet share = entryFor(contextToCreate);
+    if (share == null) {
+      return null;
+    }
+    return share.getCreatedShare(contextToCreate);
+  }
+
+  public static synchronized void contextCreated(GLContext context) {
+    ShareSet share = entryFor(context);
+    if (share != null) {
+      share.contextCreated(context);
+    }
+  }
+
+  public static synchronized void contextDestroyed(GLContext context) {
+    ShareSet share = entryFor(context);
+    if (share != null) {
+      share.contextDestroyed(context);
+    }
+  }
+
+  /** In order to avoid glGet calls for buffer object checks related
+      to glVertexPointer, etc. calls as well as glMapBuffer calls, we
+      need to share the same GLBufferSizeTracker object between
+      contexts sharing textures and display lists. For now we keep
+      this mechanism orthogonal to the GLObjectTracker to hopefully
+      keep things easier to understand. (The GLObjectTracker is
+      currently only needed in a fairly esoteric case, when the
+      Java2D/JOGL bridge is active, but the GLBufferSizeTracker
+      mechanism is now always required.) */
+  public static void registerForBufferObjectSharing(GLContext olderContextOrNull, GLContext newContext) {
+    // FIXME: downcasts to GLContextImpl undesirable
+    GLContextImpl older = (GLContextImpl) olderContextOrNull;
+    GLContextImpl newer = (GLContextImpl) newContext;
+    GLBufferSizeTracker tracker = null;
+    if (older != null) {
+      tracker = older.getBufferSizeTracker();
+      assert (tracker != null)
+        : "registerForBufferObjectSharing was not called properly for the older context, or has a bug in it";
+    }
+    if (tracker == null) {
+      tracker = new GLBufferSizeTracker();
+    }
+    newer.setBufferSizeTracker(tracker);
+  }
+
+  // FIXME: refactor Java SE dependencies
+  //  /** Indicates that the two supplied contexts (which must be able to
+  //      share textures and display lists) should be in the same
+  //      namespace for tracking of server-side object creation and
+  //      deletion. Because the sharing necessary behind the scenes is
+  //      different than that requested at the user level, the two notions
+  //      are different. This must be called immediately after the
+  //      creation of the new context (which is the second argument)
+  //      before any server-side OpenGL objects have been created in that
+  //      context. */
+  //  public static void registerForObjectTracking(GLContext olderContextOrNull,
+  //                                               GLContext newContext,
+  //                                               GLContext realShareContext) {
+  //    if (isObjectTrackingEnabled() || isObjectTrackingDebuggingEnabled()) {
+  //      GLContextImpl impl1 = null;      
+  //      GLContextImpl impl2 = null;      
+  //      GLObjectTracker tracker = null;
+  //
+  //      synchronized (GLContextShareSet.class) {
+  //        if (olderContextOrNull != null &&
+  //            newContext != null) {
+  //          if (entryFor(olderContextOrNull) != entryFor(newContext)) {
+  //            throw new IllegalArgumentException("old and new contexts must be able to share textures and display lists");
+  //          }
+  //        }
+  //
+  //        // FIXME: downcast to GLContextImpl undesirable
+  //        impl1 = (GLContextImpl) olderContextOrNull;
+  //        impl2 = (GLContextImpl) newContext;
+  //
+  //        GLObjectTracker deletedObjectTracker = null;
+  //        GLContextImpl shareImpl = (GLContextImpl) realShareContext;
+  //        // Before we zap the "user-level" object trackers, make sure
+  //        // that all contexts in the share set share the destroyed object
+  //        // tracker
+  //        if (shareImpl != null) {
+  //          deletedObjectTracker = shareImpl.getDeletedObjectTracker();
+  //        }
+  //        if (deletedObjectTracker == null) {
+  //          // Must create one and possibly set it up in the older context
+  //          deletedObjectTracker = new GLObjectTracker();
+  //          if (DEBUG) {
+  //            System.err.println("Created deletedObjectTracker " + deletedObjectTracker + " because " +
+  //                               ((shareImpl == null) ? "shareImpl was null" : "shareImpl's (" + shareImpl + ") deletedObjectTracker was null"));
+  //          }
+  //
+  //          if (shareImpl != null) {
+  //            // FIXME: think should really assert in this case
+  //            shareImpl.setDeletedObjectTracker(deletedObjectTracker);
+  //            if (DEBUG) {
+  //              System.err.println("Set deletedObjectTracker " + deletedObjectTracker + " in shareImpl context " + shareImpl);
+  //            }
+  //          }
+  //        }
+  //        impl2.setDeletedObjectTracker(deletedObjectTracker);
+  //        if (DEBUG) {
+  //          System.err.println("Set deletedObjectTracker " + deletedObjectTracker + " in impl2 context " + impl2);
+  //        }
+  //      }
+  //
+  //      // Must not hold lock around this operation
+  //      // Don't share object trackers with the primordial share context from Java2D
+  //      if (Java2D.isOGLPipelineActive()) {
+  //        // FIXME: probably need to do something different here
+  //        // Need to be able to figure out the GraphicsDevice for the
+  //        // older context if it's on-screen
+  //        GraphicsConfiguration gc = GraphicsEnvironment.
+  //          getLocalGraphicsEnvironment().
+  //          getDefaultScreenDevice().
+  //          getDefaultConfiguration();
+  //        GLContext j2dShareContext = Java2D.getShareContext(gc);
+  //        if (impl1 != null && impl1 == j2dShareContext) {
+  //          impl1 = null;
+  //        }
+  //      }
+  //
+  //      synchronized (GLContextShareSet.class) {
+  //        if (impl1 != null) {
+  //          tracker = impl1.getObjectTracker();
+  //          assert (tracker != null)
+  //            : "registerForObjectTracking was not called properly for the older context";
+  //        }
+  //        if (tracker == null) {
+  //          tracker = new GLObjectTracker();
+  //        }
+  //        // Note that we don't assert that the tracker is non-null for
+  //        // impl2 because the way we use this functionality we actually
+  //        // overwrite the initially-set object tracker in the new context
+  //        impl2.setObjectTracker(tracker);
+  //      }
+  //    }
+  //  }
+  
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  
+
+  private static ShareSet entryFor(GLContext context) {
+    return (ShareSet) shareMap.get(context);
+  }
+
+  private static void addEntry(GLContext context, ShareSet share) {
+    if (shareMap.get(context) == null) {
+      shareMap.put(context, share);
+    }
+  }
+
+  // FIXME: refactor Java SE dependencies
+  //  private static boolean isObjectTrackingEnabled() {
+  //    return ((Java2D.isOGLPipelineActive() && Java2D.isFBOEnabled()) ||
+  //            isObjectTrackingDebuggingEnabled());
+  //  }
+  //
+  //  private static boolean isObjectTrackingDebuggingEnabled() {
+  //    return forceTracking;
+  //  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/GLDrawableFactoryImpl.java b/src/jogl/classes/com/sun/opengl/impl/GLDrawableFactoryImpl.java
new file mode 100644
index 000000000..fcc55d4d7
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/GLDrawableFactoryImpl.java
@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl;
+
+import java.nio.*;
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.gluegen.runtime.*;
+import com.sun.nwi.impl.NWReflection;
+import java.lang.reflect.*;
+
+/** Extends GLDrawableFactory with a few methods for handling
+    typically software-accelerated offscreen rendering (Device
+    Independent Bitmaps on Windows, pixmaps on X11). Direct access to
+    these GLDrawables is not supplied directly to end users, though
+    they may be instantiated by the GLJPanel implementation. */
+public abstract class GLDrawableFactoryImpl extends GLDrawableFactory implements DynamicLookupHelper {
+
+  /**
+   * Make sure the right NativeWindowFactory is registered
+   */
+  static {
+    initializeNativeWindowFactory();
+  }
+
+  /** Creates a (typically software-accelerated) offscreen GLDrawable
+      used to implement the fallback rendering path of the
+      GLJPanel. */
+  public abstract GLDrawableImpl createOffscreenDrawable(NWCapabilities capabilities,
+                                                         NWCapabilitiesChooser chooser,
+                                                         int width,
+                                                         int height);
+
+  /** Dynamically looks up the given function. */
+  public abstract long dynamicLookupFunction(String glFuncName);
+
+  protected GLDrawableFactoryImpl() {
+    super();
+  }
+
+  public static GLDrawableFactoryImpl getFactoryImpl() {
+    return (GLDrawableFactoryImpl) getFactory();
+  }
+
+  // Helper function for more lazily loading the GLU library;
+  // apparently can't use System.loadLibrary on UNIX because it uses
+  // RTLD_LOCAL and we need to call dlsym(RTLD_DEFAULT)
+  public abstract void loadGLULibrary();
+
+  //----------------------------------------------------------------------
+  // Support for locking and unlocking the toolkit -- needed only on X11 platforms
+  //
+
+  public void lockToolkit() {
+    NativeWindowFactory.getDefaultFactory().getToolkitLock().lock();
+  }
+
+  public void unlockToolkit() {
+    NativeWindowFactory.getDefaultFactory().getToolkitLock().unlock();
+  }
+
+  //---------------------------------------------------------------------------
+  // Support for Java2D/JOGL bridge on Mac OS X; the external
+  // GLDrawable mechanism in the public API is sufficient to
+  // implement this functionality on all other platforms
+  //
+
+  public abstract boolean canCreateContextOnJava2DSurface();
+
+  public abstract GLContext createContextOnJava2DSurface(Object graphics, GLContext shareWith)
+    throws GLException;
+
+  //----------------------------------------------------------------------
+  // Gamma adjustment support
+  // Thanks to the LWJGL team for illustrating how to make these
+  // adjustments on various OSs.
+
+  /*
+   * Portions Copyright (c) 2002-2004 LWJGL Project
+   * All rights reserved.
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are
+   * met:
+   *
+   * * Redistributions of source code must retain the above copyright
+   *   notice, this list of conditions and the following disclaimer.
+   *
+   * * Redistributions in binary form must reproduce the above copyright
+   *   notice, this list of conditions and the following disclaimer in the
+   *   documentation and/or other materials provided with the distribution.
+   *
+   * * Neither the name of 'LWJGL' nor the names of
+   *   its contributors may be used to endorse or promote products derived
+   *   from this software without specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+   * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+   * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+   * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+   * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+   * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+   * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+
+  /**
+   * Sets the gamma, brightness, and contrast of the current main
+   * display. Returns true if the settings were changed, false if
+   * not. If this method returns true, the display settings will
+   * automatically be reset upon JVM exit (assuming the JVM does not
+   * crash); if the user wishes to change the display settings back to
+   * normal ahead of time, use resetDisplayGamma(). Throws
+   * IllegalArgumentException if any of the parameters were
+   * out-of-bounds.
+   * 
+   * @param gamma The gamma value, typically > 1.0 (default value is
+   *   1.0)
+   * @param brightness The brightness value between -1.0 and 1.0,
+   *   inclusive (default value is 0)
+   * @param contrast The contrast, greater than 0.0 (default value is 1)
+   * @throws IllegalArgumentException if any of the parameters were
+   *   out-of-bounds
+   */
+  public boolean setDisplayGamma(float gamma, float brightness, float contrast) throws IllegalArgumentException {
+    if ((brightness < -1.0f) || (brightness > 1.0f)) {
+      throw new IllegalArgumentException("Brightness must be between -1.0 and 1.0");
+    }
+    if (contrast < 0) {
+      throw new IllegalArgumentException("Contrast must be greater than 0.0");
+    }
+    // FIXME: ensure gamma is > 1.0? Are smaller / negative values legal?
+    int rampLength = getGammaRampLength();
+    if (rampLength == 0) {
+      return false;
+    }
+    float[] gammaRamp = new float[rampLength];
+    for (int i = 0; i < rampLength; i++) {
+      float intensity = (float) i / (float) (rampLength - 1);
+      // apply gamma
+      float rampEntry = (float) java.lang.Math.pow(intensity, gamma);
+      // apply brightness
+      rampEntry += brightness;
+      // apply contrast
+      rampEntry = (rampEntry - 0.5f) * contrast + 0.5f;
+      // Clamp entry to [0, 1]
+      if (rampEntry > 1.0f)
+        rampEntry = 1.0f;
+      else if (rampEntry < 0.0f)
+        rampEntry = 0.0f;
+      gammaRamp[i] = rampEntry;
+    }
+    registerGammaShutdownHook();
+    return setGammaRamp(gammaRamp);
+  }
+
+  public synchronized void resetDisplayGamma() {
+    if (gammaShutdownHook == null) {
+      throw new IllegalArgumentException("Should not call this unless setDisplayGamma called first");
+    }
+    resetGammaRamp(originalGammaRamp);
+    unregisterGammeShutdownHook();
+  }
+
+  //------------------------------------------------------
+  // Gamma-related methods to be implemented by subclasses
+  //
+
+  /** Returns the length of the computed gamma ramp for this OS and
+      hardware. Returns 0 if gamma changes are not supported. */
+  protected int getGammaRampLength() {
+    return 0;
+  }
+
+  /** Sets the gamma ramp for the main screen. Returns false if gamma
+      ramp changes were not supported. */
+  protected boolean setGammaRamp(float[] ramp) {
+    return false;
+  }
+
+  /** Gets the current gamma ramp. This is basically an opaque value
+      used only on some platforms to reset the gamma ramp to its
+      original settings. */
+  protected Buffer getGammaRamp() {
+    return null;
+  }
+
+  /** Resets the gamma ramp, potentially using the specified Buffer as
+      data to restore the original values. */
+  protected void resetGammaRamp(Buffer originalGammaRamp) {
+  }
+
+  // Shutdown hook mechanism for resetting gamma
+  private boolean gammaShutdownHookRegistered;
+  private Thread  gammaShutdownHook;
+  private Buffer  originalGammaRamp;
+  private synchronized void registerGammaShutdownHook() {
+    if (gammaShutdownHookRegistered)
+      return;
+    if (gammaShutdownHook == null) {
+      gammaShutdownHook = new Thread(new Runnable() {
+          public void run() {
+            synchronized (GLDrawableFactoryImpl.this) {
+              resetGammaRamp(originalGammaRamp);
+            }
+          }
+        });
+      originalGammaRamp = getGammaRamp();
+    }
+    Runtime.getRuntime().addShutdownHook(gammaShutdownHook);
+    gammaShutdownHookRegistered = true;
+  }
+
+  private synchronized void unregisterGammeShutdownHook() {
+    if (!gammaShutdownHookRegistered)
+      return;
+    if (gammaShutdownHook == null) {
+      throw new InternalError("Error in gamma shutdown hook logic");
+    }
+    Runtime.getRuntime().removeShutdownHook(gammaShutdownHook);
+    gammaShutdownHookRegistered = false;
+    // Leave the original gamma ramp data alone
+  }
+
+  private static void initializeNativeWindowFactory() {
+    String osName = System.getProperty("os.name");
+    String osNameLowerCase = osName.toLowerCase();
+    String factoryClassName = null;
+
+    // We break compile-time dependencies on the AWT here to
+    // make it easier to run this code on mobile devices
+
+    NativeWindowFactory factory = null;
+    
+    if (!osNameLowerCase.startsWith("wind") &&
+        !osNameLowerCase.startsWith("mac os x")) {
+        // Assume X11 platform -- should probably test for these explicitly
+        try {
+            // try X11 AWT GLX ..
+            Constructor factoryConstructor = NWReflection.getConstructor("com.sun.opengl.impl.x11.glx.awt.X11AWTGLXNativeWindowFactory", new Class[] {});
+            factory = (NativeWindowFactory) factoryConstructor.newInstance(null);
+        } catch (Exception e) {}
+        if(null==factory) {
+            try {
+                // try X11 GLX ..
+                Constructor factoryConstructor = NWReflection.getConstructor("com.sun.opengl.impl.x11.glx.X11GLXNativeWindowFactory", new Class[] {});
+                factory = (NativeWindowFactory) factoryConstructor.newInstance(null);
+            } catch (Exception e) {}
+        }
+        /**
+        if(null==factory) {
+            // must be EGL then ..
+        } */
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/GLDrawableHelper.java b/src/jogl/classes/com/sun/opengl/impl/GLDrawableHelper.java
new file mode 100644
index 000000000..e7fea1cee
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/GLDrawableHelper.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl;
+
+import java.util.*;
+import javax.media.opengl.*;
+
+/** Encapsulates the implementation of most of the GLAutoDrawable's
+    methods to be able to share it between GLCanvas and GLJPanel. */
+
+public class GLDrawableHelper {
+  private volatile List listeners = new ArrayList();
+  private static final boolean DEBUG = Debug.debug("GLDrawableHelper");
+  private static final boolean VERBOSE = Debug.verbose();
+  private static final boolean NVIDIA_CRASH_WORKAROUND = Debug.isPropertyDefined("jogl.nvidia.crash.workaround");
+  private boolean autoSwapBufferMode = true;
+
+  public GLDrawableHelper() {
+  }
+
+  public synchronized String toString() {
+    StringBuffer sb = new StringBuffer();
+    sb.append("GLEventListeners num "+listeners.size()+" [");
+    for (Iterator iter = listeners.iterator(); iter.hasNext(); ) {
+      sb.append(iter.next()+", ");
+    }
+    sb.append("]");
+    return sb.toString();
+  }
+
+  public synchronized void addGLEventListener(GLEventListener listener) {
+    List newListeners = (List) ((ArrayList) listeners).clone();
+    newListeners.add(listener);
+    listeners = newListeners;
+  }
+  
+  public synchronized void removeGLEventListener(GLEventListener listener) {
+    List newListeners = (List) ((ArrayList) listeners).clone();
+    newListeners.remove(listener);
+    listeners = newListeners;
+  }
+
+  public synchronized void dispose(GLAutoDrawable drawable) {
+    List newListeners = (List) ((ArrayList) listeners).clone();
+    for (Iterator iter = newListeners.iterator(); iter.hasNext(); ) {
+      ((GLEventListener) iter.next()).dispose(drawable);
+      iter.remove();
+    }
+    listeners = newListeners;
+  }
+
+  public void init(GLAutoDrawable drawable) {
+    for (Iterator iter = listeners.iterator(); iter.hasNext(); ) {
+      ((GLEventListener) iter.next()).init(drawable);
+    }
+  }
+
+  public void display(GLAutoDrawable drawable) {
+    for (Iterator iter = listeners.iterator(); iter.hasNext(); ) {
+      ((GLEventListener) iter.next()).display(drawable);
+    }
+  }
+
+  public void reshape(GLAutoDrawable drawable,
+                      int x, int y, int width, int height) {
+    for (Iterator iter = listeners.iterator(); iter.hasNext(); ) {
+      ((GLEventListener) iter.next()).reshape(drawable, x, y, width, height);
+    }
+  }
+
+  public void setAutoSwapBufferMode(boolean onOrOff) {
+    autoSwapBufferMode = onOrOff;
+  }
+
+  public boolean getAutoSwapBufferMode() {
+    return autoSwapBufferMode;
+  }
+
+  private static final ThreadLocal perThreadInitAction = new ThreadLocal();
+  /** Principal helper method which runs a Runnable with the context
+      made current. This could have been made part of GLContext, but a
+      desired goal is to be able to implement the GLCanvas in terms of
+      the GLContext's public APIs, and putting it into a separate
+      class helps ensure that we don't inadvertently use private
+      methods of the GLContext or its implementing classes. */
+  public void invokeGL(GLDrawable drawable,
+                       GLContext context,
+                       Runnable  runnable,
+                       Runnable  initAction) {
+    // Support for recursive makeCurrent() calls as well as calling
+    // other drawables' display() methods from within another one's
+    GLContext lastContext    = GLContext.getCurrent();
+    Runnable  lastInitAction = (Runnable) perThreadInitAction.get();
+    if (lastContext != null) {
+      lastContext.release();
+    }
+  
+    int res = 0;
+    try {
+      res = context.makeCurrent();
+      if (res != GLContext.CONTEXT_NOT_CURRENT) {
+        if(null!=initAction) {
+            perThreadInitAction.set(initAction);
+            if (res == GLContext.CONTEXT_CURRENT_NEW) {
+              if (DEBUG) {
+                System.err.println("GLDrawableHelper " + this + ".invokeGL(): Running initAction");
+              }
+              initAction.run();
+            }
+        }
+        if (DEBUG && VERBOSE) {
+          System.err.println("GLDrawableHelper " + this + ".invokeGL(): Running runnable");
+        }
+        runnable.run();
+        if (autoSwapBufferMode) {
+          if (drawable != null) {
+            drawable.swapBuffers();
+          }
+        }
+      }
+    } finally {
+      try {
+        if (res != GLContext.CONTEXT_NOT_CURRENT) {
+          context.release();
+        }
+      } catch (Exception e) {
+      }
+      if (lastContext != null) {
+        int res2 = lastContext.makeCurrent();
+        if (res2 == GLContext.CONTEXT_CURRENT_NEW) {
+          lastInitAction.run();
+        }
+      }
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/GLDrawableImpl.java b/src/jogl/classes/com/sun/opengl/impl/GLDrawableImpl.java
new file mode 100644
index 000000000..f01f8eeda
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/GLDrawableImpl.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+
+public abstract class GLDrawableImpl implements GLDrawable {
+  private NWCapabilities requestedCapabilities;
+
+  protected GLDrawableImpl(GLDrawableFactory factory,
+                           NativeWindow comp,
+                           NWCapabilities requestedCapabilities,
+                           boolean realized) {
+      this.factory = factory;
+      this.component = comp;
+      this.requestedCapabilities =
+          (requestedCapabilities == null) ? null : (NWCapabilities) requestedCapabilities.clone();
+      this.realized = realized;
+  }
+
+  public GLDrawableFactoryImpl getFactoryImpl() {
+    return (GLDrawableFactoryImpl) getFactory();
+  }
+
+  /** For offscreen GLDrawables (pbuffers and "pixmap" drawables),
+      indicates that native resources should be reclaimed. */
+  public void destroy() {
+    throw new GLException("Should not call this (should only be called for offscreen GLDrawables)");
+  }
+
+  public void swapBuffers() throws GLException {
+  }
+
+  public static String toHexString(long hex) {
+    return GLContextImpl.toHexString(hex);
+  }
+
+  protected NWCapabilities getRequestedNWCapabilities() {
+    return requestedCapabilities;
+  }
+
+  public NWCapabilities getChosenNWCapabilities() {
+    if (chosenCapabilities == null)
+      return null;
+
+    // Must return a new copy to avoid mutation by end user
+    return (NWCapabilities) chosenCapabilities.clone();
+  }
+
+  protected void setChosenNWCapabilities(NWCapabilities caps) {
+    chosenCapabilities = (caps==null) ? null : (NWCapabilities) caps.clone();
+  }
+
+  public NativeWindow getNativeWindow() {
+    return component;
+  }
+
+  public GLDrawableFactory getFactory() {
+    return factory;
+  }
+
+  public void setRealized(boolean realized) {
+    this.realized = realized;
+    if(!realized) {
+        setChosenNWCapabilities(null);
+        component.invalidate();
+    }
+  }
+
+  public boolean getRealized() {
+    return realized;
+  }
+
+  public int getWidth() {
+    return component.getWidth();
+  }
+
+  /** Returns the current height of this GLDrawable. */
+  public int getHeight() {
+    return component.getHeight();
+  }
+
+  public int lockSurface() throws GLException {
+    if (!realized) {
+      return NativeWindow.LOCK_SURFACE_NOT_READY;
+    }
+    return component.lockSurface();
+  }
+
+  public void unlockSurface() {
+    component.unlockSurface();
+  }
+
+  public boolean isSurfaceLocked() {
+    return component.isSurfaceLocked();
+  }
+
+  public String toString() {
+    return getClass().getName()+"[realized "+getRealized()+
+                ", window "+getNativeWindow()+
+                ", factory "+getFactory()+"]";
+  }
+
+  protected GLDrawableFactory factory;
+  protected NativeWindow component;
+  private NWCapabilities chosenCapabilities;
+
+  // Indicates whether the component (if an onscreen context) has been
+  // realized. Plausibly, before the component is realized the JAWT
+  // should return an error or NULL object from some of its
+  // operations; this appears to be the case on Win32 but is not true
+  // at least with Sun's current X11 implementation (1.4.x), which
+  // crashes with no other error reported if the DrawingSurfaceInfo is
+  // fetched from a locked DrawingSurface during the validation as a
+  // result of calling show() on the main thread. To work around this
+  // we prevent any JAWT or OpenGL operations from being done until
+  // addNotify() is called on the component.
+  protected boolean realized;
+
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/GLFixedArrayHandler.java b/src/jogl/classes/com/sun/opengl/impl/GLFixedArrayHandler.java
new file mode 100644
index 000000000..86ae92754
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/GLFixedArrayHandler.java
@@ -0,0 +1,66 @@
+
+package com.sun.opengl.impl;
+
+import javax.media.opengl.*;
+import javax.media.opengl.sub.*;
+import javax.media.opengl.sub.fixed.*;
+import com.sun.opengl.util.*;
+import java.nio.*;
+
+public class GLFixedArrayHandler implements GLArrayHandler {
+  private GLArrayDataEditable ad;
+
+  public GLFixedArrayHandler(GLArrayDataEditable ad) {
+    this.ad = ad;
+  }
+
+  protected final void passArrayPointer(GLPointerIf gl) {
+    switch(ad.getIndex()) {
+        case GLPointerIf.GL_VERTEX_ARRAY:
+            gl.glVertexPointer(ad);
+            break;
+        case GLPointerIf.GL_NORMAL_ARRAY:
+            gl.glNormalPointer(ad);
+            break;
+        case GLPointerIf.GL_COLOR_ARRAY:
+            gl.glColorPointer(ad);
+            break;
+        case GLPointerIf.GL_TEXTURE_COORD_ARRAY:
+            gl.glTexCoordPointer(ad);
+            break;
+        default:
+            throw new GLException("invalid glArrayIndex: "+ad.getIndex()+":\n\t"+ad); 
+    }
+  }
+
+  public void enableBuffer(GL gl, boolean enable) {
+    GLPointerIf glp = gl.getGL2ES1();
+    if(enable) {
+        glp.glEnableClientState(ad.getIndex());
+
+        Buffer buffer = ad.getBuffer();
+
+        if(ad.isVBO()) {
+            // always bind and refresh the VBO mgr, 
+            // in case more than one gl*Pointer objects are in use
+            gl.glBindBuffer(GL.GL_ARRAY_BUFFER, ad.getVBOName());
+            if(!ad.isBufferWritten()) {
+                if(null!=buffer) {
+                    gl.glBufferData(GL.GL_ARRAY_BUFFER, buffer.limit() * ad.getComponentSize(), buffer, ad.getBufferUsage());
+                }
+                ad.setBufferWritten(true);
+            }
+            passArrayPointer(glp);
+        } else if(null!=buffer) {
+            passArrayPointer(glp);
+            ad.setBufferWritten(true);
+        }
+    } else {
+        if(ad.isVBO()) {
+            gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
+        }
+        glp.glDisableClientState(ad.getIndex());
+    }
+  }
+}
+
diff --git a/src/jogl/classes/com/sun/opengl/impl/GLPbufferImpl.java b/src/jogl/classes/com/sun/opengl/impl/GLPbufferImpl.java
new file mode 100644
index 000000000..ed6f75401
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/GLPbufferImpl.java
@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl;
+
+/**
+import java.awt.Dimension;
+import java.awt.EventQueue;
+import java.awt.event.*;
+import java.beans.PropertyChangeListener;
+ */
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+
+/** Platform-independent class exposing pbuffer functionality to
+    applications. This class is not exposed in the public API as it
+    would probably add no value; however it implements the GLDrawable
+    interface so can be interacted with via its display() method. */
+
+public class GLPbufferImpl implements GLPbuffer {
+  private GLDrawableImpl pbufferDrawable;
+  private GLContextImpl context;
+  private GLDrawableHelper drawableHelper = new GLDrawableHelper();
+  private int floatMode;
+
+  public GLPbufferImpl(GLDrawableImpl pbufferDrawable,
+                       GLContext parentContext) {
+    this.pbufferDrawable = pbufferDrawable;
+    context = (GLContextImpl) pbufferDrawable.createContext(parentContext);
+    context.setSynchronized(true);
+  }
+
+  public GLContext createContext(GLContext shareWith) {
+    return pbufferDrawable.createContext(shareWith);
+  }
+
+  public void setRealized(boolean realized) {
+  }
+
+  public void setSize(int width, int height) {
+    // FIXME
+    throw new GLException("Not yet implemented");
+  }
+
+  public NativeWindow getNativeWindow() {
+      return pbufferDrawable.getNativeWindow();
+  }
+
+  public GLDrawableFactory getFactory() {
+      return pbufferDrawable.getFactory();
+  }
+
+  public int getWidth() {
+    return pbufferDrawable.getWidth();
+  }
+
+  public int getHeight() {
+    return pbufferDrawable.getHeight();
+  }
+
+  public void display() {
+    maybeDoSingleThreadedWorkaround(displayOnEventDispatchThreadAction,
+                                    displayAction,
+                                    false);
+  }
+
+  public void repaint() {
+    display();
+  }
+
+  public void addGLEventListener(GLEventListener listener) {
+    drawableHelper.addGLEventListener(listener);
+  }
+
+  public void removeGLEventListener(GLEventListener listener) {
+    drawableHelper.removeGLEventListener(listener);
+  }
+
+  public void setContext(GLContext ctx) {
+    context=(GLContextImpl)ctx;
+  }
+
+  public GLContext getContext() {
+    return context;
+  }
+
+  public GLDrawable getDrawable() {
+    return pbufferDrawable;
+  }
+
+  public GL getGL() {
+    return getContext().getGL();
+  }
+
+  public void setGL(GL gl) {
+    getContext().setGL(gl);
+  }
+
+  public void setAutoSwapBufferMode(boolean onOrOff) {
+    drawableHelper.setAutoSwapBufferMode(onOrOff);
+  }
+
+  public boolean getAutoSwapBufferMode() {
+    return drawableHelper.getAutoSwapBufferMode();
+  }
+
+  public void swapBuffers() {
+    maybeDoSingleThreadedWorkaround(swapBuffersOnEventDispatchThreadAction, swapBuffersAction, false);
+  }
+
+  public void bindTexture() {
+    // Doesn't make much sense to try to do this on the event dispatch
+    // thread given that it has to be called while the context is current
+    context.bindPbufferToTexture();
+  }
+
+  public void releaseTexture() {
+    // Doesn't make much sense to try to do this on the event dispatch
+    // thread given that it has to be called while the context is current
+    context.releasePbufferFromTexture();
+  }
+
+  public NWCapabilities getChosenNWCapabilities() {
+    if (pbufferDrawable == null)
+      return null;
+
+    return pbufferDrawable.getChosenNWCapabilities();
+  }
+
+  private boolean surfaceLocked = false;
+
+  public int lockSurface() throws GLException {
+    surfaceLocked=true;
+    return NativeWindow.LOCK_SUCCESS;
+  }
+
+  public void unlockSurface() {
+    surfaceLocked=false;
+  }
+
+  public boolean isSurfaceLocked() {
+    return surfaceLocked;
+  }
+
+  //----------------------------------------------------------------------
+  // No-ops for ComponentEvents
+  //
+
+  /*
+  public void addComponentListener(ComponentListener l) {}
+  public void removeComponentListener(ComponentListener l) {}
+  public void addFocusListener(FocusListener l) {}
+  public void removeFocusListener(FocusListener l) {}
+  public void addHierarchyBoundsListener(HierarchyBoundsListener l) {}
+  public void removeHierarchyBoundsListener(HierarchyBoundsListener l) {}
+  public void addHierarchyListener(HierarchyListener l) {}
+  public void removeHierarchyListener(HierarchyListener l) {}
+  public void addInputMethodListener(InputMethodListener l) {}
+  public void removeInputMethodListener(InputMethodListener l) {}
+  public void addKeyListener(KeyListener l) {}
+  public void removeKeyListener(KeyListener l) {}
+  public void addMouseListener(MouseListener l) {}
+  public void removeMouseListener(MouseListener l) {}
+  public void addMouseMotionListener(MouseMotionListener l) {}
+  public void removeMouseMotionListener(MouseMotionListener l) {}
+  public void addMouseWheelListener(MouseWheelListener l) {}
+  public void removeMouseWheelListener(MouseWheelListener l) {}
+  public void addPropertyChangeListener(PropertyChangeListener listener) {}
+  public void removePropertyChangeListener(PropertyChangeListener listener) {}
+  public void addPropertyChangeListener(String propertyName,
+                                        PropertyChangeListener listener) {}
+  public void removePropertyChangeListener(String propertyName,
+                                           PropertyChangeListener listener) {}
+                                           */
+
+  public void destroy() {
+    if (Threading.isSingleThreaded() &&
+        !Threading.isOpenGLThread()) {
+      Threading.invokeOnOpenGLThread(destroyAction);
+    } else {
+      destroyAction.run();
+    }
+  }
+
+  public int getFloatingPointMode() {
+    if (floatMode == 0) {
+      throw new GLException("Pbuffer not initialized, or floating-point support not requested");
+    }
+    return floatMode;
+  }
+
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+
+  private void maybeDoSingleThreadedWorkaround(Runnable eventDispatchThreadAction,
+                                               Runnable invokeGLAction,
+                                               boolean  isReshape) {
+    if (Threading.isSingleThreaded() &&
+        !Threading.isOpenGLThread()) {
+      Threading.invokeOnOpenGLThread(eventDispatchThreadAction);
+    } else {
+      drawableHelper.invokeGL(pbufferDrawable, context, invokeGLAction, initAction);
+    }
+  }
+
+  class InitAction implements Runnable {
+    public void run() {
+      floatMode = context.getFloatingPointMode();
+      drawableHelper.init(GLPbufferImpl.this);
+    }
+  }
+  private InitAction initAction = new InitAction();
+  
+  class DisplayAction implements Runnable {
+    public void run() {
+      drawableHelper.display(GLPbufferImpl.this);
+    }
+  }
+  private DisplayAction displayAction = new DisplayAction();
+
+  class SwapBuffersAction implements Runnable {
+    // FIXME: currently a no-op
+    public void run() {
+      pbufferDrawable.swapBuffers();
+    }
+  }
+  private SwapBuffersAction swapBuffersAction = new SwapBuffersAction();
+
+  // Workaround for ATI driver bugs related to multithreading issues
+  // like simultaneous rendering via Animators to canvases that are
+  // being resized on the AWT event dispatch thread
+  class DisplayOnEventDispatchThreadAction implements Runnable {
+    public void run() {
+      drawableHelper.invokeGL(pbufferDrawable, context, displayAction, initAction);
+    }
+  }
+  private DisplayOnEventDispatchThreadAction displayOnEventDispatchThreadAction =
+    new DisplayOnEventDispatchThreadAction();
+  class SwapBuffersOnEventDispatchThreadAction implements Runnable {
+    public void run() {
+      drawableHelper.invokeGL(pbufferDrawable, context, swapBuffersAction, initAction);
+    }
+  }
+  private SwapBuffersOnEventDispatchThreadAction swapBuffersOnEventDispatchThreadAction =
+    new SwapBuffersOnEventDispatchThreadAction();
+
+  class DestroyAction implements Runnable {
+    public void run() {
+      GLContext current = GLContext.getCurrent();
+      if (current == context) {
+        context.release();
+      }
+      context.destroy();
+      pbufferDrawable.destroy();
+    }
+  }
+  private DestroyAction destroyAction = new DestroyAction();
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/GLWorkerThread.java b/src/jogl/classes/com/sun/opengl/impl/GLWorkerThread.java
new file mode 100755
index 000000000..b110e4335
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/GLWorkerThread.java
@@ -0,0 +1,275 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl;
+
+import java.lang.reflect.InvocationTargetException;
+import java.security.*;
+import java.util.*;
+import javax.media.opengl.*;
+
+/** Singleton thread upon which all OpenGL work is performed by
+    default. Unfortunately many vendors' OpenGL drivers are not really
+    thread-safe and stability is much improved by performing OpenGL
+    work on at most one thread. This is the default behavior of the
+    GLAutoDrawable implementations according to the {@link
+    javax.media.opengl.Threading Threading} class. The GLWorkerThread
+    replaces the original AWT event queue thread-based mechanism for
+    two reasons: first, more than one AWT event queue thread may be
+    spawned, for example if a dialog is being shown; second, it avoids
+    blocking the AWT event queue thread during OpenGL rendering. */
+
+public class GLWorkerThread {
+  private static volatile boolean started;
+  private static volatile Thread thread;
+  private static Object lock;
+  private static volatile boolean shouldTerminate;
+  private static volatile Throwable exception;
+
+  // The Runnable to execute immediately on the worker thread
+  private static volatile Runnable work;
+  // Queue of Runnables to be asynchronously invoked
+  private static List queue = new LinkedList();
+  
+  /** Should only be called by Threading class if creation of the
+      GLWorkerThread was requested via the opengl.1thread system
+      property. */
+  public static void start() {
+    if (!started) {
+      synchronized (GLWorkerThread.class) {
+        if (!started) {
+          lock = new Object();
+          thread = new Thread(new WorkerRunnable(),
+                              "JOGL GLWorkerThread");
+          thread.setDaemon(true);
+          started = true;
+          synchronized (lock) {
+            thread.start();
+            try {
+              lock.wait();
+            } catch (InterruptedException e) {
+            }
+          }
+
+          /*
+
+          // Note: it appears that there is a bug in NVidia's current
+          // drivers where if a context was ever made current on a
+          // given thread and that thread has exited before program
+          // exit, a crash occurs in the drivers. Releasing the
+          // context from the given thread does not work around the
+          // problem.
+          //
+          // For the time being, we're going to work around this
+          // problem by not terminating the GLWorkerThread. In theory,
+          // shutting down the GLWorkerThread cleanly could be a good
+          // general solution to the problem of needing to
+          // cooperatively terminate all Animators at program exit.
+          //
+          // It appears that this doesn't even work around all of the
+          // kinds of crashes. Causing the context to be unilaterally
+          // released from the GLWorkerThread after each invocation
+          // seems to work around all of the kinds of crashes seen.
+          //
+          // These appear to be similar to the kinds of crashes seen
+          // when the Java2D/OpenGL pipeline terminates, and those are
+          // a known issue being fixed, so presumably these will be
+          // fixed in NVidia's next driver set.
+
+          // Install shutdown hook to terminate daemon thread more or
+          // less cooperatively
+          AccessController.doPrivileged(new PrivilegedAction() {
+              public Object run() {
+                Runtime.getRuntime().addShutdownHook(new Thread() {
+                    public void run() {
+                      Object lockTemp = lock;
+                      if (lockTemp == null) {
+                        // Already terminating (?)
+                        return;
+                      }
+                      synchronized (lockTemp) {
+                        shouldTerminate = true;
+                        lockTemp.notifyAll();
+                        try {
+                          lockTemp.wait(500);
+                        } catch (InterruptedException e) {
+                        }
+                      }
+                    }
+                  });
+                return null;
+              }
+            });
+
+          */
+
+        } else {
+          throw new RuntimeException("Should not start GLWorkerThread twice");
+        }
+      }
+    }
+  }
+
+  public static void invokeAndWait(Runnable runnable)
+    throws InvocationTargetException, InterruptedException {
+    if (!started) {
+      throw new RuntimeException("May not invokeAndWait on worker thread without starting it first");
+    }
+
+    Object lockTemp = lock;
+    if (lockTemp == null) {
+      return; // Terminating
+    }
+
+    synchronized (lockTemp) {
+      if (thread == null) {
+        // Terminating
+        return;
+      }
+
+      work = runnable;
+      lockTemp.notifyAll();
+      lockTemp.wait();
+      if (exception != null) {
+        Throwable localException = exception;
+        exception = null;
+        throw new InvocationTargetException(localException);
+      }
+    }
+  }
+
+  public static void invokeLater(Runnable runnable) {
+    if (!started) {
+      throw new RuntimeException("May not invokeLater on worker thread without starting it first");
+    }
+
+    Object lockTemp = lock;
+    if (lockTemp == null) {
+      return; // Terminating
+    }
+
+    synchronized (lockTemp) {
+      if (thread == null) {
+        // Terminating
+        return;
+      }
+
+      queue.add(runnable);
+      lockTemp.notifyAll();
+    }
+  }
+
+  /** Indicates whether the OpenGL worker thread was started, i.e.,
+      whether it is currently in use. */
+  public static boolean isStarted() {
+    return started;
+  }
+
+  /** Indicates whether the current thread is the OpenGL worker
+      thread. */
+  public static boolean isWorkerThread() {
+    return (Thread.currentThread() == thread);
+  }
+
+  static class WorkerRunnable implements Runnable {
+    public void run() {
+      // Notify starting thread that we're ready
+      synchronized (lock) {
+        lock.notifyAll();
+      }
+
+      while (!shouldTerminate) {
+        synchronized (lock) {
+          while (!shouldTerminate &&
+                 (work == null) &&
+                 queue.isEmpty()) {
+            try {
+              // Avoid race conditions with wanting to release contexts on this thread
+              lock.wait(1000);
+            } catch (InterruptedException e) {
+            }
+
+            if (GLContext.getCurrent() != null) {
+              // Test later to see whether we need to release this context
+              break;
+            }
+          }
+          
+          if (shouldTerminate) {
+            lock.notifyAll();
+            thread = null;
+            lock = null;
+            return;
+          }
+
+          if (work != null) {
+            try {
+              work.run();
+            } catch (Throwable t) {
+              exception = t;
+            } finally {
+              work = null;
+              lock.notifyAll();
+            }
+          }
+
+          while (!queue.isEmpty()) {
+            try {
+              Runnable curAsync = (Runnable) queue.remove(0);
+              curAsync.run();
+            } catch (Throwable t) {
+              System.out.println("Exception occurred on JOGL OpenGL worker thread:");
+              t.printStackTrace();
+            }
+          }
+
+          // See about releasing current context
+          GLContext curContext = GLContext.getCurrent();
+          if (curContext != null &&
+              (curContext instanceof GLContextImpl)) {
+            GLContextImpl impl = (GLContextImpl) curContext;
+            if (impl.hasWaiters()) {
+              impl.release();
+            }
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/InternalBufferUtils.java b/src/jogl/classes/com/sun/opengl/impl/InternalBufferUtils.java
new file mode 100644
index 000000000..89639c493
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/InternalBufferUtils.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl;
+
+import java.nio.*;
+
+/** Utility routines available only to the JOGL implementation. */
+
+public class InternalBufferUtils {
+  /** Allocates a new direct byte buffer at the given address with the
+      given capacity. This is exposed only because of glMapBufferARB
+      and its semantics; it is undesirable to allocate a new buffer
+      every frame because (a) ByteBuffers are finalizable and (b) the
+      application would typically need to re-slice the buffer every
+      frame. Instead we cache these ByteBuffer objects up in Java and
+      look them up in a HashMap by base address and capacity. */
+  public static native ByteBuffer newDirectByteBuffer(long address, int capacity);
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/NativeLibLoader.java b/src/jogl/classes/com/sun/opengl/impl/NativeLibLoader.java
new file mode 100644
index 000000000..8319de370
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/NativeLibLoader.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl;
+
+// FIXME: refactor Java SE dependencies
+//import java.awt.Toolkit;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.HashSet;
+import com.sun.nwi.impl.NativeLibLoaderBase;
+
+public class NativeLibLoader extends NativeLibLoaderBase {
+  
+  public static void loadNEWT() {
+    AccessController.doPrivileged(new PrivilegedAction() {
+      public Object run() {
+        loadLibrary("newt", nwiX11Preload, true);
+        return null;
+      }
+    });
+  }
+
+  public static void loadGL2() {
+    AccessController.doPrivileged(new PrivilegedAction() {
+      public Object run() {
+        loadLibrary("jogl_gl2", nwiX11Preload, true);
+        return null;
+      }
+    });
+  }
+
+  public static void loadGL2ES12() {
+    AccessController.doPrivileged(new PrivilegedAction() {
+      public Object run() {
+        loadLibrary("jogl_gl2es12", nwiX11Preload, true);
+        return null;
+      }
+    });
+  }
+
+  public static void loadES2() {
+    AccessController.doPrivileged(new PrivilegedAction() {
+      public Object run() {
+        loadLibrary("jogl_es2", nwiX11Preload, true);
+        return null;
+      }
+    });
+  }
+
+  public static void loadES1() {
+    AccessController.doPrivileged(new PrivilegedAction() {
+      public Object run() {
+        loadLibrary("jogl_es1", nwiX11Preload, true);
+        return null;
+      }
+    });
+  }
+
+  public static void loadCgImpl() {
+    AccessController.doPrivileged(new PrivilegedAction() {
+      public Object run() {
+        String[] preload = { "nwi", "cg", "cgGL" };
+        loadLibrary("jogl_cg", preload, true);
+        return null;
+      }
+    });
+  }
+
+  //----------------------------------------------------------------------
+  // Support for the new JNLPAppletLauncher
+  //
+
+  private static class JOGLAction implements NativeLibLoaderBase.LoaderAction {
+    public void loadLibrary(String libname, String[] preload,
+        boolean preloadIgnoreError) {
+      if (null!=preload) {
+        for (int i=0; i<preload.length; i++) {
+          try {
+            loadLibraryInternal(preload[i]);
+          }
+          catch (UnsatisfiedLinkError e) {
+            if (!preloadIgnoreError && e.getMessage().indexOf("already loaded") < 0) {
+              throw e;
+            }
+          }
+        }
+      }
+      
+      loadLibraryInternal(libname);
+    }
+  }
+
+  private static final String[] nwiX11Preload = { "nwi_x11" };
+  private static boolean usingJNLPAppletLauncher;
+  private static Method  jnlpLoadLibraryMethod;
+
+  static {
+    NativeLibLoaderBase.setLoadingAction(new JOGLAction());
+    AccessController.doPrivileged(new PrivilegedAction() {
+        public Object run() {
+          String sunAppletLauncher = System.getProperty("sun.jnlp.applet.launcher");
+          usingJNLPAppletLauncher = Boolean.valueOf(sunAppletLauncher).booleanValue();
+          return null;
+        }
+      });
+  }
+
+  // I hate the amount of delegation currently in this class
+  private static void loadLibraryInternal(String libraryName) {
+    // Note: special-casing JAWT which is built in to the JDK
+    if (usingJNLPAppletLauncher && !libraryName.equals("jawt")) {
+        try {
+          if (jnlpLoadLibraryMethod == null) {
+            Class jnlpAppletLauncherClass = Class.forName("org.jdesktop.applet.util.JNLPAppletLauncher");
+            jnlpLoadLibraryMethod = jnlpAppletLauncherClass.getDeclaredMethod("loadLibrary", new Class[] { String.class });
+          }
+          jnlpLoadLibraryMethod.invoke(null, new Object[] { libraryName });
+        } catch (Exception e) {
+          Throwable t = e;
+          if (t instanceof InvocationTargetException) {
+            t = ((InvocationTargetException) t).getTargetException();
+          }
+          if (t instanceof Error)
+            throw (Error) t;
+          if (t instanceof RuntimeException) {
+            throw (RuntimeException) t;
+          }
+          // Throw UnsatisfiedLinkError for best compatibility with System.loadLibrary()
+          throw (UnsatisfiedLinkError) new UnsatisfiedLinkError().initCause(e);
+        }
+    } else {
+      // FIXME: remove
+      // System.out.println("sun.boot.library.path=" + System.getProperty("sun.boot.library.path"));
+      System.loadLibrary(libraryName);
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/ProjectFloat.java b/src/jogl/classes/com/sun/opengl/impl/ProjectFloat.java
new file mode 100755
index 000000000..5788bbc9b
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/ProjectFloat.java
@@ -0,0 +1,1058 @@
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** $Date: 2009-03-13 22:20:29 -0700 (Fri, 13 Mar 2009) $ $Revision: 1867 $
+** $Header$
+*/
+
+/* 
+ * Copyright (c) 2002-2004 LWJGL Project
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are 
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright 
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of 'LWJGL' nor the names of 
+ *   its contributors may be used to endorse or promote products derived 
+ *   from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+package com.sun.opengl.impl;
+
+import java.nio.*;
+
+import javax.media.opengl.*;
+import javax.media.opengl.util.*;
+import javax.media.opengl.sub.fixed.GLMatrixIf;
+
+/**
+ * ProjectFloat.java
+ * <p/>
+ * <p/>
+ * Created 11-jan-2004
+ * 
+ * @author Erik Duijs
+ * @author Kenneth Russell
+ */
+public class ProjectFloat {
+  private static final float[] IDENTITY_MATRIX =
+    new float[] {
+      1.0f, 0.0f, 0.0f, 0.0f,
+      0.0f, 1.0f, 0.0f, 0.0f,
+      0.0f, 0.0f, 1.0f, 0.0f,
+      0.0f, 0.0f, 0.0f, 1.0f };
+
+  private static final float[] ZERO_MATRIX =
+    new float[] {
+      0.0f, 0.0f, 0.0f, 0.0f,
+      0.0f, 0.0f, 0.0f, 0.0f,
+      0.0f, 0.0f, 0.0f, 0.0f,
+      0.0f, 0.0f, 0.0f, 0.0f };
+
+  // Note that we have cloned parts of the implementation in order to
+  // support incoming Buffers. The reason for this is to avoid loading
+  // non-direct buffer subclasses unnecessarily, because doing so can
+  // cause performance decreases on direct buffer operations, at least
+  // on the current HotSpot JVM. It would be nicer (and make the code
+  // simpler) to simply have the array-based entry points delegate to
+  // the versions taking Buffers by wrapping the arrays.
+
+  // Array-based implementation
+  private final float[] matrix = new float[16];
+  private final float[][] tempInvertMatrix = new float[4][4];
+
+  private final float[] in = new float[4];
+  private final float[] out = new float[4];
+
+  private final float[] forward = new float[3];
+  private final float[] side = new float[3];
+  private final float[] up = new float[3];
+  
+  // Buffer-based implementation
+  private FloatBuffer locbuf;
+  private final FloatBuffer matrixBuf;
+  private final FloatBuffer tempInvertMatrixBuf;
+
+  private final FloatBuffer inBuf;
+  private final FloatBuffer outBuf;
+
+  private final FloatBuffer forwardBuf;
+  private final FloatBuffer sideBuf;
+  private final FloatBuffer upBuf;
+
+  public ProjectFloat() {
+    // Use direct buffers to avoid loading indirect buffer
+    // implementations for applications trying to avoid doing so.
+    // Slice up one big buffer because some NIO implementations
+    // allocate a huge amount of memory to back even the smallest of
+    // buffers.
+    locbuf = BufferUtil.newFloatBuffer(2*16+2*4+3*3);
+    int pos = 0;
+    int sz = 16;
+    matrixBuf = slice(locbuf, pos, sz);
+    pos += sz;
+    tempInvertMatrixBuf = slice(locbuf, pos, sz);
+    pos += sz;
+    sz = 4;
+    inBuf = slice(locbuf, pos, sz);
+    pos += sz;
+    outBuf = slice(locbuf, pos, sz);
+    pos += sz;
+    sz = 3;
+    forwardBuf = slice(locbuf, pos, sz);
+    pos += sz;
+    sideBuf = slice(locbuf, pos, sz);
+    pos += sz;
+    upBuf = slice(locbuf, pos, sz);
+  }
+
+  public void destroy() {
+    if(locbuf!=null) {
+        locbuf.clear();
+        locbuf=null;
+    }
+  }
+
+  private static FloatBuffer slice(FloatBuffer buf, int pos, int len) {
+    buf.position(pos);
+    buf.limit(pos + len);
+    return buf.slice();
+  }
+
+  /**
+   * Make matrix an identity matrix
+   */
+  public static void gluMakeIdentityf(FloatBuffer m) {
+    int oldPos = m.position();
+    m.put(IDENTITY_MATRIX);
+    m.position(oldPos);
+  }
+
+  /**
+   * Make matrix an zero matrix
+   */
+  public static void gluMakeZero(FloatBuffer m) {
+    int oldPos = m.position();
+    m.put(ZERO_MATRIX);
+    m.position(oldPos);
+  }
+
+  /**
+   * Make matrix an identity matrix
+   */
+  public static void gluMakeIdentityf(float[] m) {
+    for (int i = 0; i < 16; i++) {
+      m[i] = IDENTITY_MATRIX[i];
+    }
+  }
+
+  /**
+   * Method __gluMultMatrixVecf
+   * 
+   * @param matrix
+   * @param in
+   * @param out
+   */
+  private void __gluMultMatrixVecf(float[] matrix, int matrix_offset, float[] in, float[] out) {
+    for (int i = 0; i < 4; i++) {
+      out[i] =
+        in[0] * matrix[0*4+i+matrix_offset] +
+        in[1] * matrix[1*4+i+matrix_offset] +
+        in[2] * matrix[2*4+i+matrix_offset] +
+        in[3] * matrix[3*4+i+matrix_offset];
+    }
+  }
+
+  /**
+   * Method __gluMultMatrixVecf
+   * 
+   * @param matrix
+   * @param in
+   * @param out
+   */
+  private void __gluMultMatrixVecf(FloatBuffer matrix, FloatBuffer in, FloatBuffer out) {
+    int inPos = in.position();
+    int outPos = out.position();
+    int matrixPos = matrix.position();
+    for (int i = 0; i < 4; i++) {
+      out.put(i + outPos,
+              in.get(0+inPos) * matrix.get(0*4+i+matrixPos) +
+              in.get(1+inPos) * matrix.get(1*4+i+matrixPos) +
+              in.get(2+inPos) * matrix.get(2*4+i+matrixPos) +
+              in.get(3+inPos) * matrix.get(3*4+i+matrixPos));
+    }
+  }
+
+  /**
+   * @param src
+   * @param inverse
+   * 
+   * @return
+   */
+  public boolean gluInvertMatrixf(float[] src, float[] inverse) {
+    int i, j, k, swap;
+    float t;
+    float[][] temp = tempInvertMatrix;
+
+    for (i = 0; i < 4; i++) {
+      for (j = 0; j < 4; j++) {
+        temp[i][j] = src[i*4+j];
+      }
+    }
+    gluMakeIdentityf(inverse);
+
+    for (i = 0; i < 4; i++) {
+      //
+      // Look for largest element in column
+      //
+      swap = i;
+      for (j = i + 1; j < 4; j++) {
+        if (Math.abs(temp[j][i]) > Math.abs(temp[i][i])) {
+          swap = j;
+        }
+      }
+
+      if (swap != i) {
+        //
+        // Swap rows.
+        //
+        for (k = 0; k < 4; k++) {
+          t = temp[i][k];
+          temp[i][k] = temp[swap][k];
+          temp[swap][k] = t;
+
+          t = inverse[i*4+k];
+          inverse[i*4+k] = inverse[swap*4+k];
+          inverse[swap*4+k] = t;
+        }
+      }
+
+      if (temp[i][i] == 0) {
+        //
+        // No non-zero pivot. The matrix is singular, which shouldn't
+        // happen. This means the user gave us a bad matrix.
+        //
+        return false;
+      }
+
+      t = temp[i][i];
+      for (k = 0; k < 4; k++) {
+        temp[i][k] /= t;
+        inverse[i*4+k] /= t;
+      }
+      for (j = 0; j < 4; j++) {
+        if (j != i) {
+          t = temp[j][i];
+          for (k = 0; k < 4; k++) {
+            temp[j][k] -= temp[i][k] * t;
+            inverse[j*4+k] -= inverse[i*4+k]*t;
+          }
+        }
+      }
+    }
+    return true;
+  }
+
+  /**
+   * @param src
+   * @param inverse
+   * 
+   * @return
+   */
+  public boolean gluInvertMatrixf(FloatBuffer src, FloatBuffer inverse) {
+    int i, j, k, swap;
+    float t;
+
+    int srcPos = src.position();
+    int invPos = inverse.position();
+
+    FloatBuffer temp = tempInvertMatrixBuf;
+
+    for (i = 0; i < 4; i++) {
+      for (j = 0; j < 4; j++) {
+        temp.put(i*4+j, src.get(i*4+j + srcPos));
+      }
+    }
+    gluMakeIdentityf(inverse);
+
+    for (i = 0; i < 4; i++) {
+      //
+      // Look for largest element in column
+      //
+      swap = i;
+      for (j = i + 1; j < 4; j++) {
+        if (Math.abs(temp.get(j*4+i)) > Math.abs(temp.get(i*4+i))) {
+          swap = j;
+        }
+      }
+
+      if (swap != i) {
+        //
+        // Swap rows.
+        //
+        for (k = 0; k < 4; k++) {
+          t = temp.get(i*4+k);
+          temp.put(i*4+k, temp.get(swap*4+k));
+          temp.put(swap*4+k, t);
+
+          t = inverse.get(i*4+k + invPos);
+          inverse.put(i*4+k + invPos, inverse.get(swap*4+k + invPos));
+          inverse.put(swap*4+k + invPos, t);
+        }
+      }
+
+      if (temp.get(i*4+i) == 0) {
+        //
+        // No non-zero pivot. The matrix is singular, which shouldn't
+        // happen. This means the user gave us a bad matrix.
+        //
+        return false;
+      }
+
+      t = temp.get(i*4+i);
+      for (k = 0; k < 4; k++) {
+        temp.put(i*4+k, temp.get(i*4+k) / t);
+        inverse.put(i*4+k + invPos, inverse.get(i*4+k + invPos) / t);
+      }
+      for (j = 0; j < 4; j++) {
+        if (j != i) {
+          t = temp.get(j*4+i);
+          for (k = 0; k < 4; k++) {
+            temp.put(j*4+k, temp.get(j*4+k) - temp.get(i*4+k) * t);
+            inverse.put(j*4+k + invPos, inverse.get(j*4+k + invPos) - inverse.get(i*4+k + invPos) * t);
+          }
+        }
+      }
+    }
+    return true;
+  }
+
+
+  /**
+   * @param a
+   * @param b
+   * @param r
+   */
+  private void gluMultMatricesf(float[] a, int a_offset, float[] b, int b_offset, float[] r) {
+    for (int i = 0; i < 4; i++) {
+      for (int j = 0; j < 4; j++) {
+        r[i*4+j] =
+          a[i*4+0+a_offset]*b[0*4+j+b_offset] +
+          a[i*4+1+a_offset]*b[1*4+j+b_offset] +
+          a[i*4+2+a_offset]*b[2*4+j+b_offset] +
+          a[i*4+3+a_offset]*b[3*4+j+b_offset];
+      }
+    }
+  }
+
+
+  /**
+   * @param a
+   * @param b
+   * @param r
+   */
+  public static void gluMultMatricesf(FloatBuffer a, FloatBuffer b, FloatBuffer r) {
+    int aPos = a.position();
+    int bPos = b.position();
+    int rPos = r.position();
+
+    for (int i = 0; i < 4; i++) {
+      for (int j = 0; j < 4; j++) {
+        r.put(i*4+j + rPos,
+          a.get(i*4+0+aPos)*b.get(0*4+j+bPos) +
+          a.get(i*4+1+aPos)*b.get(1*4+j+bPos) +
+          a.get(i*4+2+aPos)*b.get(2*4+j+bPos) +
+          a.get(i*4+3+aPos)*b.get(3*4+j+bPos));
+      }
+    }
+  }
+
+  /**
+   * Normalize vector
+   *
+   * @param v
+   */
+  public static void normalize(float[] v) {
+    float r;
+
+    r = (float) Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+    if ( r == 0.0 || r == 1.0)
+      return;
+
+    r = 1.0f / r;
+
+    v[0] *= r;
+    v[1] *= r;
+    v[2] *= r;
+
+    return;
+  }
+
+  /**
+   * Normalize vector
+   *
+   * @param v
+   */
+  public static void normalize(FloatBuffer v) {
+    float r;
+
+    int vPos = v.position();
+
+    r = (float) Math.sqrt(v.get(0+vPos) * v.get(0+vPos) +
+                          v.get(1+vPos) * v.get(1+vPos) +
+                          v.get(2+vPos) * v.get(2+vPos));
+    if ( r == 0.0 || r == 1.0)
+      return;
+
+    r = 1.0f / r;
+
+    v.put(0+vPos, v.get(0+vPos) * r);
+    v.put(1+vPos, v.get(1+vPos) * r);
+    v.put(2+vPos, v.get(2+vPos) * r);
+
+    return;
+  }
+
+
+  /**
+   * Calculate cross-product
+   *
+   * @param v1
+   * @param v2
+   * @param result
+   */
+  private static void cross(float[] v1, float[] v2, float[] result) {
+    result[0] = v1[1] * v2[2] - v1[2] * v2[1];
+    result[1] = v1[2] * v2[0] - v1[0] * v2[2];
+    result[2] = v1[0] * v2[1] - v1[1] * v2[0];
+  }
+
+  /**
+   * Calculate cross-product
+   *
+   * @param v1
+   * @param v2
+   * @param result
+   */
+  private static void cross(FloatBuffer v1, FloatBuffer v2, FloatBuffer result) {
+    int v1Pos = v1.position();
+    int v2Pos = v2.position();
+    int rPos  = result.position();
+
+    result.put(0+rPos, v1.get(1+v1Pos) * v2.get(2+v2Pos) - v1.get(2+v1Pos) * v2.get(1+v2Pos));
+    result.put(1+rPos, v1.get(2+v1Pos) * v2.get(0+v2Pos) - v1.get(0+v1Pos) * v2.get(2+v2Pos));
+    result.put(2+rPos, v1.get(0+v1Pos) * v2.get(1+v2Pos) - v1.get(1+v1Pos) * v2.get(0+v2Pos));
+  }
+
+  /**
+   * Method gluOrtho2D.
+   * 
+   * @param left
+   * @param right
+   * @param bottom
+   * @param top
+   */
+  public void gluOrtho2D(GLMatrixIf gl, float left, float right, float bottom, float top) {
+    gl.glOrthof(left, right, bottom, top, -1, 1);
+  }
+
+  /**
+   * Method gluPerspective.
+   * 
+   * @param fovy
+   * @param aspect
+   * @param zNear
+   * @param zFar
+   */
+  public void gluPerspective(GLMatrixIf gl, float fovy, float aspect, float zNear, float zFar) {
+    float sine, cotangent, deltaZ;
+    float radians = fovy / 2 * (float) Math.PI / 180;
+
+    deltaZ = zFar - zNear;
+    sine = (float) Math.sin(radians);
+
+    if ((deltaZ == 0) || (sine == 0) || (aspect == 0)) {
+      return;
+    }
+
+    cotangent = (float) Math.cos(radians) / sine;
+
+    gluMakeIdentityf(matrixBuf);
+
+    matrixBuf.put(0 * 4 + 0, cotangent / aspect);
+    matrixBuf.put(1 * 4 + 1, cotangent);
+    matrixBuf.put(2 * 4 + 2, - (zFar + zNear) / deltaZ);
+    matrixBuf.put(2 * 4 + 3, -1);
+    matrixBuf.put(3 * 4 + 2, -2 * zNear * zFar / deltaZ);
+    matrixBuf.put(3 * 4 + 3, 0);
+
+    gl.glMultMatrixf(matrixBuf);
+  }
+
+  /**
+   * Method gluLookAt
+   * 
+   * @param eyex
+   * @param eyey
+   * @param eyez
+   * @param centerx
+   * @param centery
+   * @param centerz
+   * @param upx
+   * @param upy
+   * @param upz
+   */
+  public void gluLookAt(GLMatrixIf gl,
+                        float eyex,
+                        float eyey,
+                        float eyez,
+                        float centerx,
+                        float centery,
+                        float centerz,
+                        float upx,
+                        float upy,
+                        float upz) {
+    FloatBuffer forward = this.forwardBuf;
+    FloatBuffer side = this.sideBuf;
+    FloatBuffer up = this.upBuf;
+
+    forward.put(0, centerx - eyex);
+    forward.put(1, centery - eyey);
+    forward.put(2, centerz - eyez);
+
+    up.put(0, upx);
+    up.put(1, upy);
+    up.put(2, upz);
+
+    normalize(forward);
+
+    /* Side = forward x up */
+    cross(forward, up, side);
+    normalize(side);
+
+    /* Recompute up as: up = side x forward */
+    cross(side, forward, up);
+
+    gluMakeIdentityf(matrixBuf);
+    matrixBuf.put(0 * 4 + 0, side.get(0));
+    matrixBuf.put(1 * 4 + 0, side.get(1));
+    matrixBuf.put(2 * 4 + 0, side.get(2));
+
+    matrixBuf.put(0 * 4 + 1, up.get(0));
+    matrixBuf.put(1 * 4 + 1, up.get(1));
+    matrixBuf.put(2 * 4 + 1, up.get(2));
+
+    matrixBuf.put(0 * 4 + 2, -forward.get(0));
+    matrixBuf.put(1 * 4 + 2, -forward.get(1));
+    matrixBuf.put(2 * 4 + 2, -forward.get(2));
+
+    gl.glMultMatrixf(matrixBuf);
+    gl.glTranslatef(-eyex, -eyey, -eyez);
+  }
+
+  /**
+   * Method gluProject
+   * 
+   * @param objx
+   * @param objy
+   * @param objz
+   * @param modelMatrix
+   * @param projMatrix
+   * @param viewport
+   * @param win_pos
+   * 
+   * @return
+   */
+  public boolean gluProject(float objx,
+                            float objy,
+                            float objz,
+                            float[] modelMatrix,
+                            int modelMatrix_offset,
+                            float[] projMatrix,
+                            int projMatrix_offset,
+                            int[] viewport,
+                            int viewport_offset,
+                            float[] win_pos,
+                            int win_pos_offset ) {
+
+    float[] in = this.in;
+    float[] out = this.out;
+
+    in[0] = objx;
+    in[1] = objy;
+    in[2] = objz;
+    in[3] = 1.0f;
+
+    __gluMultMatrixVecf(modelMatrix, modelMatrix_offset, in, out);
+    __gluMultMatrixVecf(projMatrix, projMatrix_offset, out, in);
+
+    if (in[3] == 0.0f)
+      return false;
+
+    in[3] = (1.0f / in[3]) * 0.5f;
+
+    // Map x, y and z to range 0-1
+    in[0] = in[0] * in[3] + 0.5f;
+    in[1] = in[1] * in[3] + 0.5f;
+    in[2] = in[2] * in[3] + 0.5f;
+
+    // Map x,y to viewport
+    win_pos[0+win_pos_offset] = in[0] * viewport[2+viewport_offset] + viewport[0+viewport_offset];
+    win_pos[1+win_pos_offset] = in[1] * viewport[3+viewport_offset] + viewport[1+viewport_offset];
+    win_pos[2+win_pos_offset] = in[2];
+
+    return true;
+  }
+
+  /**
+   * Method gluProject
+   * 
+   * @param objx
+   * @param objy
+   * @param objz
+   * @param modelMatrix
+   * @param projMatrix
+   * @param viewport
+   * @param win_pos
+   * 
+   * @return
+   */
+  public boolean gluProject(float objx,
+                            float objy,
+                            float objz,
+                            FloatBuffer modelMatrix,
+                            FloatBuffer projMatrix,
+                            IntBuffer viewport,
+                            FloatBuffer win_pos) {
+
+    FloatBuffer in = this.inBuf;
+    FloatBuffer out = this.outBuf;
+
+    in.put(0, objx);
+    in.put(1, objy);
+    in.put(2, objz);
+    in.put(3, 1.0f);
+
+    __gluMultMatrixVecf(modelMatrix, in, out);
+    __gluMultMatrixVecf(projMatrix, out, in);
+
+    if (in.get(3) == 0.0f)
+      return false;
+
+    in.put(3, (1.0f / in.get(3)) * 0.5f);
+
+    // Map x, y and z to range 0-1
+    in.put(0, in.get(0) * in.get(3) + 0.5f);
+    in.put(1, in.get(1) * in.get(3) + 0.5f);
+    in.put(2, in.get(2) * in.get(3) + 0.5f);
+
+    // Map x,y to viewport
+    int vPos = viewport.position();
+    int wPos = win_pos.position();
+    win_pos.put(0+wPos, in.get(0) * viewport.get(2+vPos) + viewport.get(0+vPos));
+    win_pos.put(1+wPos, in.get(1) * viewport.get(3+vPos) + viewport.get(1+vPos));
+    win_pos.put(2+wPos, in.get(2));
+
+    return true;
+  }
+
+
+  /**
+   * Method gluUnproject
+   * 
+   * @param winx
+   * @param winy
+   * @param winz
+   * @param modelMatrix
+   * @param projMatrix
+   * @param viewport
+   * @param obj_pos
+   * 
+   * @return
+   */
+  public boolean gluUnProject(float winx,
+                              float winy,
+                              float winz,
+                              float[] modelMatrix,
+                              int modelMatrix_offset,
+                              float[] projMatrix,
+                              int projMatrix_offset,
+                              int[] viewport,
+                              int viewport_offset,
+                              float[] obj_pos,
+                              int obj_pos_offset) {
+    float[] in = this.in;
+    float[] out = this.out;
+
+    gluMultMatricesf(modelMatrix, modelMatrix_offset, projMatrix, projMatrix_offset, matrix);
+
+    if (!gluInvertMatrixf(matrix, matrix))
+      return false;
+
+    in[0] = winx;
+    in[1] = winy;
+    in[2] = winz;
+    in[3] = 1.0f;
+
+    // Map x and y from window coordinates
+    in[0] = (in[0] - viewport[0+viewport_offset]) / viewport[2+viewport_offset];
+    in[1] = (in[1] - viewport[1+viewport_offset]) / viewport[3+viewport_offset];
+
+    // Map to range -1 to 1
+    in[0] = in[0] * 2 - 1;
+    in[1] = in[1] * 2 - 1;
+    in[2] = in[2] * 2 - 1;
+
+    __gluMultMatrixVecf(matrix, 0, in, out);
+
+    if (out[3] == 0.0)
+      return false;
+
+    out[3] = 1.0f / out[3];
+
+    obj_pos[0+obj_pos_offset] = out[0] * out[3];
+    obj_pos[1+obj_pos_offset] = out[1] * out[3];
+    obj_pos[2+obj_pos_offset] = out[2] * out[3];
+
+    return true;
+  }
+
+
+  /**
+   * Method gluUnproject
+   * 
+   * @param winx
+   * @param winy
+   * @param winz
+   * @param modelMatrix
+   * @param projMatrix
+   * @param viewport
+   * @param obj_pos
+   * 
+   * @return
+   */
+  public boolean gluUnProject(float winx,
+                              float winy,
+                              float winz,
+                              FloatBuffer modelMatrix,
+                              FloatBuffer projMatrix,
+                              IntBuffer viewport,
+                              FloatBuffer obj_pos) {
+    FloatBuffer in = this.inBuf;
+    FloatBuffer out = this.outBuf;
+
+    gluMultMatricesf(modelMatrix, projMatrix, matrixBuf);
+
+    if (!gluInvertMatrixf(matrixBuf, matrixBuf))
+      return false;
+
+    in.put(0, winx);
+    in.put(1, winy);
+    in.put(2, winz);
+    in.put(3, 1.0f);
+
+    // Map x and y from window coordinates
+    int vPos = viewport.position();
+    int oPos = obj_pos.position();
+    in.put(0, (in.get(0) - viewport.get(0+vPos)) / viewport.get(2+vPos));
+    in.put(1, (in.get(1) - viewport.get(1+vPos)) / viewport.get(3+vPos));
+
+    // Map to range -1 to 1
+    in.put(0, in.get(0) * 2 - 1);
+    in.put(1, in.get(1) * 2 - 1);
+    in.put(2, in.get(2) * 2 - 1);
+
+    __gluMultMatrixVecf(matrixBuf, in, out);
+
+    if (out.get(3) == 0.0f)
+      return false;
+
+    out.put(3, 1.0f / out.get(3));
+
+    obj_pos.put(0+oPos, out.get(0) * out.get(3));
+    obj_pos.put(1+oPos, out.get(1) * out.get(3));
+    obj_pos.put(2+oPos, out.get(2) * out.get(3));
+
+    return true;
+  }
+
+
+  /**
+   * Method gluUnproject4
+   * 
+   * @param winx
+   * @param winy
+   * @param winz
+   * @param clipw
+   * @param modelMatrix
+   * @param projMatrix
+   * @param viewport
+   * @param near
+   * @param far
+   * @param obj_pos
+   * 
+   * @return
+   */
+  public boolean gluUnProject4(float winx,
+                               float winy,
+                               float winz,
+                               float clipw,
+                               float[] modelMatrix,
+                               int modelMatrix_offset,
+                               float[] projMatrix,
+                               int projMatrix_offset,
+                               int[] viewport,
+                               int viewport_offset,
+                               float near,
+                               float far,
+                               float[] obj_pos,
+                               int obj_pos_offset ) {
+    float[] in = this.in;
+    float[] out = this.out;
+
+    gluMultMatricesf(modelMatrix, modelMatrix_offset, projMatrix, projMatrix_offset, matrix);
+
+    if (!gluInvertMatrixf(matrix, matrix))
+      return false;
+
+    in[0] = winx;
+    in[1] = winy;
+    in[2] = winz;
+    in[3] = clipw;
+
+    // Map x and y from window coordinates
+    in[0] = (in[0] - viewport[0+viewport_offset]) / viewport[2+viewport_offset];
+    in[1] = (in[1] - viewport[1+viewport_offset]) / viewport[3+viewport_offset];
+    in[2] = (in[2] - near) / (far - near);
+
+    // Map to range -1 to 1
+    in[0] = in[0] * 2 - 1;
+    in[1] = in[1] * 2 - 1;
+    in[2] = in[2] * 2 - 1;
+
+    __gluMultMatrixVecf(matrix, 0, in, out);
+
+    if (out[3] == 0.0f)
+      return false;
+
+    obj_pos[0+obj_pos_offset] = out[0];
+    obj_pos[1+obj_pos_offset] = out[1];
+    obj_pos[2+obj_pos_offset] = out[2];
+    obj_pos[3+obj_pos_offset] = out[3];
+    return true;
+  }
+
+  /**
+   * Method gluUnproject4
+   * 
+   * @param winx
+   * @param winy
+   * @param winz
+   * @param clipw
+   * @param modelMatrix
+   * @param projMatrix
+   * @param viewport
+   * @param near
+   * @param far
+   * @param obj_pos
+   * 
+   * @return
+   */
+  public boolean gluUnProject4(float winx,
+                               float winy,
+                               float winz,
+                               float clipw,
+                               FloatBuffer modelMatrix,
+                               FloatBuffer projMatrix,
+                               IntBuffer viewport,
+                               float near,
+                               float far,
+                               FloatBuffer obj_pos) {
+    FloatBuffer in = this.inBuf;
+    FloatBuffer out = this.outBuf;
+
+    gluMultMatricesf(modelMatrix, projMatrix, matrixBuf);
+
+    if (!gluInvertMatrixf(matrixBuf, matrixBuf))
+      return false;
+
+    in.put(0, winx);
+    in.put(1, winy);
+    in.put(2, winz);
+    in.put(3, clipw);
+
+    // Map x and y from window coordinates
+    int vPos = viewport.position();
+    in.put(0, (in.get(0) - viewport.get(0+vPos)) / viewport.get(2+vPos));
+    in.put(1, (in.get(1) - viewport.get(1+vPos)) / viewport.get(3+vPos));
+    in.put(2, (in.get(2) - near) / (far - near));
+
+    // Map to range -1 to 1
+    in.put(0, in.get(0) * 2 - 1);
+    in.put(1, in.get(1) * 2 - 1);
+    in.put(2, in.get(2) * 2 - 1);
+
+    __gluMultMatrixVecf(matrixBuf, in, out);
+
+    if (out.get(3) == 0.0f)
+      return false;
+
+    int oPos = obj_pos.position();
+    obj_pos.put(0+oPos, out.get(0));
+    obj_pos.put(1+oPos, out.get(1));
+    obj_pos.put(2+oPos, out.get(2));
+    obj_pos.put(3+oPos, out.get(3));
+    return true;
+  }
+
+
+  /**
+   * Method gluPickMatrix
+   * 
+   * @param x
+   * @param y
+   * @param deltaX
+   * @param deltaY
+   * @param viewport
+   */
+  public void gluPickMatrix(GLMatrixIf gl,
+                            float x,
+                            float y,
+                            float deltaX,
+                            float deltaY,
+                            IntBuffer viewport) {
+    if (deltaX <= 0 || deltaY <= 0) {
+      return;
+    }
+
+    /* Translate and scale the picked region to the entire window */
+    int vPos = viewport.position();
+    gl.glTranslatef((viewport.get(2+vPos) - 2 * (x - viewport.get(0+vPos))) / deltaX,
+                    (viewport.get(3+vPos) - 2 * (y - viewport.get(1+vPos))) / deltaY,
+                    0);
+    gl.glScalef(viewport.get(2) / deltaX, viewport.get(3) / deltaY, 1.0f);
+  }
+
+  /**
+   * Method gluPickMatrix
+   * 
+   * @param x
+   * @param y
+   * @param deltaX
+   * @param deltaY
+   * @param viewport
+   * @param viewport_offset
+   */
+  public void gluPickMatrix(GLMatrixIf gl,
+                            float x,
+                            float y,
+                            float deltaX,
+                            float deltaY,
+                            int[] viewport,
+                            int viewport_offset) {
+    if (deltaX <= 0 || deltaY <= 0) {
+      return;
+    }
+
+    /* Translate and scale the picked region to the entire window */
+    gl.glTranslatef((viewport[2+viewport_offset] - 2 * (x - viewport[0+viewport_offset])) / deltaX,
+                    (viewport[3+viewport_offset] - 2 * (y - viewport[1+viewport_offset])) / deltaY,
+                    0);
+    gl.glScalef(viewport[2+viewport_offset] / deltaX, viewport[3+viewport_offset] / deltaY, 1.0f);
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/SystemUtil.java.javame_cdc_fp b/src/jogl/classes/com/sun/opengl/impl/SystemUtil.java.javame_cdc_fp
new file mode 100644
index 000000000..91723b505
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/SystemUtil.java.javame_cdc_fp
@@ -0,0 +1,10 @@
+package com.sun.opengl.impl;
+
+public class SystemUtil {
+
+    /** Wrapper for System.getenv(), which doesn't work on platforms
+        earlier than JDK 5 */
+    public static String getenv(String variableName) {
+        return null;
+    }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/SystemUtil.java.javase b/src/jogl/classes/com/sun/opengl/impl/SystemUtil.java.javase
new file mode 100644
index 000000000..3f201c2b6
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/SystemUtil.java.javase
@@ -0,0 +1,18 @@
+package com.sun.opengl.impl;
+
+public class SystemUtil {
+
+    private static volatile boolean getenvSupported = true;
+    /** Wrapper for System.getenv(), which doesn't work on platforms
+        earlier than JDK 5 */
+    public static String getenv(String variableName) {
+        if (getenvSupported) {
+            try {
+                return System.getenv(variableName);
+            } catch (Error e) {
+                getenvSupported = false;
+            }
+        }
+        return null;
+    }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/awt/AWTUtil.java b/src/jogl/classes/com/sun/opengl/impl/awt/AWTUtil.java
new file mode 100644
index 000000000..d156f86f8
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/awt/AWTUtil.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+package com.sun.opengl.impl.awt;
+
+import com.sun.nwi.impl.jawt.*;
+
+import com.sun.opengl.impl.*;
+
+import javax.media.opengl.*;
+
+import java.lang.reflect.*;
+import java.awt.GraphicsEnvironment;
+
+public class AWTUtil {
+  // See whether we're running in headless mode
+  private static boolean headlessMode;
+  private static Class j2dClazz = null;
+  private static Method isOGLPipelineActive = null;
+  private static Method isQueueFlusherThread = null;
+  private static boolean j2dOk = false;
+
+  static {
+    lockedToolkit = false;
+    headlessMode = GraphicsEnvironment.isHeadless();
+    try {
+        j2dClazz = Class.forName("com.sun.opengl.impl.awt.Java2D");
+        isOGLPipelineActive = j2dClazz.getMethod("isOGLPipelineActive", null);
+        isQueueFlusherThread = j2dClazz.getMethod("isQueueFlusherThread", null);
+        j2dOk = true;
+    } catch (Exception e) {}
+  }
+
+  private static boolean lockedToolkit;
+
+  public static synchronized void lockToolkit() throws GLException {
+    if (lockedToolkit) {
+      throw new GLException("Toolkit already locked");
+    }
+    lockedToolkit = true;
+
+    if (headlessMode) {
+      // Workaround for running (to some degree) in headless
+      // environments but still supporting rendering via pbuffers
+      // For full correctness, would need to implement a Lock class
+      return;
+    }
+
+    if(j2dOk) {
+      try {
+        if( !((Boolean)isOGLPipelineActive.invoke(null, null)).booleanValue() ||
+            !((Boolean)isQueueFlusherThread.invoke(null, null)).booleanValue() ) {
+          JAWT.getJAWT().Lock();
+        }
+      } catch (Exception e) { j2dOk=false; }
+    } 
+    if(!j2dOk) {
+      JAWT.getJAWT().Lock();
+    }
+  }
+
+  public static synchronized void unlockToolkit() {
+    if (lockedToolkit) {
+        if (headlessMode) {
+          // Workaround for running (to some degree) in headless
+          // environments but still supporting rendering via pbuffers
+          // For full correctness, would need to implement a Lock class
+          return;
+        }
+
+        if(j2dOk) {
+          try {
+            if( !((Boolean)isOGLPipelineActive.invoke(null, null)).booleanValue() ||
+                !((Boolean)isQueueFlusherThread.invoke(null, null)).booleanValue() ) {
+              JAWT.getJAWT().Unlock();
+            }
+          } catch (Exception e) { j2dOk=false; }
+        } 
+        if(!j2dOk) {
+          JAWT.getJAWT().Unlock();
+        }
+        lockedToolkit = false;
+    }
+  }
+
+  public static boolean isToolkitLocked() {
+    return lockedToolkit;
+  }
+
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/awt/Java2D.java b/src/jogl/classes/com/sun/opengl/impl/awt/Java2D.java
new file mode 100755
index 000000000..7da32f707
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/awt/Java2D.java
@@ -0,0 +1,569 @@
+/*
+ * Copyright (c) 2003-2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.awt;
+
+import com.sun.opengl.impl.*;
+
+import java.awt.*;
+import java.awt.image.*;
+import java.lang.reflect.*;
+import java.security.*;
+
+import javax.media.opengl.*;
+
+/** Defines integration with the Java2D OpenGL pipeline. This
+    integration is only supported in 1.6 and is highly experimental. */
+
+public class Java2D {
+  private static boolean DEBUG = Debug.debug("Java2D");
+  private static boolean VERBOSE = Debug.verbose();
+  private static boolean isHeadless;
+  private static boolean isOGLPipelineActive;
+  private static Method invokeWithOGLContextCurrentMethod;
+  private static Method isQueueFlusherThreadMethod;
+  private static Method getOGLViewportMethod;
+  private static Method getOGLScissorBoxMethod;
+  private static Method getOGLSurfaceIdentifierMethod;
+  // This one is currently optional and is only in very recent Mustang builds
+  private static Method getOGLTextureTypeMethod;
+
+  // The following methods and fields are needed for proper support of
+  // Frame Buffer Objects in the Java2D/OpenGL pipeline
+  // (-Dsun.java2d.opengl.fbobject=true)
+  private static boolean fbObjectSupportInitialized;
+  private static Method invokeWithOGLSharedContextCurrentMethod;
+  private static Method getOGLSurfaceTypeMethod;
+
+  // Publicly-visible constants for OpenGL surface types
+  public static final int UNDEFINED       = getOGLUtilitiesIntField("UNDEFINED");
+  public static final int WINDOW          = getOGLUtilitiesIntField("WINDOW");
+  public static final int PBUFFER         = getOGLUtilitiesIntField("PBUFFER");
+  public static final int TEXTURE         = getOGLUtilitiesIntField("TEXTURE");
+  public static final int FLIP_BACKBUFFER = getOGLUtilitiesIntField("FLIP_BACKBUFFER");
+  public static final int FBOBJECT        = getOGLUtilitiesIntField("FBOBJECT");
+
+  // If FBOs are enabled in the Java2D/OpenGL pipeline, all contexts
+  // created by JOGL must share textures and display lists with the
+  // Java2D contexts in order to access the frame buffer object for
+  // potential rendering, and to simultaneously support sharing of
+  // textures and display lists with one another. Java2D has the
+  // notion of a single shared context with which all other contexts
+  // (on the same display device?) share textures and display lists;
+  // this is an approximation to that notion which will be refined
+  // later.
+  private static boolean initializedJ2DFBOShareContext;
+  private static GLContext j2dFBOShareContext;
+
+  // Accessors for new methods in sun.java2d.opengl.CGLSurfaceData
+  // class on OS X for enabling bridge
+  //  public static long    createOGLContextOnSurface(Graphics g, long ctx);
+  //  public static boolean makeOGLContextCurrentOnSurface(Graphics g, long ctx);
+  //  public static void    destroyOGLContext(long ctx);
+  private static Method createOGLContextOnSurfaceMethod;
+  private static Method makeOGLContextCurrentOnSurfaceMethod;
+  private static Method destroyOGLContextMethod;
+
+  static {
+    AccessController.doPrivileged(new PrivilegedAction() {
+        public Object run() {
+          if (DEBUG && VERBOSE) {
+            System.err.println("Checking for Java2D/OpenGL support");
+          }
+          try {
+            isHeadless = true;
+            // Figure out whether the default graphics configuration is an
+            // OpenGL graphics configuration
+            GraphicsConfiguration cfg =
+              GraphicsEnvironment.getLocalGraphicsEnvironment().
+              getDefaultScreenDevice().
+              getDefaultConfiguration();
+            // If we get here, we aren't running in headless mode
+            isHeadless = false;
+            String name = cfg.getClass().getName();
+            if (DEBUG && VERBOSE) {
+              System.err.println("Java2D support: default GraphicsConfiguration = " + name);
+            }
+            isOGLPipelineActive = (name.startsWith("sun.java2d.opengl"));
+
+            if (isOGLPipelineActive) {
+              try {
+                // Try to get methods we need to integrate
+                Class utils = Class.forName("sun.java2d.opengl.OGLUtilities");
+                invokeWithOGLContextCurrentMethod = utils.getDeclaredMethod("invokeWithOGLContextCurrent",
+                                                                            new Class[] {
+                                                                              Graphics.class,
+                                                                              Runnable.class
+                                                                            });
+                invokeWithOGLContextCurrentMethod.setAccessible(true);
+
+                isQueueFlusherThreadMethod = utils.getDeclaredMethod("isQueueFlusherThread",
+                                                                     new Class[] {});
+                isQueueFlusherThreadMethod.setAccessible(true);
+
+                getOGLViewportMethod = utils.getDeclaredMethod("getOGLViewport",
+                                                               new Class[] {
+                                                                 Graphics.class,
+                                                                 Integer.TYPE,
+                                                                 Integer.TYPE
+                                                               });
+                getOGLViewportMethod.setAccessible(true);
+
+                getOGLScissorBoxMethod = utils.getDeclaredMethod("getOGLScissorBox",
+                                                                 new Class[] {
+                                                                   Graphics.class
+                                                                 });
+                getOGLScissorBoxMethod.setAccessible(true);
+
+                getOGLSurfaceIdentifierMethod = utils.getDeclaredMethod("getOGLSurfaceIdentifier",
+                                                                        new Class[] {
+                                                                          Graphics.class
+                                                                        });
+                getOGLSurfaceIdentifierMethod.setAccessible(true);
+
+                // Try to get additional methods required for proper FBO support
+                fbObjectSupportInitialized = true;
+                try {
+                  invokeWithOGLSharedContextCurrentMethod = utils.getDeclaredMethod("invokeWithOGLSharedContextCurrent",
+                                                                                    new Class[] {
+                                                                                      GraphicsConfiguration.class,
+                                                                                      Runnable.class
+                                                                                    });
+                  invokeWithOGLSharedContextCurrentMethod.setAccessible(true);
+
+                  getOGLSurfaceTypeMethod = utils.getDeclaredMethod("getOGLSurfaceType",
+                                                                    new Class[] {
+                                                                      Graphics.class
+                                                                    });
+                  getOGLSurfaceTypeMethod.setAccessible(true);
+                } catch (Exception e) {
+                  fbObjectSupportInitialized = false;
+                  if (DEBUG && VERBOSE) {
+                    e.printStackTrace();
+                    System.err.println("Disabling Java2D/JOGL FBO support");
+                  }
+                }
+
+                // Try to get an additional method for FBO support in recent Mustang builds
+                try {
+                  getOGLTextureTypeMethod = utils.getDeclaredMethod("getOGLTextureType",
+                                                                    new Class[] {
+                                                                      Graphics.class
+                                                                    });
+                  getOGLTextureTypeMethod.setAccessible(true);
+                } catch (Exception e) {
+                  if (DEBUG && VERBOSE) {
+                    e.printStackTrace();
+                    System.err.println("GL_ARB_texture_rectangle FBO support disabled");
+                  }
+                }
+
+                // Try to set up APIs for enabling the bridge on OS X,
+                // where it isn't possible to create generalized
+                // external GLDrawables
+                Class cglSurfaceData = null;
+                try {
+                  cglSurfaceData = Class.forName("sun.java2d.opengl.CGLSurfaceData");
+                } catch (Exception e) {
+                  if (DEBUG && VERBOSE) {
+                    e.printStackTrace();
+                    System.err.println("Unable to find class sun.java2d.opengl.CGLSurfaceData for OS X");
+                  }
+                }
+                if (cglSurfaceData != null) {
+                  // FIXME: for now, assume that FBO support is not enabled on OS X
+                  fbObjectSupportInitialized = false;
+
+                  // We need to find these methods in order to make the bridge work on OS X
+                  createOGLContextOnSurfaceMethod = cglSurfaceData.getDeclaredMethod("createOGLContextOnSurface",
+                                                                                     new Class[] {
+                                                                                       Graphics.class,
+                                                                                       Long.TYPE
+                                                                                     });
+                  createOGLContextOnSurfaceMethod.setAccessible(true);
+
+                  makeOGLContextCurrentOnSurfaceMethod = cglSurfaceData.getDeclaredMethod("makeOGLContextCurrentOnSurface",
+                                                                                          new Class[] {
+                                                                                            Graphics.class,
+                                                                                            Long.TYPE
+                                                                                          });
+                  makeOGLContextCurrentOnSurfaceMethod.setAccessible(true);
+
+                  destroyOGLContextMethod = cglSurfaceData.getDeclaredMethod("destroyOGLContext",
+                                                                             new Class[] {
+                                                                               Long.TYPE
+                                                                             });
+                  destroyOGLContextMethod.setAccessible(true);
+                }
+              } catch (Exception e) {
+                if (DEBUG && VERBOSE) {
+                  e.printStackTrace();
+                  System.err.println("Disabling Java2D/JOGL integration");
+                }
+                isOGLPipelineActive = false;
+              }
+            }
+          } catch (HeadlessException e) {
+            // The AWT is running in headless mode, so the Java 2D / JOGL bridge is clearly disabled
+          }
+
+          if (DEBUG) {
+            System.err.println("JOGL/Java2D integration " + (isOGLPipelineActive ? "enabled" : "disabled"));
+          }
+          return null;
+        }
+      });
+  }
+
+  public static boolean isOGLPipelineActive() {
+    return isOGLPipelineActive;
+  }
+
+  public static boolean isFBOEnabled() {
+    return fbObjectSupportInitialized;
+  }
+
+  public static boolean isQueueFlusherThread() {
+    checkActive();
+
+    try {
+      return ((Boolean) isQueueFlusherThreadMethod.invoke(null, new Object[] {})).booleanValue();
+    } catch (InvocationTargetException e) {
+      throw new GLException(e.getTargetException());
+    } catch (Exception e) {
+      throw (InternalError) new InternalError().initCause(e);
+    }
+  }
+  
+  /** Makes current the OpenGL context associated with the passed
+      Graphics object and runs the given Runnable on the Queue
+      Flushing Thread in one atomic action. */
+  public static void invokeWithOGLContextCurrent(Graphics g, Runnable r) throws GLException {
+    checkActive();
+
+    try {
+      // FIXME: this may need adjustment
+      // This seems to be needed in many applications which don't
+      // initialize an OpenGL context before this and which would
+      // otherwise cause initFBOShareContext to be called from the
+      // Queue Flusher Thread, which isn't allowed
+      initFBOShareContext(GraphicsEnvironment.
+                          getLocalGraphicsEnvironment().
+                          getDefaultScreenDevice().
+                          getDefaultConfiguration());
+
+      AWTUtil.lockToolkit();
+      try {
+        invokeWithOGLContextCurrentMethod.invoke(null, new Object[] {g, r});
+      } finally {
+        AWTUtil.unlockToolkit();
+      }
+    } catch (InvocationTargetException e) {
+      throw new GLException(e.getTargetException());
+    } catch (Exception e) {
+      throw (InternalError) new InternalError().initCause(e);
+    }
+  }
+
+  /** Makes current the "shared" OpenGL context associated with the
+      given GraphicsConfiguration object, allowing JOGL to share
+      server-side OpenGL objects like textures and display lists with
+      this context when necessary. This is needed when Java2D's FBO
+      support is enabled, because in order to render into that FBO,
+      JOGL must share textures and display lists with it. Returns
+      false if the passed GraphicsConfiguration was not an OpenGL
+      GraphicsConfiguration. */
+  public static boolean invokeWithOGLSharedContextCurrent(GraphicsConfiguration g, Runnable r) throws GLException {
+    checkActive();
+
+    try {
+      AWTUtil.lockToolkit();
+      try {
+        return ((Boolean) invokeWithOGLSharedContextCurrentMethod.invoke(null, new Object[] {g, r})).booleanValue();
+      } finally {
+        AWTUtil.unlockToolkit();
+      }
+    } catch (InvocationTargetException e) {
+      throw new GLException(e.getTargetException());
+    } catch (Exception e) {
+      throw (InternalError) new InternalError().initCause(e);
+    }
+  }
+
+  /** Returns the OpenGL viewport associated with the given Graphics
+      object, assuming that the Graphics object is associated with a
+      component of the specified width and height. The user should
+      call glViewport() with the returned rectangle's bounds in order
+      to get correct rendering results. Should only be called from the
+      Queue Flusher Thread. */
+  public static Rectangle getOGLViewport(Graphics g,
+                                         int componentWidth,
+                                         int componentHeight) {
+    checkActive();
+
+    try {
+      return (Rectangle) getOGLViewportMethod.invoke(null, new Object[] {g,
+                                                                         new Integer(componentWidth),
+                                                                         new Integer(componentHeight)});
+    } catch (InvocationTargetException e) {
+      throw new GLException(e.getTargetException());
+    } catch (Exception e) {
+      throw (InternalError) new InternalError().initCause(e);
+    }
+  }
+
+  /** Returns the OpenGL scissor region associated with the given
+      Graphics object, taking into account all clipping regions, etc.
+      To avoid destroying Java2D's previous rendering results, this
+      method should be called and the resulting rectangle's bounds
+      passed to a call to glScissor(). Should only be called from the
+      Queue Flusher Thread. */
+  public static Rectangle getOGLScissorBox(Graphics g) {
+    checkActive();
+
+    try {
+      return (Rectangle) getOGLScissorBoxMethod.invoke(null, new Object[] {g});
+    } catch (InvocationTargetException e) {
+      throw new GLException(e.getTargetException());
+    } catch (Exception e) {
+      throw (InternalError) new InternalError().initCause(e);
+    }
+  }
+
+  /** Returns an opaque "surface identifier" associated with the given
+      Graphics object. If this changes from invocation to invocation,
+      the underlying OpenGL drawable for the Graphics object has
+      changed and a new external GLDrawable and GLContext should be
+      created (and the old ones destroyed). Should only be called from
+      the Queue Flusher Thread.*/
+  public static Object getOGLSurfaceIdentifier(Graphics g) {
+    checkActive();
+
+    try {
+      return getOGLSurfaceIdentifierMethod.invoke(null, new Object[] {g});
+    } catch (InvocationTargetException e) {
+      throw new GLException(e.getTargetException());
+    } catch (Exception e) {
+      throw (InternalError) new InternalError().initCause(e);
+    }
+  }
+
+  /** Returns the underlying surface type for the given Graphics
+      object. This indicates, in particular, whether Java2D is
+      currently rendering into a pbuffer or FBO. */
+  public static int getOGLSurfaceType(Graphics g) {
+    checkActive();
+
+    try {
+      // FIXME: fallback path for pre-b73 (?) Mustang builds -- remove
+      // once fbobject support is in OGLUtilities
+      if (!fbObjectSupportInitialized) {
+        return 0;
+      }
+
+      return ((Integer) getOGLSurfaceTypeMethod.invoke(null, new Object[] { g })).intValue();
+    } catch (InvocationTargetException e) {
+      throw new GLException(e.getTargetException());
+    } catch (Exception e) {
+      throw (InternalError) new InternalError().initCause(e);
+    }
+  }
+
+  /** Returns the underlying texture target of the given Graphics
+      object assuming it is rendering to an FBO. Returns either
+      GL_TEXTURE_2D or GL_TEXTURE_RECTANGLE_ARB. */
+  public static int getOGLTextureType(Graphics g) {
+    checkActive();
+
+    if (getOGLTextureTypeMethod == null) {
+      return GL.GL_TEXTURE_2D;
+    }
+
+    try {
+      return ((Integer) getOGLTextureTypeMethod.invoke(null, new Object[] { g })).intValue();
+    } catch (InvocationTargetException e) {
+      throw new GLException(e.getTargetException());
+    } catch (Exception e) {
+      throw (InternalError) new InternalError().initCause(e);
+    }
+  }
+
+  /** Returns either the given GLContext or a substitute one with
+      which clients should share textures and display lists. Needed
+      when the Java2D/OpenGL pipeline is active and FBOs are being
+      used for rendering. FIXME: may need to alter the API in the
+      future to indicate which GraphicsDevice the source context is
+      associated with. */
+  public static GLContext filterShareContext(GLContext shareContext) {
+    if (isHeadless)
+      return shareContext;
+
+    // FIXME: this may need adjustment
+    initFBOShareContext(GraphicsEnvironment.
+                        getLocalGraphicsEnvironment().
+                        getDefaultScreenDevice().
+                        getDefaultConfiguration());
+    if (j2dFBOShareContext != null) {
+      return j2dFBOShareContext;
+    }
+    return shareContext;
+  }
+
+  /** Returns the GLContext associated with the Java2D "share
+      context", with which all contexts created by JOGL must share
+      textures and display lists when the FBO option is enabled for
+      the Java2D/OpenGL pipeline. */
+  public static GLContext getShareContext(GraphicsConfiguration gc) {
+    initFBOShareContext(gc);
+    // FIXME: for full generality probably need to have multiple of
+    // these, one per GraphicsConfiguration seen?
+    return j2dFBOShareContext;
+  }
+
+  //----------------------------------------------------------------------
+  // Mac OS X-specific methods
+  //
+
+  /** (Mac OS X-specific) Creates a new OpenGL context on the surface
+      associated with the given Graphics object, sharing textures and
+      display lists with the specified (CGLContextObj) share context. */
+  public static long createOGLContextOnSurface(Graphics g, long shareCtx) {
+    checkActive();
+
+    try {
+      return ((Long) createOGLContextOnSurfaceMethod.invoke(null, new Object[] { g, new Long(shareCtx) })).longValue();
+    } catch (InvocationTargetException e) {
+      throw new GLException(e.getTargetException());
+    } catch (Exception e) {
+      throw (InternalError) new InternalError().initCause(e);
+    }
+  }
+
+  /** (Mac OS X-specific) Makes the given OpenGL context current on
+      the surface associated with the given Graphics object. */
+  public static boolean makeOGLContextCurrentOnSurface(Graphics g, long ctx) {
+    checkActive();
+
+    try {
+      return ((Boolean) makeOGLContextCurrentOnSurfaceMethod.invoke(null, new Object[] { g, new Long(ctx) })).booleanValue();
+    } catch (InvocationTargetException e) {
+      throw new GLException(e.getTargetException());
+    } catch (Exception e) {
+      throw (InternalError) new InternalError().initCause(e);
+    }
+  }
+
+  /** (Mac OS X-specific) Destroys the given OpenGL context. */
+  public static void destroyOGLContext(long ctx) {
+    checkActive();
+
+    try {
+      destroyOGLContextMethod.invoke(null, new Object[] { new Long(ctx) });
+    } catch (InvocationTargetException e) {
+      throw new GLException(e.getTargetException());
+    } catch (Exception e) {
+      throw (InternalError) new InternalError().initCause(e);
+    }
+  }
+
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+
+  private static void checkActive() {
+    if (!isOGLPipelineActive()) {
+      throw new GLException("Java2D OpenGL pipeline not active (or necessary support not present)");
+    }
+  }
+
+  private static int getOGLUtilitiesIntField(final String name) {
+    Integer i = (Integer) AccessController.doPrivileged(new PrivilegedAction() {
+        public Object run() {
+          try {
+            Class utils = Class.forName("sun.java2d.opengl.OGLUtilities");
+            Field f = utils.getField(name);
+            f.setAccessible(true);
+            return f.get(null);
+          } catch (Exception e) {
+            if (DEBUG && VERBOSE) {
+              e.printStackTrace();
+            }
+            return null;
+          }
+        }
+      });
+    if (i == null)
+      return 0;
+    if (DEBUG && VERBOSE) {
+      System.err.println("OGLUtilities." + name + " = " + i.intValue());
+    }
+    return i.intValue();
+  }
+
+  private static void initFBOShareContext(final GraphicsConfiguration gc) {
+    // Note 1: this must not be done in the static initalizer due to
+    // deadlock problems.
+
+    // Note 2: the first execution of this method must not be from the
+    // Java2D Queue Flusher Thread.
+
+    if (isOGLPipelineActive() &&
+        isFBOEnabled() &&
+        !initializedJ2DFBOShareContext) {
+
+      // FIXME: this technique is probably not adequate in multi-head
+      // situations. Ideally we would keep track of a given share
+      // context on a per-GraphicsConfiguration basis or something
+      // similar rather than keeping one share context in a global
+      // variable.
+      initializedJ2DFBOShareContext = true;
+      if (DEBUG) {
+        System.err.println("Starting initialization of J2D FBO share context");
+      }
+      invokeWithOGLSharedContextCurrent(gc, new Runnable() {
+          public void run() {
+            j2dFBOShareContext = GLDrawableFactory.getFactory().createExternalGLContext();
+          }
+        });
+      if (DEBUG) {
+        System.err.println("Ending initialization of J2D FBO share context");
+      }
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/awt/Java2DGLContext.java b/src/jogl/classes/com/sun/opengl/impl/awt/Java2DGLContext.java
new file mode 100644
index 000000000..48461c116
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/awt/Java2DGLContext.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.awt;
+
+import com.sun.opengl.impl.*;
+import java.awt.Graphics;
+
+/** Provides a construct by which the shared GLJPanel code can
+ * interact with a few methods in the Mac OS X-specific Java2D/JOGL
+ * bridge implementation.
+ */
+
+public interface Java2DGLContext {
+  public void setGraphics(Graphics g);
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/egl/EGLConfig.java b/src/jogl/classes/com/sun/opengl/impl/egl/EGLConfig.java
new file mode 100644
index 000000000..2c03a20a6
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/egl/EGLConfig.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.egl;
+
+import java.util.*;
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.gluegen.runtime.NativeLibrary;
+
+public class EGLConfig {
+    
+    public _EGLConfig getNativeConfig() {
+        return _config;
+    }
+
+    public int getNativeConfigID() {
+        return configID;
+    }
+
+    public NWCapabilities getCapabilities() {
+        return capabilities;
+    }
+
+    public int[] getAttributeList() {
+        return glCapabilities2AttribList(capabilities);
+    }
+
+    public EGLConfig(long display, int configID) {
+        int[] attrs = new int[] {
+                EGL.EGL_RENDERABLE_TYPE, -1,
+                EGL.EGL_CONFIG_ID, configID,
+                EGL.EGL_NONE
+            };
+        if (GLProfile.isGLES2()) {
+            attrs[1] = EGL.EGL_OPENGL_ES2_BIT;
+        } else if (GLProfile.isGLES1()) {
+            attrs[1] = EGL.EGL_OPENGL_ES_BIT;
+        } else {
+            throw new GLException("Error creating EGL drawable - invalid GLProfile");
+        }
+        _EGLConfig[] configs = new _EGLConfig[1];
+        int[] numConfigs = new int[1];
+        if (!EGL.eglChooseConfig(display,
+                                 attrs, 0,
+                                 configs, 1,
+                                 numConfigs, 0)) {
+            throw new GLException("Graphics configuration selection (eglChooseConfig) failed");
+        }
+        if (numConfigs[0] == 0) {
+            throw new GLException("No valid graphics configuration selected from eglChooseConfig");
+        }
+        capabilities = new NWCapabilities();
+        setup(display, configID, configs[0]);
+    }
+
+    public EGLConfig(long display, NWCapabilities caps) {
+        int[] attrs = glCapabilities2AttribList(caps);
+        _EGLConfig[] configs = new _EGLConfig[1];
+        int[] numConfigs = new int[1];
+        if (!EGL.eglChooseConfig(display,
+                                 attrs, 0,
+                                 configs, 1,
+                                 numConfigs, 0)) {
+            throw new GLException("Graphics configuration selection (eglChooseConfig) failed");
+        }
+        if (numConfigs[0] == 0) {
+            throw new GLException("No valid graphics configuration selected from eglChooseConfig");
+        }
+        capabilities = (NWCapabilities)caps.clone();
+        setup(display, -1, configs[0]);
+    }
+
+    private void setup(long display, int setConfigID, _EGLConfig _config) {
+        this._config = _config;
+        int[] val = new int[1];
+        // get the configID 
+        if(EGL.eglGetConfigAttrib(display, _config, EGL.EGL_CONFIG_ID, val, 0)) {
+            configID = val[0];
+            if( setConfigID>=0 && setConfigID!=this.configID ) {
+                throw new GLException("EGL ConfigID mismatch, ask "+setConfigID+", got "+configID);
+            }
+        } else {
+            throw new GLException("EGL couldn't retrieve ConfigID");
+        }
+        // Read the actual configuration into the choosen caps
+        if(EGL.eglGetConfigAttrib(display, _config, EGL.EGL_RED_SIZE, val, 0)) {
+            capabilities.setRedBits(val[0]);
+        }
+        if(EGL.eglGetConfigAttrib(display, _config, EGL.EGL_GREEN_SIZE, val, 0)) {
+            capabilities.setGreenBits(val[0]);
+        }
+        if(EGL.eglGetConfigAttrib(display, _config, EGL.EGL_BLUE_SIZE, val, 0)) {
+            capabilities.setBlueBits(val[0]);
+        }
+        if(EGL.eglGetConfigAttrib(display, _config, EGL.EGL_ALPHA_SIZE, val, 0)) {
+            capabilities.setAlphaBits(val[0]);
+        }
+        if(EGL.eglGetConfigAttrib(display, _config, EGL.EGL_STENCIL_SIZE, val, 0)) {
+            capabilities.setStencilBits(val[0]);
+        }
+        if(EGL.eglGetConfigAttrib(display, _config, EGL.EGL_DEPTH_SIZE, val, 0)) {
+            capabilities.setDepthBits(val[0]);
+        }
+    }
+
+    public static int[] glCapabilities2AttribList(NWCapabilities caps) {
+        int[] attrs = new int[] {
+                EGL.EGL_RENDERABLE_TYPE, -1,
+                // FIXME: does this need to be configurable?
+                EGL.EGL_SURFACE_TYPE,    EGL.EGL_WINDOW_BIT,
+                EGL.EGL_RED_SIZE,        caps.getRedBits(),
+                EGL.EGL_GREEN_SIZE,      caps.getGreenBits(),
+                EGL.EGL_BLUE_SIZE,       caps.getBlueBits(),
+                EGL.EGL_ALPHA_SIZE,      (caps.getAlphaBits() > 0 ? caps.getAlphaBits() : EGL.EGL_DONT_CARE),
+                EGL.EGL_STENCIL_SIZE,    (caps.getStencilBits() > 0 ? caps.getStencilBits() : EGL.EGL_DONT_CARE),
+                EGL.EGL_DEPTH_SIZE,      caps.getDepthBits(),
+                EGL.EGL_NONE
+            };
+        if (GLProfile.isGLES2()) {
+            attrs[1] = EGL.EGL_OPENGL_ES2_BIT;
+        } else if (GLProfile.isGLES1()) {
+            attrs[1] = EGL.EGL_OPENGL_ES_BIT;
+        } else {
+            throw new GLException("Error creating EGL drawable - invalid GLProfile");
+        }
+
+        return attrs;
+    }
+
+    public String toString() {
+        return "EGLConfig[ id "+configID+
+                           ", "+capabilities+"]";
+    }
+    private _EGLConfig _config;
+    private int configID;
+    private NWCapabilities capabilities;
+}
+
diff --git a/src/jogl/classes/com/sun/opengl/impl/egl/EGLContext.java b/src/jogl/classes/com/sun/opengl/impl/egl/EGLContext.java
new file mode 100755
index 000000000..97ae63cd4
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/egl/EGLContext.java
@@ -0,0 +1,294 @@
+/*
+ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.egl;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.gluegen.runtime.ProcAddressTable;
+import java.nio.*;
+import java.util.*;
+
+public class EGLContext extends GLContextImpl {
+    private EGLDrawable drawable;
+    private long context;
+    private boolean eglQueryStringInitialized;
+    private boolean eglQueryStringAvailable;
+    private EGLExt eglExt;
+    // Table that holds the addresses of the native C-language entry points for
+    // EGL extension functions.
+    private EGLExtProcAddressTable eglExtProcAddressTable;
+
+    public EGLContext(EGLDrawable drawable, GLContext shareWith) {
+        super(shareWith);
+        this.drawable = drawable;
+    }
+
+    public Object getPlatformGLExtensions() {
+      return getEGLExt();
+    }
+
+    public EGLExt getEGLExt() {
+      if (eglExt == null) {
+        eglExt = new EGLExtImpl(this);
+      }
+      return eglExt;
+    }
+
+    public final ProcAddressTable getPlatformExtProcAddressTable() {
+        return eglExtProcAddressTable;
+    }
+
+    public final EGLExtProcAddressTable getEGLExtProcAddressTable() {
+        return eglExtProcAddressTable;
+    }
+
+    public GLDrawable getGLDrawable() {
+        return drawable;
+    }
+
+    protected String mapToRealGLFunctionName(String glFunctionName) {
+        return glFunctionName;
+    }
+
+    protected String mapToRealGLExtensionName(String glExtensionName) {
+        return glExtensionName;
+    }
+
+    public long getContext() {
+        return context;
+    }
+
+    private int makeCurrentImplInner() throws GLException {
+        boolean created = false;
+        if (context == 0) {
+            create();
+            if (DEBUG) {
+                System.err.println(getThreadName() + ": !!! Created GL context 0x" +
+                                   Long.toHexString(context) + " for " + getClass().getName());
+            }
+            created = true;
+        }
+        if (EGL.eglGetCurrentContext() != context) {
+            if (!EGL.eglMakeCurrent(drawable.getDisplay(),
+                                    drawable.getSurface(),
+                                    drawable.getSurface(),
+                                    context)) {
+                throw new GLException("Error making context 0x" +
+                                      Long.toHexString(context) + " current: error code " + EGL.eglGetError());
+            }
+        }
+
+        if (created) {
+            resetGLFunctionAvailability();
+            return CONTEXT_CURRENT_NEW;
+        }
+        return CONTEXT_CURRENT;
+    }
+
+    protected int makeCurrentImpl() throws GLException {
+        if(EGL.EGL_NO_DISPLAY==drawable.getDisplay() ) {
+            System.err.println("drawable not properly initialized");
+            return CONTEXT_NOT_CURRENT;
+        }
+        drawable.setSurface();
+
+        int lockRes = NativeWindow.LOCK_SUCCESS;
+        // FIXME: freezes AWT: int lockRes = drawable.lockSurface();
+        boolean exceptionOccurred = false;
+        try {
+          if (lockRes == NativeWindow.LOCK_SURFACE_NOT_READY) {
+            return CONTEXT_NOT_CURRENT;
+          }
+          if (lockRes == NativeWindow.LOCK_SURFACE_CHANGED) {
+            destroyImpl();
+          }
+          return makeCurrentImplInner();
+        } catch (RuntimeException e) {
+          exceptionOccurred = true;
+          throw e;
+        } finally {
+          if (exceptionOccurred ||
+              (isOptimizable() && lockRes != NativeWindow.LOCK_SURFACE_NOT_READY)) {
+            drawable.unlockSurface();
+          }
+        }
+    }
+
+    protected void releaseImpl() throws GLException {
+      getDrawableImpl().getFactoryImpl().lockToolkit();
+      try {
+        if (!EGL.eglMakeCurrent(drawable.getDisplay(),
+                                EGL.EGL_NO_SURFACE,
+                                EGL.EGL_NO_SURFACE,
+                                EGL.EGL_NO_CONTEXT)) {
+            throw new GLException("Error freeing OpenGL context 0x" +
+                                  Long.toHexString(context) + ": error code " + EGL.eglGetError());
+        }
+      } finally {
+        getDrawableImpl().getFactoryImpl().unlockToolkit();
+        drawable.unlockSurface();
+      }
+    }
+
+    protected void destroyImpl() throws GLException {
+      getDrawableImpl().getFactoryImpl().lockToolkit();
+      try {
+        if (context != 0) {
+            if (!EGL.eglDestroyContext(drawable.getDisplay(), context)) {
+                throw new GLException("Error destroying OpenGL context 0x" +
+                                      Long.toHexString(context) + ": error code " + EGL.eglGetError());
+            }
+            context = 0;
+            GLContextShareSet.contextDestroyed(this);
+        }
+      } finally {
+        getDrawableImpl().getFactoryImpl().unlockToolkit();
+      }
+    }
+
+    protected void create() throws GLException {
+        long display = drawable.getDisplay();
+        _EGLConfig config = drawable.getEGLConfig().getNativeConfig();
+        long shareWith = EGL.EGL_NO_CONTEXT;
+
+        if (display == 0) {
+            throw new GLException("Error: attempted to create an OpenGL context without a display connection");
+        }
+        if (config == null) {
+            throw new GLException("Error: attempted to create an OpenGL context without a graphics configuration");
+        }
+        EGLContext other = (EGLContext) GLContextShareSet.getShareContext(this);
+        if (other != null) {
+            shareWith = other.getContext();
+            if (shareWith == 0) {
+                throw new GLException("GLContextShareSet returned an invalid OpenGL context");
+            }
+        }
+
+        int[] contextAttrs = new int[] {
+                EGL.EGL_CONTEXT_CLIENT_VERSION, -1,
+                EGL.EGL_NONE
+        };
+        if (GLProfile.isGLES2()) {
+            contextAttrs[1] = 2;
+        } else if (GLProfile.isGLES1()) {
+            contextAttrs[1] = 1;
+        } else {
+            throw new GLException("Error creating OpenGL context - invalid GLProfile");
+        }
+        context = EGL.eglCreateContext(display, config, shareWith, contextAttrs, 0);
+        if (context == 0) {
+            throw new GLException("Error creating OpenGL context");
+        }
+        GLContextShareSet.contextCreated(this);
+        if (DEBUG) {
+            System.err.println(getThreadName() + ": !!! Created OpenGL context 0x" +
+                               Long.toHexString(context) + " for " + this +
+                               ", surface 0x" + Long.toHexString(drawable.getSurface()) +
+                               ", sharing with 0x" + Long.toHexString(shareWith));
+        }
+    }
+
+    public boolean isCreated() {
+        return (context != 0);
+    }
+
+    protected void resetGLFunctionAvailability() {
+        super.resetGLFunctionAvailability();
+        if (DEBUG) {
+          System.err.println(getThreadName() + ": !!! Initializing EGL extension address table");
+        }
+        if (eglExtProcAddressTable == null) {
+          // FIXME: cache ProcAddressTables by capability bits so we can
+          // share them among contexts with the same capabilities
+          eglExtProcAddressTable = new EGLExtProcAddressTable();
+        }          
+        resetProcAddressTable(getEGLExtProcAddressTable());
+    }
+  
+    public synchronized String getPlatformExtensionsString() {
+        if (!eglQueryStringInitialized) {
+          eglQueryStringAvailable =
+            getDrawableImpl().getFactoryImpl().dynamicLookupFunction("eglQueryString") != 0;
+          eglQueryStringInitialized = true;
+        }
+        if (eglQueryStringAvailable) {
+          GLDrawableFactoryImpl factory = getDrawableImpl().getFactoryImpl();
+          factory.lockToolkit();
+          try {
+            String ret = EGL.eglQueryString(drawable.getNativeWindow().getDisplayHandle(), 
+                                            EGL.EGL_EXTENSIONS);
+            if (DEBUG) {
+              System.err.println("!!! EGL extensions: " + ret);
+            }
+            return ret;
+          } finally {
+            factory.unlockToolkit();
+          }
+        } else {
+          return "";
+        }
+    }
+
+    //----------------------------------------------------------------------
+    // Currently unimplemented stuff
+    //
+
+    public void copy(GLContext source, int mask) throws GLException {
+        throw new GLException("Not yet implemented");
+    }
+
+    public void bindPbufferToTexture() {
+        throw new GLException("Should not call this");
+    }
+
+    public void releasePbufferFromTexture() {
+        throw new GLException("Should not call this");
+    }
+
+    public ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3) {
+        throw new GLException("Should not call this");
+    }
+
+    public boolean offscreenImageNeedsVerticalFlip() {
+        throw new GLException("Should not call this");
+    }
+
+    public int getOffscreenContextPixelDataType() {
+        throw new GLException("Should not call this");
+    }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/egl/EGLDrawable.java b/src/jogl/classes/com/sun/opengl/impl/egl/EGLDrawable.java
new file mode 100755
index 000000000..4843bba12
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/egl/EGLDrawable.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.egl;
+
+import com.sun.opengl.impl.GLDrawableImpl;
+import com.sun.nwi.impl.NWReflection;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+
+public class EGLDrawable extends GLDrawableImpl {
+    private NWCapabilitiesChooser chooser;
+    private long display;
+    private EGLConfig config;
+    private long surface;
+    private int[] tmp = new int[1];
+
+    public EGLDrawable(EGLDrawableFactory factory,
+                       NativeWindow component,
+                       NWCapabilities requestedCapabilities,
+                       NWCapabilitiesChooser chooser) throws GLException {
+        super(factory, component, requestedCapabilities, false);
+        this.chooser = chooser;
+        surface=EGL.EGL_NO_SURFACE;
+        display=0;
+        config=null;
+    }
+
+    public long getDisplay() {
+        return display;
+    }
+
+    public EGLConfig getEGLConfig() {
+        return config;
+    }
+
+    public long getSurface() {
+        return surface;
+    }
+
+    protected void setSurface() {
+        if (EGL.EGL_NO_SURFACE==surface) {
+            try {
+                lockSurface();
+                // Create the window surface
+                surface = EGL.eglCreateWindowSurface(display, config.getNativeConfig(), component.getWindowHandle(), null);
+                if (EGL.EGL_NO_SURFACE==surface) {
+                    throw new GLException("Creation of window surface (eglCreateWindowSurface) failed, component: "+component);
+                }
+            } finally {
+              unlockSurface();
+            }
+        }
+    }
+
+    public GLContext createContext(GLContext shareWith) {
+        return new EGLContext(this, shareWith);
+    }
+
+    public void setRealized(boolean realized) {
+        if (realized) {
+            if (NWReflection.instanceOf(component, "com.sun.javafx.newt.kd.KDWindow")) {
+                // KDWindows holds already determined EGL values
+                display = component.getDisplayHandle();
+                if (display==0) {
+                    throw new GLException("KDWindow has null display");
+                }
+                if (display == EGL.EGL_NO_DISPLAY) {
+                    throw new GLException("KDWindow has EGL_NO_DISPLAY");
+                }
+                Long setConfigID = new Long(component.getVisualID());
+                if ( 0 <= setConfigID.longValue() && setConfigID.longValue() <= Integer.MAX_VALUE ) {
+                    config = new EGLConfig(display, setConfigID.intValue());
+                } else {
+                    throw new GLException("KDWindow has invalid visualID/configID");
+                }
+            } else {
+                display = EGL.eglGetDisplay((0!=component.getDisplayHandle())?component.getDisplayHandle():EGL.EGL_DEFAULT_DISPLAY);
+                if (display == EGL.EGL_NO_DISPLAY) {
+                    throw new GLException("eglGetDisplay failed");
+                }
+                if (!EGL.eglInitialize(display, null, null)) {
+                    throw new GLException("eglInitialize failed");
+                }
+                config = new EGLConfig(display, getRequestedNWCapabilities());
+            }
+            setChosenNWCapabilities(config.getCapabilities());
+        } else if (surface != EGL.EGL_NO_SURFACE) {
+            // Destroy the window surface
+            if (!EGL.eglDestroySurface(display, surface)) {
+                throw new GLException("Error destroying window surface (eglDestroySurface)");
+            }
+            surface = EGL.EGL_NO_SURFACE;
+            if (EGL.EGL_NO_DISPLAY!=display) {
+                EGL.eglTerminate(display);
+                display=EGL.EGL_NO_DISPLAY;
+            }
+        }
+        super.setRealized(realized);
+    }
+
+    public void setSize(int width, int height) {
+        // FIXME: anything to do here?
+    }
+
+    public int getWidth() {
+        if (!EGL.eglQuerySurface(display, surface, EGL.EGL_WIDTH, tmp, 0)) {
+            throw new GLException("Error querying surface width");
+        }
+        return tmp[0];
+    }
+
+    public int getHeight() {
+        if (!EGL.eglQuerySurface(display, surface, EGL.EGL_HEIGHT, tmp, 0)) {
+            throw new GLException("Error querying surface height");
+        }
+        return tmp[0];
+    }
+
+    public void swapBuffers() throws GLException {
+        getFactoryImpl().lockToolkit();
+        try {
+          if (component.getSurfaceHandle() == 0) {
+            if (lockSurface() == NativeWindow.LOCK_SURFACE_NOT_READY) {
+              return;
+            }
+          }
+
+          EGL.eglSwapBuffers(display, surface);
+
+        } finally {
+          unlockSurface();
+          getFactoryImpl().unlockToolkit();
+        }
+    }
+
+    public String toString() {
+        return "EGLDrawable[ realized "+getRealized()+
+                           ", window "+getNativeWindow()+
+                           ", egl display " + display +
+                           ", " + config +
+                           ", egl surface " + surface +
+                           ", factory "+getFactory()+"]";
+    }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/egl/EGLDrawableFactory.java b/src/jogl/classes/com/sun/opengl/impl/egl/EGLDrawableFactory.java
new file mode 100755
index 000000000..8af7a3fbf
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/egl/EGLDrawableFactory.java
@@ -0,0 +1,363 @@
+/*
+ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.egl;
+
+import java.util.*;
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.gluegen.runtime.NativeLibrary;
+
+public class EGLDrawableFactory extends GLDrawableFactoryImpl {
+  
+    // We need more than one of these on certain devices (the NVidia APX 2500 in particular)
+    private List/*<NativeLibrary>*/ glesLibraries = new ArrayList();
+
+    public EGLDrawableFactory() {
+        super();
+
+        loadGLESLibrary();
+        EGL.resetProcAddressTable(this);
+    }
+
+    private NativeLibrary loadFirstAvailable(List/*<String>*/ libNames, ClassLoader loader) {
+        for (Iterator iter = libNames.iterator(); iter.hasNext(); ) {
+            NativeLibrary lib = NativeLibrary.open((String) iter.next(), loader);
+            if (lib != null) {
+                return lib;
+            }
+        }
+        return null;
+    }
+
+    private void loadGLESLibrary() {
+        List/*<NativeLibrary>*/ libs = new ArrayList();
+
+        // Try several variants
+        List/*<String>*/ glesLibNames = new ArrayList();
+        List/*<String>*/ eglLibNames = new ArrayList();
+
+        if (GLProfile.isGLES2()) {
+            // Unix
+            glesLibNames.add("libGLES20");
+            glesLibNames.add("libGLESv2");
+            glesLibNames.add("libGLESv2_CM");
+            // Windows
+            glesLibNames.add("GLES20");
+            glesLibNames.add("GLESv2");
+            glesLibNames.add("GLESv2_CM");
+        } else if (GLProfile.isGLES1()) {
+            // Unix
+            glesLibNames.add("libGLES_CM");
+            glesLibNames.add("libGLES_CL");
+            glesLibNames.add("libGLESv1_CM");
+
+            // Windows
+            glesLibNames.add("GLES_CM");
+            glesLibNames.add("GLES_CL");
+            glesLibNames.add("GLESv1_CM");
+        } else {
+            throw new GLException("Invalid GL Profile for EGL: "+GLProfile.getProfile());
+        }
+
+        // EGL Unix
+        eglLibNames.add("libEGL");
+        // EGL Windows
+        eglLibNames.add("EGL");
+
+        ClassLoader loader = getClass().getClassLoader();
+        NativeLibrary lib = loadFirstAvailable(glesLibNames, loader);
+        if (lib == null) {
+            throw new GLException("Unable to dynamically load OpenGL ES library for profile \"" + GLProfile.getProfile() + "\"");
+        }
+        glesLibraries.add(lib);
+        lib = loadFirstAvailable(eglLibNames, loader);
+        if (lib == null) {
+            throw new GLException("Unable to dynamically load EGL library for profile \"" + GLProfile.getProfile() + "\"");
+        }
+        glesLibraries.add(lib);
+        
+        if (GLProfile.isGLES2()) {
+            NativeLibLoader.loadES2();
+        } else if (GLProfile.isGLES1()) {
+            NativeLibLoader.loadES1();
+        }
+    }
+
+    public AbstractGraphicsConfiguration chooseGraphicsConfiguration(NWCapabilities capabilities,
+                                                                     NWCapabilitiesChooser chooser,
+                                                                     AbstractGraphicsDevice device) {
+        return null;
+    }
+
+    public GLDrawable createGLDrawable(NativeWindow target,
+                                    NWCapabilities capabilities,
+                                    NWCapabilitiesChooser chooser) {
+        target = NativeWindowFactory.getNativeWindow(target);
+        return new EGLDrawable(this, target,
+                               capabilities,
+                               chooser);
+    }
+
+    public GLDrawableImpl createOffscreenDrawable(NWCapabilities capabilities,
+                                                  NWCapabilitiesChooser chooser,
+                                                  int width,
+                                                  int height) {
+        throw new GLException("Not yet implemented");
+    }
+
+    public boolean canCreateGLPbuffer() {
+        // Not supported on OpenGL ES
+        return false;
+    }
+    public GLPbuffer createGLPbuffer(final NWCapabilities capabilities,
+                                     final NWCapabilitiesChooser chooser,
+                                     final int initialWidth,
+                                     final int initialHeight,
+                                     final GLContext shareWith) {
+        throw new GLException("Pbuffer support not available on OpenGL ES");
+    }
+
+    public GLContext createExternalGLContext() {
+        return new EGLExternalContext();
+    }
+
+    public boolean canCreateExternalGLDrawable() {
+        return false;
+    }
+
+    public GLDrawable createExternalGLDrawable() {
+        throw new GLException("Not yet implemented");
+    }
+
+    public void loadGLULibrary() {
+    }
+
+    private long dynamicLookupFunctionOnLibs(String glFuncName) {
+        // Look up this function name in all known libraries
+        for (Iterator iter = glesLibraries.iterator(); iter.hasNext(); ) {
+            NativeLibrary lib = (NativeLibrary) iter.next();
+            long addr = lib.lookupFunction(glFuncName);
+            if (addr != 0) {
+                return addr;
+            }
+        }
+
+        return 0;
+    }
+
+    private long eglGetProcAddressHandle = 0;
+
+    public long dynamicLookupFunction(String glFuncName) {
+        if(null==glFuncName) {
+            return 0;
+        }
+
+        // bootstrap eglGetProcAddress
+        if(0==eglGetProcAddressHandle) {
+            eglGetProcAddressHandle = dynamicLookupFunctionOnLibs("eglGetProcAddress");
+            if(0==eglGetProcAddressHandle) {
+                throw new GLException("Couldn't find eglGetProcAddress function entry");
+            }
+        }
+
+        if(glFuncName.equals("eglGetProcAddress")) {
+            return eglGetProcAddressHandle;
+        }
+
+        long addr = EGL.eglGetProcAddress(eglGetProcAddressHandle, glFuncName);
+        if(0==addr) {
+            addr = dynamicLookupFunctionOnLibs(glFuncName);
+        }
+        return addr;
+    }
+
+    public boolean canCreateContextOnJava2DSurface() {
+        return false;
+    }
+
+    /*
+
+    // FIXME: this is the OpenGL ES 2 initialization order
+
+    // Initialize everything
+    public void initialize() throws GLException {
+        System.out.println("EGLDrawableFactory.initEGL()");
+        if (!initEGL()) {
+            throw new GLException("EGL init failed");
+        }
+        System.out.println("EGLDrawableFactory.chooseConfig()");
+        if (!chooseConfig()) {
+            throw new GLException("EGL choose config failed");
+        }
+        System.out.println("EGLDrawableFactory.checkDisplay()");
+        if (!checkDisplay()) {
+            throw new GLException("EGL check display failed");
+        }
+        System.out.println("EGLDrawableFactory.checkConfig()");
+        if (!checkConfig()) {
+            throw new GLException("EGL check config failed");
+        }
+        System.out.println("EGLDrawableFactory.createWindow()");
+        if (!createWindow()) {
+            throw new GLException("KD window init failed");
+        }
+        System.out.println("EGLDrawableFactory.setWindowVisible()");
+        setWindowVisible();
+        System.out.println("EGLDrawableFactory.setWindowFullscreen()");
+        setWindowFullscreen();
+        System.out.println("EGLDrawableFactory.realizeWindow()");
+        if (!realizeWindow()) {
+            throw new GLException("EGL/GLES window realize failed");
+        }
+        System.out.println("EGLDrawableFactory.createSurface()");
+        if (!createSurface()) {
+            throw new GLException("EGL create window surface failed");
+        }
+        System.out.println("EGLDrawableFactory.createContext()");
+        if (!createContext()) {
+            throw new GLException("EGL create context failed");
+        }
+        System.out.println("EGLDrawableFactory.makeCurrent()");
+        if (!makeCurrent()) {
+            throw new GLException("EGL make current failed");
+        }
+        System.out.println("EGLDrawableFactory.updateWindowSize()");
+        updateWindowSize();
+    }
+
+    */
+
+    /*
+
+    // FIXME: this is the OpenGL ES 1 initialization order
+
+    // Initialize everything
+    public void initialize() throws GLException {
+        System.out.println("EGLDrawableFactory.initEGL()");
+        if (!initEGL()) {
+            throw new GLException("EGL init failed");
+        }
+        System.out.println("EGLDrawableFactory.chooseConfig()");
+        if (!chooseConfig()) {
+            throw new GLException("EGL choose config failed");
+        }
+        System.out.println("EGLDrawableFactory.checkDisplay()");
+        if (!checkDisplay()) {
+            throw new GLException("EGL check display failed");
+        }
+        System.out.println("EGLDrawableFactory.checkConfig()");
+        if (!checkConfig()) {
+            throw new GLException("EGL check config failed");
+        }
+        System.out.println("EGLDrawableFactory.createContext()");
+        if (!createContext()) {
+            throw new GLException("EGL create context failed");
+        }
+        //
+        // OpenKODE Core window system initialisation.
+        //
+        System.out.println("EGLDrawableFactory.createWindow()");
+        if (!createWindow()) {
+            throw new GLException("KD window init failed");
+        }
+        //        System.out.println("EGLDrawableFactory.setWindowVisible()");
+        //        setWindowVisible();
+        System.out.println("EGLDrawableFactory.setWindowFullscreen()");
+        setWindowFullscreen();
+        System.out.println("EGLDrawableFactory.realizeWindow()");
+        if (!realizeWindow()) {
+            throw new GLException("EGL/GLES window realize failed");
+        }
+        System.out.println("EGLDrawableFactory.createSurface()");
+        if (!createSurface()) {
+            throw new GLException("EGL create window surface failed");
+        }
+        System.out.println("EGLDrawableFactory.makeCurrent()");
+        if (!makeCurrent()) {
+            throw new GLException("EGL make current failed");
+        }
+        System.out.println("EGLDrawableFactory.updateWindowSize()");
+        updateWindowSize();
+    }
+
+    */
+
+    /*
+
+    // Process incoming events -- must be called every frame
+    public void processEvents() {
+        if (shouldExit()) {
+            shutdown();
+        }
+    }
+
+    public void swapBuffers() {
+        swapBuffers0();
+    }
+
+    private native boolean initEGL();
+    private native boolean chooseConfig();
+    private native boolean checkDisplay();
+    private native boolean checkConfig();
+    private native boolean createWindow();
+    private native void    setWindowVisible();
+    private native void    setWindowFullscreen();
+    private native boolean realizeWindow();
+    private native boolean createSurface();
+    private native boolean createContext();
+    private native boolean makeCurrent();
+    private native void    updateWindowSize();
+    private native void    swapBuffers0();
+
+    // Runs the native message loop one step and checks to see if we should exit
+    private native boolean shouldExit();
+    public native void shutdown();
+
+    public void testGetDirectBufferAddress() {
+        java.nio.FloatBuffer buf = com.sun.opengl.util.BufferUtil.newFloatBuffer(12);
+        int addr = getDirectBufferAddress(buf);
+        System.out.println("Direct FloatBuffer's address: 0x" + Integer.toHexString(addr));
+    }
+    public native int getDirectBufferAddress(java.nio.Buffer buf);
+
+    */
+
+    public GLContext createContextOnJava2DSurface(Object graphics, GLContext shareWith)
+        throws GLException {
+        throw new GLException("Unimplemented on this platform");
+    }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/egl/EGLExternalContext.java b/src/jogl/classes/com/sun/opengl/impl/egl/EGLExternalContext.java
new file mode 100755
index 000000000..6466c767d
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/egl/EGLExternalContext.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.egl;
+
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public class EGLExternalContext extends EGLContext {
+    private boolean firstMakeCurrent = true;
+    private boolean created = true;
+    private GLContext lastContext;
+
+    public EGLExternalContext() {
+        super(null, null);
+        GLContextShareSet.contextCreated(this);
+        resetGLFunctionAvailability();
+    }
+
+    public int makeCurrent() throws GLException {
+        // Save last context if necessary to allow external GLContexts to
+        // talk to other GLContexts created by this library
+        GLContext cur = getCurrent();
+        if (cur != null && cur != this) {
+            lastContext = cur;
+            setCurrent(null);
+        }
+        return super.makeCurrent();
+    }  
+
+    public void release() throws GLException {
+        super.release();
+        setCurrent(lastContext);
+        lastContext = null;
+    }
+
+    protected int makeCurrentImpl() throws GLException {
+        if (firstMakeCurrent) {
+            firstMakeCurrent = false;
+            return CONTEXT_CURRENT_NEW;
+        }
+        return CONTEXT_CURRENT;
+    }
+
+    protected void releaseImpl() throws GLException {
+    }
+
+    protected void destroyImpl() throws GLException {
+        created = false;
+        GLContextShareSet.contextDestroyed(this);
+    }
+
+    public boolean isCreated() {
+        return created;
+    }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/gl2/ProjectDouble.java b/src/jogl/classes/com/sun/opengl/impl/gl2/ProjectDouble.java
new file mode 100755
index 000000000..619c0bee3
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/gl2/ProjectDouble.java
@@ -0,0 +1,1042 @@
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** $Date: 2009-03-13 22:20:29 -0700 (Fri, 13 Mar 2009) $ $Revision: 1867 $
+** $Header$
+*/
+
+/* 
+ * Copyright (c) 2002-2004 LWJGL Project
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are 
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright 
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of 'LWJGL' nor the names of 
+ *   its contributors may be used to endorse or promote products derived 
+ *   from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+package com.sun.opengl.impl.gl2;
+
+import java.nio.*;
+
+import javax.media.opengl.*;
+import javax.media.opengl.util.*;
+import com.sun.opengl.impl.*;
+
+/**
+ * Project.java
+ * <p/>
+ * <p/>
+ * Created 11-jan-2004
+ * 
+ * @author Erik Duijs
+ * @author Kenneth Russell
+ */
+public class ProjectDouble {
+  private static final double[] IDENTITY_MATRIX =
+    new double[] {
+      1.0, 0.0, 0.0, 0.0,
+      0.0, 1.0, 0.0, 0.0,
+      0.0, 0.0, 1.0, 0.0,
+      0.0, 0.0, 0.0, 1.0 };
+
+  // Note that we have cloned parts of the implementation in order to
+  // support incoming Buffers. The reason for this is to avoid loading
+  // non-direct buffer subclasses unnecessarily, because doing so can
+  // cause performance decreases on direct buffer operations, at least
+  // on the current HotSpot JVM. It would be nicer (and make the code
+  // simpler) to simply have the array-based entry points delegate to
+  // the versions taking Buffers by wrapping the arrays.
+
+  // Array-based implementation
+  private final double[] matrix = new double[16];
+
+  private final double[][] tempMatrix = new double[4][4];
+  private final double[] in = new double[4];
+  private final double[] out = new double[4];
+
+  private final double[] forward = new double[3];
+  private final double[] side = new double[3];
+  private final double[] up = new double[3];
+  
+  // Buffer-based implementation
+  private DoubleBuffer locbuf;
+  private final DoubleBuffer matrixBuf;
+
+  private final DoubleBuffer tempMatrixBuf;
+  private final DoubleBuffer inBuf;
+  private final DoubleBuffer outBuf;
+
+  private final DoubleBuffer forwardBuf;
+  private final DoubleBuffer sideBuf;
+  private final DoubleBuffer upBuf;
+
+  public ProjectDouble() {
+    // Use direct buffers to avoid loading indirect buffer
+    // implementations for applications trying to avoid doing so.
+    // Slice up one big buffer because some NIO implementations
+    // allocate a huge amount of memory to back even the smallest of
+    // buffers.
+    DoubleBuffer locbuf = BufferUtil.newDoubleBuffer(128);
+    int pos = 0;
+    int sz = 16;
+    matrixBuf = slice(locbuf, pos, sz);
+    pos += sz;
+    tempMatrixBuf = slice(locbuf, pos, sz);
+    pos += sz;
+    sz = 4;
+    inBuf = slice(locbuf, pos, sz);
+    pos += sz;
+    outBuf = slice(locbuf, pos, sz);
+    pos += sz;
+    sz = 3;
+    forwardBuf = slice(locbuf, pos, sz);
+    pos += sz;
+    sideBuf = slice(locbuf, pos, sz);
+    pos += sz;
+    upBuf = slice(locbuf, pos, sz);
+  }
+
+  public void destroy() {
+    if(locbuf!=null) {
+        locbuf.clear();
+        locbuf=null;
+    }
+  }
+
+  private static DoubleBuffer slice(DoubleBuffer buf, int pos, int len) {
+    buf.position(pos);
+    buf.limit(pos + len);
+    return buf.slice();
+  }
+
+  /**
+   * Make matrix an identity matrix
+   */
+  private void __gluMakeIdentityd(DoubleBuffer m) {
+    int oldPos = m.position();
+    m.put(IDENTITY_MATRIX);
+    m.position(oldPos);
+  }
+
+  /**
+   * Make matrix an identity matrix
+   */
+  private void __gluMakeIdentityd(double[] m) {
+    for (int i = 0; i < 16; i++) {
+      m[i] = IDENTITY_MATRIX[i];
+    }
+  }
+
+  /**
+   * Method __gluMultMatrixVecd
+   * 
+   * @param matrix
+   * @param in
+   * @param out
+   */
+  private void __gluMultMatrixVecd(double[] matrix, int matrix_offset, double[] in, double[] out) {
+    for (int i = 0; i < 4; i++) {
+      out[i] =
+        in[0] * matrix[0*4+i+matrix_offset] +
+        in[1] * matrix[1*4+i+matrix_offset] +
+        in[2] * matrix[2*4+i+matrix_offset] +
+        in[3] * matrix[3*4+i+matrix_offset];
+    }
+  }
+
+  /**
+   * Method __gluMultMatrixVecd
+   * 
+   * @param matrix
+   * @param in
+   * @param out
+   */
+  private void __gluMultMatrixVecd(DoubleBuffer matrix, DoubleBuffer in, DoubleBuffer out) {
+    int inPos = in.position();
+    int outPos = out.position();
+    int matrixPos = matrix.position();
+    for (int i = 0; i < 4; i++) {
+      out.put(i + outPos,
+              in.get(0+inPos) * matrix.get(0*4+i+matrixPos) +
+              in.get(1+inPos) * matrix.get(1*4+i+matrixPos) +
+              in.get(2+inPos) * matrix.get(2*4+i+matrixPos) +
+              in.get(3+inPos) * matrix.get(3*4+i+matrixPos));
+    }
+  }
+
+  /**
+   * @param src
+   * @param inverse
+   * 
+   * @return
+   */
+  private boolean __gluInvertMatrixd(double[] src, double[] inverse) {
+    int i, j, k, swap;
+    double t;
+    double[][] temp = tempMatrix;
+
+    for (i = 0; i < 4; i++) {
+      for (j = 0; j < 4; j++) {
+        temp[i][j] = src[i*4+j];
+      }
+    }
+    __gluMakeIdentityd(inverse);
+
+    for (i = 0; i < 4; i++) {
+      //
+      // Look for largest element in column
+      //
+      swap = i;
+      for (j = i + 1; j < 4; j++) {
+        if (Math.abs(temp[j][i]) > Math.abs(temp[i][i])) {
+          swap = j;
+        }
+      }
+
+      if (swap != i) {
+        //
+        // Swap rows.
+        //
+        for (k = 0; k < 4; k++) {
+          t = temp[i][k];
+          temp[i][k] = temp[swap][k];
+          temp[swap][k] = t;
+
+          t = inverse[i*4+k];
+          inverse[i*4+k] = inverse[swap*4+k];
+          inverse[swap*4+k] = t;
+        }
+      }
+
+      if (temp[i][i] == 0) {
+        //
+        // No non-zero pivot. The matrix is singular, which shouldn't
+        // happen. This means the user gave us a bad matrix.
+        //
+        return false;
+      }
+
+      t = temp[i][i];
+      for (k = 0; k < 4; k++) {
+        temp[i][k] /= t;
+        inverse[i*4+k] /= t;
+      }
+      for (j = 0; j < 4; j++) {
+        if (j != i) {
+          t = temp[j][i];
+          for (k = 0; k < 4; k++) {
+            temp[j][k] -= temp[i][k] * t;
+            inverse[j*4+k] -= inverse[i*4+k]*t;
+          }
+        }
+      }
+    }
+    return true;
+  }
+
+  /**
+   * @param src
+   * @param inverse
+   * 
+   * @return
+   */
+  private boolean __gluInvertMatrixd(DoubleBuffer src, DoubleBuffer inverse) {
+    int i, j, k, swap;
+    double t;
+
+    int srcPos = src.position();
+    int invPos = inverse.position();
+
+    DoubleBuffer temp = tempMatrixBuf;
+
+    for (i = 0; i < 4; i++) {
+      for (j = 0; j < 4; j++) {
+        temp.put(i*4+j, src.get(i*4+j + srcPos));
+      }
+    }
+    __gluMakeIdentityd(inverse);
+
+    for (i = 0; i < 4; i++) {
+      //
+      // Look for largest element in column
+      //
+      swap = i;
+      for (j = i + 1; j < 4; j++) {
+        if (Math.abs(temp.get(j*4+i)) > Math.abs(temp.get(i*4+i))) {
+          swap = j;
+        }
+      }
+
+      if (swap != i) {
+        //
+        // Swap rows.
+        //
+        for (k = 0; k < 4; k++) {
+          t = temp.get(i*4+k);
+          temp.put(i*4+k, temp.get(swap*4+k));
+          temp.put(swap*4+k, t);
+
+          t = inverse.get(i*4+k + invPos);
+          inverse.put(i*4+k + invPos, inverse.get(swap*4+k + invPos));
+          inverse.put(swap*4+k + invPos, t);
+        }
+      }
+
+      if (temp.get(i*4+i) == 0) {
+        //
+        // No non-zero pivot. The matrix is singular, which shouldn't
+        // happen. This means the user gave us a bad matrix.
+        //
+        return false;
+      }
+
+      t = temp.get(i*4+i);
+      for (k = 0; k < 4; k++) {
+        temp.put(i*4+k, temp.get(i*4+k) / t);
+        inverse.put(i*4+k + invPos, inverse.get(i*4+k + invPos) / t);
+      }
+      for (j = 0; j < 4; j++) {
+        if (j != i) {
+          t = temp.get(j*4+i);
+          for (k = 0; k < 4; k++) {
+            temp.put(j*4+k, temp.get(j*4+k) - temp.get(i*4+k) * t);
+            inverse.put(j*4+k + invPos, inverse.get(j*4+k + invPos) - inverse.get(i*4+k + invPos) * t);
+          }
+        }
+      }
+    }
+    return true;
+  }
+
+
+  /**
+   * @param a
+   * @param b
+   * @param r
+   */
+  private void __gluMultMatricesd(double[] a, int a_offset, double[] b, int b_offset, double[] r) {
+    for (int i = 0; i < 4; i++) {
+      for (int j = 0; j < 4; j++) {
+        r[i*4+j] =
+          a[i*4+0+a_offset]*b[0*4+j+b_offset] +
+          a[i*4+1+a_offset]*b[1*4+j+b_offset] +
+          a[i*4+2+a_offset]*b[2*4+j+b_offset] +
+          a[i*4+3+a_offset]*b[3*4+j+b_offset];
+      }
+    }
+  }
+
+
+  /**
+   * @param a
+   * @param b
+   * @param r
+   */
+  private void __gluMultMatricesd(DoubleBuffer a, DoubleBuffer b, DoubleBuffer r) {
+    int aPos = a.position();
+    int bPos = b.position();
+    int rPos = r.position();
+
+    for (int i = 0; i < 4; i++) {
+      for (int j = 0; j < 4; j++) {
+        r.put(i*4+j + rPos,
+          a.get(i*4+0+aPos)*b.get(0*4+j+bPos) +
+          a.get(i*4+1+aPos)*b.get(1*4+j+bPos) +
+          a.get(i*4+2+aPos)*b.get(2*4+j+bPos) +
+          a.get(i*4+3+aPos)*b.get(3*4+j+bPos));
+      }
+    }
+  }
+
+  /**
+   * Normalize vector
+   *
+   * @param v
+   */
+  private static void normalize(double[] v) {
+    double r;
+
+    r = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+    if ( r == 0.0 )
+      return;
+
+    r = 1.0 / r;
+
+    v[0] *= r;
+    v[1] *= r;
+    v[2] *= r;
+
+    return;
+  }
+
+  /**
+   * Normalize vector
+   *
+   * @param v
+   */
+  private static void normalize(DoubleBuffer v) {
+    double r;
+
+    int vPos = v.position();
+
+    r = Math.sqrt(v.get(0+vPos) * v.get(0+vPos) +
+                  v.get(1+vPos) * v.get(1+vPos) +
+                  v.get(2+vPos) * v.get(2+vPos));
+    if ( r == 0.0 )
+      return;
+
+    r = 1.0 / r;
+
+    v.put(0+vPos, v.get(0+vPos) * r);
+    v.put(1+vPos, v.get(1+vPos) * r);
+    v.put(2+vPos, v.get(2+vPos) * r);
+
+    return;
+  }
+
+
+  /**
+   * Calculate cross-product
+   *
+   * @param v1
+   * @param v2
+   * @param result
+   */
+  private static void cross(double[] v1, double[] v2, double[] result) {
+    result[0] = v1[1] * v2[2] - v1[2] * v2[1];
+    result[1] = v1[2] * v2[0] - v1[0] * v2[2];
+    result[2] = v1[0] * v2[1] - v1[1] * v2[0];
+  }
+
+  /**
+   * Calculate cross-product
+   *
+   * @param v1
+   * @param v2
+   * @param result
+   */
+  private static void cross(DoubleBuffer v1, DoubleBuffer v2, DoubleBuffer result) {
+    int v1Pos = v1.position();
+    int v2Pos = v2.position();
+    int rPos  = result.position();
+
+    result.put(0+rPos, v1.get(1+v1Pos) * v2.get(2+v2Pos) - v1.get(2+v1Pos) * v2.get(1+v2Pos));
+    result.put(1+rPos, v1.get(2+v1Pos) * v2.get(0+v2Pos) - v1.get(0+v1Pos) * v2.get(2+v2Pos));
+    result.put(2+rPos, v1.get(0+v1Pos) * v2.get(1+v2Pos) - v1.get(1+v1Pos) * v2.get(0+v2Pos));
+  }
+
+  /**
+   * Method gluOrtho2D.
+   * 
+   * @param left
+   * @param right
+   * @param bottom
+   * @param top
+   */
+  public void gluOrtho2D(GL2 gl, double left, double right, double bottom, double top) {
+    gl.glOrtho(left, right, bottom, top, -1, 1);
+  }
+
+  /**
+   * Method gluPerspective.
+   * 
+   * @param fovy
+   * @param aspect
+   * @param zNear
+   * @param zFar
+   */
+  public void gluPerspective(GL2 gl, double fovy, double aspect, double zNear, double zFar) {
+    double sine, cotangent, deltaZ;
+    double radians = fovy / 2 * Math.PI / 180;
+
+    deltaZ = zFar - zNear;
+    sine = Math.sin(radians);
+
+    if ((deltaZ == 0) || (sine == 0) || (aspect == 0)) {
+      return;
+    }
+
+    cotangent = Math.cos(radians) / sine;
+
+    __gluMakeIdentityd(matrixBuf);
+
+    matrixBuf.put(0 * 4 + 0, cotangent / aspect);
+    matrixBuf.put(1 * 4 + 1, cotangent);
+    matrixBuf.put(2 * 4 + 2, - (zFar + zNear) / deltaZ);
+    matrixBuf.put(2 * 4 + 3, -1);
+    matrixBuf.put(3 * 4 + 2, -2 * zNear * zFar / deltaZ);
+    matrixBuf.put(3 * 4 + 3, 0);
+
+    gl.glMultMatrixd(matrixBuf);
+  }
+
+  /**
+   * Method gluLookAt
+   * 
+   * @param eyex
+   * @param eyey
+   * @param eyez
+   * @param centerx
+   * @param centery
+   * @param centerz
+   * @param upx
+   * @param upy
+   * @param upz
+   */
+  public void gluLookAt(GL2 gl,
+                        double eyex,
+                        double eyey,
+                        double eyez,
+                        double centerx,
+                        double centery,
+                        double centerz,
+                        double upx,
+                        double upy,
+                        double upz) {
+    DoubleBuffer forward = this.forwardBuf;
+    DoubleBuffer side = this.sideBuf;
+    DoubleBuffer up = this.upBuf;
+
+    forward.put(0, centerx - eyex);
+    forward.put(1, centery - eyey);
+    forward.put(2, centerz - eyez);
+
+    up.put(0, upx);
+    up.put(1, upy);
+    up.put(2, upz);
+
+    normalize(forward);
+
+    /* Side = forward x up */
+    cross(forward, up, side);
+    normalize(side);
+
+    /* Recompute up as: up = side x forward */
+    cross(side, forward, up);
+
+    __gluMakeIdentityd(matrixBuf);
+    matrixBuf.put(0 * 4 + 0, side.get(0));
+    matrixBuf.put(1 * 4 + 0, side.get(1));
+    matrixBuf.put(2 * 4 + 0, side.get(2));
+
+    matrixBuf.put(0 * 4 + 1, up.get(0));
+    matrixBuf.put(1 * 4 + 1, up.get(1));
+    matrixBuf.put(2 * 4 + 1, up.get(2));
+
+    matrixBuf.put(0 * 4 + 2, -forward.get(0));
+    matrixBuf.put(1 * 4 + 2, -forward.get(1));
+    matrixBuf.put(2 * 4 + 2, -forward.get(2));
+
+    gl.glMultMatrixd(matrixBuf);
+    gl.glTranslated(-eyex, -eyey, -eyez);
+  }
+
+  /**
+   * Method gluProject
+   * 
+   * @param objx
+   * @param objy
+   * @param objz
+   * @param modelMatrix
+   * @param projMatrix
+   * @param viewport
+   * @param win_pos
+   * 
+   * @return
+   */
+  public boolean gluProject(double objx,
+                            double objy,
+                            double objz,
+                            double[] modelMatrix,
+                            int modelMatrix_offset,
+                            double[] projMatrix,
+                            int projMatrix_offset,
+                            int[] viewport,
+                            int viewport_offset,
+                            double[] win_pos,
+                            int win_pos_offset ) {
+
+    double[] in = this.in;
+    double[] out = this.out;
+
+    in[0] = objx;
+    in[1] = objy;
+    in[2] = objz;
+    in[3] = 1.0;
+
+    __gluMultMatrixVecd(modelMatrix, modelMatrix_offset, in, out);
+    __gluMultMatrixVecd(projMatrix, projMatrix_offset, out, in);
+
+    if (in[3] == 0.0)
+      return false;
+
+    in[3] = (1.0 / in[3]) * 0.5;
+
+    // Map x, y and z to range 0-1
+    in[0] = in[0] * in[3] + 0.5f;
+    in[1] = in[1] * in[3] + 0.5f;
+    in[2] = in[2] * in[3] + 0.5f;
+
+    // Map x,y to viewport
+    win_pos[0+win_pos_offset] = in[0] * viewport[2+viewport_offset] + viewport[0+viewport_offset];
+    win_pos[1+win_pos_offset] = in[1] * viewport[3+viewport_offset] + viewport[1+viewport_offset];
+    win_pos[2+win_pos_offset] = in[2];
+
+    return true;
+  }
+
+  /**
+   * Method gluProject
+   * 
+   * @param objx
+   * @param objy
+   * @param objz
+   * @param modelMatrix
+   * @param projMatrix
+   * @param viewport
+   * @param win_pos
+   * 
+   * @return
+   */
+  public boolean gluProject(double objx,
+                            double objy,
+                            double objz,
+                            DoubleBuffer modelMatrix,
+                            DoubleBuffer projMatrix,
+                            IntBuffer viewport,
+                            DoubleBuffer win_pos) {
+
+    DoubleBuffer in = this.inBuf;
+    DoubleBuffer out = this.outBuf;
+
+    in.put(0, objx);
+    in.put(1, objy);
+    in.put(2, objz);
+    in.put(3, 1.0);
+
+    __gluMultMatrixVecd(modelMatrix, in, out);
+    __gluMultMatrixVecd(projMatrix, out, in);
+
+    if (in.get(3) == 0.0)
+      return false;
+
+    in.put(3, (1.0 / in.get(3)) * 0.5);
+
+    // Map x, y and z to range 0-1
+    in.put(0, in.get(0) * in.get(3) + 0.5f);
+    in.put(1, in.get(1) * in.get(3) + 0.5f);
+    in.put(2, in.get(2) * in.get(3) + 0.5f);
+
+    // Map x,y to viewport
+    int vPos = viewport.position();
+    int wPos = win_pos.position();
+    win_pos.put(0+wPos, in.get(0) * viewport.get(2+vPos) + viewport.get(0+vPos));
+    win_pos.put(1+wPos, in.get(1) * viewport.get(3+vPos) + viewport.get(1+vPos));
+    win_pos.put(2+wPos, in.get(2));
+
+    return true;
+  }
+
+
+  /**
+   * Method gluUnproject
+   * 
+   * @param winx
+   * @param winy
+   * @param winz
+   * @param modelMatrix
+   * @param projMatrix
+   * @param viewport
+   * @param obj_pos
+   * 
+   * @return
+   */
+  public boolean gluUnProject(double winx,
+                              double winy,
+                              double winz,
+                              double[] modelMatrix,
+                              int modelMatrix_offset,
+                              double[] projMatrix,
+                              int projMatrix_offset,
+                              int[] viewport,
+                              int viewport_offset,
+                              double[] obj_pos,
+                              int obj_pos_offset) {
+    double[] in = this.in;
+    double[] out = this.out;
+
+    __gluMultMatricesd(modelMatrix, modelMatrix_offset, projMatrix, projMatrix_offset, matrix);
+
+    if (!__gluInvertMatrixd(matrix, matrix))
+      return false;
+
+    in[0] = winx;
+    in[1] = winy;
+    in[2] = winz;
+    in[3] = 1.0;
+
+    // Map x and y from window coordinates
+    in[0] = (in[0] - viewport[0+viewport_offset]) / viewport[2+viewport_offset];
+    in[1] = (in[1] - viewport[1+viewport_offset]) / viewport[3+viewport_offset];
+
+    // Map to range -1 to 1
+    in[0] = in[0] * 2 - 1;
+    in[1] = in[1] * 2 - 1;
+    in[2] = in[2] * 2 - 1;
+
+    __gluMultMatrixVecd(matrix, 0, in, out);
+
+    if (out[3] == 0.0)
+      return false;
+
+    out[3] = 1.0 / out[3];
+
+    obj_pos[0+obj_pos_offset] = out[0] * out[3];
+    obj_pos[1+obj_pos_offset] = out[1] * out[3];
+    obj_pos[2+obj_pos_offset] = out[2] * out[3];
+
+    return true;
+  }
+
+
+  /**
+   * Method gluUnproject
+   * 
+   * @param winx
+   * @param winy
+   * @param winz
+   * @param modelMatrix
+   * @param projMatrix
+   * @param viewport
+   * @param obj_pos
+   * 
+   * @return
+   */
+  public boolean gluUnProject(double winx,
+                              double winy,
+                              double winz,
+                              DoubleBuffer modelMatrix,
+                              DoubleBuffer projMatrix,
+                              IntBuffer viewport,
+                              DoubleBuffer obj_pos) {
+    DoubleBuffer in = this.inBuf;
+    DoubleBuffer out = this.outBuf;
+
+    __gluMultMatricesd(modelMatrix, projMatrix, matrixBuf);
+
+    if (!__gluInvertMatrixd(matrixBuf, matrixBuf))
+      return false;
+
+    in.put(0, winx);
+    in.put(1, winy);
+    in.put(2, winz);
+    in.put(3, 1.0);
+
+    // Map x and y from window coordinates
+    int vPos = viewport.position();
+    int oPos = obj_pos.position();
+    in.put(0, (in.get(0) - viewport.get(0+vPos)) / viewport.get(2+vPos));
+    in.put(1, (in.get(1) - viewport.get(1+vPos)) / viewport.get(3+vPos));
+
+    // Map to range -1 to 1
+    in.put(0, in.get(0) * 2 - 1);
+    in.put(1, in.get(1) * 2 - 1);
+    in.put(2, in.get(2) * 2 - 1);
+
+    __gluMultMatrixVecd(matrixBuf, in, out);
+
+    if (out.get(3) == 0.0)
+      return false;
+
+    out.put(3, 1.0 / out.get(3));
+
+    obj_pos.put(0+oPos, out.get(0) * out.get(3));
+    obj_pos.put(1+oPos, out.get(1) * out.get(3));
+    obj_pos.put(2+oPos, out.get(2) * out.get(3));
+
+    return true;
+  }
+
+
+  /**
+   * Method gluUnproject4
+   * 
+   * @param winx
+   * @param winy
+   * @param winz
+   * @param clipw
+   * @param modelMatrix
+   * @param projMatrix
+   * @param viewport
+   * @param near
+   * @param far
+   * @param obj_pos
+   * 
+   * @return
+   */
+  public boolean gluUnProject4(double winx,
+                               double winy,
+                               double winz,
+                               double clipw,
+                               double[] modelMatrix,
+                               int modelMatrix_offset,
+                               double[] projMatrix,
+                               int projMatrix_offset,
+                               int[] viewport,
+                               int viewport_offset,
+                               double near,
+                               double far,
+                               double[] obj_pos,
+                               int obj_pos_offset ) {
+    double[] in = this.in;
+    double[] out = this.out;
+
+    __gluMultMatricesd(modelMatrix, modelMatrix_offset, projMatrix, projMatrix_offset, matrix);
+
+    if (!__gluInvertMatrixd(matrix, matrix))
+      return false;
+
+    in[0] = winx;
+    in[1] = winy;
+    in[2] = winz;
+    in[3] = clipw;
+
+    // Map x and y from window coordinates
+    in[0] = (in[0] - viewport[0+viewport_offset]) / viewport[2+viewport_offset];
+    in[1] = (in[1] - viewport[1+viewport_offset]) / viewport[3+viewport_offset];
+    in[2] = (in[2] - near) / (far - near);
+
+    // Map to range -1 to 1
+    in[0] = in[0] * 2 - 1;
+    in[1] = in[1] * 2 - 1;
+    in[2] = in[2] * 2 - 1;
+
+    __gluMultMatrixVecd(matrix, 0, in, out);
+
+    if (out[3] == 0.0)
+      return false;
+
+    obj_pos[0+obj_pos_offset] = out[0];
+    obj_pos[1+obj_pos_offset] = out[1];
+    obj_pos[2+obj_pos_offset] = out[2];
+    obj_pos[3+obj_pos_offset] = out[3];
+    return true;
+  }
+
+  /**
+   * Method gluUnproject4
+   * 
+   * @param winx
+   * @param winy
+   * @param winz
+   * @param clipw
+   * @param modelMatrix
+   * @param projMatrix
+   * @param viewport
+   * @param near
+   * @param far
+   * @param obj_pos
+   * 
+   * @return
+   */
+  public boolean gluUnProject4(double winx,
+                               double winy,
+                               double winz,
+                               double clipw,
+                               DoubleBuffer modelMatrix,
+                               DoubleBuffer projMatrix,
+                               IntBuffer viewport,
+                               double near,
+                               double far,
+                               DoubleBuffer obj_pos) {
+    DoubleBuffer in = this.inBuf;
+    DoubleBuffer out = this.outBuf;
+
+    __gluMultMatricesd(modelMatrix, projMatrix, matrixBuf);
+
+    if (!__gluInvertMatrixd(matrixBuf, matrixBuf))
+      return false;
+
+    in.put(0, winx);
+    in.put(1, winy);
+    in.put(2, winz);
+    in.put(3, clipw);
+
+    // Map x and y from window coordinates
+    int vPos = viewport.position();
+    in.put(0, (in.get(0) - viewport.get(0+vPos)) / viewport.get(2+vPos));
+    in.put(1, (in.get(1) - viewport.get(1+vPos)) / viewport.get(3+vPos));
+    in.put(2, (in.get(2) - near) / (far - near));
+
+    // Map to range -1 to 1
+    in.put(0, in.get(0) * 2 - 1);
+    in.put(1, in.get(1) * 2 - 1);
+    in.put(2, in.get(2) * 2 - 1);
+
+    __gluMultMatrixVecd(matrixBuf, in, out);
+
+    if (out.get(3) == 0.0)
+      return false;
+
+    int oPos = obj_pos.position();
+    obj_pos.put(0+oPos, out.get(0));
+    obj_pos.put(1+oPos, out.get(1));
+    obj_pos.put(2+oPos, out.get(2));
+    obj_pos.put(3+oPos, out.get(3));
+    return true;
+  }
+
+
+  /**
+   * Method gluPickMatrix
+   * 
+   * @param x
+   * @param y
+   * @param deltaX
+   * @param deltaY
+   * @param viewport
+   */
+  public void gluPickMatrix(GL2 gl,
+                            double x,
+                            double y,
+                            double deltaX,
+                            double deltaY,
+                            IntBuffer viewport) {
+    if (deltaX <= 0 || deltaY <= 0) {
+      return;
+    }
+
+    /* Translate and scale the picked region to the entire window */
+    int vPos = viewport.position();
+    gl.glTranslated((viewport.get(2+vPos) - 2 * (x - viewport.get(0+vPos))) / deltaX,
+                    (viewport.get(3+vPos) - 2 * (y - viewport.get(1+vPos))) / deltaY,
+                    0);
+    gl.glScaled(viewport.get(2) / deltaX, viewport.get(3) / deltaY, 1.0);
+  }
+
+  /**
+   * Method gluPickMatrix
+   * 
+   * @param x
+   * @param y
+   * @param deltaX
+   * @param deltaY
+   * @param viewport
+   * @param viewport_offset
+   */
+  public void gluPickMatrix(GL2 gl,
+                            double x,
+                            double y,
+                            double deltaX,
+                            double deltaY,
+                            int[] viewport,
+                            int viewport_offset) {
+    if (deltaX <= 0 || deltaY <= 0) {
+      return;
+    }
+
+    /* Translate and scale the picked region to the entire window */
+    gl.glTranslated((viewport[2+viewport_offset] - 2 * (x - viewport[0+viewport_offset])) / deltaX,
+                    (viewport[3+viewport_offset] - 2 * (y - viewport[1+viewport_offset])) / deltaY,
+                    0);
+    gl.glScaled(viewport[2+viewport_offset] / deltaX, viewport[3+viewport_offset] / deltaY, 1.0);
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/gl2/Util.java b/src/jogl/classes/com/sun/opengl/impl/gl2/Util.java
new file mode 100644
index 000000000..0fc72daa9
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/gl2/Util.java
@@ -0,0 +1,244 @@
+/* 
+ * Copyright (c) 2002-2004 LWJGL Project
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are 
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright 
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of 'LWJGL' nor the names of 
+ *   its contributors may be used to endorse or promote products derived 
+ *   from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+package com.sun.opengl.impl.gl2;
+
+import com.sun.opengl.impl.*;
+
+import java.nio.IntBuffer;
+import javax.media.opengl.*;
+
+/**
+ * Util.java
+ * <p/>
+ * <p/>
+ * Created 7-jan-2004
+ *
+ * @author Erik Duijs
+ */
+class Util {
+
+  /**
+   * temp int[] of one for getting an int from some GL functions
+   */
+  private int[] scratch = new int[1];
+
+  /**
+   * Return ceiling of integer division
+   *
+   * @param a
+   * @param b
+   *
+   * @return int
+   */
+  protected static int ceil(int a, int b) {
+    return (a % b == 0 ? a / b : a / b + 1);
+  }
+
+  /**
+   * Method compPerPix.
+   *
+   * @param format
+   *
+   * @return int
+   */
+  protected static int compPerPix(int format) {
+    /* Determine number of components per pixel */
+    switch ( format ) {
+    case GL2.GL_COLOR_INDEX:
+    case GL2.GL_STENCIL_INDEX:
+    case GL2.GL_DEPTH_COMPONENT:
+    case GL2.GL_RED:
+    case GL2.GL_GREEN:
+    case GL2.GL_BLUE:
+    case GL2.GL_ALPHA:
+    case GL2.GL_LUMINANCE:
+      return 1;
+    case GL2.GL_LUMINANCE_ALPHA:
+      return 2;
+    case GL2.GL_RGB:
+    case GL2.GL_BGR:
+      return 3;
+    case GL2.GL_RGBA:
+    case GL2.GL_BGRA:
+      return 4;
+    default :
+      return -1;
+    }
+  }
+
+  /**
+   * Method nearestPower.
+   * <p/>
+   * Compute the nearest power of 2 number.  This algorithm is a little strange, but it works quite well.
+   *
+   * @param value
+   *
+   * @return int
+   */
+  protected static int nearestPower(int value) {
+    int i;
+
+    i = 1;
+
+    /* Error! */
+    if ( value == 0 )
+      return -1;
+
+    for ( ; ; ) {
+      if ( value == 1 ) {
+        return i;
+      } else if ( value == 3 ) {
+        return i << 2;
+      }
+      value >>= 1;
+      i <<= 1;
+    }
+  }
+
+  /**
+   * Method bytesPerPixel.
+   *
+   * @param format
+   * @param type
+   *
+   * @return int
+   */
+  protected static int bytesPerPixel(int format, int type) {
+    int n, m;
+
+    switch ( format ) {
+    case GL2.GL_COLOR_INDEX:
+    case GL2.GL_STENCIL_INDEX:
+    case GL2.GL_DEPTH_COMPONENT:
+    case GL2.GL_RED:
+    case GL2.GL_GREEN:
+    case GL2.GL_BLUE:
+    case GL2.GL_ALPHA:
+    case GL2.GL_LUMINANCE:
+      n = 1;
+      break;
+    case GL2.GL_LUMINANCE_ALPHA:
+      n = 2;
+      break;
+    case GL2.GL_RGB:
+    case GL2.GL_BGR:
+      n = 3;
+      break;
+    case GL2.GL_RGBA:
+    case GL2.GL_BGRA:
+      n = 4;
+      break;
+    default :
+      n = 0;
+    }
+
+    switch ( type ) {
+    case GL2.GL_UNSIGNED_BYTE:
+      m = 1;
+      break;
+    case GL2.GL_BYTE:
+      m = 1;
+      break;
+    case GL2.GL_BITMAP:
+      m = 1;
+      break;
+    case GL2.GL_UNSIGNED_SHORT:
+      m = 2;
+      break;
+    case GL2.GL_SHORT:
+      m = 2;
+      break;
+    case GL2.GL_UNSIGNED_INT:
+      m = 4;
+      break;
+    case GL2.GL_INT:
+      m = 4;
+      break;
+    case GL2.GL_FLOAT:
+      m = 4;
+      break;
+    default :
+      m = 0;
+    }
+
+    return n * m;
+  }
+
+  /**
+   * Convenience method for returning an int, rather than getting it out of a buffer yourself.
+   *
+   * @param what
+   *
+   * @return int
+   */
+  protected int glGetIntegerv(GL gl, int what) {
+    gl.glGetIntegerv(what, scratch, 0);
+    return scratch[0];
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/gl2/fixme/GLObjectTracker.java b/src/jogl/classes/com/sun/opengl/impl/gl2/fixme/GLObjectTracker.java
new file mode 100755
index 000000000..885f3cb28
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/gl2/fixme/GLObjectTracker.java
@@ -0,0 +1,835 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.gl2;
+
+import com.sun.opengl.impl.*;
+
+import java.nio.*;
+import javax.media.opengl.*;
+
+/** 
+ * Tracks the creation of server-side OpenGL objects which can be
+ * shared between contexts. Ordinarily, when an OpenGL context is
+ * deleted and no other contexts are sharing server-side objects with
+ * it, all of the server-side objects are automatically deleted by the
+ * OpenGL implementation. It is not necessary for the end user to
+ * explicitly delete these objects. However, when the Java2D/OpenGL
+ * pipeline is active and frame buffer objects are being used for
+ * rendering, it is necessary for all OpenGL contexts created by JOGL
+ * to share server-side objects with the Java2D OpenGL context. This
+ * means that these objects "leak" into the namespace used by Java2D.
+ * In order to prevent memory leaks and to present the same
+ * programming model to the end user, it is necessary to track the
+ * creation and destruction of all of these server-side OpenGL objects
+ * and to explicitly release them when all of the JOGL-created
+ * contexts which can see them have been released. <P>
+ *
+ * The {@link #ref ref} and {@link #unref unref} methods should be
+ * used during the creation and destruction of OpenGL contexts by JOGL
+ * in order to update the liveness of the objects being tracked. The
+ * various other methods should be called by the OpenGL binding in the
+ * various named methods.
+ */
+
+public class GLObjectTracker {
+  private static final boolean DEBUG = Debug.debug("GLObjectTracker");
+
+  //----------------------------------------------------------------------
+  // Adders
+  //
+
+  // glGenBuffers
+  public synchronized void addBuffers(int n, IntBuffer ids) {
+    add(getList(BUFFERS), n, ids);
+  }
+
+  // glGenBuffers
+  public synchronized void addBuffers(int n, int[] ids, int ids_offset) {
+    add(getList(BUFFERS), n, ids, ids_offset);
+  }
+
+  // glGenBuffersARB
+  public synchronized void addBuffersARB(int n, IntBuffer ids) {
+    add(getList(BUFFERS_ARB), n, ids);
+  }
+
+  // glGenBuffersARB
+  public synchronized void addBuffersARB(int n, int[] ids, int ids_offset) {
+    add(getList(BUFFERS_ARB), n, ids, ids_offset);
+  }
+
+  // glGenFencesAPPLE
+  public synchronized void addFencesAPPLE(int n, IntBuffer ids) {
+    add(getList(FENCES_APPLE), n, ids);
+  }
+
+  // glGenFencesAPPLE
+  public synchronized void addFencesAPPLE(int n, int[] ids, int ids_offset) {
+    add(getList(FENCES_APPLE), n, ids, ids_offset);
+  }
+
+  // glGenFencesNV
+  public synchronized void addFencesNV(int n, IntBuffer ids) {
+    add(getList(FENCES_NV), n, ids);
+  }
+
+  // glGenFencesNV
+  public synchronized void addFencesNV(int n, int[] ids, int ids_offset) {
+    add(getList(FENCES_NV), n, ids, ids_offset);
+  }
+
+  // glGenFragmentShadersATI
+  public synchronized void addFragmentShadersATI(int start, int n) {
+    add(getList(FRAGMENT_SHADERS_ATI), start, n);
+  }
+
+  // glGenFramebuffersEXT
+  public synchronized void addFramebuffersEXT(int n, IntBuffer ids) {
+    add(getList(FRAMEBUFFERS_EXT), n, ids);
+  }
+
+  // glGenFramebuffersEXT
+  public synchronized void addFramebuffersEXT(int n, int[] ids, int ids_offset) {
+    add(getList(FRAMEBUFFERS_EXT), n, ids, ids_offset);
+  }
+  
+  // glGenLists
+  public synchronized void addLists(int start, int n) {
+    add(getList(LISTS), start, n);
+  }
+
+  // glGenOcclusionQueriesNV
+  public synchronized void addOcclusionQueriesNV(int n, IntBuffer ids) {
+    add(getList(OCCLUSION_QUERIES_NV), n, ids);
+  }
+
+  // glGenOcclusionQueriesNV
+  public synchronized void addOcclusionQueriesNV(int n, int[] ids, int ids_offset) {
+    add(getList(OCCLUSION_QUERIES_NV), n, ids, ids_offset);
+  }
+
+  // glCreateProgram
+  public synchronized void addProgramObject(int obj) {
+    add(getList(PROGRAM_OBJECTS), obj, 1);
+  }
+
+  // glCreateProgramObjectARB
+  public synchronized void addProgramObjectARB(int obj) {
+    add(getList(PROGRAM_AND_SHADER_OBJECTS_ARB), obj, 1);
+  }
+
+  // glGenProgramsARB
+  public synchronized void addProgramsARB(int n, IntBuffer ids) {
+    add(getList(PROGRAMS_ARB), n, ids);
+  }
+
+  // glGenProgramsARB
+  public synchronized void addProgramsARB(int n, int[] ids, int ids_offset) {
+    add(getList(PROGRAMS_ARB), n, ids, ids_offset);
+  }
+
+  // glGenProgramsNV
+  public synchronized void addProgramsNV(int n, IntBuffer ids) {
+    add(getList(PROGRAMS_NV), n, ids);
+  }
+
+  // glGenProgramsNV
+  public synchronized void addProgramsNV(int n, int[] ids, int ids_offset) {
+    add(getList(PROGRAMS_NV), n, ids, ids_offset);
+  }
+
+  // glGenQueries
+  public synchronized void addQueries(int n, IntBuffer ids) {
+    add(getList(QUERIES), n, ids);
+  }
+
+  // glGenQueries
+  public synchronized void addQueries(int n, int[] ids, int ids_offset) {
+    add(getList(QUERIES), n, ids, ids_offset);
+  }
+
+  // glGenQueriesARB
+  public synchronized void addQueriesARB(int n, IntBuffer ids) {
+    add(getList(QUERIES_ARB), n, ids);
+  }
+
+  // glGenQueriesARB
+  public synchronized void addQueriesARB(int n, int[] ids, int ids_offset) {
+    add(getList(QUERIES_ARB), n, ids, ids_offset);
+  }
+
+  // glGenRenderbuffersEXT
+  public synchronized void addRenderbuffersEXT(int n, IntBuffer ids) {
+    add(getList(RENDERBUFFERS_EXT), n, ids);
+  }
+
+  // glGenRenderbuffersEXT
+  public synchronized void addRenderbuffersEXT(int n, int[] ids, int ids_offset) {
+    add(getList(RENDERBUFFERS_EXT), n, ids, ids_offset);
+  }
+
+  // glCreateShader
+  public synchronized void addShaderObject(int obj) {
+    add(getList(SHADER_OBJECTS), obj, 1);
+  }
+
+  // glCreateShaderObjectARB
+  public synchronized void addShaderObjectARB(int obj) {
+    add(getList(PROGRAM_AND_SHADER_OBJECTS_ARB), obj, 1);
+  }
+
+  // glGenTextures
+  public synchronized void addTextures(int n, IntBuffer ids) {
+    add(getList(TEXTURES), n, ids);
+  }
+
+  // glGenTextures
+  public synchronized void addTextures(int n, int[] ids, int ids_offset) {
+    add(getList(TEXTURES), n, ids, ids_offset);
+  }
+
+  // glGenVertexArraysAPPLE
+  public synchronized void addVertexArraysAPPLE(int n, IntBuffer ids) {
+    add(getList(VERTEX_ARRAYS_APPLE), n, ids);
+  }
+
+  // glGenVertexArraysAPPLE
+  public synchronized void addVertexArraysAPPLE(int n, int[] ids, int ids_offset) {
+    add(getList(VERTEX_ARRAYS_APPLE), n, ids, ids_offset);
+  }
+
+  // glGenVertexShadersEXT
+  public synchronized void addVertexShadersEXT(int start, int n) {
+    add(getList(VERTEX_SHADERS_EXT), start, n);
+  }
+
+  //----------------------------------------------------------------------
+  // Removers
+  //
+
+  // glDeleteBuffers
+  public synchronized void removeBuffers(int n, IntBuffer ids) {
+    remove(getList(BUFFERS), n, ids);
+  }
+
+  // glDeleteBuffers
+  public synchronized void removeBuffers(int n, int[] ids, int ids_offset) {
+    remove(getList(BUFFERS), n, ids, ids_offset);
+  }
+
+  // glDeleteBuffersARB
+  public synchronized void removeBuffersARB(int n, IntBuffer ids) {
+    remove(getList(BUFFERS_ARB), n, ids);
+  }
+
+  // glDeleteBuffersARB
+  public synchronized void removeBuffersARB(int n, int[] ids, int ids_offset) {
+    remove(getList(BUFFERS_ARB), n, ids, ids_offset);
+  }
+
+  // glDeleteFencesAPPLE
+  public synchronized void removeFencesAPPLE(int n, IntBuffer ids) {
+    remove(getList(FENCES_APPLE), n, ids);
+  }
+
+  // glDeleteFencesAPPLE
+  public synchronized void removeFencesAPPLE(int n, int[] ids, int ids_offset) {
+    remove(getList(FENCES_APPLE), n, ids, ids_offset);
+  }
+
+  // glDeleteFencesNV
+  public synchronized void removeFencesNV(int n, IntBuffer ids) {
+    remove(getList(FENCES_NV), n, ids);
+  }
+
+  // glDeleteFencesNV
+  public synchronized void removeFencesNV(int n, int[] ids, int ids_offset) {
+    remove(getList(FENCES_NV), n, ids, ids_offset);
+  }
+
+  // glDeleteFragmentShaderATI
+  public synchronized void removeFragmentShaderATI(int obj) {
+    remove(getList(FRAGMENT_SHADERS_ATI), obj, 1);
+  }
+
+  // glDeleteFramebuffersEXT
+  public synchronized void removeFramebuffersEXT(int n, IntBuffer ids) {
+    remove(getList(FRAMEBUFFERS_EXT), n, ids);
+  }
+
+  // glDeleteFramebuffersEXT
+  public synchronized void removeFramebuffersEXT(int n, int[] ids, int ids_offset) {
+    remove(getList(FRAMEBUFFERS_EXT), n, ids, ids_offset);
+  }
+  
+  // glDeleteLists
+  public synchronized void removeLists(int start, int n) {
+    remove(getList(LISTS), start, n);
+  }
+
+  // glDeleteOcclusionQueriesNV
+  public synchronized void removeOcclusionQueriesNV(int n, IntBuffer ids) {
+    remove(getList(OCCLUSION_QUERIES_NV), n, ids);
+  }
+
+  // glDeleteOcclusionQueriesNV
+  public synchronized void removeOcclusionQueriesNV(int n, int[] ids, int ids_offset) {
+    remove(getList(OCCLUSION_QUERIES_NV), n, ids, ids_offset);
+  }
+
+  // glDeleteProgram
+  public synchronized void removeProgramObject(int obj) {
+    remove(getList(PROGRAM_OBJECTS), obj, 1);
+  }
+
+  // glDeleteObjectARB
+  public synchronized void removeProgramOrShaderObjectARB(int obj) {
+    remove(getList(PROGRAM_AND_SHADER_OBJECTS_ARB), obj, 1);
+  }
+
+  // glDeleteProgramsARB
+  public synchronized void removeProgramsARB(int n, IntBuffer ids) {
+    remove(getList(PROGRAMS_ARB), n, ids);
+  }
+
+  // glDeleteProgramsARB
+  public synchronized void removeProgramsARB(int n, int[] ids, int ids_offset) {
+    remove(getList(PROGRAMS_ARB), n, ids, ids_offset);
+  }
+
+  // glDeleteProgramsNV
+  public synchronized void removeProgramsNV(int n, IntBuffer ids) {
+    remove(getList(PROGRAMS_NV), n, ids);
+  }
+
+  // glDeleteProgramsNV
+  public synchronized void removeProgramsNV(int n, int[] ids, int ids_offset) {
+    remove(getList(PROGRAMS_NV), n, ids, ids_offset);
+  }
+
+  // glDeleteQueries
+  public synchronized void removeQueries(int n, IntBuffer ids) {
+    remove(getList(QUERIES), n, ids);
+  }
+
+  // glDeleteQueries
+  public synchronized void removeQueries(int n, int[] ids, int ids_offset) {
+    remove(getList(QUERIES), n, ids, ids_offset);
+  }
+
+  // glDeleteQueriesARB
+  public synchronized void removeQueriesARB(int n, IntBuffer ids) {
+    remove(getList(QUERIES_ARB), n, ids);
+  }
+
+  // glDeleteQueriesARB
+  public synchronized void removeQueriesARB(int n, int[] ids, int ids_offset) {
+    remove(getList(QUERIES_ARB), n, ids, ids_offset);
+  }
+
+  // glDeleteRenderbuffersEXT
+  public synchronized void removeRenderbuffersEXT(int n, IntBuffer ids) {
+    remove(getList(RENDERBUFFERS_EXT), n, ids);
+  }
+
+  // glDeleteRenderbuffersEXT
+  public synchronized void removeRenderbuffersEXT(int n, int[] ids, int ids_offset) {
+    remove(getList(RENDERBUFFERS_EXT), n, ids, ids_offset);
+  }
+
+  // glDeleteShader
+  public synchronized void removeShaderObject(int obj) {
+    remove(getList(SHADER_OBJECTS), obj, 1);
+  }
+
+  // glDeleteTextures
+  public synchronized void removeTextures(int n, IntBuffer ids) {
+    remove(getList(TEXTURES), n, ids);
+  }
+
+  // glDeleteTextures
+  public synchronized void removeTextures(int n, int[] ids, int ids_offset) {
+    remove(getList(TEXTURES), n, ids, ids_offset);
+  }
+
+  // glDeleteVertexArraysAPPLE
+  public synchronized void removeVertexArraysAPPLE(int n, IntBuffer ids) {
+    remove(getList(VERTEX_ARRAYS_APPLE), n, ids);
+  }
+
+  // glDeleteVertexArraysAPPLE
+  public synchronized void removeVertexArraysAPPLE(int n, int[] ids, int ids_offset) {
+    remove(getList(VERTEX_ARRAYS_APPLE), n, ids, ids_offset);
+  }
+
+  // glDeleteVertexShaderEXT
+  public synchronized void removeVertexShaderEXT(int obj) {
+    remove(getList(VERTEX_SHADERS_EXT), obj, 1);
+  }
+
+  //----------------------------------------------------------------------
+  // Reference count maintenance and manual deletion
+  //
+
+  public synchronized void transferAll(GLObjectTracker other) {
+    for (int i = 0; i < lists.length; i++) {
+      getList(i).addAll(other.lists[i]);
+      if (other.lists[i] != null) {
+        other.lists[i].clear();
+      }
+    }
+    dirty = true;
+  }
+
+  public synchronized void ref() {
+    ++refCount;
+  }
+
+  public void unref(GLObjectTracker deletedObjectPool) {
+    boolean tryDelete = false;
+    synchronized (this) {
+      if (--refCount == 0) {
+        tryDelete = true;
+      }
+    }
+    if (tryDelete) {
+      // See whether we should try to do the work now or whether we
+      // have to postpone
+      GLContext cur = GLContext.getCurrent();
+      if ((cur != null) &&
+          (cur instanceof GLContextImpl)) {
+        GLContextImpl curImpl = (GLContextImpl) cur;
+        if (deletedObjectPool != null &&
+            deletedObjectPool == curImpl.getDeletedObjectTracker()) {
+          // Should be safe to delete these objects now
+          try {
+            delete((GL2)curImpl.getGL());
+            return;
+          } catch (GLException e) {
+            // Shouldn't happen, but if it does, transfer all objects
+            // to the deleted object pool hoping we can later clean
+            // them up
+            deletedObjectPool.transferAll(this);
+            throw(e);
+          }
+        }
+      }
+      // If we get here, we couldn't attempt to delete the objects
+      // right now; instead try to transfer them to the
+      // deletedObjectPool for later cleanup (FIXME: should consider
+      // throwing an exception if deletedObjectPool is null, since
+      // that shouldn't happen)
+      if (DEBUG) {
+        String s = null;
+        if (cur == null) {
+          s = "current context was null";
+        } else if (!(cur instanceof GLContextImpl)) {
+          s = "current context was not a GLContextImpl";
+        } else if (deletedObjectPool == null) {
+          s = "no current deletedObjectPool";
+        } else if (deletedObjectPool != ((GLContextImpl) cur).getDeletedObjectTracker()) {
+          s = "deletedObjectTracker didn't match";
+          if (((GLContextImpl) cur).getDeletedObjectTracker() == null) {
+            s += " (other was null)";
+          }
+        } else {
+          s = "unknown reason";
+        }
+        System.err.println("Deferred destruction of server-side OpenGL objects into " + deletedObjectPool + ": " + s);
+      }
+
+      if (deletedObjectPool != null) {
+        deletedObjectPool.transferAll(this);
+      }
+    }
+  }
+
+  public void clean(GL2 gl) {
+    if (dirty) {
+      try {
+        delete(gl);
+        dirty = false;
+      } catch (GLException e) {
+        // FIXME: not sure what to do here; probably a bad idea to be
+        // throwing exceptions during an otherwise-successful makeCurrent
+      }
+    }
+  }
+
+
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+
+  // Kinds of sharable server-side OpenGL objects this class tracks
+  private static final int BUFFERS                        = 0;
+  private static final int BUFFERS_ARB                    = 1;
+  private static final int FENCES_APPLE                   = 2;
+  private static final int FENCES_NV                      = 3;
+  private static final int FRAGMENT_SHADERS_ATI           = 4;
+  private static final int FRAMEBUFFERS_EXT               = 5;
+  private static final int LISTS                          = 6;
+  private static final int OCCLUSION_QUERIES_NV           = 7;
+  private static final int PROGRAM_AND_SHADER_OBJECTS_ARB = 8;
+  private static final int PROGRAM_OBJECTS                = 9;
+  private static final int PROGRAMS_ARB                   = 10;
+  private static final int PROGRAMS_NV                    = 11;
+  private static final int QUERIES                        = 12;
+  private static final int QUERIES_ARB                    = 13;
+  private static final int RENDERBUFFERS_EXT              = 14;
+  private static final int SHADER_OBJECTS                 = 15;
+  private static final int TEXTURES                       = 16;
+  private static final int VERTEX_ARRAYS_APPLE            = 17;
+  private static final int VERTEX_SHADERS_EXT             = 18;
+  private static final int NUM_OBJECT_TYPES               = 19;
+
+  static abstract class Deleter {
+    public abstract void delete(GL2 gl, int obj);
+  }
+
+  static class ObjectList {
+    private static final int MIN_CAPACITY = 4;
+
+    private int size;
+    private int capacity;
+    private int[] data;
+    private Deleter deleter;
+    private String name;
+
+    public ObjectList(Deleter deleter) {
+      this.deleter = deleter;
+      clear();
+    }
+
+    public void add(int obj) {
+      if (size == capacity) {
+        int newCapacity = 2 * capacity;
+        int[] newData = new int[newCapacity];
+        System.arraycopy(data, 0, newData, 0, size);
+        data = newData;
+        capacity = newCapacity;
+      }
+
+      data[size++] = obj;
+    }
+
+    public void addAll(ObjectList other) {
+      if (other == null) {
+        return;
+      }
+      for (int i = 0; i < other.size; i++) {
+        add(other.data[i]);
+      }
+    }
+
+    public boolean remove(int value) {
+      for (int i = 0; i < size; i++) {
+        if (data[i] == value) {
+          if (i < size - 1) {
+            System.arraycopy(data, i+1, data, i, size - i - 1);
+          }
+          --size;
+          if ((size < capacity / 4) &&
+              (capacity > MIN_CAPACITY)) {
+            int newCapacity = capacity / 4;
+            if (newCapacity < MIN_CAPACITY) {
+              newCapacity = MIN_CAPACITY;
+            }
+            int[] newData = new int[newCapacity];
+            System.arraycopy(data, 0, newData, 0, size);
+            data = newData;
+            capacity = newCapacity;
+          }
+          return true;
+        }
+      }
+      return false;
+    }
+
+    public void setName(String name) {
+      if (DEBUG) {
+        this.name = name;
+      }
+    }
+
+    public void delete(GL2 gl) {
+      // Just in case we start throwing exceptions during deletion,
+      // make sure we make progress rather than going into an infinite
+      // loop
+      while (size > 0) {
+        int obj = data[size - 1];
+        --size;
+        if (DEBUG) {
+          System.err.println("Deleting server-side OpenGL object " + obj +
+                             ((name != null) ? (" (" + name + ")") : ""));
+        }
+        deleter.delete(gl, obj);
+      }
+    }
+
+    public void clear() {
+      size = 0;
+      capacity = MIN_CAPACITY;
+      data = new int[capacity];
+    }
+  }
+
+  private ObjectList[] lists = new ObjectList[NUM_OBJECT_TYPES];
+  private int refCount;
+  private boolean dirty;
+
+  private void add(ObjectList list, int n, IntBuffer ids) {
+    int pos = ids.position();
+    for (int i = 0; i < n; i++) {
+      list.add(ids.get(pos + i));
+    }
+  }
+
+  private void add(ObjectList list, int n, int[] ids, int ids_offset) {
+    for (int i = 0; i < n; i++) {
+      list.add(ids[i + ids_offset]);
+    }
+  }
+
+  private void add(ObjectList list, int start, int n) {
+    for (int i = 0; i < n; i++) {
+      list.add(start + i);
+    }
+  }
+
+  private void remove(ObjectList list, int n, IntBuffer ids) {
+    int pos = ids.position();
+    for (int i = 0; i < n; i++) {
+      list.remove(ids.get(pos + i));
+    }
+  }
+
+  private void remove(ObjectList list, int n, int[] ids, int ids_offset) {
+    for (int i = 0; i < n; i++) {
+      list.remove(ids[i + ids_offset]);
+    }
+  }
+
+  private void remove(ObjectList list, int start, int n) {
+    for (int i = 0; i < n; i++) {
+      list.remove(start + i);
+    }
+  }
+
+  private ObjectList getList(int which) {
+    ObjectList list = lists[which];
+    if (list == null) {
+      Deleter deleter = null;
+      String name = null;
+      // Figure out which deleter we need
+      switch (which) {
+        case BUFFERS:
+          deleter = new Deleter() {
+              public void delete(GL2 gl, int obj) {
+                gl.glDeleteBuffers(1, new int[] { obj }, 0);
+              }
+            };
+          name = "buffer";
+          break;
+        case BUFFERS_ARB:
+          deleter = new Deleter() {
+              public void delete(GL2 gl, int obj) {
+                gl.glDeleteBuffersARB(1, new int[] { obj }, 0);
+              }
+            };
+          name = "ARB buffer";
+          break;
+        case FENCES_APPLE:
+          deleter = new Deleter() {
+              public void delete(GL2 gl, int obj) {
+                gl.glDeleteFencesAPPLE(1, new int[] { obj }, 0);
+              }
+            };
+          name = "APPLE fence";
+          break;
+        case FENCES_NV:
+          deleter = new Deleter() {
+              public void delete(GL2 gl, int obj) {
+                gl.glDeleteFencesNV(1, new int[] { obj }, 0);
+              }
+            };
+          name = "NV fence";
+          break;
+        case FRAGMENT_SHADERS_ATI:
+          deleter = new Deleter() {
+              public void delete(GL2 gl, int obj) {
+                gl.glDeleteFragmentShaderATI(obj);
+              }
+            };
+          name = "ATI fragment shader";
+          break;
+        case FRAMEBUFFERS_EXT:
+          deleter = new Deleter() {
+              public void delete(GL2 gl, int obj) {
+                gl.glDeleteFramebuffersEXT(1, new int[] { obj }, 0);
+              }
+            };
+          name = "EXT framebuffer";
+          break;
+        case LISTS:
+          deleter = new Deleter() {
+              public void delete(GL2 gl, int obj) {
+                gl.glDeleteLists(obj, 1);
+              }
+            };
+          name = "display list";
+          break;
+        case OCCLUSION_QUERIES_NV:
+          deleter = new Deleter() {
+              public void delete(GL2 gl, int obj) {
+                gl.glDeleteOcclusionQueriesNV(1, new int[] { obj }, 0);
+              }
+            };
+          name = "NV occlusion query";
+          break;
+        case PROGRAM_AND_SHADER_OBJECTS_ARB:
+          deleter = new Deleter() {
+              public void delete(GL2 gl, int obj) {
+                gl.glDeleteObjectARB(obj);
+              }
+            };
+          name = "ARB program or shader object";
+          break;
+        case PROGRAM_OBJECTS:
+          deleter = new Deleter() {
+              public void delete(GL2 gl, int obj) {
+                gl.glDeleteProgram(obj);
+              }
+            };
+          name = "program object";
+          break;
+        case PROGRAMS_ARB:
+          deleter = new Deleter() {
+              public void delete(GL2 gl, int obj) {
+                gl.glDeleteProgramsARB(1, new int[] { obj }, 0);
+              }
+            };
+          name = "ARB program object";
+          break;
+        case PROGRAMS_NV:
+          deleter = new Deleter() {
+              public void delete(GL2 gl, int obj) {
+                gl.glDeleteProgramsNV(1, new int[] { obj }, 0);
+              }
+            };
+          name = "NV program";
+          break;
+        case QUERIES:
+          deleter = new Deleter() {
+              public void delete(GL2 gl, int obj) {
+                gl.glDeleteQueries(1, new int[] { obj }, 0);
+              }
+            };
+          name = "query";
+          break;
+        case QUERIES_ARB:
+          deleter = new Deleter() {
+              public void delete(GL2 gl, int obj) {
+                gl.glDeleteQueriesARB(1, new int[] { obj }, 0);
+              }
+            };
+          name = "ARB query";
+          break;
+        case RENDERBUFFERS_EXT:
+          deleter = new Deleter() {
+              public void delete(GL2 gl, int obj) {
+                gl.glDeleteRenderbuffersEXT(1, new int[] { obj }, 0);
+              }
+            };
+          name = "EXT renderbuffer";
+          break;
+        case SHADER_OBJECTS:
+          deleter = new Deleter() {
+              public void delete(GL2 gl, int obj) {
+                gl.glDeleteShader(obj);
+              }
+            };
+          name = "shader object";
+          break;
+        case TEXTURES:
+          deleter = new Deleter() {
+              public void delete(GL2 gl, int obj) {
+                gl.glDeleteTextures(1, new int[] { obj }, 0);
+              }
+            };
+          name = "texture";
+          break;
+        case VERTEX_ARRAYS_APPLE:
+          deleter = new Deleter() {
+              public void delete(GL2 gl, int obj) {
+                gl.glDeleteVertexArraysAPPLE(1, new int[] { obj }, 0);
+              }
+            };
+          name = "APPLE vertex array";
+          break;
+        case VERTEX_SHADERS_EXT:
+          deleter = new Deleter() {
+              public void delete(GL2 gl, int obj) {
+                gl.glDeleteVertexShaderEXT(obj);
+              }
+            };
+          name = "EXT vertex shader";
+          break;
+        default:
+          throw new InternalError("Unexpected OpenGL object type " + which);
+      }
+
+      list = new ObjectList(deleter);
+      list.setName(name);
+      lists[which] = list;
+    }
+    return list;
+  }
+
+  private void delete(GL2 gl) {
+    for (int i = 0; i < lists.length; i++) {
+      ObjectList list = lists[i];
+      if (list != null) {
+        list.delete(gl);
+        lists[i] = null;
+      }
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glsl/GLSLArrayHandler.java b/src/jogl/classes/com/sun/opengl/impl/glsl/GLSLArrayHandler.java
new file mode 100644
index 000000000..30c4a0190
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glsl/GLSLArrayHandler.java
@@ -0,0 +1,62 @@
+
+package com.sun.opengl.impl.glsl;
+
+import com.sun.opengl.impl.*;
+
+import javax.media.opengl.*;
+import javax.media.opengl.sub.*;
+import com.sun.opengl.util.*;
+import com.sun.opengl.util.glsl.ShaderState;
+import java.nio.*;
+
+public class GLSLArrayHandler implements GLArrayHandler {
+  private GLArrayDataEditable ad;
+
+  public GLSLArrayHandler(GLArrayDataEditable ad) {
+    this.ad = ad;
+  }
+
+  protected final void passVertexAttribPointer(GL2ES2 gl, ShaderState st) {
+    st.glVertexAttribPointer(gl, ad);
+  }
+
+  public void enableBuffer(GL gl, boolean enable) {
+    if(!gl.isGL2ES2()) {
+        throw new GLException("GLSLArrayHandler expects a GL2ES2 implementation");
+    }
+    GL2ES2 glsl = gl.getGL2ES2();
+    ShaderState st = ShaderState.getCurrent();
+    if(null==st) {
+        throw new GLException("No ShaderState current");
+    }
+
+    if(enable) {
+        st.glEnableVertexAttribArray(glsl, ad.getName());
+
+        Buffer buffer = ad.getBuffer();
+
+        if(ad.isVBO()) {
+            // always bind and refresh the VBO mgr,
+            // in case more than one gl*Pointer objects are in use
+            glsl.glBindBuffer(GL.GL_ARRAY_BUFFER, ad.getVBOName());
+            if(!ad.isBufferWritten()) {
+                if(null!=buffer) {
+                    glsl.glBufferData(GL.GL_ARRAY_BUFFER, buffer.limit() * ad.getComponentSize(), buffer, ad.getBufferUsage());
+                }
+                ad.setBufferWritten(true);
+            }
+            passVertexAttribPointer(glsl, st);
+        } else if(null!=buffer) {
+            passVertexAttribPointer(glsl, st);
+            ad.setBufferWritten(true);
+        }
+    } else {
+        if(ad.isVBO()) {
+            glsl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
+        }
+        st.glDisableVertexAttribArray(glsl, ad.getName());
+    }
+  }
+
+}
+
diff --git a/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/FixedFuncPipeline.java b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/FixedFuncPipeline.java
new file mode 100644
index 000000000..1d33254c0
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/FixedFuncPipeline.java
@@ -0,0 +1,533 @@
+
+package com.sun.opengl.impl.glsl.fixed;
+
+import javax.media.opengl.*;
+import javax.media.opengl.util.*;
+import javax.media.opengl.sub.fixed.*;
+import com.sun.opengl.util.glsl.*;
+import java.nio.*;
+
+public class FixedFuncPipeline {
+    public static final int MAX_TEXTURE_UNITS = 8;
+    public static final int MAX_LIGHTS        = 8;
+
+    public FixedFuncPipeline(GL2ES2 gl, PMVMatrix pmvMatrix) {
+        init(gl, pmvMatrix, FixedFuncPipeline.class, shaderSrcRootDef, shaderBinRootDef, 
+             vertexColorFileDef, vertexColorLightFileDef, fragmentColorFileDef, fragmentColorTextureFileDef);
+    }
+    public FixedFuncPipeline(GL2ES2 gl, PMVMatrix pmvMatrix, Class shaderRootClass, String shaderSrcRoot, String shaderBinRoot, 
+                       String vertexColorFile,
+                       String vertexColorLightFile,
+                       String fragmentColorFile,
+                       String fragmentColorTextureFile) {
+        init(gl, pmvMatrix, shaderRootClass, shaderSrcRoot, shaderBinRoot, 
+             vertexColorFile, vertexColorLightFile, fragmentColorFile, fragmentColorTextureFile);
+    }
+
+    public boolean verbose() { return verbose; }
+
+    public void setVerbose(boolean v) { verbose=v; }
+
+    public boolean isValid() {
+        return shaderState.linked();
+    }
+
+    public ShaderState getShaderState() {
+        return shaderState;
+    }
+
+    public int getActiveTextureUnit() {
+        return activeTextureUnit;
+    }
+
+    public String getArrayIndexName(int glArrayIndex) {
+      String name = GLContext.getPredefinedArrayIndexName(glArrayIndex); 
+      switch(glArrayIndex) {
+          case GLPointerIf.GL_VERTEX_ARRAY:
+          case GLPointerIf.GL_NORMAL_ARRAY:
+          case GLPointerIf.GL_COLOR_ARRAY:
+              break;
+          case GLPointerIf.GL_TEXTURE_COORD_ARRAY:
+              name = name + activeTextureUnit;
+      }
+      return name;
+    }
+
+    public void destroy(GL2ES2 gl) {
+        shaderProgramColor.release(gl, true);
+        shaderProgramColorLight.release(gl, true);
+        shaderProgramColorTexture.release(gl, true);
+        shaderProgramColorTextureLight.release(gl, true);
+        shaderState.destroy(gl);
+    }
+
+    public void glEnableClientState(GL2ES2 gl, int glArrayIndex) {
+        shaderState.glUseProgram(gl, true);
+
+        shaderState.glEnableVertexAttribArray(gl, getArrayIndexName(glArrayIndex));
+        // textureCoordsEnabled |=  (1 << activeTextureUnit);
+        if ( textureCoordsEnabled.get(activeTextureUnit) != 1 ) {
+            textureCoordsEnabled.put(activeTextureUnit, 1);
+            textureCoordsEnabledDirty = true;
+        }
+    }
+
+    public void glDisableClientState(GL2ES2 gl, int glArrayIndex) {
+        shaderState.glUseProgram(gl, true);
+
+        shaderState.glDisableVertexAttribArray(gl, getArrayIndexName(glArrayIndex));
+        // textureCoordsEnabled &= ~(1 << activeTextureUnit);
+        if ( textureCoordsEnabled.get(activeTextureUnit) != 0 ) {
+            textureCoordsEnabled.put(activeTextureUnit, 0);
+            textureCoordsEnabledDirty = true;
+        }
+    }
+
+    public void glVertexPointer(GL2ES2 gl, GLArrayData data) {
+        shaderState.glUseProgram(gl, true);
+        shaderState.glVertexAttribPointer(gl, data);
+    }
+
+    public void glColorPointer(GL2ES2 gl, GLArrayData data) {
+        shaderState.glUseProgram(gl, true);
+        shaderState.glVertexAttribPointer(gl, data);
+    }
+
+    public void glColor4fv(GL2ES2 gl, FloatBuffer data ) {
+        shaderState.glUseProgram(gl, true);
+        GLUniformData ud = shaderState.getUniform(mgl_ColorStatic);
+        if(null!=ud) {
+            ud.setData(data);
+            shaderState.glUniform(gl, ud);
+        }
+    }
+
+    public void glNormalPointer(GL2ES2 gl, GLArrayData data) {
+        shaderState.glUseProgram(gl, true);
+        shaderState.glVertexAttribPointer(gl, data);
+    }
+
+    public void glTexCoordPointer(GL2ES2 gl, GLArrayData data) {
+        shaderState.glUseProgram(gl, true);
+        data.setName( getArrayIndexName(data.getIndex()) );
+        shaderState.glVertexAttribPointer(gl, data);
+    }
+
+    public void glLightfv(GL2ES2 gl, int light, int pname, java.nio.FloatBuffer params) {
+        shaderState.glUseProgram(gl, true);
+        light -=GLLightingIf.GL_LIGHT0;
+        if(0 <= light && light < MAX_LIGHTS) {
+            GLUniformData ud = null;
+            switch(pname) {
+                case  GLLightingIf.GL_AMBIENT:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].ambient");
+                    break;
+                case  GLLightingIf.GL_DIFFUSE:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].diffuse");
+                    break;
+                case  GLLightingIf.GL_SPECULAR:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].specular");
+                    break;
+                case GLLightingIf.GL_POSITION:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].position");
+                    break;
+                case GLLightingIf.GL_SPOT_DIRECTION:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].spotDirection");
+                    break;
+                case GLLightingIf.GL_SPOT_EXPONENT:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].spotExponent");
+                    break;
+                case GLLightingIf.GL_SPOT_CUTOFF:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].spotCutoff");
+                    break;
+                case GLLightingIf.GL_CONSTANT_ATTENUATION:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].constantAttenuation");
+                    break;
+                case GLLightingIf.GL_LINEAR_ATTENUATION:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].linearAttenuation");
+                    break;
+                case GLLightingIf.GL_QUADRATIC_ATTENUATION:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].quadraticAttenuation");
+                    break;
+                default:
+                    if(verbose) {
+                        System.err.println("glLightfv pname not within [GL_AMBIENT GL_DIFFUSE GL_SPECULAR GL_POSITION GL_SPOT_DIRECTION]: "+pname);
+                    }
+                    return;
+            }
+            if(null!=ud) {
+                ud.setData(params);
+                shaderState.glUniform(gl, ud);
+            }
+        } else if(verbose) {
+            System.err.println("glLightfv light not within [0.."+MAX_LIGHTS+"]: "+light);
+        }
+    }
+
+    public void glMaterialfv(GL2ES2 gl, int face, int pname, java.nio.FloatBuffer params) {
+        shaderState.glUseProgram(gl, true);
+
+        switch (face) {
+            case GL.GL_FRONT:
+            case GL.GL_FRONT_AND_BACK:
+                break;
+            case GL.GL_BACK:
+                if(verbose) {
+                    System.err.println("glMaterialfv face GL_BACK currently not supported");
+                }
+                break;
+            default:
+        }
+
+        GLUniformData ud = null;
+        switch(pname) {
+            case  GLLightingIf.GL_AMBIENT:
+                ud = shaderState.getUniform(mgl_FrontMaterial+".ambient");
+                break;
+            case  GLLightingIf.GL_AMBIENT_AND_DIFFUSE:
+                glMaterialfv(gl, face, GLLightingIf.GL_AMBIENT, params);
+                // fall through intended ..
+            case  GLLightingIf.GL_DIFFUSE:
+                ud = shaderState.getUniform(mgl_FrontMaterial+".diffuse");
+                break;
+            case  GLLightingIf.GL_SPECULAR:
+                ud = shaderState.getUniform(mgl_FrontMaterial+".specular");
+                break;
+            case  GLLightingIf.GL_EMISSION:
+                ud = shaderState.getUniform(mgl_FrontMaterial+".emission");
+                break;
+            case  GLLightingIf.GL_SHININESS:
+                ud = shaderState.getUniform(mgl_FrontMaterial+".shininess");
+                break;
+            default:
+                if(verbose) {
+                    System.err.println("glMaterialfv pname not within [GL_AMBIENT GL_DIFFUSE GL_SPECULAR GL_EMISSION GL_SHININESS]: "+pname);
+                }
+                return;
+        }
+        if(null!=ud) {
+            ud.setData(params);
+            shaderState.glUniform(gl, ud);
+        }
+    }
+
+    public void glShadeModel(GL2ES2 gl, int mode) {
+        shaderState.glUseProgram(gl, true);
+        GLUniformData ud = shaderState.getUniform(mgl_ShadeModel);
+        if(null!=ud) {
+            ud.setData(mode);
+            shaderState.glUniform(gl, ud);
+        }
+    }
+
+    public void glActiveTexture(GL2ES2 gl, int textureUnit) {
+        textureUnit -= GL.GL_TEXTURE0;
+        if(0 <= textureUnit && textureUnit<MAX_TEXTURE_UNITS) {
+            shaderState.glUseProgram(gl, true);
+            GLUniformData ud;
+            ud = shaderState.getUniform(mgl_ActiveTexture);
+            if(null!=ud) {
+                ud.setData(textureUnit);
+                shaderState.glUniform(gl, ud);
+            }
+            ud = shaderState.getUniform(mgl_ActiveTextureIdx);
+            if(null!=ud) {
+                ud.setData(textureUnit);
+                shaderState.glUniform(gl, ud);
+            }
+            activeTextureUnit = textureUnit;
+        } else {
+            throw new GLException("glActivateTexture textureUnit not within GL_TEXTURE0 + [0.."+MAX_TEXTURE_UNITS+"]: "+textureUnit);
+        }
+    }
+
+    /**
+     * @return false if digested in regard to GL2ES2 spec, 
+     *         eg this call must not be passed to an underlying ES2 implementation.
+     *         true if this call shall be passed to an underlying GL2ES2/ES2 implementation as well.
+     */
+    public boolean glEnable(GL2ES2 gl, int cap, boolean enable) {
+        switch(cap) {
+            case GL.GL_TEXTURE_2D:
+                textureEnabled=enable;
+                return true;
+            case GLLightingIf.GL_LIGHTING:
+                lightingEnabled=enable;
+                return false;
+            case GL.GL_CULL_FACE:
+                cullFace=Math.abs(cullFace);
+                if(!enable) {
+                    cullFace*=-1;
+                }
+                return true;
+        }
+
+        int light = cap - GLLightingIf.GL_LIGHT0;
+        if(0 <= light && light < MAX_LIGHTS) {
+            if ( (lightsEnabled.get(light)==1) != enable ) {
+                lightsEnabled.put(light, enable?1:0);
+                lightsEnabledDirty = true;
+                return false;
+            }
+        }
+        return true; // pass it on ..
+    }
+
+    public void glCullFace(GL2ES2 gl, int faceName) {
+        switch(faceName) {
+            case GL.GL_FRONT:
+                faceName = 1; break;
+            case GL.GL_BACK:
+                faceName = 2; break;
+            case GL.GL_FRONT_AND_BACK:
+                faceName = 3; break;
+        }
+        if(0>cullFace) {
+            faceName *= -1;
+        }
+        cullFace = faceName;
+    }
+
+    public void validate(GL2ES2 gl) {
+        shaderState.glUseProgram(gl, true);
+        GLUniformData ud;
+        if(pmvMatrix.update()) {
+            ud = shaderState.getUniform(mgl_PMVMatrix);
+            if(null!=ud) {
+                // same data object ..
+                shaderState.glUniform(gl, ud);
+            } else {
+                throw new GLException("Failed to update: mgl_PMVMatrix");
+            }
+            ud = shaderState.getUniform(mgl_NormalMatrix);
+            if(null!=ud) {
+                // same data object ..
+                shaderState.glUniform(gl, ud);
+            }
+        }
+        ud = shaderState.getUniform(mgl_ColorEnabled);
+        if(null!=ud) {
+            int ca = (shaderState.isVertexAttribArrayEnabled(GLContext.mgl_Color)==true)?1:0;
+            if(ca!=ud.intValue()) {
+                ud.setData(ca);
+                shaderState.glUniform(gl, ud);
+            }
+        }
+        ud = shaderState.getUniform(mgl_CullFace);
+        if(null!=ud) {
+            if(cullFace!=ud.intValue()) {
+                ud.setData(cullFace);
+                shaderState.glUniform(gl, ud);
+            }
+        }
+
+        if(lightsEnabledDirty) {
+            ud = shaderState.getUniform(mgl_LightsEnabled);
+            if(null!=ud) {
+                // same data object 
+                shaderState.glUniform(gl, ud);
+            }
+            lightsEnabledDirty=false;
+        }
+
+        if(textureCoordsEnabledDirty) {
+            ud = shaderState.getUniform(mgl_TexCoordEnabled);
+            if(null!=ud) {
+                // same data object 
+                shaderState.glUniform(gl, ud);
+            }
+            textureCoordsEnabledDirty=false;
+        }
+
+        if(textureEnabled) {
+            if(lightingEnabled) {
+                shaderState.attachShaderProgram(gl, shaderProgramColorTextureLight);
+            } else {
+                shaderState.attachShaderProgram(gl, shaderProgramColorTexture);
+            }
+        } else {
+            if(lightingEnabled) {
+                shaderState.attachShaderProgram(gl, shaderProgramColorLight);
+            } else {
+                shaderState.attachShaderProgram(gl, shaderProgramColor);
+            }
+        }
+        if(DEBUG) {
+            System.err.println("validate: "+this);
+        }
+    }
+
+    public String toString() {
+        return "FixedFuncPipeline[pmv: "+pmvMatrix+
+               ", textureEnabled: "+textureEnabled+
+               ", textureCoordsEnabled: "+textureCoordsEnabled+
+               ", lightingEnabled: "+lightingEnabled+
+               ", lightsEnabled: "+lightsEnabled+
+               "\n\t, shaderProgramColor: "+shaderProgramColor+
+               "\n\t, shaderProgramColorTexture: "+shaderProgramColorTexture+
+               "\n\t, shaderProgramColorLight: "+shaderProgramColorLight+
+               "\n\t, shaderProgramColorTextureLight: "+shaderProgramColorTextureLight+
+               "\n\t, ShaderState: "+shaderState+
+               "]";
+    }
+
+    protected void init(GL2ES2 gl, PMVMatrix pmvMatrix, Class shaderRootClass, String shaderSrcRoot, String shaderBinRoot, 
+                       String vertexColorFile,
+                       String vertexColorLightFile,
+                       String fragmentColorFile,
+                       String fragmentColorTextureFile) 
+   {
+        if(null==pmvMatrix) {
+            throw new GLException("PMVMatrix is null");
+        }
+        this.pmvMatrix=pmvMatrix;
+        this.shaderState=new ShaderState();
+        this.shaderState.setVerbose(verbose);
+        ShaderCode vertexColor, vertexColorLight, fragmentColor, fragmentColorTexture;
+
+        vertexColor = ShaderCode.create( gl, gl.GL_VERTEX_SHADER, 1, shaderRootClass,
+                                         shaderSrcRoot, shaderBinRoot, vertexColorFile);
+
+        vertexColorLight = ShaderCode.create( gl, gl.GL_VERTEX_SHADER, 1, shaderRootClass,
+                                           shaderSrcRoot, shaderBinRoot, vertexColorLightFile);
+
+        fragmentColor = ShaderCode.create( gl, gl.GL_FRAGMENT_SHADER, 1, shaderRootClass,
+                                           shaderSrcRoot, shaderBinRoot, fragmentColorFile);
+
+        fragmentColorTexture = ShaderCode.create( gl, gl.GL_FRAGMENT_SHADER, 1, shaderRootClass,
+                                                  shaderSrcRoot, shaderBinRoot, fragmentColorTextureFile);
+
+        shaderProgramColor = new ShaderProgram();
+        shaderProgramColor.add(vertexColor);
+        shaderProgramColor.add(fragmentColor);
+        if(!shaderProgramColor.link(gl, System.err)) {
+            throw new GLException("Couldn't link VertexColor program: "+shaderProgramColor);
+        }
+
+        shaderProgramColorTexture = new ShaderProgram();
+        shaderProgramColorTexture.add(vertexColor);
+        shaderProgramColorTexture.add(fragmentColorTexture);
+        if(!shaderProgramColorTexture.link(gl, System.err)) {
+            throw new GLException("Couldn't link VertexColorTexture program: "+shaderProgramColorTexture);
+        }
+
+        shaderProgramColorLight = new ShaderProgram();
+        shaderProgramColorLight.add(vertexColorLight);
+        shaderProgramColorLight.add(fragmentColor);
+        if(!shaderProgramColorLight.link(gl, System.err)) {
+            throw new GLException("Couldn't link VertexColorLight program: "+shaderProgramColorLight);
+        }
+
+        shaderProgramColorTextureLight = new ShaderProgram();
+        shaderProgramColorTextureLight.add(vertexColorLight);
+        shaderProgramColorTextureLight.add(fragmentColorTexture);
+        if(!shaderProgramColorTextureLight.link(gl, System.err)) {
+            throw new GLException("Couldn't link VertexColorLight program: "+shaderProgramColorTextureLight);
+        }
+
+        shaderState.attachShaderProgram(gl, shaderProgramColor);
+        shaderState.glUseProgram(gl, true);
+
+        // mandatory ..
+        if(!shaderState.glUniform(gl, new GLUniformData(mgl_PMVMatrix, 4, 4, pmvMatrix.glGetPMvMviMatrixf()))) {
+            throw new GLException("Error setting PMVMatrix in shader: "+this);
+        }
+
+        // optional parameter ..
+        shaderState.glUniform(gl, new GLUniformData(mgl_NormalMatrix, 3, 3, pmvMatrix.glGetNormalMatrixf()));
+
+        shaderState.glUniform(gl, new GLUniformData(mgl_ColorEnabled,  0));
+        shaderState.glUniform(gl, new GLUniformData(mgl_ColorStatic, 4, zero4f));
+        shaderState.glUniform(gl, new GLUniformData(mgl_TexCoordEnabled,  1, textureCoordsEnabled));
+        shaderState.glUniform(gl, new GLUniformData(mgl_ActiveTexture, activeTextureUnit));
+        shaderState.glUniform(gl, new GLUniformData(mgl_ActiveTextureIdx, activeTextureUnit));
+        shaderState.glUniform(gl, new GLUniformData(mgl_ShadeModel, 0));
+        shaderState.glUniform(gl, new GLUniformData(mgl_CullFace, cullFace));
+        for(int i=0; i<MAX_LIGHTS; i++) {
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].ambient", 4, defAmbient));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].diffuse", 4, defDiffuse));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].specular", 4, defSpecular));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].position", 4, defPosition));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].spotDirection", 3, defSpotDir));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].spotExponent", defSpotExponent));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].spotCutoff", defSpotCutoff));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].constantAttenuation", defConstantAtten));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].linearAttenuation", defLinearAtten));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].quadraticAttenuation", defQuadraticAtten));
+        }
+        shaderState.glUniform(gl, new GLUniformData(mgl_LightsEnabled,  1, lightsEnabled));
+        shaderState.glUniform(gl, new GLUniformData(mgl_FrontMaterial+".ambient", 4, defMatAmbient));
+        shaderState.glUniform(gl, new GLUniformData(mgl_FrontMaterial+".diffuse", 4, defMatDiffuse));
+        shaderState.glUniform(gl, new GLUniformData(mgl_FrontMaterial+".specular", 4, defMatSpecular));
+        shaderState.glUniform(gl, new GLUniformData(mgl_FrontMaterial+".emission", 4, defMatEmission));
+        shaderState.glUniform(gl, new GLUniformData(mgl_FrontMaterial+".shininess", defMatShininess));
+
+        shaderState.glUseProgram(gl, false);
+    }
+
+    protected static final boolean DEBUG=false;
+    protected boolean verbose=false;
+
+    protected boolean textureEnabled=false;
+    protected IntBuffer textureCoordsEnabled = BufferUtil.newIntBuffer(new int[] { 0, 0, 0, 0, 0, 0, 0, 0 });
+    protected boolean textureCoordsEnabledDirty = false;
+    protected int     activeTextureUnit=0;
+
+    protected int cullFace=-2; // <=0 disabled, 1: front, 2: back (default, but disabled), 3: front & back
+
+    protected boolean lightingEnabled=false;
+    protected IntBuffer lightsEnabled = BufferUtil.newIntBuffer(new int[] { 0, 0, 0, 0, 0, 0, 0, 0 });
+    protected boolean   lightsEnabledDirty = false;
+
+    protected PMVMatrix pmvMatrix;
+    protected ShaderState shaderState;
+    protected ShaderProgram shaderProgramColor;
+    protected ShaderProgram shaderProgramColorTexture;
+    protected ShaderProgram shaderProgramColorLight;
+    protected ShaderProgram shaderProgramColorTextureLight;
+
+    // uniforms ..
+    protected static final String mgl_PMVMatrix        = "mgl_PMVMatrix";       // m4fv[3]
+    protected static final String mgl_NormalMatrix     = "mgl_NormalMatrix";    // m4fv
+    protected static final String mgl_ColorEnabled     = "mgl_ColorEnabled";    //  1i
+    protected static final String mgl_ColorStatic      = "mgl_ColorStatic";     //  4fv
+
+    protected static final String mgl_LightSource      = "mgl_LightSource";     //  struct mgl_LightSourceParameters[MAX_LIGHTS]
+    protected static final String mgl_FrontMaterial    = "mgl_FrontMaterial";   //  struct mgl_MaterialParameters
+    protected static final String mgl_LightsEnabled    = "mgl_LightsEnabled";   //  int mgl_LightsEnabled[MAX_LIGHTS];
+
+    protected static final String mgl_ShadeModel       = "mgl_ShadeModel";      //  1i
+
+    protected static final String mgl_TexCoordEnabled  = "mgl_TexCoordEnabled"; //  int mgl_TexCoordEnabled[MAX_TEXTURE_UNITS];
+    protected static final String mgl_ActiveTexture    = "mgl_ActiveTexture";   //  1i
+    protected static final String mgl_ActiveTextureIdx = "mgl_ActiveTextureIdx";//  1i
+
+    protected static final String mgl_CullFace         = "mgl_CullFace";   //  1i
+
+    protected static final FloatBuffer zero4f     = BufferUtil.newFloatBuffer(new float[] { 0.0f, 0.0f, 0.0f, 0.0f });
+
+    public static final FloatBuffer defAmbient = BufferUtil.newFloatBuffer(new float[] { 0f, 0f, 0f, 1f });
+    public static final FloatBuffer defDiffuse = zero4f;
+    public static final FloatBuffer defSpecular= zero4f;
+    public static final FloatBuffer defPosition= BufferUtil.newFloatBuffer(new float[] { 0f, 0f, 1f, 0f });
+    public static final FloatBuffer defSpotDir = BufferUtil.newFloatBuffer(new float[] { 0f, 0f, -1f });
+    public static final float defSpotExponent  = 0f;
+    public static final float defSpotCutoff    = 180f;
+    public static final float defConstantAtten = 1f;
+    public static final float defLinearAtten   = 0f;
+    public static final float defQuadraticAtten= 0f;
+
+    public static final FloatBuffer defMatAmbient = BufferUtil.newFloatBuffer(new float[] { 0.2f, 0.2f, 0.2f, 1.0f });
+    public static final FloatBuffer defMatDiffuse = BufferUtil.newFloatBuffer(new float[] { 0.8f, 0.8f, 0.8f, 1.0f });
+    public static final FloatBuffer defMatSpecular= BufferUtil.newFloatBuffer(new float[] { 0f, 0f, 0f, 1f});
+    public static final FloatBuffer defMatEmission= BufferUtil.newFloatBuffer(new float[] { 0f, 0f, 0f, 1f});
+    public static final float       defMatShininess = 0f;
+
+    protected static final String vertexColorFileDef          = "FixedFuncColor";
+    protected static final String vertexColorLightFileDef    = "FixedFuncColorLight";
+    protected static final String fragmentColorFileDef        = "FixedFuncColor";
+    protected static final String fragmentColorTextureFileDef = "FixedFuncColorTexture";
+    protected static final String shaderSrcRootDef = "shader" ;
+    protected static final String shaderBinRootDef = "shader/bin" ;
+}
+
diff --git a/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/FixedFuncColor.fp b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/FixedFuncColor.fp
new file mode 100644
index 000000000..408ff7251
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/FixedFuncColor.fp
@@ -0,0 +1,16 @@
+#include es_precision.glsl
+
+#include mgl_uniform.glsl
+#include mgl_varying.glsl
+
+void main (void)
+{
+  if( mgl_CullFace > 0 && 
+      ( ( mgl_CullFace == 1 && gl_FrontFacing ) ||
+        ( mgl_CullFace == 2 && !gl_FrontFacing ) ||
+        ( mgl_CullFace == 3 ) ) ) {
+    discard;
+  }
+  gl_FragColor = frontColor;
+}
+
diff --git a/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/FixedFuncColor.vp b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/FixedFuncColor.vp
new file mode 100644
index 000000000..346e40196
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/FixedFuncColor.vp
@@ -0,0 +1,22 @@
+#include es_precision.glsl
+
+#include mgl_const.glsl
+#include mgl_uniform.glsl
+#include mgl_attribute.glsl
+#include mgl_varying.glsl
+
+#include mgl_settexcoord.vp
+
+void main(void)
+{
+  if(mgl_ColorEnabled>0) {
+    frontColor=mgl_Color;
+  } else {
+    frontColor=mgl_ColorStatic;
+  }
+
+  gl_Position = mgl_PMVMatrix[0] * mgl_PMVMatrix[1] * mgl_Vertex;
+
+  setTexCoord(gl_Position);
+}
+
diff --git a/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/FixedFuncColorLight.vp b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/FixedFuncColorLight.vp
new file mode 100644
index 000000000..ce203cfb9
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/FixedFuncColorLight.vp
@@ -0,0 +1,70 @@
+#include es_precision.glsl
+#include mgl_lightdef.glsl
+
+#include mgl_const.glsl
+#include mgl_uniform.glsl
+#include mgl_uniform_light.glsl
+#include mgl_attribute.glsl
+#include mgl_varying.glsl
+
+#include mgl_settexcoord.vp
+
+void main(void)
+{
+  vec4 position;
+  vec3 normal, lightDir, cameraDir, halfDir;
+  vec4 ambient, diffuse, specular;
+  float NdotL, NdotHV, dist, attenuation;
+  int i;
+
+  position  = mgl_PMVMatrix[1] * mgl_Vertex; // vertex eye position 
+
+  normal = normalize(mgl_NormalMatrix * mgl_Normal); 
+  // cameraPosition:      (mgl_PMVMatrix[2] * vec4(0,0,0,1.0)).xyz                   
+  cameraDir  = normalize( (mgl_PMVMatrix[2] * vec4(0,0,0,1.0)).xyz - mgl_Vertex.xyz ); 
+
+  ambient = vec4(0,0,0,0);
+  diffuse = vec4(0,0,0,0);
+  specular = vec4(0,0,0,0);
+
+  bool lightEnabled = false;
+
+  for(i=0; i<MAX_LIGHTS; i++) {
+    if( 0!= mgl_LightsEnabled[i] ) {
+      lightEnabled = true;
+      ambient += mgl_LightSource[i].ambient;
+      lightDir = mgl_LightSource[i].position.xyz - position.xyz;
+      dist     = length(lightDir);
+      lightDir = normalize(lightDir);
+      attenuation = 1.0 / ( 
+                       mgl_LightSource[i].constantAttenuation+ 
+                       mgl_LightSource[i].linearAttenuation    * dist +   
+                       mgl_LightSource[i].quadraticAttenuation * dist * dist );
+      NdotL = max(0.0, dot(normal, lightDir));
+      diffuse += mgl_LightSource[i].diffuse * NdotL * attenuation;
+      if (NdotL != 0.0) {
+        halfDir  = normalize (lightDir + cameraDir); 
+        NdotHV   = max(0.0, dot(normal, halfDir));
+        specular += mgl_LightSource[i].specular * 
+                    pow(NdotHV,mgl_FrontMaterial.shininess) * attenuation;
+      }
+    }
+  }
+  ambient  += mgl_FrontMaterial.ambient;
+  diffuse  *= mgl_FrontMaterial.diffuse;
+  specular *= mgl_FrontMaterial.specular;
+
+  if(mgl_ColorEnabled>0) {
+    frontColor=mgl_Color;
+  } else {
+    frontColor=mgl_ColorStatic;
+  }
+  if( lightEnabled ) {
+    frontColor *= ambient + diffuse + specular;
+  }
+
+  gl_Position  = mgl_PMVMatrix[0] * position;
+
+  setTexCoord(gl_Position);
+}
+
diff --git a/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/FixedFuncColorTexture.fp b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/FixedFuncColorTexture.fp
new file mode 100644
index 000000000..86e6ace73
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/FixedFuncColorTexture.fp
@@ -0,0 +1,47 @@
+
+#include es_precision.glsl
+#include mgl_lightdef.glsl
+
+#include mgl_const.glsl
+#include mgl_uniform.glsl
+#include mgl_varying.glsl
+
+vec4 getTexColor(in sampler2D tex, in int idx) {
+    vec4 coord;
+    if(idx==0) {
+        coord= mgl_TexCoords[0];
+    } else if(idx==1) {
+        coord= mgl_TexCoords[1];
+    } else if(idx==2) {
+        coord= mgl_TexCoords[2];
+    } else if(idx==3) {
+        coord= mgl_TexCoords[3];
+    } else if(idx==4) {
+        coord= mgl_TexCoords[4];
+    } else if(idx==5) {
+        coord= mgl_TexCoords[5];
+    } else if(idx==6) {
+        coord= mgl_TexCoords[6];
+    } else {
+        coord= mgl_TexCoords[7];
+    }
+    return texture2D(tex, coord.st);
+}
+
+void main (void)
+{
+  if( mgl_CullFace > 0 && 
+      ( ( mgl_CullFace == 1 && gl_FrontFacing ) ||
+        ( mgl_CullFace == 2 && !gl_FrontFacing ) ||
+        ( mgl_CullFace == 3 ) ) ) {
+    discard;
+  }
+
+  vec4 texColor = getTexColor(mgl_ActiveTexture,mgl_ActiveTextureIdx);
+
+  if(length(texColor.rgb)>0.0) {
+    gl_FragColor = vec4(frontColor.rgb*texColor.rgb, frontColor.a) ;
+  } else {
+    gl_FragColor = frontColor;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/bin/nvidia/FixedFuncColor.bfp b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/bin/nvidia/FixedFuncColor.bfp
new file mode 100755
index 000000000..3ebaaee1d
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/bin/nvidia/FixedFuncColor.bfp
diff --git a/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/bin/nvidia/FixedFuncColor.bvp b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/bin/nvidia/FixedFuncColor.bvp
new file mode 100755
index 000000000..279ef72c7
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/bin/nvidia/FixedFuncColor.bvp
diff --git a/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/bin/nvidia/FixedFuncColorLight.bvp b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/bin/nvidia/FixedFuncColorLight.bvp
new file mode 100755
index 000000000..5a9deea71
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/bin/nvidia/FixedFuncColorLight.bvp
diff --git a/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/bin/nvidia/FixedFuncColorTexture.bfp b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/bin/nvidia/FixedFuncColorTexture.bfp
new file mode 100755
index 000000000..ce1397fe1
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/bin/nvidia/FixedFuncColorTexture.bfp
diff --git a/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/es_precision.glsl b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/es_precision.glsl
new file mode 100644
index 000000000..fd6abe54e
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/es_precision.glsl
@@ -0,0 +1,14 @@
+#ifndef es_precision_glsl
+#define es_precision_glsl
+
+#ifdef GL_ES
+  #define MEDIUMP mediump
+  #define HIGHP highp
+  #define LOWP  lowp
+#else
+  #define MEDIUMP
+  #define HIGHP
+  #define LOWP
+#endif
+
+#endif // es_precision_glsl
diff --git a/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_attribute.glsl b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_attribute.glsl
new file mode 100644
index 000000000..b09bdb05a
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_attribute.glsl
@@ -0,0 +1,19 @@
+
+#ifndef mgl_attribute_glsl
+#define mgl_attribute_glsl
+
+#include es_precision.glsl
+
+attribute HIGHP vec4    mgl_Vertex;
+attribute HIGHP vec3    mgl_Normal;
+attribute HIGHP vec4    mgl_Color;
+attribute HIGHP vec4    mgl_MultiTexCoord0;
+attribute HIGHP vec4    mgl_MultiTexCoord1;
+attribute HIGHP vec4    mgl_MultiTexCoord2;
+attribute HIGHP vec4    mgl_MultiTexCoord3;
+attribute HIGHP vec4    mgl_MultiTexCoord4;
+attribute HIGHP vec4    mgl_MultiTexCoord5;
+attribute HIGHP vec4    mgl_MultiTexCoord6;
+attribute HIGHP vec4    mgl_MultiTexCoord7;
+
+#endif // mgl_attribute_glsl
diff --git a/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_const.glsl b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_const.glsl
new file mode 100644
index 000000000..1a464a1cb
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_const.glsl
@@ -0,0 +1,10 @@
+
+#ifndef mgl_const_glsl
+#define mgl_const_glsl
+
+#include es_precision.glsl
+
+const   LOWP int     MAX_TEXTURE_UNITS = 8; // <=gl_MaxTextureImageUnits 
+const   LOWP int     MAX_LIGHTS = 8; 
+
+#endif // mgl_const_glsl
diff --git a/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_lightdef.glsl b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_lightdef.glsl
new file mode 100644
index 000000000..98e214139
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_lightdef.glsl
@@ -0,0 +1,26 @@
+#ifndef mgl_lightdef_glsl
+#define mgl_lightdef_glsl
+
+struct mgl_LightSourceParameters {
+   vec4 ambient; 
+   vec4 diffuse; 
+   vec4 specular; 
+   vec4 position; 
+   // vec4 halfVector; // is computed here
+   vec3 spotDirection; 
+   float spotExponent; 
+   float spotCutoff; // (range: [0.0,90.0], 180.0)
+   //float spotCosCutoff; // (range: [1.0,0.0],-1.0)
+   float constantAttenuation; 
+   float linearAttenuation; 
+   float quadraticAttenuation; 
+};
+struct mgl_MaterialParameters {
+   vec4 ambient;    
+   vec4 diffuse;    
+   vec4 specular;   
+   vec4 emission;   
+   float shininess; 
+};
+
+#endif // mgl_lightdef_glsl
diff --git a/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_settexcoord.vp b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_settexcoord.vp
new file mode 100644
index 000000000..1efe328d0
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_settexcoord.vp
@@ -0,0 +1,35 @@
+#ifndef mgl_settexcoord_vp
+#define mgl_settexcoord_vp
+
+#include es_precision.glsl
+
+#include mgl_const.glsl
+#include mgl_uniform.glsl
+#include mgl_attribute.glsl
+#include mgl_varying.glsl
+
+void setTexCoord(in vec4 defpos) {
+  /**
+   * bitwise operator not supported on APX 2500 ES 2.0
+   *
+  mgl_TexCoords[0] = ( 0 != (mgl_TexCoordEnabled &   1) ) ? mgl_MultiTexCoord0 : defpos;
+  mgl_TexCoords[1] = ( 0 != (mgl_TexCoordEnabled &   2) ) ? mgl_MultiTexCoord1 : defpos;
+  mgl_TexCoords[2] = ( 0 != (mgl_TexCoordEnabled &   4) ) ? mgl_MultiTexCoord2 : defpos;
+  mgl_TexCoords[3] = ( 0 != (mgl_TexCoordEnabled &   8) ) ? mgl_MultiTexCoord3 : defpos;
+  mgl_TexCoords[4] = ( 0 != (mgl_TexCoordEnabled &  16) ) ? mgl_MultiTexCoord4 : defpos;
+  mgl_TexCoords[5] = ( 0 != (mgl_TexCoordEnabled &  32) ) ? mgl_MultiTexCoord5 : defpos;
+  mgl_TexCoords[6] = ( 0 != (mgl_TexCoordEnabled &  64) ) ? mgl_MultiTexCoord6 : defpos;
+  mgl_TexCoords[7] = ( 0 != (mgl_TexCoordEnabled & 128) ) ? mgl_MultiTexCoord7 : defpos;
+   */
+  
+  mgl_TexCoords[0] = ( 0 != mgl_TexCoordEnabled[0] ) ? mgl_MultiTexCoord0 : defpos;
+  mgl_TexCoords[1] = ( 0 != mgl_TexCoordEnabled[1] ) ? mgl_MultiTexCoord1 : defpos;
+  mgl_TexCoords[2] = ( 0 != mgl_TexCoordEnabled[2] ) ? mgl_MultiTexCoord2 : defpos;
+  mgl_TexCoords[3] = ( 0 != mgl_TexCoordEnabled[3] ) ? mgl_MultiTexCoord3 : defpos;
+  mgl_TexCoords[4] = ( 0 != mgl_TexCoordEnabled[4] ) ? mgl_MultiTexCoord4 : defpos;
+  mgl_TexCoords[5] = ( 0 != mgl_TexCoordEnabled[5] ) ? mgl_MultiTexCoord5 : defpos;
+  mgl_TexCoords[6] = ( 0 != mgl_TexCoordEnabled[6] ) ? mgl_MultiTexCoord6 : defpos;
+  mgl_TexCoords[7] = ( 0 != mgl_TexCoordEnabled[7] ) ? mgl_MultiTexCoord7 : defpos;
+}
+
+#endif // mgl_settexcoord_vp
diff --git a/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_uniform.glsl b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_uniform.glsl
new file mode 100644
index 000000000..d8b3c7f95
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_uniform.glsl
@@ -0,0 +1,18 @@
+
+#ifndef mgl_uniform_glsl
+#define mgl_uniform_glsl
+
+#include es_precision.glsl
+
+#include mgl_const.glsl
+
+uniform   HIGHP mat4    mgl_PMVMatrix[3]; // P, Mv, and Mvi
+uniform   HIGHP mat3    mgl_NormalMatrix; // transpose(inverse(ModelView)).3x3
+uniform LOWP    int     mgl_ColorEnabled;
+uniform HIGHP   vec4    mgl_ColorStatic;
+uniform LOWP    int     mgl_TexCoordEnabled[MAX_TEXTURE_UNITS];
+uniform       sampler2D mgl_ActiveTexture;
+uniform LOWP    int     mgl_ActiveTextureIdx;
+uniform LOWP    int     mgl_CullFace;
+
+#endif // mgl_uniform_glsl
diff --git a/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_uniform_light.glsl b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_uniform_light.glsl
new file mode 100644
index 000000000..0dedb5d5d
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_uniform_light.glsl
@@ -0,0 +1,15 @@
+
+#ifndef mgl_uniform_light_glsl
+#define mgl_uniform_light_glsl
+
+#include es_precision.glsl
+
+#include mgl_const.glsl
+#include mgl_lightdef.glsl
+
+uniform LOWP    int     mgl_LightsEnabled[MAX_LIGHTS];
+
+uniform mgl_LightSourceParameters mgl_LightSource[MAX_LIGHTS];
+uniform mgl_MaterialParameters    mgl_FrontMaterial;
+
+#endif // mgl_uniform_light_glsl
diff --git a/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_varying.glsl b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_varying.glsl
new file mode 100644
index 000000000..fc9f735d1
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/mgl_varying.glsl
@@ -0,0 +1,12 @@
+
+#ifndef mgl_varying_glsl
+#define mgl_varying_glsl
+
+#include es_precision.glsl
+
+#include mgl_const.glsl
+
+varying   vec4    frontColor;
+varying   vec4    mgl_TexCoords[MAX_TEXTURE_UNITS];
+
+#endif // mgl_varying_glsl
diff --git a/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/scripts/nvidia-apx/glslc-ff.bat b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/scripts/nvidia-apx/glslc-ff.bat
new file mode 100755
index 000000000..21fba2fc3
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/scripts/nvidia-apx/glslc-ff.bat
@@ -0,0 +1,9 @@
+REM 
+REM You have to call it from the 'shader' directory, e.g.:
+REM   scripts\nvidia-apx\glslc-ff.bat 
+REM
+IF !"%JOGLDIR%"==""! GOTO YESPATH
+set JOGLDIR=..\lib
+:YESPATH
+   
+java -cp %JOGLDIR%\jogl.core.jar;%JOGLDIR%\jogl.gles2.jar;%JOGLDIR%\jogl.fixed.jar;%JOGLDIR%\jogl.sdk.jar javax.media.opengl.sdk.glsl.CompileShaderNVidia FixedFuncColor.fp FixedFuncColorTexture.fp FixedFuncColorLight.vp FixedFuncColor.vp
diff --git a/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/scripts/nvidia-apx/glslc.bat b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/scripts/nvidia-apx/glslc.bat
new file mode 100755
index 000000000..28f3cf822
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glsl/fixed/shader/scripts/nvidia-apx/glslc.bat
@@ -0,0 +1,9 @@
+REM 
+REM You have to call it from the 'shader' directory, e.g.:
+REM   scripts\nvidia-apx\glslc.bat <FileName>
+REM
+IF !"%JOGLDIR%"==""! GOTO YESPATH
+set JOGLDIR=..\lib
+:YESPATH
+
+java -cp %JOGLDIR%\jogl.core.jar;%JOGLDIR%\jogl.gles2.jar;%JOGLDIR%\jogl.fixed.jar;%JOGLDIR%\jogl.sdk.jar javax.media.opengl.sdk.glsl.CompileShaderNVidia %1
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/GLUquadricImpl.java b/src/jogl/classes/com/sun/opengl/impl/glu/GLUquadricImpl.java
new file mode 100644
index 000000000..2d6e41126
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/GLUquadricImpl.java
@@ -0,0 +1,1220 @@
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** $Date: 2009-03-04 17:23:34 -0800 (Wed, 04 Mar 2009) $ $Revision: 1856 $
+** $Header$
+*/
+
+/* 
+ * Copyright (c) 2002-2004 LWJGL Project
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are 
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright 
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of 'LWJGL' nor the names of 
+ *   its contributors may be used to endorse or promote products derived 
+ *   from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+package com.sun.opengl.impl.glu;
+
+import javax.media.opengl.*;
+import javax.media.opengl.sub.*;
+import javax.media.opengl.glu.*;
+import com.sun.opengl.util.ImmModeSink;
+import java.nio.*;
+
+/**
+ * GLUquadricImpl.java
+ * 
+ * 
+ * Created 22-dec-2003 (originally Quadric.java)
+ * @author Erik Duijs
+ * @author Kenneth Russell, Sven Gothel
+ */
+
+public class GLUquadricImpl implements GLUquadric {
+  private boolean useGLSL;
+  private int drawStyle;
+  private int orientation;
+  private boolean textureFlag;
+  private int normals;
+  private boolean immModeSinkEnabled;
+  private boolean immModeSinkImmediate;
+  public int normalType;
+
+  public static final boolean USE_NORM = true;
+  public static final boolean USE_TEXT = false;
+
+  private ImmModeSink immModeSink;
+
+  public GLUquadricImpl(boolean useGLSL) {
+    this.useGLSL = useGLSL;
+    drawStyle = GLU.GLU_FILL;
+    orientation = GLU.GLU_OUTSIDE;
+    textureFlag = false;
+    normals = GLU.GLU_SMOOTH;
+    normalType = GLProfile.isGLES1()?GL.GL_BYTE:GL.GL_FLOAT;
+    if(useGLSL) {
+        immModeSink = ImmModeSink.createGLSL (GL.GL_STATIC_DRAW, 32, 
+                                              3, GL.GL_FLOAT,  // vertex
+                                              0, GL.GL_FLOAT,  // color
+                                              USE_NORM?3:0, normalType,// normal
+                                              USE_TEXT?2:0, GL.GL_FLOAT); // texture
+    } else {
+        immModeSink = ImmModeSink.createFixed(GL.GL_STATIC_DRAW, 32, 
+                                              3, GL.GL_FLOAT,  // vertex
+                                              0, GL.GL_FLOAT,  // color
+                                              USE_NORM?3:0, normalType,// normal
+                                              USE_TEXT?2:0, GL.GL_FLOAT); // texture
+    }
+    immModeSinkImmediate=true;
+    immModeSinkEnabled=!GLProfile.isGL2();
+  }
+
+  public void enableImmModeSink(boolean val) {
+    if(!GLProfile.isGLES()) {
+        immModeSinkEnabled=val;
+    } else {
+        immModeSinkEnabled=true;
+    }
+  }
+
+  public boolean isImmModeSinkEnabled() {
+    return immModeSinkEnabled;
+  }
+
+  public void setImmMode(boolean val) {
+    if(immModeSinkEnabled) {
+        immModeSinkImmediate=val;
+    } else {
+        immModeSinkImmediate=true;
+    }
+  }
+
+  public boolean getImmMode() {
+    return immModeSinkImmediate;
+  }
+
+  public ImmModeSink replaceImmModeSink() {
+    if(!immModeSinkEnabled) return null;
+
+    ImmModeSink res = immModeSink;
+    if(useGLSL) {
+        immModeSink = ImmModeSink.createGLSL (GL.GL_STATIC_DRAW, 32, 
+                                              3, GL.GL_FLOAT,  // vertex
+                                              0, GL.GL_FLOAT,  // color
+                                              USE_NORM?3:0, normalType,// normal
+                                              USE_TEXT?2:0, GL.GL_FLOAT); // texture
+    } else {
+        immModeSink = ImmModeSink.createFixed(GL.GL_STATIC_DRAW, 32, 
+                                              3, GL.GL_FLOAT,  // vertex
+                                              0, GL.GL_FLOAT,  // color
+                                              USE_NORM?3:0, normalType,// normal
+                                              USE_TEXT?2:0, GL.GL_FLOAT); // texture
+    }
+    return res;
+  }
+
+  public void resetImmModeSink(GL gl) {
+    if(immModeSinkEnabled) {
+        immModeSink.reset(gl);
+    }
+  }
+
+  /**
+   * specifies the draw style for quadrics.  
+   *
+   * The legal values are as follows:
+   *
+   * GLU.FILL:       Quadrics are rendered with polygon primitives. The polygons
+   *                 are drawn in a counterclockwise fashion with respect to
+   *                 their normals (as defined with glu.quadricOrientation).
+   *
+   * GLU.LINE:       Quadrics are rendered as a set of lines.
+   *
+   * GLU.SILHOUETTE: Quadrics are rendered as a set of lines, except that edges
+   * 		   separating coplanar faces will not be drawn.
+   *
+   * GLU.POINT:       Quadrics are rendered as a set of points.
+   * 
+   * @param drawStyle The drawStyle to set
+   */
+  public void setDrawStyle(int drawStyle) {
+    this.drawStyle = drawStyle;
+  }
+
+  /**
+   * specifies what kind	of normals are desired for quadrics.
+   * The legal values	are as follows:
+   *
+   * GLU.NONE:     No normals are generated.
+   *
+   * GLU.FLAT:     One normal is generated for every facet of a quadric.
+   *
+   * GLU.SMOOTH:   One normal is generated for every vertex of a quadric.  This
+   *               is the default.
+   * 
+   * @param normals The normals to set
+   */
+  public void setNormals(int normals) {
+    this.normals = normals;
+  }
+
+  /**
+   * specifies what kind of orientation is desired for.
+   * The orientation	values are as follows:
+   *
+   * GLU.OUTSIDE:  Quadrics are drawn with normals pointing outward.
+   *
+   * GLU.INSIDE:   Normals point inward. The default is GLU.OUTSIDE.
+   *
+   * Note that the interpretation of outward and inward depends on the quadric
+   * being drawn.
+   * 
+   * @param orientation The orientation to set
+   */
+  public void setOrientation(int orientation) {
+    this.orientation = orientation;
+  }
+
+  /**
+   * specifies if texture coordinates should be generated for
+   * quadrics rendered with qobj. If the value of textureCoords is true,
+   * then texture coordinates are generated, and if textureCoords is false,
+   * they are not.. The default is false.
+   *
+   * The manner in which texture coordinates are generated depends upon the
+   * specific quadric rendered.
+   * 
+   * @param textureFlag The textureFlag to set
+   */
+  public void setTextureFlag(boolean textureFlag) {
+    this.textureFlag = textureFlag;
+  }
+
+  /**
+   * Returns the drawStyle.
+   * @return int
+   */
+  public int getDrawStyle() {
+    return drawStyle;
+  }
+
+  /**
+   * Returns the normals.
+   * @return int
+   */
+  public int getNormals() {
+    return normals;
+  }
+
+  /**
+   * Returns the orientation.
+   * @return int
+   */
+  public int getOrientation() {
+    return orientation;
+  }
+
+  /**
+   * Returns the textureFlag.
+   * @return boolean
+   */
+  public boolean getTextureFlag() {
+    return textureFlag;
+  }
+
+
+  /**
+   * draws a cylinder oriented along the z axis. The base of the
+   * cylinder is placed at z = 0, and the top at z=height. Like a sphere, a
+   * cylinder is subdivided around the z axis into slices, and along the z axis
+   * into stacks.
+   *
+   * Note that if topRadius is set to zero, then this routine will generate a
+   * cone.
+   *
+   * If the orientation is set to GLU.OUTSIDE (with glu.quadricOrientation), then
+   * any generated normals point away from the z axis. Otherwise, they point
+   * toward the z axis.
+   *
+   * If texturing is turned on (with glu.quadricTexture), then texture
+   * coordinates are generated so that t ranges linearly from 0.0 at z = 0 to
+   * 1.0 at z = height, and s ranges from 0.0 at the +y axis, to 0.25 at the +x
+   * axis, to 0.5 at the -y axis, to 0.75 at the -x axis, and back to 1.0 at the
+   * +y axis.
+   *
+   * @param baseRadius  Specifies the radius of the cylinder at z = 0.
+   * @param topRadius   Specifies the radius of the cylinder at z = height.
+   * @param height      Specifies the height of the cylinder.
+   * @param slices      Specifies the number of subdivisions around the z axis.
+   * @param stacks      Specifies the number of subdivisions along the z axis.
+   */
+  public void drawCylinder(GL gl, float baseRadius, float topRadius, float height, int slices, int stacks) {
+
+    float da, r, dr, dz;
+    float x, y, z, nz, nsign;
+    int i, j;
+
+    if (orientation == GLU.GLU_INSIDE) {
+      nsign = -1.0f;
+    } else {
+      nsign = 1.0f;
+    }
+
+    da = 2.0f * PI / slices;
+    dr = (topRadius - baseRadius) / stacks;
+    dz = height / stacks;
+    nz = (baseRadius - topRadius) / height;
+    // Z component of normal vectors
+
+    if (drawStyle == GLU.GLU_POINT) {
+      glBegin(gl, GL.GL_POINTS);
+      for (i = 0; i < slices; i++) {
+        x = cos((i * da));
+        y = sin((i * da));
+        normal3f(gl, x * nsign, y * nsign, nz * nsign);
+
+        z = 0.0f;
+        r = baseRadius;
+        for (j = 0; j <= stacks; j++) {
+          glVertex3f(gl, (x * r), (y * r), z);
+          z += dz;
+          r += dr;
+        }
+      }
+      glEnd(gl);
+    } else if (drawStyle == GLU.GLU_LINE || drawStyle == GLU.GLU_SILHOUETTE) {
+      // Draw rings
+      if (drawStyle == GLU.GLU_LINE) {
+        z = 0.0f;
+        r = baseRadius;
+        for (j = 0; j <= stacks; j++) {
+          glBegin(gl, GL.GL_LINE_LOOP);
+          for (i = 0; i < slices; i++) {
+            x = cos((i * da));
+            y = sin((i * da));
+            normal3f(gl, x * nsign, y * nsign, nz * nsign);
+            glVertex3f(gl, (x * r), (y * r), z);
+          }
+          glEnd(gl);
+          z += dz;
+          r += dr;
+        }
+      } else {
+        // draw one ring at each end
+        if (baseRadius != 0.0) {
+          glBegin(gl, GL.GL_LINE_LOOP);
+          for (i = 0; i < slices; i++) {
+            x = cos((i * da));
+            y = sin((i * da));
+            normal3f(gl, x * nsign, y * nsign, nz * nsign);
+            glVertex3f(gl, (x * baseRadius), (y * baseRadius), 0.0f);
+          }
+          glEnd(gl);
+          glBegin(gl, GL.GL_LINE_LOOP);
+          for (i = 0; i < slices; i++) {
+            x = cos((i * da));
+            y = sin((i * da));
+            normal3f(gl, x * nsign, y * nsign, nz * nsign);
+            glVertex3f(gl, (x * topRadius), (y * topRadius), height);
+          }
+          glEnd(gl);
+        }
+      }
+      // draw length lines
+      glBegin(gl, GL.GL_LINES);
+      for (i = 0; i < slices; i++) {
+        x = cos((i * da));
+        y = sin((i * da));
+        normal3f(gl, x * nsign, y * nsign, nz * nsign);
+        glVertex3f(gl, (x * baseRadius), (y * baseRadius), 0.0f);
+        glVertex3f(gl, (x * topRadius), (y * topRadius), (height));
+      }
+      glEnd(gl);
+    } else if (drawStyle == GLU.GLU_FILL) {
+      float ds = 1.0f / slices;
+      float dt = 1.0f / stacks;
+      float t = 0.0f;
+      z = 0.0f;
+      r = baseRadius;
+      for (j = 0; j < stacks; j++) {
+        float s = 0.0f;
+        glBegin(gl, immModeSink.GL_QUAD_STRIP);
+        for (i = 0; i <= slices; i++) {
+          if (i == slices) {
+            x = sin(0.0f);
+            y = cos(0.0f);
+          } else {
+            x = sin((i * da));
+            y = cos((i * da));
+          }
+          if (nsign == 1.0f) {
+            normal3f(gl, (x * nsign), (y * nsign), (nz * nsign));
+            TXTR_COORD(gl, s, t);
+            glVertex3f(gl, (x * r), (y * r), z);
+            normal3f(gl, (x * nsign), (y * nsign), (nz * nsign));
+            TXTR_COORD(gl, s, t + dt);
+            glVertex3f(gl, (x * (r + dr)), (y * (r + dr)), (z + dz));
+          } else {
+            normal3f(gl, x * nsign, y * nsign, nz * nsign);
+            TXTR_COORD(gl, s, t);
+            glVertex3f(gl, (x * r), (y * r), z);
+            normal3f(gl, x * nsign, y * nsign, nz * nsign);
+            TXTR_COORD(gl, s, t + dt);
+            glVertex3f(gl, (x * (r + dr)), (y * (r + dr)), (z + dz));
+          }
+          s += ds;
+        } // for slices
+        glEnd(gl);
+        r += dr;
+        t += dt;
+        z += dz;
+      } // for stacks
+    }
+  }
+
+  /**
+   * renders a disk on the z = 0  plane.  The disk has a radius of
+   * outerRadius, and contains a concentric circular hole with a radius of
+   * innerRadius. If innerRadius is 0, then no hole is generated. The disk is
+   * subdivided around the z axis into slices (like pizza slices), and also
+   * about the z axis into rings (as specified by slices and loops,
+   * respectively).
+   *
+   * With respect to orientation, the +z side of the disk is considered to be
+   * "outside" (see glu.quadricOrientation).  This means that if the orientation
+   * is set to GLU.OUTSIDE, then any normals generated point along the +z axis.
+   * Otherwise, they point along the -z axis.
+   *
+   * If texturing is turned on (with glu.quadricTexture), texture coordinates are
+   * generated linearly such that where r=outerRadius, the value at (r, 0, 0) is
+   * (1, 0.5), at (0, r, 0) it is (0.5, 1), at (-r, 0, 0) it is (0, 0.5), and at
+   * (0, -r, 0) it is (0.5, 0).
+   */
+  public void drawDisk(GL gl, float innerRadius, float outerRadius, int slices, int loops)
+  {
+    float da, dr;
+
+    /* Normal vectors */
+    if (normals != GLU.GLU_NONE) {
+      if (orientation == GLU.GLU_OUTSIDE) {
+        glNormal3f(gl, 0.0f, 0.0f, +1.0f);
+      }
+      else {
+        glNormal3f(gl, 0.0f, 0.0f, -1.0f);
+      }
+    }
+	
+    da = 2.0f * PI / slices;
+    dr = (outerRadius - innerRadius) /  loops;
+	
+    switch (drawStyle) {
+    case GLU.GLU_FILL:
+      {
+        /* texture of a gluDisk is a cut out of the texture unit square
+         * x, y in [-outerRadius, +outerRadius]; s, t in [0, 1]
+         * (linear mapping)
+         */
+        float dtc = 2.0f * outerRadius;
+        float sa, ca;
+        float r1 = innerRadius;
+        int l;
+        for (l = 0; l < loops; l++) {
+          float r2 = r1 + dr;
+          if (orientation == GLU.GLU_OUTSIDE) {
+            int s;
+            glBegin(gl, immModeSink.GL_QUAD_STRIP);
+            for (s = 0; s <= slices; s++) {
+              float a;
+              if (s == slices)
+                a = 0.0f;
+              else
+                a = s * da;
+              sa = sin(a);
+              ca = cos(a);
+              TXTR_COORD(gl, 0.5f + sa * r2 / dtc, 0.5f + ca * r2 / dtc);
+              glVertex2f(gl, r2 * sa, r2 * ca);
+              TXTR_COORD(gl, 0.5f + sa * r1 / dtc, 0.5f + ca * r1 / dtc);
+              glVertex2f(gl, r1 * sa, r1 * ca);
+            }
+            glEnd(gl);
+          }
+          else {
+            int s;
+            glBegin(gl, immModeSink.GL_QUAD_STRIP);
+            for (s = slices; s >= 0; s--) {
+              float a;
+              if (s == slices)
+                a = 0.0f;
+              else
+                a = s * da;
+              sa = sin(a);
+              ca = cos(a);
+              TXTR_COORD(gl, 0.5f - sa * r2 / dtc, 0.5f + ca * r2 / dtc);
+              glVertex2f(gl, r2 * sa, r2 * ca);
+              TXTR_COORD(gl, 0.5f - sa * r1 / dtc, 0.5f + ca * r1 / dtc);
+              glVertex2f(gl, r1 * sa, r1 * ca);
+            }
+            glEnd(gl);
+          }
+          r1 = r2;
+        }
+        break;
+      }
+    case GLU.GLU_LINE:
+      {
+        int l, s;
+        /* draw loops */
+        for (l = 0; l <= loops; l++) {
+          float r = innerRadius + l * dr;
+          glBegin(gl, GL.GL_LINE_LOOP);
+          for (s = 0; s < slices; s++) {
+            float a = s * da;
+            glVertex2f(gl, r * sin(a), r * cos(a));
+          }
+          glEnd(gl);
+        }
+        /* draw spokes */
+        for (s = 0; s < slices; s++) {
+          float a = s * da;
+          float x = sin(a);
+          float y = cos(a);
+          glBegin(gl, GL.GL_LINE_STRIP);
+          for (l = 0; l <= loops; l++) {
+            float r = innerRadius + l * dr;
+            glVertex2f(gl, r * x, r * y);
+          }
+          glEnd(gl);
+        }
+        break;
+      }
+    case GLU.GLU_POINT:
+      {
+        int s;
+        glBegin(gl, GL.GL_POINTS);
+        for (s = 0; s < slices; s++) {
+          float a = s * da;
+          float x = sin(a);
+          float y = cos(a);
+          int l;
+          for (l = 0; l <= loops; l++) {
+            float r = innerRadius * l * dr;
+            glVertex2f(gl, r * x, r * y);
+          }
+        }
+        glEnd(gl);
+        break;
+      }
+    case GLU.GLU_SILHOUETTE:
+      {
+        if (innerRadius != 0.0) {
+          float a;
+          glBegin(gl, GL.GL_LINE_LOOP);
+          for (a = 0.0f; a < 2.0 * PI; a += da) {
+            float x = innerRadius * sin(a);
+            float y = innerRadius * cos(a);
+            glVertex2f(gl, x, y);
+          }
+          glEnd(gl);
+        }
+        {
+          float a;
+          glBegin(gl, GL.GL_LINE_LOOP);
+          for (a = 0; a < 2.0f * PI; a += da) {
+            float x = outerRadius * sin(a);
+            float y = outerRadius * cos(a);
+            glVertex2f(gl, x, y);
+          }
+          glEnd(gl);
+        }
+        break;
+      }
+    default:
+      return;
+    }
+  }
+
+  /**
+   * renders a partial disk on the z=0 plane. A partial disk is similar to a
+   * full disk, except that only the subset of the disk from startAngle
+   * through startAngle + sweepAngle is included (where 0 degrees is along
+   * the +y axis, 90 degrees along the +x axis, 180 along the -y axis, and
+   * 270 along the -x axis).
+   * 
+   * The partial disk has a radius of outerRadius, and contains a concentric
+   * circular hole with a radius of innerRadius. If innerRadius is zero, then
+   * no hole is generated. The partial disk is subdivided around the z axis
+   * into slices (like pizza slices), and also about the z axis into rings
+   * (as specified by slices and loops, respectively).
+   * 
+   * With respect to orientation, the +z side of the partial disk is
+   * considered to be outside (see gluQuadricOrientation). This means that if
+   * the orientation is set to GLU.GLU_OUTSIDE, then any normals generated point
+   * along the +z axis. Otherwise, they point along the -z axis.
+   * 
+   * If texturing is turned on (with gluQuadricTexture), texture coordinates
+   * are generated linearly such that where r=outerRadius, the value at (r, 0, 0)
+   * is (1, 0.5), at (0, r, 0) it is (0.5, 1), at (-r, 0, 0) it is (0, 0.5),
+   * and at (0, -r, 0) it is (0.5, 0).
+   */
+  public void drawPartialDisk(GL gl,
+                              float innerRadius,
+                              float outerRadius,
+                              int slices,
+                              int loops,
+                              float startAngle,
+                              float sweepAngle) {
+    int i, j, max;
+    float[] sinCache = new float[CACHE_SIZE];
+    float[] cosCache = new float[CACHE_SIZE];
+    float angle;
+    float x, y;
+    float sintemp, costemp;
+    float deltaRadius;
+    float radiusLow, radiusHigh;
+    float texLow = 0, texHigh = 0;
+    float angleOffset;
+    int slices2;
+    int finish;
+
+    if (slices >= CACHE_SIZE)
+      slices = CACHE_SIZE - 1;
+    if (slices < 2
+        || loops < 1
+        || outerRadius <= 0.0f
+        || innerRadius < 0.0f
+        || innerRadius > outerRadius) {
+      //gluQuadricError(qobj, GLU.GLU_INVALID_VALUE);
+      System.err.println("PartialDisk: GLU_INVALID_VALUE");
+      return;
+    }
+
+    if (sweepAngle < -360.0f)
+      sweepAngle = 360.0f;
+    if (sweepAngle > 360.0f)
+      sweepAngle = 360.0f;
+    if (sweepAngle < 0) {
+      startAngle += sweepAngle;
+      sweepAngle = -sweepAngle;
+    }
+
+    if (sweepAngle == 360.0f) {
+      slices2 = slices;
+    } else {
+      slices2 = slices + 1;
+    }
+
+    /* Compute length (needed for normal calculations) */
+    deltaRadius = outerRadius - innerRadius;
+
+    /* Cache is the vertex locations cache */
+
+    angleOffset = startAngle / 180.0f * PI;
+    for (i = 0; i <= slices; i++) {
+      angle = angleOffset + ((PI * sweepAngle) / 180.0f) * i / slices;
+      sinCache[i] = sin(angle);
+      cosCache[i] = cos(angle);
+    }
+
+    if (sweepAngle == 360.0f) {
+      sinCache[slices] = sinCache[0];
+      cosCache[slices] = cosCache[0];
+    }
+
+    switch (normals) {
+    case GLU.GLU_FLAT :
+    case GLU.GLU_SMOOTH :
+      if (orientation == GLU.GLU_OUTSIDE) {
+        glNormal3f(gl, 0.0f, 0.0f, 1.0f);
+      } else {
+        glNormal3f(gl, 0.0f, 0.0f, -1.0f);
+      }
+      break;
+    default :
+    case GLU.GLU_NONE :
+      break;
+    }
+
+    switch (drawStyle) {
+    case GLU.GLU_FILL :
+      if (innerRadius == .0f) {
+        finish = loops - 1;
+        /* Triangle strip for inner polygons */
+        glBegin(gl, GL.GL_TRIANGLE_FAN);
+        if (textureFlag) {
+          glTexCoord2f(gl, 0.5f, 0.5f);
+        }
+        glVertex3f(gl, 0.0f, 0.0f, 0.0f);
+        radiusLow = outerRadius - deltaRadius * ((float) (loops - 1) / loops);
+        if (textureFlag) {
+          texLow = radiusLow / outerRadius / 2;
+        }
+
+        if (orientation == GLU.GLU_OUTSIDE) {
+          for (i = slices; i >= 0; i--) {
+            if (textureFlag) {
+              glTexCoord2f(gl, texLow * sinCache[i] + 0.5f,
+                              texLow * cosCache[i] + 0.5f);
+            }
+            glVertex3f(gl, radiusLow * sinCache[i], radiusLow * cosCache[i], 0.0f);
+          }
+        } else {
+          for (i = 0; i <= slices; i++) {
+            if (textureFlag) {
+              glTexCoord2f(gl, texLow * sinCache[i] + 0.5f,
+                              texLow * cosCache[i] + 0.5f);
+            }
+            glVertex3f(gl, radiusLow * sinCache[i], radiusLow * cosCache[i], 0.0f);
+          }
+        }
+        glEnd(gl);
+      } else {
+        finish = loops;
+      }
+      for (j = 0; j < finish; j++) {
+        radiusLow = outerRadius - deltaRadius * ((float) j / loops);
+        radiusHigh = outerRadius - deltaRadius * ((float) (j + 1) / loops);
+        if (textureFlag) {
+          texLow = radiusLow / outerRadius / 2;
+          texHigh = radiusHigh / outerRadius / 2;
+        }
+
+        glBegin(gl, immModeSink.GL_QUAD_STRIP);
+        for (i = 0; i <= slices; i++) {
+          if (orientation == GLU.GLU_OUTSIDE) {
+            if (textureFlag) {
+              glTexCoord2f(gl, texLow * sinCache[i] + 0.5f,
+                              texLow * cosCache[i] + 0.5f);
+            }
+            glVertex3f(gl, radiusLow * sinCache[i], radiusLow * cosCache[i], 0.0f);
+
+            if (textureFlag) {
+              glTexCoord2f(gl, texHigh * sinCache[i] + 0.5f,
+                              texHigh * cosCache[i] + 0.5f);
+            }
+            glVertex3f(gl, radiusHigh * sinCache[i],
+                          radiusHigh * cosCache[i],
+                          0.0f);
+          } else {
+            if (textureFlag) {
+              glTexCoord2f(gl, texHigh * sinCache[i] + 0.5f,
+                              texHigh * cosCache[i] + 0.5f);
+            }
+            glVertex3f(gl, radiusHigh * sinCache[i],
+                          radiusHigh * cosCache[i],
+                          0.0f);
+
+            if (textureFlag) {
+              glTexCoord2f(gl, texLow * sinCache[i] + 0.5f,
+                              texLow * cosCache[i] + 0.5f);
+            }
+            glVertex3f(gl, radiusLow * sinCache[i], radiusLow * cosCache[i], 0.0f);
+          }
+        }
+        glEnd(gl);
+      }
+      break;
+    case GLU.GLU_POINT :
+      glBegin(gl, GL.GL_POINTS);
+      for (i = 0; i < slices2; i++) {
+        sintemp = sinCache[i];
+        costemp = cosCache[i];
+        for (j = 0; j <= loops; j++) {
+          radiusLow = outerRadius - deltaRadius * ((float) j / loops);
+
+          if (textureFlag) {
+            texLow = radiusLow / outerRadius / 2;
+
+            glTexCoord2f(gl, texLow * sinCache[i] + 0.5f,
+                            texLow * cosCache[i] + 0.5f);
+          }
+          glVertex3f(gl, radiusLow * sintemp, radiusLow * costemp, 0.0f);
+        }
+      }
+      glEnd(gl);
+      break;
+    case GLU.GLU_LINE :
+      if (innerRadius == outerRadius) {
+        glBegin(gl, GL.GL_LINE_STRIP);
+
+        for (i = 0; i <= slices; i++) {
+          if (textureFlag) {
+            glTexCoord2f(gl, sinCache[i] / 2 + 0.5f, cosCache[i] / 2 + 0.5f);
+          }
+          glVertex3f(gl, innerRadius * sinCache[i], innerRadius * cosCache[i], 0.0f);
+        }
+        glEnd(gl);
+        break;
+      }
+      for (j = 0; j <= loops; j++) {
+        radiusLow = outerRadius - deltaRadius * ((float) j / loops);
+        if (textureFlag) {
+          texLow = radiusLow / outerRadius / 2;
+        }
+
+        glBegin(gl, GL.GL_LINE_STRIP);
+        for (i = 0; i <= slices; i++) {
+          if (textureFlag) {
+            glTexCoord2f(gl, texLow * sinCache[i] + 0.5f,
+                            texLow * cosCache[i] + 0.5f);
+          }
+          glVertex3f(gl, radiusLow * sinCache[i], radiusLow * cosCache[i], 0.0f);
+        }
+        glEnd(gl);
+      }
+      for (i = 0; i < slices2; i++) {
+        sintemp = sinCache[i];
+        costemp = cosCache[i];
+        glBegin(gl, GL.GL_LINE_STRIP);
+        for (j = 0; j <= loops; j++) {
+          radiusLow = outerRadius - deltaRadius * ((float) j / loops);
+          if (textureFlag) {
+            texLow = radiusLow / outerRadius / 2;
+          }
+
+          if (textureFlag) {
+            glTexCoord2f(gl, texLow * sinCache[i] + 0.5f,
+                            texLow * cosCache[i] + 0.5f);
+          }
+          glVertex3f(gl, radiusLow * sintemp, radiusLow * costemp, 0.0f);
+        }
+        glEnd(gl);
+      }
+      break;
+    case GLU.GLU_SILHOUETTE :
+      if (sweepAngle < 360.0f) {
+        for (i = 0; i <= slices; i += slices) {
+          sintemp = sinCache[i];
+          costemp = cosCache[i];
+          glBegin(gl, GL.GL_LINE_STRIP);
+          for (j = 0; j <= loops; j++) {
+            radiusLow = outerRadius - deltaRadius * ((float) j / loops);
+
+            if (textureFlag) {
+              texLow = radiusLow / outerRadius / 2;
+              glTexCoord2f(gl, texLow * sinCache[i] + 0.5f,
+                              texLow * cosCache[i] + 0.5f);
+            }
+            glVertex3f(gl, radiusLow * sintemp, radiusLow * costemp, 0.0f);
+          }
+          glEnd(gl);
+        }
+      }
+      for (j = 0; j <= loops; j += loops) {
+        radiusLow = outerRadius - deltaRadius * ((float) j / loops);
+        if (textureFlag) {
+          texLow = radiusLow / outerRadius / 2;
+        }
+
+        glBegin(gl, GL.GL_LINE_STRIP);
+        for (i = 0; i <= slices; i++) {
+          if (textureFlag) {
+            glTexCoord2f(gl, texLow * sinCache[i] + 0.5f,
+                            texLow * cosCache[i] + 0.5f);
+          }
+          glVertex3f(gl, radiusLow * sinCache[i], radiusLow * cosCache[i], 0.0f);
+        }
+        glEnd(gl);
+        if (innerRadius == outerRadius)
+          break;
+      }
+      break;
+    default :
+      break;
+    }
+  }
+
+  /**
+   * draws a sphere of the given	radius centered	around the origin.
+   * The sphere is subdivided around the z axis into slices and along the z axis
+   * into stacks (similar to lines of longitude and latitude).
+   *
+   * If the orientation is set to GLU.OUTSIDE (with glu.quadricOrientation), then
+   * any normals generated point away from the center of the sphere. Otherwise,
+   * they point toward the center of the sphere.
+
+   * If texturing is turned on (with glu.quadricTexture), then texture
+   * coordinates are generated so that t ranges from 0.0 at z=-radius to 1.0 at
+   * z=radius (t increases linearly along longitudinal lines), and s ranges from
+   * 0.0 at the +y axis, to 0.25 at the +x axis, to 0.5 at the -y axis, to 0.75
+   * at the -x axis, and back to 1.0 at the +y axis.
+   */
+  public void drawSphere(GL gl, float radius, int slices, int stacks) {
+    // TODO
+
+    float rho, drho, theta, dtheta;
+    float x, y, z;
+    float s, t, ds, dt;
+    int i, j, imin, imax;
+    boolean normals;
+    float nsign;
+
+    normals = (this.normals != GLU.GLU_NONE);
+
+    if (orientation == GLU.GLU_INSIDE) {
+      nsign = -1.0f;
+    } else {
+      nsign = 1.0f;
+    }
+
+    drho = PI / stacks;
+    dtheta = 2.0f * PI / slices;
+
+    if (drawStyle == GLU.GLU_FILL) {
+      if (!textureFlag) {
+        // draw +Z end as a triangle fan
+        glBegin(gl, GL.GL_TRIANGLE_FAN);
+        glNormal3f(gl, 0.0f, 0.0f, 1.0f);
+        glVertex3f(gl, 0.0f, 0.0f, nsign * radius);
+        for (j = 0; j <= slices; j++) {
+          theta = (j == slices) ? 0.0f : j * dtheta;
+          x = -sin(theta) * sin(drho);
+          y = cos(theta) * sin(drho);
+          z = nsign * cos(drho);
+          if (normals) {
+            glNormal3f(gl, x * nsign, y * nsign, z * nsign);
+          }
+          glVertex3f(gl, x * radius, y * radius, z * radius);
+        }
+        glEnd(gl);
+      }
+
+      ds = 1.0f / slices;
+      dt = 1.0f / stacks;
+      t = 1.0f; // because loop now runs from 0
+      if (textureFlag) {
+        imin = 0;
+        imax = stacks;
+      } else {
+        imin = 1;
+        imax = stacks - 1;
+      }
+
+      // draw intermediate stacks as quad strips
+      for (i = imin; i < imax; i++) {
+        rho = i * drho;
+        glBegin(gl, immModeSink.GL_QUAD_STRIP);
+        s = 0.0f;
+        for (j = 0; j <= slices; j++) {
+          theta = (j == slices) ? 0.0f : j * dtheta;
+          x = -sin(theta) * sin(rho);
+          y = cos(theta) * sin(rho);
+          z = nsign * cos(rho);
+          if (normals) {
+            glNormal3f(gl, x * nsign, y * nsign, z * nsign);
+          }
+          TXTR_COORD(gl, s, t);
+          glVertex3f(gl, x * radius, y * radius, z * radius);
+          x = -sin(theta) * sin(rho + drho);
+          y = cos(theta) * sin(rho + drho);
+          z = nsign * cos(rho + drho);
+          if (normals) {
+            glNormal3f(gl, x * nsign, y * nsign, z * nsign);
+          }
+          TXTR_COORD(gl, s, t - dt);
+          s += ds;
+          glVertex3f(gl, x * radius, y * radius, z * radius);
+        }
+        glEnd(gl);
+        t -= dt;
+      }
+
+      if (!textureFlag) {
+        // draw -Z end as a triangle fan
+        glBegin(gl, GL.GL_TRIANGLE_FAN);
+        glNormal3f(gl, 0.0f, 0.0f, -1.0f);
+        glVertex3f(gl, 0.0f, 0.0f, -radius * nsign);
+        rho = PI - drho;
+        s = 1.0f;
+        for (j = slices; j >= 0; j--) {
+          theta = (j == slices) ? 0.0f : j * dtheta;
+          x = -sin(theta) * sin(rho);
+          y = cos(theta) * sin(rho);
+          z = nsign * cos(rho);
+          if (normals)
+            glNormal3f(gl, x * nsign, y * nsign, z * nsign);
+          s -= ds;
+          glVertex3f(gl, x * radius, y * radius, z * radius);
+        }
+        glEnd(gl);
+      }
+    } else if (
+               drawStyle == GLU.GLU_LINE
+               || drawStyle == GLU.GLU_SILHOUETTE) {
+      // draw stack lines
+      for (i = 1;
+           i < stacks;
+           i++) { // stack line at i==stacks-1 was missing here
+        rho = i * drho;
+        glBegin(gl, GL.GL_LINE_LOOP);
+        for (j = 0; j < slices; j++) {
+          theta = j * dtheta;
+          x = cos(theta) * sin(rho);
+          y = sin(theta) * sin(rho);
+          z = cos(rho);
+          if (normals)
+            glNormal3f(gl, x * nsign, y * nsign, z * nsign);
+          glVertex3f(gl, x * radius, y * radius, z * radius);
+        }
+        glEnd(gl);
+      }
+      // draw slice lines
+      for (j = 0; j < slices; j++) {
+        theta = j * dtheta;
+        glBegin(gl, GL.GL_LINE_STRIP);
+        for (i = 0; i <= stacks; i++) {
+          rho = i * drho;
+          x = cos(theta) * sin(rho);
+          y = sin(theta) * sin(rho);
+          z = cos(rho);
+          if (normals)
+            glNormal3f(gl, x * nsign, y * nsign, z * nsign);
+          glVertex3f(gl, x * radius, y * radius, z * radius);
+        }
+        glEnd(gl);
+      }
+    } else if (drawStyle == GLU.GLU_POINT) {
+      // top and bottom-most points
+      glBegin(gl, GL.GL_POINTS);
+      if (normals)
+        glNormal3f(gl, 0.0f, 0.0f, nsign);
+      glVertex3f(gl, 0.0f, 0.0f, radius);
+      if (normals)
+        glNormal3f(gl, 0.0f, 0.0f, -nsign);
+      glVertex3f(gl, 0.0f, 0.0f, -radius);
+
+      // loop over stacks
+      for (i = 1; i < stacks - 1; i++) {
+        rho = i * drho;
+        for (j = 0; j < slices; j++) {
+          theta = j * dtheta;
+          x = cos(theta) * sin(rho);
+          y = sin(theta) * sin(rho);
+          z = cos(rho);
+          if (normals)
+            glNormal3f(gl, x * nsign, y * nsign, z * nsign);
+          glVertex3f(gl, x * radius, y * radius, z * radius);
+        }
+      }
+      glEnd(gl);
+    }
+  }
+
+
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+
+  private static final float PI = (float)Math.PI;
+  private static final int CACHE_SIZE = 240;
+
+  private final void glBegin(GL gl, int mode) {
+      if(immModeSinkEnabled) {
+          immModeSink.glBegin(mode);
+      } else {
+          gl.getGL2().glBegin(mode);
+      }
+  }
+
+  private final void glEnd(GL gl) {
+      if(immModeSinkEnabled) {
+          immModeSink.glEnd(gl, immModeSinkImmediate);
+      } else {
+          gl.getGL2().glEnd();
+      }
+  }
+
+  private final void glVertex2f(GL gl, float x, float y) {
+      if(immModeSinkEnabled) {
+          immModeSink.glVertex2f(x, y);
+      } else {
+          gl.getGL2().glVertex2f(x, y);
+      }
+  }
+
+  private final void glVertex3f(GL gl, float x, float y, float z) {
+      if(immModeSinkEnabled) {
+          immModeSink.glVertex3f(x, y, z);
+      } else {
+          gl.getGL2().glVertex3f(x, y, z);
+      }
+  }
+
+  private final void glNormal3f_s(GL gl, float x, float y, float z) {
+      short a=(short)(x*0xFFFF);
+      short b=(short)(y*0xFFFF);
+      short c=(short)(z*0xFFFF);
+      if(immModeSinkEnabled) {
+          immModeSink.glNormal3s(a, b, c);
+      } else {
+          gl.getGL2().glNormal3s(a, b, c);
+      }
+  }
+
+  private final void glNormal3f_b(GL gl, float x, float y, float z) {
+      byte a=(byte)(x*0xFF);
+      byte b=(byte)(y*0xFF);
+      byte c=(byte)(z*0xFF);
+      if(immModeSinkEnabled) {
+          immModeSink.glNormal3b(a, b, c);
+      } else {
+          gl.getGL2().glNormal3b(a, b, c);
+      }
+  }
+
+  private final void glNormal3f(GL gl, float x, float y, float z) {
+    switch(normalType) {
+        case GL.GL_FLOAT:
+            if(immModeSinkEnabled) {
+                immModeSink.glNormal3f(x,y,z);
+            } else {
+                gl.getGL2().glNormal3f(x,y,z);
+            }
+            break;
+        case GL.GL_SHORT:
+            glNormal3f_s(gl, x, y, z);
+            break;
+        case GL.GL_BYTE:
+            glNormal3f_b(gl, x, y, z);
+            break;
+    }
+  }
+
+  private final void glTexCoord2f(GL gl, float x, float y) {
+      if(immModeSinkEnabled) {
+          immModeSink.glTexCoord2f(x, y);
+      } else {
+          gl.getGL2().glTexCoord2f(x, y);
+      }
+  }
+
+  /**
+   * Call glNormal3f after scaling normal to unit length.
+   *
+   * @param x
+   * @param y
+   * @param z
+   */
+  private void normal3f(GL gl, float x, float y, float z) {
+    float mag;
+	
+    mag = (float)Math.sqrt(x * x + y * y + z * z);
+    if (mag > 0.00001F) {
+      x /= mag;
+      y /= mag;
+      z /= mag;
+    }
+    glNormal3f(gl, x, y, z);
+  }
+
+  private final void TXTR_COORD(GL gl, float x, float y) {
+    if (textureFlag) glTexCoord2f(gl, x,y);
+  }
+
+  private float sin(float r) {
+    return (float)Math.sin(r);
+  }
+
+  private float cos(float r) {
+    return (float)Math.cos(r);
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/Glue.java b/src/jogl/classes/com/sun/opengl/impl/glu/Glue.java
new file mode 100755
index 000000000..ada5ab684
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/Glue.java
@@ -0,0 +1,114 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu;
+
+/**
+ *
+ * @author  Administrator
+ */
+public class Glue {
+  private static String[] __gluNurbsErrors = {
+    " ",
+    "spline order un-supported",
+    "too few knots",
+    "valid knot range is empty",
+    "decreasing knot sequence knot",
+    "knot multiplicity greater than order of spline",
+    "gluEndCurve() must follow gluBeginCurve()",
+    "gluBeginCurve() must precede gluEndCurve()",
+    "missing or extra geometric data",
+    "can't draw piecewise linear trimming curves",
+    "missing or extra domain data",
+    "missing or extra domain data",
+    "gluEndTrim() must precede gluEndSurface()",
+    "gluBeginSurface() must precede gluEndSurface()",
+    "curve of improper type passed as trim curve",
+    "gluBeginSurface() must precede gluBeginTrim()",
+    "gluEndTrim() must follow gluBeginTrim()",
+    "gluBeginTrim() must follow gluEndTrim()",
+    "invalid or missing trim curve",
+    "gluBeginTrim() must precede gluPwlCurve()",
+    "piecewise linear trimming curve referenced twice",
+    "piecewise linear trimming curve and nurbs curve mixed",
+    "improper usage of trim data type",
+    "nurbs curve referenced twice",
+    "nurbs curve and piecewise linear trimming curve mixed",
+    "nurbs surface referenced twice",
+    "invalid property",
+    "gluEndSurface() must follow gluBeginSurface()",
+    "intersecting or misoriented trim curve",
+    "intersecting trim curves",
+    "UNUSED",
+    "inconnected trim curves",
+    "unknown knot error",
+    "negative vertex count encountered",
+    "negative byte-stride encountered",
+    "unknown type descriptor",
+    "null control point reference",
+    "duplicate point on piecewise linear trimming curve"
+  } ;
+  
+  /** Creates a new instance of Glue */
+  public Glue() {
+  }
+  
+  public static String __gluNURBSErrorString( int errno ) {
+    return( __gluNurbsErrors[ errno ] );
+  }
+  
+  private static String[] __gluTessErrors = {
+    " ",
+    "gluTessBeginPolygon() must precede a gluTessEndPolygon",
+    "gluTessBeginContour() must precede a gluTessEndContour()",
+    "gluTessEndPolygon() must follow a gluTessBeginPolygon()",
+    "gluTessEndContour() must follow a gluTessBeginContour()",
+    "a coordinate is too large",
+    "need combine callback"
+  };
+  
+  public static String __gluTessErrorString( int errno ) {
+    return( __gluTessErrors[ errno ] );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/error/Error.java b/src/jogl/classes/com/sun/opengl/impl/glu/error/Error.java
new file mode 100644
index 000000000..d24a41f10
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/error/Error.java
@@ -0,0 +1,100 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ *
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ * 
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.error;
+
+import javax.media.opengl.GL;
+import javax.media.opengl.glu.GLU;
+import com.sun.opengl.impl.glu.Glue;
+
+/**
+ *
+ * @author  Administrator
+ */
+public class Error {
+  
+  private static String[] glErrorStrings = {
+    "invalid enumerant",
+    "invalid value",
+    "invalid operation",
+    "stack overflow",
+    "stack underflow",
+    "out of memory",
+    "invalid framebuffer operation"
+  };
+  
+  private static String[] gluErrorStrings = {
+    "invalid enumerant",
+    "invalid value",
+    "out of memory",
+    "",
+    "invalid operation"
+  };
+  
+  /** Creates a new instance of Error */
+  public Error() {
+  }
+  
+  public static String gluErrorString( int errorCode ) {
+    if( errorCode == 0 ) {
+      return( "no error" );
+    }
+    if( (errorCode >= GL.GL_INVALID_ENUM) && (errorCode <= GL.GL_INVALID_FRAMEBUFFER_OPERATION) ) {
+      return( glErrorStrings[ errorCode - GL.GL_INVALID_ENUM ] );
+    }
+    if( errorCode == 0x8031 /* GL.GL_TABLE_TOO_LARGE */ ) {
+      return( "table too large" );
+    }
+    if( (errorCode >= GLU.GLU_INVALID_ENUM) && (errorCode <= GLU.GLU_INVALID_OPERATION) ) {
+      return( gluErrorStrings[ errorCode - GLU.GLU_INVALID_ENUM ] );
+    }
+//    if( (errorCode >= GLU.GLU_NURBS_ERROR1) && (errorCode <= GLU.GLU_NURBS_ERROR37) ) {
+//      return( gluErrorStrings[ errorCode - (GLU.GLU_NURBS_ERROR1 - 1) ] );
+//    }
+    if( (errorCode >= GLU.GLU_TESS_ERROR1) && (errorCode <= GLU.GLU_TESS_ERROR8) ) {
+        return( Glue.__gluTessErrorString(errorCode - (GLU.GLU_TESS_ERROR1 - 1)) );
+    }
+    return( "error ("+errorCode+")" );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/gl2/nurbs/GL2Backend.java b/src/jogl/classes/com/sun/opengl/impl/glu/gl2/nurbs/GL2Backend.java
new file mode 100755
index 000000000..d54f1c56f
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/gl2/nurbs/GL2Backend.java
@@ -0,0 +1,49 @@
+package com.sun.opengl.impl.glu.gl2.nurbs;
+import com.sun.opengl.impl.glu.nurbs.*;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Class responsible for rendering
+ * @author Tomas Hrasky
+ *
+ */
+public class GL2Backend extends Backend {
+  public GL2Backend() {
+    super();
+    curveEvaluator = new GL2CurveEvaluator();
+    surfaceEvaluator = new GL2SurfaceEvaluator();
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/gl2/nurbs/GL2CurveEvaluator.java b/src/jogl/classes/com/sun/opengl/impl/glu/gl2/nurbs/GL2CurveEvaluator.java
new file mode 100755
index 000000000..5be4f9049
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/gl2/nurbs/GL2CurveEvaluator.java
@@ -0,0 +1,205 @@
+package com.sun.opengl.impl.glu.gl2.nurbs;
+import com.sun.opengl.impl.glu.nurbs.*;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+import javax.media.opengl.GL;
+import javax.media.opengl.GL2;
+import javax.media.opengl.glu.GLU;
+import javax.media.opengl.glu.gl2.GLUgl2;
+
+/**
+ * Class rendering curves with OpenGL
+ * @author Tomáš Hráský
+ *
+ */
+class GL2CurveEvaluator implements CurveEvaluator {
+
+  /**
+   * Output triangles (for callback) or render curve 
+   */
+  private boolean output_triangles;
+
+  /**
+   * OpenGL object
+   */
+  private GL2 gl;
+
+  /**
+   * Not used
+   */
+  private int vertex_flag;
+
+  /**
+   * Not used
+   */
+  private int normal_flag;
+
+  /**
+   * Not used
+   */
+  private int color_flag;
+
+  /**
+   * Not used
+   */
+  private int texcoord_flag;
+
+  /**
+   * Number of bezier arc - used for color distinguishing of arcs forming NURBS curve
+   */
+  private int poradi;
+
+  /**
+   * Makes new Evaluator
+   */
+  public GL2CurveEvaluator() {
+    gl = GLUgl2.getCurrentGL2();
+  }
+
+  /**
+   * Pushes eval bit
+   */
+  public void bgnmap1f() {
+    // DONE
+    if (output_triangles) {
+      vertex_flag = 0;
+      normal_flag = 0;
+      color_flag = 0;
+      texcoord_flag = 0;
+    } else {
+      gl.glPushAttrib(GL2.GL_EVAL_BIT);
+    }
+
+  }
+
+  /**
+   * Pops all OpenGL attributes
+   */
+  public void endmap1f() {
+    // DONE
+    if (output_triangles) {
+
+    } else {
+      gl.glPopAttrib();
+    }
+
+  }
+
+  /**
+   * Initializes opengl evaluator
+   * @param type curve type
+   * @param ulo lowest u
+   * @param uhi highest u
+   * @param stride control point coords
+   * @param order curve order
+   * @param ps control points
+   */
+  public void map1f(int type, float ulo, float uhi, int stride, int order,
+                    CArrayOfFloats ps) {
+    if (output_triangles) {
+      // TODO code for callback (output_triangles probably indicates callback)
+      //				System.out.println("TODO curveevaluator.map1f-output_triangles");
+    } else {
+      gl.glMap1f(type, ulo, uhi, stride, order, ps.getArray(), ps
+                 .getPointer());
+
+      // DEBUG - drawing bézier control points
+      // gl.glColor3d(.5,.5,.5);
+      // gl.glPointSize(5);
+      // gl.glBegin(GL2.GL_POINTS);
+      // float[] ctrlpoints=ps.getArray();
+      // for(int i=ps.getPointer();i<ps.getPointer()+order;i++){
+      // gl.glVertex3d(ctrlpoints[i * 4], ctrlpoints[i * 4 + 1],0);
+      // }
+      // gl.glEnd();
+    }
+
+  }
+
+  /**
+   * Calls opengl enable
+   * @param type what to enable
+   */
+  public void enable(int type) {
+    // DONE
+    gl.glEnable(type);
+  }
+
+  /**
+   * Calls glMapGrid1f
+   * @param nu steps
+   * @param u1 low u
+   * @param u2 high u
+   */
+  public void mapgrid1f(int nu, float u1, float u2) {
+    if (output_triangles) {
+      //				System.out.println("TODO curveevaluator.mapgrid1f");
+    } else
+      gl.glMapGrid1f(nu, u1, u2);
+    //			// System.out.println("upravit NU");
+    // gl.glMapGrid1f(50,u1,u2);
+  }
+
+  /**
+   * Evaluates a curve using glEvalMesh1f
+   * @param style Backend.N_MESHFILL/N_MESHLINE/N_MESHPOINT
+   * @param from lowest param
+   * @param to highest param
+   */
+  public void mapmesh1f(int style, int from, int to) {
+    /* //DEBUG drawing control points
+       this.poradi++;
+       if (poradi % 2 == 0)
+       gl.glColor3f(1, 0, 0);
+       else
+       gl.glColor3f(0, 1, 0);
+    */
+    if (output_triangles) {
+      // TODO code for callback
+      //			System.out.println("TODO openglcurveevaluator.mapmesh1f output_triangles");
+    } else {
+      switch (style) {
+      case Backend.N_MESHFILL:
+      case Backend.N_MESHLINE:
+        gl.glEvalMesh1(GL2.GL_LINE, from, to);
+        break;
+      case Backend.N_MESHPOINT:
+        gl.glEvalMesh1(GL2.GL_POINT, from, to);
+        break;
+      }
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/gl2/nurbs/GL2SurfaceEvaluator.java b/src/jogl/classes/com/sun/opengl/impl/glu/gl2/nurbs/GL2SurfaceEvaluator.java
new file mode 100755
index 000000000..c226b7db9
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/gl2/nurbs/GL2SurfaceEvaluator.java
@@ -0,0 +1,217 @@
+package com.sun.opengl.impl.glu.gl2.nurbs;
+import com.sun.opengl.impl.glu.nurbs.*;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+import javax.media.opengl.GL;
+import javax.media.opengl.GL2;
+import javax.media.opengl.glu.GLU;
+import javax.media.opengl.glu.gl2.GLUgl2;
+
+/**
+ * Class rendering surfaces with OpenGL
+ * @author Tomas Hrasky
+ *
+ */
+class GL2SurfaceEvaluator implements SurfaceEvaluator {
+
+  /**
+   * JOGL OpenGL object
+   */
+  private GL2 gl;
+
+  /**
+   * Output triangles (callback)
+   */
+  private boolean output_triangles;
+
+  /**
+   * Number of patch - used for distinguishing bezier plates forming NURBS surface with different colors
+   */
+  private int poradi;
+
+  /**
+   * Creates new evaluator
+   */
+  public GL2SurfaceEvaluator() {
+    gl = GLUgl2.getCurrentGL2();
+  }
+
+  /**
+   * Pushes eval bit
+   */
+  public void bgnmap2f() {
+
+    if (output_triangles) {
+      // TODO outp triangles surfaceevaluator bgnmap2f
+      //			System.out.println("TODO surfaceevaluator.bgnmap2f output triangles");
+    } else {
+      gl.glPushAttrib(GL2.GL_EVAL_BIT);
+      //				System.out.println("TODO surfaceevaluator.bgnmap2f glgetintegerv");
+    }
+
+  }
+
+  /**
+   * Sets  glPolygonMode
+   * @param style polygon mode (N_MESHFILL/N_MESHLINE/N_MESHPOINT)
+   */
+  public void polymode(int style) {
+    if (!output_triangles) {
+      switch (style) {
+      default:
+      case NurbsConsts.N_MESHFILL:
+        gl.glPolygonMode(GL2.GL_FRONT_AND_BACK, GL2.GL_FILL);
+        break;
+      case NurbsConsts.N_MESHLINE:
+        gl.glPolygonMode(GL2.GL_FRONT_AND_BACK, GL2.GL_LINE);
+        break;
+      case NurbsConsts.N_MESHPOINT:
+        gl.glPolygonMode(GL2.GL_FRONT_AND_BACK, GL2.GL_POINT);
+        break;
+      }
+    }
+
+  }
+
+  /**
+   * Pops all attributes
+   */
+  public void endmap2f() {
+    // TODO Auto-generated method stub
+    if (output_triangles) {
+      //			System.out.println("TODO surfaceevaluator.endmap2f output triangles");
+    } else {
+      gl.glPopAttrib();
+      // TODO use LOD
+    }
+  }
+
+  /**
+   * Empty method
+   * @param ulo
+   * @param uhi
+   * @param vlo
+   * @param vhi
+   */
+  public void domain2f(float ulo, float uhi, float vlo, float vhi) {
+    // DONE
+  }
+
+  /**
+   * Defines 2D mesh
+   * @param nu number of steps in u direction
+   * @param u0 lowest u
+   * @param u1 highest u
+   * @param nv number of steps in v direction
+   * @param v0 lowest v
+   * @param v1 highest v
+   */
+  public void mapgrid2f(int nu, float u0, float u1, int nv, float v0, float v1) {
+
+    if (output_triangles) {
+      //			System.out.println("TODO openglsurfaceavaluator.mapgrid2f output_triangles");
+    } else {
+      gl.glMapGrid2d(nu, u0, u1, nv, v0, v1);
+    }
+
+  }
+
+  /**
+   * Evaluates surface
+   * @param style surface style
+   * @param umin minimum U
+   * @param umax maximum U
+   * @param vmin minimum V
+   * @param vmax maximum V
+   */
+  public void mapmesh2f(int style, int umin, int umax, int vmin, int vmax) {
+    if (output_triangles) {
+      //			System.out.println("TODO openglsurfaceavaluator.mapmesh2f output_triangles");
+    } else {
+      /* //DEBUG - draw control points
+         this.poradi++;
+         if (poradi % 2 == 0)
+         gl.glColor3f(1, 0, 0);
+         else if (poradi % 2 == 1)
+         gl.glColor3f(0, 1, 0);
+      */
+      switch (style) {
+      case NurbsConsts.N_MESHFILL:
+        gl.glEvalMesh2(GL2.GL_FILL, umin, umax, vmin, vmax);
+        break;
+      case NurbsConsts.N_MESHLINE:
+        gl.glEvalMesh2(GL2.GL_LINE, umin, umax, vmin, vmax);
+        break;
+      case NurbsConsts.N_MESHPOINT:
+        gl.glEvalMesh2(GL2.GL_POINT, umin, umax, vmin, vmax);
+        break;
+      }
+    }
+  }
+
+  /**
+   * Initializes evaluator
+   * @param type surface type
+   * @param ulo lowest u
+   * @param uhi highest u
+   * @param ustride number of objects between control points in u direction
+   * @param uorder surface order in u direction
+   * @param vlo lowest v
+   * @param vhi highest v
+   * @param vstride number of control points' coords
+   * @param vorder surface order in v direction
+   * @param pts control points
+   */
+  public void map2f(int type, float ulo, float uhi, int ustride, int uorder,
+                    float vlo, float vhi, int vstride, int vorder, CArrayOfFloats pts) {
+    // TODO Auto-generated method stub
+    if (output_triangles) {
+      //			System.out.println("TODO openglsurfaceevaluator.map2f output_triangles");
+    } else {
+      gl.glMap2f(type, ulo, uhi, ustride, uorder, vlo, vhi, vstride,
+                 vorder, pts.getArray(), pts.getPointer());
+    }
+  }
+
+  /**
+   * Calls opengl enable
+   * @param type what to enable
+   */
+  public void enable(int type) {
+    //DONE
+    gl.glEnable(type);
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/gl2/nurbs/GLUgl2nurbsImpl.java b/src/jogl/classes/com/sun/opengl/impl/glu/gl2/nurbs/GLUgl2nurbsImpl.java
new file mode 100755
index 000000000..d6c653a73
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/gl2/nurbs/GLUgl2nurbsImpl.java
@@ -0,0 +1,862 @@
+package com.sun.opengl.impl.glu.gl2.nurbs;
+import com.sun.opengl.impl.glu.nurbs.*;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+import java.lang.reflect.Method;
+
+import javax.media.opengl.GL;
+import javax.media.opengl.GL2;
+import javax.media.opengl.glu.GLUnurbs;
+
+/**
+ * Base object for working with NURBS curves and surfaces
+ * 
+ * @author Tomas Hrasky
+ * 
+ */
+public class GLUgl2nurbsImpl implements GLUnurbs {
+
+  /**
+   * Curve type - no type
+   */
+  public static final int CT_NONE = 0;
+
+  /**
+   * Curve type - NURBS curve
+   */
+  public static final int CT_NURBSCURVE = 1;
+
+  /**
+   * Curve type - picewise linear curve
+   */
+  public static final int CT_NPWLCURVE = 2;
+
+  /**
+   * Matrixes autoloading
+   */
+  private boolean autoloadmode;
+
+  /**
+   * Using callback
+   */
+  private int callBackFlag;
+
+  /**
+   * Object for error call backs
+   */
+  private Object errorCallback;
+
+  /**
+   * List of map definitions
+   */
+  Maplist maplist;
+
+  /**
+   * Indicates validity of data
+   */
+  private int isDataValid;
+
+  /**
+   * Are we in the middle of curve processing
+   */
+  private int inCurve;
+
+  /**
+   * Current curve
+   */
+  private O_curve currentCurve;
+
+  /**
+   * Are we in trim
+   */
+  private boolean inTrim;
+
+  /**
+   * Are we playbacking curve/surface rendering
+   */
+  private boolean playBack;
+
+  /**
+   * Next curve in linked list
+   */
+  private O_curve nextCurve;
+
+  /**
+   * Is curve modified
+   */
+  private int isCurveModified;
+
+  /**
+   * Object holding rendering settings
+   */
+  private Renderhints renderhints;
+
+  /**
+   * Display list
+   */
+  private DisplayList dl;
+
+  /**
+   * Object for subdividing curves and surfaces
+   */
+  private Subdivider subdivider;
+
+  /**
+   * Object responsible for rendering
+   */
+  private Backend backend;
+
+  /**
+   * Next picewise linear curve in linked list
+   */
+  private O_pwlcurve nextPwlcurve;
+
+  /**
+   * Next trimming NURBS curve in linked list
+   */
+  private O_nurbscurve nextNurbscurve;
+
+  /**
+   * Are we in the middle of surface processing
+   */
+  private int inSurface;
+
+  /**
+   * Are there any changes in trimming
+   */
+  private boolean isTrimModified;
+
+  /**
+   * Are there any changes in surface data
+   */
+  private boolean isDataSurfaceModified;
+
+  /**
+   * Nurber of trmims of processed surface
+   */
+  private int numTrims;
+
+  /**
+   * Current processed surface
+   */
+  private O_surface currentSurface;
+
+  /**
+   * Next trimming curve
+   */
+  private O_trim nextTrim;
+
+  /**
+   * Nextr surface in linked list
+   */
+  private O_nurbssurface nextNurbssurface;
+
+  /**
+   * Are there any changes in surface
+   */
+  private boolean isSurfaceModified;
+
+  /**
+   * Initializes default GLUgl2nurbs object
+   */
+  public GLUgl2nurbsImpl() {
+    // DONE
+    maplist = new Maplist(backend);
+    renderhints = new Renderhints();
+    subdivider = new Subdivider();
+    // original code
+
+    redefineMaps();
+
+    defineMap(GL2.GL_MAP2_NORMAL, 0, 3);
+    defineMap(GL2.GL_MAP1_NORMAL, 0, 3);
+    defineMap(GL2.GL_MAP2_TEXTURE_COORD_1, 0, 1);
+    defineMap(GL2.GL_MAP1_TEXTURE_COORD_1, 0, 1);
+    defineMap(GL2.GL_MAP2_TEXTURE_COORD_2, 0, 2);
+    defineMap(GL2.GL_MAP1_TEXTURE_COORD_2, 0, 2);
+    defineMap(GL2.GL_MAP2_TEXTURE_COORD_3, 0, 3);
+    defineMap(GL2.GL_MAP1_TEXTURE_COORD_3, 0, 3);
+    defineMap(GL2.GL_MAP2_TEXTURE_COORD_4, 1, 4);
+    defineMap(GL2.GL_MAP1_TEXTURE_COORD_4, 1, 4);
+    defineMap(GL2.GL_MAP2_VERTEX_4, 1, 4);
+    defineMap(GL2.GL_MAP1_VERTEX_4, 1, 4);
+    defineMap(GL2.GL_MAP2_VERTEX_3, 0, 3);
+    defineMap(GL2.GL_MAP1_VERTEX_3, 0, 3);
+    defineMap(GL2.GL_MAP2_COLOR_4, 0, 4);
+    defineMap(GL2.GL_MAP1_COLOR_4, 0, 4);
+    defineMap(GL2.GL_MAP2_INDEX, 0, 1);
+    defineMap(GL2.GL_MAP1_INDEX, 0, 1);
+
+    setnurbsproperty(GL2.GL_MAP1_VERTEX_3, NurbsConsts.N_SAMPLINGMETHOD,
+                     (float) NurbsConsts.N_PATHLENGTH);
+    setnurbsproperty(GL2.GL_MAP1_VERTEX_4, NurbsConsts.N_SAMPLINGMETHOD,
+                     (float) NurbsConsts.N_PATHLENGTH);
+    setnurbsproperty(GL2.GL_MAP2_VERTEX_3, NurbsConsts.N_SAMPLINGMETHOD,
+                     (float) NurbsConsts.N_PATHLENGTH);
+    setnurbsproperty(GL2.GL_MAP2_VERTEX_4, NurbsConsts.N_SAMPLINGMETHOD,
+                     (float) NurbsConsts.N_PATHLENGTH);
+
+    setnurbsproperty(GL2.GL_MAP1_VERTEX_3, NurbsConsts.N_PIXEL_TOLERANCE,
+                     (float) 50.0);
+    setnurbsproperty(GL2.GL_MAP1_VERTEX_4, NurbsConsts.N_PIXEL_TOLERANCE,
+                     (float) 50.0);
+    setnurbsproperty(GL2.GL_MAP2_VERTEX_3, NurbsConsts.N_PIXEL_TOLERANCE,
+                     (float) 50.0);
+    setnurbsproperty(GL2.GL_MAP2_VERTEX_4, NurbsConsts.N_PIXEL_TOLERANCE,
+                     (float) 50.0);
+
+    setnurbsproperty(GL2.GL_MAP1_VERTEX_3, NurbsConsts.N_ERROR_TOLERANCE,
+                     (float) 0.50);
+    setnurbsproperty(GL2.GL_MAP1_VERTEX_4, NurbsConsts.N_ERROR_TOLERANCE,
+                     (float) 0.50);
+    setnurbsproperty(GL2.GL_MAP2_VERTEX_3, NurbsConsts.N_ERROR_TOLERANCE,
+                     (float) 0.50);
+    setnurbsproperty(GL2.GL_MAP2_VERTEX_4, NurbsConsts.N_ERROR_TOLERANCE,
+                     (float) 0.50);
+
+    setnurbsproperty(GL2.GL_MAP1_VERTEX_3, NurbsConsts.N_S_STEPS,
+                     (float) 100.0);
+    setnurbsproperty(GL2.GL_MAP1_VERTEX_4, NurbsConsts.N_S_STEPS,
+                     (float) 100.0);
+    setnurbsproperty(GL2.GL_MAP2_VERTEX_3, NurbsConsts.N_S_STEPS,
+                     (float) 100.0);
+    setnurbsproperty(GL2.GL_MAP2_VERTEX_4, NurbsConsts.N_S_STEPS,
+                     (float) 100.0);
+
+    setnurbsproperty(GL2.GL_MAP1_VERTEX_3, NurbsConsts.N_SAMPLINGMETHOD,
+                     NurbsConsts.N_PATHLENGTH);
+
+    set_domain_distance_u_rate(100.0);
+    set_domain_distance_v_rate(100.0);
+    set_is_domain_distance_sampling(0);
+
+    this.autoloadmode = true;
+
+    this.callBackFlag = 0;
+
+    this.errorCallback = null;
+  }
+
+  /**
+   * Sets domain distance for dom.dist. sampling in u direction
+   * 
+   * @param d
+   *            distance
+   */
+  private void set_domain_distance_u_rate(double d) {
+    // DONE
+    subdivider.set_domain_distance_u_rate(d);
+  }
+
+  /**
+   * Sets domain distance for dom.dist. sampling in v direction
+   * 
+   * @param d
+   *            distance
+   */
+  private void set_domain_distance_v_rate(double d) {
+    // DONE
+    subdivider.set_domain_distance_v_rate(d);
+  }
+
+  /**
+   * Begins new NURBS curve
+   */
+  public void bgncurve() {
+    // DONE
+    O_curve o_curve = new O_curve();
+    thread("do_bgncurve", o_curve);
+  }
+
+  /**
+   * Calls a method with given name and passes argumet
+   * 
+   * @param name
+   *            name of a method to be called
+   * @param arg
+   *            parameter to be passed to called method
+   */
+  private void thread(String name, Object arg) {
+    // DONE
+    Class partype[] = new Class[1];
+    partype[0] = arg.getClass();
+    Method m;
+    try {
+      m = this.getClass().getMethod(name, partype);
+      if (dl != null) {
+        dl.append(this, m, arg);
+      } else {
+        m.invoke(this, new Object[] { arg });
+      }
+    } catch (Throwable e) {
+      e.printStackTrace();
+    }
+
+  }
+
+  /**
+   * Calls a method with given name
+   * 
+   * @param name
+   *            name of a method to be called
+   */
+  private void thread2(String name) {
+    // DONE
+    try {
+      Method m = this.getClass().getMethod(name, (Class[]) null);
+      if (dl != null) {
+        dl.append(this, m, null);
+      } else {
+        m.invoke(this, (Object[]) null);
+      }
+    } catch (Throwable e) {
+      e.printStackTrace();
+    }
+  }
+
+  /**
+   * Begins a NURBS curve
+   * 
+   * @param o_curve
+   *            curve object
+   */
+  public void do_bgncurve(O_curve o_curve) {
+    if (inCurve > 0) {
+      do_nurbserror(6);
+      endcurve();
+    }
+    inCurve = 1;
+    currentCurve = o_curve;
+
+    currentCurve.curvetype = CT_NONE;
+
+    if (inTrim) {
+      if (!nextCurve.equals(o_curve)) {
+        isCurveModified = 1;
+        nextCurve = o_curve;
+      }
+    } else {
+      if (!playBack)
+        bgnrender();
+      isDataValid = 1;
+    }
+    nextCurve = o_curve.next;
+    // kind of solution of union
+    nextPwlcurve = o_curve.o_pwlcurve;
+    nextNurbscurve = o_curve.o_nurbscurve;
+  }
+
+  /**
+   * Begins new surface
+   * 
+   * @param o_surface
+   *            surface object
+   */
+  public void do_bgnsurface(O_surface o_surface) {
+    // DONE
+    if (inSurface > 0) {
+      do_nurbserror(27);
+      endsurface();
+    }
+    inSurface = 1;
+    if (!playBack)
+      bgnrender();
+
+    isTrimModified = false;
+    isDataSurfaceModified = false;
+    isDataValid = 1;
+    numTrims = 0;
+    currentSurface = o_surface;
+    nextTrim = o_surface.o_trim;
+    nextNurbssurface = o_surface.o_nurbssurface;
+  }
+
+  /**
+   * End a curve
+   */
+  public void endcurve() {
+    // DONE
+    thread2("do_endcurve");
+  }
+
+  /**
+   * Ends surface
+   */
+  public void do_endsurface() {
+    // DONE
+    if (inTrim) {
+      do_nurbserror(12);
+      endtrim();
+    }
+
+    if (inSurface <= 0) {
+      do_nurbserror(13);
+      return;
+    }
+
+    inSurface = 0;
+
+    nextNurbssurface = null;
+
+    if (isDataValid <= 0) {
+      return;
+    }
+
+    if (nextTrim != null) {
+      isTrimModified = true;
+      nextTrim = null;
+    }
+
+    // TODO errval ??
+    if (numTrims > 0) {
+      //				System.out.println("TODO glunurbs.do_endsurface - numtrims > 0");
+    }
+
+    subdivider.beginQuilts(new GL2Backend());
+    for (O_nurbssurface n = currentSurface.o_nurbssurface; n != null; n = n.next) {
+      subdivider.addQuilt(n.bezier_patches);
+    }
+    subdivider.endQuilts();
+    subdivider.drawSurfaces();
+    if (!playBack)
+      endrender();
+
+  }
+
+  /**
+   * Ends a curve
+   */
+  public void do_endcurve() {
+    // DONE
+    //			// System.out.println("do_endcurve");
+    if (inCurve <= 0) {
+      do_nurbserror(7);
+      return;
+    }
+    inCurve = 0;
+
+    nextCurve = null;
+
+    if (currentCurve.curvetype == CT_NURBSCURVE) {
+      // nextNurbscurve = null;
+      // currentCurve.o_nurbscurve=null;
+    } else {
+      // nextPwlcurve = null;
+      // currentCurve.o_pwlcurve=null;
+    }
+    if (!inTrim) {
+      if (isDataValid <= 0) {
+        return;
+      }
+      // TODO errval?
+      if (currentCurve.curvetype == CT_NURBSCURVE) {
+        subdivider.beginQuilts(new GL2Backend());
+
+        for (O_nurbscurve n = currentCurve.o_nurbscurve; n != null; n = n.next)
+          subdivider.addQuilt(n.bezier_curves);
+
+        subdivider.endQuilts();
+        subdivider.drawCurves();
+        if (!playBack)
+          endrender();
+      } else {
+        if (!playBack)
+          endrender();
+        do_nurbserror(9);
+      }
+    }
+
+  }
+
+  /**
+   * Method for handling error codes
+   * 
+   * @param i
+   *            error code
+   */
+  private void do_nurbserror(int i) {
+    // TODO nurberror
+    //			System.out.println("TODO nurbserror " + i);
+  }
+
+  /**
+   * Begin rendering
+   */
+  private void bgnrender() {
+    // DONE
+    if (autoloadmode) {
+      loadGLMatrices();
+    }
+  }
+
+  /**
+   * Load matrices from OpenGL state machine
+   */
+  private void loadGLMatrices() {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO glunurbs.loadGLMatrices");
+  }
+
+  /**
+   * End rendering
+   */
+  private void endrender() {
+    // DONE
+  }
+
+  /**
+   * Make a NURBS curve
+   * 
+   * @param nknots
+   *            number of knots in knot vector
+   * @param knot
+   *            knot vector
+   * @param stride
+   *            number of control points coordinates
+   * @param ctlarray
+   *            control points
+   * @param order
+   *            order of the curve
+   * @param realType
+   *            type of the curve
+   */
+  public void nurbscurve(int nknots, float[] knot, int stride,
+                         float[] ctlarray, int order, int realType) {
+    // DONE
+    Mapdesc mapdesc = maplist.locate(realType);
+    if (mapdesc == null) {
+      do_nurbserror(35);
+      isDataValid = 0;
+      return;
+    }
+    if (ctlarray == null) {
+      do_nurbserror(36);
+      isDataValid = 0;
+      return;
+    }
+    if (stride < 0) {
+      do_nurbserror(34);
+      isDataValid = 0;
+      return;
+    }
+    Knotvector knots = new Knotvector(nknots, stride, order, knot);
+
+    if (!do_check_knots(knots, "curve"))
+      return;
+
+    O_nurbscurve o_nurbscurve = new O_nurbscurve(realType);
+    o_nurbscurve.bezier_curves = new Quilt(mapdesc);
+    CArrayOfFloats ctrlcarr = new CArrayOfFloats(ctlarray);
+    o_nurbscurve.bezier_curves.toBezier(knots, ctrlcarr, mapdesc
+                                        .getNCoords());
+    thread("do_nurbscurve", o_nurbscurve);
+  }
+
+  /**
+   * Check knot vector specification
+   * 
+   * @param knots
+   *            knot vector
+   * @param msg
+   *            error message
+   * @return knot vector is / is not valid
+   */
+  public boolean do_check_knots(Knotvector knots, String msg) {
+    // DONE
+    int status = knots.validate();
+    if (status > 0) {
+      do_nurbserror(status);
+      if (renderhints.errorchecking != NurbsConsts.N_NOMSG)
+        knots.show(msg);
+    }
+    return (status > 0) ? false : true;
+  }
+
+  /**
+   * Draw a curve
+   * 
+   * @param o_nurbscurve
+   *            NURBS curve object
+   */
+  public void do_nurbscurve(O_nurbscurve o_nurbscurve) {
+    // DONE
+
+    if (inCurve <= 0) {
+      bgncurve();
+      inCurve = 2;
+    }
+
+    if (o_nurbscurve.used) {
+      do_nurbserror(23);
+      isDataValid = 0;
+      return;
+    } else
+      o_nurbscurve.used = true;
+
+    if (currentCurve.curvetype == CT_NONE) {
+      currentCurve.curvetype = CT_NURBSCURVE;
+    } else if (currentCurve.curvetype != CT_NURBSCURVE) {
+      do_nurbserror(24);
+      isDataValid = 0;
+      return;
+    }
+
+    // it was necessary to overcome problem with pointer to pointer here
+
+    // if(!o_nurbscurve.equals(nextNurbscurve)){
+    if (!o_nurbscurve.equals(currentCurve.o_nurbscurve)) {
+      isCurveModified = 1;
+      currentCurve.o_nurbscurve = o_nurbscurve;
+      // nextNurbscurve=o_nurbscurve;
+
+    }
+
+    nextNurbscurve = o_nurbscurve.next;
+
+    if (!currentCurve.equals(o_nurbscurve.owner)) {
+      isCurveModified = 1;
+      o_nurbscurve.owner = currentCurve;
+    }
+
+    if (o_nurbscurve.owner == null)
+      isCurveModified = 1;
+
+    if (inCurve == 2)
+      endcurve();
+  }
+
+  /**
+   * Draw NURBS surface
+   * 
+   * @param o_nurbssurface
+   *            NURBS surface object
+   */
+  public void do_nurbssurface(O_nurbssurface o_nurbssurface) {
+    // DONE
+    if (inSurface <= 0) {
+      bgnsurface();
+      inSurface = 2;
+    }
+    if (o_nurbssurface.used) {
+      do_nurbserror(25);
+      isDataValid = 0;
+      return;
+    } else
+      o_nurbssurface.used = true;
+
+    if (!o_nurbssurface.equals(nextNurbscurve)) {
+      isSurfaceModified = true;
+      // nextNurbssurface=o_nurbssurface;
+      currentSurface.o_nurbssurface = o_nurbssurface;
+    }
+
+    if (!currentSurface.equals(o_nurbssurface.owner)) {
+      isSurfaceModified = true;
+      o_nurbssurface.owner = currentSurface;
+    }
+
+    nextNurbssurface = o_nurbssurface.next;
+
+    if (inSurface == 2)
+      endsurface();
+  }
+
+  /**
+   * (Re)Inicialize maps
+   */
+  public void redefineMaps() {
+    // DONE
+    maplist.initialize();
+  }
+
+  /**
+   * Define a map of given properties
+   * 
+   * @param type
+   *            map type
+   * @param rational
+   *            is rational
+   * @param ncoords
+   *            number of control point coordinates
+   */
+  public void defineMap(int type, int rational, int ncoords) {
+    // DONE
+    maplist.define(type, rational, ncoords);
+  }
+
+  /**
+   * Set NURBS property
+   * 
+   * @param type
+   *            property type
+   * @param tag
+   *            property tag
+   * @param value
+   *            property value
+   */
+  public void setnurbsproperty(int type, int tag, float value) {
+    // DONE
+    Mapdesc mapdesc = maplist.locate(type);
+    if (mapdesc == null) {
+      do_nurbserror(35);
+      return;
+    }
+    if (!mapdesc.isProperty(tag)) {
+      do_nurbserror(26);
+      return;
+    }
+    Property prop = new Property(type, tag, value);
+    thread("do_setnurbsproperty2", prop);
+  }
+
+  /**
+   * Set parameters of existing property
+   * 
+   * @param prop
+   *            property
+   */
+  public void do_setnurbsproperty2(Property prop) {
+    Mapdesc mapdesc = maplist.find(prop.type);
+    mapdesc.setProperty(prop.tag, prop.value);
+  }
+
+  /**
+   * Set given property to rendering hints
+   * 
+   * @param prop
+   *            property to be set
+   */
+  public void do_setnurbsproperty(Property prop) {
+    // DONE
+    renderhints.setProperty(prop);
+    // TODO freeproperty?
+  }
+
+  /**
+   * Sets wheteher we use domain distance sampling
+   * 
+   * @param i
+   *            domain distance sampling flag
+   */
+  public void set_is_domain_distance_sampling(int i) {
+    // DONE
+    subdivider.set_is_domain_distance_sampling(i);
+  }
+
+  /**
+   * Begin new surface
+   */
+  public void bgnsurface() {
+    // DONE
+    O_surface o_surface = new O_surface();
+    // TODO nuid
+    //			System.out.println("TODO glunurbs.bgnsurface nuid");
+    thread("do_bgnsurface", o_surface);
+  }
+
+  /**
+   * End current surface
+   */
+  public void endsurface() {
+    // DONE
+    thread2("do_endsurface");
+  }
+
+  /**
+   * End surface trimming
+   */
+  private void endtrim() {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO glunurbs.endtrim");
+  }
+
+  /**
+   * Make NURBS surface
+   * 
+   * @param sknot_count
+   *            number of knots in s direction
+   * @param sknot
+   *            knot vector in s direction
+   * @param tknot_count
+   *            number of knots in t direction
+   * @param tknot
+   *            knot vector in t direction
+   * @param s_stride
+   *            number of coords of control points in s direction
+   * @param t_stride
+   *            number of coords of control points in t direction
+   * @param ctlarray
+   *            control points
+   * @param sorder
+   *            order of curve in s direction
+   * @param torder
+   *            order of curve in t direction
+   * @param type
+   *            NURBS surface type (rational,...)
+   */
+  public void nurbssurface(int sknot_count, float[] sknot, int tknot_count,
+                           float[] tknot, int s_stride, int t_stride, float[] ctlarray,
+                           int sorder, int torder, int type) {
+    // DONE
+    Mapdesc mapdesc = maplist.locate(type);
+    if (mapdesc == null) {
+      do_nurbserror(35);
+      isDataValid = 0;
+      return;
+    }
+    if (s_stride < 0 || t_stride < 0) {
+      do_nurbserror(34);
+      isDataValid = 0;
+      return;
+    }
+    Knotvector sknotvector = new Knotvector(sknot_count, s_stride, sorder,
+                                            sknot);
+    if (!do_check_knots(sknotvector, "surface"))
+      return;
+    Knotvector tknotvector = new Knotvector(tknot_count, t_stride, torder,
+                                            tknot);
+    if (!do_check_knots(tknotvector, "surface"))
+      return;
+
+    O_nurbssurface o_nurbssurface = new O_nurbssurface(type);
+    o_nurbssurface.bezier_patches = new Quilt(mapdesc);
+
+    CArrayOfFloats ctrlarr = new CArrayOfFloats(ctlarray);
+    o_nurbssurface.bezier_patches.toBezier(sknotvector, tknotvector,
+                                           ctrlarr, mapdesc.getNCoords());
+    thread("do_nurbssurface", o_nurbssurface);
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/BuildMipmap.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/BuildMipmap.java
new file mode 100644
index 000000000..c30f83d20
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/BuildMipmap.java
@@ -0,0 +1,1598 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import javax.media.opengl.GL;
+import javax.media.opengl.GL2;
+import javax.media.opengl.glu.GLU;
+import javax.media.opengl.util.BufferUtil;
+import com.sun.opengl.impl.Debug;
+import java.nio.*;
+import java.io.*;
+
+/**
+ *
+ * @author  Administrator
+ */
+public class BuildMipmap {
+
+  private static final boolean DEBUG = Debug.debug("BuildMipmap");
+  private static final boolean VERBOSE = Debug.verbose();
+
+  /** Creates a new instance of BuildMipmap */
+  public BuildMipmap() {
+  }
+  
+  public static int gluBuild1DMipmapLevelsCore( GL gl, int target, int internalFormat,
+                  int width, int widthPowerOf2, int format, int type, int userLevel,
+                  int baseLevel, int maxLevel, ByteBuffer data ) {
+    int newwidth;
+    int level, levels;
+    ShortBuffer newImage = null;
+    int newImage_width;
+    ShortBuffer otherImage = null;
+    ShortBuffer imageTemp = null;
+    int memReq;
+    int maxsize;
+    int cmpts;
+    PixelStorageModes psm = new PixelStorageModes();
+    
+    assert( Mipmap.checkMipmapArgs( internalFormat, format, type ) == 0 );
+    assert( width >= 1 );
+    
+    newwidth = widthPowerOf2;
+    levels = Mipmap.computeLog( newwidth );
+    
+    levels += userLevel;
+    
+    Mipmap.retrieveStoreModes( gl, psm );
+    try {
+      newImage = BufferUtil.nativeOrder(ByteBuffer.allocateDirect( Mipmap.image_size( width, 1, format, 
+            GL2.GL_UNSIGNED_SHORT ) )).asShortBuffer();
+    } catch( OutOfMemoryError ome ) {
+      return( GLU.GLU_OUT_OF_MEMORY );
+    }
+    newImage_width = width;
+    
+    Image.fill_image( psm, width, 1, format, type, Mipmap.is_index( format ), data, newImage );
+    cmpts = Mipmap.elements_per_group( format, type );
+    gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, 2 );
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, 0 );
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, 0 );
+    gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, 0 );
+    
+    // if swap_bytes was set, swapping occurred in fill_image
+    gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, GL2.GL_FALSE );
+    
+    for( level = userLevel; level <= levels; level++ ) {
+      if( newImage_width == newwidth ) {
+        // user newimage for this level
+        if( baseLevel <= level && level <= maxLevel ) {
+          gl.getGL2().glTexImage1D( target, level, internalFormat, newImage_width, 0, format,
+                        GL2.GL_UNSIGNED_SHORT, newImage );
+        }
+      } else {
+        if( otherImage == null ) {
+          memReq = Mipmap.image_size( newwidth, 1, format, GL2.GL_UNSIGNED_SHORT );
+          try {
+            otherImage = BufferUtil.nativeOrder(ByteBuffer.allocateDirect( memReq )).asShortBuffer();
+          } catch( OutOfMemoryError ome ) {
+            gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, psm.getUnpackAlignment() );
+            gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, psm.getUnpackSkipRows() );
+            gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, psm.getUnpackSkipPixels() );
+            gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, psm.getUnpackRowLength() );
+            gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, (psm.getUnpackSwapBytes() ? 1 : 0) );
+            return( GLU.GLU_OUT_OF_MEMORY );
+          }
+        }
+        ScaleInternal.scale_internal( cmpts, newImage_width, 1, newImage, newwidth, 1, otherImage );
+        // swap newImage and otherImage
+        imageTemp = otherImage;
+        otherImage = newImage;
+        newImage = imageTemp;
+        
+        newImage_width = newwidth;
+        if( baseLevel <= level && level <= maxLevel ) {
+          gl.getGL2().glTexImage1D( target, level, internalFormat, newImage_width, 0, 
+                            format, GL2.GL_UNSIGNED_SHORT, newImage );
+        }
+      }
+      if( newwidth > 1 ) {
+        newwidth /= 2;
+      }
+    }
+    gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, psm.getUnpackAlignment() );
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, psm.getUnpackSkipRows() );
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, psm.getUnpackSkipPixels() );
+    gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, psm.getUnpackRowLength() );
+    gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, (psm.getUnpackSwapBytes() ? 1 : 0) );
+    
+    return( 0 );
+  }
+  
+  public static int bitmapBuild2DMipmaps( GL gl, int target, int internalFormat,
+            int width, int height, int format, int type, ByteBuffer data ) {
+    int newwidth[] = new int[1];
+    int newheight[] = new int[1];
+    int level, levels;
+    ShortBuffer newImage = null;
+    int newImage_width;
+    int newImage_height;
+    ShortBuffer otherImage = null;
+    ShortBuffer tempImage = null;
+    int memReq;
+    int maxsize;
+    int cmpts;
+    PixelStorageModes psm = new PixelStorageModes();
+    
+    Mipmap.retrieveStoreModes( gl, psm );
+    
+    Mipmap.closestFit( gl, target, width, height, internalFormat, format, type, newwidth, newheight );
+    
+    levels = Mipmap.computeLog( newwidth[0] );
+    level = Mipmap.computeLog( newheight[0] );
+    if( level > levels ) {
+      levels = level;
+    }
+    
+    try {
+      newImage = BufferUtil.nativeOrder(ByteBuffer.allocateDirect( Mipmap.image_size( width, height, 
+            format, GL2.GL_UNSIGNED_SHORT ) )).asShortBuffer();
+    } catch( OutOfMemoryError ome ) {
+      return( GLU.GLU_OUT_OF_MEMORY );
+    }
+    newImage_width = width;
+    newImage_height = height;
+    
+    Image.fill_image( psm, width, height, format, type, Mipmap.is_index( format ), data, newImage );
+    
+    cmpts = Mipmap.elements_per_group( format, type );
+    gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, 2 );
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, 0 );
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, 0 );
+    gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, 0 );
+    
+    // if swap_bytes is set, swapping occurred in fill_image
+    gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, GL2.GL_FALSE );
+    
+    for( level = 0; level < levels; level++ ) {
+      if( newImage_width == newwidth[0] && newImage_height == newheight[0] ) {
+        newImage.rewind();
+        gl.glTexImage2D( target, level, internalFormat, newImage_width,
+            newImage_height, 0, format, GL2.GL_UNSIGNED_SHORT, newImage );
+      } else {
+        if( otherImage == null ) {
+          memReq = Mipmap.image_size( newwidth[0], newheight[0], format, GL2.GL_UNSIGNED_SHORT );
+          try {
+            otherImage = BufferUtil.nativeOrder(ByteBuffer.allocateDirect( memReq )).asShortBuffer();
+          } catch( OutOfMemoryError ome ) {
+            gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, psm.getUnpackAlignment() );
+            gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, psm.getUnpackSkipRows() );
+            gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, psm.getUnpackSkipPixels() );
+            gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, psm.getUnpackRowLength() );
+            gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, (psm.getUnpackSwapBytes() ? 1 : 0) );
+            return( GLU.GLU_OUT_OF_MEMORY );
+          }
+        }
+        ScaleInternal.scale_internal( cmpts, newImage_width, newImage_height, 
+                              newImage, newwidth[0], newheight[0], otherImage );
+        // swap newImage and otherImage
+        tempImage = otherImage;
+        otherImage = newImage;
+        newImage = tempImage;
+        
+        newImage_width = newwidth[0];
+        newImage_height = newheight[0];
+        newImage.rewind();
+        gl.glTexImage2D( target, level, internalFormat, newImage_width, newImage_height,
+                                    0, format, GL2.GL_UNSIGNED_SHORT, newImage );
+      }
+      if( newheight[0] > 1 ) {
+        newwidth[0] /= 2;
+      }
+      if( newheight[0] > 1 ) {
+        newheight[0] /= 2;
+      }
+    }
+    gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, psm.getUnpackAlignment() );
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, psm.getUnpackSkipRows() );
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, psm.getUnpackSkipPixels() );
+    gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, psm.getUnpackRowLength() );
+    gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, (psm.getUnpackSwapBytes() ? 1 : 0) );
+    
+    return( 0 );
+  }
+  
+  public static int gluBuild2DMipmapLevelsCore( GL gl, int target, int internalFormat,
+                int width, int height, int widthPowerOf2, int heightPowerOf2,
+                int format, int type, int userLevel, int baseLevel, int maxLevel,
+                ByteBuffer data ) { // PointerWrapper data
+    int newwidth;
+    int newheight;
+    int level, levels;
+    int usersImage;
+    ByteBuffer srcImage = null;
+    ByteBuffer dstImage = null;
+    ByteBuffer tempImage = null;
+    int newImage_width;
+    int newImage_height;
+    short[] SWAP_IMAGE = null;
+    int memReq;
+    int maxsize;
+    int cmpts;
+    int mark=-1;
+    
+    boolean myswap_bytes;
+    int groups_per_line, element_size, group_size;
+    int rowsize, padding;
+    PixelStorageModes psm = new PixelStorageModes();
+    
+    assert( Mipmap.checkMipmapArgs( internalFormat, format, type ) == 0 );
+    assert( width >= 1 && height >= 1 );
+    
+    if( type == GL2.GL_BITMAP ) {
+      return( bitmapBuild2DMipmaps( gl, target, internalFormat, width, height, format, type, data ) );
+    }
+    
+    newwidth = widthPowerOf2;
+    newheight = heightPowerOf2;
+    levels = Mipmap.computeLog( newwidth );
+    level = Mipmap.computeLog( newheight );
+    if( level > levels ) {
+      levels = level;
+    }
+    
+    levels += userLevel;
+    
+    Mipmap.retrieveStoreModes( gl, psm );
+    myswap_bytes = psm.getUnpackSwapBytes();
+    cmpts = Mipmap.elements_per_group( format, type );
+    if( psm.getUnpackRowLength() > 0 ) {
+      groups_per_line = psm.getUnpackRowLength();
+    } else {
+      groups_per_line = width;
+    }
+    
+    element_size = Mipmap.bytes_per_element( type );
+    group_size = element_size * cmpts;
+    if( element_size == 1 ) {
+      myswap_bytes = false;
+    }
+    
+    rowsize = groups_per_line * group_size;
+    padding = ( rowsize % psm.getUnpackAlignment() );
+    if( padding != 0 ) {
+      rowsize += psm.getUnpackAlignment() - padding;
+    }
+    
+    mark = psm.getUnpackSkipRows() * rowsize + psm.getUnpackSkipPixels() * group_size;
+    data.position( mark );
+    
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, 0 );
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, 0 );
+    gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, 0 );
+    
+    level = userLevel;
+    
+    // already power of two square
+    if( width == newwidth && height == newheight ) {
+      // use usersImage for level userLevel
+      if( baseLevel <= level && level <= maxLevel ) {
+        data.rewind();
+        gl.glTexImage2D( target, level, internalFormat, width, height, 0, format, type, data );
+      }
+      if( levels == 0 ) { /* we're done. clean up and return */
+        gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, psm.getUnpackAlignment() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, psm.getUnpackSkipRows() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, psm.getUnpackSkipPixels() );
+        gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, psm.getUnpackRowLength() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, (psm.getUnpackSwapBytes() ? 1 : 0) );
+        return( 0 );
+      }
+      int nextWidth = newwidth / 2;
+      int nextHeight = newheight / 2;
+      
+      // clamp to 1
+      if( nextWidth < 1 ) {
+        nextWidth = 1;
+      }
+      if( nextHeight < 1 ) {
+        nextHeight = 1;
+      }
+      memReq = Mipmap.image_size( nextWidth, nextHeight, format, type );
+      
+      try {
+        switch( type ) {
+          case( GL2.GL_UNSIGNED_BYTE ):
+          case( GL2.GL_BYTE ):
+          case( GL2.GL_UNSIGNED_SHORT ):
+          case( GL2.GL_SHORT ):
+          case( GL2.GL_UNSIGNED_INT ):
+          case( GL2.GL_INT ):
+          case( GL2.GL_FLOAT ):
+          case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+          case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+          case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+          case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+          case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+          case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+          case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+          case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+          case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+          case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+          case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+          case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+            dstImage = BufferUtil.nativeOrder(ByteBuffer.allocateDirect( memReq ));
+            break;
+          default:
+            return( GLU.GLU_INVALID_ENUM );
+        }
+      } catch( OutOfMemoryError ome ) {
+        gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, psm.getUnpackAlignment() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, psm.getUnpackSkipRows() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, psm.getUnpackSkipPixels() );
+        gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, psm.getUnpackRowLength() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, (psm.getUnpackSwapBytes() ? 1 : 0) );
+        return( GLU.GLU_OUT_OF_MEMORY );
+      }
+      if( dstImage != null ) {
+        switch( type ) {
+          case( GL2.GL_UNSIGNED_BYTE ):
+            HalveImage.halveImage_ubyte( cmpts, width, height, data, dstImage, element_size, rowsize, group_size );
+            break;
+          case( GL2.GL_BYTE ):
+            HalveImage.halveImage_byte( cmpts, width, height, data, dstImage, element_size, rowsize, group_size );
+            break;
+          case( GL2.GL_UNSIGNED_SHORT ):
+            HalveImage.halveImage_ushort( cmpts, width, height, data, dstImage.asShortBuffer(), element_size, rowsize, group_size, myswap_bytes );
+            break;
+          case( GL2.GL_SHORT ):
+            HalveImage.halveImage_short( cmpts, width, height, data, dstImage.asShortBuffer(), element_size, rowsize, group_size, myswap_bytes );
+            break;
+          case( GL2.GL_UNSIGNED_INT ):
+            HalveImage.halveImage_uint( cmpts, width, height, data, dstImage.asIntBuffer(), element_size, rowsize, group_size, myswap_bytes );
+            break;
+          case( GL2.GL_INT ):
+            HalveImage.halveImage_int( cmpts, width, height, data, dstImage.asIntBuffer(), element_size, rowsize, group_size, myswap_bytes );
+            break;
+          case( GL2.GL_FLOAT ):
+            HalveImage.halveImage_float( cmpts, width, height, data, dstImage.asFloatBuffer(), element_size, rowsize, group_size, myswap_bytes );
+            break;
+          case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+            assert( format == GL2.GL_RGB );
+            HalveImage.halveImagePackedPixel( 3, new Extract332(), width, height, data, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+          case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+            assert( format == GL2.GL_RGB );
+            HalveImage.halveImagePackedPixel( 3, new Extract233rev(), width, height, data, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+          case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+            HalveImage.halveImagePackedPixel( 3, new Extract565(), width, height, data, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+          case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+            HalveImage.halveImagePackedPixel( 3, new Extract565rev(), width, height, data, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+          case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+            HalveImage.halveImagePackedPixel( 4, new Extract4444(), width, height, data, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+          case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+            HalveImage.halveImagePackedPixel( 4, new Extract4444rev(), width, height, data, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+          case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+            HalveImage.halveImagePackedPixel( 4, new Extract5551(), width, height, data, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+          case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+            HalveImage.halveImagePackedPixel( 4, new Extract1555rev(), width, height, data, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+          case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+            HalveImage.halveImagePackedPixel( 4, new Extract8888(), width, height, data, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+          case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+            HalveImage.halveImagePackedPixel( 4, new Extract8888rev(), width, height, data, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+          case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+            HalveImage.halveImagePackedPixel( 4, new Extract1010102(), width, height, data, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+          case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+            HalveImage.halveImagePackedPixel( 4, new Extract2101010rev(), width, height, data, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+          default:
+            assert( false );
+            break;
+        }
+      }
+      newwidth = width / 2;
+      newheight = height / 2;
+      // clamp to 1
+      if( newwidth < 1 ) {
+        newwidth = 1;
+      }
+      if( newheight < 1 ) {
+        newheight = 1;
+      }
+      
+      myswap_bytes = false;
+      rowsize = newwidth * group_size;
+      memReq = Mipmap.image_size( newwidth, newheight, format, type );
+      // swap srcImage and dstImage
+      tempImage = srcImage;
+      srcImage = dstImage;
+      dstImage = tempImage;
+      try {
+        switch( type ) {
+          case( GL2.GL_UNSIGNED_BYTE ):
+          case( GL2.GL_BYTE ):
+          case( GL2.GL_UNSIGNED_SHORT ):
+          case( GL2.GL_SHORT ):
+          case( GL2.GL_UNSIGNED_INT ):
+          case( GL2.GL_INT ):
+          case( GL2.GL_FLOAT ):
+          case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+          case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+          case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+          case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+          case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+          case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+          case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+          case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+          case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+          case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+          case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+          case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+            dstImage = BufferUtil.nativeOrder(ByteBuffer.allocateDirect( memReq ));
+            break;
+          default:
+            return( GLU.GLU_INVALID_ENUM );
+        }
+      } catch( OutOfMemoryError ome ) {
+        gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, psm.getUnpackAlignment() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, psm.getUnpackSkipRows() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, psm.getUnpackSkipPixels() );
+        gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, psm.getUnpackRowLength() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, (psm.getUnpackSwapBytes() ? 1 : 0) );
+        return( GLU.GLU_OUT_OF_MEMORY );
+      }
+      // level userLevel+1 is in srcImage; level userLevel already saved
+      level = userLevel + 1;
+    } else { // user's image is not nice powerof2 size square
+      memReq = Mipmap.image_size( newwidth, newheight, format, type );
+      try { 
+        switch( type ) {
+          case( GL2.GL_UNSIGNED_BYTE ):
+          case( GL2.GL_BYTE ):
+          case( GL2.GL_UNSIGNED_SHORT ):
+          case( GL2.GL_SHORT ):
+          case( GL2.GL_UNSIGNED_INT ):
+          case( GL2.GL_INT ):
+          case( GL2.GL_FLOAT ):
+          case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+          case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+          case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+          case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+          case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+          case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+          case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+          case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+          case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+          case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+          case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+          case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+            dstImage = BufferUtil.nativeOrder(ByteBuffer.allocateDirect( memReq ));
+            break;
+          default:
+            return( GLU.GLU_INVALID_ENUM );
+        }
+      } catch( OutOfMemoryError ome ) {
+        gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, psm.getUnpackAlignment() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, psm.getUnpackSkipRows() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, psm.getUnpackSkipPixels() );
+        gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, psm.getUnpackRowLength() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, (psm.getUnpackSwapBytes() ? 1 : 0) );
+        return( GLU.GLU_OUT_OF_MEMORY );
+      }
+      data.position( mark );
+      switch( type ) {
+        case( GL2.GL_UNSIGNED_BYTE ):
+          ScaleInternal.scale_internal_ubyte( cmpts, width, height, data, 
+                newwidth, newheight, dstImage, element_size, rowsize, group_size );
+          break;
+        case( GL2.GL_BYTE ):
+          ScaleInternal.scale_internal_byte( cmpts, width, height, data, newwidth, 
+                  newheight, dstImage, element_size, rowsize, group_size );
+          break;
+        case( GL2.GL_UNSIGNED_SHORT ):
+          ScaleInternal.scale_internal_ushort( cmpts, width, height, data, newwidth, 
+                  newheight, dstImage.asShortBuffer(), element_size, rowsize, group_size, myswap_bytes );
+          break;
+        case( GL2.GL_SHORT ):
+          ScaleInternal.scale_internal_ushort( cmpts, width, height, data, newwidth,
+                  newheight, dstImage.asShortBuffer(), element_size, rowsize, group_size, myswap_bytes );
+          break;
+        case( GL2.GL_UNSIGNED_INT ):
+          ScaleInternal.scale_internal_uint( cmpts, width, height, data, newwidth,
+                  newheight, dstImage.asIntBuffer(), element_size, rowsize, group_size, myswap_bytes );
+          break;
+        case( GL2.GL_INT ):
+          ScaleInternal.scale_internal_int( cmpts, width, height, data, newwidth,
+                  newheight, dstImage.asIntBuffer(), element_size, rowsize, group_size, myswap_bytes );
+          break;
+        case( GL2.GL_FLOAT ):
+          ScaleInternal.scale_internal_float( cmpts, width, height, data, newwidth,
+                  newheight, dstImage.asFloatBuffer(), element_size, rowsize, group_size, myswap_bytes );
+          break;
+        case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+          ScaleInternal.scaleInternalPackedPixel( 3, new Extract332(), width, height, data, newwidth,
+              newheight, dstImage, element_size, rowsize, myswap_bytes );
+          break;
+        case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+          ScaleInternal.scaleInternalPackedPixel( 3, new Extract233rev(), width, height, data, newwidth,
+              newheight, dstImage, element_size, rowsize, myswap_bytes );
+          break;
+        case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+          ScaleInternal.scaleInternalPackedPixel( 3, new Extract565(), width, height, data, newwidth,
+              newheight, dstImage, element_size, rowsize, myswap_bytes );
+          break;
+        case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+          ScaleInternal.scaleInternalPackedPixel( 3, new Extract565rev(), width, height, data, newwidth,
+              newheight, dstImage, element_size, rowsize, myswap_bytes );
+          break;
+        case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+          ScaleInternal.scaleInternalPackedPixel( 4, new Extract4444(), width, height, data, newwidth,
+              newheight, dstImage, element_size, rowsize, myswap_bytes );
+          break;
+        case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+          ScaleInternal.scaleInternalPackedPixel( 4, new Extract4444rev(), width, height, data, newwidth,
+              newheight, dstImage, element_size, rowsize, myswap_bytes );
+          break;
+        case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+          ScaleInternal.scaleInternalPackedPixel( 4, new Extract5551(), width, height, data, newwidth,
+              newheight, dstImage, element_size, rowsize, myswap_bytes );
+          break;
+        case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+          ScaleInternal.scaleInternalPackedPixel( 4, new Extract1555rev(), width, height, data, newwidth,
+              newheight, dstImage, element_size, rowsize, myswap_bytes );
+          break;
+        case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+          ScaleInternal.scaleInternalPackedPixel( 4, new Extract8888(), width, height, data, newwidth,
+              newheight, dstImage, element_size, rowsize, myswap_bytes );
+          break;
+        case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+          ScaleInternal.scaleInternalPackedPixel( 4, new Extract8888rev(), width, height, data, newwidth,
+              newheight, dstImage, element_size, rowsize, myswap_bytes );
+          break;
+        case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+          ScaleInternal.scaleInternalPackedPixel( 4, new Extract1010102(), width, height, data, newwidth,
+              newheight, dstImage, element_size, rowsize, myswap_bytes );
+          break;
+        case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+          ScaleInternal.scaleInternalPackedPixel( 4, new Extract2101010rev(), width, height, data, newwidth,
+              newheight, dstImage, element_size, rowsize, myswap_bytes );
+          break;
+        default:
+          assert( false );
+          break;
+      }
+      myswap_bytes = false;
+      rowsize = newwidth * group_size;
+      // swap dstImage and srcImage
+      tempImage = srcImage;
+      srcImage = dstImage;
+      dstImage = tempImage;
+      
+      if( levels != 0 ) { // use as little memory as possible
+        int nextWidth = newwidth / 2;
+        int nextHeight = newheight / 2;
+        if( nextWidth < 1 ) {
+          nextWidth = 1;
+        }
+        if( nextHeight < 1 ) {
+          nextHeight = 1;
+        }
+        
+        memReq = Mipmap.image_size( nextWidth, nextHeight, format, type );
+        try {
+          switch( type ) {
+            case( GL2.GL_UNSIGNED_BYTE ):
+            case( GL2.GL_BYTE ):
+            case( GL2.GL_UNSIGNED_SHORT ):
+            case( GL2.GL_SHORT ):
+            case( GL2.GL_UNSIGNED_INT ):
+            case( GL2.GL_INT ):
+            case( GL2.GL_FLOAT ):
+            case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+            case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+            case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+            case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+            case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+            case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+            case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+            case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+            case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+            case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+            case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+            case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+              dstImage = BufferUtil.nativeOrder(ByteBuffer.allocateDirect( memReq ));
+              break;
+            default:
+              return( GLU.GLU_INVALID_ENUM );
+          }
+        } catch( OutOfMemoryError ome ) {
+          gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, psm.getUnpackAlignment() );
+          gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, psm.getUnpackSkipRows() );
+          gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, psm.getUnpackSkipPixels() );
+          gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, psm.getUnpackRowLength() );
+          gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, (psm.getUnpackSwapBytes() ? 1 : 0) );
+          return( GLU.GLU_OUT_OF_MEMORY );
+        }
+      }
+      // level userLevel is in srcImage; nothing saved yet
+      level = userLevel;
+    }
+    
+    gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, GL2.GL_FALSE );
+    if( baseLevel <= level && level <= maxLevel ) {
+      srcImage.rewind();
+      gl.glTexImage2D( target, level, internalFormat, newwidth, newheight, 0, format, type, srcImage );
+      if (DEBUG) {
+        System.err.println("GL Error(" + level + "): " + gl.glGetError() );
+        if (VERBOSE) {
+          srcImage.limit( Mipmap.image_size( newwidth, newheight, format, type ) );
+          writeTargaFile("glu2DMipmapJ" + level + ".tga",
+                         srcImage, newwidth, newheight);
+          srcImage.clear();
+        }
+      }
+    }
+    
+    level++;  // update current level for the loop
+    for( ; level <= levels; level++ ) {
+      srcImage.rewind();
+      dstImage.rewind();
+      switch( type ) {
+        case( GL2.GL_UNSIGNED_BYTE ):
+          HalveImage.halveImage_ubyte( cmpts, newwidth, newheight, srcImage, dstImage, element_size, rowsize, group_size );
+          break;
+        case( GL2.GL_BYTE ):
+          HalveImage.halveImage_byte( cmpts, newwidth, newheight, srcImage, dstImage, element_size, rowsize, group_size );
+          break;
+        case( GL2.GL_UNSIGNED_SHORT ):
+          HalveImage.halveImage_ushort( cmpts, newwidth, newheight, srcImage, dstImage.asShortBuffer(), element_size, rowsize, group_size, myswap_bytes );
+          break;
+        case( GL2.GL_SHORT ):
+          HalveImage.halveImage_short( cmpts, newwidth, newheight, srcImage, dstImage.asShortBuffer(), element_size, rowsize, group_size, myswap_bytes );
+          break;
+        case( GL2.GL_UNSIGNED_INT ):
+          HalveImage.halveImage_uint( cmpts, newwidth, newheight, srcImage, dstImage.asIntBuffer(), element_size, rowsize, group_size, myswap_bytes );
+          break;
+        case( GL2.GL_INT ):
+          HalveImage.halveImage_int( cmpts, newwidth, newheight, srcImage, dstImage.asIntBuffer(), element_size, rowsize, group_size, myswap_bytes );
+          break;
+        case( GL2.GL_FLOAT ):
+          HalveImage.halveImage_float( cmpts, newwidth, newheight, srcImage, dstImage.asFloatBuffer(), element_size, rowsize, group_size, myswap_bytes );
+          break;
+        case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+          assert( format == GL2.GL_RGB );
+          HalveImage.halveImagePackedPixel( 3, new Extract332(), newwidth, newheight, srcImage, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+        case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+          assert( format == GL2.GL_RGB );
+          HalveImage.halveImagePackedPixel( 3, new Extract233rev(), newwidth, newheight, srcImage, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+        case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+          HalveImage.halveImagePackedPixel( 3, new Extract565(), newwidth, newheight, srcImage, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+        case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+          HalveImage.halveImagePackedPixel( 3, new Extract565rev(), newwidth, newheight, srcImage, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+        case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+          HalveImage.halveImagePackedPixel( 4, new Extract4444(), newwidth, newheight, srcImage, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+        case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+          HalveImage.halveImagePackedPixel( 4, new Extract4444rev(), newwidth, newheight, srcImage, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+        case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+          HalveImage.halveImagePackedPixel( 4, new Extract5551(), newwidth, newheight, srcImage, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+        case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+          HalveImage.halveImagePackedPixel( 4, new Extract1555rev(), newwidth, newheight, srcImage, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+        case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+          HalveImage.halveImagePackedPixel( 4, new Extract8888(), newwidth, newheight, srcImage, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+        case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+          HalveImage.halveImagePackedPixel( 4, new Extract8888rev(), newwidth, newheight, srcImage, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+        case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+          HalveImage.halveImagePackedPixel( 4, new Extract1010102(), newwidth, newheight, srcImage, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+        case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+          HalveImage.halveImagePackedPixel( 4, new Extract2101010rev(), newwidth, newheight, srcImage, dstImage, element_size, rowsize, myswap_bytes );
+            break;
+        default:
+          assert( false );
+          break;
+      }
+      
+      // swap dstImage and srcImage
+      tempImage = srcImage;
+      srcImage = dstImage;
+      dstImage = tempImage;
+      
+      if( newwidth > 1 ) {
+        newwidth /= 2;
+        rowsize /= 2;
+      }
+      if( newheight > 1 ) {
+        newheight /= 2;
+      }
+      // compute amount to pad per row if any
+      int rowPad = rowsize % psm.getUnpackAlignment();
+      
+      // should row be padded
+      if( rowPad == 0 ) {
+        // call teximage with srcImage untouched since its not padded
+        if( baseLevel <= level && level <= maxLevel ) {
+          srcImage.rewind();
+          gl.glTexImage2D( target, level, internalFormat, newwidth, newheight, 0, format, type, srcImage );
+          if (DEBUG) {
+            System.err.println("GL Error(" + level + "): " + gl.glGetError() );
+            if (VERBOSE) {
+              srcImage.limit( Mipmap.image_size( newwidth, newheight, format, type ) );
+              writeTargaFile("glu2DMipmapJ" + level + ".tga",
+                             srcImage, newwidth, newheight);
+              srcImage.clear();
+            }
+          }
+        }
+      } else {
+        // compute length of new row in bytes, including padding
+        int newRowLength = rowsize + psm.getUnpackAlignment() - rowPad;
+        int ii, jj;
+        int dstTrav;
+        int srcTrav;
+        
+        // allocate new image for mipmap of size newRowLength x newheight
+        ByteBuffer newMipmapImage = null;
+        try {
+          newMipmapImage = ByteBuffer.allocateDirect( newRowLength * newheight );
+        } catch( OutOfMemoryError ome ) {
+          gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, psm.getUnpackAlignment() );
+          gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, psm.getUnpackSkipRows() );
+          gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, psm.getUnpackSkipPixels() );
+          gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, psm.getUnpackRowLength() );
+          gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, (psm.getUnpackSwapBytes() ? 1 : 0) );
+          return( GLU.GLU_OUT_OF_MEMORY );
+        }
+        srcImage.rewind();
+        // copy image from srcImage into newMipmapImage by rows
+        for( ii = 0; ii < newheight; ii++ ) {
+          newMipmapImage.position(newRowLength * ii);
+          for( jj = 0; jj < rowsize; jj++ ) {
+            newMipmapImage.put( srcImage.get() );
+          }
+        }
+        
+        // and use this new image for mipmapping instead
+        if( baseLevel <= level && level <= maxLevel ) {
+          newMipmapImage.rewind();
+          gl.glTexImage2D( target, level, internalFormat, newwidth, newheight, 0, format, type, newMipmapImage );
+          if (DEBUG) {
+            System.err.println("GL Error(" + level + " padded): " + gl.glGetError() );
+            if (VERBOSE) {
+              writeTargaFile("glu2DMipmapJ" + level + ".tga",
+                             newMipmapImage, newwidth, newheight);
+            }
+          }
+        }
+      }
+    }
+    gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, psm.getUnpackAlignment() );
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, psm.getUnpackSkipRows() );
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, psm.getUnpackSkipPixels() );
+    gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, psm.getUnpackRowLength() );
+    gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, (psm.getUnpackSwapBytes() ? 1 : 0) );
+    
+    return( 0 );
+  }
+  
+  public static int fastBuild2DMipmaps( GL gl, PixelStorageModes psm, int target,
+          int components, int width, int height, int format, int type, ByteBuffer data ) {
+    int[] newwidth = new int[1];
+    int[] newheight = new int[1];
+    int level, levels;
+    ByteBuffer newImage;
+    int newImage_width;
+    int newImage_height;
+    ByteBuffer otherImage;
+    ByteBuffer imageTemp;
+    int memReq;
+    int maxsize;
+    int cmpts;
+    
+    Mipmap.closestFit( gl, target, width, height, components, format, type, newwidth, 
+            newheight );
+    
+    levels = Mipmap.computeLog( newwidth[0] );
+    level = Mipmap.computeLog( newheight[0] );
+    if( level > levels ) {
+      levels = level;
+    }
+    
+    cmpts = Mipmap.elements_per_group( format, type );
+    
+    otherImage = null;
+    //  No need to copy the user data if its packed correctly.
+    //  Make sure that later routines don't change that data.
+    
+    if( psm.getUnpackSkipRows() == 0 && psm.getUnpackSkipPixels() == 0 ) {
+      newImage = data;
+      newImage_width = width;
+      newImage_height = height;
+    } else {
+      int rowsize;
+      int group_per_line;
+      int elements_per_line;
+      int start;
+      int iter;
+      int iter2;
+      int i, j;
+      
+      try {
+        newImage = BufferUtil.nativeOrder(ByteBuffer.allocateDirect( Mipmap.image_size( 
+              width, height, format, GL2.GL_UNSIGNED_BYTE ) ));
+      } catch( OutOfMemoryError err ) {
+        return( GLU.GLU_OUT_OF_MEMORY );
+      }
+      newImage_width = width;
+      newImage_height = height;
+
+      // Abbreviated version of fill_image for the restricted case.
+      if( psm.getUnpackRowLength() > 0 ) {
+        group_per_line = psm.getUnpackRowLength();
+      } else {
+        group_per_line = width;
+      }
+      rowsize = group_per_line * cmpts;
+      elements_per_line = width * cmpts;
+      start = psm.getUnpackSkipRows() * rowsize + psm.getUnpackSkipPixels() * cmpts;
+      
+      for( i = 0; i < height; i++ ) {
+        iter = start;
+        data.position( iter );
+        for( j = 0; j < elements_per_line; j++ ) {
+          newImage.put( data.get() );
+        }
+        start += rowsize;
+      }
+    }
+    
+    gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, 1 );
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, 0 );
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, 0 );
+    gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, 0 );
+    gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, GL2.GL_FALSE );
+    
+    for( level = 0; level <= levels; level++ ) {
+      if( newImage_width == newwidth[0] && newImage_height == newheight[0] ) {
+        // use newImage for this level
+        newImage.rewind();
+        gl.glTexImage2D( target, level, components, newImage_width, newImage_height,
+                0, format, GL2.GL_UNSIGNED_BYTE, newImage );
+      } else {
+        if( otherImage == null ) {
+          memReq = Mipmap.image_size( newwidth[0], newheight[0], format, GL2.GL_UNSIGNED_BYTE );
+          try {
+            otherImage = BufferUtil.nativeOrder(ByteBuffer.allocateDirect( memReq ));
+          } catch( OutOfMemoryError err ) {
+            gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, psm.getUnpackAlignment() );
+            gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, psm.getUnpackSkipRows() );
+            gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, psm.getUnpackSkipPixels() );
+            gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, psm.getUnpackRowLength() );
+            gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, ( psm.getUnpackSwapBytes() ? 1 : 0 ) ) ;
+            return( GLU.GLU_OUT_OF_MEMORY );
+          }
+        }
+        // swap newImage and otherImage
+        imageTemp = otherImage;
+        otherImage = newImage;
+        newImage = imageTemp;
+        
+        newImage_width = newwidth[0];
+        newImage_height = newheight[0];
+        newImage.rewind();
+        gl.glTexImage2D( target, level, components, newImage_width, newImage_height,
+                0, format, GL2.GL_UNSIGNED_BYTE, newImage );
+      }
+      if( newwidth[0] > 1 ) {
+        newwidth[0] /= 2;
+      }
+      if( newheight[0] > 1 ) {
+        newheight[0] /= 2;
+      }
+    }
+    gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, psm.getUnpackAlignment() );
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, psm.getUnpackSkipRows() );
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, psm.getUnpackSkipPixels() );
+    gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, psm.getUnpackRowLength() );
+    gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, ( psm.getUnpackSwapBytes() ? 1 : 0 ) ) ;
+    
+    return( 0 );
+  }
+  
+  public static int gluBuild3DMipmapLevelsCore( GL gl, int target, int internalFormat,
+          int width, int height, int depth, int widthPowerOf2, int heightPowerOf2,
+          int depthPowerOf2, int format, int type, int userLevel, int baseLevel,
+          int maxLevel, ByteBuffer data ) {
+    int newWidth;
+    int newHeight;
+    int newDepth;
+    int level, levels;
+    ByteBuffer usersImage;
+    ByteBuffer srcImage, dstImage, tempImage;
+    int newImageWidth;
+    int newImageHeight;
+    int newImageDepth;
+    int memReq;
+    int maxSize;
+    int cmpts;
+    int mark=-1;
+    
+    boolean myswapBytes;
+    int groupsPerLine, elementSize, groupSize;
+    int rowsPerImage, imageSize;
+    int rowSize, padding;
+    PixelStorageModes psm = new PixelStorageModes();
+    
+    assert( Mipmap.checkMipmapArgs( internalFormat, format, type ) == 0 );
+    assert( width >= 1 && height >= 1 && depth >= 1 );
+    assert( type != GL2.GL_BITMAP );
+    
+    srcImage = dstImage = null;
+    
+    newWidth = widthPowerOf2;
+    newHeight = heightPowerOf2;
+    newDepth = depthPowerOf2;
+    levels = Mipmap.computeLog( newWidth );
+    level = Mipmap.computeLog( newHeight );
+    if( level > levels ) {
+      levels = level;
+    }
+    level = Mipmap.computeLog( newDepth );
+    if( level > levels ) {
+      levels = level;
+    }
+    
+    levels += userLevel;
+    
+    Mipmap.retrieveStoreModes3D( gl, psm );
+    myswapBytes = psm.getUnpackSwapBytes();
+    cmpts = Mipmap.elements_per_group( format, type );
+    if( psm.getUnpackRowLength() > 0 ) {
+      groupsPerLine = psm.getUnpackRowLength();
+    } else {
+      groupsPerLine = width;
+    }
+    
+    elementSize = Mipmap.bytes_per_element( type );
+    groupSize = elementSize * cmpts;
+    if( elementSize == 1 ) {
+      myswapBytes = false;
+    }
+    
+    // 3dstuff
+    if( psm.getUnpackImageHeight() > 0 ) {
+      rowsPerImage = psm.getUnpackImageHeight();
+    } else {
+      rowsPerImage = height;
+    }
+    
+    rowSize = groupsPerLine * groupSize;
+    padding = ( rowSize % psm.getUnpackAlignment() );
+    if( padding != 0 ) {
+      rowSize += psm.getUnpackAlignment() - padding;
+    }
+    
+    imageSize = rowsPerImage * rowSize;
+    
+    usersImage = ByteBuffer.wrap(data.array());
+    mark = psm.getUnpackSkipRows() * rowSize +
+           psm.getUnpackSkipPixels() * groupSize +
+           psm.getUnpackSkipImages() * imageSize;
+    usersImage.position( mark );
+    
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, 0 );
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, 0 );
+    gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, 0 );
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_IMAGES, 0 );
+    gl.glPixelStorei( GL2.GL_UNPACK_IMAGE_HEIGHT, 0 );
+    
+    level = userLevel;
+    
+    if( width == newWidth && height == newHeight && depth == newDepth ) {
+      // use usersImage for level userlevel
+      if( baseLevel <= level && level <= maxLevel ) {
+        gl.getGL2().glTexImage3D( target, level, internalFormat, width, height, depth,
+                0, format, type, usersImage );
+      }
+      if( levels == 0 ) { /* we're done. clean up and return */
+        gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, psm.getUnpackAlignment() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, psm.getUnpackSkipRows() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, psm.getUnpackSkipPixels() );
+        gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, psm.getUnpackRowLength() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, psm.getUnpackSwapBytes() ? 1 : 0 );
+        gl.glPixelStorei( GL2.GL_UNPACK_SKIP_IMAGES, psm.getUnpackSkipImages() );
+        gl.glPixelStorei( GL2.GL_UNPACK_IMAGE_HEIGHT, psm.getUnpackImageHeight() );
+        return( 0 );
+      }
+      int nextWidth = newWidth / 2;
+      int nextHeight = newHeight / 2;
+      int nextDepth = newDepth / 2;
+      
+      // clamp to one
+      if( nextWidth < 1 ) {
+        nextWidth = 1;
+      }
+      if( nextHeight < 1 ) {
+        nextHeight = 1;
+      }
+      if( nextDepth < 1 ) {
+        nextDepth = 1;
+      }
+      memReq = Mipmap.imageSize3D( nextWidth, nextHeight, nextDepth, format, type );
+      try {
+        switch( type ) {
+          case( GL2.GL_UNSIGNED_BYTE ):
+          case( GL2.GL_BYTE ):
+          case( GL2.GL_UNSIGNED_SHORT ):
+          case( GL2.GL_SHORT ):
+          case( GL2.GL_UNSIGNED_INT ):
+          case( GL2.GL_INT ):
+          case( GL2.GL_FLOAT ):
+          case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+          case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+          case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+          case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+          case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+          case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+          case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+          case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+          case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+          case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+          case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+          case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+            dstImage = BufferUtil.nativeOrder(ByteBuffer.allocateDirect( memReq ));
+            break;
+          default:
+            return( GLU.GLU_INVALID_ENUM );
+        }
+      } catch( OutOfMemoryError err ) {
+        gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, psm.getUnpackAlignment() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, psm.getUnpackSkipRows() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, psm.getUnpackSkipPixels() );
+        gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, psm.getUnpackRowLength() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, psm.getUnpackSwapBytes() ? 1 : 0 );
+        gl.glPixelStorei( GL2.GL_UNPACK_SKIP_IMAGES, psm.getUnpackSkipImages() );
+        gl.glPixelStorei( GL2.GL_UNPACK_IMAGE_HEIGHT, psm.getUnpackImageHeight() );
+        return( GLU.GLU_OUT_OF_MEMORY );
+      }
+      
+      if( dstImage != null ) {
+        switch( type ) {
+          case( GL2.GL_UNSIGNED_BYTE ):
+            if( depth > 1 ) {
+              HalveImage.halveImage3D( cmpts, new ExtractUByte(), width, height, depth,
+                      usersImage, dstImage, elementSize, 
+                      groupSize, rowSize, imageSize, myswapBytes );
+            } else {
+              HalveImage.halveImage_ubyte( cmpts, width, height, usersImage,
+                      dstImage, elementSize, rowSize, groupSize );
+            }
+            break;
+          case( GL2.GL_BYTE ):
+            if( depth > 1 ) {
+              HalveImage.halveImage3D( cmpts, new ExtractSByte(), width, height, depth,
+                      usersImage, dstImage, elementSize, groupSize, rowSize,
+                      imageSize, myswapBytes );
+            } else {
+              HalveImage.halveImage_byte( cmpts, width, height, usersImage,
+                      dstImage, elementSize, rowSize, groupSize );
+            }
+            break;
+          case( GL2.GL_UNSIGNED_SHORT ):
+            if( depth > 1 ) {
+              HalveImage.halveImage3D( cmpts, new ExtractUShort(), width, height, depth,
+                      usersImage, dstImage, elementSize, groupSize, rowSize,
+                      imageSize, myswapBytes );
+            } else {
+              HalveImage.halveImage_ushort( cmpts, width, height, usersImage, 
+                      dstImage.asShortBuffer(), elementSize, rowSize, groupSize, myswapBytes );
+            }
+            break;
+          case( GL2.GL_SHORT ):
+            if( depth > 1 ) {
+              HalveImage.halveImage3D( cmpts, new ExtractSShort(), width, height, depth,
+                      usersImage, dstImage, elementSize, groupSize, rowSize,
+                      imageSize, myswapBytes );
+            } else {
+              HalveImage.halveImage_short( cmpts, width, height, usersImage,
+                      dstImage.asShortBuffer(), elementSize, rowSize, groupSize, myswapBytes );
+            }
+            break;
+          case( GL2.GL_UNSIGNED_INT ):
+            if( depth > 1 ) {
+              HalveImage.halveImage3D( cmpts, new ExtractUInt(), width, height, depth,
+                      usersImage, dstImage, elementSize, groupSize, rowSize,
+                      imageSize, myswapBytes );
+            } else {
+              HalveImage.halveImage_uint( cmpts, width, height, usersImage,
+                      dstImage.asIntBuffer(), elementSize, rowSize, groupSize, myswapBytes );
+            }
+            break;
+          case( GL2.GL_INT ):
+            if( depth > 1 ) {
+              HalveImage.halveImage3D( cmpts, new ExtractSInt(), width, height, depth,
+                      usersImage, dstImage, elementSize, groupSize, rowSize,
+                      imageSize, myswapBytes );
+            } else {
+              HalveImage.halveImage_int( cmpts, width, height, usersImage,
+                      dstImage.asIntBuffer(), elementSize, rowSize, groupSize, myswapBytes );
+            }
+            break;
+          case( GL2.GL_FLOAT ):
+            if( depth > 1 ) {
+              HalveImage.halveImage3D( cmpts, new ExtractFloat(), width, height, depth,
+                      usersImage, dstImage, elementSize, groupSize, rowSize,
+                      imageSize, myswapBytes );
+            } else {
+              HalveImage.halveImage_float( cmpts, width, height, usersImage,
+                      dstImage.asFloatBuffer(), elementSize, rowSize, groupSize, myswapBytes );
+            }
+            break;
+          case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+            assert( format == GL2.GL_RGB );
+            HalveImage.halveImagePackedPixel3D( 3, new Extract332(), width, height, depth, usersImage,
+                    dstImage, elementSize, rowSize, imageSize, myswapBytes );
+            break;
+          case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+            assert( format == GL2.GL_RGB );
+            HalveImage.halveImagePackedPixel3D( 3, new Extract233rev(), width, height, depth, usersImage,
+                    dstImage, elementSize, rowSize, imageSize, myswapBytes );
+            break;
+          case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+            HalveImage.halveImagePackedPixel3D( 3, new Extract565(), width, height, depth, usersImage,
+                    dstImage, elementSize, rowSize, imageSize, myswapBytes );
+            break;
+          case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+            HalveImage.halveImagePackedPixel3D( 3, new Extract565rev(), width, height, depth, usersImage,
+                    dstImage, elementSize, rowSize, imageSize, myswapBytes );
+            break;
+          case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+            HalveImage.halveImagePackedPixel3D( 4, new Extract4444(), width, height, depth, usersImage,
+                    dstImage, elementSize, rowSize, imageSize, myswapBytes );
+            break;
+          case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+            HalveImage.halveImagePackedPixel3D( 4, new Extract4444rev(), width, height, depth, usersImage,
+                    dstImage, elementSize, rowSize, imageSize, myswapBytes );
+            break;
+          case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+            HalveImage.halveImagePackedPixel3D( 4, new Extract5551(), width, height, depth, usersImage,
+                    dstImage, elementSize, rowSize, imageSize, myswapBytes );
+            break;
+          case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+            HalveImage.halveImagePackedPixel3D( 4, new Extract1555rev(), width, height, depth, usersImage,
+                    dstImage, elementSize, rowSize, imageSize, myswapBytes );
+            break;
+          case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+            HalveImage.halveImagePackedPixel3D( 4, new Extract8888(), width, height, depth, usersImage,
+                    dstImage, elementSize, rowSize, imageSize, myswapBytes );
+            break;
+          case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+            HalveImage.halveImagePackedPixel3D( 4, new Extract8888rev(), width, height, depth, usersImage,
+                    dstImage, elementSize, rowSize, imageSize, myswapBytes );
+            break;
+          case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+            HalveImage.halveImagePackedPixel3D( 4, new Extract1010102(), width, height, depth, usersImage,
+                    dstImage, elementSize, rowSize, imageSize, myswapBytes );
+            break;
+          case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+            HalveImage.halveImagePackedPixel3D( 4, new Extract2101010rev(), width, height, depth, usersImage,
+                    dstImage, elementSize, rowSize, imageSize, myswapBytes );
+            break;
+          default:
+            assert( false );
+            break;
+        }
+      }
+      newWidth = width / 2;
+      newHeight = height / 2;
+      newDepth = depth / 2;
+      // clamp to 1
+      if( newWidth < 1 ) {
+        newWidth = 1;
+      }
+      if( newHeight < 1 ) {
+        newHeight = 1;
+      }
+      if( newDepth < 1 ) {
+        newDepth = 1;
+      }
+      
+      myswapBytes = false;
+      rowSize = newWidth * groupSize;
+      imageSize = rowSize * newHeight;
+      memReq = Mipmap.imageSize3D( newWidth, newHeight, newDepth, format, type );
+      // swap srcImage and dstImage
+      tempImage = srcImage;
+      srcImage = dstImage;
+      dstImage = tempImage;
+      try {
+        switch( type ) {
+          case( GL2.GL_UNSIGNED_BYTE ):
+          case( GL2.GL_BYTE ):
+          case( GL2.GL_UNSIGNED_SHORT ):
+          case( GL2.GL_SHORT ):
+          case( GL2.GL_UNSIGNED_INT ):
+          case( GL2.GL_INT ):
+          case( GL2.GL_FLOAT ):
+          case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+          case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+          case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+          case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+          case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+          case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+          case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+          case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+          case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+          case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+          case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+          case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+            dstImage = BufferUtil.nativeOrder(ByteBuffer.allocateDirect( memReq ));
+            break;
+          default:
+            return( GLU.GLU_INVALID_ENUM );
+        }
+      } catch( OutOfMemoryError err ) {
+        gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, psm.getUnpackAlignment() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, psm.getUnpackSkipRows() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, psm.getUnpackSkipPixels() );
+        gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, psm.getUnpackRowLength() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, psm.getUnpackSwapBytes() ? 1 : 0 );
+        gl.glPixelStorei( GL2.GL_UNPACK_SKIP_IMAGES, psm.getUnpackSkipImages() );
+        gl.glPixelStorei( GL2.GL_UNPACK_IMAGE_HEIGHT, psm.getUnpackImageHeight() );
+        return( GLU.GLU_OUT_OF_MEMORY );
+      }
+      
+      // level userLevel + 1 is in srcImage; level userLevel already saved
+      level = userLevel + 1;
+    } else {
+      memReq = Mipmap.imageSize3D( newWidth, newHeight, newDepth, format, type );
+      try {
+        switch( type ) {
+          case( GL2.GL_UNSIGNED_BYTE ):
+          case( GL2.GL_BYTE ):
+          case( GL2.GL_UNSIGNED_SHORT ):
+          case( GL2.GL_SHORT ):
+          case( GL2.GL_UNSIGNED_INT ):
+          case( GL2.GL_INT ):
+          case( GL2.GL_FLOAT ):
+          case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+          case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+          case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+          case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+          case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+          case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+          case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+          case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+          case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+          case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+          case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+          case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+            dstImage = BufferUtil.nativeOrder(ByteBuffer.allocateDirect( memReq ));
+            break;
+          default:
+            return( GLU.GLU_INVALID_ENUM );
+        }
+      } catch( OutOfMemoryError err ) {
+        gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, psm.getUnpackAlignment() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, psm.getUnpackSkipRows() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, psm.getUnpackSkipPixels() );
+        gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, psm.getUnpackRowLength() );
+        gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, psm.getUnpackSwapBytes() ? 1 : 0 );
+        gl.glPixelStorei( GL2.GL_UNPACK_SKIP_IMAGES, psm.getUnpackSkipImages() );
+        gl.glPixelStorei( GL2.GL_UNPACK_IMAGE_HEIGHT, psm.getUnpackImageHeight() );
+        return( GLU.GLU_OUT_OF_MEMORY );
+      }
+      
+      ScaleInternal.gluScaleImage3D( gl, format, width, height, depth, type,
+              usersImage, newWidth, newHeight, newDepth, type, dstImage );
+      
+      myswapBytes = false;
+      rowSize = newWidth * groupSize;
+      imageSize = rowSize * newHeight;
+      // swap dstImage and srcImage
+      tempImage = srcImage;
+      srcImage = dstImage;
+      dstImage = tempImage;
+      
+      if( levels != 0 ) {
+        int nextWidth = newWidth / 2;
+        int nextHeight = newHeight / 2;
+        int nextDepth = newDepth / 2;
+        if( nextWidth < 1 ) {
+          nextWidth = 1;
+        }
+        if( nextHeight < 1 ) {
+          nextHeight = 1;
+        }
+        if( nextDepth < 1 ) {
+          nextDepth = 1;
+        }
+        memReq = Mipmap.imageSize3D( nextWidth, nextHeight, nextDepth, format, type );
+        try {
+          switch( type ) {
+            case( GL2.GL_UNSIGNED_BYTE ):
+            case( GL2.GL_BYTE ):
+            case( GL2.GL_UNSIGNED_SHORT ):
+            case( GL2.GL_SHORT ):
+            case( GL2.GL_UNSIGNED_INT ):
+            case( GL2.GL_INT ):
+            case( GL2.GL_FLOAT ):
+            case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+            case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+            case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+            case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+            case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+            case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+            case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+            case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+            case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+            case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+            case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+            case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+              dstImage = BufferUtil.nativeOrder(ByteBuffer.allocateDirect( memReq ));
+              break;
+            default:
+              return( GLU.GLU_INVALID_ENUM );
+          }
+        } catch( OutOfMemoryError err ) {
+          gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, psm.getUnpackAlignment() );
+          gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, psm.getUnpackSkipRows() );
+          gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, psm.getUnpackSkipPixels() );
+          gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, psm.getUnpackRowLength() );
+          gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, psm.getUnpackSwapBytes() ? 1 : 0 );
+          gl.glPixelStorei( GL2.GL_UNPACK_SKIP_IMAGES, psm.getUnpackSkipImages() );
+          gl.glPixelStorei( GL2.GL_UNPACK_IMAGE_HEIGHT, psm.getUnpackImageHeight() );
+          return( GLU.GLU_OUT_OF_MEMORY );
+        }
+      }
+      // level userLevel is in srcImage; nothing saved yet
+      level = userLevel;
+    }
+    
+    gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, GL2.GL_FALSE );
+    if( baseLevel <= level && level <= maxLevel ) {
+      usersImage.position( mark );
+      gl.getGL2().glTexImage3D( target, level, internalFormat, width, height, depth,
+              0, format, type, usersImage );
+    }
+    level++;
+    for( ; level <= levels; level++ ) {
+      switch( type ) {
+        case( GL2.GL_UNSIGNED_BYTE ):
+          if( depth > 1 ) {
+            HalveImage.halveImage3D( cmpts, new ExtractUByte(), width, height, depth,
+                    usersImage, dstImage, elementSize, groupSize, rowSize,
+                    imageSize, myswapBytes );
+          } else {
+            HalveImage.halveImage_ubyte( cmpts, width, height, usersImage,
+                    dstImage, elementSize, rowSize, groupSize );
+          }
+          break;
+        case( GL2.GL_BYTE ):
+          if( depth > 1 ) {
+            HalveImage.halveImage3D( cmpts, new ExtractSByte(), width, height, depth,
+                    usersImage, dstImage, elementSize, groupSize, rowSize,
+                    imageSize, myswapBytes );
+          } else {
+            HalveImage.halveImage_byte( cmpts, width, height, usersImage,
+                    dstImage, elementSize, rowSize, groupSize );
+          }
+          break;
+        case( GL2.GL_UNSIGNED_SHORT ):
+          if( depth > 1 ) {
+            HalveImage.halveImage3D( cmpts, new ExtractUShort(), width, height, depth,
+                    usersImage, dstImage, elementSize, groupSize, rowSize,
+                    imageSize, myswapBytes );
+          } else {
+            HalveImage.halveImage_ushort( cmpts, width, height, usersImage,
+                    dstImage.asShortBuffer(), elementSize, rowSize, groupSize, myswapBytes );
+          }
+          break;
+        case( GL2.GL_SHORT ):
+          if( depth > 1 ) {
+            HalveImage.halveImage3D( cmpts, new ExtractSShort(), width, height, depth,
+                    usersImage, dstImage, elementSize, groupSize, rowSize,
+                    imageSize, myswapBytes );
+          } else {
+            HalveImage.halveImage_short( cmpts, width, height, usersImage,
+                    dstImage.asShortBuffer(), elementSize, rowSize, groupSize, myswapBytes );
+          }
+          break;
+        case( GL2.GL_UNSIGNED_INT ):
+          if( depth > 1 ) {
+            HalveImage.halveImage3D( cmpts, new ExtractUInt(), width, height, depth,
+                    usersImage, dstImage, elementSize, groupSize, rowSize,
+                    imageSize, myswapBytes );
+          } else {
+            HalveImage.halveImage_uint( cmpts, width, height, usersImage,
+                    dstImage.asIntBuffer(), elementSize, rowSize, groupSize, myswapBytes );
+          }
+          break;
+        case( GL2.GL_INT ):
+          if( depth > 1 ) {
+            HalveImage.halveImage3D( cmpts, new ExtractSInt(), width, height, depth,
+                    usersImage, dstImage, elementSize, groupSize, rowSize,
+                    imageSize, myswapBytes );
+          } else {
+            HalveImage.halveImage_int( cmpts, width, height, usersImage,
+                    dstImage.asIntBuffer(), elementSize, rowSize, groupSize, myswapBytes );
+          }
+          break;
+        case( GL2.GL_FLOAT ):
+          if( depth > 1 ) {
+            HalveImage.halveImage3D( cmpts, new ExtractFloat(), width, height, depth,
+                    usersImage, dstImage, elementSize, groupSize, rowSize,
+                    imageSize, myswapBytes );
+          } else {
+            HalveImage.halveImage_float( cmpts, width, height, usersImage,
+                    dstImage.asFloatBuffer(), elementSize, rowSize, groupSize, myswapBytes );
+          }
+          break;
+        case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+          HalveImage.halveImagePackedPixel3D( 3, new Extract332(), width, height, depth, usersImage,
+                  dstImage, elementSize, rowSize, imageSize, myswapBytes );
+          break;
+        case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+          HalveImage.halveImagePackedPixel3D( 3, new Extract233rev(), width, height, depth, usersImage,
+                  dstImage, elementSize, rowSize, imageSize, myswapBytes );
+          break;
+        case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+          HalveImage.halveImagePackedPixel3D( 3, new Extract565(), width, height, depth, usersImage,
+                  dstImage, elementSize, rowSize, imageSize, myswapBytes );
+          break;
+        case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+          HalveImage.halveImagePackedPixel3D( 3, new Extract565rev(), width, height, depth, usersImage,
+                  dstImage, elementSize, rowSize, imageSize, myswapBytes );
+          break;
+        case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+          HalveImage.halveImagePackedPixel3D( 4, new Extract4444(), width, height, depth, usersImage,
+                  dstImage, elementSize, rowSize, imageSize, myswapBytes );
+          break;
+        case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+          HalveImage.halveImagePackedPixel3D( 4, new Extract4444rev(), width, height, depth, usersImage,
+                  dstImage, elementSize, rowSize, imageSize, myswapBytes );
+          break;
+        case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+          HalveImage.halveImagePackedPixel3D( 4, new Extract5551(), width, height, depth, usersImage,
+                  dstImage, elementSize, rowSize, imageSize, myswapBytes );
+          break;
+        case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+          HalveImage.halveImagePackedPixel3D( 4, new Extract1555rev(), width, height, depth, usersImage,
+                  dstImage, elementSize, rowSize, imageSize, myswapBytes );
+          break;
+        case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+          HalveImage.halveImagePackedPixel3D( 4, new Extract8888(), width, height, depth, usersImage,
+                  dstImage, elementSize, rowSize, imageSize, myswapBytes );
+          break;
+        case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+          HalveImage.halveImagePackedPixel3D( 4, new Extract8888rev(), width, height, depth, usersImage,
+                  dstImage, elementSize, rowSize, imageSize, myswapBytes );
+          break;
+        case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+          HalveImage.halveImagePackedPixel3D( 4, new Extract1010102(), width, height, depth, usersImage,
+                  dstImage, elementSize, rowSize, imageSize, myswapBytes );
+          break;
+        case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+          HalveImage.halveImagePackedPixel3D( 4, new Extract2101010rev(), width, height, depth, usersImage,
+                  dstImage, elementSize, rowSize, imageSize, myswapBytes );
+          break;
+        default:
+          assert( false );
+          break;
+      }
+      
+      tempImage = srcImage;
+      srcImage = dstImage;
+      dstImage = tempImage;
+      
+      if( newWidth > 1 ) {
+        newWidth /= 2;
+        rowSize /= 2;
+      }
+      if( newHeight > 1 ) {
+        newHeight /= 2;
+        imageSize = rowSize * newHeight;
+      }
+      if( newDepth > 1 ) {
+        newDepth /= 2;
+      }
+      if( baseLevel <= level && level <= maxLevel ) {
+        usersImage.position( mark );
+        gl.getGL2().glTexImage3D( target, level, internalFormat, width, height, depth,
+                0, format, type, usersImage );
+      }
+    }
+    gl.glPixelStorei( GL2.GL_UNPACK_ALIGNMENT, psm.getUnpackAlignment() );
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_ROWS, psm.getUnpackSkipRows() );
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_PIXELS, psm.getUnpackSkipPixels() );
+    gl.glPixelStorei( GL2.GL_UNPACK_ROW_LENGTH, psm.getUnpackRowLength() );
+    gl.glPixelStorei( GL2.GL_UNPACK_SWAP_BYTES, psm.getUnpackSwapBytes() ? 1 : 0 );
+    gl.glPixelStorei( GL2.GL_UNPACK_SKIP_IMAGES, psm.getUnpackSkipImages() );
+    gl.glPixelStorei( GL2.GL_UNPACK_IMAGE_HEIGHT, psm.getUnpackImageHeight() );
+    return( 0 );
+  }
+
+  private static final int TARGA_HEADER_SIZE = 18;
+  private static void writeTargaFile(String filename, ByteBuffer data,
+                                     int width, int height) {
+    try {
+      FileOutputStream fos = new FileOutputStream(new File(filename));
+      ByteBuffer header = ByteBuffer.allocateDirect(TARGA_HEADER_SIZE);
+      header.put(0, (byte) 0).put(1, (byte) 0);
+      header.put(2, (byte) 2); // uncompressed type
+      header.put(12, (byte) (width & 0xFF)); // width
+      header.put(13, (byte) (width >> 8)); // width
+      header.put(14, (byte) (height & 0xFF)); // height
+      header.put(15, (byte) (height >> 8)); // height
+      header.put(16, (byte) 24); // pixel size
+      fos.write(header.array());
+      fos.write(data.array());
+      data.clear();
+      fos.close();
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract.java
new file mode 100644
index 000000000..d5224af74
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract.java
@@ -0,0 +1,56 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.ByteBuffer;
+
+/**
+ *
+ * @author Administrator
+ */
+public interface Extract {
+  public void extract( boolean isSwap, ByteBuffer packedPixel, float[] extractComponents );
+  public void shove( float[] shoveComponents, int index, ByteBuffer packedPixel );
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract1010102.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract1010102.java
new file mode 100644
index 000000000..fc29b299b
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract1010102.java
@@ -0,0 +1,97 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.ByteBuffer;
+
+/**
+ *
+ * @author Administrator
+ */
+public class Extract1010102 implements Extract {
+  
+  /** Creates a new instance of Extract1010102 */
+  public Extract1010102() {
+  }
+  
+  public void extract( boolean isSwap, ByteBuffer packedPixel, float[] extractComponents ) {
+    long uint = 0;
+    
+    if( isSwap ) {
+      uint = 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( packedPixel.getInt() );
+    } else {
+      uint = 0x00000000FFFFFFFF & packedPixel.getInt();
+    }
+    
+    // 11111111,11000000,00000000,00000000 == 0xFFC00000
+    // 00000000,00111111,11110000,00000000 == 0x003F0000
+    // 00000000,00000000,00001111,11111100 == 0x00000FFC
+    // 00000000,00000000,00000000,00000011 == 0x00000003
+    
+    extractComponents[0] = (float)( ( uint & 0xFFC00000 ) >> 22 ) / 1023.0f;
+    extractComponents[1] = (float)( ( uint & 0x003FF000 ) >> 12 ) / 1023.0f;
+    extractComponents[2] = (float)( ( uint & 0x00000FFC ) >>  2 ) / 1023.0f;
+    extractComponents[3] = (float)( ( uint & 0x00000003 )       ) / 3.0f;
+  }
+  
+  public void shove( float[] shoveComponents, int index, ByteBuffer packedPixel ) {
+    // 11110000,00000000 == 0xF000
+    // 00001111,00000000 == 0x0F00
+    // 00000000,11110000 == 0x00F0
+    // 00000000,00001111 == 0x000F
+    
+    assert( 0.0f <= shoveComponents[0] && shoveComponents[0] <= 1.0f );
+    assert( 0.0f <= shoveComponents[1] && shoveComponents[1] <= 1.0f );
+    assert( 0.0f <= shoveComponents[2] && shoveComponents[2] <= 1.0f );
+    assert( 0.0f <= shoveComponents[3] && shoveComponents[3] <= 1.0f );
+    
+    // due to limited precision, need to round before shoving
+    long uint = (((int)((shoveComponents[0] * 1023) + 0.5f) << 22) & 0xFFC00000 );
+    uint |= (((int)((shoveComponents[1] * 1023) + 0.5f) <<   12) & 0x003FF000 );
+    uint |= (((int)((shoveComponents[2] * 1023) + 0.5f) <<    2) & 0x00000FFC );
+    uint |= (((int)((shoveComponents[3] *    3) + 0.5f)        ) & 0x00000003 );
+    packedPixel.asIntBuffer().put( index, (int)uint );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract1555rev.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract1555rev.java
new file mode 100644
index 000000000..e1c59041a
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract1555rev.java
@@ -0,0 +1,97 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.ByteBuffer;
+
+/**
+ *
+ * @author Administrator
+ */
+public class Extract1555rev implements Extract {
+  
+  /** Creates a new instance of Extract1555rev */
+  public Extract1555rev() {
+  }
+  
+  public void extract( boolean isSwap, ByteBuffer packedPixel, float[] extractComponents ) {
+    int ushort = 0;
+    
+    if( isSwap ) {
+      ushort = 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( packedPixel.getShort() );
+    } else {
+      ushort = 0x0000FFFF & packedPixel.getShort();
+    }
+    
+    // 00000000,00011111 == 0x001F
+    // 00000011,11100000 == 0x03E0
+    // 01111100,00000000 == 0x7C00
+    // 10000000,00000000 == 0x8000
+    
+    extractComponents[0] = (float)( ( ushort & 0x001F )       ) / 31.0f;
+    extractComponents[1] = (float)( ( ushort & 0x003E ) >>  5 ) / 31.0f;
+    extractComponents[2] = (float)( ( ushort & 0x7C00 ) >>  10) / 31.0f;
+    extractComponents[3] = (float)( ( ushort & 0x8000 ) >>  15);
+  }
+  
+  public void shove( float[] shoveComponents, int index, ByteBuffer packedPixel ) {
+    // 00000000,00011111 == 0x001F
+    // 00000011,11100000 == 0x03E0
+    // 01111100,00000000 == 0x7C00
+    // 10000000,00000000 == 0x8000
+    
+    assert( 0.0f <= shoveComponents[0] && shoveComponents[0] <= 1.0f );
+    assert( 0.0f <= shoveComponents[1] && shoveComponents[1] <= 1.0f );
+    assert( 0.0f <= shoveComponents[2] && shoveComponents[2] <= 1.0f );
+    assert( 0.0f <= shoveComponents[3] && shoveComponents[3] <= 1.0f );
+    
+    // due to limited precision, need to round before shoving
+    int ushort = (((int)((shoveComponents[0] * 31) + 0.5f)   ) & 0x0000001F );
+    ushort |= (((int)((shoveComponents[1] * 31) + 0.5f) <<  5) & 0x000003E0 );
+    ushort |= (((int)((shoveComponents[2] * 31) + 0.5f) << 10) & 0x00007C00 );
+    ushort |= (((int)((shoveComponents[3]) + 0.5f)      << 15) & 0x00008000 );
+    packedPixel.asShortBuffer().put( index, (short)ushort );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract2101010rev.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract2101010rev.java
new file mode 100644
index 000000000..e04d948d8
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract2101010rev.java
@@ -0,0 +1,97 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.ByteBuffer;
+
+/**
+ *
+ * @author Administrator
+ */
+public class Extract2101010rev implements Extract {
+  
+  /** Creates a new instance of Extract2101010 */
+  public Extract2101010rev() {
+  }
+  
+  public void extract( boolean isSwap, ByteBuffer packedPixel, float[] extractComponents ) {
+    long uint = 0;
+    
+    if( isSwap ) {
+      uint = 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( packedPixel.getInt() );
+    } else {
+      uint = 0x00000000FFFFFFFF & packedPixel.getInt();
+    }
+    
+    // 11111111,11000000,00000000,00000000 == 0xFFC00000
+    // 00000000,00111111,11110000,00000000 == 0x003F0000
+    // 00000000,00000000,00001111,11111100 == 0x00000FFC
+    // 00000000,00000000,00000000,00000011 == 0x00000003
+    
+    extractComponents[0] = (float)( ( uint & 0x000003FF )       ) / 1023.0f;
+    extractComponents[1] = (float)( ( uint & 0x000FFC00 ) >> 10 ) / 1023.0f;
+    extractComponents[2] = (float)( ( uint & 0x3FF00000 ) >> 20 ) / 1023.0f;
+    extractComponents[3] = (float)( ( uint & 0xC0000000 ) >> 30 ) / 3.0f;
+  }
+  
+  public void shove( float[] shoveComponents, int index, ByteBuffer packedPixel ) {
+    // 11110000,00000000 == 0xF000
+    // 00001111,00000000 == 0x0F00
+    // 00000000,11110000 == 0x00F0
+    // 00000000,00001111 == 0x000F
+    
+    assert( 0.0f <= shoveComponents[0] && shoveComponents[0] <= 1.0f );
+    assert( 0.0f <= shoveComponents[1] && shoveComponents[1] <= 1.0f );
+    assert( 0.0f <= shoveComponents[2] && shoveComponents[2] <= 1.0f );
+    assert( 0.0f <= shoveComponents[3] && shoveComponents[3] <= 1.0f );
+    
+    // due to limited precision, need to round before shoving
+    long uint = (((int)((shoveComponents[0] * 1023) + 0.5f)    ) & 0x000003FF );
+    uint |= (((int)((shoveComponents[1] * 1023) + 0.5f) <<   10) & 0x000FFC00 );
+    uint |= (((int)((shoveComponents[2] * 1023) + 0.5f) <<   20) & 0x3FF00000 );
+    uint |= (((int)((shoveComponents[3] *    3) + 0.5f) <<   30) & 0xC0000000 );
+    packedPixel.asIntBuffer().put( index, (int)uint );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract233rev.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract233rev.java
new file mode 100644
index 000000000..a3d8ce2a8
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract233rev.java
@@ -0,0 +1,85 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.ByteBuffer;
+
+/**
+ *
+ * @author Administrator
+ */
+public class Extract233rev implements Extract {
+  
+  /** Creates a new instance of Extract223rev */
+  public Extract233rev() {
+  }
+  
+  public void extract( boolean isSwap, ByteBuffer packedPixel, float[] extractComponents ) {
+    // 11100000 == 0xe0
+    // 00011100 == 0x1c
+    // 00000011 == 0x03
+    byte ubyte = packedPixel.get();
+    extractComponents[0] = (float)((ubyte & 0x07) ) / 7.0f;
+    extractComponents[1] = (float)((ubyte & 0x38) >> 3) / 7.0f;
+    extractComponents[2] = (float)((ubyte & 0xC0) >> 6) / 3.0f;
+  }
+  
+  public void shove( float[] shoveComponents, int index, ByteBuffer packedPixel ) {
+    // 11100000 == 0xE0
+    // 00011100 == 0x1C
+    // 00000011 == 0x03
+    
+    assert( 0.0f <= shoveComponents[0] && shoveComponents[0] <= 1.0f );
+    assert( 0.0f <= shoveComponents[1] && shoveComponents[1] <= 1.0f );
+    assert( 0.0f <= shoveComponents[2] && shoveComponents[2] <= 1.0f );
+    
+    // due to limited precision, need to round before shoving
+    byte b = (byte)( ( (int)( ( shoveComponents[0] * 7 ) + 0.5f ) ) & 0x07 );
+    b |= (byte)( ( (int)( ( shoveComponents[1] * 7 ) + 0.5f ) << 3 ) & 0x38 );
+    b |= (byte)( ( (int)( ( shoveComponents[2] * 3 ) + 0.5f ) << 6 ) & 0xC0 );
+    packedPixel.position( index );
+    packedPixel.put( b );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract332.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract332.java
new file mode 100644
index 000000000..008911364
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract332.java
@@ -0,0 +1,84 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.ByteBuffer;
+
+/**
+ *
+ * @author Administrator
+ */
+public class Extract332 implements Extract {
+  
+  /** Creates a new instance of Extract332 */
+  public Extract332() {
+  }
+  
+  public void extract( boolean isSwap, ByteBuffer packedPixel, float[] extractComponents ) {
+    // 11100000 == 0xe0
+    // 00011100 == 0x1c
+    // 00000011 == 0x03
+    byte ubyte = packedPixel.get();
+    extractComponents[0] = (float)((ubyte & 0xe0) >> 5) / 7.0f;
+    extractComponents[1] = (float)((ubyte & 0x1c) >> 2) / 7.0f;
+    extractComponents[2] = (float)((ubyte & 0x03)) / 3.0f;
+  }
+  
+  public void shove( float[] shoveComponents, int index, ByteBuffer packedPixel ) {
+    // 11100000 == 0xE0
+    // 00011100 == 0x1C
+    // 00000011 == 0x03
+    
+    assert( 0.0f <= shoveComponents[0] && shoveComponents[0] <= 1.0f );
+    assert( 0.0f <= shoveComponents[1] && shoveComponents[1] <= 1.0f );
+    assert( 0.0f <= shoveComponents[2] && shoveComponents[2] <= 1.0f );
+    
+    // due to limited precision, need to round before shoving
+    byte b = (byte)( ( (int)( ( shoveComponents[0] * 7 ) + 0.5f ) << 5 ) & 0xE0 );
+    b |= (byte)( ( (int)( ( shoveComponents[1] * 7 ) + 0.5f ) << 2 ) & 0x1C );
+    b |= (byte)( ( (int)( ( shoveComponents[2] * 3 ) + 0.5f ) ) & 0x03 );
+    packedPixel.put( index, b );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract4444.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract4444.java
new file mode 100644
index 000000000..b7414b184
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract4444.java
@@ -0,0 +1,96 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.*;
+
+/**
+ *
+ * @author Administrator
+ */
+public class Extract4444 implements Extract {
+  
+  /** Creates a new instance of Extract4444 */
+  public Extract4444() {
+  }
+  
+  public void extract( boolean isSwap, ByteBuffer packedPixel, float[] extractComponents ) {
+    int ushort = 0;
+    
+    if( isSwap ) {
+      ushort = 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( packedPixel.getShort() );
+    } else {
+      ushort = 0x0000FFFF & packedPixel.getShort();
+    }
+    
+    // 11110000,00000000 == 0xF000
+    // 00001111,00000000 == 0x0F00
+    // 00000000,11110000 == 0x00F0
+    // 00000000,00001111 == 0x000F
+    
+    extractComponents[0] = (float)( ( ushort & 0xF000 ) >> 12 ) / 15.0f;
+    extractComponents[1] = (float)( ( ushort & 0x0F00 ) >> 8  ) / 15.0f;
+    extractComponents[2] = (float)( ( ushort & 0x00F0 ) >> 4  ) / 15.0f;
+    extractComponents[3] = (float)( ( ushort & 0x000F )       ) / 15.0f;
+  }
+  
+  public void shove( float[] shoveComponents, int index, ByteBuffer packedPixel ) {
+    // 11110000,00000000 == 0xF000
+    // 00001111,00000000 == 0x0F00
+    // 00000000,11110000 == 0x00F0
+    // 00000000,00001111 == 0x000F
+    
+    assert( 0.0f <= shoveComponents[0] && shoveComponents[0] <= 1.0f );
+    assert( 0.0f <= shoveComponents[1] && shoveComponents[1] <= 1.0f );
+    assert( 0.0f <= shoveComponents[2] && shoveComponents[2] <= 1.0f );
+    
+    // due to limited precision, need to round before shoving
+    int ushort = (((int)((shoveComponents[0] * 15) + 0.5f) << 12) & 0x0000F000 );
+    ushort |= (((int)((shoveComponents[1] * 15) + 0.5f) << 8) & 0x00000F00 );
+    ushort |= (((int)((shoveComponents[2] * 15) + 0.5f) << 4) & 0x000000F0 );
+    ushort |= (((int)((shoveComponents[3] * 15) + 0.5f)     ) & 0x0000000F );
+    packedPixel.asShortBuffer().put( index, (short)ushort );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract4444rev.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract4444rev.java
new file mode 100644
index 000000000..30a2fa1ac
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract4444rev.java
@@ -0,0 +1,97 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.*;
+
+/**
+ *
+ * @author Administrator
+ */
+public class Extract4444rev implements Extract {
+  
+  /** Creates a new instance of Extract4444rev */
+  public Extract4444rev() {
+  }
+  
+  public void extract( boolean isSwap, ByteBuffer packedPixel, float[] extractComponents ) {
+    int ushort = 0;
+    
+    if( isSwap ) {
+      ushort = 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( packedPixel.getShort() );
+    } else {
+      ushort = 0x0000FFFF & packedPixel.getShort();
+    }
+    
+    // 00000000,00001111 == 0x000F
+    // 00000000,11110000 == 0x00F0
+    // 00001111,00000000 == 0x0F00
+    // 11110000,00000000 == 0xF000
+    
+    extractComponents[0] = (float)( ( ushort & 0x000F )       ) / 15.0f;
+    extractComponents[1] = (float)( ( ushort & 0x00F0 ) >> 4  ) / 15.0f;
+    extractComponents[2] = (float)( ( ushort & 0x0F00 ) >> 8  ) / 15.0f;
+    extractComponents[3] = (float)( ( ushort & 0xF000 ) >> 12 ) / 15.0f;
+  }
+  
+  public void shove( float[] shoveComponents, int index, ByteBuffer packedPixel ) {
+    // 11110000,00000000 == 0xF000
+    // 00001111,00000000 == 0x0F00
+    // 00000000,11110000 == 0x00F0
+    // 00000000,00001111 == 0x000F
+    
+    assert( 0.0f <= shoveComponents[0] && shoveComponents[0] <= 1.0f );
+    assert( 0.0f <= shoveComponents[1] && shoveComponents[1] <= 1.0f );
+    assert( 0.0f <= shoveComponents[2] && shoveComponents[2] <= 1.0f );
+    assert( 0.0f <= shoveComponents[3] && shoveComponents[3] <= 1.0f );
+    
+    // due to limited precision, need to round before shoving
+    int ushort = (((int)((shoveComponents[0] * 15) + 0.5f)   ) & 0x0000000F );
+    ushort |= (((int)((shoveComponents[1] * 15) + 0.5f) <<  4) & 0x000000F0 );
+    ushort |= (((int)((shoveComponents[2] * 15) + 0.5f) <<  8) & 0x00000F00 );
+    ushort |= (((int)((shoveComponents[3] * 15) + 0.5f) << 12) & 0x0000F000 );
+    packedPixel.asShortBuffer().put( index, (short)ushort );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract5551.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract5551.java
new file mode 100644
index 000000000..f9e692e98
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract5551.java
@@ -0,0 +1,97 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.*;
+
+/**
+ *
+ * @author Administrator
+ */
+public class Extract5551 implements Extract {
+  
+  /** Creates a new instance of Extract5551 */
+  public Extract5551() {
+  }
+  
+  public void extract( boolean isSwap, ByteBuffer packedPixel, float[] extractComponents ) {
+    int ushort = 0;
+    
+    if( isSwap ) {
+      ushort = 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( packedPixel.getShort() );
+    } else {
+      ushort = 0x0000FFFF & packedPixel.getShort();
+    }
+    
+    // 11111000,00000000 == 0xF800
+    // 00000111,11000000 == 0x07C0
+    // 00000000,00111110 == 0x003E
+    // 00000000,00000001 == 0x0001
+    
+    extractComponents[0] = (float)( ( ushort & 0xF800 ) >> 11 ) / 31.0f;
+    extractComponents[1] = (float)( ( ushort & 0x00F0 ) >>  6 ) / 31.0f;
+    extractComponents[2] = (float)( ( ushort & 0x0F00 ) >>  1 ) / 31.0f;
+    extractComponents[3] = (float)( ( ushort & 0xF000 )       );
+  }
+  
+  public void shove( float[] shoveComponents, int index, ByteBuffer packedPixel ) {
+    // 11110000,00000000 == 0xF000
+    // 00001111,00000000 == 0x0F00
+    // 00000000,11110000 == 0x00F0
+    // 00000000,00001111 == 0x000F
+    
+    assert( 0.0f <= shoveComponents[0] && shoveComponents[0] <= 1.0f );
+    assert( 0.0f <= shoveComponents[1] && shoveComponents[1] <= 1.0f );
+    assert( 0.0f <= shoveComponents[2] && shoveComponents[2] <= 1.0f );
+    assert( 0.0f <= shoveComponents[3] && shoveComponents[3] <= 1.0f );
+    
+    // due to limited precision, need to round before shoving
+    int ushort = (((int)((shoveComponents[0] * 31) + 0.5f) << 11) & 0x0000F800 );
+    ushort |= (((int)((shoveComponents[1] * 31) + 0.5f) <<  6) & 0x000007C0 );
+    ushort |= (((int)((shoveComponents[2] * 31) + 0.5f) <<  1) & 0x0000003E );
+    ushort |= (((int)((shoveComponents[3]) + 0.5f)) & 0x00000001 );
+    packedPixel.asShortBuffer().put( index, (short)ushort );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract565.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract565.java
new file mode 100644
index 000000000..5eff68d7e
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract565.java
@@ -0,0 +1,92 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.*;
+
+/**
+ *
+ * @author Administrator
+ */
+public class Extract565 implements Extract {
+  
+  /** Creates a new instance of Extract565 */
+  public Extract565() {
+  }
+  
+  public void extract( boolean isSwap, ByteBuffer packedPixel, float[] extractComponents ) {
+    int ushort = 0;
+    
+    if( isSwap ) {
+      ushort = 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( packedPixel.getShort() );
+    } else {
+      ushort = 0x0000FFFF & packedPixel.getShort();
+    }
+    
+    // 11111000,00000000 == 0xF800
+    // 00000111,11100000 == 0x07E0
+    // 00000000,00111111 == 0x001F
+    
+    extractComponents[0] = (float)( ( ushort & 0xF800 ) >> 11 ) / 31.0f;
+    extractComponents[1] = (float)( ( ushort & 0x07E0 ) >> 5 ) / 63.0f;
+    extractComponents[2] = (float)( ( ushort & 0x001F ) ) / 31.0f;
+  }
+  
+  public void shove( float[] shoveComponents, int index, ByteBuffer packedPixel ) {
+    // 11111000,00000000 == 0xF800
+    // 00000111,11100000 == 0x07E0
+    // 00000000,00111111 == 0x001F
+    
+    assert( 0.0f <= shoveComponents[0] && shoveComponents[0] <= 1.0f );
+    assert( 0.0f <= shoveComponents[1] && shoveComponents[1] <= 1.0f );
+    assert( 0.0f <= shoveComponents[2] && shoveComponents[2] <= 1.0f );
+    
+    // due to limited precision, need to round before shoving
+    int ushort = (((int)((shoveComponents[0] * 31) + 0.5f) << 11) & 0x0000F800 );
+    ushort |= (((int)((shoveComponents[1] * 63) + 0.5f) << 5) & 0x000007E0 );
+    ushort |= (((int)((shoveComponents[2] * 31) + 0.5f) ) & 0x0000001F );
+    packedPixel.asShortBuffer().put( index, (short)ushort );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract565rev.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract565rev.java
new file mode 100644
index 000000000..099f80be5
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract565rev.java
@@ -0,0 +1,92 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.*;
+
+/**
+ *
+ * @author Administrator
+ */
+public class Extract565rev implements Extract {
+  
+  /** Creates a new instance of Extract565rev */
+  public Extract565rev() {
+  }
+  
+  public void extract( boolean isSwap, ByteBuffer packedPixel, float[] extractComponents ) {
+    int ushort = 0;
+    
+    if( isSwap ) {
+      ushort = 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( packedPixel.getShort() );
+    } else {
+      ushort = 0x0000FFFF & packedPixel.getShort();
+    }
+    
+    // 00000000,00011111 == 0x001F
+    // 00000111,11100000 == 0x07E0
+    // 11111000,00000000 == 0xF800
+    
+    extractComponents[0] = (float)( ( ushort & 0x001F ) ) / 31.0f;
+    extractComponents[1] = (float)( ( ushort & 0x07E0 ) >> 5 ) / 63.0f;
+    extractComponents[2] = (float)( ( ushort & 0xF800 ) >> 11 ) / 31.0f;
+  }
+  
+  public void shove( float[] shoveComponents, int index, ByteBuffer packedPixel ) {
+    // 00000000,00111111 == 0x001F
+    // 00000111,11100000 == 0x07E0
+    // 11111000,00000000 == 0xF800
+    
+    assert( 0.0f <= shoveComponents[0] && shoveComponents[0] <= 1.0f );
+    assert( 0.0f <= shoveComponents[1] && shoveComponents[1] <= 1.0f );
+    assert( 0.0f <= shoveComponents[2] && shoveComponents[2] <= 1.0f );
+    
+    // due to limited precision, need to round before shoving
+    int ushort = (((int)((shoveComponents[0] * 31) + 0.5f) ) & 0x0000001F );
+    ushort |= (((int)((shoveComponents[1] * 63) + 0.5f) << 5) & 0x000007E0 );
+    ushort |= (((int)((shoveComponents[2] * 31) + 0.5f) << 11) & 0x0000F800 );
+    packedPixel.asShortBuffer().put( index, (short)ushort );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract8888.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract8888.java
new file mode 100644
index 000000000..f3da73952
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract8888.java
@@ -0,0 +1,97 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.*;
+
+/**
+ *
+ * @author Administrator
+ */
+public class Extract8888 implements Extract {
+  
+  /** Creates a new instance of Extract8888 */
+  public Extract8888() {
+  }
+  
+  public void extract( boolean isSwap, ByteBuffer packedPixel, float[] extractComponents ) {
+    long uint = 0;
+    
+    if( isSwap ) {
+      uint = 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( packedPixel.getInt() );
+    } else {
+      uint = 0x00000000FFFFFFFF & packedPixel.getInt();
+    }
+    
+    // 11111000,00000000 == 0xF800
+    // 00000111,11000000 == 0x07C0
+    // 00000000,00111110 == 0x003E
+    // 00000000,00000001 == 0x0001
+    
+    extractComponents[0] = (float)( ( uint & 0xFF000000 ) >> 24 ) / 255.0f;
+    extractComponents[1] = (float)( ( uint & 0x00FF0000 ) >> 16 ) / 255.0f;
+    extractComponents[2] = (float)( ( uint & 0x0000FF00 ) >>  8 ) / 255.0f;
+    extractComponents[3] = (float)( ( uint & 0x000000FF )       ) / 255.0f;
+  }
+  
+  public void shove( float[] shoveComponents, int index, ByteBuffer packedPixel ) {
+    // 11110000,00000000 == 0xF000
+    // 00001111,00000000 == 0x0F00
+    // 00000000,11110000 == 0x00F0
+    // 00000000,00001111 == 0x000F
+    
+    assert( 0.0f <= shoveComponents[0] && shoveComponents[0] <= 1.0f );
+    assert( 0.0f <= shoveComponents[1] && shoveComponents[1] <= 1.0f );
+    assert( 0.0f <= shoveComponents[2] && shoveComponents[2] <= 1.0f );
+    assert( 0.0f <= shoveComponents[3] && shoveComponents[3] <= 1.0f );
+    
+    // due to limited precision, need to round before shoving
+    long uint = (((int)((shoveComponents[0] * 255) + 0.5f) << 24) & 0xFF000000 );
+    uint |= (((int)((shoveComponents[1] * 255) + 0.5f) <<   16) & 0x00FF0000 );
+    uint |= (((int)((shoveComponents[2] * 255) + 0.5f) <<    8) & 0x0000FF00 );
+    uint |= (((int)((shoveComponents[3] * 255) + 0.5f)        ) & 0x000000FF );
+    packedPixel.asIntBuffer().put( index, (int)uint );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract8888rev.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract8888rev.java
new file mode 100644
index 000000000..58dbe81f8
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Extract8888rev.java
@@ -0,0 +1,97 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.*;
+
+/**
+ *
+ * @author Administrator
+ */
+public class Extract8888rev implements Extract {
+  
+  /** Creates a new instance of Extract8888rev */
+  public Extract8888rev() {
+  }
+  
+  public void extract( boolean isSwap, ByteBuffer packedPixel, float[] extractComponents ) {
+    long uint = 0;
+    
+    if( isSwap ) {
+      uint = 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( packedPixel.getInt() );
+    } else {
+      uint = 0x00000000FFFFFFFF & packedPixel.getInt();
+    }
+    
+    // 11111000,00000000 == 0xF800
+    // 00000111,11000000 == 0x07C0
+    // 00000000,00111110 == 0x003E
+    // 00000000,00000001 == 0x0001
+    
+    extractComponents[0] = (float)( ( uint & 0x000000FF )       ) / 255.0f;
+    extractComponents[1] = (float)( ( uint & 0x0000FF00 ) >>  8 ) / 255.0f;
+    extractComponents[2] = (float)( ( uint & 0x00FF0000 ) >> 16 ) / 255.0f;
+    extractComponents[3] = (float)( ( uint & 0xFF000000 ) >> 24 ) / 255.0f;
+  }
+  
+  public void shove( float[] shoveComponents, int index, ByteBuffer packedPixel ) {
+    // 11110000,00000000 == 0xF000
+    // 00001111,00000000 == 0x0F00
+    // 00000000,11110000 == 0x00F0
+    // 00000000,00001111 == 0x000F
+    
+    assert( 0.0f <= shoveComponents[0] && shoveComponents[0] <= 1.0f );
+    assert( 0.0f <= shoveComponents[1] && shoveComponents[1] <= 1.0f );
+    assert( 0.0f <= shoveComponents[2] && shoveComponents[2] <= 1.0f );
+    assert( 0.0f <= shoveComponents[3] && shoveComponents[3] <= 1.0f );
+    
+    // due to limited precision, need to round before shoving
+    long uint = (((int)((shoveComponents[0] * 255) + 0.5f)    ) & 0x000000FF );
+    uint |= (((int)((shoveComponents[1] * 255) + 0.5f) <<    8) & 0x0000FF00 );
+    uint |= (((int)((shoveComponents[2] * 255) + 0.5f) <<   16) & 0x00FF0000 );
+    uint |= (((int)((shoveComponents[3] * 255) + 0.5f) <<   24) & 0xFF000000 );
+    packedPixel.asIntBuffer().put( index, (int)uint );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractFloat.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractFloat.java
new file mode 100644
index 000000000..7d06dfa82
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractFloat.java
@@ -0,0 +1,74 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.*;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ExtractFloat implements ExtractPrimitive {
+  
+  /** Creates a new instance of ExtractFloat */
+  public ExtractFloat() {
+  }
+  
+  public double extract( boolean isSwap, ByteBuffer data ) {
+    float f = 0;
+    if( isSwap ) {
+      f = Mipmap.GLU_SWAP_4_BYTES( data.getInt() );
+    } else {
+      f = data.getInt();
+    }
+    assert( f <= 1.0f );
+    return( f );
+  }
+  
+  public void shove( double value, int index, ByteBuffer data ) {
+    assert(0.0 <= value && value < 1.0);
+    data.asFloatBuffer().put( index, (float)value );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractPrimitive.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractPrimitive.java
new file mode 100644
index 000000000..4cea1aa39
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractPrimitive.java
@@ -0,0 +1,56 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.ByteBuffer;
+
+/**
+ *
+ * @author Administrator
+ */
+public interface ExtractPrimitive {
+  public double extract( boolean isSwap, ByteBuffer pointer );
+  public void shove( double value, int index, ByteBuffer pointer );
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractSByte.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractSByte.java
new file mode 100644
index 000000000..a2cfeca94
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractSByte.java
@@ -0,0 +1,69 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.ByteBuffer;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ExtractSByte implements ExtractPrimitive {
+  
+  /** Creates a new instance of ExtractUByte */
+  public ExtractSByte() {
+  }
+  
+  public double extract( boolean isSwap, ByteBuffer sbyte ) {
+    byte b = sbyte.get();
+    assert( b <= 127 );
+    return( b );
+  }
+  
+  public void shove( double value, int index, ByteBuffer data ) {
+    data.position( index );
+    data.put( (byte)value );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractSInt.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractSInt.java
new file mode 100644
index 000000000..48becdc18
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractSInt.java
@@ -0,0 +1,76 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.*;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ExtractSInt implements ExtractPrimitive {
+  
+  /** Creates a new instance of ExtractSInt */
+  public ExtractSInt() {
+  }
+  
+  public double extract( boolean isSwap, ByteBuffer uint ) {
+    int i = 0;
+    if( isSwap ) {
+      i = Mipmap.GLU_SWAP_4_BYTES( uint.getInt() );
+    } else {
+      i = uint.getInt();
+    }
+    assert( i <= 0x7FFFFFFF );
+    return( i );
+  }
+  
+  public void shove( double value, int index, ByteBuffer data ) {
+    assert(0.0 <= value && value < Integer.MAX_VALUE);
+    IntBuffer ib = data.asIntBuffer();
+    ib.position( index );
+    ib.put( (int)value );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractSShort.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractSShort.java
new file mode 100644
index 000000000..00ff15119
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractSShort.java
@@ -0,0 +1,76 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.*;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ExtractSShort implements ExtractPrimitive {
+  
+  /** Creates a new instance of ExtractSShort */
+  public ExtractSShort() {
+  }
+  
+  public double extract( boolean isSwap, ByteBuffer ushort ) {
+    short s = 0;
+    if( isSwap ) {
+      s = Mipmap.GLU_SWAP_2_BYTES( ushort.getShort() );
+    } else {
+      s = ushort.getShort();
+    }
+    assert( s <= 32767 );
+    return( s );
+  }
+  
+  public void shove( double value, int index, ByteBuffer data ) {
+    assert(0.0 <= value && value < 32768.0);
+    ShortBuffer sb = data.asShortBuffer();
+    sb.position( index );
+    sb.put( (short)value );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractUByte.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractUByte.java
new file mode 100644
index 000000000..4767d93c0
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractUByte.java
@@ -0,0 +1,70 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.ByteBuffer;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ExtractUByte implements ExtractPrimitive {
+  
+  /** Creates a new instance of ExtractUByte */
+  public ExtractUByte() {
+  }
+  
+  public double extract( boolean isSwap, ByteBuffer ubyte ) {
+    int i = 0x000000FF & ubyte.get();
+    assert( i <= 255 );
+    return( i );
+  }
+  
+  public void shove( double value, int index, ByteBuffer data ) {
+    assert(0.0 <= value && value < 256.0);
+    data.position( index );
+    data.put( (byte)value );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractUInt.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractUInt.java
new file mode 100644
index 000000000..e6cd6e183
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractUInt.java
@@ -0,0 +1,76 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.*;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ExtractUInt implements ExtractPrimitive {
+  
+  /** Creates a new instance of ExtractUInt */
+  public ExtractUInt() {
+  }
+  
+  public double extract( boolean isSwap, ByteBuffer uint ) {
+    long i = 0;
+    if( isSwap ) {
+      i = 0xFFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( uint.getInt() );
+    } else {
+      i = 0xFFFFFFFF & uint.getInt();
+    }
+    assert( i <= 0xFFFFFFFF );
+    return( i );
+  }
+  
+  public void shove( double value, int index, ByteBuffer data ) {
+    assert(0.0 <= value && value < 0xFFFFFFFF);
+    IntBuffer ib = data.asIntBuffer();
+    ib.position( index );
+    ib.put( (int)value );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractUShort.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractUShort.java
new file mode 100644
index 000000000..89b42e41b
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ExtractUShort.java
@@ -0,0 +1,76 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.*;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ExtractUShort implements ExtractPrimitive {
+  
+  /** Creates a new instance of ExtracUShort */
+  public ExtractUShort() {
+  }
+  
+  public double extract( boolean isSwap, ByteBuffer ushort ) {
+    int i = 0;
+    if( isSwap ) {
+      i = 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( ushort.getShort() );
+    } else {
+      i = 0x0000FFFF & ushort.getShort();
+    }
+    assert( i <= 65535 );
+    return( i );
+  }
+  
+  public void shove( double value, int index, ByteBuffer data ) {
+    assert(0.0 <= value && value < 65536.0);
+    ShortBuffer sb = data.asShortBuffer();
+    sb.position( index );
+    sb.put( (short)value );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/HalveImage.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/HalveImage.java
new file mode 100644
index 000000000..7f2e87a63
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/HalveImage.java
@@ -0,0 +1,1533 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import javax.media.opengl.GL;
+import java.nio.*;
+
+/**
+ *
+ * @author  Administrator
+ */
+public class HalveImage {
+  
+  private static final int BOX2 = 2;
+  private static final int BOX4 = 4;
+  private static final int BOX8 = 8;
+  
+  public static void halveImage( int components, int width, int height,
+          ShortBuffer datain, ShortBuffer dataout ) {
+    int i, j, k;
+    int newwidth, newheight;
+    int delta;
+    int t = 0;
+    short temp = 0;
+    
+    newwidth = width / 2;
+    newheight = height /2;
+    delta = width * components;
+    
+    // Piece of cake
+    for( i = 0; i < newheight; i++ ) {
+      for( j = 0; j < newwidth; j++ ) {
+        for( k = 0; k < components; k++ ) {
+          datain.position( t );
+          temp = datain.get();
+          datain.position( t + components );
+          temp += datain.get();
+          datain.position( t + delta );
+          temp += datain.get();
+          datain.position( t + delta + components );
+          temp +=datain.get();
+          temp += 2;
+          temp /= 4;
+          dataout.put( temp );
+          t++;
+        }
+        t += components;
+      }
+      t += delta;
+    }
+  }
+  
+  public static void halveImage_ubyte( int components, int width, int height,
+                                      ByteBuffer datain, ByteBuffer dataout,
+                                      int element_size, int ysize, int group_size ) {
+    int i, j, k;
+    int newwidth, newheight;
+    int s;
+    int t;
+    
+    // Handle case where there is only 1 column/row
+    if( width == 1 || height == 1 ) {
+      assert( !( width == 1 && height == 1 ) ); // can't be 1x1
+      halve1Dimage_ubyte( components, width, height, datain, dataout, element_size, ysize, group_size );
+      return;
+    }
+    
+    newwidth = width / 2;
+    newheight = height / 2;
+    s = 0;
+    t = 0;
+    
+    int temp = 0;
+    // piece of cake
+    for( i = 0; i < newheight; i++ ) {
+      for( j = 0; j < newwidth; j++ ) {
+        for( k = 0; k < components; k++ ) {
+          datain.position( t );
+          temp = ( 0x000000FF & datain.get() );
+          datain.position( t + group_size );
+          temp += ( 0x000000FF & datain.get() );
+          datain.position( t + ysize );
+          temp += ( 0x000000FF & datain.get() );
+          datain.position( t + ysize + group_size );
+          temp += ( 0x000000FF & datain.get() ) + 2;
+          dataout.put( (byte)(temp / 4) );
+          t += element_size;
+        }
+        t += group_size;
+      }
+      t += ysize;
+    }
+  }
+  
+  public static void halve1Dimage_ubyte( int components, int width, int height,
+                      ByteBuffer datain, ByteBuffer dataout, 
+                      int element_size, int ysize, int group_size ) {
+    int halfWidth = width / 2;
+    int halfHeight = height / 2;
+    int src = 0;
+    int dest = 0;
+    int jj;
+    int temp = 0;
+    
+    assert( width == 1 || height == 1 ); // Must be 1D
+    assert( width != height ); // can't be square
+    
+    if( height == 1 ) { // 1 row
+      assert( width != 1 ); // widthxheight can't be 1x1
+      halfHeight = 1;
+      
+      for( jj = 0; jj < halfWidth; jj++ ) {
+        int kk;
+        for( kk = 0; kk < components; kk++ ) {
+          datain.position( src );
+          temp = ( 0x000000FF & datain.get() );
+          datain.position( src + group_size );
+          temp += ( 0x000000FF & datain.get() );
+          temp /= 2;
+          dataout.put( (byte)temp );
+          /*
+          dataout.setByte( (byte)(((0x000000FF & datain.setIndexInBytes(src).getByte()) + 
+                    (0x000000FF & datain.setIndexInBytes( src + group_size ).getByte())) / 2 ) );
+           */
+          src += element_size;
+          //dataout.plusPlus();
+          dest++;
+        }
+        src += group_size; // skip to next 2
+      }
+      int padBytes = ysize - ( width * group_size );
+      src += padBytes; // for assertion only
+    } else if( width == 1 ) { // 1 column
+      int padBytes = ysize - ( width * group_size );
+      assert( height != 1 );
+      halfWidth = 1;
+      // one vertical column with possible pad bytes per row
+      // average two at a time
+      for( jj = 0; jj < halfHeight; jj++ ) {
+        int kk;
+        for( kk = 0; kk < components; kk++ ) {
+          datain.position( src );
+          temp = ( 0x000000FF & datain.get() );
+          datain.position( src + ysize );
+          temp += ( 0x000000FF & datain.get() );
+          temp /= 2;
+          dataout.put( (byte)temp );
+          /*
+          dataout.setByte( (byte)(((0x000000FF & datain.setIndexInBytes(src).getByte()) + 
+                    (0x000000FF & datain.setIndexInBytes(src + ysize).getByte()) ) / 2 ) );
+           */
+          src += element_size;
+          //dataout.plusPlus();
+          dest++;
+        }
+        src += padBytes; // add pad bytes, if any, to get to end of row
+        src += ysize;
+      }
+    }
+    assert( src == ysize * height );
+    assert( dest == components * element_size * halfWidth * halfHeight );
+  }
+  
+  public static void halveImage_byte( int components, int width, int height,
+                    ByteBuffer datain, ByteBuffer dataout, int element_size,
+                    int ysize, int group_size ) {
+    int i, j, k;
+    int newwidth, newheight;
+    int s = 0;
+    int t = 0;
+    byte temp = (byte)0;
+    
+    // handle case where there is only 1 column
+    if( width == 1 || height == 1 ) {
+      assert( !( width == 1 && height == 1 ) );
+      halve1Dimage_byte( components, width, height, datain, dataout, element_size,
+                                                            ysize, group_size );
+      return;
+    }
+    
+    newwidth = width / 2;
+    newheight = height / 2;
+    
+    for( i = 0; i < newheight; i++ ) {
+      for( j = 0; j < newwidth; j++ ) {
+        for( k = 0; k < components; k++ ) {
+          datain.position( t );
+          temp = datain.get();
+          datain.position( t + group_size );
+          temp += datain.get();
+          datain.position( t + ysize );
+          temp += datain.get();
+          datain.position( t + ysize + group_size );
+          temp += datain.get();
+          temp += 2;
+          temp /= 4;
+          dataout.put( temp );
+          t += element_size;
+        }
+        t += group_size;
+      }
+      t += ysize;
+    }
+  }
+  
+  public static void halve1Dimage_byte( int components, int width, int height,
+                      ByteBuffer datain, ByteBuffer dataout,
+                      int element_size, int ysize, int group_size ) {
+    int halfWidth = width / 2;
+    int halfHeight = width / 2;
+    int src = 0;
+    int dest = 0;
+    int jj;
+    byte temp = (byte)0;
+    
+    assert( width == 1 || height == 1 ); // must be 1D
+    assert( width != height ); // can't be square
+    
+    if( height == 1 ) { // 1 row
+      assert( width != 1 ); // widthxheight can't be 1
+      halfHeight = 1;
+      
+      for( jj = 0; jj < halfWidth; jj++ ) {
+        int kk;
+        for( kk = 0; kk < components; kk++ ) {
+          datain.position( src );
+          temp = datain.get();
+          datain.position( src + group_size );
+          temp += datain.get();
+          temp /= 2;
+          dataout.put( temp );
+          src += element_size;
+          dest++;
+        }
+        src += group_size; // skip to next 2
+      }
+      int padBytes = ysize - ( width * group_size );
+      src += padBytes; // for assert only
+    } else if( width == 1 ) { // 1 column
+      int padBytes = ysize - ( width * group_size );
+      assert( height != 1 ); // widthxheight can't be 1
+      halfWidth = 1;
+      // one vertical column with possible pad bytes per row
+      // average two at a time
+      
+      for( jj = 0; jj < halfHeight; jj++ ) {
+        int kk;
+        for( kk = 0; kk < components; kk++ ) {
+          datain.position( src );
+          temp = datain.get();
+          datain.position( src + ysize );
+          temp += datain.get();
+          temp /= 2;
+          src += element_size;
+          dest++;
+        }
+        src += padBytes; // add pad bytes, if any, to get to end of row
+        src += ysize;
+      }
+      assert( src == ysize * height );
+    }
+    assert( dest == components * element_size * halfWidth * halfHeight );
+  }
+  
+  public static void halveImage_ushort( int components, int width, int height,
+                          ByteBuffer datain, ShortBuffer dataout, int element_size,
+                          int ysize, int group_size, boolean myswap_bytes ) {
+    int i, j, k, l;
+    int newwidth, newheight;
+    int s = 0;
+    int t = 0;
+    int temp = 0;
+    // handle case where there is only 1 column/row
+    if( width == 1 || height == 1 ) {
+      assert( !( width == 1 && height == 1 ) ); // can't be 1x1
+      halve1Dimage_ushort( components, width, height, datain, dataout, element_size,
+                                ysize, group_size, myswap_bytes );
+      return;
+    }
+    
+    newwidth = width / 2;
+    newheight = height / 2;
+    
+    // Piece of cake
+    if( !myswap_bytes ) {
+      for( i = 0; i < newheight; i++ ) {
+        for( j = 0; j < newwidth; j++ ) {
+          for( k = 0; k < components; k++ ) {
+            datain.position( t );
+            temp = ( 0x0000FFFF & datain.getShort() );
+            datain.position( t + group_size );
+            temp += ( 0x0000FFFF & datain.getShort() );
+            datain.position( t + ysize );
+            temp += ( 0x0000FFFF & datain.getShort() );
+            datain.position( t + ysize + group_size );
+            temp += ( 0x0000FFFF & datain.getShort() );
+            dataout.put( (short)( ( temp + 2 ) / 4 ) );
+            t += element_size;
+          }
+          t += group_size;
+        }
+        t += ysize;
+      }
+    } else {
+      for( i = 0; i < newheight; i++ ) {
+        for( j = 0; j < newwidth; j++ ) {
+          for( k = 0; k < components; k++ ) {
+            datain.position( t );
+            temp = ( 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort() ) );
+            datain.position( t + group_size );
+            temp += ( 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort() ) );
+            datain.position( t + ysize );
+            temp += ( 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort() ) );
+            datain.position( t + ysize + group_size );
+            temp += ( 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort() ) );
+            dataout.put( (short)( ( temp + 2 ) / 4 ) );
+            t += element_size;
+          }
+          t += group_size;
+        }
+        t += ysize;
+      }
+    }
+  }
+  
+  public static void halve1Dimage_ushort( int components, int width, int height,
+                      ByteBuffer datain, ShortBuffer dataout, int element_size,
+                      int ysize, int group_size, boolean myswap_bytes ) {
+    int halfWidth = width / 2;
+    int halfHeight = height / 2;
+    int src = 0;
+    int dest = 0;
+    int jj;
+    
+    assert( width == 1 || height == 1 ); // must be 1D
+    assert( width != height ); // can't be square
+    
+    if( height == 1 ) { // 1 row
+      assert( width != 1 ); // widthxheight can't be 1
+      halfHeight = 1;
+      
+      for( jj = 0; jj < halfWidth; jj++ ) {
+        int kk;
+        for( kk = 0; kk < halfHeight; kk++ ) {
+          int[] ushort = new int[BOX2];
+          if( myswap_bytes ) {
+            datain.position( src );
+            ushort[0] = ( 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort() ) );
+            datain.position( src + group_size );
+            ushort[1] = (0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort() ) );
+          } else {
+            datain.position( src );
+            ushort[0] = (0x0000FFFF & datain.getShort() );
+            datain.position( src + group_size );
+            ushort[1] = (0x0000FFFF & datain.getShort() );
+          }
+          dataout.put( (short)( (ushort[0] + ushort[1]) / 2 ) );
+          src += element_size;
+          dest += 2;
+        }
+        src += group_size; // skip to next 2
+      }
+      int padBytes = ysize - ( width * group_size );
+      src += padBytes; // for assertion only
+    } else if( width == 1 ) { // 1 column
+      int padBytes = ysize - ( width * group_size );
+      assert( height != 1 ); // widthxheight can't be 1
+      halfWidth = 1;
+      // one vertical column with possible pad bytes per row
+      // average two at a time
+      
+      for( jj = 0; jj < halfHeight; jj++ ) {
+        int kk;
+        for( kk = 0; kk < components; kk++ ) {
+          int[] ushort = new int[BOX2];
+          if( myswap_bytes ) {
+            datain.position( src );
+            ushort[0] = ( 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort() ) );
+            datain.position( src + ysize );
+            ushort[0] = ( 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort() ) );
+          } else {
+            datain.position( src );
+            ushort[0] = ( 0x0000FFFF & datain.getShort() );
+            datain.position( src + ysize );
+            ushort[1] = ( 0x0000FFFF & datain.getShort() );
+          }
+          dataout.put( (short)((ushort[0] + ushort[1]) / 2) );
+          src += element_size;
+          dest += 2;
+        }
+        src += padBytes; // add pad bytes, if any, to get to end of row
+        src += ysize;
+      }
+      assert( src == ysize * height );
+    }
+    assert( dest == components * element_size * halfWidth * halfHeight );
+  }
+  
+  public static void halveImage_short( int components, int width, int height,
+                        ByteBuffer datain, ShortBuffer dataout, int element_size,
+                        int ysize, int group_size, boolean myswap_bytes ) {
+    int i, j, k, l;
+    int newwidth, newheight;
+    int s = 0;
+    int t = 0;
+    short temp = (short)0;
+    // handle case where there is only 1 column/row
+    if( width == 1 || height == 1 ) {
+      assert( !( width == 1 && height == 1 ) ); // can't be 1x1
+      halve1Dimage_short( components, width, height, datain, dataout, element_size,
+                            ysize, group_size, myswap_bytes );
+      return;
+    }
+    
+    newwidth = width / 2;
+    newheight = height / 2;
+    
+    // Piece of cake
+    if( !myswap_bytes ) {
+      for( i = 0; i < newheight; i++ ) {
+        for( j = 0; j < newwidth; j++ ) {
+          for( k = 0; k < components; k++ ) {
+            datain.position( t );
+            temp = datain.getShort();
+            datain.position( t + group_size );
+            temp += datain.getShort();
+            datain.position( t + ysize );
+            temp += datain.getShort();
+            datain.position( t + ysize + group_size );
+            temp += datain.getShort();
+            temp += 2;
+            temp /= 4;
+            dataout.put( (short)temp );
+            t += element_size;
+          }
+          t += group_size;
+        }
+        t += ysize;
+      }
+    } else {
+      for( i = 0; i < newheight; i++ ) {
+        for( j = 0; j < newwidth; j++ ) {
+          for( k = 0; k < components; k++ ) {
+            short b;
+            int buf;
+            datain.position( t );
+            temp = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+            datain.position( t + group_size );
+            temp += Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+            datain.position( t + ysize );
+            temp += Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+            datain.position( t + ysize + group_size );
+            temp += Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+            temp += 2;
+            temp /= 4;
+            dataout.put( temp );
+            t += element_size;
+          }
+          t += group_size;
+        }
+        t += ysize;
+      }
+    }
+  }
+  
+  public static void halve1Dimage_short( int components, int width, int height,
+              ByteBuffer datain, ShortBuffer dataout, int element_size, int ysize,
+              int group_size, boolean myswap_bytes ) {
+    int halfWidth = width / 2;
+    int halfHeight = height / 2;
+    int src = 0;
+    int dest = 0;
+    int jj;
+    
+    assert( width == 1 || height == 1 ); // must be 1D
+    assert( width != height ); // can't be square
+    
+    if( height == 1 ) { // 1 row
+      assert( width != 1 ); // can't be 1x1
+      halfHeight = 1;
+      
+      for( jj = 0; jj < halfWidth; jj++ ) {
+        int kk;
+        for( kk = 0; kk < components; kk++ ) {
+          short[] sshort = new short[BOX2];
+          if( myswap_bytes ) {
+            datain.position( src );
+            sshort[0] = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+            datain.position( src + group_size );
+            sshort[1] = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+          } else {
+            datain.position( src );
+            sshort[0] = datain.getShort();
+            datain.position( src + group_size );
+            sshort[1] = datain.getShort();
+          }
+          dataout.put( (short)(( sshort[0] + sshort[1] ) / 2) );
+          src += element_size;
+          dest += 2;
+        }
+        src += group_size; // skip to next 2
+      }
+      int padBytes = ysize - ( width * group_size );
+      src += padBytes; // for assertion only
+    } else if( width == 1 ) {
+      int padBytes = ysize - ( width * group_size );
+      assert( height != 1 );
+      halfWidth = 1;
+      // one vertical column with possible pad bytes per row
+      // average two at a time
+      
+      for( jj = 0; jj < halfHeight; jj++ ) {
+        int kk;
+        for( kk = 0; kk < components; kk++ ) {
+          short[] sshort = new short[BOX2];
+          if( myswap_bytes ) {
+            datain.position( src );
+            sshort[0] = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+            datain.position( src + ysize );
+            sshort[1] = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+          } else {
+            datain.position( src );
+            sshort[0] = datain.getShort();
+            datain.position( src + ysize );
+            sshort[1] = datain.getShort();
+          }
+          dataout.put( (short)(( sshort[0] + sshort[1] ) / 2) );
+          src += element_size;
+          dest += 2;
+        }
+        src += padBytes; // add pad bytes, if any, to get to end of row
+        src += ysize;
+      }
+      assert( src == ysize * height );
+    }
+    assert( dest == ( components * element_size * halfWidth * halfHeight ) );
+  }
+  
+  public static void halveImage_uint( int components, int width, int height,
+                          ByteBuffer datain, IntBuffer dataout, int element_size,
+                          int ysize, int group_size, boolean myswap_bytes ) {
+    int i, j, k, l;
+    int newwidth, newheight;
+    int s = 0;
+    int t = 0;
+    double temp = 0;
+    
+    // handle case where there is only 1 column/row
+    if( width == 1 || height == 1 ) {
+      assert( !( width == 1 && height == 1 ) ); // can't be 1x1
+      halve1Dimage_uint( components, width, height, datain, dataout, element_size,
+                                ysize, group_size, myswap_bytes );
+      return;
+    }
+    
+    newwidth = width / 2;
+    newheight = height / 2;
+    
+    // Piece of cake
+    if( !myswap_bytes ) {
+      for( i = 0; i < newheight; i++ ) {
+        for( j = 0; j < newwidth; j++ ) {
+          for( k = 0; k < components; k++ ) {
+            datain.position( t );
+            temp = (0x000000007FFFFFFFL & datain.getInt() );
+            datain.position( t + group_size );
+            temp += (0x000000007FFFFFFFL & datain.getInt() );
+            datain.position( t + ysize );
+            temp += (0x000000007FFFFFFFL & datain.getInt() );
+            datain.position( t + ysize + group_size );
+            temp += (0x000000007FFFFFFFL & datain.getInt() );
+            dataout.put( (int)( ( temp / 4 ) + 0.5 ) );
+            t += element_size;
+          }
+          t += group_size;
+        }
+        t += ysize;
+      }
+    } else {
+      for( i = 0; i < newheight; i++ ) {
+        for( j = 0; j < newwidth; j++ ) {
+          for( k = 0; k < components; k++ ) {
+            // need to cast to double to hold large unsigned ints
+            double buf;
+            datain.position( t );
+            buf = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
+            datain.position( t + group_size );
+            buf += ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
+            datain.position( t + ysize );
+            buf += ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
+            datain.position( t + ysize + group_size );
+            buf += ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
+            temp /= 4;
+            temp += 0.5;
+            dataout.put( (int)temp );
+            t += element_size;
+          }
+          t += group_size;
+        }
+        t += ysize;
+      }
+    }
+  }
+  
+  public static void halve1Dimage_uint( int components, int width, int height,
+                      ByteBuffer datain, IntBuffer dataout, int element_size, int ysize,
+                      int group_size, boolean myswap_bytes ) {
+    int halfWidth = width / 2;
+    int halfHeight = height / 2;
+    int src = 0;
+    int dest = 0;
+    int jj;
+    
+    assert( width == 1 || height == 1 ); // must be 1D
+    assert( width != height ); // can't be square
+    
+    if( height == 1 ) { // 1 row
+      assert( width != 1 ); // widthxheight can't be 1
+      halfHeight = 1;
+      
+      for( jj = 0; jj < halfWidth; jj++ ) {
+        int kk;
+        for( kk = 0; kk < halfHeight; kk++ ) {
+          long[] uint = new long[BOX2];
+          if( myswap_bytes ) {
+            datain.position( src );
+            uint[0] = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
+            datain.position( src + group_size );
+            uint[1] = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
+          } else {
+            datain.position( src );
+            uint[0] = ( 0x00000000FFFFFFFF & datain.getInt() );
+            datain.position( src + group_size );
+            uint[1] = (0x00000000FFFFFFFF & datain.getInt() );
+          }
+          dataout.put( (int)( ( uint[0] + uint[1] ) / 2.0 ) );
+          src += element_size;
+          dest += 4;
+        }
+        src += group_size; // skip to next 2
+      }
+      int padBytes = ysize - ( width * group_size );
+      src += padBytes; // for assertion only
+    } else if( width == 1 ) { // 1 column
+      int padBytes = ysize - ( width * group_size );
+      assert( height != 1 ); // widthxheight can't be 1
+      halfWidth = 1;
+      // one vertical column with possible pad bytes per row
+      // average two at a time
+      
+      for( jj = 0; jj < halfHeight; jj++ ) {
+        int kk;
+        for( kk = 0; kk < components; kk++ ) {
+          long[] uint = new long[BOX2];
+          if( myswap_bytes ) {
+            datain.position( src );
+            uint[0] = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
+            datain.position( src + group_size );
+            uint[0] = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
+          } else {
+            datain.position( src );
+            uint[0] = ( 0x00000000FFFFFFFF & datain.getInt() );
+            datain.position( src + ysize );
+            uint[1] = ( 0x00000000FFFFFFFF & datain.getInt() );
+          }
+          dataout.put( (int)( ( uint[0] + uint[1] ) / 2.0 ) );
+          src += element_size;
+          dest += 4;
+        }
+        src += padBytes; // add pad bytes, if any, to get to end of row
+        src += ysize;
+      }
+      assert( src == ysize * height );
+    }
+    assert( dest == components * element_size * halfWidth * halfHeight );
+  }
+  
+  public static void halveImage_int( int components, int width, int height,
+                        ByteBuffer datain, IntBuffer dataout, int element_size,
+                        int ysize, int group_size, boolean myswap_bytes ) {
+    int i, j, k, l;
+    int newwidth, newheight;
+    int s = 0;
+    int t = 0;
+    int temp = 0;
+    
+    // handle case where there is only 1 column/row
+    if( width == 1 || height == 1 ) {
+      assert( !( width == 1 && height == 1 ) ); // can't be 1x1
+      halve1Dimage_int( components, width, height, datain, dataout, element_size,
+                            ysize, group_size, myswap_bytes );
+      return;
+    }
+    
+    newwidth = width / 2;
+    newheight = height / 2;
+    
+    // Piece of cake
+    if( !myswap_bytes ) {
+      for( i = 0; i < newheight; i++ ) {
+        for( j = 0; j < newwidth; j++ ) {
+          for( k = 0; k < components; k++ ) {
+            datain.position( t );
+            temp = datain.getInt();
+            datain.position( t + group_size );
+            temp += datain.getInt();
+            datain.position( t + ysize );
+            temp += datain.getInt();
+            datain.position( t + ysize + group_size );
+            temp += datain.getInt();
+            temp = (int)( ( temp / 4.0f ) + 0.5f );
+            dataout.put( temp );
+            t += element_size;
+          }
+          t += group_size;
+        }
+        t += ysize;
+      }
+    } else {
+      for( i = 0; i < newheight; i++ ) {
+        for( j = 0; j < newwidth; j++ ) {
+          for( k = 0; k < components; k++ ) {
+            long b;
+            float buf;
+            datain.position( t );
+            b = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
+            buf = b;
+            datain.position( t + group_size );
+            b = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
+            buf += b;
+            datain.position( t + ysize );
+            b = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
+            buf += b;
+            datain.position( t + ysize + group_size );
+            b = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
+            buf += b;
+            dataout.put( (int)( ( buf / 4.0f ) + 0.5f ) );
+            t += element_size;
+          }
+          t += group_size;
+        }
+        t += ysize;
+      }
+    }
+  }
+  
+  public static void halve1Dimage_int( int components, int width, int height,
+              ByteBuffer datain, IntBuffer dataout, int element_size, int ysize,
+              int group_size, boolean myswap_bytes ) {
+    int halfWidth = width / 2;
+    int halfHeight = height / 2;
+    int src = 0;
+    int dest = 0;
+    int jj;
+    
+    assert( width == 1 || height == 1 ); // must be 1D
+    assert( width != height ); // can't be square
+    
+    if( height == 1 ) { // 1 row
+      assert( width != 1 ); // can't be 1x1
+      halfHeight = 1;
+      
+      for( jj = 0; jj < halfWidth; jj++ ) {
+        int kk;
+        for( kk = 0; kk < components; kk++ ) {
+          long[] uint = new long[BOX2];
+          if( myswap_bytes ) {
+            datain.position( src );
+            uint[0] = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
+            datain.position( src + group_size );
+            uint[1] = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
+          } else {
+            datain.position( src );
+            uint[0] = ( 0x00000000FFFFFFFF & datain.getInt() );
+            datain.position( src + group_size );
+            uint[1] = ( 0x00000000FFFFFFFF & datain.getInt() );
+          }
+          dataout.put( (int)( ( (float)uint[0] + (float)uint[1] ) / 2.0f) );
+          src += element_size;
+          dest += 4;
+        }
+        src += group_size; // skip to next 2
+      }
+      int padBytes = ysize - ( width * group_size );
+      src += padBytes; // for assertion only
+    } else if( width == 1 ) {
+      int padBytes = ysize - ( width * group_size );
+      assert( height != 1 );
+      halfWidth = 1;
+      // one vertical column with possible pad bytes per row
+      // average two at a time
+      
+      for( jj = 0; jj < halfHeight; jj++ ) {
+        int kk;
+        for( kk = 0; kk < components; kk++ ) {
+          long[] uint = new long[BOX2];
+          if( myswap_bytes ) {
+            datain.position( src );
+            uint[0] = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
+            datain.position( src + ysize );
+            uint[1] = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
+          } else {
+            datain.position( src );
+            uint[0] = ( 0x00000000FFFFFFFF & datain.getInt() );
+            datain.position( src + ysize );
+            uint[1] = ( 0x00000000FFFFFFFF & datain.getInt() );
+          }
+          dataout.put( (int)(( (float)uint[0] + (float)uint[1] ) / 2.0f) );
+          src += element_size;
+          dest += 4;
+        }
+        src += padBytes; // add pad bytes, if any, to get to end of row
+        src += ysize;
+      }
+      assert( src == ysize * height );
+    }
+    assert( dest == ( components * element_size * halfWidth * halfHeight ) );
+  }
+  
+  public static void halveImage_float( int components, int width, int height,
+                    ByteBuffer datain, FloatBuffer dataout, int element_size,
+                    int ysize, int group_size, boolean myswap_bytes ) {
+    int i, j, k, l;
+    int newwidth, newheight;
+    int s = 0;
+    int t = 0;
+    float temp = 0.0f;
+    // handle case where there is only 1 column/row
+    if( width == 1 || height == 1 ) {
+      assert( !( width == 1 && height == 1 ) ); // can't be 1x1
+      halve1Dimage_float( components, width, height, datain, dataout, element_size,
+                                              ysize, group_size, myswap_bytes );
+      return;
+    }
+    
+    newwidth = width / 2;
+    newheight = height / 2;
+    
+    // Piece of cake
+    if( !myswap_bytes ) {
+      for( i = 0; i < newheight; i++ ) {
+        for( j = 0; j < newwidth; j++ ) {
+          for( k = 0; k < components; k++ ) {
+            datain.position( t );
+            temp = datain.getFloat();
+            datain.position( t + group_size );
+            temp += datain.getFloat();
+            datain.position( t + ysize );
+            temp += datain.getFloat();
+            datain.position( t + ysize + group_size );
+            temp /= 4.0f;
+            dataout.put( temp );
+            t += element_size;
+          }
+          t += group_size;
+        }
+        t += ysize;
+      }
+    } else {
+      for( i = 0; i < newheight; i++ ) {
+        for( j = 0; j < newwidth; j++ ) {
+          for( k = 0; k < components; k++ ) {
+            float buf;
+            datain.position( t );
+            buf = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+            datain.position( t + group_size );
+            buf += Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+            datain.position( t + ysize );
+            buf += Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+            datain.position( t + ysize + group_size );
+            buf += Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+            dataout.put( buf / 4.0f );
+            t += element_size;
+          }
+          t += group_size;
+        }
+        t += ysize;
+      }
+    }
+  }
+  
+  public static void halve1Dimage_float( int components, int width, int height,
+              ByteBuffer datain, FloatBuffer dataout, int element_size, int ysize,
+              int group_size, boolean myswap_bytes ) {
+    int halfWidth = width / 2;
+    int halfHeight = height / 2;
+    int src = 0;
+    int dest = 0;
+    int jj;
+    
+    assert( width == 1 || height == 1 ); // must be 1D
+    assert( width != height ); // can't be square
+    
+    if( height == 1 ) { // 1 row
+      assert( width != 1 ); // can't be 1x1
+      halfHeight = 1;
+      
+      for( jj = 0; jj < halfWidth; jj++ ) {
+        int kk;
+        for( kk = 0; kk < components; kk++ ) {
+          float[] sfloat = new float[BOX2];
+          if( myswap_bytes ) {
+            datain.position( src );
+            sfloat[0] = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+            datain.position( src + group_size );
+            sfloat[1] = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+          } else {
+            datain.position( src );
+            sfloat[0] = datain.getFloat();
+            datain.position( src + group_size );
+            sfloat[1] = datain.getFloat();
+          }
+          dataout.put( (sfloat[0] + sfloat[1]) / 2.0f );
+          src += element_size;
+          dest += 4;
+        }
+        src += group_size; // skip to next 2
+      }
+      int padBytes = ysize - ( width * group_size );
+      src += padBytes; // for assertion only
+    } else if( width == 1 ) {
+      int padBytes = ysize - ( width * group_size );
+      assert( height != 1 );
+      halfWidth = 1;
+      // one vertical column with possible pad bytes per row
+      // average two at a time
+      
+      for( jj = 0; jj < halfHeight; jj++ ) {
+        int kk;
+        for( kk = 0; kk < components; kk++ ) {
+          float[] sfloat = new float[BOX2];
+          if( myswap_bytes ) {
+            datain.position( src );
+            sfloat[0] = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+            datain.position( src + ysize );
+            sfloat[1] = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+          } else {
+            datain.position( src );
+            sfloat[0] = datain.getFloat();
+            datain.position( src + ysize );
+            sfloat[1] = datain.getFloat();
+          }
+          dataout.put( ( sfloat[0] + sfloat[1] ) / 2.0f );
+          src += element_size;
+          dest += 4;
+        }
+        src += padBytes; // add pad bytes, if any, to get to end of row
+        src += ysize;
+      }
+      assert( src == ysize * height );
+    }
+    assert( dest == ( components * element_size * halfWidth * halfHeight ) );
+  }
+  
+  public static void halveImagePackedPixel( int components, Extract extract, int width, 
+          int height, ByteBuffer datain, ByteBuffer dataout, 
+          int pixelSizeInBytes, int rowSizeInBytes, boolean isSwap ) {
+    if( width == 1 || height == 1 ) {
+      assert( !( width == 1 && height == 1 ) );
+      halve1DimagePackedPixel( components, extract, width, height, datain, dataout,
+                          pixelSizeInBytes, rowSizeInBytes, isSwap );
+      return;
+    }
+    int ii, jj;
+    
+    int halfWidth = width / 2;
+    int halfHeight = height / 2;
+    int src = 0;
+    int padBytes = rowSizeInBytes - ( width * pixelSizeInBytes );
+    int outIndex = 0;
+    
+    for( ii = 0; ii < halfHeight; ii++ ) {
+      for( jj = 0; jj < halfWidth; jj++ ) {
+        float totals[] = new float[4];
+        float extractTotals[][] = new float[BOX4][4];
+        int cc;
+        
+        datain.position( src );
+        extract.extract( isSwap, datain, extractTotals[0] );
+        datain.position( src + pixelSizeInBytes );
+        extract.extract( isSwap, datain, extractTotals[1] );
+        datain.position( src + rowSizeInBytes );
+        extract.extract( isSwap, datain, extractTotals[2] );
+        datain.position( src + rowSizeInBytes + pixelSizeInBytes );
+        extract.extract( isSwap, datain, extractTotals[3] );
+        for( cc = 0; cc < components; cc++ ) {
+          int kk = 0;
+          // grab 4 pixels to average
+          totals[cc] = 0.0f;
+          for( kk = 0; kk < BOX4; kk++ ) {
+            totals[cc] += extractTotals[kk][cc];
+          }
+          totals[cc] /= BOX4;
+        }
+        extract.shove( totals, outIndex, dataout );
+        outIndex++;
+        src += pixelSizeInBytes + pixelSizeInBytes;
+      }
+      // skip past pad bytes, if any, to get to next row
+      src += padBytes;
+      src += rowSizeInBytes;
+    }
+    assert( src == rowSizeInBytes * height );
+    assert( outIndex == halfWidth * halfHeight );
+  }
+  
+  public static void halve1DimagePackedPixel( int components, Extract extract, int width,
+              int height, ByteBuffer datain, ByteBuffer dataout,
+              int pixelSizeInBytes, int rowSizeInBytes, boolean isSwap ) {
+    int halfWidth = width / 2;
+    int halfHeight = height / 2;
+    int src = 0;
+    int jj;
+    
+    assert( width == 1 || height == 1 );
+    assert( width != height );
+    
+    if( height == 1 ) {
+      int outIndex = 0;
+      
+      assert( width != 1 );
+      halfHeight = 1;
+      
+      // one horizontal row with possible pad bytes
+      
+      for( jj = 0; jj < halfWidth; jj++ ) {
+        float[] totals = new float[4];
+        float[][] extractTotals = new float[BOX2][4];
+        int cc;
+        
+        datain.position( src );
+        extract.extract( isSwap, datain, extractTotals[0] );
+        datain.position( src + pixelSizeInBytes );
+        extract.extract( isSwap, datain, extractTotals[1] );
+        for( cc = 0; cc < components; cc++ ) {
+          int kk = 0;
+          // grab 4 pixels to average
+          totals[cc] = 0.0f;
+          for( kk = 0; kk < BOX2; kk++ ) {
+            totals[cc] += extractTotals[kk][cc];
+          }
+          totals[cc] /= BOX2;
+        }
+        extract.shove( totals, outIndex, dataout );
+        outIndex++;
+        // skip over to next group of 2
+        src += pixelSizeInBytes + pixelSizeInBytes;
+      }
+      int padBytes = rowSizeInBytes - ( width * pixelSizeInBytes );
+      src += padBytes;
+      
+      assert( src == rowSizeInBytes );
+      assert( outIndex == halfWidth * halfHeight );
+    } else if( width == 1 ) {
+      int outIndex = 0;
+      
+      assert( height != 1 );
+      halfWidth = 1;
+      // one vertical volumn with possible pad bytes per row
+      // average two at a time
+      
+      for( jj = 0; jj < halfHeight; jj++ ) {
+        float[] totals = new float[4];
+        float[][] extractTotals = new float[BOX2][4];
+        int cc;
+        // average two at a time, instead of four
+        datain.position( src );
+        extract.extract( isSwap, datain, extractTotals[0] );
+        datain.position( src + rowSizeInBytes );
+        extract.extract( isSwap, datain, extractTotals[1] );
+        for( cc = 0; cc < components; cc++ ) {
+          int kk = 0;
+          // grab 4 pixels to average
+          totals[cc] = 0.0f;
+          for( kk = 0; kk < BOX2; kk++ ) {
+            totals[cc] += extractTotals[kk][cc];
+          }
+          totals[cc] /= BOX2;
+        }
+        extract.shove( totals, outIndex, dataout );
+        outIndex++;
+        // skip over to next group of 2
+        src += rowSizeInBytes + rowSizeInBytes;
+      }
+      assert( src == rowSizeInBytes );
+      assert( outIndex == halfWidth * halfHeight );
+    }
+  }
+  
+  public static void halveImagePackedPixelSlice( int components, Extract extract,
+          int width, int height, int depth, ByteBuffer dataIn,
+          ByteBuffer dataOut, int pixelSizeInBytes, int rowSizeInBytes,
+          int imageSizeInBytes, boolean isSwap ) {
+    int ii, jj;
+    int halfWidth = width / 2;
+    int halfHeight = height / 2;
+    int halfDepth = depth / 2;
+    int src = 0;
+    int padBytes = rowSizeInBytes - ( width * pixelSizeInBytes );
+    int outIndex = 0;
+    
+    assert( (width == 1 || height == 1) && depth >= 2 );
+    
+    if( width == height ) {
+      assert( width == 1 && height == 1 );
+      assert( depth >= 2 );
+      
+      for( ii = 0; ii < halfDepth; ii++ ) {
+        float totals[] = new float[4];
+        float extractTotals[][] = new float[BOX2][4];
+        int cc;
+        
+        dataIn.position( src );
+        extract.extract( isSwap, dataIn, extractTotals[0] );
+        dataIn.position( src + imageSizeInBytes );
+        extract.extract( isSwap, dataIn, extractTotals[1] );
+        
+        for( cc = 0; cc < components; cc++ ) {
+          int kk;
+          
+          // average only 2 pixels since a column
+          totals[cc]= 0.0f;
+          for( kk = 0; kk < BOX2; kk++ ) {
+            totals[cc] += extractTotals[kk][cc];
+          }
+          totals[cc] /= BOX2;
+        } // for cc
+        
+        extract.shove( totals, outIndex, dataOut );
+        outIndex++;
+        // skip over to next group of 2
+        src += imageSizeInBytes + imageSizeInBytes;
+      } // for ii
+    } else if( height == 1 ) {
+      assert( width != 1 );
+      
+      for( ii = 0; ii < halfDepth; ii++ ) {
+        for( jj = 0; jj < halfWidth; jj++ ) {
+          float totals[] = new float[4];
+          float extractTotals[][] = new float[BOX4][4];
+          int cc;
+          
+          dataIn.position( src );
+          extract.extract( isSwap, dataIn, extractTotals[0] );
+          dataIn.position( src + pixelSizeInBytes );
+          extract.extract( isSwap, dataIn, extractTotals[1] );
+          dataIn.position( src + imageSizeInBytes );
+          extract.extract( isSwap, dataIn, extractTotals[2] );
+          dataIn.position( src + pixelSizeInBytes + imageSizeInBytes );
+          extract.extract( isSwap, dataIn, extractTotals[3] );
+          
+          for( cc = 0; cc < components; cc++ ) {
+            int kk;
+            
+            // grab 4 pixels to average
+            totals[cc] = 0.0f;
+            for( kk = 0; kk < BOX4; kk++ ) {
+              totals[cc]+= extractTotals[kk][cc];
+            }
+            totals[cc]/= (float)BOX4;
+          }
+          extract.shove( totals, outIndex, dataOut );
+          outIndex++;
+          // skip over to next horizontal square of 4
+          src += imageSizeInBytes + imageSizeInBytes;
+        }
+      }
+    } else if( width == 1 ) {
+      assert( height != 1 );
+      
+      for( ii = 0; ii < halfDepth; ii++ ) {
+        for( jj = 0; jj < halfWidth; jj++ ) {
+          float totals[] = new float[4];
+          float extractTotals[][] = new float[BOX4][4];
+          int cc;
+          
+          dataIn.position( src );
+          extract.extract( isSwap, dataIn, extractTotals[0] );
+          dataIn.position( src + rowSizeInBytes );
+          extract.extract( isSwap, dataIn, extractTotals[1] );
+          dataIn.position( src + imageSizeInBytes );
+          extract.extract( isSwap, dataIn, extractTotals[2] );
+          dataIn.position( src + rowSizeInBytes + imageSizeInBytes );
+          extract.extract( isSwap, dataIn, extractTotals[3] );
+          
+          for( cc = 0; cc < components; cc++ ) {
+            int kk;
+            
+            // grab 4 pixels to average
+            totals[cc] = 0.0f;
+            for( kk = 0; kk < BOX4; kk++ ) {
+              totals[cc]+= extractTotals[kk][cc];
+            }
+            totals[cc]/= (float)BOX4;
+          }
+          extract.shove( totals, outIndex, dataOut );
+          outIndex++;
+          // skip over to next horizontal square of 4
+          src += imageSizeInBytes + imageSizeInBytes;
+        }
+      }
+    }
+  }
+  
+  public static void halveImageSlice( int components, ExtractPrimitive extract, int width,
+          int height, int depth, ByteBuffer dataIn, ByteBuffer dataOut,
+          int elementSizeInBytes, int groupSizeInBytes, int rowSizeInBytes,
+          int imageSizeInBytes, boolean isSwap ) {
+    int ii, jj;
+    int halfWidth = width / 2;
+    int halfHeight = height / 2;
+    int halfDepth = depth / 2;
+    int src = 0;
+    int padBytes = rowSizeInBytes - ( width * groupSizeInBytes );
+    int outIndex = 0;
+    
+    assert( (width == 1 || height == 1) && depth >= 2 );
+    
+    if( width == height ) {
+      assert( width == 1 && height == 1 );
+      assert( depth >= 2 );
+      
+      for( ii = 0; ii < halfDepth; ii++ ) {
+        int cc;
+        for( cc = 0; cc < components; cc++ ) {
+          double[] totals = new double[4];
+          double[][] extractTotals = new double[BOX2][4];
+          int kk;
+          
+          dataIn.position( src );
+          extractTotals[0][cc] = extract.extract( isSwap, dataIn );
+          dataIn.position( src + imageSizeInBytes );
+          extractTotals[1][cc] = extract.extract( isSwap, dataIn );
+          
+          // average 2 pixels since only a column
+          totals[cc] = 0.0f;
+          // totals[red] = extractTotals[0][red] + extractTotals[1][red];
+          // totals[red] = red / 2;
+          for( kk = 0; kk < BOX2; kk++ ) {
+            totals[cc] += extractTotals[kk][cc];
+          }
+          totals[cc] /= (double)BOX2;
+          
+          extract.shove( totals[cc], outIndex, dataOut );
+          outIndex++;
+          src += elementSizeInBytes;
+        } // for cc
+        // skip over next group of 2
+        src += rowSizeInBytes;
+      } // for ii
+      
+      assert( src == rowSizeInBytes * height * depth );
+      assert( outIndex == halfDepth * components );
+    } else if( height == 1 ) {
+      assert( width != 1 );
+      
+      for( ii = 0; ii < halfDepth; ii++ ) {
+        for( jj = 0; jj < halfWidth; jj++ ) {
+          int cc;
+          for( cc = 0; cc < components; cc++ ) {
+            int kk;
+            double totals[] = new double[4];
+            double extractTotals[][] = new double[BOX4][4];
+            
+            dataIn.position( src );
+            extractTotals[0][cc] = extract.extract( isSwap, dataIn );
+            dataIn.position( src + groupSizeInBytes );
+            extractTotals[1][cc] = extract.extract( isSwap, dataIn );
+            dataIn.position( src + imageSizeInBytes );
+            extractTotals[2][cc] = extract.extract( isSwap, dataIn );
+            dataIn.position( src + imageSizeInBytes + groupSizeInBytes );
+            extractTotals[3][cc] = extract.extract( isSwap, dataIn );
+            
+            // grab 4 pixels to average
+            totals[cc] = 0.0f;
+            // totals[red] = extractTotals[0][red] + extractTotals[1][red] +
+            //               extractTotals[2][red] + extractTotals[3][red];
+            // totals[red] /= (double)BOX4;
+            for( kk = 0; kk < BOX4; kk++ ) {
+              totals[cc] += extractTotals[kk][cc];
+            }
+            totals[cc] /= (double)BOX4;
+            
+            extract.shove( totals[cc], outIndex, dataOut );
+            outIndex++;
+            src += elementSizeInBytes;
+          } // for cc
+          // skip over to next horizontal square of 4
+          src += elementSizeInBytes;
+        } // for jj
+        src += padBytes;
+        src += rowSizeInBytes;
+      } // for ii
+      assert( src == rowSizeInBytes * height * depth );
+      assert( outIndex == halfWidth * halfDepth * components );
+    } else if( width == 1 ) {
+      assert( height != 1 );
+      
+      for( ii = 0; ii < halfDepth; ii++ ) {
+        for( jj = 0; jj < halfHeight; jj++ ) {
+          int cc;
+          for( cc = 0; cc < components; cc++ ) {
+            int kk;
+            double totals[] = new double[4];
+            double extractTotals[][] = new double[BOX4][4];
+            
+            dataIn.position( src );
+            extractTotals[0][cc] = extract.extract( isSwap, dataIn );
+            dataIn.position( src + rowSizeInBytes );
+            extractTotals[1][cc] = extract.extract( isSwap, dataIn );
+            dataIn.position( src + imageSizeInBytes );
+            extractTotals[2][cc] = extract.extract( isSwap, dataIn );
+            dataIn.position( src + imageSizeInBytes + groupSizeInBytes );
+            extractTotals[3][cc] = extract.extract( isSwap, dataIn );
+            
+            
+            // grab 4 pixels to average
+            totals[cc] = 0.0f;
+            // totals[red] = extractTotals[0][red] + extractTotals[1][red] +
+            //               extractTotals[2][red] + extractTotals[3][red];
+            // totals[red] /= (double)BOX4;
+            for( kk = 0; kk < BOX4; kk++ ) {
+              totals[cc] += extractTotals[kk][cc];
+            }
+            totals[cc] /= (double)BOX4;
+            
+            extract.shove( totals[cc], outIndex, dataOut );
+            outIndex++;
+            src += elementSizeInBytes;
+          } // for cc
+          // skip over to next horizontal square of 4
+          src += padBytes;
+          src += rowSizeInBytes;
+        } // for jj
+        src += imageSizeInBytes;
+      } // for ii
+      assert( src == rowSizeInBytes * height * depth );
+      assert( outIndex == halfWidth * halfDepth * components );
+    }
+  }
+  
+  public static void halveImage3D( int components, ExtractPrimitive extract,
+          int width, int height, int depth, ByteBuffer dataIn, ByteBuffer dataOut,
+          int elementSizeInBytes, int groupSizeInBytes, int rowSizeInBytes,
+          int imageSizeInBytes, boolean isSwap ) {
+    assert( depth > 1 );
+    
+    // horizontal/vertical/onecolumn slice viewed from top
+    if( width == 1 || height == 1 ) {
+      assert( 1 <= depth );
+      
+      halveImageSlice( components, extract, width, height, depth, dataIn, dataOut,
+              elementSizeInBytes, groupSizeInBytes, rowSizeInBytes, imageSizeInBytes,
+              isSwap );
+      return;
+    }
+    
+    int ii, jj, dd;
+    
+    int halfWidth = width / 2;
+    int halfHeight = height / 2;
+    int halfDepth = depth / 2;
+    int src = 0;
+    int padBytes = rowSizeInBytes - ( width * groupSizeInBytes );
+    int outIndex = 0;
+    
+    for( dd = 0; dd < halfDepth; dd++ ) {
+      for( ii = 0; ii < halfHeight; ii++ ) {
+        for( jj = 0; jj < halfWidth; jj++ ) {
+          int cc;
+          for( cc = 0; cc < components; cc++ ) {
+            int kk;
+            double totals[] = new double[4];
+            double extractTotals[][] = new double[BOX8][4];
+            
+            dataIn.position( src );
+            extractTotals[0][cc] = extract.extract( isSwap, dataIn );
+            dataIn.position( src + groupSizeInBytes );
+            extractTotals[1][cc] = extract.extract( isSwap, dataIn );
+            dataIn.position( src + rowSizeInBytes );
+            extractTotals[2][cc] = extract.extract( isSwap, dataIn );
+            dataIn.position( src + rowSizeInBytes + groupSizeInBytes );
+            extractTotals[3][cc] = extract.extract( isSwap, dataIn );
+            dataIn.position( src + imageSizeInBytes );
+            extractTotals[4][cc] = extract.extract( isSwap, dataIn );
+            dataIn.position( src + groupSizeInBytes + imageSizeInBytes );
+            extractTotals[5][cc] = extract.extract( isSwap, dataIn );
+            dataIn.position( src + rowSizeInBytes + imageSizeInBytes );
+            extractTotals[6][cc] = extract.extract( isSwap, dataIn );
+            dataIn.position( src + rowSizeInBytes + imageSizeInBytes + groupSizeInBytes );
+            extractTotals[7][cc] = extract.extract( isSwap, dataIn );
+            
+            totals[cc] = 0.0f;
+            
+            for( kk = 0; kk < BOX8; kk++ ) {
+              totals[cc] += extractTotals[kk][cc];
+            }
+            totals[cc] /= (double)BOX8;
+            
+            extract.shove( totals[cc], outIndex, dataOut );
+            outIndex++;
+            
+            src += elementSizeInBytes;
+          } // for cc
+          // skip over to next square of 4
+          src += groupSizeInBytes;
+        } // for jj
+        // skip past pad bytes, if any, to get to next row
+        src += padBytes;
+        src += rowSizeInBytes;
+      } // for ii
+      src += imageSizeInBytes;
+    } // for dd
+    assert( src == rowSizeInBytes * height * depth );
+    assert( outIndex == halfWidth * halfHeight * halfDepth * components );
+  }
+  
+  public static void halveImagePackedPixel3D( int components, Extract extract,
+          int width, int height, int depth, ByteBuffer dataIn, 
+          ByteBuffer dataOut, int pixelSizeInBytes, int rowSizeInBytes,
+          int imageSizeInBytes, boolean isSwap ) {
+    if( depth == 1 ) {
+      assert( 1 <= width && 1 <= height );
+      
+      halveImagePackedPixel( components, extract, width, height, dataIn, dataOut,
+              pixelSizeInBytes, rowSizeInBytes, isSwap );
+      return;
+    } else if( width == 1 || height == 1 ) { // a horizontal or vertical slice viewed from top
+      assert( 1 <= depth );
+      
+      halveImagePackedPixelSlice( components, extract, width, height, depth, dataIn,
+              dataOut, pixelSizeInBytes, rowSizeInBytes, imageSizeInBytes, isSwap );
+      return;
+    }
+    int ii, jj, dd;
+    
+    int halfWidth = width / 2;
+    int halfHeight = height / 2;
+    int halfDepth = depth / 2;
+    int src = 0;
+    int padBytes = rowSizeInBytes - ( width * pixelSizeInBytes );
+    int outIndex = 0;
+    
+    for( dd = 0; dd < halfDepth; dd++ ) {
+      for( ii = 0; ii < halfHeight; ii++ ) {
+        for( jj = 0; jj < halfWidth; jj++ ) {
+          float totals[] = new float[4]; // 4 is max components
+          float extractTotals[][] = new float[BOX8][4];
+          int cc;
+          
+          dataIn.position( src );
+          extract.extract( isSwap, dataIn, extractTotals[0] );
+          dataIn.position( src + pixelSizeInBytes );
+          extract.extract( isSwap, dataIn, extractTotals[1] );
+          dataIn.position( src + rowSizeInBytes );
+          extract.extract( isSwap, dataIn, extractTotals[2] );
+          dataIn.position( src + rowSizeInBytes + pixelSizeInBytes );
+          extract.extract( isSwap, dataIn, extractTotals[3] );
+          dataIn.position( src + imageSizeInBytes );
+          extract.extract( isSwap, dataIn, extractTotals[4] );
+          dataIn.position( src + pixelSizeInBytes + imageSizeInBytes );
+          extract.extract( isSwap, dataIn, extractTotals[5] );
+          dataIn.position( src + rowSizeInBytes + imageSizeInBytes );
+          extract.extract( isSwap, dataIn, extractTotals[6] );
+          dataIn.position( src + rowSizeInBytes + pixelSizeInBytes + imageSizeInBytes );
+          extract.extract( isSwap, dataIn, extractTotals[7] );
+          
+          for( cc = 0; cc < components; cc++ ) {
+            int kk;
+            // grab 8 pixels to average
+            totals[cc] = 0.0f;
+            for( kk = 0; kk < BOX8; kk++ ) {
+              totals[cc] += extractTotals[kk][cc];
+            }
+            totals[cc] /= (float)BOX8;
+          }
+          extract.shove( totals, outIndex, dataOut );
+          outIndex++;
+          // skip over to next square of 4
+          src += pixelSizeInBytes + pixelSizeInBytes;
+        }
+        // skip past pad bytes, if any, to get to next row
+        src += padBytes;
+        src += rowSizeInBytes;
+      }
+      src += imageSizeInBytes;
+    }
+    assert( src == rowSizeInBytes * height * depth );
+    assert( outIndex == halfWidth * halfHeight * halfDepth );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Image.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Image.java
new file mode 100644
index 000000000..605d5547b
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Image.java
@@ -0,0 +1,1413 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import javax.media.opengl.GL;
+import javax.media.opengl.GL2;
+import java.nio.*;
+
+/**
+ *
+ * @author  Administrator
+ */
+public class Image {
+  
+  /** Creates a new instance of Image */
+  public Image() {
+  }
+  
+  public static short getShortFromByteArray( byte[] array, int index ) {
+    short s;
+    s = (short)(array[index] << 8 );
+    s |= (short)(0x00FF & array[index+1]);
+    return( s );
+  }
+  
+  public static int getIntFromByteArray( byte[] array, int index ) {
+    int i;
+    i = ( array[index] << 24 ) & 0xFF000000;
+    i |= ( array[index+1] << 16 ) & 0x00FF0000;
+    i |= ( array[index+2] << 8 ) & 0x0000FF00;
+    i |= ( array[index+3] ) & 0x000000FF;
+    return( i );
+  }
+  
+  public static float getFloatFromByteArray( byte[] array, int index ) {
+    int i = getIntFromByteArray( array, index );
+    return( Float.intBitsToFloat(i) );
+  }
+  
+  /*
+   *  Extract array from user's data applying all pixel store modes.
+   *  The internal format used is an array of unsigned shorts.
+   */
+  public static void fill_image( PixelStorageModes psm, int width, int height,
+                  int format, int type, boolean index_format, ByteBuffer userdata,
+                  ShortBuffer newimage ) {
+    int components;
+    int element_size;
+    int rowsize;
+    int padding;
+    int groups_per_line;
+    int group_size;
+    int elements_per_line;
+    int start;
+    int iter = 0;
+    int iter2;
+    int i, j, k;
+    boolean myswap_bytes;
+    
+    // Create a Extract interface object
+    Extract extract = null;
+    switch( type ) {
+      case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+        extract = new Extract332();
+        break;
+      case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+        extract = new Extract233rev();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+        extract = new Extract565();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+        extract = new Extract565rev();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+        extract = new Extract4444();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+        extract = new Extract4444rev();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+        extract = new Extract5551();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+        extract = new Extract1555rev();
+        break;
+      case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+        extract = new Extract8888();
+        break;
+      case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+        extract = new Extract8888rev();
+        break;
+      case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+        extract = new Extract1010102();
+        break;
+      case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+        extract = new Extract2101010rev();
+        break;
+    }
+    
+    myswap_bytes = psm.getUnpackSwapBytes();
+    components = Mipmap.elements_per_group( format, type );
+    if( psm.getUnpackRowLength() > 0 ) {
+      groups_per_line = psm.getUnpackRowLength();
+    } else {
+      groups_per_line = width;
+    }
+    
+    // All formats except GL_BITMAP fall out trivially
+    if( type == GL2.GL_BITMAP ) {
+      int bit_offset;
+      int current_bit;
+      
+      rowsize = ( groups_per_line * components + 7 ) / 8;
+      padding = ( rowsize % psm.getUnpackAlignment() );
+      if( padding != 0 ) {
+        rowsize += psm.getUnpackAlignment() - padding;
+      }
+      start = psm.getUnpackSkipRows() * rowsize + ( psm.getUnpackSkipPixels() * components / 8 );
+      elements_per_line = width * components;
+      iter2 = 0;
+      for( i = 0; i < height; i++ ) {
+        iter = start;
+        userdata.position( iter ); // ****************************************
+        bit_offset = (psm.getUnpackSkipPixels() * components) % 8;
+        for( j = 0; j < elements_per_line; j++ ) {
+          // retrieve bit
+          if( psm.getUnpackLsbFirst() ) {
+            userdata.position( iter );
+            current_bit = ( userdata.get() & 0x000000FF ) & ( 1 << bit_offset );//userdata[iter] & ( 1 << bit_offset );
+          } else {
+            current_bit = ( userdata.get() & 0x000000FF ) & ( 1 << ( 7 - bit_offset ) );
+          }
+          if( current_bit != 0 ) {
+            if( index_format ) {
+              newimage.position( iter2 );
+              newimage.put( (short)1 );
+            } else {
+              newimage.position( iter2 );
+              newimage.put( (short)65535 );
+            }
+          } else {
+            newimage.position( iter2 );
+            newimage.put( (short)0 );
+          }
+          bit_offset++;
+          if( bit_offset == 8 ) {
+            bit_offset = 0;
+            iter++;
+          }
+          iter2++;
+        }
+        start += rowsize;
+      }
+    } else {
+      element_size = Mipmap.bytes_per_element( type );
+      group_size = element_size * components;
+      if( element_size == 1 ) {
+        myswap_bytes = false;
+      }
+      
+      rowsize = groups_per_line * group_size;
+      padding = ( rowsize % psm.getUnpackAlignment() );
+      if( padding != 0 ) {
+        rowsize += psm.getUnpackAlignment() - padding;
+      }
+      start = psm.getUnpackSkipRows() * rowsize + psm.getUnpackSkipPixels() * group_size;
+      elements_per_line = width * components;
+      
+      iter2 = 0;
+      for( i = 0; i < height; i++ ) {
+        iter = start;
+        userdata.position( iter ); //***************************************
+        for( j = 0; j < elements_per_line; j++ ) {
+          Type_Widget widget = new Type_Widget();
+          float[] extractComponents = new float[4];
+          userdata.position( iter );
+          switch( type ) {
+            case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+              extract.extract( false, userdata /*userdata[iter]*/, extractComponents );
+              for( k = 0; k < 3; k++ ) {
+                newimage.put( iter2++, (short)(extractComponents[k] * 65535 ) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+              extract.extract( false, userdata /*userdata[iter]*/, extractComponents );
+              for( k = 0; k < 3; k++ ) {
+                newimage.put( iter2++, (short)(extractComponents[k] * 65535 ) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_BYTE ):
+              if( index_format ) {
+                newimage.put( iter2++, (short)( 0x000000FF & userdata.get() ) );//userdata[iter];
+              } else {
+                newimage.put( iter2++, (short)( 0x000000FF & userdata.get()/*userdata[iter]*/ * 257 ) );
+              }
+              break;
+            case( GL2.GL_BYTE ):
+              if( index_format ) {
+                newimage.put( iter2++, userdata.get() ); //userdata[iter];
+              } else {
+                newimage.put( iter2++, (short)(userdata.get()/*userdata[iter]*/ * 516 ) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+              extract.extract( myswap_bytes, userdata/*userdata[iter]*/, extractComponents );
+              for( k = 0; k < 3; k++ ) {
+                newimage.put( iter2++, (short)(extractComponents[k] * 65535) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+              extract.extract( myswap_bytes, userdata, extractComponents );
+              for( k = 0; k < 3; k++ ) {
+                newimage.put( iter2++, (short)(extractComponents[k] * 65535 ) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+              extract.extract( myswap_bytes, userdata, extractComponents );
+              for( k = 0; k < 4; k++ ) {
+                newimage.put( iter2++, (short)(extractComponents[k] * 65535 ) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+              extract.extract( myswap_bytes, userdata, extractComponents );
+              for( k = 0; k < 4; k++ ) {
+                newimage.put( iter2++, (short)( extractComponents[k] * 65535 ) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+              extract.extract( myswap_bytes, userdata, extractComponents );
+              for( k = 0; k < 4; k++ ) {
+                newimage.put( iter2++, (short)(extractComponents[k] * 65535 ) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+              extract.extract( myswap_bytes, userdata, extractComponents );
+              for( k = 0; k < 4; k++ ) {
+                newimage.put( iter2++, (short)( extractComponents[k] * 65535 ) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT ):
+            case( GL2.GL_SHORT ):
+              if( myswap_bytes ) {
+                widget.setUB1( userdata.get() );
+                widget.setUB0( userdata.get() );
+              } else {
+                widget.setUB0( userdata.get() );
+                widget.setUB1( userdata.get() );
+              }
+              if( type == GL2.GL_SHORT ) {
+                if( index_format ) {
+                  newimage.put( iter2++, widget.getS0() );
+                } else {
+                  newimage.put( iter2++, (short)(widget.getS0() * 2) );
+                }
+              } else {
+                newimage.put( iter2++, widget.getUS0() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+              extract.extract( myswap_bytes, userdata, extractComponents );
+              for( k = 0; k < 4; k++ ) {
+                newimage.put( iter2++, (short)( extractComponents[k] * 65535 ) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+              extract.extract( myswap_bytes, userdata, extractComponents );
+              for( k = 0; k < 4; k++ ) {
+                newimage.put( iter2++, (short)( extractComponents[k] * 65535 ) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+              extract.extract( myswap_bytes, userdata, extractComponents );
+              for( k = 0; k < 4; k++ ) {
+                newimage.put( iter2++, (short)( extractComponents[k] * 65535 ) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+              extract.extract( myswap_bytes, userdata, extractComponents );
+              for( k = 0; k < 4; k++ ) {
+                newimage.put( iter2++, (short)( extractComponents[k] * 65535 ) );
+              }
+              break;
+            case( GL2.GL_INT ):
+            case( GL2.GL_UNSIGNED_INT ):
+            case( GL2.GL_FLOAT ):
+              if( myswap_bytes ) {
+                widget.setUB3( userdata.get() );
+                widget.setUB2( userdata.get() );
+                widget.setUB1( userdata.get() );
+                widget.setUB0( userdata.get() );
+              } else {
+                widget.setUB0( userdata.get() );
+                widget.setUB1( userdata.get() );
+                widget.setUB2( userdata.get() );
+                widget.setUB3( userdata.get() );
+              }
+              if( type == GL2.GL_FLOAT ) {
+                if( index_format ) {
+                  newimage.put( iter2++, (short)widget.getF() );
+                } else {
+                  newimage.put( iter2++, (short)(widget.getF() * 65535 ) );
+                }
+              } else if( type == GL2.GL_UNSIGNED_INT ) {
+                if( index_format ) {
+                  newimage.put( iter2++, (short)( widget.getUI() ) );
+                } else {
+                  newimage.put( iter2++, (short)( widget.getUI() >> 16 ) );
+                }
+              } else {
+                if( index_format ) {
+                  newimage.put( iter2++, (short)( widget.getI() ) );
+                } else {
+                  newimage.put( iter2++, (short)( widget.getI() >> 15 ) );
+                }
+              }
+              break;
+          }
+          iter += element_size;
+        }  // for j
+        start += rowsize;
+        // want iter pointing at start, not within, row for assertion purposes
+        iter = start;
+      } // for i
+      
+      // iterators should be one byte past end
+      if( !Mipmap.isTypePackedPixel( type ) ) {
+        assert( iter2 == ( width * height * components ) );
+      } else {
+        assert( iter2 == ( width * height * Mipmap.elements_per_group( format, 0 ) ) );
+      }
+      assert( iter == ( rowsize * height + psm.getUnpackSkipRows() * rowsize + psm.getUnpackSkipPixels() * group_size ) );
+    }
+  }
+  
+  /*
+   *  Insert array into user's data applying all pixel store modes.
+   *  Theinternal format is an array of unsigned shorts.
+   *  empty_image() because it is the opposet of fill_image().
+   */
+  public static void empty_image( PixelStorageModes psm, int width, int height, 
+                                  int format, int type, boolean index_format, 
+                                  ShortBuffer oldimage, ByteBuffer userdata ) {
+    
+    int components;
+    int element_size;
+    int rowsize;
+    int padding;
+    int groups_per_line;
+    int group_size;
+    int elements_per_line;
+    int start;
+    int iter = 0;
+    int iter2;
+    int i, j, k;
+    boolean myswap_bytes;
+    
+    // Create a Extract interface object
+    Extract extract = null;
+    switch( type ) {
+      case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+        extract = new Extract332();
+        break;
+      case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+        extract = new Extract233rev();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+        extract = new Extract565();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+        extract = new Extract565rev();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+        extract = new Extract4444();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+        extract = new Extract4444rev();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+        extract = new Extract5551();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+        extract = new Extract1555rev();
+        break;
+      case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+        extract = new Extract8888();
+        break;
+      case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+        extract = new Extract8888rev();
+        break;
+      case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+        extract = new Extract1010102();
+        break;
+      case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+        extract = new Extract2101010rev();
+        break;
+    }
+    
+    myswap_bytes = psm.getPackSwapBytes();
+    components = Mipmap.elements_per_group( format, type );
+    if( psm.getPackRowLength() > 0 ) {
+      groups_per_line = psm.getPackRowLength();
+    } else {
+      groups_per_line = width;
+    }
+    
+    // all formats except GL_BITMAP fall out trivially
+    if( type == GL2.GL_BITMAP ) {
+      int bit_offset;
+      int current_bit;
+      
+      rowsize = ( groups_per_line * components + 7 ) / 8;
+      padding = ( rowsize % psm.getPackAlignment() );
+      if( padding != 0 ) {
+        rowsize += psm.getPackAlignment() - padding;
+      }
+      start = psm.getPackSkipRows() * rowsize + psm.getPackSkipPixels() * components / 8;
+      elements_per_line = width * components;
+      iter2 = 0;
+      for( i = 0; i < height; i++ ) {
+        iter = start;
+        bit_offset = ( psm.getPackSkipPixels() * components ) % 8;
+        for( j = 0; j < elements_per_line; j++ ) {
+          if( index_format ) {
+            current_bit = oldimage.get( iter2 ) & 1;
+          } else {
+            if( oldimage.get( iter2 ) < 0 ) { // must check for negative rather than 32767
+              current_bit = 1;
+            } else {
+              current_bit = 0;
+            }
+          }
+          
+          if( current_bit != 0 ) {
+            if( psm.getPackLsbFirst() ) {
+              userdata.put( iter, (byte)( ( userdata.get( iter ) | ( 1 << bit_offset ) ) ) );
+            } else {
+              userdata.put( iter, (byte)( ( userdata.get( iter ) | ( 7 - bit_offset ) ) ) );
+            }
+          } else {
+            if( psm.getPackLsbFirst() ) {
+              //userdata[iter] &= ~( 1 << bit_offset );
+              userdata.put( iter, (byte)( ( userdata.get( iter ) & ~( 1 << bit_offset ) ) ) );
+            } else {
+              //userdata[iter] &= ~( 1 << ( 7 - bit_offset ) );
+              userdata.put( iter, (byte)( ( userdata.get( iter ) & ~( 7 - bit_offset ) ) ) );
+            }
+          }
+          
+          bit_offset++;
+          if( bit_offset == 8 ) {
+            bit_offset = 0;
+            iter++;
+          }
+          iter2++;
+        }
+        start += rowsize;
+      }
+    } else {
+      float shoveComponents[] = new float[4];
+      
+      element_size = Mipmap.bytes_per_element( type );
+      group_size = element_size * components;
+      if( element_size == 1 ) {
+        myswap_bytes = false;
+      }
+      
+      rowsize = groups_per_line * group_size;
+      padding = ( rowsize % psm.getPackAlignment() );
+      if( padding != 0 ) {
+        rowsize += psm.getPackAlignment() - padding;
+      }
+      start = psm.getPackSkipRows() * rowsize + psm.getPackSkipPixels() * group_size;
+      elements_per_line = width * components;
+      
+      iter2 = 0;
+      for( i = 0; i < height; i++ ) {
+        iter = start;
+        for( j = 0; j < elements_per_line; j++ ) {
+          Type_Widget widget = new Type_Widget();
+          
+          switch( type ) {
+            case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+              for( k = 0; k < 3; k++ ) {
+                shoveComponents[k] = oldimage.get( iter2++ ) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, userdata );
+              break;
+            case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+              for( k = 0; k < 3; k++ ) {
+                shoveComponents[k] = oldimage.get(iter2++) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, userdata );
+              break;
+            case( GL2.GL_UNSIGNED_BYTE ):
+              if( index_format ) {
+                //userdata[iter] = (byte)oldimage[iter2++];
+                userdata.put( iter, (byte)oldimage.get(iter2++) );
+              } else {
+                //userdata[iter] = (byte)( oldimage[iter2++] >> 8 );
+                userdata.put( iter, (byte)( oldimage.get(iter2++) ) );
+              }
+              break;
+            case( GL2.GL_BYTE ):
+              if( index_format ) {
+                //userdata[iter] = (byte)oldimage[iter2++];
+                userdata.put( iter, (byte)oldimage.get(iter2++) );
+              } else {
+                //userdata[iter] = (byte)( oldimage[iter2++] >> 9 );
+                userdata.put( iter, (byte)( oldimage.get(iter2++) ) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+              for( k = 0; k < 3; k++ ) {
+                shoveComponents[k] = oldimage.get(iter2++) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, widget.getBuffer() );
+              if( myswap_bytes ) {
+                //userdata[iter] = widget.getUB1();
+                //userdata[iter+1] = widget.getUB0();
+                userdata.put( iter, widget.getUB1() );
+                userdata.put( iter + 1,widget.getUB0() );
+              } else {
+                //userdata[iter] = widget.getUB0();
+                //userdata[iter+1] = widget.getUB1();
+                userdata.put( iter, widget.getUB0() );
+                userdata.put( iter + 1, widget.getUB1() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+              for( k = 0; k < 3; k++ ) {
+                shoveComponents[k] = oldimage.get(iter2++) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, widget.getBuffer() );
+              if( myswap_bytes ) {
+                //userdata[iter] = widget.getUB1();
+                //userdata[iter+1] = widget.getUB0();
+                userdata.put( iter, widget.getUB1() );
+                userdata.put( iter + 1, widget.getUB0() );
+              } else {
+                //userdata[iter] = widget.getUB0();
+                //userdata[iter+1] = widget.getUB1();
+                userdata.put( iter, widget.getUB0() );
+                userdata.put( iter, widget.getUB1() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+              for( k = 0; k < 4; k++ ) {
+                shoveComponents[k] = oldimage.get(iter2++) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, widget.getBuffer() );
+              if( myswap_bytes ) {
+                //userdata[iter] = widget.getUB1();
+                //userdata[iter+1] = widget.getUB0();
+                userdata.put( iter, widget.getUB1() );
+                userdata.put( iter + 1, widget.getUB0() );
+              } else {
+                //userdata[iter] = widget.getUB0();
+                //userdata[iter+1] = widget.getUB1();
+                userdata.put( iter, widget.getUB0() );
+                userdata.put( iter + 1, widget.getUB1() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+              for( k = 0; k < 4; k++ ) {
+                shoveComponents[k] = oldimage.get( iter2++ ) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, widget.getBuffer() );
+              if( myswap_bytes ) {
+                //userdata[iter] = widget.getUB1();
+                //userdata[iter+1] = widget.getUB0();
+                userdata.put( iter, widget.getUB1() );
+                userdata.put( iter + 1, widget.getUB0() );
+              } else {
+                //userdata[iter] = widget.getUB0();
+                //userdata[iter+1] = widget.getUB1();
+                userdata.put( iter, widget.getUB0() );
+                userdata.put( iter + 1, widget.getUB1() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+              for( k = 0; k < 4; k++ ) {
+                shoveComponents[k] = oldimage.get( iter2++ ) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, widget.getBuffer() );
+              if( myswap_bytes ) {
+                //userdata[iter] = widget.getUB1();
+                //userdata[iter+1] = widget.getUB0();
+                userdata.put( iter, widget.getUB1() );
+                userdata.put( iter + 1, widget.getUB0() );
+              } else {
+                //userdata[iter] = widget.getUB0();
+                //userdata[iter+1] = widget.getUB1();
+                userdata.put( iter, widget.getUB0() );
+                userdata.put( iter + 1, widget.getUB1() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+              for( k = 0; k < 4; k++ ) {
+                shoveComponents[k] = oldimage.get( iter2++ ) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, widget.getBuffer() );
+              if( myswap_bytes ) {
+                //userdata[iter] = widget.getUB1();
+                //userdata[iter+1] = widget.getUB0();
+                userdata.put( iter, widget.getUB1() );
+                userdata.put( iter + 1, widget.getUB0() );
+              } else {
+                //userdata[iter] = widget.getUB0();
+                //userdata[iter+1] = widget.getUB1();
+                userdata.put( iter, widget.getUB0() );
+                userdata.put( iter + 1, widget.getUB1() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT ):
+            case( GL2.GL_SHORT ):
+              if( type == GL2.GL_SHORT ) {
+                if( index_format ) {
+                  widget.setS0( oldimage.get( iter2++ ) );
+                } else {
+                  widget.setS0( (short)(oldimage.get( iter2++ ) >> 1) );
+                }
+              } else {
+                widget.setUS0( oldimage.get( iter2++ ) );
+              }
+              if( myswap_bytes ) {
+                //userdata[iter] = widget.getUB1();
+                //userdata[iter+1] = widget.getUB0();
+                userdata.put( iter, widget.getUB1() );
+                userdata.put( iter + 1, widget.getUB0() );
+              } else {
+                //userdata[iter] = widget.getUB0();
+                //userdata[iter] = widget.getUB1();
+                userdata.put( iter, widget.getUB0() );
+                userdata.put( iter + 1, widget.getUB1() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+              for( k = 0; k < 4; k++ ) {
+                shoveComponents[k] = oldimage.get( iter2++ ) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, widget.getBuffer() );
+              if( myswap_bytes ) {
+                //userdata[iter+3] = widget.getUB0();
+                //userdata[iter+2] = widget.getUB1();
+                //userdata[iter+1] = widget.getUB2();
+                //userdata[iter  ] = widget.getUB3();
+                userdata.put( iter + 3, widget.getUB0() );
+                userdata.put( iter + 2, widget.getUB1() );
+                userdata.put( iter + 1, widget.getUB2() );
+                userdata.put( iter    , widget.getUB3() );
+              } else {
+                userdata.putInt( iter, widget.getUI() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+              for( k = 0; k < 4; k++ ) {
+                shoveComponents[k] = oldimage.get( iter2++ ) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, widget.getBuffer() );
+              if( myswap_bytes ) {
+                //userdata[iter+3] = widget.getUB0();
+                //userdata[iter+2] = widget.getUB1();
+                //userdata[iter+1] = widget.getUB2();
+                //userdata[iter  ] = widget.getUB3();
+                userdata.put( iter + 3, widget.getUB0() );
+                userdata.put( iter + 2, widget.getUB1() );
+                userdata.put( iter + 2, widget.getUB2() );
+                userdata.put( iter    , widget.getUB3() );
+              } else {
+                userdata.putInt( iter, widget.getUI() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+              for( k = 0; k < 4; k++ ) {
+                shoveComponents[k] = oldimage.get( iter2++ ) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, widget.getBuffer() );
+              if( myswap_bytes ) {
+                //userdata[iter+3] = widget.getUB0();
+                //userdata[iter+2] = widget.getUB1();
+                //userdata[iter+1] = widget.getUB2();
+                //userdata[iter  ] = widget.getUB3();
+                userdata.put( iter + 3, widget.getUB0() );
+                userdata.put( iter + 2, widget.getUB1() );
+                userdata.put( iter + 1, widget.getUB2() );
+                userdata.put( iter    , widget.getUB3() );
+              } else {
+                userdata.putInt( iter, widget.getUI() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+              for( k = 0; k < 4; k++ ) {
+                shoveComponents[k] = oldimage.get( iter2++ ) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, widget.getBuffer() );
+              if( myswap_bytes ) {
+                //userdata[iter+3] = widget.getUB0();
+                //userdata[iter+2] = widget.getUB1();
+                //userdata[iter+1] = widget.getUB2();
+                //userdata[iter  ] = widget.getUB3();
+                userdata.put( iter + 3, widget.getUB0() );
+                userdata.put( iter + 2, widget.getUB1() );
+                userdata.put( iter + 1, widget.getUB2() );
+                userdata.put( iter    , widget.getUB3() );
+              } else {
+                userdata.putInt( iter, widget.getUI() );
+              }
+              break;
+            case( GL2.GL_INT ):
+            case( GL2.GL_UNSIGNED_INT ):
+            case( GL2.GL_FLOAT ):
+              if( type == GL2.GL_FLOAT ) {
+                if( index_format ) {
+                  widget.setF( oldimage.get( iter2++ ) );
+                } else {
+                  widget.setF( oldimage.get( iter2++ ) / 65535.0f );
+                }
+              } else if( type == GL2.GL_UNSIGNED_INT ) {
+                if( index_format ) {
+                  widget.setUI( oldimage.get( iter2++ ) );
+                } else {
+                  widget.setUI( oldimage.get( iter2++ ) * 65537 );
+                }
+              } else {
+                if( index_format ) {
+                  widget.setI( oldimage.get( iter2++ ) );
+                } else {
+                  widget.setI( (oldimage.get( iter2++ ) * 65537) / 2 );
+                }
+              }
+              if( myswap_bytes ) {
+                userdata.put( iter + 3, widget.getUB0() );
+                userdata.put( iter + 2, widget.getUB1() );
+                userdata.put( iter + 1, widget.getUB2() );
+                userdata.put( iter    , widget.getUB3() );
+              } else {
+                userdata.put( iter    , widget.getUB0() );
+                userdata.put( iter + 1, widget.getUB1() );
+                userdata.put( iter + 2, widget.getUB2() );
+                userdata.put( iter + 3, widget.getUB3() );
+              }
+              break;
+          }
+          iter += element_size;
+        } // for j
+        start += rowsize;
+        // want iter pointing at start, not within, row for assertion purposes
+        iter = start;
+      } // for i
+      // iterators should be one byte past end
+      if( !Mipmap.isTypePackedPixel( type ) ) {
+        assert( iter2 == width * height * components );
+      } else {
+        assert( iter2 == width * height * Mipmap.elements_per_group( format, 0 ) );
+      }
+      assert( iter == rowsize * height + psm.getPackSkipRows() * rowsize + psm.getPackSkipPixels() * group_size );
+    }
+  }
+  
+  public static void fillImage3D( PixelStorageModes psm, int width, int height,
+          int depth, int format, int type, boolean indexFormat, ByteBuffer userImage,
+          ShortBuffer newImage ) {
+    boolean myswapBytes;
+    int components;
+    int groupsPerLine;
+    int elementSize;
+    int groupSize;
+    int rowSize;
+    int padding;
+    int elementsPerLine;
+    int rowsPerImage;
+    int imageSize;
+    int start, rowStart;
+    int iter = 0;
+    int iter2 = 0;
+    int ww, hh, dd, k;
+    Type_Widget widget = new Type_Widget();
+    float extractComponents[] = new float[4];
+    
+    // Create a Extract interface object
+    Extract extract = null;
+    switch( type ) {
+      case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+        extract = new Extract332();
+        break;
+      case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+        extract = new Extract233rev();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+        extract = new Extract565();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+        extract = new Extract565rev();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+        extract = new Extract4444();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+        extract = new Extract4444rev();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+        extract = new Extract5551();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+        extract = new Extract1555rev();
+        break;
+      case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+        extract = new Extract8888();
+        break;
+      case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+        extract = new Extract8888rev();
+        break;
+      case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+        extract = new Extract1010102();
+        break;
+      case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+        extract = new Extract2101010rev();
+        break;
+    }
+    
+    myswapBytes = psm.getUnpackSwapBytes();
+    components = Mipmap.elements_per_group( format, type );
+    if( psm.getUnpackRowLength() > 0 ) {
+      groupsPerLine = psm.getUnpackRowLength();
+    } else {
+      groupsPerLine = width;
+    }
+    elementSize = Mipmap.bytes_per_element( type );
+    groupSize = elementSize * components;
+    if( elementSize == 1 ) {
+      myswapBytes = false;
+    }
+    
+    // 3dstuff begin
+    if( psm.getUnpackImageHeight() > 0 ) {
+      rowsPerImage = psm.getUnpackImageHeight();
+    } else {
+      rowsPerImage = height;
+    }
+    // 3dstuff end
+    
+    rowSize = groupsPerLine * groupSize;
+    padding = rowSize % psm.getUnpackAlignment();
+    if( padding != 0 ) {
+      rowSize += psm.getUnpackAlignment() - padding;
+    }
+    
+    imageSize = rowsPerImage * rowSize; // 3dstuff
+    
+    start = psm.getUnpackSkipRows() * rowSize + 
+            psm.getUnpackSkipPixels() * groupSize + 
+            psm.getUnpackSkipImages() * imageSize;
+    elementsPerLine = width * components;
+    
+    iter2 = 0;
+    for( dd = 0; dd < depth; dd++ ) {
+      rowStart = start;
+      for( hh = 0; hh < height; hh++ ) {
+        iter = rowStart;
+        for( ww = 0; ww < elementsPerLine; ww++ ) {
+          
+          switch( type ) {
+            case( GL2.GL_UNSIGNED_BYTE ):
+              if( indexFormat ) {
+                newImage.put( iter2++, (short)(0x000000FF & userImage.get( iter ) ) );
+              } else {
+                newImage.put( iter2++, (short)((0x000000FF & userImage.get( iter ) ) * 257 ) );
+              }
+              break;
+            case( GL2.GL_BYTE ):
+              if( indexFormat ) {
+                newImage.put( iter2++, userImage.get( iter ) );
+              } else {
+                newImage.put( iter2++, (short)(userImage.get( iter ) * 516 ) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+              userImage.position( iter );
+              extract.extract( false, userImage, extractComponents );
+              for( k = 0; k < 3; k++ ) {
+                newImage.put( iter2++, (short)(extractComponents[k] * 65535) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+              userImage.position( iter );
+              extract.extract( false, userImage, extractComponents );
+              for( k = 0; k < 3; k++ ) {
+                newImage.put( iter2++, (short)(extractComponents[k] * 65535) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+              userImage.position( iter );
+              extract.extract( myswapBytes, userImage, extractComponents );
+              for( k = 0; k < 4; k++ ) {
+                newImage.put( iter2++, (short)(extractComponents[k] * 65535) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+              userImage.position( iter );
+              extract.extract( myswapBytes, userImage, extractComponents );
+              for( k = 0; k < 4; k++ ) {
+                newImage.put( iter2++, (short)(extractComponents[k] * 65535) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+              userImage.position( iter );
+              extract.extract( myswapBytes, userImage, extractComponents );
+              for( k = 0; k < 4; k++ ) {
+                newImage.put( iter2++, (short)(extractComponents[k] * 65535) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+              userImage.position( iter );
+              extract.extract( myswapBytes, userImage, extractComponents );
+              for( k = 0; k < 4; k++ ) {
+                newImage.put( iter2++, (short)(extractComponents[k] * 65535) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+              userImage.position( iter );
+              extract.extract( myswapBytes, userImage, extractComponents );
+              for( k = 0; k < 4; k++ ) {
+                newImage.put( iter2++, (short)(extractComponents[k] * 65535) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+              userImage.position( iter );
+              extract.extract( myswapBytes, userImage, extractComponents );
+              for( k = 0; k < 4; k++ ) {
+                newImage.put( iter2++, (short)(extractComponents[k] * 65535) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT ):
+            case( GL2.GL_SHORT ):
+              if( myswapBytes ) {
+                widget.setUB0( userImage.get( iter + 1 ) );
+                widget.setUB1( userImage.get( iter ) );
+              } else {
+                widget.setUB0( userImage.get( iter ) );
+                widget.setUB1( userImage.get( iter + 1 ) );
+              }
+              if( type == GL2.GL_SHORT ) {
+                if( indexFormat ) {
+                  newImage.put( iter2++, widget.getUS0() );
+                } else {
+                  newImage.put( iter2++, (short)(widget.getUS0() * 2) );
+                }
+              } else {
+                newImage.put( iter2++, widget.getUS0() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+              userImage.position( iter );
+              extract.extract( myswapBytes, userImage, extractComponents );
+              for( k = 0; k < 4; k++ ) {
+                newImage.put( iter2++, (short)( extractComponents[k] * 65535 ) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+              userImage.position( iter );
+              extract.extract( myswapBytes, userImage, extractComponents );
+              for( k = 0; k < 4; k++ ) {
+                newImage.put( iter2++, (short)( extractComponents[k] * 65535 ) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+              userImage.position( iter );
+              extract.extract( myswapBytes, userImage, extractComponents );
+              for( k = 0; k < 4; k++ ) {
+                newImage.put( iter2++, (short)( extractComponents[k] * 65535 ) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+              extract.extract( myswapBytes, userImage, extractComponents );
+              for( k = 0; k < 4; k++ ) {
+                newImage.put( iter2++, (short)( extractComponents[k] * 65535 ) );
+              }
+              break;
+            case( GL2.GL_INT ):
+            case( GL2.GL_UNSIGNED_INT ):
+            case( GL2.GL_FLOAT ):
+              if( myswapBytes ) {
+                widget.setUB0( userImage.get( iter + 3 ) );
+                widget.setUB1( userImage.get( iter + 2 ) );
+                widget.setUB2( userImage.get( iter + 1 ) );
+                widget.setUB3( userImage.get( iter     ) );
+              } else {
+                widget.setUB0( userImage.get( iter     ) );
+                widget.setUB1( userImage.get( iter + 1 ) );
+                widget.setUB2( userImage.get( iter + 2 ) );
+                widget.setUB3( userImage.get( iter + 3 ) );
+              }
+              if( type == GL2.GL_FLOAT ) {
+                if( indexFormat ) {
+                  newImage.put( iter2++, (short)widget.getF() );
+                } else {
+                  newImage.put( iter2++, (short)( widget.getF() * 65535.0f ) );
+                }
+              } else if( type == GL2.GL_UNSIGNED_INT ) {
+                if( indexFormat ) {
+                  newImage.put( iter2++, (short)widget.getUI() );
+                } else {
+                  newImage.put( iter2++, (short)(widget.getUI() >> 16) );
+                }
+              } else {
+                if( indexFormat ) {
+                  newImage.put( iter2++, (short)widget.getI() );
+                } else {
+                  newImage.put( iter2++, (short)(widget.getI() >> 15) );
+                }
+              }
+              break;
+            default:
+              assert( false );
+          }
+          iter += elementSize;
+        } // for ww
+        rowStart += rowSize;
+        iter = rowStart; // for assert
+      } // for hh
+      start += imageSize;
+    }// for dd
+    
+    // iterators should be one byte past end
+    if( !Mipmap.isTypePackedPixel( type ) ) {
+      assert( iter2 == width * height * depth * components );
+    } else {
+      assert( iter2 == width * height * depth * Mipmap.elements_per_group( format, 0 ) );
+    }
+    assert( iter == rowSize * height * depth + psm.getUnpackSkipRows() * rowSize + 
+            psm.getUnpackSkipPixels() * groupSize +
+            psm.getUnpackSkipImages() * imageSize );
+  }
+  
+  public static void emptyImage3D( PixelStorageModes psm, int width, int height, int depth,
+          int format, int type, boolean indexFormat, ShortBuffer oldImage, ByteBuffer userImage ) {
+    boolean myswapBytes;
+    int components;
+    int groupsPerLine;
+    int elementSize;
+    int groupSize;
+    int rowSize;
+    int padding;
+    int start, rowStart, iter;
+    int elementsPerLine;
+    int iter2;
+    int ii, jj, dd, k;
+    int rowsPerImage;
+    int imageSize;
+    Type_Widget widget = new Type_Widget();
+    float[] shoveComponents = new float[4];
+    
+    // Create a Extract interface object
+    Extract extract = null;
+    switch( type ) {
+      case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+        extract = new Extract332();
+        break;
+      case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+        extract = new Extract233rev();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+        extract = new Extract565();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+        extract = new Extract565rev();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+        extract = new Extract4444();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+        extract = new Extract4444rev();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+        extract = new Extract5551();
+        break;
+      case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+        extract = new Extract1555rev();
+        break;
+      case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+        extract = new Extract8888();
+        break;
+      case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+        extract = new Extract8888rev();
+        break;
+      case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+        extract = new Extract1010102();
+        break;
+      case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+        extract = new Extract2101010rev();
+        break;
+    }
+    
+    iter = 0;
+    
+    myswapBytes = psm.getPackSwapBytes();
+    components = Mipmap.elements_per_group( format, type );
+    if( psm.getPackRowLength() > 0 ) {
+      groupsPerLine = psm.getPackRowLength();
+    } else {
+      groupsPerLine = width;
+    }
+    
+    elementSize = Mipmap.bytes_per_element( type );
+    groupSize = elementSize * components;
+    if( elementSize == 1 ) {
+      myswapBytes = false;
+    }
+    
+    // 3dstuff begin
+    if( psm.getPackImageHeight() > 0 ) {
+      rowsPerImage = psm.getPackImageHeight();
+    } else {
+      rowsPerImage = height;
+    }
+    
+    // 3dstuff end
+    
+    rowSize = groupsPerLine * groupSize;
+    padding = rowSize % psm.getPackAlignment();
+    if( padding != 0 ) {
+      rowSize += psm.getPackAlignment() - padding;
+    }
+    
+    imageSize = rowsPerImage * rowSize;
+    
+    start = psm.getPackSkipRows() * rowSize +
+            psm.getPackSkipPixels() * groupSize +
+            psm.getPackSkipImages() * imageSize;
+    elementsPerLine = width * components;
+    
+    iter2 = 0;
+    for( dd = 0; dd < depth; dd++ ) {
+      rowStart = start;
+      
+      for( ii = 0; ii < height; ii++ ) {
+        iter = rowStart;
+        
+        for( jj = 0; jj < elementsPerLine; jj++ ) {
+          
+          switch( type ) {
+            case( GL2.GL_UNSIGNED_BYTE ):
+              if( indexFormat ) {
+                userImage.put( iter, (byte)(oldImage.get( iter2++ ) ) );
+              } else {
+                userImage.put( iter, (byte)(oldImage.get( iter2++ ) >> 8 ) );
+              }
+              break;
+            case( GL2.GL_BYTE ):
+              if( indexFormat ) {
+                userImage.put( iter, (byte)(oldImage.get(iter2++) ) );
+              } else {
+                userImage.put( iter, (byte)(oldImage.get(iter2++) >> 9) );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+              for( k = 0; k < 3; k++ ) {
+                shoveComponents[k] = oldImage.get( iter2++ ) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, userImage );
+              break;
+            case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+              for( k = 0; k < 3; k++ ) {
+                shoveComponents[k] = oldImage.get( iter2++ ) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, userImage );
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+              for( k = 0; k < 4; k++ ) {
+                shoveComponents[k] = oldImage.get( iter2++ ) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, widget.getBuffer() );
+              if( myswapBytes ) {
+                userImage.putShort( iter, widget.getUB1() );
+                userImage.putShort( iter + 1, widget.getUB0() );
+              } else {
+                userImage.putShort( iter, widget.getUS0() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+              for( k = 0; k < 4; k++ ) {
+                shoveComponents[k] = oldImage.get( iter2++ ) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, widget.getBuffer() );
+              if( myswapBytes ) {
+                userImage.put( iter, widget.getUB1() );
+                userImage.put( iter + 1, widget.getUB0() );
+              } else {
+                userImage.putShort( iter, widget.getUS0() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+              for( k = 0; k < 4; k++ ) {
+                shoveComponents[k] = oldImage.get( iter2++ ) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, widget.getBuffer() );
+              if( myswapBytes ) {
+                userImage.put( iter, widget.getUB1() );
+                userImage.put( iter + 1, widget.getUB0() );
+              } else {
+                userImage.putShort( iter, widget.getUS0() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+              for( k = 0; k < 4; k++ ) {
+                shoveComponents[k] = oldImage.get( iter2++ ) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, widget.getBuffer() );
+              if( myswapBytes ) {
+                userImage.put( iter, widget.getUB1() );
+                userImage.put( iter + 1, widget.getUB0() );
+              } else {
+                userImage.putShort( iter, widget.getUS0() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+              for( k = 0; k < 4; k++ ) {
+                shoveComponents[k] = oldImage.get( iter2++ ) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, widget.getBuffer() );
+              if( myswapBytes ) {
+                userImage.put( iter, widget.getUB1() );
+                userImage.put( iter + 1, widget.getUB0() );
+              } else {
+                userImage.putShort( iter, widget.getUS0() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+              for( k = 0; k < 4; k++ ) {
+                shoveComponents[k] = oldImage.get( iter2++ ) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, widget.getBuffer() );
+              if( myswapBytes ) {
+                userImage.put( iter, widget.getUB1() );
+                userImage.put( iter + 1, widget.getUB0() );
+              } else {
+                userImage.putShort( iter, widget.getUS0() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_SHORT ):
+            case( GL2.GL_SHORT ):
+              if( type == GL2.GL_SHORT ) {
+                if( indexFormat ) {
+                  widget.setS0( (short)oldImage.get( iter2++ ) );
+                } else {
+                  widget.setS0( (short)(oldImage.get( iter2++ ) >> 1) );
+                }
+              } else {
+                widget.setUS0( (short)oldImage.get( iter2++ ) );
+              }
+              if( myswapBytes ) {
+                userImage.put( iter, widget.getUB1() );
+                userImage.put( iter + 1, widget.getUB0() );
+              } else {
+                userImage.put( iter, widget.getUB0() );
+                userImage.put( iter + 1, widget.getUB1() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+              for( k = 0; k < 4; k++ ) {
+                shoveComponents[k] = oldImage.get( iter2++ ) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, widget.getBuffer() );
+              if( myswapBytes ) {
+                userImage.put( iter + 3, widget.getUB0() );
+                userImage.put( iter + 2, widget.getUB1() );
+                userImage.put( iter + 1, widget.getUB2() );
+                userImage.put( iter    , widget.getUB3() );
+              } else {
+                userImage.putInt( iter, widget.getUI() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+              for( k = 0; k < 4; k++ ) {
+                shoveComponents[k] = oldImage.get( iter2++ ) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, widget.getBuffer() );
+              if( myswapBytes ) {
+                userImage.put( iter + 3, widget.getUB0() );
+                userImage.put( iter + 2, widget.getUB1() );
+                userImage.put( iter + 1, widget.getUB2() );
+                userImage.put( iter    , widget.getUB3() );
+              } else {
+                userImage.putInt( iter, widget.getUI() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+              for( k = 0; k < 4; k++ ) {
+                shoveComponents[k] = oldImage.get( iter2++ ) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, widget.getBuffer() );
+              if( myswapBytes ) {
+                userImage.put( iter + 3, widget.getUB0() );
+                userImage.put( iter + 2, widget.getUB1() );
+                userImage.put( iter + 1, widget.getUB2() );
+                userImage.put( iter    ,widget.getUB3() );
+              } else {
+                userImage.putInt( iter, widget.getUI() );
+              }
+              break;
+            case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+              for( k = 0; k < 4; k++ ) {
+                shoveComponents[k] = oldImage.get( iter2++ ) / 65535.0f;
+              }
+              extract.shove( shoveComponents, 0, widget.getBuffer() );
+              if( myswapBytes ) {
+                userImage.put( iter + 3, widget.getUB0() );
+                userImage.put( iter + 2, widget.getUB2() );
+                userImage.put( iter + 1, widget.getUB1() );
+                userImage.put( iter    , widget.getUB0() );
+              } else {
+                userImage.putInt( iter, widget.getUI() );
+              }
+              break;
+            case( GL2.GL_INT ):
+            case( GL2.GL_UNSIGNED_INT ):
+            case( GL2.GL_FLOAT ):
+              if( type == GL2.GL_FLOAT ) {
+                if( indexFormat ) {
+                  widget.setF( oldImage.get( iter2++ ) );
+                } else {
+                  widget.setF( oldImage.get( iter2++ ) / 65535.0f );
+                }
+              } else if( type == GL2.GL_UNSIGNED_INT ) {
+                if( indexFormat ) {
+                  widget.setUI( oldImage.get( iter2++ ) );
+                } else {
+                  widget.setUI( oldImage.get( iter2++ ) * 65537 );
+                }
+              } else {
+                if( indexFormat ) {
+                  widget.setI( oldImage.get( iter2++ ) );
+                } else {
+                  widget.setI( ( oldImage.get( iter2++ ) * 65535 ) / 2 );
+                }
+              }
+              if( myswapBytes ) {
+                userImage.put( iter + 3, widget.getUB0() );
+                userImage.put( iter + 2, widget.getUB1() );
+                userImage.put( iter + 1, widget.getUB2() );
+                userImage.put( iter    , widget.getUB3() );
+              } else {
+                userImage.put( iter    , widget.getUB0() );
+                userImage.put( iter + 1, widget.getUB1() );
+                userImage.put( iter + 2, widget.getUB2() );
+                userImage.put( iter + 3, widget.getUB3() );
+              }
+              break;
+            default:
+              assert( false );
+          }
+          
+          iter += elementSize;
+        } // for jj
+        rowStart += rowSize;
+      } // for ii
+      start += imageSize;
+    } // for dd
+    
+    if( !Mipmap.isTypePackedPixel( type ) ) {
+      assert( iter2 == width * height * depth * components );
+    } else {
+      assert( iter2 == width * height * depth * Mipmap.elements_per_group( format, 0 ) );
+    }
+    assert( iter == rowSize * height * depth + 
+                    psm.getUnpackSkipRows() * rowSize +
+                    psm.getUnpackSkipPixels() * groupSize +
+                    psm.getUnpackSkipImages() * imageSize );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Mipmap.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Mipmap.java
new file mode 100644
index 000000000..b048bf1f5
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Mipmap.java
@@ -0,0 +1,867 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import javax.media.opengl.GL;
+import javax.media.opengl.GL2;
+import javax.media.opengl.glu.GLU;
+import javax.media.opengl.util.BufferUtil;
+import javax.media.opengl.GLException;
+import java.nio.*;
+
+/**
+ *
+ * @author  Administrator
+ */
+public class Mipmap {
+  
+  /** Creates a new instance of Mipmap */
+  public Mipmap() {
+  }
+  
+  public static int computeLog( int value ) {
+    int i = 0;
+    // Error
+    if( value == 0 ) {
+      return( -1 );
+    }
+    for( ;; ) {
+      if( (value & 1) >= 1 ) {
+        if( value != 1 ) {
+          return( -1 );
+        }
+        return( i );
+      }
+      value = value >> 1;
+      i++;
+    }
+  }
+  
+  /* Compute the nearest power of 2 number.  This algorithm is a little strange
+   * but it works quite well.
+   */
+  public static int nearestPower( int value ) {
+    int i = 1;
+    // Error!
+    if( value == 0 ) {
+      return( -1 );
+    }
+    for( ;; ) {
+      if( value == 1 ) {
+        return( i );
+      } else if( value == 3 ) {
+        return( i * 4 );
+      }
+      value = value >> 1;
+      i *= 2;
+    }
+  }
+  
+  public static short GLU_SWAP_2_BYTES( short s ) {
+    byte b = 0;
+    b = (byte)( s >>> 8 );
+    s = (short)( s << 8 );
+    s = (short)( s | (0x00FF & b) );
+    return( s );
+  }
+  
+  public static int GLU_SWAP_4_BYTES( int i ) {
+    int t = i << 24;
+    t |= 0x00FF0000 & ( i << 8 );
+    t |= 0x0000FF00 & ( i >>> 8 );
+    t |= 0x000000FF & ( i >>> 24 );
+    return( t );
+  }
+  
+  public static float GLU_SWAP_4_BYTES( float f ) {
+    int i = Float.floatToRawIntBits( f );
+    float temp = Float.intBitsToFloat( i );
+    return( temp );
+  }
+  
+  public static int checkMipmapArgs( int internalFormat, int format, int type ) {
+    if( !legalFormat( format ) || !legalType( type ) ) {
+      return( GLU.GLU_INVALID_ENUM );
+    }
+    if( format == GL2.GL_STENCIL_INDEX ) {
+      return( GLU.GLU_INVALID_ENUM );
+    }
+    if( !isLegalFormatForPackedPixelType( format, type ) ) {
+      return( GLU.GLU_INVALID_OPERATION );
+    }
+    return( 0 );
+  }
+  
+  public static boolean legalFormat( int format ) {
+    switch( format ) {
+      case( GL2.GL_COLOR_INDEX ):
+      case( GL2.GL_STENCIL_INDEX ):
+      case( GL2.GL_DEPTH_COMPONENT ):
+      case( GL2.GL_RED ):
+      case( GL2.GL_GREEN ):
+      case( GL2.GL_BLUE ):
+      case( GL2.GL_ALPHA ):
+      case( GL2.GL_RGB ):
+      case( GL2.GL_RGBA ):
+      case( GL2.GL_LUMINANCE ):
+      case( GL2.GL_LUMINANCE_ALPHA ):
+      case( GL2.GL_BGR ):
+      case( GL2.GL_BGRA ):
+        return( true );
+      default:
+        return( false );
+    }
+  }
+  
+  public static boolean legalType( int type ) {
+    switch( type ) {
+      case( GL2.GL_BITMAP ):
+      case( GL2.GL_BYTE ):
+      case( GL2.GL_UNSIGNED_BYTE ):
+      case( GL2.GL_SHORT ):
+      case( GL2.GL_UNSIGNED_SHORT ):
+      case( GL2.GL_INT ):
+      case( GL2.GL_UNSIGNED_INT ):
+      case( GL2.GL_FLOAT ):
+      case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+      case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+      case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+      case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+      case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+      case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+      case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+      case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+      case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+      case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+      case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+      case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+        return( true );
+      default:
+        return( false );
+    }
+  }
+  
+  public static boolean isTypePackedPixel( int type ) {
+    assert( legalType( type ) );
+    
+    if( type == GL2.GL_UNSIGNED_BYTE_3_3_2 ||
+        type == GL2.GL_UNSIGNED_BYTE_2_3_3_REV ||
+        type == GL2.GL_UNSIGNED_SHORT_5_6_5 ||
+        type == GL2.GL_UNSIGNED_SHORT_5_6_5_REV ||
+        type == GL2.GL_UNSIGNED_SHORT_4_4_4_4 ||
+        type == GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ||
+        type == GL2.GL_UNSIGNED_SHORT_5_5_5_1 ||
+        type == GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ||
+        type == GL2.GL_UNSIGNED_INT_8_8_8_8 ||
+        type == GL2.GL_UNSIGNED_INT_8_8_8_8_REV ||
+        type == GL2.GL_UNSIGNED_INT_10_10_10_2 ||
+        type == GL2.GL_UNSIGNED_INT_2_10_10_10_REV ) {
+          return( true );
+    }
+    return( false );
+  }
+  
+  public static boolean isLegalFormatForPackedPixelType( int format, int type ) {
+    // if not a packed pixel type then return true
+    if( isTypePackedPixel( type ) ) {
+      return( true );
+    }
+    
+    // 3_3_2/2_3_3_REV & 5_6_5/5_6_5_REV are only compatible with RGB
+    if( (type == GL2.GL_UNSIGNED_BYTE_3_3_2 || type == GL2.GL_UNSIGNED_BYTE_2_3_3_REV ||
+        type == GL2.GL_UNSIGNED_SHORT_5_6_5 || type == GL2.GL_UNSIGNED_SHORT_5_6_5_REV )
+        & format != GL2.GL_RGB ) {
+          return( false );
+    }
+    
+    // 4_4_4_4/4_4_4_4_REV & 5_5_5_1/1_5_5_5_REV & 8_8_8_8/8_8_8_8_REV &
+    // 10_10_10_2/2_10_10_10_REV are only campatible with RGBA, BGRA & ARGB_EXT
+    if( ( type == GL2.GL_UNSIGNED_SHORT_4_4_4_4 ||
+          type == GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ||
+          type == GL2.GL_UNSIGNED_SHORT_5_5_5_1 ||
+          type == GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ||
+          type == GL2.GL_UNSIGNED_INT_8_8_8_8 ||
+          type == GL2.GL_UNSIGNED_INT_8_8_8_8_REV ||
+          type == GL2.GL_UNSIGNED_INT_10_10_10_2 ||
+          type == GL2.GL_UNSIGNED_INT_2_10_10_10_REV ) &&
+          (format != GL2.GL_RGBA && format != GL2.GL_BGRA) ) {
+            return( false );
+    }
+    return( true );
+  }
+  
+  public static boolean isLegalLevels( int userLevel, int baseLevel, int maxLevel,
+                                            int totalLevels ) {
+    if( (baseLevel < 0) || (baseLevel < userLevel) || (maxLevel < baseLevel) ||
+                                                  (totalLevels < maxLevel) ) {
+      return( false );
+    }
+    return( true );
+  }
+  
+  /* Given user requested textures size, determine if it fits. If it doesn't then
+   * halve both sides and make the determination again until it does fit ( for
+   * IR only ).
+   * Note that proxy textures are not implemented in RE* even though they
+   * advertise the texture extension.
+   * Note that proxy textures are implemented but not according to spec in IMPACT*
+   */
+  public static void closestFit( GL gl, int target, int width, int height, int internalFormat,
+                                int format, int type, int[] newWidth, int[] newHeight ) {
+    // Use proxy textures if OpenGL version >= 1.1
+    if( Double.parseDouble( gl.glGetString( GL.GL_VERSION ).trim().substring( 0, 3 ) ) >= 1.1 ) {
+      int widthPowerOf2 = nearestPower( width );
+      int heightPowerOf2 = nearestPower( height );
+      int[] proxyWidth = new int[1];
+      boolean noProxyTextures = false;
+      
+      // Some drivers (in particular, ATI's) seem to set a GL error
+      // when proxy textures are used even though this is in violation
+      // of the spec. Guard against this and interactions with the
+      // DebugGL by watching for GLException.
+      try {
+        do {
+          // compute level 1 width & height, clamping each at 1
+          int widthAtLevelOne = ( ( width > 1 ) ? (widthPowerOf2 >> 1) : widthPowerOf2 );
+          int heightAtLevelOne = ( ( height > 1 ) ? (heightPowerOf2 >> 1) : heightPowerOf2 );
+          int proxyTarget;
+        
+          assert( widthAtLevelOne > 0 );
+          assert( heightAtLevelOne > 0 );
+        
+          // does width x height at level 1 & all their mipmaps fit?
+          if( target == GL2.GL_TEXTURE_2D || target == GL2.GL_PROXY_TEXTURE_2D ) {
+            proxyTarget = GL2.GL_PROXY_TEXTURE_2D;
+            gl.glTexImage2D( proxyTarget, 1, internalFormat, widthAtLevelOne,
+                             heightAtLevelOne, 0, format, type, null );
+          } else if( (target == GL2.GL_TEXTURE_CUBE_MAP_POSITIVE_X) || 
+                     (target == GL2.GL_TEXTURE_CUBE_MAP_NEGATIVE_X) || 
+                     (target == GL2.GL_TEXTURE_CUBE_MAP_POSITIVE_Y) || 
+                     (target == GL2.GL_TEXTURE_CUBE_MAP_NEGATIVE_Y) || 
+                     (target == GL2.GL_TEXTURE_CUBE_MAP_POSITIVE_Z) || 
+                     (target == GL2.GL_TEXTURE_CUBE_MAP_NEGATIVE_Z) ) {
+            proxyTarget = GL2.GL_PROXY_TEXTURE_CUBE_MAP;
+            gl.glTexImage2D( proxyTarget, 1, internalFormat, widthAtLevelOne,
+                             heightAtLevelOne, 0, format, type, null );
+          } else {
+            assert( target == GL2.GL_TEXTURE_1D || target == GL2.GL_PROXY_TEXTURE_1D );
+            proxyTarget = GL2.GL_PROXY_TEXTURE_1D;
+            gl.getGL2().glTexImage1D( proxyTarget, 1, internalFormat, widthAtLevelOne, 
+                             0, format, type, null );
+          }
+          if(gl.isGL2()) {
+            gl.getGL2().glGetTexLevelParameteriv( proxyTarget, 1, GL2.GL_TEXTURE_WIDTH, proxyWidth, 0 );
+          } else {
+            proxyWidth[0] = 0;
+          }
+          // does it fit?
+          if( proxyWidth[0] == 0 ) { // nope, so try again with theses sizes
+            if( widthPowerOf2 == 1 && heightPowerOf2 == 1 ) {
+              /* A 1x1 texture couldn't fit for some reason so break out.  This
+               * should never happen.  But things happen.  The disadvantage with
+               * this if-statement is that we will never be aware of when this
+               * happens since it will silently branch out.
+               */
+              noProxyTextures = true;
+              break;
+            }
+            widthPowerOf2 = widthAtLevelOne;
+            heightPowerOf2 = heightAtLevelOne;
+          }
+          // else it does fit
+        } while( proxyWidth[0] == 0 );
+      } catch (GLException e) {
+        noProxyTextures = true;
+      }
+      // loop must terminate
+      // return the width & height at level 0 that fits
+      if( !noProxyTextures ) {
+        newWidth[0] = widthPowerOf2;
+        newHeight[0] = heightPowerOf2;
+        return;
+      }
+    }
+    int[] maxsize = new int[1];
+    gl.glGetIntegerv( GL2.GL_MAX_TEXTURE_SIZE, maxsize , 0);
+    // clamp user's texture sizes to maximum sizes, if necessary
+    newWidth[0] = nearestPower( width );
+    if( newWidth[0] > maxsize[0] ) {
+      newWidth[0] = maxsize[0];
+    }
+    newHeight[0] = nearestPower( height );
+    if( newHeight[0] > maxsize[0] ) {
+      newHeight[0] = maxsize[0];
+    }
+  }
+  
+  public static void closestFit3D( GL gl, int target, int width, int height, int depth, 
+          int internalFormat, int format, int type, int[] newWidth, int[] newHeight,
+          int[] newDepth ) {
+    int widthPowerOf2 = nearestPower( width );
+    int heightPowerOf2 = nearestPower( height );
+    int depthPowerOf2 = nearestPower( depth );
+    int[] proxyWidth = new int[1];
+    
+    do {
+      // compute level 1 width & height & depth, clamping each at 1
+      int widthAtLevelOne = (widthPowerOf2 > 1) ? widthPowerOf2 >> 1 : widthPowerOf2;
+      int heightAtLevelOne = (heightPowerOf2 > 1) ? heightPowerOf2 >> 1 : heightPowerOf2;
+      int depthAtLevelOne = (depthPowerOf2 > 1) ? depthPowerOf2 >> 1 : depthPowerOf2;
+      int proxyTarget = 0;
+      assert( widthAtLevelOne > 0 );
+      assert( heightAtLevelOne > 0 );
+      assert( depthAtLevelOne > 0 );
+      
+      // does width x height x depth at level 1 & all their mipmaps fit?
+      if( target == GL2.GL_TEXTURE_3D || target == GL2.GL_PROXY_TEXTURE_3D ) {
+        proxyTarget = GL2.GL_PROXY_TEXTURE_3D;
+        gl.getGL2().glTexImage3D( proxyTarget, 1, internalFormat, widthAtLevelOne,
+                heightAtLevelOne, depthAtLevelOne, 0, format, type, null );
+      }
+      if(gl.isGL2()) {
+        gl.getGL2().glGetTexLevelParameteriv( proxyTarget, 1, GL2.GL_TEXTURE_WIDTH, proxyWidth, 0 );
+      } else {
+        proxyWidth[0] = 0;
+      }
+      // does it fit
+      if( proxyWidth[0] == 0 ) {
+        if( widthPowerOf2 == 1 && heightPowerOf2 == 1 && depthPowerOf2 == 1 ) {
+          newWidth[0] = newHeight[0] = newDepth[0] = 1;
+          return;
+        }
+        widthPowerOf2 = widthAtLevelOne;
+        heightPowerOf2 = heightAtLevelOne;
+        depthPowerOf2 = depthAtLevelOne;
+      }
+    } while( proxyWidth[0] == 0 );
+    // loop must terminate
+    
+    // return the width & height at level 0 that fits
+    newWidth[0] = widthPowerOf2;
+    newHeight[0] = heightPowerOf2;
+    newDepth[0] = depthPowerOf2;
+  }
+  
+  public static int elements_per_group( int format, int type ) {
+    // Return the number of elements per grtoup of a specified gromat
+    
+    // If the type is packedpixels then answer is 1
+    if( type == GL2.GL_UNSIGNED_BYTE_3_3_2 ||
+        type == GL2.GL_UNSIGNED_BYTE_2_3_3_REV ||
+        type == GL2.GL_UNSIGNED_SHORT_5_6_5 ||
+        type == GL2.GL_UNSIGNED_SHORT_5_6_5_REV ||
+        type == GL2.GL_UNSIGNED_SHORT_4_4_4_4 ||
+        type == GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ||
+        type == GL2.GL_UNSIGNED_SHORT_5_5_5_1 ||
+        type == GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ||
+        type == GL2.GL_UNSIGNED_INT_8_8_8_8 ||
+        type == GL2.GL_UNSIGNED_INT_8_8_8_8_REV ||
+        type == GL2.GL_UNSIGNED_INT_10_10_10_2 ||
+        type == GL2.GL_UNSIGNED_INT_2_10_10_10_REV ) {
+          return( 1 );
+    }
+    
+    // Types are not packed pixels so get elements per group
+    switch( format ) {
+      case( GL2.GL_RGB ):
+      case( GL2.GL_BGR ):
+        return( 3 );
+      case( GL2.GL_LUMINANCE_ALPHA ):
+        return( 2 );
+      case( GL2.GL_RGBA ):
+      case( GL2.GL_BGRA ):
+        return( 4 );
+      default:
+        return( 1 );
+    }
+  }
+  
+  public static int bytes_per_element( int type ) {
+    // return the number of bytes per element, based on the element type
+    
+    switch( type ) {
+      case( GL2.GL_BITMAP ):
+      case( GL2.GL_BYTE ):
+      case( GL2.GL_UNSIGNED_BYTE ):
+      case( GL2.GL_UNSIGNED_BYTE_3_3_2 ):
+      case( GL2.GL_UNSIGNED_BYTE_2_3_3_REV ):
+        return( 1 );
+      case( GL2.GL_SHORT ):
+      case( GL2.GL_UNSIGNED_SHORT ):
+      case( GL2.GL_UNSIGNED_SHORT_5_6_5 ):
+      case( GL2.GL_UNSIGNED_SHORT_5_6_5_REV ):
+      case( GL2.GL_UNSIGNED_SHORT_4_4_4_4 ):
+      case( GL2.GL_UNSIGNED_SHORT_4_4_4_4_REV ):
+      case( GL2.GL_UNSIGNED_SHORT_5_5_5_1 ):
+      case( GL2.GL_UNSIGNED_SHORT_1_5_5_5_REV ):
+        return( 2 );
+      case( GL2.GL_INT ):
+      case( GL2.GL_UNSIGNED_INT ):
+      case( GL2.GL_UNSIGNED_INT_8_8_8_8 ):
+      case( GL2.GL_UNSIGNED_INT_8_8_8_8_REV ):
+      case( GL2.GL_UNSIGNED_INT_10_10_10_2 ):
+      case( GL2.GL_UNSIGNED_INT_2_10_10_10_REV ):
+      case( GL2.GL_FLOAT ):
+        return( 4 );
+      default:
+        return( 4 );
+    }
+  }
+  
+  public static boolean is_index( int format ) {
+    return( format == GL2.GL_COLOR_INDEX || format == GL2.GL_STENCIL_INDEX );
+  }
+  
+  /* Compute memory required for internal packed array of data of given type and format. */
+  
+  public static int image_size( int width, int height, int format, int type ) {
+    int bytes_per_row;
+    int components;
+    
+    assert( width > 0 );
+    assert( height > 0 );
+    components = elements_per_group( format, type );
+    if( type == GL2.GL_BITMAP ) {
+      bytes_per_row = (width + 7) / 8;
+    } else {
+      bytes_per_row = bytes_per_element( type ) * width;
+    }
+    return( bytes_per_row * height * components );
+  }
+  
+  public static int imageSize3D( int width, int height, int depth, int format, int type ) {
+    int components = elements_per_group( format, type );
+    int bytes_per_row = bytes_per_element( type ) * width;
+    
+    assert( width > 0 && height > 0 && depth > 0 );
+    assert( type != GL2.GL_BITMAP );
+    
+    return( bytes_per_row * height * depth * components );
+  }
+  
+  public static void retrieveStoreModes( GL gl, PixelStorageModes psm ) {
+    int[] a = new int[1];
+    gl.glGetIntegerv( GL2.GL_UNPACK_ALIGNMENT, a, 0);
+    psm.setUnpackAlignment( a[0] );
+    gl.glGetIntegerv( GL2.GL_UNPACK_ROW_LENGTH, a, 0);
+    psm.setUnpackRowLength( a[0] );
+    gl.glGetIntegerv( GL2.GL_UNPACK_SKIP_ROWS, a, 0);
+    psm.setUnpackSkipRows( a[0] );
+    gl.glGetIntegerv( GL2.GL_UNPACK_SKIP_PIXELS, a, 0);
+    psm.setUnpackSkipPixels( a[0] );
+    gl.glGetIntegerv( GL2.GL_UNPACK_LSB_FIRST, a, 0);
+    psm.setUnpackLsbFirst( ( a[0] == 1 ) );
+    gl.glGetIntegerv( GL2.GL_UNPACK_SWAP_BYTES, a, 0);
+    psm.setUnpackSwapBytes( ( a[0] == 1 ) );
+    
+    gl.glGetIntegerv( GL2.GL_PACK_ALIGNMENT, a, 0);
+    psm.setPackAlignment( a[0] );
+    gl.glGetIntegerv( GL2.GL_PACK_ROW_LENGTH, a, 0);
+    psm.setPackRowLength( a[0] );
+    gl.glGetIntegerv( GL2.GL_PACK_SKIP_ROWS, a, 0);
+    psm.setPackSkipRows( a[0] );
+    gl.glGetIntegerv( GL2.GL_PACK_SKIP_PIXELS, a, 0);
+    psm.setPackSkipPixels( a[0] );
+    gl.glGetIntegerv( GL2.GL_PACK_LSB_FIRST, a, 0);
+    psm.setPackLsbFirst( ( a[0] == 1 ) );
+    gl.glGetIntegerv( GL2.GL_PACK_SWAP_BYTES, a, 0);
+    psm.setPackSwapBytes( ( a[0] == 1 ) );
+  }
+  
+  public static void retrieveStoreModes3D( GL gl, PixelStorageModes psm ) {
+    int[] a = new int[1];
+    gl.glGetIntegerv( GL2.GL_UNPACK_ALIGNMENT, a, 0);
+    psm.setUnpackAlignment( a[0] );
+    gl.glGetIntegerv( GL2.GL_UNPACK_ROW_LENGTH, a, 0);
+    psm.setUnpackRowLength( a[0] );
+    gl.glGetIntegerv( GL2.GL_UNPACK_SKIP_ROWS, a, 0);
+    psm.setUnpackSkipRows( a[0] );
+    gl.glGetIntegerv( GL2.GL_UNPACK_SKIP_PIXELS, a, 0);
+    psm.setUnpackSkipPixels( a[0] );
+    gl.glGetIntegerv( GL2.GL_UNPACK_LSB_FIRST, a, 0);
+    psm.setUnpackLsbFirst( ( a[0] == 1 ) );
+    gl.glGetIntegerv( GL2.GL_UNPACK_SWAP_BYTES, a, 0);
+    psm.setUnpackSwapBytes( ( a[0] == 1 ) );
+    gl.glGetIntegerv( GL2.GL_UNPACK_SKIP_IMAGES, a, 0);
+    psm.setUnpackSkipImages( a[0] );
+    gl.glGetIntegerv( GL2.GL_UNPACK_IMAGE_HEIGHT, a, 0);
+    psm.setUnpackImageHeight( a[0] );
+    
+    gl.glGetIntegerv( GL2.GL_PACK_ALIGNMENT, a, 0);
+    psm.setPackAlignment( a[0] );
+    gl.glGetIntegerv( GL2.GL_PACK_ROW_LENGTH, a, 0);
+    psm.setPackRowLength( a[0] );
+    gl.glGetIntegerv( GL2.GL_PACK_SKIP_ROWS, a, 0);
+    psm.setPackSkipRows( a[0] );
+    gl.glGetIntegerv( GL2.GL_PACK_SKIP_PIXELS, a, 0 );
+    psm.setPackSkipPixels( a[0] );
+    gl.glGetIntegerv( GL2.GL_PACK_LSB_FIRST, a, 0 );
+    psm.setPackLsbFirst( ( a[0] == 1 ) );
+    gl.glGetIntegerv( GL2.GL_PACK_SWAP_BYTES, a, 0 );
+    psm.setPackSwapBytes( ( a[0] == 1 ) );
+    gl.glGetIntegerv( GL2.GL_PACK_SKIP_IMAGES, a, 0 );
+    psm.setPackSkipImages( a[0] );
+    gl.glGetIntegerv( GL2.GL_PACK_IMAGE_HEIGHT, a, 0 );
+    psm.setPackImageHeight( a[0] );
+  }
+  
+  public static int gluScaleImage( GL gl, int format, int widthin, int heightin, 
+          int typein, ByteBuffer datain, int widthout, int heightout, 
+          int typeout, ByteBuffer dataout ) {
+    int datainPos = datain.position();
+    int dataoutPos = dataout.position();
+    try {
+
+      int components;
+      ByteBuffer beforeimage;
+      ByteBuffer afterimage;
+      PixelStorageModes psm = new PixelStorageModes();
+    
+      if( (widthin == 0)  || (heightin == 0) || (widthout == 0) || (heightout == 0) ) {
+        return( 0 );
+      }
+      if( (widthin < 0) || (heightin < 0) || (widthout < 0) || (heightout < 0) ) {
+        return( GLU.GLU_INVALID_VALUE );
+      }
+      if( !legalFormat( format ) || !legalType( typein ) || !legalType( typeout ) ) {
+        return( GLU.GLU_INVALID_ENUM );
+      }
+      if( !isLegalFormatForPackedPixelType( format, typein ) ) {
+        return( GLU.GLU_INVALID_OPERATION );
+      }
+      if( !isLegalFormatForPackedPixelType( format, typeout ) ) {
+        return( GLU.GLU_INVALID_OPERATION );
+      }
+      beforeimage = BufferUtil.nativeOrder(ByteBuffer.allocateDirect( image_size( widthin, heightin, format, GL2.GL_UNSIGNED_SHORT ) ));
+      afterimage = BufferUtil.nativeOrder(ByteBuffer.allocateDirect( image_size( widthout, heightout, format, GL2.GL_UNSIGNED_SHORT ) ));
+      if( beforeimage == null || afterimage == null ) {
+        return( GLU.GLU_OUT_OF_MEMORY );
+      }
+    
+      retrieveStoreModes( gl, psm );
+      Image.fill_image( psm, widthin, heightin, format, typein, is_index( format ), datain, beforeimage.asShortBuffer() );
+      components = elements_per_group( format, 0 );
+      ScaleInternal.scale_internal( components, widthin, heightin, beforeimage.asShortBuffer(), widthout, heightout, afterimage.asShortBuffer() );
+      Image.empty_image( psm, widthout, heightout, format, typeout, is_index( format ), afterimage.asShortBuffer(), dataout );
+    
+      return( 0 );
+    } finally {
+      datain.position(datainPos);
+      dataout.position(dataoutPos);
+    }
+  }
+  
+  public static int gluBuild1DMipmapLevels( GL gl, int target, int internalFormat,
+                          int width, int format, int type, int userLevel, int baseLevel,
+                          int maxLevel, ByteBuffer data ) {
+    int dataPos = data.position();
+    try {
+
+      int levels;
+    
+      int rc = checkMipmapArgs( internalFormat, format, type );
+      if( rc != 0 ) {
+        return( rc );
+      }
+    
+      if( width < 1 ) {
+        return( GLU.GLU_INVALID_VALUE );
+      }
+    
+      levels = computeLog( width );
+    
+      levels += userLevel;
+      if( !isLegalLevels( userLevel, baseLevel, maxLevel, levels ) ) {
+        return( GLU.GLU_INVALID_VALUE );
+      }
+    
+      return( BuildMipmap.gluBuild1DMipmapLevelsCore( gl, target, internalFormat, width,
+              width, format, type, userLevel, baseLevel, maxLevel, data ) );
+    } finally {
+      data.position(dataPos);
+    }
+  }
+  
+  public static int gluBuild1DMipmaps( GL gl, int target, int internalFormat, int width,
+              int format, int type, ByteBuffer data ) {
+    int dataPos = data.position();
+
+    try {
+      int[] widthPowerOf2 = new int[1];
+      int levels;
+      int[] dummy = new int[1];
+    
+      int rc = checkMipmapArgs( internalFormat, format, type );
+      if( rc != 0 ) {
+        return( rc );
+      }
+    
+      if( width < 1 ) {
+        return( GLU.GLU_INVALID_VALUE );
+      }
+    
+      closestFit( gl, target, width, 1, internalFormat, format, type, widthPowerOf2, dummy );
+      levels = computeLog( widthPowerOf2[0] );
+    
+      return( BuildMipmap.gluBuild1DMipmapLevelsCore( gl, target, internalFormat, 
+                    width, widthPowerOf2[0], format, type, 0, 0, levels, data ) );
+    } finally {
+      data.position(dataPos);
+    }
+  }
+
+ 
+  public static int gluBuild2DMipmapLevels( GL gl, int target, int internalFormat,
+          int width, int height, int format, int type, int userLevel,
+          int baseLevel, int maxLevel, Object data ) {
+    int dataPos = 0;
+
+    int level, levels;
+    
+    int rc = checkMipmapArgs( internalFormat, format, type );
+    if( rc != 0 ) {
+      return( rc );
+    }
+    
+    if( width < 1 || height < 1 ) {
+      return( GLU.GLU_INVALID_VALUE );
+    }
+    
+    levels = computeLog( width );
+    level = computeLog( height );
+    if( level > levels ) {
+      levels = level;
+    }
+    
+    levels += userLevel;
+    if( !isLegalLevels( userLevel, baseLevel, maxLevel, levels ) ) {
+      return( GLU.GLU_INVALID_VALUE );
+    }
+    
+    //PointerWrapper pointer = PointerWrapperFactory.getPointerWrapper( data );
+    ByteBuffer buffer = null;
+    if( data instanceof ByteBuffer ) {
+        buffer = (ByteBuffer)data;
+        dataPos = buffer.position();
+    } else if( data instanceof byte[] ) {
+      byte[] array = (byte[])data;
+      buffer = ByteBuffer.allocateDirect(array.length);
+      buffer.put(array);
+    } else if( data instanceof short[] ) {
+        short[] array = (short[])data;
+        buffer = ByteBuffer.allocateDirect( array.length * 2 );
+        ShortBuffer sb = buffer.asShortBuffer();
+        sb.put( array );
+    } else if( data instanceof int[] ) {
+        int[] array = (int[])data;
+        buffer = ByteBuffer.allocateDirect( array.length * 4 );
+        IntBuffer ib = buffer.asIntBuffer();
+        ib.put( array );
+    } else if( data instanceof float[] ) {
+        float[] array = (float[])data;
+        buffer = ByteBuffer.allocateDirect( array.length * 4 );
+        FloatBuffer fb = buffer.asFloatBuffer();
+        fb.put( array );
+    }
+    
+    try {
+      return( BuildMipmap.gluBuild2DMipmapLevelsCore( gl, target, internalFormat,
+              width, height, width, height, format, type, userLevel, baseLevel,
+              maxLevel, buffer ) );
+    } finally {
+      buffer.position(dataPos);
+    }
+  }
+
+ 
+  public static int gluBuild2DMipmaps( GL gl, int target, int internalFormat,
+          int width, int height, int format, int type, Object data ) {
+    int dataPos = 0;
+
+    int[] widthPowerOf2 = new int[1];
+    int[] heightPowerOf2 = new int[1];
+    int level, levels;
+    
+    int rc = checkMipmapArgs( internalFormat, format, type );
+    if( rc != 0 ) {
+      return( rc );
+    }
+    
+    if( width < 1 || height < 1 ) {
+      return( GLU.GLU_INVALID_VALUE );
+    }
+    
+    closestFit( gl, target, width, height, internalFormat, format, type, 
+            widthPowerOf2, heightPowerOf2 );
+    
+    levels = computeLog( widthPowerOf2[0] );
+    level = computeLog( heightPowerOf2[0] );
+    if( level > levels ) {
+      levels = level;
+    }
+    
+    //PointerWrapper pointer = PointerWrapperFactory.getPointerWrapper( data );
+    ByteBuffer buffer = null;
+    if( data instanceof ByteBuffer ) {
+        buffer = (ByteBuffer)data;
+        dataPos = buffer.position();
+    } else if( data instanceof byte[] ) {
+      byte[] array = (byte[])data;
+      buffer = ByteBuffer.allocateDirect(array.length);
+      buffer.put(array);
+    } else if( data instanceof short[] ) {
+        short[] array = (short[])data;
+        buffer = ByteBuffer.allocateDirect( array.length * 2 );
+        ShortBuffer sb = buffer.asShortBuffer();
+        sb.put( array );
+    } else if( data instanceof int[] ) {
+        int[] array = (int[])data;
+        buffer = ByteBuffer.allocateDirect( array.length * 4 );
+        IntBuffer ib = buffer.asIntBuffer();
+        ib.put( array );
+    } else if( data instanceof float[] ) {
+        float[] array = (float[])data;
+        buffer = ByteBuffer.allocateDirect( array.length * 4 );
+        FloatBuffer fb = buffer.asFloatBuffer();
+        fb.put( array );
+    }
+    
+    try {
+      return( BuildMipmap.gluBuild2DMipmapLevelsCore( gl, target, internalFormat, 
+              width, height, widthPowerOf2[0], heightPowerOf2[0], format, type, 0, 
+              0, levels, buffer ) );
+    } finally {
+      buffer.position(dataPos);
+    }
+  }
+ 
+ 
+  public static int gluBuild3DMipmaps( GL gl, int target, int internalFormat,
+          int width, int height, int depth, int format, int type, ByteBuffer data ) {
+    int dataPos = data.position();
+    try {
+
+      int[] widthPowerOf2 = new int[1];
+      int[] heightPowerOf2 = new int[1];
+      int[] depthPowerOf2 = new int[1];
+      int level, levels;
+    
+      int rc = checkMipmapArgs( internalFormat, format, type );
+      if( rc != 0 ) {
+        return( rc );
+      }
+    
+      if( width < 1 || height < 1 || depth < 1 ) {
+        return( GLU.GLU_INVALID_VALUE );
+      }
+    
+      if( type == GL2.GL_BITMAP ) {
+        return( GLU.GLU_INVALID_ENUM );
+      }
+    
+      closestFit3D( gl, target, width, height, depth, internalFormat, format,
+                    type, widthPowerOf2, heightPowerOf2, depthPowerOf2 );
+    
+      levels = computeLog( widthPowerOf2[0] );
+      level = computeLog( heightPowerOf2[0] );
+      if( level > levels ) {
+        levels = level;
+      }
+      level = computeLog( depthPowerOf2[0] );
+      if( level > levels ) {
+        levels = level;
+      }
+    
+      return( BuildMipmap.gluBuild3DMipmapLevelsCore( gl, target, internalFormat, width,
+              height, depth, widthPowerOf2[0], heightPowerOf2[0], depthPowerOf2[0],
+              format, type, 0, 0, levels, data ) );
+    } finally {
+      data.position(dataPos);
+    }
+  }
+  
+  public static int gluBuild3DMipmapLevels( GL gl, int target, int internalFormat,
+          int width, int height, int depth, int format, int type, int userLevel,
+          int baseLevel, int maxLevel, ByteBuffer data ) {
+    int dataPos = data.position();
+    try {
+      int level, levels;
+    
+      int rc = checkMipmapArgs( internalFormat, format, type );
+      if( rc != 0 ) {
+        return( rc );
+      }
+    
+      if( width < 1 || height < 1 || depth < 1 ) {
+        return( GLU.GLU_INVALID_VALUE );
+      }
+    
+      if( type == GL2.GL_BITMAP ) {
+        return( GLU.GLU_INVALID_ENUM );
+      }
+    
+      levels = computeLog( width );
+      level = computeLog( height );
+      if( level > levels ) {
+        levels = level;
+      }
+      level = computeLog( depth );
+      if( level > levels ) {
+        levels = level;
+      }
+    
+      levels += userLevel;
+      if( !isLegalLevels( userLevel, baseLevel, maxLevel, levels ) ) {
+        return( GLU.GLU_INVALID_VALUE );
+      }
+    
+      return( BuildMipmap.gluBuild3DMipmapLevelsCore( gl, target, internalFormat, width,
+              height, depth, width, height, depth, format, type, userLevel,
+              baseLevel, maxLevel, data ) );
+    } finally {
+      data.position(dataPos);
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/PixelStorageModes.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/PixelStorageModes.java
new file mode 100644
index 000000000..82324f1b0
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/PixelStorageModes.java
@@ -0,0 +1,426 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+/**
+ *
+ * @author  Administrator
+ */
+public class PixelStorageModes {
+
+  /**
+   * Holds value of property packAlignment.
+   */
+  private int packAlignment;
+
+  /**
+   * Holds value of property packRowLength.
+   */
+  private int packRowLength;
+
+  /**
+   * Holds value of property packSkipRows.
+   */
+  private int packSkipRows;
+
+  /**
+   * Holds value of property packSkipPixels.
+   */
+  private int packSkipPixels;
+
+  /**
+   * Holds value of property packLsbFirst.
+   */
+  private boolean packLsbFirst;
+
+  /**
+   * Holds value of property packSwapBytes.
+   */
+  private boolean packSwapBytes;
+
+  /**
+   * Holds value of property packSkipImages.
+   */
+  private int packSkipImages;
+
+  /**
+   * Holds value of property packImageHeight.
+   */
+  private int packImageHeight;
+
+  /**
+   * Holds value of property unpackAlignment.
+   */
+  private int unpackAlignment;
+
+  /**
+   * Holds value of property unpackRowLength.
+   */
+  private int unpackRowLength;
+
+  /**
+   * Holds value of property unpackSkipRows.
+   */
+  private int unpackSkipRows;
+
+  /**
+   * Holds value of property unpackSkipPixels.
+   */
+  private int unpackSkipPixels;
+
+  /**
+   * Holds value of property unpackLsbFirst.
+   */
+  private boolean unpackLsbFirst;
+
+  /**
+   * Holds value of property unpackSwapBytes.
+   */
+  private boolean unpackSwapBytes;
+
+  /**
+   * Holds value of property unpackSkipImages.
+   */
+  private int unpackSkipImages;
+
+  /**
+   * Holds value of property unpackImageHeight.
+   */
+  private int unpackImageHeight;
+  
+  /** Creates a new instance of PixelStorageModes */
+  public PixelStorageModes() {
+  }
+
+  /**
+   * Getter for property packAlignment.
+   * @return Value of property packAlignment.
+   */
+  public int getPackAlignment() {
+
+    return this.packAlignment;
+  }
+
+  /**
+   * Setter for property packAlignment.
+   * @param packAlignment New value of property packAlignment.
+   */
+  public void setPackAlignment(int packAlignment) {
+
+    this.packAlignment = packAlignment;
+  }
+
+  /**
+   * Getter for property packRowLength.
+   * @return Value of property packRowLength.
+   */
+  public int getPackRowLength() {
+
+    return this.packRowLength;
+  }
+
+  /**
+   * Setter for property packRowLength.
+   * @param packRowLength New value of property packRowLength.
+   */
+  public void setPackRowLength(int packRowLength) {
+
+    this.packRowLength = packRowLength;
+  }
+
+  /**
+   * Getter for property packSkipRows.
+   * @return Value of property packSkipRows.
+   */
+  public int getPackSkipRows() {
+
+    return this.packSkipRows;
+  }
+
+  /**
+   * Setter for property packSkipRows.
+   * @param packSkipRows New value of property packSkipRows.
+   */
+  public void setPackSkipRows(int packSkipRows) {
+
+    this.packSkipRows = packSkipRows;
+  }
+
+  /**
+   * Getter for property packSkipPixels.
+   * @return Value of property packSkipPixels.
+   */
+  public int getPackSkipPixels() {
+
+    return this.packSkipPixels;
+  }
+
+  /**
+   * Setter for property packSkipPixels.
+   * @param packSkipPixels New value of property packSkipPixels.
+   */
+  public void setPackSkipPixels(int packSkipPixels) {
+
+    this.packSkipPixels = packSkipPixels;
+  }
+
+  /**
+   * Getter for property packLsbFirst.
+   * @return Value of property packLsbFirst.
+   */
+  public boolean getPackLsbFirst() {
+
+    return this.packLsbFirst;
+  }
+
+  /**
+   * Setter for property packLsbFirst.
+   * @param packLsbFirst New value of property packLsbFirst.
+   */
+  public void setPackLsbFirst(boolean packLsbFirst) {
+
+    this.packLsbFirst = packLsbFirst;
+  }
+
+  /**
+   * Getter for property packSwapBytes.
+   * @return Value of property packSwapBytes.
+   */
+  public boolean getPackSwapBytes() {
+
+    return this.packSwapBytes;
+  }
+
+  /**
+   * Setter for property packSwapBytes.
+   * @param packSwapBytes New value of property packSwapBytes.
+   */
+  public void setPackSwapBytes(boolean packSwapBytes) {
+
+    this.packSwapBytes = packSwapBytes;
+  }
+
+  /**
+   * Getter for property packSkipImages.
+   * @return Value of property packSkipImages.
+   */
+  public int getPackSkipImages() {
+
+    return this.packSkipImages;
+  }
+
+  /**
+   * Setter for property packSkipImages.
+   * @param packSkipImages New value of property packSkipImages.
+   */
+  public void setPackSkipImages(int packSkipImages) {
+
+    this.packSkipImages = packSkipImages;
+  }
+
+  /**
+   * Getter for property packImageHeight.
+   * @return Value of property packImageHeight.
+   */
+  public int getPackImageHeight() {
+
+    return this.packImageHeight;
+  }
+
+  /**
+   * Setter for property packImageHeight.
+   * @param packImageHeight New value of property packImageHeight.
+   */
+  public void setPackImageHeight(int packImageHeight) {
+
+    this.packImageHeight = packImageHeight;
+  }
+
+  /**
+   * Getter for property unpackAlignment.
+   * @return Value of property unpackAlignment.
+   */
+  public int getUnpackAlignment() {
+
+    return this.unpackAlignment;
+  }
+
+  /**
+   * Setter for property unpackAlignment.
+   * @param unpackAlignment New value of property unpackAlignment.
+   */
+  public void setUnpackAlignment(int unpackAlignment) {
+
+    this.unpackAlignment = unpackAlignment;
+  }
+
+  /**
+   * Getter for property unpackRowLength.
+   * @return Value of property unpackRowLength.
+   */
+  public int getUnpackRowLength() {
+
+    return this.unpackRowLength;
+  }
+
+  /**
+   * Setter for property unpackRowLength.
+   * @param unpackRowLength New value of property unpackRowLength.
+   */
+  public void setUnpackRowLength(int unpackRowLength) {
+
+    this.unpackRowLength = unpackRowLength;
+  }
+
+  /**
+   * Getter for property unpackSkipRows.
+   * @return Value of property unpackSkipRows.
+   */
+  public int getUnpackSkipRows() {
+
+    return this.unpackSkipRows;
+  }
+
+  /**
+   * Setter for property unpackSkipRows.
+   * @param unpackSkipRows New value of property unpackSkipRows.
+   */
+  public void setUnpackSkipRows(int unpackSkipRows) {
+
+    this.unpackSkipRows = unpackSkipRows;
+  }
+
+  /**
+   * Getter for property unpackSkipPixels.
+   * @return Value of property unpackSkipPixels.
+   */
+  public int getUnpackSkipPixels() {
+
+    return this.unpackSkipPixels;
+  }
+
+  /**
+   * Setter for property unpackSkipPixels.
+   * @param unpackSkipPixels New value of property unpackSkipPixels.
+   */
+  public void setUnpackSkipPixels(int unpackSkipPixels) {
+
+    this.unpackSkipPixels = unpackSkipPixels;
+  }
+
+  /**
+   * Getter for property unpackLsbFirst.
+   * @return Value of property unpackLsbFirst.
+   */
+  public boolean getUnpackLsbFirst() {
+
+    return this.unpackLsbFirst;
+  }
+
+  /**
+   * Setter for property unpackLsbFirst.
+   * @param unpackLsbFirst New value of property unpackLsbFirst.
+   */
+  public void setUnpackLsbFirst(boolean unpackLsbFirst) {
+
+    this.unpackLsbFirst = unpackLsbFirst;
+  }
+
+  /**
+   * Getter for property unpackSwapBytes.
+   * @return Value of property unpackSwapBytes.
+   */
+  public boolean getUnpackSwapBytes() {
+
+    return this.unpackSwapBytes;
+  }
+
+  /**
+   * Setter for property unpackSwapBytes.
+   * @param unpackSwapBytes New value of property unpackSwapBytes.
+   */
+  public void setUnpackSwapBytes(boolean unpackSwapBytes) {
+
+    this.unpackSwapBytes = unpackSwapBytes;
+  }
+
+  /**
+   * Getter for property unpackSkipImages.
+   * @return Value of property unpackSkipImages.
+   */
+  public int getUnpackSkipImages() {
+
+    return this.unpackSkipImages;
+  }
+
+  /**
+   * Setter for property unpackSkipImages.
+   * @param unpackSkipImages New value of property unpackSkipImages.
+   */
+  public void setUnpackSkipImages(int unpackSkipImages) {
+
+    this.unpackSkipImages = unpackSkipImages;
+  }
+
+  /**
+   * Getter for property unpackImageHeight.
+   * @return Value of property unpackImageHeight.
+   */
+  public int getUnpackImageHeight() {
+
+    return this.unpackImageHeight;
+  }
+
+  /**
+   * Setter for property unpackImageHeight.
+   * @param unpackImageHeight New value of property unpackImageHeight.
+   */
+  public void setUnpackImageHeight(int unpackImageHeight) {
+
+    this.unpackImageHeight = unpackImageHeight;
+  }
+  
+  
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ScaleInternal.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ScaleInternal.java
new file mode 100644
index 000000000..70ddab880
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/ScaleInternal.java
@@ -0,0 +1,2447 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import javax.media.opengl.GL;
+import javax.media.opengl.GL2;
+import javax.media.opengl.glu.GLU;
+import javax.media.opengl.util.BufferUtil;
+import java.nio.*;
+
+/**
+ *
+ * @author  Administrator
+ */
+public class ScaleInternal {
+  
+  public static final float UINT_MAX = (float)(0x00000000FFFFFFFF);
+  
+  public static void scale_internal( int components, int widthin, int heightin,
+          ShortBuffer datain, int widthout, int heightout, ShortBuffer dataout ) {
+    float x, lowx, highx, convx, halfconvx;
+    float y, lowy, highy, convy, halfconvy;
+    float xpercent, ypercent;
+    float percent;
+    // Max components in a format is 4, so...
+    float[] totals = new float[4];
+    float area;
+    int i, j, k, yint, xint, xindex, yindex;
+    int temp;
+    
+    if( (widthin == (widthout * 2)) && (heightin == (heightout * 2)) ) {
+      HalveImage.halveImage( components, widthin, heightin, datain, dataout );
+      return;
+    }
+    convy = (float)heightin / heightout;
+    convx = (float)widthin / widthout;
+    halfconvx = convx / 2;
+    halfconvy = convy / 2;
+    for( i = 0; i < heightout; i++ ) {
+      y = convy * ( i + 0.5f );
+      if( heightin > heightout ) {
+        highy = y + halfconvy;
+        lowy = y - halfconvy;
+      } else {
+        highy = y + 0.5f;
+        lowy = y - 0.5f;
+      }
+      for( j = 0; j < widthout; j++ ) {
+        x = convx * ( j + 0.5f );
+        if( widthin > widthout ) {
+          highx = x + halfconvx;
+          lowx = x - halfconvx;
+        } else {
+          highx = x + 0.5f;
+          lowx = x - 0.5f;
+        }
+        // Ok, now apply box filter to box that goes from (lowx, lowy)
+        // to (highx, highy) on input data into this pixel on output
+        // data.
+        totals[0] = totals[1] = totals[2] = totals[3] = 0.0f;
+        area = 0.0f;
+        
+        y = lowy;
+        yint = (int)Math.floor( y );
+        while( y < highy ) {
+          yindex = ( yint + heightin ) % heightin;
+          if( highy < yint + 1 ) {
+            ypercent = highy - y;
+          } else {
+            ypercent = yint + 1 - y;
+          }
+          
+          x = lowx;
+          xint = (int)Math.floor( x );
+          
+          while( x < highx ) {
+            xindex = ( xint + widthin ) % widthin;
+            if( highx < xint + 1 ) {
+              xpercent = highx -x;
+            } else {
+              xpercent = xint + 1 - x;
+            }
+            
+            percent = xpercent * ypercent;
+            area += percent;
+            temp = ( xindex + ( yindex * widthin) ) * components;
+            for( k = 0; k < components; k++ ) {
+              totals[k] += datain.get( temp + k ) * percent; 
+            }
+            
+            xint++;
+            x = xint;
+          }
+          yint++;
+          y = yint;
+        }
+        
+        temp = ( j + ( i * widthout ) ) * components;
+        for( k = 0; k < components; k++ ) {
+          // totals[] should be rounded in the case of enlarging an RGB
+          // ramp when the type is 332 or 4444
+          dataout.put(  temp + k, (short)((totals[k] + 0.5f) / area) );
+        }
+      }
+    }
+  }
+  
+  public static void scale_internal_ubyte( int components, int widthin, int heightin,
+                              ByteBuffer datain, int widthout, int heightout, 
+                              ByteBuffer dataout, int element_size, int ysize, int group_size ) {
+    float x, convx;
+    float y, convy;
+    float percent;
+    // Max components in a format is 4, so...
+    float[] totals = new float[4];
+    float area;
+    int i, j, k, xindex;
+    
+    int temp, temp0;
+    int temp_index;
+    int outindex;
+    
+    int lowx_int, highx_int, lowy_int, highy_int;
+    float x_percent, y_percent;
+    float lowx_float, highx_float, lowy_float, highy_float;
+    float convy_float, convx_float;
+    int convy_int, convx_int;
+    int l, m;
+    int left, right;
+    
+    if( (widthin == (widthout * 2)) && (heightin == (heightout * 2)) ) {
+      HalveImage.halveImage_ubyte( components, widthin, heightin, datain, dataout, 
+                        element_size, ysize, group_size );
+      return;
+    }
+    convy = (float)heightin / heightout;
+    convx = (float)widthin / widthout;
+    convy_int = (int)Math.floor( convy );
+    convy_float = convy - convy_int;
+    convx_int = (int)Math.floor( convx );
+    convx_float = convx - convx_int;
+    
+    area = convx * convy;
+    
+    lowy_int = 0;
+    lowy_float = 0.0f;
+    highy_int = convy_int;
+    highy_float = convy_float;
+    
+    for( i = 0; i < heightout; i++ ) {
+      // Clamp here to be sure we don't read beyond input buffer.
+      if (highy_int >= heightin)
+        highy_int = heightin - 1;
+      lowx_int = 0;
+      lowx_float = 0.0f;
+      highx_int = convx_int;
+      highx_float = convx_float;
+      
+      for( j = 0; j < widthout; j++ ) {
+        
+        // Ok, now apply box filter to box that goes from (lowx, lowy)
+        // to (highx, highy) on input data into this pixel on output
+        // data.
+        totals[0] = totals[1] = totals[2] = totals[3] = 0.0f;
+        
+        // caulate the value for pixels in the 1st row
+        xindex = lowx_int * group_size;
+
+        if( ( highy_int > lowy_int ) && ( highx_int > lowx_int ) ) {
+          
+          y_percent = 1 - lowy_float;
+          temp = xindex + lowy_int * ysize;
+          percent = y_percent * ( 1 - lowx_float );
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            totals[k] += ( 0x000000FF & datain.get() ) * percent;
+          }
+          left = temp;
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              totals[k] += ( 0x000000FF & datain.get() ) * y_percent;
+            }
+          }
+          temp += group_size;
+          right = temp;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            totals[k] += ( 0x000000FF & datain.get() ) * percent;
+          }
+          
+          // calculate the value for pixels in the last row
+          y_percent = highy_float;
+          percent = y_percent * ( 1 - lowx_float );
+          temp = xindex + highy_int * ysize;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            totals[k] += ( 0x000000FF & datain.get() ) * percent;
+          }
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              totals[k] += ( 0x000000FF & datain.get() ) * y_percent;
+            }
+          }
+          temp += group_size;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            totals[k] += ( 0x000000FF & datain.get() ) * percent;
+          }
+          
+          // calculate the value for the pixels in the 1st and last column
+          for( m = lowy_int + 1; m < highy_int; m++ ) {
+            left += ysize;
+            right += ysize;
+            for( k = 0; k < components; k++, left += element_size, right += element_size ) {
+              float f = 0.0f;
+              datain.position( left );
+              f = ( 0x000000FF & datain.get() ) * ( 1.0f - lowx_float );
+              datain.position( right );
+              f += ( 0x000000FF & datain.get() ) * highx_float;
+              totals[k] += f;
+            }
+          }
+        } else if( highy_int > lowy_int ) {
+          x_percent = highx_float - lowx_float;
+          percent = ( 1 - lowy_float) * x_percent;
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            totals[k] += ( 0x000000FF & datain.get() ) * percent;
+          }
+          for( m = lowy_int + 1; m < highy_int; m++ ) {
+            temp += ysize;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              totals[k] += ( 0x000000FF & datain.get() ) * x_percent;
+            }
+          }
+          percent = x_percent * highy_float;
+          temp += ysize;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            totals[k] += ( 0x000000FF & datain.get() ) * percent;
+          }
+        } else if( highx_int > lowx_int ) {
+          y_percent = highy_float - lowy_float;
+          percent = ( 1 - lowx_float ) * y_percent;
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            totals[k] += ( 0x000000FF & datain.get() ) * percent;
+          }
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              totals[k] += ( 0x000000FF & datain.get() ) * y_percent;
+            }
+          }
+          temp += group_size;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            totals[k] += ( 0x000000FF & datain.get() ) * percent;
+          }
+        } else {
+          percent = ( highy_float - lowy_float ) * ( highx_float - lowx_float );
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            totals[k] += ( 0x000000FF & datain.get() ) * percent;
+          }
+        }
+
+        // this is for the pixels in the body
+        temp0 = xindex + group_size + ( lowy_int + 1 ) * ysize;
+        for( m = lowy_int + 1; m < highy_int; m++ ) {
+          temp = temp0;
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              totals[k] += ( 0x000000FF & datain.get() );
+            }
+            temp += group_size;
+          }
+          temp0 += ysize;
+        }
+        
+        outindex = ( j + ( i * widthout ) ) * components;
+        for( k = 0; k < components; k++ ) {
+          dataout.position( outindex + k );
+          dataout.put( (byte)(totals[k] / area) );
+        }
+        lowx_int = highx_int;
+        lowx_float = highx_float;
+        highx_int += convx_int;
+        highx_float += convx_float;
+        if( highx_float > 1.0f ) {
+          highx_float -= 1.0f;
+          highx_int++;
+        }
+
+        // Clamp to make sure we don't run off the right edge
+        if (highx_int > widthin - 1) {
+          int delta = (highx_int - widthin + 1);
+          lowx_int -= delta;
+          highx_int -= delta;
+        }
+      }
+      lowy_int = highy_int;
+      lowy_float = highy_float;
+      highy_int += convy_int;
+      highy_float += convy_float;
+      if( highy_float > 1.0f ) {
+        highy_float -= 1.0f;
+        highy_int++;
+      }
+    }
+  }
+  
+  public static void scale_internal_byte( int components, int widthin, int heightin,
+                              ByteBuffer datain, int widthout, int heightout, 
+                              ByteBuffer dataout, int element_size, int ysize,
+                              int group_size ) {
+    float x, convx;
+    float y, convy;
+    float percent;
+    // Max components in a format is 4, so...
+    float[] totals = new float[4];
+    float area;
+    int i, j, k, xindex;
+    
+    int temp, temp0;
+    int temp_index;
+    int outindex;
+    
+    int lowx_int, highx_int, lowy_int, highy_int;
+    float x_percent, y_percent;
+    float lowx_float, highx_float, lowy_float, highy_float;
+    float convy_float, convx_float;
+    int convy_int, convx_int;
+    int l, m;
+    int left, right;
+    
+    if( (widthin == (widthout * 2)) && (heightin == (heightout * 2)) ) {
+      HalveImage.halveImage_byte( components, widthin, heightin, datain, dataout, 
+                        element_size, ysize, group_size );
+      return;
+    }
+    convy = (float)heightin / heightout;
+    convx = (float)widthin / widthout;
+    convy_int = (int)Math.floor( convy );
+    convy_float = convy - convy_int;
+    convx_int = (int)Math.floor( convx );
+    convx_float = convx - convx_int;
+    
+    area = convx * convy;
+    
+    lowy_int = 0;
+    lowy_float = 0.0f;
+    highy_int = convy_int;
+    highy_float = convy_float;
+    
+    for( i = 0; i < heightout; i++ ) {
+      // Clamp here to be sure we don't read beyond input buffer.
+      if (highy_int >= heightin)
+        highy_int = heightin - 1;
+      lowx_int = 0;
+      lowx_float = 0.0f;
+      highx_int = convx_int;
+      highx_float = convx_float;
+      
+      for( j = 0; j < widthout; j++ ) {
+        
+        // Ok, now apply box filter to box that goes from (lowx, lowy)
+        // to (highx, highy) on input data into this pixel on output
+        // data.
+        totals[0] = totals[1] = totals[2] = totals[3] = 0.0f;
+        
+        // caulate the value for pixels in the 1st row
+        xindex = lowx_int * group_size;
+        if( ( highy_int > lowy_int ) && ( highx_int > lowx_int ) ) {
+          
+          y_percent = 1 - lowy_float;
+          temp = xindex + lowy_int * ysize;
+          percent = y_percent * ( 1 - lowx_float );
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            totals[k] += datain.get() * percent;
+          }
+          left = temp;
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              totals[k] += datain.get() * y_percent;
+            }
+          }
+          temp += group_size;
+          right = temp;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            totals[k] += datain.get() * percent;
+          }
+          
+          // calculate the value for pixels in the last row
+          y_percent = highy_float;
+          percent = y_percent * ( 1 - lowx_float );
+          temp = xindex + highy_int * ysize;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            totals[k] += datain.get() * percent;
+          }
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              totals[k] += datain.get() * y_percent;
+            }
+          }
+          temp += group_size;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            totals[k] += datain.get() * percent;
+          }
+          
+          // calculate the value for the pixels in the 1st and last column
+          for( m = lowy_int + 1; m < highy_int; m++ ) {
+            left += ysize;
+            right += ysize;
+            for( k = 0; k < components; k++, left += element_size, right += element_size ) {
+              float f = 0.0f;
+              datain.position( left );
+              f = datain.get() * ( 1 - lowx_float );
+              datain.position( right );
+              f += datain.get() * highx_float;
+              totals[k] += f;
+            }
+          }
+        } else if( highy_int > lowy_int ) {
+          x_percent = highx_float - lowx_float;
+          percent = ( 1 - lowy_float) * x_percent;
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            totals[k] += datain.get() * percent;
+          }
+          for( m = lowy_int + 1; m < highy_int; m++ ) {
+            temp += ysize;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              totals[k] += datain.get() * x_percent;
+            }
+          }
+          percent = x_percent * highy_float;
+          temp += ysize;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            totals[k] += datain.get() * percent;
+          }
+        } else if( highx_int > lowx_int ) {
+          y_percent = highy_float - lowy_float;
+          percent = ( 1 - lowx_float ) * y_percent;
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            totals[k] += datain.get() * percent;
+          }
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              totals[k] += datain.get() * y_percent;
+            }
+          }
+          temp += group_size;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            totals[k] += datain.get() * percent;
+          }
+        } else {
+          percent = ( highy_float - lowy_float ) * ( highx_float - lowx_float );
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            totals[k] += datain.get() * percent;
+          }
+        }
+        
+        // this is for the pixels in the body
+        temp0 = xindex + group_size + ( lowy_int + 1 ) * ysize;
+        for( m = lowy_int + 1; m < highy_int; m++ ) {
+          temp = temp0;
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              totals[k] += datain.get();
+            }
+            temp += group_size;
+          }
+          temp0 += ysize;
+        }
+        
+        outindex = ( j + ( i * widthout ) ) * components;
+        for( k = 0; k < components; k++ ) {
+          dataout.position( outindex + k );
+          dataout.put( (byte)(totals[k] / area) );
+        }
+        lowx_int = highx_int;
+        lowx_float = highx_float;
+        highx_int += convx_int;
+        highx_float += convx_float;
+        if( highx_float > 1.0f ) {
+          highx_float -= 1.0f;
+          highx_int++;
+        }
+
+        // Clamp to make sure we don't run off the right edge
+        if (highx_int > widthin - 1) {
+          int delta = (highx_int - widthin + 1);
+          lowx_int -= delta;
+          highx_int -= delta;
+        }
+      }
+      lowy_int = highy_int;
+      lowy_float = highy_float;
+      highy_int += convy_int;
+      highy_float += convy_float;
+      if( highy_float > 1.0f ) {
+        highy_float -= 1.0f;
+        highy_int++;
+      }
+    }
+  }
+  
+  public static void scale_internal_ushort( int components, int widthin, int heightin,
+                              ByteBuffer datain, int widthout, int heightout, 
+                              ShortBuffer dataout, int element_size, int ysize, 
+                              int group_size, boolean myswap_bytes ) {
+    float x, convx;
+    float y, convy;
+    float percent;
+    // Max components in a format is 4, so...
+    float[] totals = new float[4];
+    float area;
+    int i, j, k, xindex;
+    
+    int temp, temp0;
+    int temp_index;
+    int outindex;
+    
+    int lowx_int, highx_int, lowy_int, highy_int;
+    float x_percent, y_percent;
+    float lowx_float, highx_float, lowy_float, highy_float;
+    float convy_float, convx_float;
+    int convy_int, convx_int;
+    int l, m;
+    int left, right;
+    
+    if( (widthin == (widthout * 2)) && (heightin == (heightout * 2)) ) {
+      HalveImage.halveImage_ushort( components, widthin, heightin, datain, dataout, 
+                        element_size, ysize, group_size, myswap_bytes );
+      return;
+    }
+    convy = (float)heightin / heightout;
+    convx = (float)widthin / widthout;
+    convy_int = (int)Math.floor( convy );
+    convy_float = convy - convy_int;
+    convx_int = (int)Math.floor( convx );
+    convx_float = convx - convx_int;
+    
+    area = convx * convy;
+    
+    lowy_int = 0;
+    lowy_float = 0.0f;
+    highy_int = convy_int;
+    highy_float = convy_float;
+    
+    for( i = 0; i < heightout; i++ ) {
+      // Clamp here to be sure we don't read beyond input buffer.
+      if (highy_int >= heightin)
+        highy_int = heightin - 1;
+      lowx_int = 0;
+      lowx_float = 0.0f;
+      highx_int = convx_int;
+      highx_float = convx_float;
+      
+      for( j = 0; j < widthout; j++ ) {
+        
+        // Ok, now apply box filter to box that goes from (lowx, lowy)
+        // to (highx, highy) on input data into this pixel on output
+        // data.
+        totals[0] = totals[1] = totals[2] = totals[3] = 0.0f;
+        
+        // caulate the value for pixels in the 1st row
+        xindex = lowx_int * group_size;
+        if( ( highy_int > lowy_int ) && ( highx_int > lowx_int ) ) {
+          
+          y_percent = 1 - lowy_float;
+          temp = xindex + lowy_int * ysize;
+          percent = y_percent * ( 1 - lowx_float );
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              totals[k] += ( 0x0000FFFF & ((int)Mipmap.GLU_SWAP_2_BYTES( datain.getShort() ))) * percent;
+            } else {
+              totals[k] += ( 0x0000FFFF & datain.getShort() ) * percent;
+            }
+          }
+          left = temp;
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                totals[k] += ( 0x0000FFFF & ((int)Mipmap.GLU_SWAP_2_BYTES( datain.getShort() ))) * y_percent;
+              } else {
+                totals[k] += ( 0x0000FFFF & datain.getShort()) * y_percent;
+              }
+            }
+          }
+          temp += group_size;
+          right = temp;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              totals[k] += ( 0x0000FFFF & (Mipmap.GLU_SWAP_2_BYTES( datain.getShort() ))) * percent;
+            } else {
+              totals[k] += ( 0x0000FFFF & datain.getShort()) * percent;
+            }
+          }
+          
+          // calculate the value for pixels in the last row
+          y_percent = highy_float;
+          percent = y_percent * ( 1 - lowx_float );
+          temp = xindex + highy_int * ysize;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              totals[k] += ( 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort()) ) * percent;
+            } else {
+              totals[k] += ( 0x0000FFFF & datain.getShort() ) * percent;
+            }
+          }
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                totals[k] += ( 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort()) ) * y_percent;
+              } else {
+                totals[k] += ( 0x0000FFFF & datain.getShort()) * y_percent;
+              }
+            }
+          }
+          temp += group_size;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              totals[k] += ( 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort()) ) * percent;
+            } else {
+              totals[k] += ( 0x0000FFFF & datain.getShort()) * percent;
+            }
+          }
+          
+          // calculate the value for the pixels in the 1st and last column
+          for( m = lowy_int + 1; m < highy_int; m++ ) {
+            left += ysize;
+            right += ysize;
+            for( k = 0; k < components; k++, left += element_size, right += element_size ) {
+              if( myswap_bytes ) {
+                datain.position( left );
+                float f = (0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES(datain.getShort())) * ( 1 - lowx_float );
+                datain.position( right );
+                f += ((0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES(datain.getShort())) * highx_float);
+                totals[k] += f;
+              } else {
+                datain.position( left );
+                float f = ((0x0000FFFF & datain.getShort()) * ( 1 - lowx_float ));
+                datain.position( right );
+                f += ((0x0000FFFF & datain.getShort()) * highx_float);
+                totals[k] += f;
+              }
+            }
+          }
+        } else if( highy_int > lowy_int ) {
+          x_percent = highx_float - lowx_float;
+          percent = ( 1 - lowy_float) * x_percent;
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              totals[k] += (0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort() )) * percent;
+            } else {
+              totals[k] += (0x0000FFFF & datain.getShort()) * percent;
+            }
+          }
+          for( m = lowy_int + 1; m < highy_int; m++ ) {
+            temp += ysize;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                totals[k] += (0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort()) ) * x_percent;
+              } else {
+                totals[k] += (0x0000FFFF & datain.getShort()) * x_percent;
+              }
+            }
+          }
+          percent = x_percent * highy_float;
+          temp += ysize;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              totals[k] += (0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort() )) * percent;
+            } else {
+              totals[k] += (0x0000FFFF & datain.getShort()) * percent;
+            }
+          }
+        } else if( highx_int > lowx_int ) {
+          y_percent = highy_float - lowy_float;
+          percent = ( 1 - lowx_float ) * y_percent;
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              totals[k] += (0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort()) ) * percent;
+            } else {
+              totals[k] += (0x0000FFFF & datain.getShort()) * percent;
+            }
+          }
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                totals[k] += (0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort()) ) * y_percent;
+              } else {
+                totals[k] += (0x0000FFFF & datain.getShort()) * y_percent;
+              }
+            }
+          }
+          temp += group_size;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              totals[k] += (0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort()) ) * percent;
+            } else {
+              totals[k] += (0x0000FFFF & datain.getShort()) * percent;
+            }
+          }
+        } else {
+          percent = ( highy_float - lowy_float ) * ( highx_float - lowx_float );
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              totals[k] += (0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort()) ) * percent;
+            } else {
+              totals[k] += (0x0000FFFF & datain.getShort()) * percent;
+            }
+          }
+        }
+        
+        // this is for the pixels in the body
+        temp0 = xindex + group_size + ( lowy_int + 1 ) * ysize;
+        for( m = lowy_int + 1; m < highy_int; m++ ) {
+          temp = temp0;
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                totals[k] += (0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort()));
+              } else {
+                totals[k] += (0x0000FFFF & datain.getShort());
+              }
+            }
+            temp += group_size;
+          }
+          temp0 += ysize;
+        }
+        
+        outindex = ( j + ( i * widthout ) ) * components;
+        for( k = 0; k < components; k++ ) {
+          dataout.position( outindex + k );
+          dataout.put( (short)(totals[k] / area) );
+        }
+        lowx_int = highx_int;
+        lowx_float = highx_float;
+        highx_int += convx_int;
+        highx_float += convx_float;
+        if( highx_float > 1.0f ) {
+          highx_float -= 1.0f;
+          highx_int++;
+        }
+
+        // Clamp to make sure we don't run off the right edge
+        if (highx_int > widthin - 1) {
+          int delta = (highx_int - widthin + 1);
+          lowx_int -= delta;
+          highx_int -= delta;
+        }
+      }
+      lowy_int = highy_int;
+      lowy_float = highy_float;
+      highy_int += convy_int;
+      highy_float += convy_float;
+      if( highy_float > 1.0f ) {
+        highy_float -= 1.0f;
+        highy_int++;
+      }
+    }
+  }
+  
+  public static void scale_internal_short( int components, int widthin, int heightin,
+                              ByteBuffer datain, int widthout, int heightout,
+                              ShortBuffer dataout, int element_size, int ysize, 
+                              int group_size, boolean myswap_bytes ) {
+    float x, convx;
+    float y, convy;
+    float percent;
+    // Max components in a format is 4, so...
+    float[] totals = new float[4];
+    float area;
+    int i, j, k, xindex;
+    
+    int temp, temp0;
+    int temp_index;
+    int outindex;
+    
+    int lowx_int, highx_int, lowy_int, highy_int;
+    float x_percent, y_percent;
+    float lowx_float, highx_float, lowy_float, highy_float;
+    float convy_float, convx_float;
+    int convy_int, convx_int;
+    int l, m;
+    int left, right;
+    
+    int swapbuf; // unsigned buffer
+    
+    if( (widthin == (widthout * 2)) && (heightin == (heightout * 2)) ) {
+      HalveImage.halveImage_short( components, widthin, heightin, datain, dataout, 
+                        element_size, ysize, group_size, myswap_bytes );
+      return;
+    }
+    convy = (float)heightin / heightout;
+    convx = (float)widthin / widthout;
+    convy_int = (int)Math.floor( convy );
+    convy_float = convy - convy_int;
+    convx_int = (int)Math.floor( convx );
+    convx_float = convx - convx_int;
+    
+    area = convx * convy;
+    
+    lowy_int = 0;
+    lowy_float = 0.0f;
+    highy_int = convy_int;
+    highy_float = convy_float;
+    
+    for( i = 0; i < heightout; i++ ) {
+      // Clamp here to be sure we don't read beyond input buffer.
+      if (highy_int >= heightin)
+        highy_int = heightin - 1;
+      lowx_int = 0;
+      lowx_float = 0.0f;
+      highx_int = convx_int;
+      highx_float = convx_float;
+      
+      for( j = 0; j < widthout; j++ ) {
+        
+        // Ok, now apply box filter to box that goes from (lowx, lowy)
+        // to (highx, highy) on input data into this pixel on output
+        // data.
+        totals[0] = totals[1] = totals[2] = totals[3] = 0.0f;
+        
+        // caulate the value for pixels in the 1st row
+        xindex = lowx_int * group_size;
+        if( ( highy_int > lowy_int ) && ( highx_int > lowx_int ) ) {
+          
+          y_percent = 1 - lowy_float;
+          temp = xindex + lowy_int * ysize;
+          percent = y_percent * ( 1 - lowx_float );
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getShort() * percent;
+            }
+          }
+          left = temp;
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                swapbuf = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+                totals[k] += swapbuf * y_percent;
+              } else {
+                totals[k] += datain.getShort() * y_percent;
+              }
+            }
+          }
+          temp += group_size;
+          right = temp;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getShort() * percent;
+            }
+          }
+          
+          // calculate the value for pixels in the last row
+          y_percent = highy_float;
+          percent = y_percent * ( 1 - lowx_float );
+          temp = xindex + highy_int * ysize;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getShort() * percent;
+            }
+          }
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                swapbuf = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+                totals[k] += swapbuf * y_percent;
+              } else {
+                totals[k] += datain.getShort() * y_percent;
+              }
+            }
+          }
+          temp += group_size;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getShort() * percent;
+            }
+          }
+          
+          // calculate the value for the pixels in the 1st and last column
+          for( m = lowy_int + 1; m < highy_int; m++ ) {
+            left += ysize;
+            right += ysize;
+            for( k = 0; k < components; k++, left += element_size, right += element_size ) {
+              if( myswap_bytes ) {
+                datain.position( left );
+                swapbuf = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+                totals[k] += swapbuf * ( 1 - lowx_float );
+                datain.position( right );
+                swapbuf = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+                totals[k] += swapbuf * highx_float;
+              } else {
+                datain.position( left );
+                totals[k] += datain.getShort() * ( 1 - lowx_float );
+                datain.position( right );
+                totals[k] += datain.getShort() * highx_float;
+              }
+            }
+          }
+        } else if( highy_int > lowy_int ) {
+          x_percent = highx_float - lowx_float;
+          percent = ( 1 - lowy_float) * x_percent;
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getShort() * percent;
+            }
+          }
+          for( m = lowy_int + 1; m < highy_int; m++ ) {
+            temp += ysize;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                swapbuf = Mipmap.GLU_SWAP_2_BYTES( datain.getShort());
+                totals[k] += swapbuf * x_percent;
+              } else {
+                totals[k] += datain.getShort() * x_percent;
+              }
+            }
+          }
+          percent = x_percent * highy_float;
+          temp += ysize;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getShort() * percent;
+            }
+          }
+        } else if( highx_int > lowx_int ) {
+          y_percent = highy_float - lowy_float;
+          percent = ( 1 - lowx_float ) * y_percent;
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getShort() * percent;
+            }
+          }
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                swapbuf = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+                totals[k] += swapbuf * y_percent;
+              } else {
+                totals[k] += datain.getShort() * y_percent;
+              }
+            }
+          }
+          temp += group_size;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getShort() * percent;
+            }
+          }
+        } else {
+          percent = ( highy_float - lowy_float ) * ( highx_float - lowx_float );
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getShort() * percent;
+            }
+          }
+        }
+        
+        // this is for the pixels in the body
+        temp0 = xindex + group_size + ( lowy_int + 1 ) * ysize;
+        for( m = lowy_int + 1; m < highy_int; m++ ) {
+          temp = temp0;
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                swapbuf = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
+                totals[k] += swapbuf;
+              } else {
+                totals[k] += datain.getShort();
+              }
+            }
+            temp += group_size;
+          }
+          temp0 += ysize;
+        }
+        
+        outindex = ( j + ( i * widthout ) ) * components;
+        for( k = 0; k < components; k++ ) {
+          dataout.position( outindex + k );
+          dataout.put( (short)(totals[k] / area) );
+        }
+        lowx_int = highx_int;
+        lowx_float = highx_float;
+        highx_int += convx_int;
+        highx_float += convx_float;
+        if( highx_float > 1.0f ) {
+          highx_float -= 1.0f;
+          highx_int++;
+        }
+
+        // Clamp to make sure we don't run off the right edge
+        if (highx_int > widthin - 1) {
+          int delta = (highx_int - widthin + 1);
+          lowx_int -= delta;
+          highx_int -= delta;
+        }
+      }
+      lowy_int = highy_int;
+      lowy_float = highy_float;
+      highy_int += convy_int;
+      highy_float += convy_float;
+      if( highy_float > 1.0f ) {
+        highy_float -= 1.0f;
+        highy_int++;
+      }
+    }
+  }
+  
+  public static void scale_internal_uint( int components, int widthin, int heightin,
+                              ByteBuffer datain, int widthout, int heightout, 
+                              IntBuffer dataout, int element_size, int ysize, 
+                              int group_size, boolean myswap_bytes ) {
+    float x, convx;
+    float y, convy;
+    float percent;
+    // Max components in a format is 4, so...
+    float[] totals = new float[4];
+    float area;
+    int i, j, k, xindex;
+    
+    int temp, temp0;
+    int temp_index;
+    int outindex;
+    
+    int lowx_int, highx_int, lowy_int, highy_int;
+    float x_percent, y_percent;
+    float lowx_float, highx_float, lowy_float, highy_float;
+    float convy_float, convx_float;
+    int convy_int, convx_int;
+    int l, m;
+    int left, right;
+    
+    if( (widthin == (widthout * 2)) && (heightin == (heightout * 2)) ) {
+      HalveImage.halveImage_uint( components, widthin, heightin, datain, dataout, 
+                        element_size, ysize, group_size, myswap_bytes );
+      return;
+    }
+    convy = (float)heightin / heightout;
+    convx = (float)widthin / widthout;
+    convy_int = (int)Math.floor( convy );
+    convy_float = convy - convy_int;
+    convx_int = (int)Math.floor( convx );
+    convx_float = convx - convx_int;
+    
+    area = convx * convy;
+    
+    lowy_int = 0;
+    lowy_float = 0.0f;
+    highy_int = convy_int;
+    highy_float = convy_float;
+    
+    for( i = 0; i < heightout; i++ ) {
+      // Clamp here to be sure we don't read beyond input buffer.
+      if (highy_int >= heightin)
+        highy_int = heightin - 1;
+      lowx_int = 0;
+      lowx_float = 0.0f;
+      highx_int = convx_int;
+      highx_float = convx_float;
+      
+      for( j = 0; j < widthout; j++ ) {
+        
+        // Ok, now apply box filter to box that goes from (lowx, lowy)
+        // to (highx, highy) on input data into this pixel on output
+        // data.
+        totals[0] = totals[1] = totals[2] = totals[3] = 0.0f;
+        
+        // caulate the value for pixels in the 1st row
+        xindex = lowx_int * group_size;
+        if( ( highy_int > lowy_int ) && ( highx_int > lowx_int ) ) {
+          
+          y_percent = 1 - lowy_float;
+          temp = xindex + lowy_int * ysize;
+          percent = y_percent * ( 1 - lowx_float );
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              totals[k] += (0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt()) ) * percent;
+            } else {
+              totals[k] += (0x00000000FFFFFFFF & datain.getInt()) * percent;
+            }
+          }
+          left = temp;
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                totals[k] += (0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt()) ) * y_percent;
+              } else {
+                totals[k] += (0x00000000FFFFFFFF & datain.getInt()) * y_percent;
+              }
+            }
+          }
+          temp += group_size;
+          right = temp;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              totals[k] += (0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt()) ) * percent;
+            } else {
+              totals[k] += (0x00000000FFFFFFFF & datain.getInt()) * percent;
+            }
+          }
+          
+          // calculate the value for pixels in the last row
+          y_percent = highy_float;
+          percent = y_percent * ( 1 - lowx_float );
+          temp = xindex + highy_int * ysize;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              totals[k] += (0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt()) ) * percent;
+            } else {
+              totals[k] += (0x00000000FFFFFFFF & datain.getInt()) * percent;
+            }
+          }
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                totals[k] += (0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt()) ) * y_percent;
+              } else {
+                totals[k] += (0x00000000FFFFFFFF & datain.getInt()) * y_percent;
+              }
+            }
+          }
+          temp += group_size;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              totals[k] += (0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt()) ) * percent;
+            } else {
+              totals[k] += (0x00000000FFFFFFFF & datain.getInt()) * percent;
+            }
+          }
+          
+          // calculate the value for the pixels in the 1st and last column
+          for( m = lowy_int + 1; m < highy_int; m++ ) {
+            left += ysize;
+            right += ysize;
+            for( k = 0; k < components; k++, left += element_size, right += element_size ) {
+              if( myswap_bytes ) {
+                datain.position( left );
+                totals[k] += ((0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES(datain.getInt())) * ( 1 - lowx_float ));
+                datain.position( right );
+                totals[k] += ((0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES(datain.getInt())) * highx_float);
+              } else {
+                datain.position( left );
+                totals[k] += ((0x00000000FFFFFFFF & datain.getInt()) * ( 1 - lowx_float ));
+                datain.position( right );
+                totals[k] += ((0x00000000FFFFFFFF & datain.getInt()) * highx_float);
+              }
+            }
+          }
+        } else if( highy_int > lowy_int ) {
+          x_percent = highx_float - lowx_float;
+          percent = ( 1 - lowy_float) * x_percent;
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              totals[k] += (0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt())) * percent;
+            } else {
+              totals[k] += (0x00000000FFFFFFFF & datain.getInt()) * percent;
+            }
+          }
+          for( m = lowy_int + 1; m < highy_int; m++ ) {
+            temp += ysize;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                totals[k] += (0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt())) * x_percent;
+              } else {
+                totals[k] += (0x00000000FFFFFFFF & datain.getInt()) * x_percent;
+              }
+            }
+          }
+          percent = x_percent * highy_float;
+          temp += ysize;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              totals[k] += (0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt())) * percent;
+            } else {
+              totals[k] += (0x00000000FFFFFFFF & datain.getInt()) * percent;
+            }
+          }
+        } else if( highx_int > lowx_int ) {
+          y_percent = highy_float - lowy_float;
+          percent = ( 1 - lowx_float ) * y_percent;
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              totals[k] += (0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt())) * percent;
+            } else {
+              totals[k] += (0x00000000FFFFFFFF & datain.getInt()) * percent;
+            }
+          }
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                totals[k] += (0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt())) * y_percent;
+              } else {
+                totals[k] += (0x00000000FFFFFFFF & datain.getInt()) * y_percent;
+              }
+            }
+          }
+          temp += group_size;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              totals[k] += (0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt())) * percent;
+            } else {
+              totals[k] += (0x00000000FFFFFFFF & datain.getInt()) * percent;
+            }
+          }
+        } else {
+          percent = ( highy_float - lowy_float ) * ( highx_float - lowx_float );
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            long tempInt0 = ( 0xFFFFFFFFL & datain.getInt( temp_index ) );
+            datain.position( temp_index );
+            long tempInt1 = ( 0xFFFFFFFFL & datain.getInt() );
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              totals[k] += (0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt())) * percent;
+            } else {
+              totals[k] += (0x00000000FFFFFFFF & datain.getInt()) * percent;
+            }
+          }
+        }
+        
+        // this is for the pixels in the body
+        temp0 = xindex + group_size + ( lowy_int + 1 ) * ysize;
+        for( m = lowy_int + 1; m < highy_int; m++ ) {
+          temp = temp0;
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                totals[k] += (0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt()));
+              } else {
+                totals[k] += (0x00000000FFFFFFFF & datain.getInt());
+              }
+            }
+            temp += group_size;
+          }
+          temp0 += ysize;
+        }
+        
+        outindex = ( j + ( i * widthout ) ) * components;
+        float value = 0.0f;
+        for( k = 0; k < components; k++ ) {
+          value = totals[k] / area;
+          dataout.position( outindex + k );
+          if( value >= UINT_MAX ) {
+            dataout.put( (int)value );
+          } else {
+            dataout.put( (int)(totals[k] / area) );
+          }
+        }
+        lowx_int = highx_int;
+        lowx_float = highx_float;
+        highx_int += convx_int;
+        highx_float += convx_float;
+        if( highx_float > 1.0f ) {
+          highx_float -= 1.0f;
+          highx_int++;
+        }
+
+        // Clamp to make sure we don't run off the right edge
+        if (highx_int > widthin - 1) {
+          int delta = (highx_int - widthin + 1);
+          lowx_int -= delta;
+          highx_int -= delta;
+        }
+      }
+      lowy_int = highy_int;
+      lowy_float = highy_float;
+      highy_int += convy_int;
+      highy_float += convy_float;
+      if( highy_float > 1.0f ) {
+        highy_float -= 1.0f;
+        highy_int++;
+      }
+    }
+  }
+  
+  public static void scale_internal_int( int components, int widthin, int heightin,
+                              ByteBuffer datain, int widthout, int heightout, 
+                              IntBuffer dataout, int element_size, int ysize, 
+                              int group_size, boolean myswap_bytes ) {
+    float x, convx;
+    float y, convy;
+    float percent;
+    // Max components in a format is 4, so...
+    float[] totals = new float[4];
+    float area;
+    int i, j, k, xindex;
+    
+    int temp, temp0;
+    int temp_index;
+    int outindex;
+    
+    int lowx_int, highx_int, lowy_int, highy_int;
+    float x_percent, y_percent;
+    float lowx_float, highx_float, lowy_float, highy_float;
+    float convy_float, convx_float;
+    int convy_int, convx_int;
+    int l, m;
+    int left, right;
+    
+    long swapbuf; // unsigned buffer
+    
+    if( (widthin == (widthout * 2)) && (heightin == (heightout * 2)) ) {
+      HalveImage.halveImage_int( components, widthin, heightin, datain, dataout, 
+                        element_size, ysize, group_size, myswap_bytes );
+      return;
+    }
+    convy = (float)heightin / heightout;
+    convx = (float)widthin / widthout;
+    convy_int = (int)Math.floor( convy );
+    convy_float = convy - convy_int;
+    convx_int = (int)Math.floor( convx );
+    convx_float = convx - convx_int;
+    
+    area = convx * convy;
+    
+    lowy_int = 0;
+    lowy_float = 0.0f;
+    highy_int = convy_int;
+    highy_float = convy_float;
+    
+    for( i = 0; i < heightout; i++ ) {
+      // Clamp here to be sure we don't read beyond input buffer.
+      if (highy_int >= heightin)
+        highy_int = heightin - 1;
+      lowx_int = 0;
+      lowx_float = 0.0f;
+      highx_int = convx_int;
+      highx_float = convx_float;
+      
+      for( j = 0; j < widthout; j++ ) {
+        
+        // Ok, now apply box filter to box that goes from (lowx, lowy)
+        // to (highx, highy) on input data into this pixel on output
+        // data.
+        totals[0] = totals[1] = totals[2] = totals[3] = 0.0f;
+        
+        // caulate the value for pixels in the 1st row
+        xindex = lowx_int * group_size;
+        if( ( highy_int > lowy_int ) && ( highx_int > lowx_int ) ) {
+          
+          y_percent = 1 - lowy_float;
+          temp = xindex + lowy_int * ysize;
+          percent = y_percent * ( 1 - lowx_float );
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getInt() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getInt() * percent;
+            }
+          }
+          left = temp;
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getInt() );
+                totals[k] += swapbuf * y_percent;
+              } else {
+                totals[k] += datain.getInt() * y_percent;
+              }
+            }
+          }
+          temp += group_size;
+          right = temp;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getInt() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getInt() * percent;
+            }
+          }
+          
+          // calculate the value for pixels in the last row
+          y_percent = highy_float;
+          percent = y_percent * ( 1 - lowx_float );
+          temp = xindex + highy_int * ysize;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getInt() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getInt() * percent;
+            }
+          }
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getInt() );
+                totals[k] += swapbuf * y_percent;
+              } else {
+                totals[k] += datain.getInt() * y_percent;
+              }
+            }
+          }
+          temp += group_size;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getInt() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getInt() * percent;
+            }
+          }
+          
+          // calculate the value for the pixels in the 1st and last column
+          for( m = lowy_int + 1; m < highy_int; m++ ) {
+            left += ysize;
+            right += ysize;
+            for( k = 0; k < components; k++, left += element_size, right += element_size ) {
+              if( myswap_bytes ) {
+                datain.position( left );
+                swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getInt() );
+                totals[k] += swapbuf * ( 1 - lowx_float );
+                datain.position( right );
+                swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getInt() );
+                totals[k] += swapbuf * highx_float;
+              } else {
+                datain.position( left );
+                totals[k] += (datain.getInt() * ( 1 - lowx_float ));
+                datain.position( right );
+                totals[k] += (datain.getInt() * highx_float);
+              }
+            }
+          }
+        } else if( highy_int > lowy_int ) {
+          x_percent = highx_float - lowx_float;
+          percent = ( 1 - lowy_float) * x_percent;
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getInt() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getInt() * percent;
+            }
+          }
+          for( m = lowy_int + 1; m < highy_int; m++ ) {
+            temp += ysize;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getInt() );
+                totals[k] += swapbuf * x_percent;
+              } else {
+                totals[k] += datain.getInt() * x_percent;
+              }
+            }
+          }
+          percent = x_percent * highy_float;
+          temp += ysize;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getInt() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getInt() * percent;
+            }
+          }
+        } else if( highx_int > lowx_int ) {
+          y_percent = highy_float - lowy_float;
+          percent = ( 1 - lowx_float ) * y_percent;
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getInt() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getInt() * percent;
+            }
+          }
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getInt() );
+                totals[k] += swapbuf * y_percent;
+              } else {
+                totals[k] += datain.getInt() * y_percent;
+              }
+            }
+          }
+          temp += group_size;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getInt() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getInt() * percent;
+            }
+          }
+        } else {
+          percent = ( highy_float - lowy_float ) * ( highx_float - lowx_float );
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getInt() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getInt() * percent;
+            }
+          }
+        }
+        
+        // this is for the pixels in the body
+        temp0 = xindex + group_size + ( lowy_int + 1 ) * ysize;
+        for( m = lowy_int + 1; m < highy_int; m++ ) {
+          temp = temp0;
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getInt() );
+                totals[k] += swapbuf;
+              } else {
+                totals[k] += datain.getInt();
+              }
+            }
+            temp += group_size;
+          }
+          temp0 += ysize;
+        }
+        
+        outindex = ( j + ( i * widthout ) ) * components;
+        for( k = 0; k < components; k++ ) {
+          dataout.position( outindex + k );
+          dataout.put( (int)(totals[k] / area) );
+        }
+        lowx_int = highx_int;
+        lowx_float = highx_float;
+        highx_int += convx_int;
+        highx_float += convx_float;
+        if( highx_float > 1.0f ) {
+          highx_float -= 1.0f;
+          highx_int++;
+        }
+
+        // Clamp to make sure we don't run off the right edge
+        if (highx_int > widthin - 1) {
+          int delta = (highx_int - widthin + 1);
+          lowx_int -= delta;
+          highx_int -= delta;
+        }
+      }
+      lowy_int = highy_int;
+      lowy_float = highy_float;
+      highy_int += convy_int;
+      highy_float += convy_float;
+      if( highy_float > 1.0f ) {
+        highy_float -= 1.0f;
+        highy_int++;
+      }
+    }
+  }
+  
+  public static void scale_internal_float( int components, int widthin, int heightin,
+                              ByteBuffer datain, int widthout, int heightout, 
+                              FloatBuffer dataout, int element_size, int ysize, 
+                              int group_size, boolean myswap_bytes ) {
+    float x, convx;
+    float y, convy;
+    float percent;
+    // Max components in a format is 4, so...
+    float[] totals = new float[4];
+    float area;
+    int i, j, k, xindex;
+    
+    int temp, temp0;
+    int temp_index;
+    int outindex;
+    
+    int lowx_int, highx_int, lowy_int, highy_int;
+    float x_percent, y_percent;
+    float lowx_float, highx_float, lowy_float, highy_float;
+    float convy_float, convx_float;
+    int convy_int, convx_int;
+    int l, m;
+    int left, right;
+    
+    float swapbuf; // unsigned buffer
+    
+    if( (widthin == (widthout * 2)) && (heightin == (heightout * 2)) ) {
+      HalveImage.halveImage_float( components, widthin, heightin, datain, dataout, 
+                        element_size, ysize, group_size, myswap_bytes );
+      return;
+    }
+    convy = (float)heightin / heightout;
+    convx = (float)widthin / widthout;
+    convy_int = (int)Math.floor( convy );
+    convy_float = convy - convy_int;
+    convx_int = (int)Math.floor( convx );
+    convx_float = convx - convx_int;
+    
+    area = convx * convy;
+    
+    lowy_int = 0;
+    lowy_float = 0.0f;
+    highy_int = convy_int;
+    highy_float = convy_float;
+    
+    for( i = 0; i < heightout; i++ ) {
+      // Clamp here to be sure we don't read beyond input buffer.
+      if (highy_int >= heightin)
+        highy_int = heightin - 1;
+      lowx_int = 0;
+      lowx_float = 0.0f;
+      highx_int = convx_int;
+      highx_float = convx_float;
+      
+      for( j = 0; j < widthout; j++ ) {
+        
+        // Ok, now apply box filter to box that goes from (lowx, lowy)
+        // to (highx, highy) on input data into this pixel on output
+        // data.
+        totals[0] = totals[1] = totals[2] = totals[3] = 0.0f;
+        
+        // caulate the value for pixels in the 1st row
+        xindex = lowx_int * group_size;
+        if( ( highy_int > lowy_int ) && ( highx_int > lowx_int ) ) {
+          
+          y_percent = 1 - lowy_float;
+          temp = xindex + lowy_int * ysize;
+          percent = y_percent * ( 1 - lowx_float );
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getFloat() * percent;
+            }
+          }
+          left = temp;
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+                totals[k] += swapbuf * y_percent;
+              } else {
+                totals[k] += datain.getFloat() * y_percent;
+              }
+            }
+          }
+          temp += group_size;
+          right = temp;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getFloat() * percent;
+            }
+          }
+          
+          // calculate the value for pixels in the last row
+          y_percent = highy_float;
+          percent = y_percent * ( 1 - lowx_float );
+          temp = xindex + highy_int * ysize;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getFloat() * percent;
+            }
+          }
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+                totals[k] += swapbuf * y_percent;
+              } else {
+                totals[k] += datain.getFloat() * y_percent;
+              }
+            }
+          }
+          temp += group_size;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getFloat() * percent;
+            }
+          }
+          
+          // calculate the value for the pixels in the 1st and last column
+          for( m = lowy_int + 1; m < highy_int; m++ ) {
+            left += ysize;
+            right += ysize;
+            for( k = 0; k < components; k++, left += element_size, right += element_size ) {
+              if( myswap_bytes ) {
+                datain.position( left );
+                swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+                totals[k] += swapbuf * ( 1 - lowx_float );
+                datain.position( right );
+                swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+                totals[k] += swapbuf * highx_float;
+              } else {
+                datain.position( left );
+                totals[k] += (datain.getFloat() * ( 1 - lowx_float ));
+                datain.position( right );
+                totals[k] += (datain.getFloat() * highx_float);
+              }
+            }
+          }
+        } else if( highy_int > lowy_int ) {
+          x_percent = highx_float - lowx_float;
+          percent = ( 1 - lowy_float) * x_percent;
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getFloat() * percent;
+            }
+          }
+          for( m = lowy_int + 1; m < highy_int; m++ ) {
+            temp += ysize;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+                totals[k] += swapbuf * x_percent;
+              } else {
+                totals[k] += datain.getFloat() * x_percent;
+              }
+            }
+          }
+          percent = x_percent * highy_float;
+          temp += ysize;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getFloat() * percent;
+            }
+          }
+        } else if( highx_int > lowx_int ) {
+          y_percent = highy_float - lowy_float;
+          percent = ( 1 - lowx_float ) * y_percent;
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getFloat() * percent;
+            }
+          }
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += group_size;
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+                totals[k] += swapbuf * y_percent;
+              } else {
+                totals[k] += datain.getFloat() * y_percent;
+              }
+            }
+          }
+          temp += group_size;
+          percent = y_percent * highx_float;
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getFloat() * percent;
+            }
+          }
+        } else {
+          percent = ( highy_float - lowy_float ) * ( highx_float - lowx_float );
+          temp = xindex + (lowy_int * ysize);
+          for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+            datain.position( temp_index );
+            if( myswap_bytes ) {
+              swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+              totals[k] += swapbuf * percent;
+            } else {
+              totals[k] += datain.getFloat() * percent;
+            }
+          }
+        }
+        
+        // this is for the pixels in the body
+        temp0 = xindex + group_size + ( lowy_int + 1 ) * ysize;
+        for( m = lowy_int + 1; m < highy_int; m++ ) {
+          temp = temp0;
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            for( k = 0, temp_index = temp; k < components; k++, temp_index += element_size ) {
+              datain.position( temp_index );
+              if( myswap_bytes ) {
+                swapbuf = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
+                totals[k] += swapbuf;
+              } else {
+                totals[k] += datain.getFloat();
+              }
+            }
+            temp += group_size;
+          }
+          temp0 += ysize;
+        }
+        
+        outindex = ( j + ( i * widthout ) ) * components;
+        for( k = 0; k < components; k++ ) {
+          dataout.position( outindex + k );
+          dataout.put( (totals[k] / area) );
+        }
+        lowx_int = highx_int;
+        lowx_float = highx_float;
+        highx_int += convx_int;
+        highx_float += convx_float;
+        if( highx_float > 1.0f ) {
+          highx_float -= 1.0f;
+          highx_int++;
+        }
+
+        // Clamp to make sure we don't run off the right edge
+        if (highx_int > widthin - 1) {
+          int delta = (highx_int - widthin + 1);
+          lowx_int -= delta;
+          highx_int -= delta;
+        }
+      }
+      lowy_int = highy_int;
+      lowy_float = highy_float;
+      highy_int += convy_int;
+      highy_float += convy_float;
+      if( highy_float > 1.0f ) {
+        highy_float -= 1.0f;
+        highy_int++;
+      }
+    }
+  }
+  
+  public static void scaleInternalPackedPixel( int components, Extract extract, 
+              int widthIn, int heightIn, ByteBuffer dataIn, int widthOut,
+              int heightOut, ByteBuffer dataOut, int pixelSizeInBytes,
+              int rowSizeInBytes, boolean isSwap ) {
+    float x, convx;
+    float y, convy;
+    float percent;
+    
+    // max components in a format is 4, so
+    float[] totals = new float[4];
+    float[] extractTotals = new float[4];
+    float[] extractMoreTotals = new float[4];
+    float[] shoveTotals = new float[4];
+    
+    float area;
+    int i, j, k, xindex;
+    
+    int temp, temp0;
+    int temp_index;
+    int outIndex = 0;
+    
+    int lowx_int, highx_int, lowy_int, highy_int;
+    float x_percent, y_percent;
+    float lowx_float, highx_float, lowy_float, highy_float;
+    float convy_float, convx_float;
+    int convy_int, convx_int;
+    int l, m;
+    int left, right;
+    
+    if( widthIn == widthOut * 2 && heightIn == heightOut * 2 ) {
+      HalveImage.halveImagePackedPixel( components, extract, widthIn, heightIn, dataIn, dataOut,
+                              pixelSizeInBytes, rowSizeInBytes, isSwap );
+      return;
+    }
+    convy = (float)heightIn / (float)heightOut;
+    convx = (float)widthIn / (float)widthOut;
+    convy_int = (int)Math.floor( convy );
+    convy_float = convy - convy_int;
+    convx_int = (int)Math.floor( convx );
+    convx_float = convx - convx_int;
+    
+    area = convx * convy;
+    
+    lowy_int = 0;
+    lowy_float = 0.0f;
+    highy_int = convy_int;
+    highy_float = convx_float;
+    
+    for( i = 0; i < heightOut; i++ ) {
+      // Clamp here to be sure we don't read beyond input buffer.
+      if (highy_int >= heightIn)
+        highy_int = heightIn - 1;
+      lowx_int = 0;
+      lowx_float = 0.0f;
+      highx_int = convx_int;
+      highx_float = convx_float;
+      
+      for( j = 0; j < widthOut; j++ ) {
+        // ok now apply box filter to box that goes from( lowx, lowy )
+        // to ( highx, highy ) on input data into this pixel on output data
+        totals[0] = totals[1] = totals[2] = totals[3] = 0.0f;
+        
+        // calculate that value for pixels in the 1st row
+        xindex = lowx_int * pixelSizeInBytes;
+        if( (highy_int > lowy_int) && (highx_int > lowx_int) ) {
+          
+          y_percent = 1 - lowy_float;
+          temp = xindex + lowy_int * rowSizeInBytes;
+          percent = y_percent * ( 1 - lowx_float );
+          dataIn.position( temp );
+          extract.extract( isSwap, dataIn, extractTotals );
+          for( k = 0; k < components; k++ ) {
+            totals[k] += extractTotals[k] * percent;
+          }
+          left = temp;
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += pixelSizeInBytes;
+            dataIn.position( temp );
+            extract.extract( isSwap, dataIn, extractTotals );
+            for( k = 0; k < components; k++ ) {
+              totals[k] += extractTotals[k] * y_percent;
+            }
+          }
+          temp += pixelSizeInBytes;
+          right = temp;
+          percent = y_percent * highx_float;
+          dataIn.position( temp );
+          extract.extract( isSwap, dataIn, extractTotals );
+          for( k = 0; k < components; k++ ) {
+            totals[k] += extractTotals[k] * percent;
+          }
+          // calculate the value for pixels in the last row
+          
+          y_percent = highy_float;
+          percent = y_percent * ( 1 - lowx_float );
+          temp = xindex + highy_int * rowSizeInBytes;
+          dataIn.position( temp );
+          extract.extract( isSwap, dataIn, extractTotals );
+          for( k = 0; k < components; k++ ) {
+            totals[k] += extractTotals[k] * percent;
+          }
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += pixelSizeInBytes;
+            dataIn.position( temp );
+            extract.extract( isSwap, dataIn, extractTotals );
+            for( k = 0; k < components; k++ ) {
+              totals[k] += extractTotals[k] * y_percent;
+            }
+          }
+          temp += pixelSizeInBytes;
+          percent = y_percent * highx_float;
+          dataIn.position( temp );
+          for( k = 0; k < components; k++ ) {
+            totals[k] += extractTotals[k] * percent;
+          }
+          
+          // calculate the value for pixels in the 1st and last column
+          for( m = lowy_int + 1; m < highy_int; m++ ) {
+            left += rowSizeInBytes;
+            right += rowSizeInBytes;
+            dataIn.position( left );
+            extract.extract( isSwap, dataIn, extractTotals );
+            dataIn.position( right );
+            extract.extract( isSwap, dataIn, extractMoreTotals );
+            for( k = 0; k < components; k++ ) {
+              totals[k] += ( extractTotals[k] * ( 1 - lowx_float ) + extractMoreTotals[k] * highx_float );
+            }
+          }
+        } else if( highy_int > lowy_int ) {
+          x_percent = highx_float - lowx_float;
+          percent = ( 1 - lowy_float ) * x_percent;
+          temp = xindex + lowy_int * rowSizeInBytes;
+          dataIn.position( temp );
+          extract.extract( isSwap, dataIn, extractTotals );
+          for( k = 0; k < components; k++ ) {
+            totals[k] += extractTotals[k] * percent;
+          }
+          for( m = lowy_int + 1; m < highy_int; m++ ) {
+            temp += rowSizeInBytes;
+            dataIn.position( temp );
+            extract.extract( isSwap, dataIn, extractTotals );
+            for( k = 0; k < components; k++ ) {
+              totals[k] += extractTotals[k] * x_percent;
+            }
+          }
+          percent = x_percent * highy_float;
+          temp += rowSizeInBytes;
+          dataIn.position( temp );
+          extract.extract( isSwap, dataIn, extractTotals );
+          for( k = 0; k < components; k++ ) {
+            totals[k] += extractTotals[k] * percent;
+          }
+        } else if( highx_int > lowx_int ) {
+          y_percent = highy_float - lowy_float;
+          percent = ( 1 - lowx_float ) * y_percent;
+          temp = xindex + lowy_int * rowSizeInBytes;
+          dataIn.position( temp );
+          extract.extract( isSwap, dataIn, extractTotals );
+          for( k = 0; k < components; k++ ) {
+            totals[k] += extractTotals[k] * percent;
+          }
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            temp += pixelSizeInBytes;
+            dataIn.position( temp );
+            extract.extract( isSwap, dataIn, extractTotals );
+            for( k = 0; k < components; k++ ) {
+              totals[k] += extractTotals[k] * y_percent;
+            }
+          }
+          temp += pixelSizeInBytes;
+          percent = y_percent * highx_float;
+          dataIn.position( temp );
+          extract.extract( isSwap, dataIn, extractTotals );
+          for( k = 0; k < components; k++ ) {
+            totals[k] += extractTotals[k] * percent;
+          }
+        } else {
+          percent = ( highy_float - lowy_float ) * ( highx_float - lowx_float );
+          temp = xindex + lowy_int * rowSizeInBytes;
+          dataIn.position( temp );
+          extract.extract( isSwap, dataIn, extractTotals );
+          for( k = 0; k < components; k++ ) {
+            totals[k] += extractTotals[k] * percent;
+          }
+        }
+        
+        // this is for the pixels in the body
+        temp0 = xindex + pixelSizeInBytes + ( lowy_int + 1 ) * rowSizeInBytes;
+        for( m = lowy_int + 1; m < highy_int; m++ ) {
+          temp = temp0;
+          for( l = lowx_int + 1; l < highx_int; l++ ) {
+            dataIn.position( temp );
+            extract.extract( isSwap, dataIn, extractTotals );
+            for( k = 0; k < components; k++ ) {
+              totals[k] += extractTotals[k] * percent;
+            }
+            temp += pixelSizeInBytes;
+          }
+          temp0 += rowSizeInBytes;
+        }
+        
+        outIndex = ( j + ( i * widthOut ) );
+        for( k = 0; k < components; k++ ) {
+          shoveTotals[k] = totals[k] / area;
+        }
+        extract.shove( shoveTotals, outIndex, dataOut );
+        lowx_int = highx_int;
+        lowx_float = highx_float;
+        highx_int += convx_int;
+        highx_float += convx_float;
+        if( highx_float > 1.0f ) {
+          highx_float -= 1.0f;
+          highx_int++;
+        }
+
+        // Clamp to make sure we don't run off the right edge
+        if (highx_int > widthIn - 1) {
+          int delta = (highx_int - widthIn + 1);
+          lowx_int -= delta;
+          highx_int -= delta;
+        }
+      }
+      lowy_int = highy_int;
+      lowy_float = highy_float;
+      highy_int += convy_int;
+      highy_float += convy_float;
+      if( highy_float > 1.0f ) {
+        highy_float -= 1.0f;
+        highy_int++;
+      }
+    }
+    assert( outIndex == ( widthOut * heightOut - 1) );
+  }
+  
+  public static void scaleInternal3D( int components, int widthIn, int heightIn,
+          int depthIn, ShortBuffer dataIn, int widthOut, int heightOut,
+          int depthOut, ShortBuffer dataOut ) {
+    float x, lowx, highx, convx, halfconvx;
+    float y, lowy, highy, convy, halfconvy;
+    float z, lowz, highz, convz, halfconvz;
+    float xpercent, ypercent, zpercent;
+    float percent;
+    // max compnents in a format is 4
+    float[] totals = new float[4];
+    float volume;
+    int i, j, d, k, zint, yint, xint, xindex, yindex, zindex;
+    int temp;
+    
+    lowy = highy = lowx = highx = 0.0f;
+    
+    convz = (float)depthIn / depthOut;
+    convy = (float)heightIn / heightOut;
+    convx = (float)widthIn / widthOut;
+    halfconvz = convz / 2.0f;
+    halfconvy = convy / 2.0f;
+    halfconvx = convx / 2.0f;
+    for( d = 0; d < depthOut; d++ ) {
+      z = convz * ( d + 0.5f );
+      if( depthIn > depthOut ) {
+        highz = z + halfconvz;
+        lowz = z - halfconvz;
+      } else {
+        highz = z + 0.5f;
+        lowz = z - 0.5f;
+      }
+      for( i = 0; i < heightOut; i++ ) {
+        y = convy * ( i + 0.5f );
+        if( heightIn > heightOut ) {
+          highz = y + halfconvy;
+          lowz = y - halfconvy;
+        } else {
+          highz = y + 0.5f;
+          lowz = y - 0.5f;
+        }
+        for( j = 0; j < widthOut; j++ ) {
+          x = convx * ( j + 0.5f );
+          if( depthIn > depthOut ) {
+            highz = x + halfconvx;
+            lowz = x - halfconvx;
+          } else {
+            highz = x + 0.5f;
+            lowz = x - 0.5f;
+          }
+          
+          // Ok, now apply box filter to box that goes from ( lowx, lowy, lowz )
+          // to ( highx, highy, highz ) on input data into this pixel on output data
+          
+          totals[0] = totals[1] = totals[2] = totals[3] = 0.0f;
+          volume = 0.0f;
+          
+          z = lowz;
+          zint = (int)(Math.floor( z ) );
+          while( z < highz ) {
+            zindex = ( zint + depthIn ) % depthIn;
+            if( highz < zint + 1 ) {
+              zpercent = highz - z;
+            } else {
+              zpercent = zint + 1 - z;
+            }
+            
+            y = lowy;
+            yint = (int)(Math.floor( y ) );
+            while( y < highy ) {
+              yindex = ( yint + heightIn ) % heightIn;
+              if( highy < yint + 1 ) {
+                ypercent = highy - y;
+              } else {
+                ypercent = yint + 1 - y;
+              }
+              
+              x = lowx;
+              xint = (int)(Math.floor( x ) );
+              
+              while( x < highx ) {
+                xindex = (xint + widthIn ) % widthIn;
+                if( highx < xint + 1 ) {
+                  xpercent = highx - x;
+                } else {
+                  xpercent = xint + 1 - x;
+                }
+                
+                percent = xpercent * ypercent * zpercent;
+                volume += percent;
+                
+                temp = (xindex + ( yindex *widthIn) + (zindex * widthIn *heightIn)) * components;
+                for( k = 0; k < components; k++ ) {
+                  assert( 0 <= (temp+k) && (temp+k) < (widthIn * heightIn * depthIn * components) );
+                  totals[k] += dataIn.get( temp + k ) * percent;
+                }
+                xint++;
+                x = xint;
+              } // while x
+              yint++;
+              y = yint;
+            } // while y
+            zint++;
+            z = zint;
+          } // while z
+          
+          temp = ( j + ( i * widthOut ) + (d * widthOut * heightOut ) ) * components;
+          for( k = 0; k < components; k++ ) {
+            // totals should be rounded in the case of enlarging an rgb ramp when the type is 332 or 4444
+            assert( 0 <= ( temp + k ) && ( temp + k ) < (widthOut * heightOut* depthOut * components) );
+            dataOut.put( temp + k, (short)((totals[k] + 0.5f) / volume ) );
+          }
+        }
+      }
+    }
+  }
+  
+  public static int gluScaleImage3D( GL gl, int format, int widthIn, int heightIn, 
+          int depthIn, int typeIn, ByteBuffer dataIn, int widthOut, int heightOut, 
+          int depthOut, int typeOut, ByteBuffer dataOut ) {
+    int components;
+    ShortBuffer beforeImage, afterImage;
+    PixelStorageModes psm = new PixelStorageModes();
+    
+    if( widthIn == 0 || heightIn == 0 || depthIn == 0 ||
+            widthOut == 0 || heightOut == 0 || depthOut == 0 ) {
+      return( 0 );
+    }
+    
+    if( widthIn < 0 || heightIn < 0 || depthIn < 0 ||
+            widthOut < 0 || heightOut < 0 || depthOut < 0 ) {
+      return( GLU.GLU_INVALID_VALUE );
+    }
+    
+    if( !Mipmap.legalFormat(format) || !Mipmap.legalType(typeIn) || 
+            !Mipmap.legalType(typeOut) || typeIn == GL2.GL_BITMAP ||
+            typeOut == GL2.GL_BITMAP ) {
+      return( GLU.GLU_INVALID_ENUM );
+    }
+    
+    if( !Mipmap.isLegalFormatForPackedPixelType( format, typeIn ) ) {
+      return( GLU.GLU_INVALID_OPERATION );
+    }
+    
+    if( !Mipmap.isLegalFormatForPackedPixelType( format, typeOut ) ) {
+      return( GLU.GLU_INVALID_OPERATION );
+    }
+    
+    try {
+    beforeImage = BufferUtil.nativeOrder(ByteBuffer.allocateDirect( Mipmap.imageSize3D( widthIn, 
+            heightIn, depthIn, format, GL2.GL_UNSIGNED_SHORT ) )).asShortBuffer();
+    afterImage = BufferUtil.nativeOrder(ByteBuffer.allocateDirect( Mipmap.imageSize3D( widthIn, 
+            heightIn, depthIn, format, GL2.GL_UNSIGNED_SHORT ) )).asShortBuffer();
+    } catch( OutOfMemoryError err ) {
+      return( GLU.GLU_OUT_OF_MEMORY );
+    }
+    Mipmap.retrieveStoreModes3D( gl, psm );
+    
+    Image.fillImage3D( psm, widthIn, heightIn, depthIn, format, typeIn,
+            Mipmap.is_index( format ), dataIn, beforeImage );
+    components = Mipmap.elements_per_group( format, 0 );
+    ScaleInternal.scaleInternal3D( components, widthIn, heightIn, depthIn,
+            beforeImage, widthOut, heightOut, depthOut, afterImage );
+    Image.emptyImage3D( psm, widthOut, heightOut, depthOut, format, typeOut,
+            Mipmap.is_index( format ), afterImage, dataOut );
+    
+    return( 0 );
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Type_Widget.java b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Type_Widget.java
new file mode 100644
index 000000000..d5c6768b3
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/mipmap/Type_Widget.java
@@ -0,0 +1,224 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.mipmap;
+
+import java.nio.*;
+
+/**
+ *
+ * @author  Administrator
+ */
+public class Type_Widget {
+  
+  ByteBuffer buffer;
+  
+  /** Creates a new instance of Type_Widget */
+  public Type_Widget() {
+    buffer = ByteBuffer.allocateDirect( 4 );
+  }
+  
+  public void setUB0( byte b ) {
+    buffer.position( 0 );
+    buffer.put( b );
+  }
+  
+  public byte getUB0() {
+    buffer.position( 0 );
+    return( buffer.get() );
+  }
+  
+  public void setUB1( byte b ) {
+    buffer.position( 1 );
+    buffer.put( b );
+  }
+  
+  public byte getUB1() {
+    buffer.position( 1 );
+    return( buffer.get() );
+  }
+  
+  public void setUB2( byte b ) {
+    buffer.position( 2 );
+    buffer.put( b );
+  }
+  
+  public byte getUB2() {
+    buffer.position( 2 );
+    return( buffer.get() );
+  }
+  
+  public void setUB3( byte b ) {
+    buffer.position( 3 );
+    buffer.put( b );
+  }
+  
+  public byte getUB3() {
+    buffer.position( 3 );
+    return( buffer.get() );
+  }
+  
+  public void setUS0( short s ) {
+    buffer.position( 0 );
+    buffer.putShort( s );
+  }
+  
+  public short getUS0() {
+    buffer.position( 0 );
+    return( buffer.getShort() );
+  }
+  
+  public void setUS1( short s ) {
+    buffer.position( 2 );
+    buffer.putShort( s );
+  }
+  
+  public short getUS1() {
+   buffer.position( 2 );
+   return( buffer.getShort() );
+  }
+  
+  public void setUI( int i ) {
+    buffer.position( 0 );
+    buffer.putInt( i );
+  }
+  
+  public int getUI() {
+    buffer.position( 0 );
+    return( buffer.getInt() );
+  }
+  
+  public void setB0( byte b ) {
+    buffer.position( 0 );
+    buffer.put( b );
+  }
+  
+  public byte getB0() {
+    buffer.position( 0 );
+    return( buffer.get() );
+  }
+  
+  public void setB1( byte b ) {
+    buffer.position( 1 );
+    buffer.put( b );
+  }
+  
+  public byte getB1() {
+    buffer.position( 1 );
+    return( buffer.get() );
+  }
+  
+  public void setB2( byte b ) {
+    buffer.position( 2 );
+    buffer.put( b );
+  }
+  
+  public byte getB2() {
+    buffer.position( 2 );
+    return( buffer.get() );
+  }
+  
+  public void setB3( byte b ) {
+    buffer.position( 3 );
+    buffer.put( b );
+  }
+  
+  public byte getB3() {
+    buffer.position( 3 );
+    return( buffer.get() );
+  }
+  
+  public void setS0( short s ) {
+    buffer.position( 0 );
+    buffer.putShort( s );
+  }
+  
+  public short getS0() {
+    buffer.position( 0 );
+    return( buffer.getShort() );
+  }
+  
+  public void setS1( short s ) {
+    buffer.position( 2 );
+    buffer.putShort( s );
+  }
+  
+  public short getS1() {
+    buffer.position( 2 );
+    return( buffer.getShort() );
+  }
+  
+  public void setI( int i ) {
+    buffer.position( 0 );
+    buffer.putInt( i );
+  }
+  
+  public int getI() {
+    buffer.position( 0 );
+    return( buffer.getInt() );
+  }
+  
+  public void setF( float f ) {
+    buffer.position( 0 );
+    buffer.putFloat( f );
+  }
+  
+  public float getF() {
+    buffer.position( 0 );
+    return( buffer.getFloat() );
+  }
+  
+  public ByteBuffer getBuffer() {
+    buffer.rewind();
+    return( buffer );
+  }
+  
+  public static void main( String args[] ) {
+    Type_Widget t = new Type_Widget();
+    t.setI( 1000000 );
+    
+    System.out.println("int: " + Integer.toHexString( t.getI() ) );
+    
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Arc.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Arc.java
new file mode 100755
index 000000000..e96aa83f8
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Arc.java
@@ -0,0 +1,258 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+*/
+
+/**
+ * Trimming arc
+ * @author Tomas Hrasky
+ *
+ */
+public class Arc {
+  /**
+   * Corresponding picewise-linear arc
+   */
+  public PwlArc pwlArc;
+
+  /**
+   * Arc type
+   */
+  private long type;
+
+  /**
+   * Arc link in linked list
+   */
+  public Arc link;
+
+  /**
+   * Previous arc
+   */
+  Arc prev;
+
+  /**
+   * Next arc
+   */
+  Arc next;
+
+  /**
+   * Corresponding berizer type arc
+   */
+  private BezierArc bezierArc;
+
+  /**
+   * Makes new arc at specified side
+   * 
+   * @param side
+   *            which side doeas this arc form
+   */
+  public Arc(int side) {
+    bezierArc = null;
+    pwlArc = null;
+    type = 0;
+    setside(side);
+    // nuid=_nuid
+  }
+
+  /**
+   * Sets side the arc is at
+   * 
+   * @param side
+   *            arc side
+   */
+  private void setside(int side) {
+    // DONE
+    clearside();
+    type |= side << 8;
+  }
+
+  /**
+   * Unsets side
+   */
+  private void clearside() {
+    // DONE
+    type &= ~(0x7 << 8);
+  }
+
+  // this one replaces enum arc_side 
+  /**
+   * Side not specified
+   */
+  public static final int ARC_NONE = 0;
+
+  /**
+   * Arc on right
+   */
+  public static final int ARC_RIGHT = 1;
+
+  /**
+   * Arc on top
+   */
+  public static final int ARC_TOP = 2;
+
+  /**
+   * Arc on left
+   */
+  public static final int ARC_LEFT = 3;
+
+  /**
+   * Arc on bottom
+   */
+  public static final int ARC_BOTTOM = 4;
+
+  /**
+   * Bezier type flag
+   */
+  private static final long BEZIER_TAG = 1 << 13;
+
+  /**
+   * Arc type flag
+   */
+  private static final long ARC_TAG = 1 << 3;
+
+  /**
+   * Tail type tag
+   */
+  private static final long TAIL_TAG = 1 << 6;
+
+  /**
+   * Appends arc to the list
+   * 
+   * @param jarc
+   *            arc to be append
+   * @return this
+   */
+  public Arc append(Arc jarc) {
+    // DONE
+    if (jarc != null) {
+      next = jarc.next;
+      prev = jarc;
+      next.prev = this;
+      prev.next = this;
+    } else {
+      next = this;
+      prev = this;
+    }
+
+    return this;
+  }
+
+  /**
+   * Unused
+   * 
+   * @return true
+   */
+  public boolean check() {
+    return true;
+  }
+
+  /**
+   * Sets bezier type flag
+   */
+  public void setbezier() {
+    // DONE
+    type |= BEZIER_TAG;
+
+  }
+
+  /**
+   * Returns tail of linked list coords
+   * 
+   * @return tail coords
+   */
+  public float[] tail() {
+    // DONE
+    return pwlArc.pts[0].param;
+  }
+
+  /**
+   * Returns head of linked list coords
+   * 
+   * @return head coords
+   */
+  public float[] head() {
+    // DONE
+    return next.pwlArc.pts[0].param;
+  }
+
+  /**
+   * Returns whether arc is marked with arc_tag
+   * 
+   * @return is arc marked with arc_tag
+   */
+  public boolean ismarked() {
+    // DONE
+    return ((type & ARC_TAG) > 0) ? true : false;
+  }
+
+  /**
+   * Cleans arc_tag flag
+   */
+  public void clearmark() {
+    // DONE
+    type &= (~ARC_TAG);
+  }
+
+  /**
+   * Sets arc_tag flag
+   */
+  public void setmark() {
+    // DONE
+    type |= ARC_TAG;
+  }
+
+  /**
+   * sets tail tag
+   */
+  public void setitail() {
+    // DONE
+    type |= TAIL_TAG;
+  }
+
+  /**
+   * Returns whether arc is marked tail
+   * 
+   * @return is tail
+   */
+  public boolean getitail() {
+    return false;
+  }
+
+  /**
+   * Unsets tail tag
+   */
+  public void clearitail() {
+    // DONE
+    type &= (~TAIL_TAG);
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/ArcSdirSorter.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/ArcSdirSorter.java
new file mode 100755
index 000000000..f8fbe2930
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/ArcSdirSorter.java
@@ -0,0 +1,63 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Class for sorting list of Arcs
+ * @author Tomas Hrasky
+ *
+ */
+public class ArcSdirSorter {
+
+  /**
+   * Makes new ArcSdirSorter with Subdivider
+   * @param subdivider subdivider
+   */ 
+  public ArcSdirSorter(Subdivider subdivider) {
+    //TODO
+    //			System.out.println("TODO arcsdirsorter.constructor");
+  }
+
+  /**
+   * Sorts list of arcs
+   * @param list  arc list to be sorted
+   * @param count size of list
+   */
+  public void qsort(CArrayOfArcs list, int count) {
+    // TODO
+    //			System.out.println("TODO arcsdirsorter.qsort");
+  }
+
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/ArcTdirSorter.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/ArcTdirSorter.java
new file mode 100755
index 000000000..9e9a10b42
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/ArcTdirSorter.java
@@ -0,0 +1,60 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Class for sorting list of Arcs
+ * @author Tomas Hrasky
+ *
+ */
+public class ArcTdirSorter {
+  /**
+   * Makes new ArcSdirSorter with Subdivider
+   * @param subdivider subdivider
+   */ 
+  public ArcTdirSorter(Subdivider subdivider) {
+    // TODO Auto-generated constructor stub
+    //			System.out.println("TODO arcTsorter.konstruktor");
+  }
+  /**
+   * Sorts list of arcs
+   * @param list  arc list to be sorted
+   * @param count size of list
+   */
+  public void qsort(CArrayOfArcs list, int count) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO arcTsorter.qsort");
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/ArcTesselator.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/ArcTesselator.java
new file mode 100755
index 000000000..496e8b7d6
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/ArcTesselator.java
@@ -0,0 +1,90 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Class for arc tesselation
+ * @author Tomas Hrasky
+ *
+ */
+public class ArcTesselator {
+
+  /**
+   * Makes given arc an bezier arc
+   * @param arc arc to work with
+   * @param s1 minimum s param
+   * @param s2 maximum s param
+   * @param t1 minimum t param
+   * @param t2 maximum s param
+   */
+  public void bezier(Arc arc, float s1, float s2, float t1, float t2) {
+    // DONE
+    TrimVertex[] p = new TrimVertex[2];
+    p[0] = new TrimVertex();
+    p[1] = new TrimVertex();
+    arc.pwlArc = new PwlArc(2, p);
+    p[0].param[0] = s1;
+    p[0].param[1] = s2;
+    p[1].param[0] = t1;
+    p[1].param[1] = t2;
+    arc.setbezier();
+  }
+
+  /**
+   * Empty method
+   * @param newright arc to work with
+   * @param s first tail
+   * @param t2 second tail
+   * @param t1 third tail
+   * @param f stepsize
+   */
+  public void pwl_right(Arc newright, float s, float t1, float t2, float f) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO arctesselator.pwl_right");
+  }
+
+  /**
+   * Empty method
+   * @param newright arc to work with
+   * @param s first tail
+   * @param t2 second tail
+   * @param t1 third tail
+   * @param f stepsize
+   */
+  public void pwl_left(Arc newright, float s, float t2, float t1, float f) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO arctesselator.pwl_left");
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Backend.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Backend.java
new file mode 100755
index 000000000..9467104f5
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Backend.java
@@ -0,0 +1,217 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Class responsible for rendering
+ * @author Tomas Hrasky
+ *
+ */
+public abstract class Backend {
+
+  /**
+   * Fill surface
+   */
+  public static final int N_MESHFILL = 0;
+
+  /**
+   * Draw surface as wire model
+   */
+  public static final int N_MESHLINE = 1;
+
+  /**
+   * Draw surface with points
+   */
+  public static final int N_MESHPOINT = 2;
+
+  /**
+   * Object rendering curves
+   */
+  protected CurveEvaluator curveEvaluator;
+
+  /**
+   * Object rendering surfaces
+   */
+  protected SurfaceEvaluator surfaceEvaluator;
+
+  /**
+   * Makes new backend 
+   */
+  public Backend() {
+    // curveEvaluator = new OpenGLCurveEvaluator();
+    // surfaceEvaluator = new OpenGLSurfaceEvaluator();
+  }
+
+  /**
+   * Begin a curve
+   */
+  public void bgncurv() {
+    // DONE
+    curveEvaluator.bgnmap1f();
+
+  }
+
+  /**
+   * End a curve
+   */
+  public void endcurv() {
+    // DONE
+    curveEvaluator.endmap1f();
+
+  }
+
+  /**
+   * Make cuve with given parameters
+   * @param type curve type
+   * @param ps control points
+   * @param stride control points coordinates number
+   * @param order order of curve
+   * @param ulo smallest u
+   * @param uhi highest u
+   */
+  public void curvpts(int type, CArrayOfFloats ps, int stride, int order,
+                      float ulo, float uhi) {
+    // DONE
+    curveEvaluator.map1f(type, ulo, uhi, stride, order, ps);
+    curveEvaluator.enable(type);
+  }
+
+  /**
+   * Draw curve
+   * @param u1 smallest u
+   * @param u2 highest u
+   * @param nu number of pieces
+   */
+  public void curvgrid(float u1, float u2, int nu) {
+    // DONE
+    curveEvaluator.mapgrid1f(nu, u1, u2);
+
+  }
+
+  /**
+   * Evaluates curve mesh
+   * @param from low param
+   * @param n step
+   */
+  public void curvmesh(int from, int n) {
+    // DONE
+    curveEvaluator.mapmesh1f(N_MESHFILL, from, from + n);
+  }
+
+  /**
+   * Begin surface
+   * @param wiretris use triangles
+   * @param wirequads use quads
+   */
+  public void bgnsurf(int wiretris, int wirequads) {
+    // DONE
+    surfaceEvaluator.bgnmap2f();
+
+    if (wiretris > 0)
+      surfaceEvaluator.polymode(NurbsConsts.N_MESHLINE);
+    else
+      surfaceEvaluator.polymode(NurbsConsts.N_MESHFILL);
+  }
+
+  /**
+   * End surface
+   */
+  public void endsurf() {
+    // DONE
+    surfaceEvaluator.endmap2f();
+  }
+
+  /**
+   * Empty method
+   * @param ulo low u param
+   * @param uhi hig u param
+   * @param vlo low v param
+   * @param vhi high v param
+   */
+  public void patch(float ulo, float uhi, float vlo, float vhi) {
+    // DONE
+    surfaceEvaluator.domain2f(ulo, uhi, vlo, vhi);
+  }
+
+  /**
+   * Draw surface
+   * @param u0 lowest u
+   * @param u1 highest u
+   * @param nu number of pieces in u direction
+   * @param v0 lowest v
+   * @param v1 highest v
+   * @param nv number of pieces in v direction
+   */
+  public void surfgrid(float u0, float u1, int nu, float v0, float v1, int nv) {
+    // DONE
+    surfaceEvaluator.mapgrid2f(nu, u0, u1, nv, v0, v1);
+
+  }
+
+  /**
+   * Evaluates surface mesh
+   * @param u u param
+   * @param v v param
+   * @param n step in u direction
+   * @param m step in v direction
+   */
+  public void surfmesh(int u, int v, int n, int m) {
+    //			System.out.println("TODO backend.surfmesh wireframequads");
+    // TODO wireframequads
+    surfaceEvaluator.mapmesh2f(NurbsConsts.N_MESHFILL, u, u + n, v, v + m);
+  }
+
+  /**
+   * Make surface
+   * @param type surface type
+   * @param pts control points
+   * @param ustride control points coordinates in u direction
+   * @param vstride control points coordinates in v direction
+   * @param uorder surface order in u direction
+   * @param vorder surface order in v direction
+   * @param ulo lowest u
+   * @param uhi hightest u
+   * @param vlo lowest v
+   * @param vhi hightest v
+   */
+  public void surfpts(int type, CArrayOfFloats pts, int ustride, int vstride,
+                      int uorder, int vorder, float ulo, float uhi, float vlo, float vhi) {
+    // DONE
+    surfaceEvaluator.map2f(type, ulo, uhi, ustride, uorder, vlo, vhi,
+                           vstride, vorder, pts);
+    surfaceEvaluator.enable(type);
+
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/BezierArc.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/BezierArc.java
new file mode 100755
index 000000000..ef4cf0684
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/BezierArc.java
@@ -0,0 +1,44 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Empty class
+ * @author Tomas Hrasky
+ *
+ */
+public class BezierArc {
+
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Bin.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Bin.java
new file mode 100755
index 000000000..0f0806d96
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Bin.java
@@ -0,0 +1,155 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Class holding trimming arcs
+ * @author Tomas Hrasky
+ *
+ */
+public class Bin {
+
+  /**
+   * Head of linked list of arcs
+   */
+  private Arc head;
+
+  /**
+   * Current arc
+   */
+  private Arc current;
+
+  /**
+   * Indicates whether there are any Arcs in linked list
+   * @return true if there are any Arcs in linked list
+   */
+  public boolean isnonempty() {
+    // DONE
+    return this.head != null ? true : false;
+  }
+
+  /**
+   * Adds and arc to linked list
+   * @param jarc added arc
+   */
+  public void addarc(Arc jarc) {
+    // DONE
+    // if (head == null)
+    // head = jarc;
+    // else {
+    jarc.link = head;
+    head = jarc;
+    // }
+
+  }
+
+  /**
+   * Returns number of arcs in linked list
+   * @return number of arcs
+   */
+  public int numarcs() {
+    // DONE
+    int count = 0;
+    for (Arc jarc = firstarc(); jarc != null; jarc = nextarc())
+      count++;
+    return count;
+  }
+
+  /**
+   * Removes first arc in list
+   * @return new linked list head
+   */
+  public Arc removearc() {
+    // DONE
+    Arc jarc = head;
+    if (jarc != null)
+      head = jarc.link;
+    return jarc;
+
+  }
+
+  /**
+   * Consolidates linked list
+   */
+  public void adopt() {
+    // DONE
+    markall();
+
+    Arc orphan;
+    while ((orphan = removearc()) != null) {
+      for (Arc parent = orphan.next; !parent.equals(orphan); parent = parent.next) {
+        if (!parent.ismarked()) {
+          orphan.link = parent.link;
+          parent.link = orphan;
+          orphan.clearmark();
+          break;
+        }
+      }
+    }
+
+  }
+
+  /**
+   * Marks all arc in linked list
+   */
+  private void markall() {
+    // DONE
+    for (Arc jarc = firstarc(); jarc != null; jarc = nextarc())
+      jarc.setmark();
+  }
+
+  /**
+   * Returns first arc in linked list
+   * @return first arc in linked list
+   */
+  private Arc firstarc() {
+    // DONE
+    current = head;
+    return nextarc();
+  }
+
+  /**
+   * Returns next arc in linked list
+   * @return next arc
+   * 
+   */
+  private Arc nextarc() {
+    // DONE
+    Arc jarc = current;
+    if (jarc != null)
+      current = jarc.link;
+    return jarc;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Breakpt.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Breakpt.java
new file mode 100755
index 000000000..9cccc5102
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Breakpt.java
@@ -0,0 +1,59 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Class holding break point parameters
+ * 
+ * @author Tomas Hrasky
+ * 
+ */
+public class Breakpt {
+
+  /**
+   * Breakpoint multiplicity
+   */
+  public int multi;
+
+  /**
+   * Breakpint value
+   */
+  public float value;
+
+  /**
+   * Breakpoint deficit (how many times it has to be added)
+   */
+  public int def;
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/CArrayOfArcs.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/CArrayOfArcs.java
new file mode 100755
index 000000000..3d6e1d47f
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/CArrayOfArcs.java
@@ -0,0 +1,194 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/**
+ * Class replacing C language pointer
+ * 
+ * @author Tomas Hrasky
+ * 
+ */
+public class CArrayOfArcs {
+  /**
+   * Underlaying array
+   */
+  private Arc[] array;
+
+  /**
+   * Pointer to array member
+   */
+  private int pointer;
+
+  /**
+   * Don't check for array borders?
+   */
+  private boolean noCheck = true;
+
+  /**
+   * Makes new CArray
+   * 
+   * @param array
+   *            underlaying array
+   * @param pointer
+   *            pointer (index) to array
+   */
+  public CArrayOfArcs(Arc[] array, int pointer) {
+    this.array = array;
+    // this.pointer=pointer;
+    setPointer(pointer);
+  }
+
+  /**
+   * Makes new CArray from other CArray
+   * 
+   * @param carray
+   *            reference array
+   */
+  public CArrayOfArcs(CArrayOfArcs carray) {
+    this.array = carray.array;
+    // this.pointer=carray.pointer;
+    setPointer(carray.pointer);
+  }
+
+  /**
+   * Makes new CArray with pointer set to 0
+   * 
+   * @param ctlarray
+   *            underlaying array
+   */
+  public CArrayOfArcs(Arc[] ctlarray) {
+    this.array = ctlarray;
+    this.pointer = 0;
+  }
+
+  /**
+   * Returns element at pointer
+   * 
+   * @return element at pointer
+   */
+  public Arc get() {
+    return array[pointer];
+  }
+
+  /**
+   * Increases pointer by one (++)
+   */
+  public void pp() {
+    // pointer++;
+    setPointer(pointer + 1);
+  }
+
+  /**
+   * Sets element at pointer
+   * 
+   * @param f
+   *            desired value
+   */
+  public void set(Arc f) {
+    array[pointer] = f;
+
+  }
+
+  /**
+   * Returns array element at specified index
+   * 
+   * @param i
+   *            array index
+   * @return element at index
+   */
+  public Arc get(int i) {
+    return array[i];
+  }
+
+  /**
+   * Returns array element at specified index relatively to pointer
+   * 
+   * @param i
+   *            relative index
+   * @return element at relative index
+   */
+  public Arc getRelative(int i) {
+    return array[pointer + i];
+  }
+
+  /**
+   * Sets value of element at specified index relatively to pointer
+   * 
+   * @param i
+   *            relative index
+   * @param value
+   *            value to be set
+   */
+  public void setRelative(int i, Arc value) {
+    array[pointer + i] = value;
+  }
+
+  /**
+   * Lessens pointer by value
+   * 
+   * @param i
+   *            lessen by
+   */
+  public void lessenPointerBy(int i) {
+    // pointer-=i;
+    setPointer(pointer - i);
+  }
+
+  /**
+   * Returns pointer value
+   * 
+   * @return pointer value
+   */
+  public int getPointer() {
+    return pointer;
+  }
+
+  /**
+   * Sets ponter value
+   * 
+   * @param pointer
+   *            pointer value to be set
+   */
+  public void setPointer(int pointer) {
+    if (!noCheck && pointer > array.length)
+      throw new IllegalArgumentException("Pointer " + pointer
+                                         + " out of bounds " + array.length);
+    this.pointer = pointer;
+  }
+
+  /**
+   * Raises pointer by value
+   * 
+   * @param i
+   *            raise by
+   */
+  public void raisePointerBy(int i) {
+    // pointer+=i;
+    setPointer(pointer + i);
+  }
+
+  /**
+   * Lessens ponter by one (--)
+   */
+  public void mm() {
+    // pointer--;
+    setPointer(pointer - 1);
+  }
+
+  /**
+   * Returns underlaying array
+   * 
+   * @return underlaying array
+   */
+  public Arc[] getArray() {
+    return array;
+  }
+
+  /**
+   * Sets underlaying array
+   * 
+   * @param array
+   *            underlaying array
+   */
+  public void setArray(Arc[] array) {
+    this.array = array;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/CArrayOfBreakpts.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/CArrayOfBreakpts.java
new file mode 100755
index 000000000..f5932d954
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/CArrayOfBreakpts.java
@@ -0,0 +1,130 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/**
+ * Class replacing C language pointer
+ * 
+ * @author Tomas Hrasky
+ * 
+ */
+public class CArrayOfBreakpts {
+  /**
+   * Underlaying array
+   */
+  private Breakpt[] pole;
+
+  /**
+   * Pointer to array member
+   */
+  private int pointer;
+
+  /**
+   * Makes new CArray
+   * 
+   * @param array
+   *            underlaying array
+   * @param pointer
+   *            pointer (index) to array
+   */
+  public CArrayOfBreakpts(Breakpt[] array, int pointer) {
+    this.pole = array;
+    this.pointer = pointer;
+  }
+
+  /**
+   * Makes new CArray from other CArray
+   * 
+   * @param carray
+   *            reference array
+   */
+  public CArrayOfBreakpts(CArrayOfBreakpts carray) {
+    this.pole = carray.pole;
+    this.pointer = carray.pointer;
+  }
+
+  /**
+   * Returns element at pointer
+   * 
+   * @return element at pointer
+   */
+  public Breakpt get() {
+    return pole[pointer];
+  }
+
+  /**
+   * Increases pointer by one (++)
+   */
+  public void pp() {
+    pointer++;
+  }
+
+  /**
+   * Sets element at pointer
+   * 
+   * @param f
+   *            desired value
+   */
+  public void set(Breakpt f) {
+    pole[pointer] = f;
+
+  }
+
+  /**
+   * Returns array element at specified index
+   * 
+   * @param i
+   *            array index
+   * @return element at index
+   */
+  public Breakpt get(int i) {
+    return pole[i];
+  }
+
+  /**
+   * Lessens pointer by value
+   * 
+   * @param i
+   *            lessen by
+   */
+  public void lessenPointerBy(int i) {
+    pointer -= i;
+
+  }
+
+  /**
+   * Returns pointer value
+   * 
+   * @return pointer value
+   */
+  public int getPointer() {
+    return pointer;
+  }
+
+  /**
+   * Sets ponter value
+   * 
+   * @param pointer
+   *            pointer value to be set
+   */
+  public void setPointer(int pointer) {
+    this.pointer = pointer;
+  }
+
+  /**
+   * Raises pointer by value
+   * 
+   * @param i
+   *            raise by
+   */
+  public void raisePointerBy(int i) {
+    pointer += i;
+
+  }
+
+  /**
+   * Lessens ponter by one (--)
+   */
+  public void mm() {
+    pointer--;
+
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/CArrayOfFloats.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/CArrayOfFloats.java
new file mode 100755
index 000000000..fb3fac69b
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/CArrayOfFloats.java
@@ -0,0 +1,195 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/**
+ * Class replacing C language pointer
+ * 
+ * @author Tomas Hrasky
+ * 
+ */
+public class CArrayOfFloats {
+
+  /**
+   * Underlaying array
+   */
+  private float[] array;
+
+  /**
+   * Pointer to array member
+   */
+  private int pointer;
+
+  /**
+   * Don't check for array borders?
+   */
+  private boolean noCheck = true;
+
+  /**
+   * Makes new CArray
+   * 
+   * @param array
+   *            underlaying array
+   * @param pointer
+   *            pointer (index) to array
+   */
+  public CArrayOfFloats(float[] array, int pointer) {
+    this.array = array;
+    // this.pointer=pointer;
+    setPointer(pointer);
+  }
+
+  /**
+   * Makes new CArray from other CArray
+   * 
+   * @param carray
+   *            reference array
+   */
+  public CArrayOfFloats(CArrayOfFloats carray) {
+    this.array = carray.array;
+    // this.pointer=carray.pointer;
+    setPointer(carray.pointer);
+  }
+
+  /**
+   * Makes new CArray with pointer set to 0
+   * 
+   * @param ctlarray
+   *            underlaying array
+   */
+  public CArrayOfFloats(float[] ctlarray) {
+    this.array = ctlarray;
+    this.pointer = 0;
+  }
+
+  /**
+   * Returns element at pointer
+   * 
+   * @return element at pointer
+   */
+  public float get() {
+    return array[pointer];
+  }
+
+  /**
+   * Increases pointer by one (++)
+   */
+  public void pp() {
+    // pointer++;
+    setPointer(pointer + 1);
+  }
+
+  /**
+   * Sets element at pointer
+   * 
+   * @param f
+   *            desired value
+   */
+  public void set(float f) {
+    array[pointer] = f;
+
+  }
+
+  /**
+   * Returns array element at specified index
+   * 
+   * @param i
+   *            array index
+   * @return element at index
+   */
+  public float get(int i) {
+    return array[i];
+  }
+
+  /**
+   * Returns array element at specified index relatively to pointer
+   * 
+   * @param i
+   *            relative index
+   * @return element at relative index
+   */
+  public float getRelative(int i) {
+    return array[pointer + i];
+  }
+
+  /**
+   * Sets value of element at specified index relatively to pointer
+   * 
+   * @param i
+   *            relative index
+   * @param value
+   *            value to be set
+   */
+  public void setRelative(int i, float value) {
+    array[pointer + i] = value;
+  }
+
+  /**
+   * Lessens pointer by value
+   * 
+   * @param i
+   *            lessen by
+   */
+  public void lessenPointerBy(int i) {
+    // pointer-=i;
+    setPointer(pointer - i);
+  }
+
+  /**
+   * Returns pointer value
+   * 
+   * @return pointer value
+   */
+  public int getPointer() {
+    return pointer;
+  }
+
+  /**
+   * Sets ponter value
+   * 
+   * @param pointer
+   *            pointer value to be set
+   */
+  public void setPointer(int pointer) {
+    if (!noCheck && pointer > array.length)
+      throw new IllegalArgumentException("Pointer " + pointer
+                                         + " out of bounds " + array.length);
+    this.pointer = pointer;
+  }
+
+  /**
+   * Raises pointer by value
+   * 
+   * @param i
+   *            raise by
+   */
+  public void raisePointerBy(int i) {
+    // pointer+=i;
+    setPointer(pointer + i);
+  }
+
+  /**
+   * Lessens ponter by one (--)
+   */
+  public void mm() {
+    // pointer--;
+    setPointer(pointer - 1);
+  }
+
+  /**
+   * Returns underlaying array
+   * 
+   * @return underlaying array
+   */
+  public float[] getArray() {
+    return array;
+  }
+
+  /**
+   * Sets underlaying array
+   * 
+   * @param array
+   *            underlaying array
+   */
+  public void setArray(float[] array) {
+    this.array = array;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/CArrayOfQuiltspecs.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/CArrayOfQuiltspecs.java
new file mode 100755
index 000000000..fed301895
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/CArrayOfQuiltspecs.java
@@ -0,0 +1,160 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/**
+ * Class replacing C language pointer
+ * 
+ * @author Tomas Hrasky
+ * 
+ */
+public class CArrayOfQuiltspecs {
+  /**
+   * Underlaying array
+   */
+  private Quiltspec[] array;
+
+  /**
+   * Pointer to array member
+   */
+  private int pointer;
+
+  /**
+   * Makes new CArray
+   * 
+   * @param array
+   *            underlaying array
+   * @param pointer
+   *            pointer (index) to array
+   */
+  public CArrayOfQuiltspecs(Quiltspec[] array, int pointer) {
+    this.array = array;
+    this.pointer = pointer;
+  }
+
+  /**
+   * Makes new CArray from other CArray
+   * 
+   * @param carray
+   *            reference array
+   */
+  public CArrayOfQuiltspecs(CArrayOfQuiltspecs carray) {
+    this.array = carray.array;
+    this.pointer = carray.pointer;
+  }
+
+  /**
+   * Makes new CArray with pointer set to 0
+   * 
+   * @param array
+   *            underlaying array
+   */
+  public CArrayOfQuiltspecs(Quiltspec[] array) {
+    this.array = array;
+    this.pointer = 0;
+  }
+
+  /**
+   * Returns element at pointer
+   * 
+   * @return element at pointer
+   */
+  public Quiltspec get() {
+    return array[pointer];
+  }
+
+  /**
+   * Increases pointer by one (++)
+   */
+  public void pp() {
+    pointer++;
+  }
+
+  /**
+   * Sets element at pointer
+   * 
+   * @param f
+   *            desired value
+   */
+  public void set(Quiltspec f) {
+    array[pointer] = f;
+
+  }
+
+  /**
+   * Returns array element at specified index
+   * 
+   * @param i
+   *            array index
+   * @return element at index
+   */
+  public Quiltspec get(int i) {
+    return array[i];
+  }
+
+  /**
+   * Lessens pointer by value
+   * 
+   * @param i
+   *            lessen by
+   */
+  public void lessenPointerBy(int i) {
+    pointer -= i;
+
+  }
+
+  /**
+   * Returns pointer value
+   * 
+   * @return pointer value
+   */
+  public int getPointer() {
+    return pointer;
+  }
+
+  /**
+   * Sets ponter value
+   * 
+   * @param pointer
+   *            pointer value to be set
+   */
+  public void setPointer(int pointer) {
+    this.pointer = pointer;
+  }
+
+  /**
+   * Raises pointer by value
+   * 
+   * @param i
+   *            raise by
+   */
+  public void raisePointerBy(int i) {
+    pointer += i;
+
+  }
+
+  /**
+   * Lessens ponter by one (--)
+   */
+  public void mm() {
+    pointer--;
+
+  }
+
+  /**
+   * Returns underlaying array
+   * 
+   * @return underlaying array
+   */
+  public Quiltspec[] getArray() {
+    return array;
+  }
+
+  /**
+   * Sets underlaying array
+   * 
+   * @param array
+   *            underlaying array
+   */
+  public void setArray(Quiltspec[] array) {
+    this.array = array;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Curve.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Curve.java
new file mode 100755
index 000000000..318c8416c
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Curve.java
@@ -0,0 +1,238 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Class holding curve definition
+ * @author Tomáš Hráský
+ *
+ */
+public class Curve {
+
+  /**
+   * Maximum coordinates per control point
+   */
+  private static final int MAXCOORDS = 5;
+
+  /**
+   * Max curve order
+   */
+  private static final int MAXORDER = 24;
+
+  /**
+   * Next curve in linked list
+   */
+  public Curve next;
+
+  /**
+   * OpenGL maps
+   */
+  private Mapdesc mapdesc;
+
+  /**
+   * Does the curve need sampling
+   */
+  private boolean needsSampling;
+
+  /**
+   * Culling
+   */
+  private int cullval;
+
+  /**
+   * Number of coords
+   */
+  private int stride;
+
+  /**
+   * Curve order
+   */
+  private int order;
+
+  /**
+   * Holds conversion range borders
+   */
+  private float[] range;
+
+  /**
+   * Subdivision stepsize
+   */
+  public float stepsize;
+
+  /**
+   * Minimal subdivision stepsize
+   */
+  private float minstepsize;
+
+  /**
+   * Sampling points
+   */
+  float[] spts;
+
+  /**
+   * Makes new Curve
+   * 
+   * @param geo
+   * @param pta
+   * @param ptb
+   * @param c
+   *            next curve in linked list
+   */
+  public Curve(Quilt geo, float[] pta, float[] ptb, Curve c) {
+
+    spts = new float[MAXORDER * MAXCOORDS];
+
+    mapdesc = geo.mapdesc;
+
+    next = c;
+    needsSampling = mapdesc.isRangeSampling() ? true : false;
+
+    cullval = mapdesc.isCulling() ? Subdivider.CULL_ACCEPT
+      : Subdivider.CULL_TRIVIAL_REJECT;
+    order = geo.qspec.get(0).order;
+    stride = MAXCOORDS;
+
+    // CArrayOfFloats ps = geo.cpts;
+    CArrayOfFloats ps = new CArrayOfFloats(geo.cpts.getArray(), 0);
+    CArrayOfQuiltspecs qs = geo.qspec;
+    ps.raisePointerBy(qs.get().offset);
+    ps.raisePointerBy(qs.get().index * qs.get().order * qs.get().stride);
+
+    if (needsSampling) {
+      mapdesc.xformSampling(ps, qs.get().order, qs.get().stride, spts,
+                            stride);
+    }
+    if (cullval == Subdivider.CULL_ACCEPT) {
+      //				System.out.println("TODO curve.Curve-cullval");
+      // mapdesc.xformCulling(ps,qs.get().order,qs.get().stride,cpts,stride);
+    }
+
+    range = new float[3];
+    range[0] = qs.get().breakpoints[qs.get().index];
+    range[1] = qs.get().breakpoints[qs.get().index + 1];
+    range[2] = range[1] - range[0];
+    // TODO it is necessary to solve problem with "this" pointer here 
+    if (range[0] != pta[0]) {
+      //				System.out.println("TODO curve.Curve-range0");
+      // Curve lower=new Curve(this,pta,0);
+      // lower.next=next;
+      // this=lower;
+    }
+    if (range[1] != ptb[0]) {
+      //				System.out.println("TODO curve.Curve-range1");
+      // Curve lower=new Curve(this,ptb,0);
+    }
+  }
+
+  /**
+   * Checks culling type
+   * @return Subdivider.CULL_ACCEPT
+   */
+  public int cullCheck() {
+    if (cullval == Subdivider.CULL_ACCEPT) {
+      //				System.out.println("TODO curve.cullval");
+      // cullval=mapdesc.cullCheck(cpts,order,stride);
+    }
+    // TODO compute cullval and return the computed value
+    // return cullval;
+    return Subdivider.CULL_ACCEPT;
+  }
+
+  /**
+   * Computes subdivision step size
+   */
+  public void getStepSize() {
+    minstepsize = 0;
+    if (mapdesc.isConstantSampling()) {
+      setstepsize(mapdesc.maxrate);
+    } else if (mapdesc.isDomainSampling()) {
+      setstepsize(mapdesc.maxrate * range[2]);
+    } else {
+      assert (order <= MAXORDER);
+
+      float tmp[][] = new float[MAXORDER][MAXCOORDS];
+
+      int tstride = (MAXORDER);
+
+      int val = 0;
+      // mapdesc.project(spts,stride,tmp,tstride,order);
+
+      //				System.out.println("TODO curve.getsptepsize mapdesc.project");
+
+      if (val == 0) {
+        setstepsize(mapdesc.maxrate);
+      } else {
+        float t = mapdesc.getProperty(NurbsConsts.N_PIXEL_TOLERANCE);
+        if (mapdesc.isParametricDistanceSampling()) {
+          //						System.out.println("TODO curve.getstepsize - parametric");
+        } else if (mapdesc.isPathLengthSampling()) {
+          //						System.out.println("TODO curve.getstepsize - pathlength");
+        } else {
+          setstepsize(mapdesc.maxrate);
+        }
+      }
+
+    }
+
+  }
+
+  /**
+   * Sets maximum subdivision step size
+   * @param max maximum subdivision step size
+   */
+  private void setstepsize(float max) {
+    // DONE
+    stepsize = (max >= 1) ? (range[2] / max) : range[2];
+    minstepsize = stepsize;
+  }
+
+  /**
+   * Clamps the curve
+   */
+  public void clamp() {
+    // DONE
+    if (stepsize < minstepsize)
+      stepsize = mapdesc.clampfactor * minstepsize;
+  }
+
+  /**
+   * Tells whether curve needs subdivision
+   * 
+   * @return curve needs subdivison
+   */
+  public boolean needsSamplingSubdivision() {
+    return (stepsize < minstepsize);
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/CurveEvaluator.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/CurveEvaluator.java
new file mode 100755
index 000000000..a6393ddf4
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/CurveEvaluator.java
@@ -0,0 +1,86 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Class rendering curves with OpenGL
+ * @author Tomáš Hráský
+ *
+ */
+public interface CurveEvaluator {
+  /**
+   * Pushes eval bit
+   */
+  public void bgnmap1f();
+
+  /**
+   * Pops all OpenGL attributes
+   */
+  public void endmap1f() ;
+
+  /**
+   * Initializes opengl evaluator
+   * @param type curve type
+   * @param ulo lowest u
+   * @param uhi highest u
+   * @param stride control point coords
+   * @param order curve order
+   * @param ps control points
+   */
+  public void map1f(int type, float ulo, float uhi, int stride, int order,
+                    CArrayOfFloats ps) ;
+
+  /**
+   * Calls opengl enable
+   * @param type what to enable
+   */
+  public void enable(int type) ;
+
+  /**
+   * Calls glMapGrid1f
+   * @param nu steps
+   * @param u1 low u
+   * @param u2 high u
+   */
+  public void mapgrid1f(int nu, float u1, float u2) ;
+
+  /**
+   * Evaluates a curve using glEvalMesh1f
+   * @param style Backend.N_MESHFILL/N_MESHLINE/N_MESHPOINT
+   * @param from lowest param
+   * @param to highest param
+   */
+  public void mapmesh1f(int style, int from, int to) ;
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Curvelist.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Curvelist.java
new file mode 100755
index 000000000..fdce39b46
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Curvelist.java
@@ -0,0 +1,121 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Class for woking with linked list of curves
+ * @author Tomas Hrasky
+ *
+ */
+public class Curvelist {
+
+  /**
+   * Head of linked list
+   */
+  private Curve curve;
+
+  /**
+   * Holds conversion range borders
+   */
+  float[] range;
+
+  /**
+   * Subdivision step size
+   */
+  public float stepsize;
+
+  /**
+   * Do curves need subdivision?
+   */
+  private boolean needsSubdivision;
+
+  /**
+   * Makes new instance on top of specified lis of Quilts
+   * @param qlist underlaying list of quilts
+   * @param pta range start
+   * @param ptb range end
+   */
+  public Curvelist(Quilt qlist, float[] pta, float[] ptb) {
+    // DONE
+    curve = null;
+    range = new float[3];
+
+    for (Quilt q = qlist; q != null; q = q.next) {
+      curve = new Curve(q, pta, ptb, curve);
+    }
+    range[0] = pta[0];
+    range[1] = ptb[0];
+    range[2] = range[1] - range[0];
+  }
+
+  /**
+   * Compute step size
+   */
+  public void getstepsize() {
+    // DONE
+    stepsize = range[2];
+    Curve c;
+    for (c = curve; c != null; c = c.next) {
+      c.getStepSize();
+      c.clamp();
+      stepsize = (c.stepsize < stepsize) ? c.stepsize : stepsize;
+      if (c.needsSamplingSubdivision())
+        break;
+    }
+    needsSubdivision = (c != null) ? true : false;
+
+  }
+
+  /**
+   * Indicates whether curves need subdivision
+   * @return curves need subdivision
+   */
+  public boolean needsSamplingSubdivision() {
+    // DONE
+    return needsSubdivision;
+  }
+
+  /**
+   * Checks for culling
+   * @return Subdivider.CULL_TRIVIAL_REJECT or Subdivider.CULL_ACCEPT
+   */
+  public int cullCheck() {
+    // DONE
+    for (Curve c = curve; c != null; c = c.next)
+      if (c.cullCheck() == Subdivider.CULL_TRIVIAL_REJECT)
+        return Subdivider.CULL_TRIVIAL_REJECT;
+    return Subdivider.CULL_ACCEPT;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/DisplayList.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/DisplayList.java
new file mode 100755
index 000000000..735c36edf
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/DisplayList.java
@@ -0,0 +1,56 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+import java.lang.reflect.Method;
+
+/**
+ * Display list
+ * @author Tomas Hrasky
+ *
+ */
+public class DisplayList {
+
+  /**
+   * Append action to the display list
+   * @param src source object to invoke method on
+   * @param m invoked method
+   * @param arg method argument
+   */
+  public void append(Object src, Method m, Object arg) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO displaylist append");
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Flist.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Flist.java
new file mode 100755
index 000000000..d9e798854
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Flist.java
@@ -0,0 +1,130 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+import java.util.Arrays;
+
+/**
+ * List of breakpoints
+ * @author Tomas Hrasky
+ *
+ */
+public class Flist {
+
+  /**
+   * Data elements end index
+   * 
+   */
+  public int end;
+
+  /**
+   *Data elements start index 
+   */
+  public int start;
+
+  /**
+   * Breakpoint values
+   */
+  public float[] pts;
+
+  /**
+   * Number of array fields
+   */
+  private int npts;
+
+  /**
+   * Grows list
+   * @param maxpts maximum desired size
+   */
+  public void grow(int maxpts) {
+    // DONE
+    if (npts < maxpts) {
+      // npts=2*maxpts;
+      npts = maxpts;
+      pts = new float[npts];
+    }
+    start = 0;
+    end = 0;
+  }
+
+  /**
+   * Removes duplicate array elemnts 
+   */
+  public void filter() {
+    // INFO the aim of this method is to remove duplicates from array
+
+    Arrays.sort(pts);
+
+    start = 0;
+
+    int j = 0;
+
+    for (int i = 1; i < end; i++) {
+      if (pts[i] == pts[i - j - 1])
+        j++;
+      pts[i - j] = pts[i];
+    }
+
+    end -= j;
+
+  }
+
+  /**
+   * Sets start and and to real start and end of array elements
+   * @param from start from
+   * @param to end at
+   */
+  public void taper(float from, float to) {
+    // DONE
+
+    while (pts[start] != from) {
+      start++;
+    }
+
+    while (pts[end - 1] != to) {
+      end--;
+    }
+
+  }
+
+  /**
+   * Adds breakpoint value
+   * @param f value
+   */
+  public void add(float f) {
+    //DONE
+    pts[end++] = f;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Knotspec.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Knotspec.java
new file mode 100755
index 000000000..bcb55388d
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Knotspec.java
@@ -0,0 +1,557 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Knot vector specification
+ * 
+ * @author Tomas Hrasky
+ * 
+ */
+public class Knotspec {
+
+  /**
+   * Begin of input knots
+   */
+  public CArrayOfFloats inkbegin;
+
+  /**
+   * End of input knots
+   */
+  public CArrayOfFloats inkend;
+
+  /**
+   * Stride before knot operations
+   */
+  public int prestride;
+
+  /**
+   * Curve order
+   */
+  public int order;
+
+  /**
+   * Next knot specification in linked list (used in surfaces)
+   */
+  public Knotspec next;
+
+  /**
+   * Last knot
+   */
+  public CArrayOfFloats klast;
+
+  /**
+   * First knot
+   */
+  CArrayOfFloats kfirst;
+
+  /**
+   * Beginning of breakpoints
+   */
+  CArrayOfBreakpts bbegin;
+
+  /**
+   * End of breakpoints
+   */
+  CArrayOfBreakpts bend;
+
+  /**
+   * Considered left end knot
+   */
+  CArrayOfFloats kleft;
+
+  /**
+   * Considered right end knot
+   */
+  CArrayOfFloats kright;
+
+  /**
+   * Offset before knot operations
+   */
+  int preoffset;
+
+  /**
+   * Control points array Length after knot operations
+   */
+  int postwidth;
+
+  /**
+   * Beginning of coeficients array
+   */
+  private CArrayOfFloats sbegin;
+
+  /**
+   * Beginning of output knots
+   */
+  private CArrayOfFloats outkbegin;
+
+  /**
+   * End of output knots
+   */
+  private CArrayOfFloats outkend;
+
+  /**
+   * Control points aray length before knot operations
+   */
+  int prewidth;
+
+  /**
+   * Offset after knot operations
+   */
+  int postoffset;
+
+  /**
+   * Number of control points' coordinates after knot operations
+   */
+  public int poststride;
+
+  /**
+   * Number of control points' coordinates
+   */
+  public int ncoords;
+
+  /**
+   * Tell whether knotspec has already benn transformed
+   */
+  public boolean istransformed;
+
+  /**
+   * Knotspec to be transformed
+   */
+  public Knotspec kspectotrans;
+
+  /**
+   * Finds knot border of knot insertion and required multiplicities
+   */
+  public void preselect() {
+    // DONE
+    float kval;
+
+    klast = new CArrayOfFloats(inkend);
+    klast.lessenPointerBy(order);
+    for (kval = klast.get(); klast.getPointer() != inkend.getPointer(); klast
+           .pp()) {
+      if (!Knotvector.identical(klast.get(), kval))
+        break;
+    }
+
+    kfirst = new CArrayOfFloats(inkbegin);
+    kfirst.raisePointerBy(order - 1);
+    for (kval = kfirst.get(); kfirst.getPointer() != inkend.getPointer(); kfirst
+           .pp()) {
+      if (!Knotvector.identical(kfirst.get(), kval))
+        break;
+    }
+
+    CArrayOfFloats k = new CArrayOfFloats(kfirst);
+    k.mm();
+
+    for (; k.getPointer() >= inkbegin.getPointer(); k.mm())
+      if (!Knotvector.identical(kval, k.get()))
+        break;
+    k.pp();
+
+    Breakpt[] bbeginArray = new Breakpt[(klast.getPointer() - kfirst
+                                         .getPointer()) + 1];
+    for (int i = 0; i < bbeginArray.length; i++)
+      bbeginArray[i] = new Breakpt();
+    bbegin = new CArrayOfBreakpts(bbeginArray, 0);
+    bbegin.get().multi = kfirst.getPointer() - k.getPointer();
+    bbegin.get().value = kval;
+
+    bend = new CArrayOfBreakpts(bbegin);
+    kleft = new CArrayOfFloats(kfirst);
+    kright = new CArrayOfFloats(kfirst);
+
+  }
+
+  /**
+   * Perpares knotspec for transformation
+   */
+  public void select() {
+    // DONE
+    breakpoints();
+    knots();
+    factors();
+
+    preoffset = kleft.getPointer() - (inkbegin.getPointer() + order);
+    postwidth = ((bend.getPointer() - bbegin.getPointer()) * order);
+    prewidth = (outkend.getPointer() - outkbegin.getPointer()) - order;
+    postoffset = (bbegin.get().def > 1) ? (bbegin.get().def - 1) : 0;
+
+  }
+
+  /**
+   * Computes alpha factors for computing new control points
+   */
+  private void factors() {
+    // DONE
+    CArrayOfFloats mid = new CArrayOfFloats(outkend.getArray(), (outkend
+                                                                 .getPointer() - 1)
+                                            - order + bend.get().multi);
+
+    CArrayOfFloats fptr = null;
+    if (sbegin != null)
+      fptr = new CArrayOfFloats(sbegin);
+
+    for (CArrayOfBreakpts bpt = new CArrayOfBreakpts(bend); bpt
+           .getPointer() >= bbegin.getPointer(); bpt.mm()) {
+      mid.lessenPointerBy(bpt.get().multi);
+      int def = bpt.get().def - 1;
+      if (def < 0)
+        continue;
+      float kv = bpt.get().value;
+
+      CArrayOfFloats kf = new CArrayOfFloats(mid.getArray(), (mid
+                                                              .getPointer() - def)
+                                             + (order - 1));
+      for (CArrayOfFloats kl = new CArrayOfFloats(kf.getArray(), kf
+                                                  .getPointer()
+                                                  + def); kl.getPointer() != kf.getPointer(); kl.mm()) {
+        CArrayOfFloats kh, kt;
+        for (kt = new CArrayOfFloats(kl), kh = new CArrayOfFloats(mid); kt
+               .getPointer() != kf.getPointer(); kh.mm(), kt.mm()) {
+          fptr.set((kv - kh.get()) / (kt.get() - kh.get()));
+          fptr.pp();
+        }
+        kl.set(kv);
+      }
+    }
+
+  }
+
+  /**
+   * Makes new knot vector
+   */
+  private void knots() {
+    // DONE
+    CArrayOfFloats inkpt = new CArrayOfFloats(kleft.getArray(), kleft
+                                              .getPointer()
+                                              - order);
+    CArrayOfFloats inkend = new CArrayOfFloats(kright.getArray(), kright
+                                               .getPointer()
+                                               + bend.get().def);
+
+    outkbegin = new CArrayOfFloats(new float[inkend.getPointer()
+                                             - inkpt.getPointer()], 0);
+    CArrayOfFloats outkpt;
+    for (outkpt = new CArrayOfFloats(outkbegin); inkpt.getPointer() != inkend
+           .getPointer(); inkpt.pp(), outkpt.pp()) {
+      outkpt.set(inkpt.get());
+    }
+    outkend = new CArrayOfFloats(outkpt);
+  }
+
+  /**
+   * Analyzes breakpoints
+   */
+  private void breakpoints() {
+    // DONE
+    CArrayOfBreakpts ubpt = new CArrayOfBreakpts(bbegin);
+    CArrayOfBreakpts ubend = new CArrayOfBreakpts(bend);
+    int nfactors = 0;
+
+    ubpt.get().value = ubend.get().value;
+    ubpt.get().multi = ubend.get().multi;
+
+    kleft = new CArrayOfFloats(kright);
+
+    for (; kright.getPointer() != klast.getPointer(); kright.pp()) {
+      if (Knotvector.identical(kright.get(), ubpt.get().value)) {
+        ubpt.get().multi++;
+      } else {
+        ubpt.get().def = order - ubpt.get().multi;
+        nfactors += (ubpt.get().def * (ubpt.get().def - 1)) / 2;
+        ubpt.pp();
+        ubpt.get().value = kright.get();
+        ubpt.get().multi = 1;
+      }
+    }
+    ubpt.get().def = order - ubpt.get().multi;
+    nfactors += (ubpt.get().def * (ubpt.get().def - 1)) / 2;
+
+    bend = new CArrayOfBreakpts(ubpt);
+
+    if (nfactors > 0) {
+      sbegin = new CArrayOfFloats(new float[nfactors], 0);
+    } else {
+      sbegin = null;
+    }
+
+  }
+
+  /**
+   * Copies control points
+   * 
+   * @param _inpt
+   *            input control points
+   * @param _outpt
+   *            output control points
+   */
+  public void copy(CArrayOfFloats _inpt, CArrayOfFloats _outpt) {
+    CArrayOfFloats inpt = new CArrayOfFloats(_inpt);
+    CArrayOfFloats outpt = new CArrayOfFloats(_outpt);
+
+    inpt.raisePointerBy(preoffset);
+    if (next != null) {
+      for (CArrayOfFloats lpt = new CArrayOfFloats(outpt.getArray(),
+                                                   outpt.getPointer() + prewidth); outpt.getPointer() != lpt
+             .getPointer(); outpt.raisePointerBy(poststride)) {
+        next.copy(inpt, outpt);
+        inpt.raisePointerBy(prestride);
+      }
+
+    } else {
+      for (CArrayOfFloats lpt = new CArrayOfFloats(outpt.getArray(),
+                                                   outpt.getPointer() + prewidth); outpt.getPointer() != lpt
+             .getPointer(); outpt.raisePointerBy(poststride)) {
+        pt_io_copy(outpt, inpt);
+        inpt.raisePointerBy(prestride);
+      }
+    }
+
+  }
+
+  /**
+   * Copies one control point to other
+   * 
+   * @param topt
+   *            source control point
+   * @param frompt
+   *            destination control point
+   */
+  private void pt_io_copy(CArrayOfFloats topt, CArrayOfFloats frompt) {
+    // DONE
+    switch (ncoords) {
+    case 4:
+      topt.setRelative(3, frompt.getRelative(3));
+    case 3:
+      topt.setRelative(2, frompt.getRelative(2));
+    case 2:
+      topt.setRelative(1, frompt.getRelative(1));
+    case 1:
+      topt.set(frompt.get());
+      break;
+    default:
+      // TODO break with copying in general case
+      //				System.out.println("TODO knotspec.pt_io_copy");
+      break;
+    }
+
+  }
+
+  /**
+   * Inserts a knot
+   * 
+   * @param _p
+   *            inserted knot
+   */
+  public void transform(CArrayOfFloats _p) {
+    CArrayOfFloats p = new CArrayOfFloats(_p);
+    // DONE
+    if (next != null) {//surface code
+      if (this.equals(kspectotrans)) {
+        next.transform(p);
+      } else {
+        if (istransformed) {
+          p.raisePointerBy(postoffset);
+          for (CArrayOfFloats pend = new CArrayOfFloats(p.getArray(),
+							p.getPointer() + postwidth); p.getPointer() != pend
+                 .getPointer(); p.raisePointerBy(poststride))
+            next.transform(p);
+
+        } else {
+          CArrayOfFloats pend = new CArrayOfFloats(p.getArray(), p
+                                                   .getPointer()
+                                                   + prewidth);
+          for (; p.getPointer() != pend.getPointer(); p
+                 .raisePointerBy(poststride))
+            next.transform(p);
+        }
+      }
+
+    } else {//code for curve 
+      if (this.equals(kspectotrans)) {
+        insert(p);
+      } else {
+        if (istransformed) {
+          p.raisePointerBy(postoffset);
+          for (CArrayOfFloats pend = new CArrayOfFloats(p.getArray(),
+							p.getPointer() + postwidth); p.getPointer() != pend
+                 .getPointer(); p.raisePointerBy(poststride)) {
+            kspectotrans.insert(p);
+          }
+        } else {
+          CArrayOfFloats pend = new CArrayOfFloats(p.getArray(), p
+                                                   .getPointer()
+                                                   + prewidth);
+          for (; p.getPointer() != pend.getPointer(); p
+                 .raisePointerBy(poststride))
+            kspectotrans.insert(p);
+        }
+      }
+    }
+
+  }
+
+  /**
+   * Inserts a knot and computes new control points
+   * 
+   * @param p
+   *            inserted knot
+   */
+  private void insert(CArrayOfFloats p) {
+    // DONE
+    CArrayOfFloats fptr = null;
+    if (sbegin != null)
+      fptr = new CArrayOfFloats(sbegin);
+    CArrayOfFloats srcpt = new CArrayOfFloats(p.getArray(), p.getPointer()
+                                              + prewidth - poststride);
+    // CArrayOfFloats srcpt = new CArrayOfFloats(p.getArray(), prewidth -
+    // poststride);
+    CArrayOfFloats dstpt = new CArrayOfFloats(p.getArray(), p.getPointer()
+                                              + postwidth + postoffset - poststride);
+    // CArrayOfFloats dstpt = new CArrayOfFloats(p.getArray(), postwidth +
+    // postoffset - poststride);
+    CArrayOfBreakpts bpt = new CArrayOfBreakpts(bend);
+
+    for (CArrayOfFloats pend = new CArrayOfFloats(srcpt.getArray(), srcpt
+                                                  .getPointer()
+                                                  - poststride * bpt.get().def); srcpt.getPointer() != pend
+           .getPointer(); pend.raisePointerBy(poststride)) {
+      CArrayOfFloats p1 = new CArrayOfFloats(srcpt);
+      for (CArrayOfFloats p2 = new CArrayOfFloats(srcpt.getArray(), srcpt
+                                                  .getPointer()
+                                                  - poststride); p2.getPointer() != pend.getPointer(); p1
+             .setPointer(p2.getPointer()), p2
+             .lessenPointerBy(poststride)) {
+        pt_oo_sum(p1, p1, p2, fptr.get(), 1.0 - fptr.get());
+        fptr.pp();
+      }
+    }
+    bpt.mm();
+    for (; bpt.getPointer() >= bbegin.getPointer(); bpt.mm()) {
+
+      for (int multi = bpt.get().multi; multi > 0; multi--) {
+        pt_oo_copy(dstpt, srcpt);
+        dstpt.lessenPointerBy(poststride);
+        srcpt.lessenPointerBy(poststride);
+      }
+      for (CArrayOfFloats pend = new CArrayOfFloats(srcpt.getArray(),
+                                                    srcpt.getPointer() - poststride * bpt.get().def); srcpt
+             .getPointer() != pend.getPointer(); pend
+             .raisePointerBy(poststride), dstpt
+             .lessenPointerBy(poststride)) {
+        pt_oo_copy(dstpt, srcpt);
+        CArrayOfFloats p1 = new CArrayOfFloats(srcpt);
+
+        for (CArrayOfFloats p2 = new CArrayOfFloats(srcpt.getArray(),
+                                                    srcpt.getPointer() - poststride); p2.getPointer() != pend
+               .getPointer(); p1.setPointer(p2.getPointer()), p2
+               .lessenPointerBy(poststride)) {
+          pt_oo_sum(p1, p1, p2, fptr.get(), 1.0 - fptr.get());
+          fptr.pp();
+        }
+      }
+    }
+  }
+
+  /**
+   * Copies one control point to another
+   * 
+   * @param topt
+   *            source ctrl point
+   * @param frompt
+   *            distance ctrl point
+   */
+  private void pt_oo_copy(CArrayOfFloats topt, CArrayOfFloats frompt) {
+    // DONE
+    // this is a "trick" with case - "break" is omitted so it comes through all cases
+    switch (ncoords) {
+    case 4:
+      topt.setRelative(3, frompt.getRelative(3));
+    case 3:
+      topt.setRelative(2, frompt.getRelative(2));
+    case 2:
+      topt.setRelative(1, frompt.getRelative(1));
+    case 1:
+      topt.setRelative(0, frompt.getRelative(0));
+      break;
+    default:
+      // default uses memcpy but it is not needed (we probably won't have more than 4 coords)
+      // TODO not sure about it
+      break;
+    }
+
+  }
+
+  /**
+   * Computes new control point
+   * 
+   * @param x
+   *            first point
+   * @param y
+   *            second point
+   * @param z
+   *            third pont
+   * @param a
+   *            alpha
+   * @param b
+   *            1 - alpha
+   */
+  private void pt_oo_sum(CArrayOfFloats x, CArrayOfFloats y,
+                         CArrayOfFloats z, float a, double b) {
+    // DONE
+    switch (ncoords) {
+    case 4:
+      x.setRelative(3, (float) (a * y.getRelative(3) + b
+                                * z.getRelative(3)));
+    case 3:
+      x.setRelative(2, (float) (a * y.getRelative(2) + b
+                                * z.getRelative(2)));
+    case 2:
+      x.setRelative(1, (float) (a * y.getRelative(1) + b
+                                * z.getRelative(1)));
+    case 1:
+      x.setRelative(0, (float) (a * y.getRelative(0) + b
+                                * z.getRelative(0)));
+      break;
+    default:
+      //no need of default - see previous method and its case statement				
+      //				System.out.println("TODO pt_oo_sum default");
+      break;
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Knotvector.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Knotvector.java
new file mode 100755
index 000000000..c7c3d4578
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Knotvector.java
@@ -0,0 +1,179 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Knot vector used in curve specification
+ * 
+ * @author Tomas Hrasky
+ * 
+ */
+public class Knotvector {
+
+  /**
+   * Tolerance used when comparing knots - when difference is smaller, knots
+   * are considered equal
+   */
+  public static final float TOLERANCE = 1.0e-5f;
+
+  /**
+   * Maximum curve order
+   */
+  private static final int MAXORDER = 24;
+
+  /**
+   * Number of knots
+   */
+  int knotcount;
+
+  /**
+   * Number of control points' coordinates
+   */
+  int stride;
+
+  /**
+   * Curve order
+   */
+  int order;
+
+  /**
+   * Knots
+   */
+  float[] knotlist;
+
+  /**
+   * Makes new knotvector
+   * 
+   * @param nknots
+   *            number of knots
+   * @param stride
+   *            number of ctrl points' corrdinates
+   * @param order
+   *            curve order
+   * @param knot
+   *            knots
+   */
+  public Knotvector(int nknots, int stride, int order, float[] knot) {
+    // DONE
+    init(nknots, stride, order, knot);
+  }
+
+  /**
+   * Initializes knotvector
+   * 
+   * @param nknots
+   *            number of knots
+   * @param stride
+   *            number of ctrl points' corrdinates
+   * @param order
+   *            curve order
+   * @param knot
+   *            knots
+   */
+  public void init(int nknots, int stride, int order, float[] knot) {
+    // DONE
+    this.knotcount = nknots;
+    this.stride = stride;
+    this.order = order;
+    this.knotlist = new float[nknots];
+    for (int i = 0; i < nknots; i++) {
+      this.knotlist[i] = knot[i];
+    }
+
+  }
+
+  /**
+   * Validates knot vector parameters
+   * 
+   * @return knot vector validity
+   */
+  public int validate() {
+    int kindex = knotcount - 1;
+    if (order < 1 || order > MAXORDER) {
+      return 1;
+    }
+    if (knotcount < 2 * order) {
+      return 2;
+    }
+    if (identical(knotlist[kindex - (order - 1)], knotlist[order - 1])) {
+      return 3;
+    }
+    for (int i = 0; i < kindex; i++) {
+      if (knotlist[i] > knotlist[i + 1])
+        return 4;
+    }
+    int multi = 1;
+    for (; kindex >= 1; kindex--) {
+      if (knotlist[kindex] - knotlist[kindex - 1] < TOLERANCE) {
+        multi++;
+        continue;
+      }
+      if (multi > order) {
+        return 5;
+      }
+      multi = 1;
+    }
+    if (multi > order) {
+      return 5;
+    }
+
+    return 0;
+  }
+
+  /**
+   * Show specified message
+   * 
+   * @param msg
+   *            message to be shown
+   */
+  public void show(String msg) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO knotvector.show");
+
+  }
+
+  /**
+   * Compares two knots for equality
+   * 
+   * @param a
+   *            first knot
+   * @param b
+   *            second knot
+   * @return knots are/are not equal
+   */
+  public static boolean identical(float a, float b) {
+    return ((a - b) < TOLERANCE) ? true : false;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Mapdesc.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Mapdesc.java
new file mode 100755
index 000000000..8b52a4a8a
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Mapdesc.java
@@ -0,0 +1,442 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Class holding properties of OpenGL map
+ * @author Tomas Hrasky
+ *
+ */
+public class Mapdesc {
+
+  /**
+   * Maximum control point coords
+   */
+  private static final int MAXCOORDS = 5;
+
+  /**
+   * Next description in list
+   */
+  public Mapdesc next;
+
+  /**
+   * Is map rational
+   */
+  public int isrational;
+
+  /**
+   * Number of control point coords
+   */
+  public int ncoords;
+
+  /**
+   * Map type
+   */
+  private int type;
+
+  /**
+   * Number of homogenous coords
+   */
+  private int hcoords;
+
+  /**
+   * Number of inhomogenous coords
+   */
+  private int inhcoords;
+
+  /**
+   * Not used
+   */
+  private int mask;
+
+  /**
+   * Value of N_PIXEL_TOLERANCE property
+   */
+  private float pixel_tolerance;
+
+  /**
+   * Value of N_ERROR_TOLERANCE property
+   */
+  private float error_tolerance;
+
+  /**
+   * Value of N_BBOX_SUBDIVIDING property
+   */
+  private float bbox_subdividing;
+
+  /**
+   * Value of N_CULLING property
+   */
+  private float culling_method;
+
+  /**
+   * Value of N_SAMPLINGMETHOD property
+   */
+  private float sampling_method;
+
+  /**
+   * Value of N_CLAMPFACTOR property
+   */
+  float clampfactor;
+
+  /**
+   * Value of N_MINSAVINGS property 
+   */
+  private float minsavings;
+
+  /**
+   * Steps in u direction
+   */
+  private float s_steps;
+
+  /**
+   * Steps in v direction
+   */
+  private float t_steps;
+
+  /**
+   * Maximal step
+   */
+  float maxrate;
+
+  /**
+   * Maximal u direction step
+   */
+  private float maxsrate;
+
+  /**
+   * Maximal v direction step
+   */
+  private float maxtrate;
+
+  /**
+   * Not used
+   */
+  private float[][] bmat;
+
+  /**
+   * Sampling matrix
+   */
+  private float[][] smat;
+
+  /**
+   * Not used
+   */
+  private float[][] cmat;
+
+  /**
+   * Not used
+   */
+  private float[] bboxsize;
+
+  /**
+   * Makes new mapdesc 
+   * @param type map type
+   * @param rational is rational
+   * @param ncoords number of control points coords
+   * @param backend backend object
+   */
+  public Mapdesc(int type, int rational, int ncoords, Backend backend) {
+    // DONE
+    this.type = type;
+    this.isrational = rational;
+    this.ncoords = ncoords;
+    this.hcoords = ncoords + (isrational > 0 ? 0 : 1);
+    this.inhcoords = ncoords - (isrational > 0 ? 1 : 0);
+    this.mask = ((1 << (inhcoords * 2)) - 1);
+    next = null;
+
+    assert (hcoords <= MAXCOORDS);
+    assert (inhcoords >= 1);
+
+    pixel_tolerance = 1f;
+    error_tolerance = 1f;
+    bbox_subdividing = NurbsConsts.N_NOBBOXSUBDIVISION;
+    culling_method = NurbsConsts.N_NOCULLING;
+    sampling_method = NurbsConsts.N_NOSAMPLING;
+    clampfactor = NurbsConsts.N_NOCLAMPING;
+    minsavings = NurbsConsts.N_NOSAVINGSSUBDIVISION;
+    s_steps = 0f;
+    t_steps = 0f;
+
+    maxrate = (s_steps < 0) ? 0 : s_steps;
+    maxsrate = (s_steps < 0) ? 0 : s_steps;
+    maxtrate = (t_steps < 0) ? 0 : t_steps;
+    bmat = new float[MAXCOORDS][MAXCOORDS];
+    cmat = new float[MAXCOORDS][MAXCOORDS];
+    smat = new float[MAXCOORDS][MAXCOORDS];
+
+    identify(bmat);
+    identify(cmat);
+    identify(smat);
+    bboxsize = new float[MAXCOORDS];
+    for (int i = 0; i < inhcoords; i++)
+      bboxsize[i] = 1;
+  }
+
+  /**
+   * Make matrix identity matrix
+   * @param arr matrix
+   */
+  private void identify(float[][] arr) {
+    // DONE
+    for (int i = 0; i < MAXCOORDS; i++)
+      for (int j = 0; j < MAXCOORDS; j++)
+        arr[i][j] = 0;
+    for (int i = 0; i < MAXCOORDS; i++)
+      arr[i][i] = 1;
+
+  }
+
+  /**
+   * Tells whether tag is property tag
+   * @param tag property tag
+   * @return is/is not property
+   */
+  public boolean isProperty(int tag) {
+    boolean ret;
+    switch (tag) {
+    case NurbsConsts.N_PIXEL_TOLERANCE:
+    case NurbsConsts.N_ERROR_TOLERANCE:
+    case NurbsConsts.N_CULLING:
+    case NurbsConsts.N_BBOX_SUBDIVIDING:
+    case NurbsConsts.N_S_STEPS:
+    case NurbsConsts.N_T_STEPS:
+    case NurbsConsts.N_SAMPLINGMETHOD:
+    case NurbsConsts.N_CLAMPFACTOR:
+    case NurbsConsts.N_MINSAVINGS:
+      ret = true;
+      break;
+    default:
+      ret = false;
+      break;
+    }
+    return ret;
+  }
+
+  /**
+   * Returns number of control points' coords
+   * @return number of control points' coords
+   */
+  public int getNCoords() {
+    return ncoords;
+  }
+
+  /**
+   * Returns map type
+   * @return map type
+   */
+  public int getType() {
+    return type;
+  }
+
+  /**
+   * Tells whether map is range sampling
+   * @return is map range sampling
+   */
+  public boolean isRangeSampling() {
+    // DONE
+    return (isParametricDistanceSampling() || isPathLengthSampling()
+            || isSurfaceAreaSampling() || isObjectSpaceParaSampling() || isObjectSpacePathSampling());
+  }
+
+  /**
+   * Tells whether map is object space sampling
+   * @return is map object space sampling
+   */
+  private boolean isObjectSpacePathSampling() {
+    // DONE
+    return sampling_method == NurbsConsts.N_OBJECTSPACE_PATH;
+  }
+
+  /**
+   * Tells whether map is object space parasampling
+   * @return is map object space parasampling
+   */
+  private boolean isObjectSpaceParaSampling() {
+    // DONE
+    return sampling_method == NurbsConsts.N_OBJECTSPACE_PARA;
+  }
+
+  /**
+   * Tells whether map is area sampling surface
+   * @return is map area sampling surface
+   */
+  private boolean isSurfaceAreaSampling() {
+    // DONE
+    return sampling_method == NurbsConsts.N_SURFACEAREA;
+  }
+
+  /**
+   * Tells whether map is path length sampling
+   * @return is map path length sampling
+   */
+  boolean isPathLengthSampling() {
+    // DONE
+    return sampling_method == NurbsConsts.N_PATHLENGTH;
+  }
+
+  /**
+   * Tells whether map is parametric distance sampling
+   * @return is map parametric distance sampling
+   */
+  boolean isParametricDistanceSampling() {
+    // DONE
+    return sampling_method == NurbsConsts.N_PARAMETRICDISTANCE;
+  }
+
+  /**
+   * Tells whether map is culling 
+   * @return is map culling
+   */
+  public boolean isCulling() {
+    // DONE
+    return culling_method != NurbsConsts.N_NOCULLING ? true : false;
+  }
+
+  /**
+   * Tells whether map is constantly sampling 
+   * @return is map constant sampling
+   */
+  public boolean isConstantSampling() {
+    return (sampling_method == NurbsConsts.N_FIXEDRATE) ? true : false;
+  }
+
+  /**
+   * Tells whether map is domain sampling 
+   * @return is map domain sampling
+   */
+  public boolean isDomainSampling() {
+    return (sampling_method == NurbsConsts.N_DOMAINDISTANCE) ? true : false;
+  }
+
+  /**
+   * Returns property of specified tag value 
+   * @param tag property tag
+   * @return property value
+   */
+  public float getProperty(int tag) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO mapdesc.getproperty");
+    return 0;
+  }
+
+  /**
+   * Sets property with given tag
+   * @param tag property tag
+   * @param value desired value
+   */
+  public void setProperty(int tag, float value) {
+    // TODO Auto-generated method stub
+    switch (tag) {
+    case NurbsConsts.N_PIXEL_TOLERANCE:
+      pixel_tolerance = value;
+      break;
+    case NurbsConsts.N_ERROR_TOLERANCE:
+      error_tolerance = value;
+      break;
+    case NurbsConsts.N_CULLING:
+      culling_method = value;
+      break;
+    case NurbsConsts.N_BBOX_SUBDIVIDING:
+      if (value <= 0)
+        value = NurbsConsts.N_NOBBOXSUBDIVISION;
+      bbox_subdividing = value;
+      break;
+    case NurbsConsts.N_S_STEPS:
+      if (value < 0)
+        value = 0;
+      s_steps = value;
+      maxrate = value;
+      maxsrate = value;
+      break;
+    case NurbsConsts.N_T_STEPS:
+      if (value < 0)
+        value = 0;
+      t_steps = value;
+      maxtrate = value;
+      break;
+    case NurbsConsts.N_SAMPLINGMETHOD:
+      sampling_method = value;
+      break;
+    case NurbsConsts.N_CLAMPFACTOR:
+      if (value < 0)
+        value = 0;
+      clampfactor = value;
+      break;
+    case NurbsConsts.N_MINSAVINGS:
+      if (value <= 0)
+        value = NurbsConsts.N_NOSAVINGSSUBDIVISION;
+      minsavings = value;
+      break;
+    }
+  }
+
+  /**
+   * Samples curve
+   * @param pts control points
+   * @param order curve order
+   * @param stride number of control points' coordinates
+   * @param sp breakpoints
+   * @param outstride output number of control points' coordinates
+   */
+  public void xformSampling(CArrayOfFloats pts, int order, int stride,
+                            float[] sp, int outstride) {
+    // DONE
+    xFormMat(smat, pts, order, stride, sp, outstride);
+  }
+
+  /**
+   * Empty method
+   * @param mat sampling matrix
+   * @param pts ontrol points
+   * @param order curve order
+   * @param stride number of control points' coordinates
+   * @param cp breakpoints
+   * @param outstride output number of control points' coordinates
+   */
+  private void xFormMat(float[][] mat, CArrayOfFloats pts, int order,
+			int stride, float[] cp, int outstride) {
+    // TODO Auto-generated method stub
+
+    //		System.out.println("TODO mapdsc.xformmat ; change cp from float[] to carrayoffloats");
+
+    if (isrational > 0) {
+
+    } else {
+
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Maplist.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Maplist.java
new file mode 100755
index 000000000..3b6e22ea5
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Maplist.java
@@ -0,0 +1,122 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Class holding list of Mapdescs
+ * @author Tomáš Hráský
+ *
+ */
+public class Maplist {
+  /**
+   * Head of linked list
+   */
+  private Mapdesc maps;
+
+  /**
+   * Backend class
+   */
+  private Backend backend;
+
+  /**
+   * Makes new Maplist
+   * @param backend Backend class
+   */
+  public Maplist(Backend backend) {
+    this.backend = backend;
+  }
+
+  /**
+   * Sets linked list beginning to null
+   */
+  public void initialize() {
+    // TODO mapdespool.clear ?
+    maps = null;
+  }
+
+  /**
+   * Defines new Mapdesc if it is not defined and appends it to linked list
+   * @param type map type
+   * @param rational is map rational
+   * @param ncoords number of coords
+   */
+  public void define(int type, int rational, int ncoords) {
+    // DONE
+    Mapdesc m = locate(type);
+    assert (m == null || (m.isrational == rational && m.ncoords == ncoords));
+    add(type, rational, ncoords);
+
+  }
+
+  /**
+   * Adds new Mapdesc to linked list
+   * @param type map type
+   * @param rational is map rational
+   * @param ncoords number of coords
+   */
+  private void add(int type, int rational, int ncoords) {
+    // DONE
+    Mapdesc map = new Mapdesc(type, rational, ncoords, backend);
+    if (maps == null) {
+      maps = map;
+    } else {
+      map.next = maps;
+      maps = map;
+    }
+  }
+
+  /**
+   * Tries to find Mapdesc in linked list
+   * @param type map type
+   * @return Mapdesc of type or null if there is no such map
+   */
+  public Mapdesc locate(int type) {
+    // DONE
+    Mapdesc m = null;
+    for (m = maps; m != null; m = m.next)
+      if (m.getType() == type)
+        break;
+    return m;
+  }
+
+  /**
+   * Alias for locate
+   * @param type maptype
+   * @return Mapdesc of type or null if there is no such map
+   */
+  public Mapdesc find(int type) {
+    return locate(type);
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/NurbsConsts.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/NurbsConsts.java
new file mode 100755
index 000000000..c98e74b7c
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/NurbsConsts.java
@@ -0,0 +1,184 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Class hodling NURBS constants as seen in OpenGL GLU documentation
+ * @author JOGL project
+ *
+ */
+public class NurbsConsts {
+  /*
+   * NURBS Properties - one set per map, each takes a single INREAL arg
+   */
+  public static final int N_SAMPLING_TOLERANCE = 1;
+
+  public static final int N_S_RATE = 6;
+
+  public static final int N_T_RATE = 7;
+
+  public static final int N_CLAMPFACTOR = 13;
+
+  public static final float N_NOCLAMPING = 0.0f;
+
+  public static final int N_MINSAVINGS = 14;
+
+  public static final float N_NOSAVINGSSUBDIVISION = 0.0f;
+
+  /*
+   * NURBS Properties - one set per map, each takes an enumerated value
+   */
+  public static final int N_CULLING = 2;
+
+  public static final float N_NOCULLING = 0.0f;
+
+  public static final float N_CULLINGON = 1.0f;
+
+  public static final int N_SAMPLINGMETHOD = 10;
+
+  public static final float N_NOSAMPLING = 0.0f;
+
+  public static final float N_FIXEDRATE = 3.0f;
+
+  public static final float N_DOMAINDISTANCE = 2.0f;
+
+  public static final float N_PARAMETRICDISTANCE = 5.0f;
+
+  public static final float N_PATHLENGTH = 6.0f;
+
+  public static final float N_SURFACEAREA = 7.0f;
+
+  public static final float N_OBJECTSPACE_PARA = 8.0f;
+
+  public static final float N_OBJECTSPACE_PATH = 9.0f;
+
+  public static final int N_BBOX_SUBDIVIDING = 17;
+
+  public static final float N_NOBBOXSUBDIVISION = 0.0f;
+
+  public static final float N_BBOXTIGHT = 1.0f;
+
+  public static final float N_BBOXROUND = 2.0f;
+
+  /*
+   * NURBS Rendering Properties - one set per renderer each takes an
+   * enumerated value
+   */
+  public static final int N_DISPLAY = 3;
+
+  public static final int N_FILL = 1;
+
+  public static final int N_OUTLINE_POLY = 2;
+
+  public static final int N_OUTLINE_TRI = 3;
+
+  public static final int N_OUTLINE_QUAD = 4;
+
+  public static final int N_OUTLINE_PATCH = 5;
+
+  public static final int N_OUTLINE_PARAM = 6;
+
+  public static final int N_OUTLINE_PARAM_S = 7;
+
+  public static final int N_OUTLINE_PARAM_ST = 8;
+
+  public static final int N_OUTLINE_SUBDIV = 9;
+
+  public static final int N_OUTLINE_SUBDIV_S = 10;
+
+  public static final int N_OUTLINE_SUBDIV_ST = 11;
+
+  public static final int N_ISOLINE_S = 12;
+
+  public static final int N_ERRORCHECKING = 4;
+
+  public static final int N_NOMSG = 0;
+
+  public static final int N_MSG = 1;
+
+  /* GL 4.0 propeties not defined above */
+
+  public static final int N_PIXEL_TOLERANCE = N_SAMPLING_TOLERANCE;
+
+  public static final int N_ERROR_TOLERANCE = 20;
+
+  public static final int N_SUBDIVISIONS = 5;
+
+  public static final int N_TILES = 8;
+
+  public static final int N_TMP1 = 9;
+
+  public static final int N_TMP2 = N_SAMPLINGMETHOD;
+
+  public static final int N_TMP3 = 11;
+
+  public static final int N_TMP4 = 12;
+
+  public static final int N_TMP5 = N_CLAMPFACTOR;
+
+  public static final int N_TMP6 = N_MINSAVINGS;
+
+  public static final int N_S_STEPS = N_S_RATE;
+
+  public static final int N_T_STEPS = N_T_RATE;
+
+  /*
+   * NURBS Rendering Properties - one set per map, each takes an INREAL matrix
+   * argument
+   */
+  public static final int N_CULLINGMATRIX = 1;
+
+  public static final int N_SAMPLINGMATRIX = 2;
+
+  public static final int N_BBOXMATRIX = 3;
+
+  /*
+   * NURBS Rendering Properties - one set per map, each takes an INREAL vector
+   * argument
+   */
+  public static final int N_BBOXSIZE = 4;
+
+  /* type argument for trimming curves */
+
+  public static final int N_P2D = 0x8;
+
+  public static final int N_P2DR = 0xd;
+
+  public static final int N_MESHLINE = 1;
+
+  public static final int N_MESHFILL = 0;
+
+  public static final int N_MESHPOINT = 2;
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/O_curve.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/O_curve.java
new file mode 100755
index 000000000..b130226c4
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/O_curve.java
@@ -0,0 +1,63 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Struct holding curve links
+ * @author Tomáš Hráský
+ *
+ */
+public class O_curve {
+
+  /**
+   * Curve type
+   */
+  public int curvetype;
+
+  /**
+   * Next curve in linked list
+   */
+  public O_curve next;
+
+  /**
+   * Curve of picewiselinear type
+   */
+  public O_pwlcurve o_pwlcurve;
+
+  /**
+   * NURBS curve
+   */
+  public O_nurbscurve o_nurbscurve;
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/O_nurbscurve.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/O_nurbscurve.java
new file mode 100755
index 000000000..68bf60b27
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/O_nurbscurve.java
@@ -0,0 +1,80 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * NURBS curve object
+ * @author Tomáš Hráský
+ *
+ */
+public class O_nurbscurve {
+
+  /**
+   * List of bezier curves
+   */
+  public Quilt bezier_curves;
+
+  /**
+   * Curve type
+   */
+  public int type;
+
+  /**
+   * Was curve used ?
+   */
+  public boolean used;
+
+  /**
+   * Parent curve
+   */
+  public O_curve owner;
+
+  /**
+   * Next curve in list
+   */
+  public O_nurbscurve next;
+
+  /**
+   * Makes new O_nurbscurve
+   * @param realType type of curve 
+   */
+  public O_nurbscurve(int realType) {
+    // DONE
+    this.type = realType;
+    this.owner = null;
+    this.next = null;
+    this.used = false;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/O_nurbssurface.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/O_nurbssurface.java
new file mode 100755
index 000000000..1cbaa6ccc
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/O_nurbssurface.java
@@ -0,0 +1,79 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * NURBS surface object
+ * @author Tomáš Hráský
+ *
+ */
+public class O_nurbssurface {
+
+  /**
+   * List of bezier patches forming NURBS surface
+   */
+  public Quilt bezier_patches;
+
+  /**
+   * Was surface used
+   */
+  public boolean used;
+
+  /**
+   * Parent O_surface
+   */
+  public O_surface owner;
+
+  /**
+   * Next surface in list
+   */
+  public O_nurbssurface next;
+
+  /**
+   * Surface type
+   */
+  private int type;
+
+  /**
+   * Makes new O_nurbssurface of type
+   * @param type surface type
+   */
+  public O_nurbssurface(int type) {
+    this.type = type;
+    this.owner = null;
+    this.next = null;
+    this.used = false;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/O_pwlcurve.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/O_pwlcurve.java
new file mode 100755
index 000000000..4dec066d6
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/O_pwlcurve.java
@@ -0,0 +1,44 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Empty class
+ * @author Tomáš Hráský
+ *
+ */
+public class O_pwlcurve {
+
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/O_surface.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/O_surface.java
new file mode 100755
index 000000000..4ef680c2f
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/O_surface.java
@@ -0,0 +1,52 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Surface object
+ * @author Tomáš Hráský
+ *
+ */
+public class O_surface {
+  /**
+   * NURBS surface
+   */
+  public O_nurbssurface o_nurbssurface;
+
+  /**
+   * Trims
+   */
+  public O_trim o_trim;
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/O_trim.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/O_trim.java
new file mode 100755
index 000000000..c1f61ebab
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/O_trim.java
@@ -0,0 +1,44 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Empty class
+ * @author Tomáš Hráský
+ *
+ */
+public class O_trim {
+
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Patch.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Patch.java
new file mode 100755
index 000000000..f15ad1f92
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Patch.java
@@ -0,0 +1,54 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Empty class
+ * @author Tomas Hrasky
+ *
+ */
+public class Patch {
+
+  /**
+   * Empty constructor
+   * @param q
+   * @param pta
+   * @param ptb
+   * @param patch
+   */
+  public Patch(Quilt q, float[] pta, float[] ptb, Patch patch) {
+    //			System.out.println("TODO patch.constructor");
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Patchlist.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Patchlist.java
new file mode 100755
index 000000000..b2b9033ec
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Patchlist.java
@@ -0,0 +1,145 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * List of patches
+ * @author Tomáš Hráský
+ *
+ */
+public class Patchlist {
+
+  /**
+   * Array of ranges
+   */
+  public Pspec[] pspec;
+
+  /**
+   * head of list of patches
+   */
+  private Patch patch;
+
+  /**
+   * Makes new list of patches 
+   * @param quilts list of quilts
+   * @param pta low border
+   * @param ptb high border
+   */
+  public Patchlist(Quilt quilts, float[] pta, float[] ptb) {
+    // DONE
+    patch = null;
+
+    for (Quilt q = quilts; q != null; q = q.next)
+      patch = new Patch(q, pta, ptb, patch);
+    pspec[0] = new Pspec();
+    pspec[0].range[0] = pta[0];
+    pspec[0].range[1] = ptb[0];
+    pspec[0].range[2] = ptb[0] - pta[0];
+    pspec[1] = new Pspec();
+    pspec[1].range[0] = pta[1];
+    pspec[1].range[1] = ptb[1];
+    pspec[1].range[2] = ptb[1] - pta[1];
+
+  }
+
+  /**
+   * Empty constructor
+   * @param patchlist
+   * @param param
+   * @param mid
+   */
+  public Patchlist(Patchlist patchlist, int param, float mid) {
+    // TODO Auto-generated constructor stub
+    //			System.out.println("TODO patchlist.konstruktor 2");
+  }
+
+  /**
+   * Empty method
+   * @return 0
+   */
+  public int cullCheck() {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO patchlist.cullcheck");
+    return 0;
+  }
+
+  /**
+   * Empty method
+   */
+  public void getstepsize() {
+    //			System.out.println("TODO patchlist.getsptepsize");
+    // TODO Auto-generated method stub
+
+  }
+
+  /**
+   * Empty method
+   * @return false
+   */
+  public boolean needsSamplingSubdivision() {
+    // TODO Auto-generated method stub
+    //			System.out.println("patchlist.needsSamplingSubdivision");
+    return false;
+  }
+
+  /**
+   * Empty method
+   * @param i
+   * @return false
+   */
+  public boolean needsSubdivision(int i) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO patchlist.needsSubdivision");
+    return false;
+  }
+
+  /**
+   * Empty method
+   * @return false
+   */
+  public boolean needsNonSamplingSubdivision() {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO patchlist.needsNonSamplingSubdivision");
+    return false;
+  }
+
+  /**
+   * Empty method
+   */
+  public void bbox() {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO patchlist.bbox");
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Property.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Property.java
new file mode 100755
index 000000000..e0ad1dd32
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Property.java
@@ -0,0 +1,75 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Class representing property
+ * 
+ * @author Tomas Hrasky
+ * 
+ */
+public class Property {
+
+  /**
+   * Property type
+   */
+  public int type;
+
+  /**
+   * Property id
+   */
+  public int tag;
+
+  /**
+   * Property value
+   */
+  public float value;
+
+  /**
+   * Makes new property with given parameters
+   * 
+   * @param type
+   *            property type
+   * @param tag
+   *            property id
+   * @param value
+   *            property value
+   */
+  public Property(int type, int tag, float value) {
+    this.type = type;
+    this.tag = tag;
+    this.value = value;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Pspec.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Pspec.java
new file mode 100755
index 000000000..5fc66fa82
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Pspec.java
@@ -0,0 +1,47 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Class holding range
+ * @author Tomáš Hráský
+ *
+ */
+public class Pspec {
+  /**
+   * Range
+   */
+  public float[] range;
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/PwlArc.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/PwlArc.java
new file mode 100755
index 000000000..6b8255d85
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/PwlArc.java
@@ -0,0 +1,71 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Picewiselinar trimming arc
+ * @author Tomáš Hráský
+ *
+ */
+public class PwlArc {
+
+  /**
+   * Number of points
+   */
+  private int npts;
+
+  /**
+   * Vertexes
+   */
+  public TrimVertex[] pts;
+
+  /**
+   * Arc type
+   */
+  private int type;
+
+  /**
+   * Makes new trimming arc
+   * @param i num ber of vertexes
+   * @param p trimming vertexes array
+   */
+  public PwlArc(int i, TrimVertex[] p) {
+    // DONE
+    this.npts = i;
+    this.pts = p;
+    type = NurbsConsts.N_P2D;
+
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Quilt.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Quilt.java
new file mode 100755
index 000000000..bc058b093
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Quilt.java
@@ -0,0 +1,282 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Class for converting NURBS curves and surfaces to list of bezier arcs or patches repectively
+ * @author Tomáš Hráský
+ *
+ */
+public class Quilt {
+  /**
+   * Maximum quilt dimension
+   */
+  private static final int MAXDIM = 2;
+
+  /**
+   * List of map descriptions
+   */
+  Mapdesc mapdesc;
+
+  /**
+   *  Array of quiltspecs pointer
+   */
+  public CArrayOfQuiltspecs qspec;
+
+  /**
+   * End array of quilt specs pointer
+   */
+  public CArrayOfQuiltspecs eqspec;
+
+  /**
+   * Control points
+   */
+  public CArrayOfFloats cpts;
+
+  /**
+   * Next quilt in list
+   */
+  public Quilt next;
+
+  /**
+   * Makes new quilt with mapdesc
+   * @param mapdesc map description
+   */
+  public Quilt(Mapdesc mapdesc) {
+    // DONE
+    this.mapdesc = mapdesc;
+    Quiltspec[] tmpquilts = new Quiltspec[MAXDIM];
+    for (int i = 0; i < tmpquilts.length; i++)
+      tmpquilts[i] = new Quiltspec();
+    this.qspec = new CArrayOfQuiltspecs(tmpquilts);
+
+  }
+
+  /**
+   * Converts NURBS surface to bezier patches
+   * @param sknotvector knots in u direction
+   * @param tknotvector knots in v direction
+   * @param ctrlarr control points
+   * @param coords control points coords
+   */
+  public void toBezier(Knotvector sknotvector, Knotvector tknotvector,
+                       CArrayOfFloats ctrlarr, int coords) {
+    Splinespec spline = new Splinespec(2);
+    spline.kspecinit(sknotvector, tknotvector);
+    spline.select();
+    spline.layout(coords);
+    spline.setupquilt(this);
+    spline.copy(ctrlarr);
+    spline.transform();
+  }
+
+  /**
+   * Converts NURBS curve to list of bezier curves
+   * @param knots knot vector
+   * @param ctlarray control points
+   * @param ncoords number of coordinates
+   */
+  public void toBezier(Knotvector knots, CArrayOfFloats ctlarray, int ncoords) {
+    // DONE
+    Splinespec spline = new Splinespec(1);
+    spline.kspecinit(knots);
+    spline.select();
+    spline.layout(ncoords);
+    spline.setupquilt(this);
+    spline.copy(ctlarray);
+    spline.transform();
+  }
+
+  /**
+   * Walks thru all arcs/patches
+   * @param pta low border
+   * @param ptb high border
+   * @param backend Backend
+   */
+  public void downloadAll(float[] pta, float[] ptb, Backend backend) {
+    // DONE
+    for (Quilt m = this; m != null; m = m.next) {
+      m.select(pta, ptb);
+      m.download(backend);
+    }
+
+  }
+
+  /**
+   * Renders arcs/patches
+   * @param backend Backend for rendering
+   */
+  private void download(Backend backend) {
+    // DONE
+    if (getDimension() == 2) {
+
+      CArrayOfFloats ps = new CArrayOfFloats(cpts);
+      ps.raisePointerBy(qspec.get(0).offset);
+      ps.raisePointerBy(qspec.get(1).offset);
+      ps.raisePointerBy(qspec.get(0).index * qspec.get(0).order
+                        * qspec.get(0).stride);
+      ps.raisePointerBy(qspec.get(1).index * qspec.get(1).order
+                        * qspec.get(1).stride);
+
+      backend.surfpts(mapdesc.getType(), ps, qspec.get(0).stride, qspec
+                      .get(1).stride, qspec.get(0).order, qspec.get(1).order,
+                      qspec.get(0).breakpoints[qspec.get(0).index],
+                      qspec.get(0).breakpoints[qspec.get(0).index + 1], qspec
+                      .get(1).breakpoints[qspec.get(1).index], qspec
+                      .get(1).breakpoints[qspec.get(1).index + 1]);
+
+    } else {// code for curves
+      // CArrayOfFloats ps=new CArrayOfFloats(cpts);
+      CArrayOfFloats ps = new CArrayOfFloats(cpts.getArray(), 0);
+      ps.raisePointerBy(qspec.get(0).offset);
+      ps.raisePointerBy(qspec.get(0).index * qspec.get(0).order
+                        * qspec.get(0).stride);
+      backend.curvpts(mapdesc.getType(), ps, qspec.get(0).stride, qspec
+                      .get(0).order,
+                      qspec.get(0).breakpoints[qspec.get(0).index],
+                      qspec.get(0).breakpoints[qspec.get(0).index + 1]);
+    }
+
+  }
+
+  /**
+   * Returns quilt dimension
+   * @return quilt dimesion
+   */
+  private int getDimension() {
+    // DONE
+    return eqspec.getPointer() - qspec.getPointer();
+  }
+
+  /**
+   * Finds Quiltspec.index
+   * @param pta range
+   * @param ptb range
+   */
+  private void select(float[] pta, float[] ptb) {
+    // DONE
+    int dim = eqspec.getPointer() - qspec.getPointer();
+    int i, j;
+    for (i = 0; i < dim; i++) {
+      for (j = qspec.get(i).width - 1; j >= 0; j--)
+        if (qspec.get(i).breakpoints[j] <= pta[i]
+            && ptb[i] <= qspec.get(i).breakpoints[j + 1])
+          break;
+      assert (j != -1);
+      qspec.get(i).index = j;
+    }
+  }
+
+  /**
+   * Find range according to breakpoints
+   * @param from low param
+   * @param to high param
+   * @param bpts breakpoints
+   */
+  public void getRange(float[] from, float[] to, Flist bpts) {
+    // DONE
+    getRange(from, to, 0, bpts);
+
+  }
+
+  /**
+   * Find range according to breakpoints
+   * @param from low param
+   * @param to high param
+   * @param i from/to array index
+   * @param list breakpoints
+   */
+  private void getRange(float[] from, float[] to, int i, Flist list) {
+    // DONE
+    Quilt maps = this;
+    from[i] = maps.qspec.get(i).breakpoints[0];
+    to[i] = maps.qspec.get(i).breakpoints[maps.qspec.get(i).width];
+    int maxpts = 0;
+    Quilt m;
+    for (m = maps; m != null; m = m.next) {
+      if (m.qspec.get(i).breakpoints[0] > from[i])
+        from[i] = m.qspec.get(i).breakpoints[0];
+      if (m.qspec.get(i).breakpoints[m.qspec.get(i).width] < to[i])
+        to[i] = m.qspec.get(i).breakpoints[m.qspec.get(i).width];
+      maxpts += m.qspec.get(i).width + 1;
+    }
+    list.grow(maxpts);
+    for (m = maps; m != null; m = m.next) {
+      for (int j = 0; j <= m.qspec.get(i).width; j++) {
+        list.add(m.qspec.get(i).breakpoints[j]);
+      }
+    }
+    list.filter();
+    list.taper(from[i], to[i]);
+  }
+
+  /**
+   * Is this quilt culled
+   * @return 0 or Subdivider.CULL_ACCEPT
+   */
+  public int isCulled() {
+    if (mapdesc.isCulling()) {
+      //				System.out.println("TODO quilt.isculled mapdesc.isculling");
+      return 0;
+    } else {
+      return Subdivider.CULL_ACCEPT;
+    }
+  }
+
+  /**
+   * Finds range for surface
+   * @param from low param
+   * @param to high param
+   * @param slist u direction breakpoints
+   * @param tlist v direction breakpoints
+   */
+  public void getRange(float[] from, float[] to, Flist slist, Flist tlist) {
+    // DONE
+    getRange(from, to, 0, slist);
+    getRange(from, to, 1, tlist);
+
+  }
+
+  /**
+   * Empty method
+   * @param sbrkpts
+   * @param tbrkpts
+   * @param rate
+   */
+  public void findRates(Flist sbrkpts, Flist tbrkpts, float[] rate) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO quilt.findrates");
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Quiltspec.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Quiltspec.java
new file mode 100755
index 000000000..d94986a03
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Quiltspec.java
@@ -0,0 +1,85 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Quilt definition
+ * @author Tomas Hrasky
+ *
+ */
+public class Quiltspec {
+
+  /**
+   * Stride between control points
+   */
+  public int stride;
+
+  /**
+   * Quilt width in breakpoints
+   */
+  public int width;
+
+  /**
+   * Quilt order
+   */
+  public int order;
+
+  /**
+   * Start offset
+   */
+  public int offset;
+
+  /**
+   * Breakpoint index
+   */
+  public int index;
+
+  /**
+   * Boundary
+   */
+  public int[] bdry;
+
+  /**
+   * Breakpoints
+   */
+  public float[] breakpoints;
+
+  /**
+   * Makes new quiltspec
+   */
+  public Quiltspec() {
+    this.bdry = new int[2];
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/README.txt b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/README.txt
new file mode 100755
index 000000000..89630c71e
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/README.txt
@@ -0,0 +1,59 @@
+Unimplemented functionality
+	- tesselation and callbacks
+	- trimming
+	- setting NURBS properties (-> sampling etc.)
+Differences from C++ source
+	- no pooling
+	- pointers to arrays are replaced by CArrayOf... classes and their methods
+Unimplemented or incomplete "calltree top" methods (according to glu.def in Mesa 6.5)
+	gluBeginTrim
+	gluDeleteNurbsRenderer - won't be needed
+	gluEndTrim
+	gluGetNurbsProperty
+	gluLoadSamplingMatrices
+	gluNurbsCallback
+	gluNurbsCallbackData
+	gluNurbsCallbackDataEXT
+	gluNurbsCurve - TODO type switch
+	gluNurbsProperty
+	gluPwlCurve
+	gluQuadricCallback - not a NURBS method
+As of files
+	- Arc[ST]dirSorter.java - unimplemented (part of tesselation)
+	- Backend.java:194 - wireframe quads - part of tesselation/callback
+	- Curve.java:141-204 - culling
+	- DisplayList.java:57 - append to DL - not sure whether it will be needed
+	- GLUnurbs.java	:443,484 - error values
+			:445 - trimming
+			:512 - error handling (callback)
+			:530 - loadGLmatrices
+			:786 - nuid - nurbs object id - won't be needed I think
+			:803 - end trim
+	- GLUwNURBS.java:68,176 - NUBRS properties
+	- Knotspec.java	:371 - copying in general case (more than 4 coords)
+			:517 - copying with more than 4 coords
+			:556 - pt_oo_sum default
+	- Knotvector.java:165 - show method (probably debugging)
+	- Mapdesc.java	:354 - get property
+			:435 - xFormMat - change param cp to CArrayOfFloats; probably sampling functionality
+	- Maplist.java:68 - clear ?
+	- OpenGLCurveEvaluator.java	:132 - tess./callback code
+					:168 - mapgrid1f
+					:190 - tess./callback code (output triangles)
+	- OpenGLSurfaceEvaluator.java	:77 . tess./callback code
+					:81 - glGetIntegerValue
+					:114 - tess./callback code
+					:117 - Level of detail
+					:144,161,201 - tess./callback code - output triangles
+	- Patch.java:55 - constructor stuff ?
+	- Patchlist.java:55 - constructor stuff ?
+			:97 - cull check
+			:105 - step size
+			:115 - need of sampling subdivision
+			:126 - need of subdivision
+			:137 - need of non sampling subd.
+			:146 - bbox (??)
+	-Quilt.java	:254 - culling
+			:282 - rates
+	-Subdivider.java - all TODOs - it's stuff about trimming probably
+			 :545 - jumpbuffer - not sure purpose it exactly served in original source
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Renderhints.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Renderhints.java
new file mode 100755
index 000000000..c571d9d88
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Renderhints.java
@@ -0,0 +1,128 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Class holding rendering params 
+ * @author Tomas Hrasky
+ *
+ */
+public class Renderhints {
+
+  /**
+   * Check for errors
+   */
+  public int errorchecking;
+
+  /**
+   * Maximum subdivisions
+   */
+  public int maxsubdivisions;
+
+  /**
+   * Number of subdivisions
+   */
+  private int subdivisions;
+
+  /**
+   * Display method
+   */
+  int display_method;
+
+  /**
+   * Output triangles
+   */
+  int wiretris;
+
+  /**
+   * Output quads
+   */
+  int wirequads;
+
+  /**
+   * Makes new Renderinghints
+   */
+  public Renderhints() {
+    display_method = NurbsConsts.N_FILL;
+    errorchecking = NurbsConsts.N_MSG;
+    subdivisions = 6;
+    // tmp1=0;
+  }
+
+  /**
+   * Set property value
+   * @param prop property
+   */
+  public void setProperty(Property prop) {
+    switch (prop.type) {
+    case NurbsConsts.N_DISPLAY:
+      display_method = (int) prop.value;
+      break;
+    case NurbsConsts.N_ERRORCHECKING:
+      errorchecking = (int) prop.value;
+      break;
+    case NurbsConsts.N_SUBDIVISIONS:
+      subdivisions = (int) prop.value;
+      break;
+    default:
+      // abort - end program
+      break;
+    }
+  }
+
+  /**
+   * Initialization
+   */
+  public void init() {
+    // DONE
+    maxsubdivisions = subdivisions;
+    if (maxsubdivisions < 0)
+      maxsubdivisions = 0;
+
+    if (display_method == NurbsConsts.N_FILL) {
+      wiretris = 0;
+      wirequads = 0;
+    } else if (display_method == NurbsConsts.N_OUTLINE_TRI) {
+      wiretris = 1;
+      wirequads = 0;
+    } else if (display_method == NurbsConsts.N_OUTLINE_QUAD) {
+      wiretris = 0;
+      wirequads = 1;
+    } else {
+      wiretris = 1;
+      wirequads = 1;
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Splinespec.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Splinespec.java
new file mode 100755
index 000000000..35288c67d
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Splinespec.java
@@ -0,0 +1,204 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * NURBS definition
+ * @author Tomas Hrasky
+ *
+ */
+public class Splinespec {
+
+  /**
+   * Dimension
+   */
+  private int dim;
+
+  /**
+   * Knot vector specs
+   */
+  private Knotspec kspec;
+
+  /**
+   * Control points after conversion
+   */
+  private CArrayOfFloats outcpts;
+
+  /**
+   * Makes new Splinespec with given dimension
+   * @param i dimension
+   */
+  public Splinespec(int i) {
+    // DONE
+    this.dim = i;
+  }
+
+  /**
+   * Initializes knotspec according to knotvector
+   * @param knotvector basic knotvector
+   */
+  public void kspecinit(Knotvector knotvector) {
+    // DONE
+    this.kspec = new Knotspec();
+    kspec.inkbegin = new CArrayOfFloats(knotvector.knotlist, 0);
+    kspec.inkend = new CArrayOfFloats(knotvector.knotlist,
+                                      knotvector.knotcount);
+    kspec.prestride = knotvector.stride;
+    kspec.order = knotvector.order;
+    kspec.next = null;
+  }
+
+  /**
+   * Initializes knotspec according to knotvector - SURFACE
+   * @param sknotvector knotvector in u dir
+   * @param tknotvector knotvector in v dir
+   */
+  public void kspecinit(Knotvector sknotvector, Knotvector tknotvector) {
+    // DONE
+    this.kspec = new Knotspec();
+    Knotspec tkspec = new Knotspec();
+
+    kspec.inkbegin = new CArrayOfFloats(sknotvector.knotlist, 0);
+    kspec.inkend = new CArrayOfFloats(sknotvector.knotlist,
+                                      sknotvector.knotcount);
+    kspec.prestride = sknotvector.stride;
+    kspec.order = sknotvector.order;
+    kspec.next = tkspec;
+
+    tkspec.inkbegin = new CArrayOfFloats(tknotvector.knotlist, 0);
+    tkspec.inkend = new CArrayOfFloats(tknotvector.knotlist,
+                                       tknotvector.knotcount);
+    tkspec.prestride = tknotvector.stride;
+    tkspec.order = tknotvector.order;
+    tkspec.next = null;
+  }
+
+  /**
+   * Preselect and select knotspecs
+   */
+  public void select() {
+    // DONE
+    for (Knotspec knotspec = kspec; knotspec != null; knotspec = knotspec.next) {
+      knotspec.preselect();
+      knotspec.select();
+    }
+
+  }
+
+  /**
+   * Prepares for conversion
+   * @param ncoords number of coords
+   */
+  public void layout(int ncoords) {
+    // DONE
+    int stride = ncoords;
+    for (Knotspec knotspec = kspec; knotspec != null; knotspec = knotspec.next) {
+      knotspec.poststride = stride;
+      stride *= (knotspec.bend.getPointer() - knotspec.bbegin
+                 .getPointer())
+        * knotspec.order + knotspec.postoffset;
+      knotspec.preoffset *= knotspec.prestride;
+      knotspec.prewidth *= knotspec.poststride;
+      knotspec.postwidth *= knotspec.poststride;
+      knotspec.postoffset *= knotspec.poststride;
+      knotspec.ncoords = ncoords;
+    }
+    outcpts = new CArrayOfFloats(new float[stride]);
+
+  }
+
+  /**
+   * Prepares quilt for conversion
+   * @param quilt quilt to work with
+   */
+  public void setupquilt(Quilt quilt) {
+    // DONE
+    CArrayOfQuiltspecs qspec = new CArrayOfQuiltspecs(quilt.qspec);
+    quilt.eqspec = new CArrayOfQuiltspecs(qspec.getArray(), dim);
+    for (Knotspec knotspec = kspec; knotspec != null;) {
+      qspec.get().stride = knotspec.poststride;
+      qspec.get().width = knotspec.bend.getPointer()
+        - knotspec.bbegin.getPointer();
+      qspec.get().order = knotspec.order;
+      qspec.get().offset = knotspec.postoffset;
+      qspec.get().index = 0;
+      qspec.get().bdry[0] = (knotspec.kleft.getPointer() == knotspec.kfirst
+                             .getPointer()) ? 1 : 0;
+      qspec.get().bdry[1] = (knotspec.kright.getPointer() == knotspec.klast
+                             .getPointer()) ? 1 : 0;
+      qspec.get().breakpoints = new float[qspec.get().width + 1];
+      CArrayOfFloats k = new CArrayOfFloats(qspec.get().breakpoints, 0);
+      for (CArrayOfBreakpts bk = new CArrayOfBreakpts(knotspec.bbegin); bk
+             .getPointer() <= knotspec.bend.getPointer(); bk.pp()) {
+        k.set(bk.get().value);
+        k.pp();
+      }
+      knotspec = knotspec.next;
+      if (knotspec != null)
+        qspec.pp();
+    }
+    quilt.cpts = new CArrayOfFloats(outcpts);
+    quilt.next = null;
+  }
+
+  /**
+   * Copies array of control points to output array
+   * @param ctlarray control points array
+   */
+  public void copy(CArrayOfFloats ctlarray) {
+    // DONE
+    kspec.copy(ctlarray, outcpts);
+
+  }
+
+  /**
+   * Transforms knotspecs - conversion
+   */
+  public void transform() {
+    // DONE
+    Knotspec knotspec;
+    outcpts.setPointer(0);
+    for (knotspec = kspec; knotspec != null; knotspec = knotspec.next)
+      knotspec.istransformed = false;
+
+    for (knotspec = kspec; knotspec != null; knotspec = knotspec.next) {
+      for (Knotspec kspec2 = kspec; kspec2 != null; kspec2 = kspec2.next)
+        kspec2.kspectotrans = knotspec;
+      kspec.transform(outcpts);
+      knotspec.istransformed = true;
+    }
+
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Subdivider.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Subdivider.java
new file mode 100755
index 000000000..b1506d6a1
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/Subdivider.java
@@ -0,0 +1,1167 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Class working with curves and surfaces
+ * @author Tomas Hrasky
+ *
+ */
+public class Subdivider {
+  /**
+   * Cull type 
+   */
+  public static final int CULL_TRIVIAL_REJECT = 0;
+
+  /**
+   * Cull type
+   */
+  public static final int CULL_ACCEPT = 1;
+
+  /**
+   * Maximum trimming arcs
+   */
+  private static final int MAXARCS = 10;
+
+  /**
+   * Linked list of Quilts
+   */
+  Quilt qlist;
+
+  /**
+   * Object holding rendering honts information
+   */
+  private Renderhints renderhints;
+
+  /**
+   * Backend object
+   */
+  private Backend backend;
+
+  /**
+   * Number of subdivisions
+   */
+  private int subdivisions;
+
+  /**
+   * U step when using domain distance sampling 
+   */
+  private float domain_distance_u_rate;
+
+  /**
+   * Use domain distance sampling
+   */
+  private int is_domain_distance_sampling;
+
+  /**
+   * Initial class holding trimming arcs
+   */
+  private Bin initialbin;
+
+  /**
+   * Not used
+   */
+  private boolean showDegenerate;
+
+  /**
+   * Is triming arc type bezier arc
+   */
+  private boolean isArcTypeBezier;
+
+  /**
+   * Breakpoints in v direction
+   */
+  private Flist tpbrkpts;
+
+  /**
+   * Breakpoints in u direction
+   */
+  private Flist spbrkpts;
+
+  /**
+   * Unused
+   */
+  private int s_index;
+
+  /**
+   * Head of linked list of trimming arcs
+   */
+  private Arc pjarc;
+
+  /**
+   * Class tesselating trimming arcs
+   */
+  private ArcTesselator arctesselator;
+
+  /**
+   * Unused
+   */
+  private int t_index;
+
+  /**
+   * Breakpoints
+   */
+  private Flist smbrkpts;
+
+  /**
+   * Not used
+   */
+  private float[] stepsizes;
+
+  /**
+   * Domain distance in V direction
+   */
+  private float domain_distance_v_rate;
+
+  /**
+   * Initializes quilt list
+   */
+  public void beginQuilts(Backend backend) {
+    // DONE
+    qlist = null;
+    renderhints = new Renderhints();
+    this.backend = backend;
+
+    initialbin = new Bin();
+    arctesselator = new ArcTesselator();
+  }
+
+  /**
+   * Adds quilt to linked list
+   * @param quilt added quilt
+   */
+  public void addQuilt(Quilt quilt) {
+    // DONE
+    if (qlist == null)
+      qlist = quilt;
+    else {
+      quilt.next = qlist;
+      qlist = quilt;
+    }
+
+  }
+
+  /**
+   * Empty method
+   */
+  public void endQuilts() {
+    // DONE
+  }
+
+  /**
+   * Draws a surface
+   */
+  public void drawSurfaces() {
+    renderhints.init();
+
+    if (qlist == null) {
+      //				System.out.println("qlist is null");
+      return;
+    }
+
+    for (Quilt q = qlist; q != null; q = q.next) {
+      if (q.isCulled() == CULL_TRIVIAL_REJECT) {
+        freejarcs(initialbin);
+        return;
+      }
+    }
+
+    float[] from = new float[2];
+    float[] to = new float[2];
+
+    spbrkpts = new Flist();
+    tpbrkpts = new Flist();
+    qlist.getRange(from, to, spbrkpts, tpbrkpts);
+
+    boolean optimize = (is_domain_distance_sampling > 0 && (renderhints.display_method != NurbsConsts.N_OUTLINE_PATCH));
+
+    // TODO decide whether to optimize (when there is gluNurbsProperty implemented)
+    optimize = true;
+
+    if (!initialbin.isnonempty()) {
+      if (!optimize) {
+        makeBorderTrim(from, to);
+      }
+    } else {
+      float[] rate = new float[2];
+      qlist.findRates(spbrkpts, tpbrkpts, rate);
+      //				System.out.println("subdivider.drawsurfaces decompose");
+    }
+
+    backend.bgnsurf(renderhints.wiretris, renderhints.wirequads);
+
+    // TODO partition test
+
+    if (!initialbin.isnonempty() && optimize) {
+
+      int i, j;
+      int num_u_steps;
+      int num_v_steps;
+      for (i = spbrkpts.start; i < spbrkpts.end - 1; i++) {
+        for (j = tpbrkpts.start; j < tpbrkpts.end - 1; j++) {
+          float[] pta = new float[2];
+          float[] ptb = new float[2];
+
+          pta[0] = spbrkpts.pts[i];
+          ptb[0] = spbrkpts.pts[i + 1];
+          pta[1] = tpbrkpts.pts[j];
+          ptb[1] = tpbrkpts.pts[j + 1];
+          qlist.downloadAll(pta, ptb, backend);
+
+          num_u_steps = (int) (domain_distance_u_rate * (ptb[0] - pta[0]));
+          num_v_steps = (int) (domain_distance_v_rate * (ptb[1] - pta[1]));
+
+          if (num_u_steps <= 0)
+            num_u_steps = 1;
+          if (num_v_steps <= 0)
+            num_v_steps = 1;
+
+          backend.surfgrid(pta[0], ptb[0], num_u_steps, ptb[1],
+                           pta[1], num_v_steps);
+          backend.surfmesh(0, 0, num_u_steps, num_v_steps);
+
+        }
+      }
+
+    } else
+
+      subdivideInS(initialbin);
+
+    backend.endsurf();
+  }
+
+  /**
+   * Empty method
+   * @param initialbin2
+   */
+  private void freejarcs(Bin initialbin2) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO subdivider.freejarcs");
+  }
+
+  /**
+   * Subdivide in U direction
+   * @param source Trimming arcs source
+   */
+  private void subdivideInS(Bin source) {
+    // DONE
+    if (renderhints.display_method == NurbsConsts.N_OUTLINE_PARAM) {
+      outline(source);
+      freejarcs(source);
+    } else {
+      setArcTypeBezier();
+      setNonDegenerate();
+      splitInS(source, spbrkpts.start, spbrkpts.end);
+    }
+
+  }
+
+  /**
+   * Split in U direction
+   * @param source Trimming arcs source
+   * @param start breakpoints start
+   * @param end breakpoints end
+   */
+  private void splitInS(Bin source, int start, int end) {
+    // DONE
+    if (source.isnonempty()) {
+      if (start != end) {
+        int i = start + (end - start) / 2;
+        Bin left = new Bin();
+        Bin right = new Bin();
+
+        split(source, left, right, 0, spbrkpts.pts[i]);
+        splitInS(left, start, i);
+        splitInS(right, i + 1, end);
+      } else {
+        if (start == spbrkpts.start || start == spbrkpts.end) {
+          freejarcs(source);
+        } else if (renderhints.display_method == NurbsConsts.N_OUTLINE_PARAM_S) {
+          outline(source);
+          freejarcs(source);
+        } else {
+          setArcTypeBezier();
+          setNonDegenerate();
+          s_index = start;
+          splitInT(source, tpbrkpts.start, tpbrkpts.end);
+        }
+      }
+    } else{
+      //				System.out.println("Source is empty - subdivider.splitins");
+    }
+  }
+
+  /**
+   * Split in V direction
+   * @param source
+   * @param start
+   * @param end
+   */
+  private void splitInT(Bin source, int start, int end) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO subdivider.splitint");
+
+    if (source.isnonempty()) {
+      if (start != end) {
+        int i = start + (end - start) / 2;
+        Bin left = new Bin();
+        Bin right = new Bin();
+        split(source, left, right, 1, tpbrkpts.pts[i + 1]);
+        splitInT(left, start, i);
+        splitInT(right, i + 1, end);
+      } else {
+        if (start == tpbrkpts.start || start == tpbrkpts.end) {
+          freejarcs(source);
+        } else if (renderhints.display_method == NurbsConsts.N_OUTLINE_PARAM_ST) {
+          outline(source);
+          freejarcs(source);
+        } else {
+          t_index = start;
+          setArcTypeBezier();
+          setDegenerate();
+
+          float[] pta = new float[2];
+          float[] ptb = new float[2];
+
+          pta[0] = spbrkpts.pts[s_index - 1];
+          pta[1] = tpbrkpts.pts[t_index - 1];
+
+          ptb[0] = spbrkpts.pts[s_index];
+          ptb[1] = tpbrkpts.pts[t_index];
+          qlist.downloadAll(pta, ptb, backend);
+
+          Patchlist patchlist = new Patchlist(qlist, pta, ptb);
+
+          samplingSplit(source, patchlist,
+                        renderhints.maxsubdivisions, 0);
+          setNonDegenerate();
+          setArcTypeBezier();
+        }
+      }
+    }
+
+  }
+
+  /**
+   * Sample 
+   * @param source
+   * @param patchlist
+   * @param subdivisions
+   * @param param
+   */
+  private void samplingSplit(Bin source, Patchlist patchlist,
+                             int subdivisions, int param) {
+    // DONE
+    if (!source.isnonempty())
+      return;
+    if (patchlist.cullCheck() == CULL_TRIVIAL_REJECT) {
+      freejarcs(source);
+      return;
+    }
+
+    patchlist.getstepsize();
+    if (renderhints.display_method == NurbsConsts.N_OUTLINE_PATCH) {
+      tesselation(source, patchlist);
+      outline(source);
+      freejarcs(source);
+      return;
+    }
+
+    tesselation(source, patchlist);
+    if (patchlist.needsSamplingSubdivision() && subdivisions > 0) {
+      if (!patchlist.needsSubdivision(0)) {
+        param = 1;
+      } else if (patchlist.needsSubdivision(1))
+        param = 0;
+      else
+        param = 1 - param;
+
+      Bin left = new Bin();
+      Bin right = new Bin();
+
+      float mid = (float) ((patchlist.pspec[param].range[0] + patchlist.pspec[param].range[1]) * .5);
+
+      split(source, left, right, param, mid);
+      Patchlist subpatchlist = new Patchlist(patchlist, param, mid);
+      samplingSplit(left, subpatchlist, subdivisions - 1, param);
+      samplingSplit(right, subpatchlist, subdivisions - 1, param);
+    } else {
+      setArcTypePwl();
+      setDegenerate();
+      nonSamplingSplit(source, patchlist, subdivisions, param);
+      setDegenerate();
+      setArcTypeBezier();
+    }
+  }
+
+  /**
+   * Not used
+   * @param source
+   * @param patchlist
+   * @param subdivisions
+   * @param param
+   */
+  private void nonSamplingSplit(Bin source, Patchlist patchlist,
+                                int subdivisions, int param) {
+    // DONE
+    if (patchlist.needsNonSamplingSubdivision() && subdivisions > 0) {
+      param = 1 - param;
+
+      Bin left = new Bin();
+      Bin right = new Bin();
+
+      float mid = (float) ((patchlist.pspec[param].range[0] + patchlist.pspec[param].range[1]) * .5);
+      split(source, left, right, param, mid);
+      Patchlist subpatchlist = new Patchlist(patchlist, param, mid);
+      if (left.isnonempty()) {
+        if (subpatchlist.cullCheck() == CULL_TRIVIAL_REJECT)
+          freejarcs(left);
+        else
+          nonSamplingSplit(left, subpatchlist, subdivisions - 1,
+                           param);
+      }
+      if (right.isnonempty()) {
+        if (patchlist.cullCheck() == CULL_TRIVIAL_REJECT)
+          freejarcs(right);
+        else
+          nonSamplingSplit(right, subpatchlist, subdivisions - 1,
+                           param);
+      }
+    } else {
+      patchlist.bbox();
+      backend.patch(patchlist.pspec[0].range[0],
+                    patchlist.pspec[0].range[1], patchlist.pspec[1].range[0],
+                    patchlist.pspec[1].range[1]);
+      if (renderhints.display_method == NurbsConsts.N_OUTLINE_SUBDIV) {
+        outline(source);
+        freejarcs(source);
+      } else {
+        setArcTypePwl();
+        setDegenerate();
+        findIrregularS(source);
+        monosplitInS(source, smbrkpts.start, smbrkpts.end);
+      }
+    }
+
+  }
+
+  /**
+   * Not used
+   * @param source
+   * @param start
+   * @param end
+   */
+  private void monosplitInS(Bin source, int start, int end) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO subdivider.monosplitins");
+  }
+
+  /**
+   * Not used
+   * @param source
+   */
+  private void findIrregularS(Bin source) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO subdivider.findIrregularS");
+  }
+
+  /**
+   * Not used
+   */
+  private void setArcTypePwl() {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO subdivider.setarctypepwl");
+  }
+
+  /**
+   * Not used
+   * @param source
+   * @param patchlist
+   */
+  private void tesselation(Bin source, Patchlist patchlist) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO subdivider.tesselation");
+  }
+
+  /**
+   * Not used
+   */
+  private void setDegenerate() {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO subdivider.setdegenerate");
+  }
+
+  /**
+   * Not used
+   * @param bin
+   * @param left
+   * @param right
+   * @param param
+   * @param value
+   */
+  private void split(Bin bin, Bin left, Bin right, int param, float value) {
+    // DONE
+    Bin intersections = new Bin();
+    Bin unknown = new Bin();
+
+    partition(bin, left, intersections, right, unknown, param, value);
+
+    int count = intersections.numarcs();
+    // TODO jumpbuffer ??
+
+    if (count % 2 == 0) {
+
+      Arc[] arclist = new Arc[MAXARCS];
+      CArrayOfArcs list;
+      if (count >= MAXARCS) {
+        list = new CArrayOfArcs(new Arc[count]);
+      } else {
+        list = new CArrayOfArcs(arclist);
+      }
+
+      CArrayOfArcs last, lptr;
+      Arc jarc;
+
+      for (last = new CArrayOfArcs(list); (jarc = intersections
+                                           .removearc()) != null; last.pp())
+        last.set(jarc);
+
+      if (param == 0) {// sort into incrasing t order
+        ArcSdirSorter sorter = new ArcSdirSorter(this);
+        sorter.qsort(list, count);
+
+        for (lptr = new CArrayOfArcs(list); lptr.getPointer() < last
+               .getPointer(); lptr.raisePointerBy(2))
+          check_s(lptr.get(), lptr.getRelative(1));
+        for (lptr = new CArrayOfArcs(list); lptr.getPointer() < last
+               .getPointer(); lptr.raisePointerBy(2))
+          join_s(left, right, lptr.get(), lptr.getRelative(1));
+        for (lptr = new CArrayOfArcs(list); lptr.getPointer() != last
+               .getPointer(); lptr.pp()) {
+          if (lptr.get().head()[0] <= value
+              && lptr.get().tail()[0] <= value)
+            left.addarc(lptr.get());
+          else
+            right.addarc(lptr.get());
+        }
+
+      } else {// sort into decreasing s order
+        ArcTdirSorter sorter = new ArcTdirSorter(this);
+        sorter.qsort(list, count);
+
+        for (lptr = new CArrayOfArcs(list); lptr.getPointer() < last
+               .getPointer(); lptr.raisePointerBy(2))
+          check_t(lptr.get(), lptr.getRelative(1));
+        for (lptr = new CArrayOfArcs(list); lptr.getPointer() < last
+               .getPointer(); lptr.raisePointerBy(2))
+          join_t(left, right, lptr.get(), lptr.getRelative(1));
+        for (lptr = new CArrayOfArcs(list); lptr.getPointer() != last
+               .getPointer(); lptr.raisePointerBy(2)) {
+          if (lptr.get().head()[0] <= value
+              && lptr.get().tail()[0] <= value)
+            left.addarc(lptr.get());
+          else
+            right.addarc(lptr.get());
+        }
+
+      }
+
+      unknown.adopt();
+    }
+  }
+
+  /**
+   * Not used
+   * @param left
+   * @param right
+   * @param arc
+   * @param relative
+   */
+  private void join_t(Bin left, Bin right, Arc arc, Arc relative) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO subdivider.join_t");
+  }
+
+  /**
+   * Not used
+   * @param arc
+   * @param relative
+   */
+  private void check_t(Arc arc, Arc relative) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO subdivider.check_t");
+  }
+
+  /**
+   * Not used
+   * @param left
+   * @param right
+   * @param jarc1
+   * @param jarc2
+   */
+  private void join_s(Bin left, Bin right, Arc jarc1, Arc jarc2) {
+    // DONE
+    if (!jarc1.getitail())
+      jarc1 = jarc1.next;
+    if (!jarc2.getitail())
+      jarc2 = jarc2.next;
+
+    float s = jarc1.tail()[0];
+    float t1 = jarc1.tail()[1];
+    float t2 = jarc2.tail()[1];
+
+    if (t1 == t2) {
+      simplelink(jarc1, jarc2);
+    } else {
+      Arc newright = new Arc(Arc.ARC_RIGHT);
+      Arc newleft = new Arc(Arc.ARC_LEFT);
+      if (isBezierArcType()) {
+        arctesselator.bezier(newright, s, s, t1, t2);
+        arctesselator.bezier(newleft, s, s, t2, t1);
+      } else {
+        arctesselator.pwl_right(newright, s, t1, t2, stepsizes[0]);
+        arctesselator.pwl_left(newright, s, t2, t1, stepsizes[2]);
+      }
+      link(jarc1, jarc2, newright, newleft);
+      left.addarc(newright);
+      right.addarc(newleft);
+    }
+
+  }
+
+  /**
+   * Not used
+   * @param jarc1
+   * @param jarc2
+   * @param newright
+   * @param newleft
+   */
+  private void link(Arc jarc1, Arc jarc2, Arc newright, Arc newleft) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO subdivider.link");
+  }
+
+  /**
+   * Not used
+   * @return true
+   */
+  private boolean isBezierArcType() {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO subdivider.isbezierarc");
+    return true;
+  }
+
+  /**
+   * Not used
+   * @param jarc1
+   * @param jarc2
+   */
+  private void simplelink(Arc jarc1, Arc jarc2) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO subdivider.simplelink");
+  }
+
+  /**
+   * Not used
+   * @param arc
+   * @param relative
+   */
+  private void check_s(Arc arc, Arc relative) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO subdivider.check_s");
+
+  }
+
+  /**
+   * Not used
+   * @param bin
+   * @param left
+   * @param intersections
+   * @param right
+   * @param unknown
+   * @param param
+   * @param value
+   */
+  private void partition(Bin bin, Bin left, Bin intersections, Bin right,
+                         Bin unknown, int param, float value) {
+
+    Bin headonleft = new Bin();
+    Bin headonright = new Bin();
+    Bin tailonleft = new Bin();
+    Bin tailonright = new Bin();
+
+    for (Arc jarc = bin.removearc(); jarc != null; jarc = bin.removearc()) {
+      float tdiff = jarc.tail()[param] - value;
+      float hdiff = jarc.head()[param] - value;
+
+      if (tdiff > 0) {
+        if (hdiff > 0) {
+          right.addarc(jarc);
+        } else if (hdiff == 0) {
+          tailonright.addarc(jarc);
+        } else {
+          Arc jtemp;
+          switch (arc_split(jarc, param, value, 0)) {
+          case 2:
+            tailonright.addarc(jarc);
+            headonleft.addarc(jarc.next);
+            break;
+            // TODO rest cases
+          default:
+            System.out
+              .println("TODO subdivider.partition rest cases");
+            break;
+          }
+        }
+      } else if (tdiff == 0) {
+        if (hdiff > 0) {
+          headonright.addarc(jarc);
+        } else if (hdiff == 0) {
+          unknown.addarc(jarc);
+        } else {
+          headonright.addarc(jarc);
+        }
+      } else {
+        if (hdiff > 0) {
+          // TODO rest
+          //						System.out.println("TODO subdivider.partition rest of else");
+        } else if (hdiff == 0) {
+          tailonleft.addarc(jarc);
+        } else {
+          left.addarc(jarc);
+        }
+      }
+
+    }
+    if (param == 0) {
+      classify_headonleft_s(headonleft, intersections, left, value);
+      classify_tailonleft_s(tailonleft, intersections, left, value);
+      classify_headonright_s(headonright, intersections, right, value);
+      classify_tailonright_s(tailonright, intersections, right, value);
+    } else {
+      classify_headonleft_t(headonleft, intersections, left, value);
+      classify_tailonleft_t(tailonleft, intersections, left, value);
+      classify_headonright_t(headonright, intersections, right, value);
+      classify_tailonright_t(tailonright, intersections, right, value);
+    }
+  }
+
+  /**
+   * Not used
+   * @param tailonright
+   * @param intersections
+   * @param right
+   * @param value
+   */
+  private void classify_tailonright_t(Bin tailonright, Bin intersections,
+                                      Bin right, float value) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO subdivider.classify_tailonright_t");
+
+  }
+
+  /**
+   * Not used
+   * @param bin
+   * @param in
+   * @param out
+   * @param val
+   */
+  private void classify_tailonleft_s(Bin bin, Bin in, Bin out, float val) {
+
+    // DONE
+    Arc j;
+    while ((j = bin.removearc()) != null) {
+      j.clearitail();
+
+      float diff = j.next.head()[0] - val;
+      if (diff > 0) {
+        in.addarc(j);
+      } else if (diff < 0) {
+        if (ccwTurn_sl(j, j.next))
+          out.addarc(j);
+        else
+          in.addarc(j);
+      } else {
+        if (j.next.tail()[1] > j.next.head()[1])
+          in.addarc(j);
+        else
+          out.addarc(j);
+      }
+    }
+
+  }
+
+  /**
+   * Not used
+   * @param bin
+   * @param in
+   * @param out
+   * @param val
+   */
+  private void classify_headonright_s(Bin bin, Bin in, Bin out, float val) {
+    // DONE
+    Arc j;
+    while ((j = bin.removearc()) != null) {
+      j.setitail();
+
+      float diff = j.prev.tail()[0] - val;
+      if (diff > 0) {
+        if (ccwTurn_sr(j.prev, j))
+          out.addarc(j);
+        else
+          in.addarc(j);
+      } else if (diff < 0) {
+        out.addarc(j);
+      } else {
+        if (j.prev.tail()[1] > j.prev.head()[1])
+          out.addarc(j);
+        else
+          in.addarc(j);
+      }
+    }
+  }
+
+  /**
+   * Not used
+   * @param prev
+   * @param j
+   * @return false
+   */
+  private boolean ccwTurn_sr(Arc prev, Arc j) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO ccwTurn_sr");
+    return false;
+  }
+
+  /**
+   * Not used
+   * @param headonright
+   * @param intersections
+   * @param right
+   * @param value
+   */
+  private void classify_headonright_t(Bin headonright, Bin intersections,
+                                      Bin right, float value) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO subdivider.classify_headonright_t");
+  }
+
+  /**
+   * Not used
+   * @param tailonleft
+   * @param intersections
+   * @param left
+   * @param value
+   */
+  private void classify_tailonleft_t(Bin tailonleft, Bin intersections,
+                                     Bin left, float value) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO subdivider.classify_tailonleft_t");
+  }
+
+  /**
+   * Not used
+   * @param bin
+   * @param in
+   * @param out
+   * @param val
+   */
+  private void classify_headonleft_t(Bin bin, Bin in, Bin out, float val) {
+    // DONE
+    Arc j;
+    while ((j = bin.removearc()) != null) {
+      j.setitail();
+
+      float diff = j.prev.tail()[1] - val;
+      if (diff > 0) {
+        out.addarc(j);
+      } else if (diff < 0) {
+        if (ccwTurn_tl(j.prev, j))
+          out.addarc(j);
+        else
+          in.addarc(j);
+      } else {
+        if (j.prev.tail()[0] > j.prev.head()[0])
+          out.addarc(j);
+        else
+          in.addarc(j);
+      }
+    }
+  }
+
+  /**
+   * Not used
+   * @param prev
+   * @param j
+   * @return false
+   */
+  private boolean ccwTurn_tl(Arc prev, Arc j) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO subdivider.ccwTurn_tl");
+    return false;
+  }
+
+  /**
+   * Not used
+   * @param bin
+   * @param in
+   * @param out
+   * @param val
+   */
+  private void classify_tailonright_s(Bin bin, Bin in, Bin out, float val) {
+    // DONE
+    Arc j;
+    while ((j = bin.removearc()) != null) {
+      j.clearitail();
+
+      float diff = j.next.head()[0] - val;
+      if (diff > 0) {
+        if (ccwTurn_sr(j, j.next))
+          out.addarc(j);
+        else
+          in.addarc(j);
+      } else if (diff < 0) {
+        in.addarc(j);
+      } else {
+        if (j.next.tail()[1] > j.next.head()[1])
+          out.addarc(j);
+        else
+          in.addarc(j);
+      }
+    }
+
+  }
+
+  /**
+   * Not used
+   * @param bin
+   * @param in
+   * @param out
+   * @param val
+   */
+  private void classify_headonleft_s(Bin bin, Bin in, Bin out, float val) {
+    // DONE
+    Arc j;
+    while ((j = bin.removearc()) != null) {
+      j.setitail();
+
+      float diff = j.prev.tail()[0] - val;
+      if (diff > 0) {
+        out.addarc(j);
+      } else if (diff < 0) {
+        if (ccwTurn_sl(j.prev, j))
+          out.addarc(j);
+        else
+          in.addarc(j);
+      } else {
+        if (j.prev.tail()[1] > j.prev.head()[1])
+          in.addarc(j);
+        else
+          out.addarc(j);
+      }
+    }
+
+  }
+
+  /**
+   * Not used
+   * @param prev
+   * @param j
+   * @return false
+   */
+  private boolean ccwTurn_sl(Arc prev, Arc j) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO subdivider.ccwTurn_sl");
+    return false;
+  }
+
+  /**
+   * Not used
+   * @param jarc
+   * @param param
+   * @param value
+   * @param i
+   * @return 0
+   */
+  private int arc_split(Arc jarc, int param, float value, int i) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO subdivider.arc_split");
+    return 0;
+  }
+
+  /**
+   * Not used
+   */
+  private void setNonDegenerate() {
+    // DONE
+    this.showDegenerate = false;
+
+  }
+
+  /**
+   * sets trimming arc default type to bezier
+   */
+  private void setArcTypeBezier() {
+    // DONE
+    isArcTypeBezier = true;
+  }
+
+  /**
+   * Not used
+   * @param source
+   */
+  private void outline(Bin source) {
+    // TODO Auto-generated method stub
+    //			System.out.println("TODO subdivider.outline");
+  }
+
+  /**
+   * Makes default trim along surface borders
+   * @param from range beginnings
+   * @param to range ends
+   */
+  private void makeBorderTrim(float[] from, float[] to) {
+    // DONE
+    float smin = from[0];
+    float smax = to[0];
+
+    float tmin = from[1];
+    float tmax = to[1];
+
+    pjarc = null;
+    Arc jarc = null;
+
+    jarc = new Arc(Arc.ARC_BOTTOM);
+    arctesselator.bezier(jarc, smin, smax, tmin, tmin);
+    initialbin.addarc(jarc);
+    pjarc = jarc.append(pjarc);
+
+    jarc = new Arc(Arc.ARC_RIGHT);
+    arctesselator.bezier(jarc, smax, smax, tmin, tmax);
+    initialbin.addarc(jarc);
+    pjarc = jarc.append(pjarc);
+
+    jarc = new Arc(Arc.ARC_TOP);
+    arctesselator.bezier(jarc, smax, smin, tmax, tmax);
+    initialbin.addarc(jarc);
+    pjarc = jarc.append(pjarc);
+
+    jarc = new Arc(Arc.ARC_LEFT);
+    arctesselator.bezier(jarc, smin, smin, tmax, tmin);
+    initialbin.addarc(jarc);
+    jarc = jarc.append(pjarc);
+
+    // assert (jarc.check() == true);
+  }
+
+  /**
+   * Draws NURBS curve
+   */
+  public void drawCurves() {
+    // DONE
+    float[] from = new float[1];
+    float[] to = new float[1];
+
+    Flist bpts = new Flist();
+    qlist.getRange(from, to, bpts);
+
+    renderhints.init();
+
+    backend.bgncurv();
+
+    for (int i = bpts.start; i < bpts.end - 1; i++) {
+      float[] pta = new float[1];
+      float[] ptb = new float[1];
+      pta[0] = bpts.pts[i];
+      ptb[0] = bpts.pts[i + 1];
+
+      qlist.downloadAll(pta, ptb, backend);
+      Curvelist curvelist = new Curvelist(qlist, pta, ptb);
+      samplingSplit(curvelist, renderhints.maxsubdivisions);
+    }
+    backend.endcurv();
+  }
+
+  /**
+   * Samples a curve in case of need, or sends curve to backend
+   * @param curvelist list of curves
+   * @param maxsubdivisions maximum number of subdivisions
+   */
+  private void samplingSplit(Curvelist curvelist, int maxsubdivisions) {
+    if (curvelist.cullCheck() == CULL_TRIVIAL_REJECT)
+      return;
+
+    curvelist.getstepsize();
+
+    if (curvelist.needsSamplingSubdivision() && (subdivisions > 0)) {
+      // TODO kód
+      //				System.out.println("TODO subdivider-needsSamplingSubdivision");
+    } else {
+      int nu = (int) (1 + curvelist.range[2] / curvelist.stepsize);
+      backend.curvgrid(curvelist.range[0], curvelist.range[1], nu);
+      backend.curvmesh(0, nu);
+    }
+
+  }
+
+  /**
+   * Sets new domain_distance_u_rate value
+   * @param d new domain_distance_u_rate value
+
+  */
+  public void set_domain_distance_u_rate(double d) {
+    // DONE
+    domain_distance_u_rate = (float) d;
+  }
+
+  /**
+   * Sets new domain_distance_v_rate value
+   * @param d new domain_distance_v_rate value
+   */
+  public void set_domain_distance_v_rate(double d) {
+    // DONE
+    domain_distance_v_rate = (float) d;
+  }
+
+  /**
+   * Sets new is_domain_distance_sampling value
+   * @param i new is_domain_distance_sampling value
+   */
+  public void set_is_domain_distance_sampling(int i) {
+    // DONE
+    this.is_domain_distance_sampling = i;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/SurfaceEvaluator.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/SurfaceEvaluator.java
new file mode 100755
index 000000000..feb3bc9a7
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/SurfaceEvaluator.java
@@ -0,0 +1,111 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Class rendering surfaces with OpenGL
+ * @author Tomas Hrasky
+ *
+ */
+public interface SurfaceEvaluator {
+
+  /**
+   * Pushes eval bit
+   */
+  public void bgnmap2f() ;
+
+  /**
+   * Sets  glPolygonMode
+   * @param style polygon mode (N_MESHFILL/N_MESHLINE/N_MESHPOINT)
+   */
+  public void polymode(int style) ;
+
+  /**
+   * Pops all attributes
+   */
+  public void endmap2f() ;
+
+  /**
+   * Empty method
+   * @param ulo
+   * @param uhi
+   * @param vlo
+   * @param vhi
+   */
+  public void domain2f(float ulo, float uhi, float vlo, float vhi) ;
+
+  /**
+   * Defines 2D mesh
+   * @param nu number of steps in u direction
+   * @param u0 lowest u
+   * @param u1 highest u
+   * @param nv number of steps in v direction
+   * @param v0 lowest v
+   * @param v1 highest v
+   */
+  public void mapgrid2f(int nu, float u0, float u1, int nv, float v0, float v1) ;
+
+  /**
+   * Evaluates surface
+   * @param style surface style
+   * @param umin minimum U
+   * @param umax maximum U
+   * @param vmin minimum V
+   * @param vmax maximum V
+   */
+  public void mapmesh2f(int style, int umin, int umax, int vmin, int vmax) ;
+
+  /**
+   * Initializes evaluator
+   * @param type surface type
+   * @param ulo lowest u
+   * @param uhi highest u
+   * @param ustride number of objects between control points in u direction
+   * @param uorder surface order in u direction
+   * @param vlo lowest v
+   * @param vhi highest v
+   * @param vstride number of control points' coords
+   * @param vorder surface order in v direction
+   * @param pts control points
+   */
+  public void map2f(int type, float ulo, float uhi, int ustride, int uorder,
+                    float vlo, float vhi, int vstride, int vorder, CArrayOfFloats pts) ;
+
+  /**
+   * Calls opengl enable
+   * @param type what to enable
+   */
+  public void enable(int type) ;
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/TrimVertex.java b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/TrimVertex.java
new file mode 100755
index 000000000..ec3f6fc10
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/nurbs/TrimVertex.java
@@ -0,0 +1,56 @@
+package com.sun.opengl.impl.glu.nurbs;
+
+/*
+ ** License Applicability. Except to the extent portions of this file are
+ ** made subject to an alternative license as permitted in the SGI Free
+ ** Software License B, Version 1.1 (the "License"), the contents of this
+ ** file are subject only to the provisions of the License. You may not use
+ ** this file except in compliance with the License. You may obtain a copy
+ ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ **
+ ** http://oss.sgi.com/projects/FreeB
+ **
+ ** Note that, as provided in the License, the Software is distributed on an
+ ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ **
+ ** Original Code. The Original Code is: OpenGL Sample Implementation,
+ ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ ** Copyright in any portions created by third parties is as indicated
+ ** elsewhere herein. All Rights Reserved.
+ **
+ ** Additional Notice Provisions: The application programming interfaces
+ ** established by SGI in conjunction with the Original Code are The
+ ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ ** Window System(R) (Version 1.3), released October 19, 1998. This software
+ ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ ** published by SGI, but has not been independently verified as being
+ ** compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+/**
+ * Holds vertex used in trim
+ * 
+ * @author Tomas Hrasky
+ * 
+ */
+public class TrimVertex {
+
+  /**
+   * Trim vertex coords
+   */
+  public float[] param;
+
+  /**
+   * Makes new empty trim vertex
+   */
+  public TrimVertex() {
+    param = new float[2];
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/registry/Registry.java b/src/jogl/classes/com/sun/opengl/impl/glu/registry/Registry.java
new file mode 100644
index 000000000..488a3c0f2
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/registry/Registry.java
@@ -0,0 +1,79 @@
+/*
+ * License Applicability. Except to the extent portions of this file are
+ * made subject to an alternative license as permitted in the SGI Free
+ * Software License B, Version 1.1 (the "License"), the contents of this
+ * file are subject only to the provisions of the License. You may not use
+ * this file except in compliance with the License. You may obtain a copy
+ * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+ * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+ * 
+ * http://oss.sgi.com/projects/FreeB
+ * 
+ * Note that, as provided in the License, the Software is distributed on an
+ * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+ * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+ * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ * 
+ * NOTE:  The Original Code (as defined below) has been licensed to Sun
+ * Microsystems, Inc. ("Sun") under the SGI Free Software License B
+ * (Version 1.1), shown above ("SGI License").   Pursuant to Section
+ * 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+ * you under an alternative license ("Alternative License").  This
+ * Alternative License includes all of the provisions of the SGI License
+ * except that Section 2.2 and 11 are omitted.  Any differences between
+ * the Alternative License and the SGI License are offered solely by Sun
+ * and not by SGI.
+ *
+ * Original Code. The Original Code is: OpenGL Sample Implementation,
+ * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+ * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+ * Copyright in any portions created by third parties is as indicated
+ * elsewhere herein. All Rights Reserved.
+ * 
+ * Additional Notice Provisions: The application programming interfaces
+ * established by SGI in conjunction with the Original Code are The
+ * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+ * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+ * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+ * Window System(R) (Version 1.3), released October 19, 1998. This software
+ * was created using the OpenGL(R) version 1.2.1 Sample Implementation
+ * published by SGI, but has not been independently verified as being
+ * compliant with the OpenGL(R) version 1.2.1 Specification.
+ */
+
+package com.sun.opengl.impl.glu.registry;
+
+import javax.media.opengl.glu.GLU;
+
+/**
+ *
+ * @author  Administrator
+ */
+public class Registry {
+  
+  /** Creates a new instance of Registry */
+  public Registry() {
+  }
+  
+  public static String gluGetString(int name) {
+    if( name == GLU.GLU_VERSION ) {
+      return( "1.3" );
+    } else if( name == GLU.GLU_EXTENSIONS ) {
+      return( "GLU_EXT_nurbs_tessellator GLU_EXT_object_space_tess " );
+    }
+    return( null );
+  }
+  
+  public static boolean gluCheckExtension( String extName, String extString ) {
+    if( extName == null || extString == null ) {
+      return( false );
+    }
+    if ((extString.indexOf(extName + " ") >= 0) ||
+        extString.endsWith(extName) ||
+        extString.equals(extName)) {
+        return true;
+    }
+    return false;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/ActiveRegion.java b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/ActiveRegion.java
new file mode 100644
index 000000000..a04c5c74b
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/ActiveRegion.java
@@ -0,0 +1,69 @@
+/*
+* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
+* All rights reserved.
+*/
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** Author: Eric Veach, July 1994
+** Java Port: Pepijn Van Eeckhoudt, July 2003
+** Java Port: Nathan Parker Burg, August 2003
+*/
+package com.sun.opengl.impl.glu.tessellator;
+
+
+class ActiveRegion {
+    GLUhalfEdge eUp;		/* upper edge, directed right to left */
+    DictNode nodeUp;	/* dictionary node corresponding to eUp */
+    int windingNumber;	/* used to determine which regions are
+                                 * inside the polygon */
+    boolean inside;		/* is this region inside the polygon? */
+    boolean sentinel;	/* marks fake edges at t = +/-infinity */
+    boolean dirty;		/* marks regions where the upper or lower
+                                 * edge has changed, but we haven't checked
+                                 * whether they intersect yet */
+    boolean fixUpperEdge;	/* marks temporary edges introduced when
+                                 * we process a "right vertex" (one without
+                                 * any edges leaving to the right) */
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/CachedVertex.java b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/CachedVertex.java
new file mode 100644
index 000000000..993671c0d
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/CachedVertex.java
@@ -0,0 +1,58 @@
+/*
+* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
+* All rights reserved.
+*/
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** Author: Eric Veach, July 1994
+** Java Port: Pepijn Van Eeckhoudt, July 2003
+** Java Port: Nathan Parker Burg, August 2003
+*/
+package com.sun.opengl.impl.glu.tessellator;
+
+class CachedVertex {
+    public double[] coords = new double[3];
+    public Object data;
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/Dict.java b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/Dict.java
new file mode 100644
index 000000000..d2f6e3790
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/Dict.java
@@ -0,0 +1,140 @@
+/*
+* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
+* All rights reserved.
+*/
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** Author: Eric Veach, July 1994
+** Java Port: Pepijn Van Eeckhoudt, July 2003
+** Java Port: Nathan Parker Burg, August 2003
+*/
+package com.sun.opengl.impl.glu.tessellator;
+
+class Dict {
+    DictNode head;
+    Object frame;
+    DictLeq leq;
+
+    private Dict() {
+    }
+
+    static Dict dictNewDict(Object frame, DictLeq leq) {
+        Dict dict = new Dict();
+        dict.head = new DictNode();
+
+        dict.head.key = null;
+        dict.head.next = dict.head;
+        dict.head.prev = dict.head;
+
+        dict.frame = frame;
+        dict.leq = leq;
+
+        return dict;
+    }
+
+    static void dictDeleteDict(Dict dict) {
+        dict.head = null;
+        dict.frame = null;
+        dict.leq = null;
+    }
+
+    static DictNode dictInsert(Dict dict, Object key) {
+        return dictInsertBefore(dict, dict.head, key);
+    }
+
+    static DictNode dictInsertBefore(Dict dict, DictNode node, Object key) {
+        do {
+            node = node.prev;
+        } while (node.key != null && !dict.leq.leq(dict.frame, node.key, key));
+
+        DictNode newNode = new DictNode();
+        newNode.key = key;
+        newNode.next = node.next;
+        node.next.prev = newNode;
+        newNode.prev = node;
+        node.next = newNode;
+
+        return newNode;
+    }
+
+    static Object dictKey(DictNode aNode) {
+        return aNode.key;
+    }
+
+    static DictNode dictSucc(DictNode aNode) {
+        return aNode.next;
+    }
+
+    static DictNode dictPred(DictNode aNode) {
+        return aNode.prev;
+    }
+
+    static DictNode dictMin(Dict aDict) {
+        return aDict.head.next;
+    }
+
+    static DictNode dictMax(Dict aDict) {
+        return aDict.head.prev;
+    }
+
+    static void dictDelete(Dict dict, DictNode node) {
+        node.next.prev = node.prev;
+        node.prev.next = node.next;
+    }
+
+    static DictNode dictSearch(Dict dict, Object key) {
+        DictNode node = dict.head;
+
+        do {
+            node = node.next;
+        } while (node.key != null && !(dict.leq.leq(dict.frame, key, node.key)));
+
+        return node;
+    }
+
+    public interface DictLeq {
+        boolean leq(Object frame, Object key1, Object key2);
+    }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/DictNode.java b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/DictNode.java
new file mode 100644
index 000000000..1222bd948
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/DictNode.java
@@ -0,0 +1,59 @@
+/*
+* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
+* All rights reserved.
+*/
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** Author: Eric Veach, July 1994
+** Java Port: Pepijn Van Eeckhoudt, July 2003
+** Java Port: Nathan Parker Burg, August 2003
+*/
+package com.sun.opengl.impl.glu.tessellator;
+
+class DictNode {
+    Object key;
+    DictNode next;
+    DictNode prev;
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/GLUface.java b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/GLUface.java
new file mode 100644
index 000000000..f0589dbea
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/GLUface.java
@@ -0,0 +1,65 @@
+/*
+* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
+* All rights reserved.
+*/
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** Author: Eric Veach, July 1994
+** Java Port: Pepijn Van Eeckhoudt, July 2003
+** Java Port: Nathan Parker Burg, August 2003
+*/
+package com.sun.opengl.impl.glu.tessellator;
+
+class GLUface {
+    public GLUface next;		/* next face (never NULL) */
+    public GLUface prev;		/* previous face (never NULL) */
+    public GLUhalfEdge anEdge;	/* a half edge with this left face */
+    public Object data;		/* room for client's data */
+
+    /* Internal data (keep hidden) */
+    public GLUface trail;		/* "stack" for conversion to strips */
+    public boolean marked;		/* flag for conversion to strips */
+    public boolean inside;		/* this face is in the polygon interior */
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/GLUhalfEdge.java b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/GLUhalfEdge.java
new file mode 100644
index 000000000..1b6e81cc5
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/GLUhalfEdge.java
@@ -0,0 +1,71 @@
+/*
+* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
+* All rights reserved.
+*/
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** Author: Eric Veach, July 1994
+** Java Port: Pepijn Van Eeckhoudt, July 2003
+** Java Port: Nathan Parker Burg, August 2003
+*/
+package com.sun.opengl.impl.glu.tessellator;
+
+class GLUhalfEdge {
+    public GLUhalfEdge next;		/* doubly-linked list (prev==Sym->next) */
+    public GLUhalfEdge Sym;		/* same edge, opposite direction */
+    public GLUhalfEdge Onext;		/* next edge CCW around origin */
+    public GLUhalfEdge Lnext;		/* next edge CCW around left face */
+    public GLUvertex Org;		/* origin vertex (Overtex too long) */
+    public com.sun.opengl.impl.glu.tessellator.GLUface Lface;		/* left face */
+
+    /* Internal data (keep hidden) */
+    public com.sun.opengl.impl.glu.tessellator.ActiveRegion activeRegion;	/* a region with this upper edge (sweep.c) */
+    public int winding;	/* change in winding number when crossing */
+    public boolean first;
+
+    public GLUhalfEdge(boolean first) {
+        this.first = first;
+    }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/GLUmesh.java b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/GLUmesh.java
new file mode 100644
index 000000000..73fbe815e
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/GLUmesh.java
@@ -0,0 +1,60 @@
+/*
+* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
+* All rights reserved.
+*/
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** Author: Eric Veach, July 1994
+** Java Port: Pepijn Van Eeckhoudt, July 2003
+** Java Port: Nathan Parker Burg, August 2003
+*/
+package com.sun.opengl.impl.glu.tessellator;
+
+class GLUmesh {
+    GLUvertex vHead = new GLUvertex();		/* dummy header for vertex list */
+    com.sun.opengl.impl.glu.tessellator.GLUface fHead = new GLUface();		/* dummy header for face list */
+    com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eHead = new GLUhalfEdge(true);		/* dummy header for edge list */
+    com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eHeadSym = new GLUhalfEdge(false);	/* and its symmetric counterpart */
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/GLUtessellatorImpl.java b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/GLUtessellatorImpl.java
new file mode 100644
index 000000000..f4efb116a
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/GLUtessellatorImpl.java
@@ -0,0 +1,646 @@
+/*
+* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
+* All rights reserved.
+*/
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** Author: Eric Veach, July 1994
+** Java Port: Pepijn Van Eeckhoudt, July 2003
+** Java Port: Nathan Parker Burg, August 2003
+*/
+package com.sun.opengl.impl.glu.tessellator;
+
+import com.sun.opengl.impl.glu.tessellator.*;
+import javax.media.opengl.*;
+import javax.media.opengl.glu.*;
+
+public class GLUtessellatorImpl implements GLUtessellator {
+    public static final int TESS_MAX_CACHE = 100;
+
+    private int state;		/* what begin/end calls have we seen? */
+
+    private GLUhalfEdge lastEdge;	/* lastEdge->Org is the most recent vertex */
+    GLUmesh mesh;		/* stores the input contours, and eventually
+                                   the tessellation itself */
+
+    /*** state needed for projecting onto the sweep plane ***/
+
+    double[] normal = new double[3];	/* user-specified normal (if provided) */
+    double[] sUnit = new double[3];	/* unit vector in s-direction (debugging) */
+    double[] tUnit = new double[3];	/* unit vector in t-direction (debugging) */
+
+    /*** state needed for the line sweep ***/
+
+    private double relTolerance;	/* tolerance for merging features */
+    int windingRule;	/* rule for determining polygon interior */
+    boolean fatalError;	/* fatal error: needed combine callback */
+
+    Dict dict;		/* edge dictionary for sweep line */
+    PriorityQ pq;		/* priority queue of vertex events */
+    GLUvertex event;		/* current sweep event being processed */
+
+    /*** state needed for rendering callbacks (see render.c) ***/
+
+    boolean flagBoundary;	/* mark boundary edges (use EdgeFlag) */
+    boolean boundaryOnly;	/* Extract contours, not triangles */
+    boolean avoidDegenerateTris; /* JOGL-specific hint to try to improve triangulation
+                                    by avoiding producing degenerate (zero-area) triangles;
+                                    has not been tested exhaustively and is therefore an option */
+
+    GLUface lonelyTriList;
+    /* list of triangles which could not be rendered as strips or fans */
+
+
+
+    /*** state needed to cache single-contour polygons for renderCache() */
+
+    private boolean flushCacheOnNextVertex;		/* empty cache on next vertex() call */
+    int cacheCount;		/* number of cached vertices */
+    CachedVertex[] cache = new CachedVertex[TESS_MAX_CACHE];	/* the vertex data */
+
+    /*** rendering callbacks that also pass polygon data  ***/
+    private Object polygonData;		/* client data for current polygon */
+
+    private GLUtessellatorCallback callBegin;
+    private GLUtessellatorCallback callEdgeFlag;
+    private GLUtessellatorCallback callVertex;
+    private GLUtessellatorCallback callEnd;
+//    private GLUtessellatorCallback callMesh;
+    private GLUtessellatorCallback callError;
+    private GLUtessellatorCallback callCombine;
+
+    private GLUtessellatorCallback callBeginData;
+    private GLUtessellatorCallback callEdgeFlagData;
+    private GLUtessellatorCallback callVertexData;
+    private GLUtessellatorCallback callEndData;
+//    private GLUtessellatorCallback callMeshData;
+    private GLUtessellatorCallback callErrorData;
+    private GLUtessellatorCallback callCombineData;
+
+    private static final double GLU_TESS_DEFAULT_TOLERANCE = 0.0;
+//    private static final int GLU_TESS_MESH = 100112;	/* void (*)(GLUmesh *mesh)	    */
+    private static GLUtessellatorCallback NULL_CB = new GLUtessellatorCallbackAdapter();
+
+//    #define MAX_FAST_ALLOC	(MAX(sizeof(EdgePair), \
+//                 MAX(sizeof(GLUvertex),sizeof(GLUface))))
+
+    private GLUtessellatorImpl() {
+        state = TessState.T_DORMANT;
+
+        normal[0] = 0;
+        normal[1] = 0;
+        normal[2] = 0;
+
+        relTolerance = GLU_TESS_DEFAULT_TOLERANCE;
+        windingRule = GLU.GLU_TESS_WINDING_ODD;
+        flagBoundary = false;
+        boundaryOnly = false;
+
+        callBegin = NULL_CB;
+        callEdgeFlag = NULL_CB;
+        callVertex = NULL_CB;
+        callEnd = NULL_CB;
+        callError = NULL_CB;
+        callCombine = NULL_CB;
+//        callMesh = NULL_CB;
+
+        callBeginData = NULL_CB;
+        callEdgeFlagData = NULL_CB;
+        callVertexData = NULL_CB;
+        callEndData = NULL_CB;
+        callErrorData = NULL_CB;
+        callCombineData = NULL_CB;
+
+        polygonData = null;
+
+        for (int i = 0; i < cache.length; i++) {
+            cache[i] = new CachedVertex();
+        }
+    }
+
+    static public GLUtessellator gluNewTess()
+    {
+        return new GLUtessellatorImpl();
+    }
+
+
+    private void makeDormant() {
+        /* Return the tessellator to its original dormant state. */
+
+        if (mesh != null) {
+            Mesh.__gl_meshDeleteMesh(mesh);
+        }
+        state = TessState.T_DORMANT;
+        lastEdge = null;
+        mesh = null;
+    }
+
+    private void requireState(int newState) {
+        if (state != newState) gotoState(newState);
+    }
+
+    private void gotoState(int newState) {
+        while (state != newState) {
+            /* We change the current state one level at a time, to get to
+             * the desired state.
+             */
+            if (state < newState) {
+                if (state == TessState.T_DORMANT) {
+                    callErrorOrErrorData(GLU.GLU_TESS_MISSING_BEGIN_POLYGON);
+                    gluTessBeginPolygon(null);
+                } else if (state == TessState.T_IN_POLYGON) {
+                    callErrorOrErrorData(GLU.GLU_TESS_MISSING_BEGIN_CONTOUR);
+                    gluTessBeginContour();
+                }
+            } else {
+                if (state == TessState.T_IN_CONTOUR) {
+                    callErrorOrErrorData(GLU.GLU_TESS_MISSING_END_CONTOUR);
+                    gluTessEndContour();
+                } else if (state == TessState.T_IN_POLYGON) {
+                    callErrorOrErrorData(GLU.GLU_TESS_MISSING_END_POLYGON);
+                    /* gluTessEndPolygon( tess ) is too much work! */
+                    makeDormant();
+                }
+            }
+        }
+    }
+
+    public void gluDeleteTess() {
+        requireState(TessState.T_DORMANT);
+    }
+
+    public void gluTessProperty(int which, double value) {
+        switch (which) {
+            case GLU.GLU_TESS_TOLERANCE:
+                if (value < 0.0 || value > 1.0) break;
+                relTolerance = value;
+                return;
+
+            case GLU.GLU_TESS_WINDING_RULE:
+                int windingRule = (int) value;
+                if (windingRule != value) break;	/* not an integer */
+
+                switch (windingRule) {
+                    case GLU.GLU_TESS_WINDING_ODD:
+                    case GLU.GLU_TESS_WINDING_NONZERO:
+                    case GLU.GLU_TESS_WINDING_POSITIVE:
+                    case GLU.GLU_TESS_WINDING_NEGATIVE:
+                    case GLU.GLU_TESS_WINDING_ABS_GEQ_TWO:
+                        this.windingRule = windingRule;
+                        return;
+                    default:
+                        break;
+                }
+
+            case GLU.GLU_TESS_BOUNDARY_ONLY:
+                boundaryOnly = (value != 0);
+                return;
+
+            case GLU.GLU_TESS_AVOID_DEGENERATE_TRIANGLES:
+                avoidDegenerateTris = (value != 0);
+                return;
+
+            default:
+                callErrorOrErrorData(GLU.GLU_INVALID_ENUM);
+                return;
+        }
+        callErrorOrErrorData(GLU.GLU_INVALID_VALUE);
+    }
+
+/* Returns tessellator property */
+    public void gluGetTessProperty(int which, double[] value, int value_offset) {
+        switch (which) {
+            case GLU.GLU_TESS_TOLERANCE:
+/* tolerance should be in range [0..1] */
+                assert (0.0 <= relTolerance && relTolerance <= 1.0);
+                value[value_offset] = relTolerance;
+                break;
+            case GLU.GLU_TESS_WINDING_RULE:
+                assert (windingRule == GLU.GLU_TESS_WINDING_ODD ||
+                        windingRule == GLU.GLU_TESS_WINDING_NONZERO ||
+                        windingRule == GLU.GLU_TESS_WINDING_POSITIVE ||
+                        windingRule == GLU.GLU_TESS_WINDING_NEGATIVE ||
+                        windingRule == GLU.GLU_TESS_WINDING_ABS_GEQ_TWO);
+                value[value_offset] = windingRule;
+                break;
+            case GLU.GLU_TESS_BOUNDARY_ONLY:
+                assert (boundaryOnly == true || boundaryOnly == false);
+                value[value_offset] = boundaryOnly ? 1 : 0;
+                break;
+            case GLU.GLU_TESS_AVOID_DEGENERATE_TRIANGLES:
+                value[value_offset] = avoidDegenerateTris ? 1 : 0;
+                break;
+            default:
+                value[value_offset] = 0.0;
+                callErrorOrErrorData(GLU.GLU_INVALID_ENUM);
+                break;
+        }
+    } /* gluGetTessProperty() */
+
+    public void gluTessNormal(double x, double y, double z) {
+        normal[0] = x;
+        normal[1] = y;
+        normal[2] = z;
+    }
+
+    public void gluTessCallback(int which, GLUtessellatorCallback aCallback) {
+        switch (which) {
+            case GLU.GLU_TESS_BEGIN:
+                callBegin = aCallback == null ? NULL_CB : aCallback;
+                return;
+            case GLU.GLU_TESS_BEGIN_DATA:
+                callBeginData = aCallback == null ? NULL_CB : aCallback;
+                return;
+            case GLU.GLU_TESS_EDGE_FLAG:
+                callEdgeFlag = aCallback == null ? NULL_CB : aCallback;
+/* If the client wants boundary edges to be flagged,
+ * we render everything as separate triangles (no strips or fans).
+ */
+                flagBoundary = aCallback != null;
+                return;
+            case GLU.GLU_TESS_EDGE_FLAG_DATA:
+                callEdgeFlagData = callBegin = aCallback == null ? NULL_CB : aCallback;
+/* If the client wants boundary edges to be flagged,
+ * we render everything as separate triangles (no strips or fans).
+ */
+                flagBoundary = (aCallback != null);
+                return;
+            case GLU.GLU_TESS_VERTEX:
+                callVertex = aCallback == null ? NULL_CB : aCallback;
+                return;
+            case GLU.GLU_TESS_VERTEX_DATA:
+                callVertexData = aCallback == null ? NULL_CB : aCallback;
+                return;
+            case GLU.GLU_TESS_END:
+                callEnd = aCallback == null ? NULL_CB : aCallback;
+                return;
+            case GLU.GLU_TESS_END_DATA:
+                callEndData = aCallback == null ? NULL_CB : aCallback;
+                return;
+            case GLU.GLU_TESS_ERROR:
+                callError = aCallback == null ? NULL_CB : aCallback;
+                return;
+            case GLU.GLU_TESS_ERROR_DATA:
+                callErrorData = aCallback == null ? NULL_CB : aCallback;
+                return;
+            case GLU.GLU_TESS_COMBINE:
+                callCombine = aCallback == null ? NULL_CB : aCallback;
+                return;
+            case GLU.GLU_TESS_COMBINE_DATA:
+                callCombineData = aCallback == null ? NULL_CB : aCallback;
+                return;
+//            case GLU_TESS_MESH:
+//                callMesh = aCallback == null ? NULL_CB : aCallback;
+//                return;
+            default:
+                callErrorOrErrorData(GLU.GLU_INVALID_ENUM);
+                return;
+        }
+    }
+
+    private boolean addVertex(double[] coords, Object vertexData) {
+        GLUhalfEdge e;
+
+        e = lastEdge;
+        if (e == null) {
+/* Make a self-loop (one vertex, one edge). */
+
+            e = Mesh.__gl_meshMakeEdge(mesh);
+            if (e == null) return false;
+            if (!Mesh.__gl_meshSplice(e, e.Sym)) return false;
+        } else {
+/* Create a new vertex and edge which immediately follow e
+ * in the ordering around the left face.
+ */
+            if (Mesh.__gl_meshSplitEdge(e) == null) return false;
+            e = e.Lnext;
+        }
+
+/* The new vertex is now e.Org. */
+        e.Org.data = vertexData;
+        e.Org.coords[0] = coords[0];
+        e.Org.coords[1] = coords[1];
+        e.Org.coords[2] = coords[2];
+
+/* The winding of an edge says how the winding number changes as we
+ * cross from the edge''s right face to its left face.  We add the
+ * vertices in such an order that a CCW contour will add +1 to
+ * the winding number of the region inside the contour.
+ */
+        e.winding = 1;
+        e.Sym.winding = -1;
+
+        lastEdge = e;
+
+        return true;
+    }
+
+    private void cacheVertex(double[] coords, Object vertexData) {
+        if (cache[cacheCount] == null) {
+            cache[cacheCount] = new CachedVertex();
+        }
+
+        CachedVertex v = cache[cacheCount];
+
+        v.data = vertexData;
+        v.coords[0] = coords[0];
+        v.coords[1] = coords[1];
+        v.coords[2] = coords[2];
+        ++cacheCount;
+    }
+
+
+    private boolean flushCache() {
+        CachedVertex[] v = cache;
+
+        mesh = Mesh.__gl_meshNewMesh();
+        if (mesh == null) return false;
+
+        for (int i = 0; i < cacheCount; i++) {
+            CachedVertex vertex = v[i];
+            if (!addVertex(vertex.coords, vertex.data)) return false;
+        }
+        cacheCount = 0;
+        flushCacheOnNextVertex = false;
+
+        return true;
+    }
+
+    public void gluTessVertex(double[] coords, int coords_offset, Object vertexData) {
+        int i;
+        boolean tooLarge = false;
+        double x;
+        double[] clamped = new double[3];
+
+        requireState(TessState.T_IN_CONTOUR);
+
+        if (flushCacheOnNextVertex) {
+            if (!flushCache()) {
+                callErrorOrErrorData(GLU.GLU_OUT_OF_MEMORY);
+                return;
+            }
+            lastEdge = null;
+        }
+        for (i = 0; i < 3; ++i) {
+            x = coords[i+coords_offset];
+            if (x < -GLU.GLU_TESS_MAX_COORD) {
+                x = -GLU.GLU_TESS_MAX_COORD;
+                tooLarge = true;
+            }
+            if (x > GLU.GLU_TESS_MAX_COORD) {
+                x = GLU.GLU_TESS_MAX_COORD;
+                tooLarge = true;
+            }
+            clamped[i] = x;
+        }
+        if (tooLarge) {
+            callErrorOrErrorData(GLU.GLU_TESS_COORD_TOO_LARGE);
+        }
+
+        if (mesh == null) {
+            if (cacheCount < TESS_MAX_CACHE) {
+                cacheVertex(clamped, vertexData);
+                return;
+            }
+            if (!flushCache()) {
+                callErrorOrErrorData(GLU.GLU_OUT_OF_MEMORY);
+                return;
+            }
+        }
+
+        if (!addVertex(clamped, vertexData)) {
+            callErrorOrErrorData(GLU.GLU_OUT_OF_MEMORY);
+        }
+    }
+
+
+    public void gluTessBeginPolygon(Object data) {
+        requireState(TessState.T_DORMANT);
+
+        state = TessState.T_IN_POLYGON;
+        cacheCount = 0;
+        flushCacheOnNextVertex = false;
+        mesh = null;
+
+        polygonData = data;
+    }
+
+
+    public void gluTessBeginContour() {
+        requireState(TessState.T_IN_POLYGON);
+
+        state = TessState.T_IN_CONTOUR;
+        lastEdge = null;
+        if (cacheCount > 0) {
+/* Just set a flag so we don't get confused by empty contours
+ * -- these can be generated accidentally with the obsolete
+ * NextContour() interface.
+ */
+            flushCacheOnNextVertex = true;
+        }
+    }
+
+
+    public void gluTessEndContour() {
+        requireState(TessState.T_IN_CONTOUR);
+        state = TessState.T_IN_POLYGON;
+    }
+
+    public void gluTessEndPolygon() {
+        GLUmesh mesh;
+
+        try {
+            requireState(TessState.T_IN_POLYGON);
+            state = TessState.T_DORMANT;
+
+            if (this.mesh == null) {
+                if (!flagBoundary /*&& callMesh == NULL_CB*/) {
+
+/* Try some special code to make the easy cases go quickly
+ * (eg. convex polygons).  This code does NOT handle multiple contours,
+ * intersections, edge flags, and of course it does not generate
+ * an explicit mesh either.
+ */
+                    if (Render.__gl_renderCache(this)) {
+                        polygonData = null;
+                        return;
+                    }
+                }
+                if (!flushCache()) throw new RuntimeException(); /* could've used a label*/
+            }
+
+/* Determine the polygon normal and project vertices onto the plane
+         * of the polygon.
+         */
+            Normal.__gl_projectPolygon(this);
+
+/* __gl_computeInterior( tess ) computes the planar arrangement specified
+ * by the given contours, and further subdivides this arrangement
+ * into regions.  Each region is marked "inside" if it belongs
+ * to the polygon, according to the rule given by windingRule.
+ * Each interior region is guaranteed be monotone.
+ */
+            if (!Sweep.__gl_computeInterior(this)) {
+                throw new RuntimeException();	/* could've used a label */
+            }
+
+            mesh = this.mesh;
+            if (!fatalError) {
+                boolean rc = true;
+
+/* If the user wants only the boundary contours, we throw away all edges
+ * except those which separate the interior from the exterior.
+ * Otherwise we tessellate all the regions marked "inside".
+ */
+                if (boundaryOnly) {
+                    rc = TessMono.__gl_meshSetWindingNumber(mesh, 1, true);
+                } else {
+                    rc = TessMono.__gl_meshTessellateInterior(mesh, avoidDegenerateTris);
+                }
+                if (!rc) throw new RuntimeException();	/* could've used a label */
+
+                Mesh.__gl_meshCheckMesh(mesh);
+
+                if (callBegin != NULL_CB || callEnd != NULL_CB
+                        || callVertex != NULL_CB || callEdgeFlag != NULL_CB
+                        || callBeginData != NULL_CB
+                        || callEndData != NULL_CB
+                        || callVertexData != NULL_CB
+                        || callEdgeFlagData != NULL_CB) {
+                    if (boundaryOnly) {
+                        Render.__gl_renderBoundary(this, mesh);  /* output boundary contours */
+                    } else {
+                        Render.__gl_renderMesh(this, mesh);	   /* output strips and fans */
+                    }
+                }
+//                if (callMesh != NULL_CB) {
+//
+///* Throw away the exterior faces, so that all faces are interior.
+//                 * This way the user doesn't have to check the "inside" flag,
+//                 * and we don't need to even reveal its existence.  It also leaves
+//                 * the freedom for an implementation to not generate the exterior
+//                 * faces in the first place.
+//                 */
+//                    TessMono.__gl_meshDiscardExterior(mesh);
+//                    callMesh.mesh(mesh);		/* user wants the mesh itself */
+//                    mesh = null;
+//                    polygonData = null;
+//                    return;
+//                }
+            }
+            Mesh.__gl_meshDeleteMesh(mesh);
+            polygonData = null;
+            mesh = null;
+        } catch (Exception e) {
+            e.printStackTrace();
+            callErrorOrErrorData(GLU.GLU_OUT_OF_MEMORY);
+        }
+    }
+
+    /*******************************************************/
+
+/* Obsolete calls -- for backward compatibility */
+
+    public void gluBeginPolygon() {
+        gluTessBeginPolygon(null);
+        gluTessBeginContour();
+    }
+
+
+/*ARGSUSED*/
+    public void gluNextContour(int type) {
+        gluTessEndContour();
+        gluTessBeginContour();
+    }
+
+
+    public void gluEndPolygon() {
+        gluTessEndContour();
+        gluTessEndPolygon();
+    }
+
+    void callBeginOrBeginData(int a) {
+        if (callBeginData != NULL_CB)
+            callBeginData.beginData(a, polygonData);
+        else
+            callBegin.begin(a);
+    }
+
+    void callVertexOrVertexData(Object a) {
+        if (callVertexData != NULL_CB)
+            callVertexData.vertexData(a, polygonData);
+        else
+            callVertex.vertex(a);
+    }
+
+    void callEdgeFlagOrEdgeFlagData(boolean a) {
+        if (callEdgeFlagData != NULL_CB)
+            callEdgeFlagData.edgeFlagData(a, polygonData);
+        else
+            callEdgeFlag.edgeFlag(a);
+    }
+
+    void callEndOrEndData() {
+        if (callEndData != NULL_CB)
+            callEndData.endData(polygonData);
+        else
+            callEnd.end();
+    }
+
+    void callCombineOrCombineData(double[] coords, Object[] vertexData, float[] weights, Object[] outData) {
+        if (callCombineData != NULL_CB)
+            callCombineData.combineData(coords, vertexData, weights, outData, polygonData);
+        else
+            callCombine.combine(coords, vertexData, weights, outData);
+    }
+
+    void callErrorOrErrorData(int a) {
+        if (callErrorData != NULL_CB)
+            callErrorData.errorData(a, polygonData);
+        else
+            callError.error(a);
+    }
+
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/GLUvertex.java b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/GLUvertex.java
new file mode 100644
index 000000000..e97767a12
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/GLUvertex.java
@@ -0,0 +1,65 @@
+/*
+* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
+* All rights reserved.
+*/
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** Author: Eric Veach, July 1994
+** Java Port: Pepijn Van Eeckhoudt, July 2003
+** Java Port: Nathan Parker Burg, August 2003
+*/
+package com.sun.opengl.impl.glu.tessellator;
+
+class GLUvertex {
+    public GLUvertex next;		/* next vertex (never NULL) */
+    public GLUvertex prev;		/* previous vertex (never NULL) */
+    public com.sun.opengl.impl.glu.tessellator.GLUhalfEdge anEdge;	/* a half-edge with this origin */
+    public Object data;		/* client's data */
+
+    /* Internal data (keep hidden) */
+    public double[] coords = new double[3];	/* vertex location in 3D */
+    public double s, t;		/* projection onto the sweep plane */
+    public int pqHandle;	/* to allow deletion from priority queue */
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/Geom.java b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/Geom.java
new file mode 100644
index 000000000..1287a60e0
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/Geom.java
@@ -0,0 +1,338 @@
+/*
+* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
+* All rights reserved.
+*/
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** Author: Eric Veach, July 1994
+** Java Port: Pepijn Van Eeckhoudt, July 2003
+** Java Port: Nathan Parker Burg, August 2003
+*/
+package com.sun.opengl.impl.glu.tessellator;
+
+class Geom {
+    private Geom() {
+    }
+
+    /* Given three vertices u,v,w such that VertLeq(u,v) && VertLeq(v,w),
+     * evaluates the t-coord of the edge uw at the s-coord of the vertex v.
+     * Returns v->t - (uw)(v->s), ie. the signed distance from uw to v.
+     * If uw is vertical (and thus passes thru v), the result is zero.
+     *
+     * The calculation is extremely accurate and stable, even when v
+     * is very close to u or w.  In particular if we set v->t = 0 and
+     * let r be the negated result (this evaluates (uw)(v->s)), then
+     * r is guaranteed to satisfy MIN(u->t,w->t) <= r <= MAX(u->t,w->t).
+     */
+    static double EdgeEval(GLUvertex u, GLUvertex v, GLUvertex w) {
+        double gapL, gapR;
+
+        assert (VertLeq(u, v) && VertLeq(v, w));
+
+        gapL = v.s - u.s;
+        gapR = w.s - v.s;
+
+        if (gapL + gapR > 0) {
+            if (gapL < gapR) {
+                return (v.t - u.t) + (u.t - w.t) * (gapL / (gapL + gapR));
+            } else {
+                return (v.t - w.t) + (w.t - u.t) * (gapR / (gapL + gapR));
+            }
+        }
+        /* vertical line */
+        return 0;
+    }
+
+    static double EdgeSign(GLUvertex u, GLUvertex v, GLUvertex w) {
+        double gapL, gapR;
+
+        assert (VertLeq(u, v) && VertLeq(v, w));
+
+        gapL = v.s - u.s;
+        gapR = w.s - v.s;
+
+        if (gapL + gapR > 0) {
+            return (v.t - w.t) * gapL + (v.t - u.t) * gapR;
+        }
+        /* vertical line */
+        return 0;
+    }
+
+
+    /***********************************************************************
+     * Define versions of EdgeSign, EdgeEval with s and t transposed.
+     */
+
+    static double TransEval(GLUvertex u, GLUvertex v, GLUvertex w) {
+        /* Given three vertices u,v,w such that TransLeq(u,v) && TransLeq(v,w),
+         * evaluates the t-coord of the edge uw at the s-coord of the vertex v.
+         * Returns v->s - (uw)(v->t), ie. the signed distance from uw to v.
+         * If uw is vertical (and thus passes thru v), the result is zero.
+         *
+         * The calculation is extremely accurate and stable, even when v
+         * is very close to u or w.  In particular if we set v->s = 0 and
+         * let r be the negated result (this evaluates (uw)(v->t)), then
+         * r is guaranteed to satisfy MIN(u->s,w->s) <= r <= MAX(u->s,w->s).
+         */
+        double gapL, gapR;
+
+        assert (TransLeq(u, v) && TransLeq(v, w));
+
+        gapL = v.t - u.t;
+        gapR = w.t - v.t;
+
+        if (gapL + gapR > 0) {
+            if (gapL < gapR) {
+                return (v.s - u.s) + (u.s - w.s) * (gapL / (gapL + gapR));
+            } else {
+                return (v.s - w.s) + (w.s - u.s) * (gapR / (gapL + gapR));
+            }
+        }
+        /* vertical line */
+        return 0;
+    }
+
+    static double TransSign(GLUvertex u, GLUvertex v, GLUvertex w) {
+        /* Returns a number whose sign matches TransEval(u,v,w) but which
+         * is cheaper to evaluate.  Returns > 0, == 0 , or < 0
+         * as v is above, on, or below the edge uw.
+         */
+        double gapL, gapR;
+
+        assert (TransLeq(u, v) && TransLeq(v, w));
+
+        gapL = v.t - u.t;
+        gapR = w.t - v.t;
+
+        if (gapL + gapR > 0) {
+            return (v.s - w.s) * gapL + (v.s - u.s) * gapR;
+        }
+        /* vertical line */
+        return 0;
+    }
+
+
+    static boolean VertCCW(GLUvertex u, GLUvertex v, GLUvertex w) {
+        /* For almost-degenerate situations, the results are not reliable.
+         * Unless the floating-point arithmetic can be performed without
+         * rounding errors, *any* implementation will give incorrect results
+         * on some degenerate inputs, so the client must have some way to
+         * handle this situation.
+         */
+        return (u.s * (v.t - w.t) + v.s * (w.t - u.t) + w.s * (u.t - v.t)) >= 0;
+    }
+
+/* Given parameters a,x,b,y returns the value (b*x+a*y)/(a+b),
+ * or (x+y)/2 if a==b==0.  It requires that a,b >= 0, and enforces
+ * this in the rare case that one argument is slightly negative.
+ * The implementation is extremely stable numerically.
+ * In particular it guarantees that the result r satisfies
+ * MIN(x,y) <= r <= MAX(x,y), and the results are very accurate
+ * even when a and b differ greatly in magnitude.
+ */
+    static double Interpolate(double a, double x, double b, double y) {
+        a = (a < 0) ? 0 : a;
+        b = (b < 0) ? 0 : b;
+        if (a <= b) {
+            if (b == 0) {
+                return (x + y) / 2.0;
+            } else {
+                return (x + (y - x) * (a / (a + b)));
+            }
+        } else {
+            return (y + (x - y) * (b / (a + b)));
+        }
+    }
+
+    static void EdgeIntersect(GLUvertex o1, GLUvertex d1,
+                              GLUvertex o2, GLUvertex d2,
+                              GLUvertex v)
+/* Given edges (o1,d1) and (o2,d2), compute their point of intersection.
+ * The computed point is guaranteed to lie in the intersection of the
+ * bounding rectangles defined by each edge.
+ */ {
+        double z1, z2;
+
+        /* This is certainly not the most efficient way to find the intersection
+         * of two line segments, but it is very numerically stable.
+         *
+         * Strategy: find the two middle vertices in the VertLeq ordering,
+         * and interpolate the intersection s-value from these.  Then repeat
+         * using the TransLeq ordering to find the intersection t-value.
+         */
+
+        if (!VertLeq(o1, d1)) {
+            GLUvertex temp = o1;
+            o1 = d1;
+            d1 = temp;
+        }
+        if (!VertLeq(o2, d2)) {
+            GLUvertex temp = o2;
+            o2 = d2;
+            d2 = temp;
+        }
+        if (!VertLeq(o1, o2)) {
+            GLUvertex temp = o1;
+            o1 = o2;
+            o2 = temp;
+            temp = d1;
+            d1 = d2;
+            d2 = temp;
+        }
+
+        if (!VertLeq(o2, d1)) {
+            /* Technically, no intersection -- do our best */
+            v.s = (o2.s + d1.s) / 2.0;
+        } else if (VertLeq(d1, d2)) {
+            /* Interpolate between o2 and d1 */
+            z1 = EdgeEval(o1, o2, d1);
+            z2 = EdgeEval(o2, d1, d2);
+            if (z1 + z2 < 0) {
+                z1 = -z1;
+                z2 = -z2;
+            }
+            v.s = Interpolate(z1, o2.s, z2, d1.s);
+        } else {
+            /* Interpolate between o2 and d2 */
+            z1 = EdgeSign(o1, o2, d1);
+            z2 = -EdgeSign(o1, d2, d1);
+            if (z1 + z2 < 0) {
+                z1 = -z1;
+                z2 = -z2;
+            }
+            v.s = Interpolate(z1, o2.s, z2, d2.s);
+        }
+
+        /* Now repeat the process for t */
+
+        if (!TransLeq(o1, d1)) {
+            GLUvertex temp = o1;
+            o1 = d1;
+            d1 = temp;
+        }
+        if (!TransLeq(o2, d2)) {
+            GLUvertex temp = o2;
+            o2 = d2;
+            d2 = temp;
+        }
+        if (!TransLeq(o1, o2)) {
+            GLUvertex temp = o2;
+            o2 = o1;
+            o1 = temp;
+            temp = d2;
+            d2 = d1;
+            d1 = temp;
+        }
+
+        if (!TransLeq(o2, d1)) {
+            /* Technically, no intersection -- do our best */
+            v.t = (o2.t + d1.t) / 2.0;
+        } else if (TransLeq(d1, d2)) {
+            /* Interpolate between o2 and d1 */
+            z1 = TransEval(o1, o2, d1);
+            z2 = TransEval(o2, d1, d2);
+            if (z1 + z2 < 0) {
+                z1 = -z1;
+                z2 = -z2;
+            }
+            v.t = Interpolate(z1, o2.t, z2, d1.t);
+        } else {
+            /* Interpolate between o2 and d2 */
+            z1 = TransSign(o1, o2, d1);
+            z2 = -TransSign(o1, d2, d1);
+            if (z1 + z2 < 0) {
+                z1 = -z1;
+                z2 = -z2;
+            }
+            v.t = Interpolate(z1, o2.t, z2, d2.t);
+        }
+    }
+
+    static boolean VertEq(GLUvertex u, GLUvertex v) {
+        return u.s == v.s && u.t == v.t;
+    }
+
+    static boolean VertLeq(GLUvertex u, GLUvertex v) {
+        return u.s < v.s || (u.s == v.s && u.t <= v.t);
+    }
+
+/* Versions of VertLeq, EdgeSign, EdgeEval with s and t transposed. */
+
+    static boolean TransLeq(GLUvertex u, GLUvertex v) {
+        return u.t < v.t || (u.t == v.t && u.s <= v.s);
+    }
+
+    static boolean EdgeGoesLeft(GLUhalfEdge e) {
+        return VertLeq(e.Sym.Org, e.Org);
+    }
+
+    static boolean EdgeGoesRight(GLUhalfEdge e) {
+        return VertLeq(e.Org, e.Sym.Org);
+    }
+
+    static double VertL1dist(GLUvertex u, GLUvertex v) {
+        return Math.abs(u.s - v.s) + Math.abs(u.t - v.t);
+    }
+
+    /***********************************************************************/
+
+    // Compute the cosine of the angle between the edges between o and
+    // v1 and between o and v2
+    static double EdgeCos(GLUvertex o, GLUvertex v1, GLUvertex v2) {
+        double ov1s = v1.s - o.s;
+        double ov1t = v1.t - o.t;
+        double ov2s = v2.s - o.s;
+        double ov2t = v2.t - o.t;
+        double dotp = ov1s * ov2s + ov1t * ov2t;
+        double len = Math.sqrt(ov1s * ov1s + ov1t * ov1t) * Math.sqrt(ov2s * ov2s + ov2t * ov2t);
+        if (len > 0.0) {
+            dotp /= len;
+        }
+        return dotp;
+    }
+
+    static final double EPSILON = 1.0e-5;
+    static final double ONE_MINUS_EPSILON = 1.0 - EPSILON;
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/Mesh.java b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/Mesh.java
new file mode 100644
index 000000000..290fb1037
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/Mesh.java
@@ -0,0 +1,734 @@
+/*
+* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
+* All rights reserved.
+*/
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** Author: Eric Veach, July 1994
+** Java Port: Pepijn Van Eeckhoudt, July 2003
+** Java Port: Nathan Parker Burg, August 2003
+*/
+package com.sun.opengl.impl.glu.tessellator;
+
+class Mesh {
+    private Mesh() {
+    }
+
+    /************************ Utility Routines ************************/
+/* MakeEdge creates a new pair of half-edges which form their own loop.
+ * No vertex or face structures are allocated, but these must be assigned
+ * before the current edge operation is completed.
+ */
+    static com.sun.opengl.impl.glu.tessellator.GLUhalfEdge MakeEdge(com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eNext) {
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e;
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eSym;
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge ePrev;
+
+//        EdgePair * pair = (EdgePair *)
+//        memAlloc(sizeof(EdgePair));
+//        if (pair == NULL) return NULL;
+//
+//        e = &pair - > e;
+        e = new com.sun.opengl.impl.glu.tessellator.GLUhalfEdge(true);
+//        eSym = &pair - > eSym;
+        eSym = new com.sun.opengl.impl.glu.tessellator.GLUhalfEdge(false);
+
+
+        /* Make sure eNext points to the first edge of the edge pair */
+        if (!eNext.first) {
+            eNext = eNext.Sym;
+        }
+
+        /* Insert in circular doubly-linked list before eNext.
+         * Note that the prev pointer is stored in Sym->next.
+         */
+        ePrev = eNext.Sym.next;
+        eSym.next = ePrev;
+        ePrev.Sym.next = e;
+        e.next = eNext;
+        eNext.Sym.next = eSym;
+
+        e.Sym = eSym;
+        e.Onext = e;
+        e.Lnext = eSym;
+        e.Org = null;
+        e.Lface = null;
+        e.winding = 0;
+        e.activeRegion = null;
+
+        eSym.Sym = e;
+        eSym.Onext = eSym;
+        eSym.Lnext = e;
+        eSym.Org = null;
+        eSym.Lface = null;
+        eSym.winding = 0;
+        eSym.activeRegion = null;
+
+        return e;
+    }
+
+/* Splice( a, b ) is best described by the Guibas/Stolfi paper or the
+ * CS348a notes (see mesh.h).  Basically it modifies the mesh so that
+ * a->Onext and b->Onext are exchanged.  This can have various effects
+ * depending on whether a and b belong to different face or vertex rings.
+ * For more explanation see __gl_meshSplice() below.
+ */
+    static void Splice(com.sun.opengl.impl.glu.tessellator.GLUhalfEdge a, com.sun.opengl.impl.glu.tessellator.GLUhalfEdge b) {
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge aOnext = a.Onext;
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge bOnext = b.Onext;
+
+        aOnext.Sym.Lnext = b;
+        bOnext.Sym.Lnext = a;
+        a.Onext = bOnext;
+        b.Onext = aOnext;
+    }
+
+/* MakeVertex( newVertex, eOrig, vNext ) attaches a new vertex and makes it the
+ * origin of all edges in the vertex loop to which eOrig belongs. "vNext" gives
+ * a place to insert the new vertex in the global vertex list.  We insert
+ * the new vertex *before* vNext so that algorithms which walk the vertex
+ * list will not see the newly created vertices.
+ */
+    static void MakeVertex(com.sun.opengl.impl.glu.tessellator.GLUvertex newVertex,
+                           com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eOrig, com.sun.opengl.impl.glu.tessellator.GLUvertex vNext) {
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e;
+        com.sun.opengl.impl.glu.tessellator.GLUvertex vPrev;
+        com.sun.opengl.impl.glu.tessellator.GLUvertex vNew = newVertex;
+
+        assert (vNew != null);
+
+        /* insert in circular doubly-linked list before vNext */
+        vPrev = vNext.prev;
+        vNew.prev = vPrev;
+        vPrev.next = vNew;
+        vNew.next = vNext;
+        vNext.prev = vNew;
+
+        vNew.anEdge = eOrig;
+        vNew.data = null;
+        /* leave coords, s, t undefined */
+
+        /* fix other edges on this vertex loop */
+        e = eOrig;
+        do {
+            e.Org = vNew;
+            e = e.Onext;
+        } while (e != eOrig);
+    }
+
+/* MakeFace( newFace, eOrig, fNext ) attaches a new face and makes it the left
+ * face of all edges in the face loop to which eOrig belongs.  "fNext" gives
+ * a place to insert the new face in the global face list.  We insert
+ * the new face *before* fNext so that algorithms which walk the face
+ * list will not see the newly created faces.
+ */
+    static void MakeFace(com.sun.opengl.impl.glu.tessellator.GLUface newFace, com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eOrig, com.sun.opengl.impl.glu.tessellator.GLUface fNext) {
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e;
+        com.sun.opengl.impl.glu.tessellator.GLUface fPrev;
+        com.sun.opengl.impl.glu.tessellator.GLUface fNew = newFace;
+
+        assert (fNew != null);
+
+        /* insert in circular doubly-linked list before fNext */
+        fPrev = fNext.prev;
+        fNew.prev = fPrev;
+        fPrev.next = fNew;
+        fNew.next = fNext;
+        fNext.prev = fNew;
+
+        fNew.anEdge = eOrig;
+        fNew.data = null;
+        fNew.trail = null;
+        fNew.marked = false;
+
+        /* The new face is marked "inside" if the old one was.  This is a
+         * convenience for the common case where a face has been split in two.
+         */
+        fNew.inside = fNext.inside;
+
+        /* fix other edges on this face loop */
+        e = eOrig;
+        do {
+            e.Lface = fNew;
+            e = e.Lnext;
+        } while (e != eOrig);
+    }
+
+/* KillEdge( eDel ) destroys an edge (the half-edges eDel and eDel->Sym),
+ * and removes from the global edge list.
+ */
+    static void KillEdge(com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eDel) {
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge ePrev, eNext;
+
+        /* Half-edges are allocated in pairs, see EdgePair above */
+        if (!eDel.first) {
+            eDel = eDel.Sym;
+        }
+
+        /* delete from circular doubly-linked list */
+        eNext = eDel.next;
+        ePrev = eDel.Sym.next;
+        eNext.Sym.next = ePrev;
+        ePrev.Sym.next = eNext;
+    }
+
+
+/* KillVertex( vDel ) destroys a vertex and removes it from the global
+ * vertex list.  It updates the vertex loop to point to a given new vertex.
+ */
+    static void KillVertex(com.sun.opengl.impl.glu.tessellator.GLUvertex vDel, com.sun.opengl.impl.glu.tessellator.GLUvertex newOrg) {
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e, eStart = vDel.anEdge;
+        com.sun.opengl.impl.glu.tessellator.GLUvertex vPrev, vNext;
+
+        /* change the origin of all affected edges */
+        e = eStart;
+        do {
+            e.Org = newOrg;
+            e = e.Onext;
+        } while (e != eStart);
+
+        /* delete from circular doubly-linked list */
+        vPrev = vDel.prev;
+        vNext = vDel.next;
+        vNext.prev = vPrev;
+        vPrev.next = vNext;
+    }
+
+/* KillFace( fDel ) destroys a face and removes it from the global face
+ * list.  It updates the face loop to point to a given new face.
+ */
+    static void KillFace(com.sun.opengl.impl.glu.tessellator.GLUface fDel, com.sun.opengl.impl.glu.tessellator.GLUface newLface) {
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e, eStart = fDel.anEdge;
+        com.sun.opengl.impl.glu.tessellator.GLUface fPrev, fNext;
+
+        /* change the left face of all affected edges */
+        e = eStart;
+        do {
+            e.Lface = newLface;
+            e = e.Lnext;
+        } while (e != eStart);
+
+        /* delete from circular doubly-linked list */
+        fPrev = fDel.prev;
+        fNext = fDel.next;
+        fNext.prev = fPrev;
+        fPrev.next = fNext;
+    }
+
+
+    /****************** Basic Edge Operations **********************/
+
+/* __gl_meshMakeEdge creates one edge, two vertices, and a loop (face).
+ * The loop consists of the two new half-edges.
+ */
+    public static com.sun.opengl.impl.glu.tessellator.GLUhalfEdge __gl_meshMakeEdge(com.sun.opengl.impl.glu.tessellator.GLUmesh mesh) {
+        com.sun.opengl.impl.glu.tessellator.GLUvertex newVertex1 = new com.sun.opengl.impl.glu.tessellator.GLUvertex();
+        com.sun.opengl.impl.glu.tessellator.GLUvertex newVertex2 = new com.sun.opengl.impl.glu.tessellator.GLUvertex();
+        com.sun.opengl.impl.glu.tessellator.GLUface newFace = new com.sun.opengl.impl.glu.tessellator.GLUface();
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e;
+
+        e = MakeEdge(mesh.eHead);
+        if (e == null) return null;
+
+        MakeVertex(newVertex1, e, mesh.vHead);
+        MakeVertex(newVertex2, e.Sym, mesh.vHead);
+        MakeFace(newFace, e, mesh.fHead);
+        return e;
+    }
+
+
+/* __gl_meshSplice( eOrg, eDst ) is the basic operation for changing the
+ * mesh connectivity and topology.  It changes the mesh so that
+ *	eOrg->Onext <- OLD( eDst->Onext )
+ *	eDst->Onext <- OLD( eOrg->Onext )
+ * where OLD(...) means the value before the meshSplice operation.
+ *
+ * This can have two effects on the vertex structure:
+ *  - if eOrg->Org != eDst->Org, the two vertices are merged together
+ *  - if eOrg->Org == eDst->Org, the origin is split into two vertices
+ * In both cases, eDst->Org is changed and eOrg->Org is untouched.
+ *
+ * Similarly (and independently) for the face structure,
+ *  - if eOrg->Lface == eDst->Lface, one loop is split into two
+ *  - if eOrg->Lface != eDst->Lface, two distinct loops are joined into one
+ * In both cases, eDst->Lface is changed and eOrg->Lface is unaffected.
+ *
+ * Some special cases:
+ * If eDst == eOrg, the operation has no effect.
+ * If eDst == eOrg->Lnext, the new face will have a single edge.
+ * If eDst == eOrg->Lprev, the old face will have a single edge.
+ * If eDst == eOrg->Onext, the new vertex will have a single edge.
+ * If eDst == eOrg->Oprev, the old vertex will have a single edge.
+ */
+    public static boolean __gl_meshSplice(com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eOrg, com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eDst) {
+        boolean joiningLoops = false;
+        boolean joiningVertices = false;
+
+        if (eOrg == eDst) return true;
+
+        if (eDst.Org != eOrg.Org) {
+            /* We are merging two disjoint vertices -- destroy eDst->Org */
+            joiningVertices = true;
+            KillVertex(eDst.Org, eOrg.Org);
+        }
+        if (eDst.Lface != eOrg.Lface) {
+            /* We are connecting two disjoint loops -- destroy eDst.Lface */
+            joiningLoops = true;
+            KillFace(eDst.Lface, eOrg.Lface);
+        }
+
+        /* Change the edge structure */
+        Splice(eDst, eOrg);
+
+        if (!joiningVertices) {
+            com.sun.opengl.impl.glu.tessellator.GLUvertex newVertex = new com.sun.opengl.impl.glu.tessellator.GLUvertex();
+
+            /* We split one vertex into two -- the new vertex is eDst.Org.
+             * Make sure the old vertex points to a valid half-edge.
+             */
+            MakeVertex(newVertex, eDst, eOrg.Org);
+            eOrg.Org.anEdge = eOrg;
+        }
+        if (!joiningLoops) {
+            com.sun.opengl.impl.glu.tessellator.GLUface newFace = new com.sun.opengl.impl.glu.tessellator.GLUface();
+
+            /* We split one loop into two -- the new loop is eDst.Lface.
+             * Make sure the old face points to a valid half-edge.
+             */
+            MakeFace(newFace, eDst, eOrg.Lface);
+            eOrg.Lface.anEdge = eOrg;
+        }
+
+        return true;
+    }
+
+
+/* __gl_meshDelete( eDel ) removes the edge eDel.  There are several cases:
+ * if (eDel.Lface != eDel.Rface), we join two loops into one; the loop
+ * eDel.Lface is deleted.  Otherwise, we are splitting one loop into two;
+ * the newly created loop will contain eDel.Dst.  If the deletion of eDel
+ * would create isolated vertices, those are deleted as well.
+ *
+ * This function could be implemented as two calls to __gl_meshSplice
+ * plus a few calls to memFree, but this would allocate and delete
+ * unnecessary vertices and faces.
+ */
+    static boolean __gl_meshDelete(com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eDel) {
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eDelSym = eDel.Sym;
+        boolean joiningLoops = false;
+
+        /* First step: disconnect the origin vertex eDel.Org.  We make all
+         * changes to get a consistent mesh in this "intermediate" state.
+         */
+        if (eDel.Lface != eDel.Sym.Lface) {
+            /* We are joining two loops into one -- remove the left face */
+            joiningLoops = true;
+            KillFace(eDel.Lface, eDel.Sym.Lface);
+        }
+
+        if (eDel.Onext == eDel) {
+            KillVertex(eDel.Org, null);
+        } else {
+            /* Make sure that eDel.Org and eDel.Sym.Lface point to valid half-edges */
+            eDel.Sym.Lface.anEdge = eDel.Sym.Lnext;
+            eDel.Org.anEdge = eDel.Onext;
+
+            Splice(eDel, eDel.Sym.Lnext);
+            if (!joiningLoops) {
+                com.sun.opengl.impl.glu.tessellator.GLUface newFace = new com.sun.opengl.impl.glu.tessellator.GLUface();
+
+                /* We are splitting one loop into two -- create a new loop for eDel. */
+                MakeFace(newFace, eDel, eDel.Lface);
+            }
+        }
+
+        /* Claim: the mesh is now in a consistent state, except that eDel.Org
+         * may have been deleted.  Now we disconnect eDel.Dst.
+         */
+        if (eDelSym.Onext == eDelSym) {
+            KillVertex(eDelSym.Org, null);
+            KillFace(eDelSym.Lface, null);
+        } else {
+            /* Make sure that eDel.Dst and eDel.Lface point to valid half-edges */
+            eDel.Lface.anEdge = eDelSym.Sym.Lnext;
+            eDelSym.Org.anEdge = eDelSym.Onext;
+            Splice(eDelSym, eDelSym.Sym.Lnext);
+        }
+
+        /* Any isolated vertices or faces have already been freed. */
+        KillEdge(eDel);
+
+        return true;
+    }
+
+
+    /******************** Other Edge Operations **********************/
+
+/* All these routines can be implemented with the basic edge
+ * operations above.  They are provided for convenience and efficiency.
+ */
+
+
+/* __gl_meshAddEdgeVertex( eOrg ) creates a new edge eNew such that
+ * eNew == eOrg.Lnext, and eNew.Dst is a newly created vertex.
+ * eOrg and eNew will have the same left face.
+ */
+    static com.sun.opengl.impl.glu.tessellator.GLUhalfEdge __gl_meshAddEdgeVertex(com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eOrg) {
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eNewSym;
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eNew = MakeEdge(eOrg);
+
+        eNewSym = eNew.Sym;
+
+        /* Connect the new edge appropriately */
+        Splice(eNew, eOrg.Lnext);
+
+        /* Set the vertex and face information */
+        eNew.Org = eOrg.Sym.Org;
+        {
+            com.sun.opengl.impl.glu.tessellator.GLUvertex newVertex = new com.sun.opengl.impl.glu.tessellator.GLUvertex();
+
+            MakeVertex(newVertex, eNewSym, eNew.Org);
+        }
+        eNew.Lface = eNewSym.Lface = eOrg.Lface;
+
+        return eNew;
+    }
+
+
+/* __gl_meshSplitEdge( eOrg ) splits eOrg into two edges eOrg and eNew,
+ * such that eNew == eOrg.Lnext.  The new vertex is eOrg.Sym.Org == eNew.Org.
+ * eOrg and eNew will have the same left face.
+ */
+    public static com.sun.opengl.impl.glu.tessellator.GLUhalfEdge __gl_meshSplitEdge(com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eOrg) {
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eNew;
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge tempHalfEdge = __gl_meshAddEdgeVertex(eOrg);
+
+        eNew = tempHalfEdge.Sym;
+
+        /* Disconnect eOrg from eOrg.Sym.Org and connect it to eNew.Org */
+        Splice(eOrg.Sym, eOrg.Sym.Sym.Lnext);
+        Splice(eOrg.Sym, eNew);
+
+        /* Set the vertex and face information */
+        eOrg.Sym.Org = eNew.Org;
+        eNew.Sym.Org.anEdge = eNew.Sym;	/* may have pointed to eOrg.Sym */
+        eNew.Sym.Lface = eOrg.Sym.Lface;
+        eNew.winding = eOrg.winding;	/* copy old winding information */
+        eNew.Sym.winding = eOrg.Sym.winding;
+
+        return eNew;
+    }
+
+
+/* __gl_meshConnect( eOrg, eDst ) creates a new edge from eOrg.Sym.Org
+ * to eDst.Org, and returns the corresponding half-edge eNew.
+ * If eOrg.Lface == eDst.Lface, this splits one loop into two,
+ * and the newly created loop is eNew.Lface.  Otherwise, two disjoint
+ * loops are merged into one, and the loop eDst.Lface is destroyed.
+ *
+ * If (eOrg == eDst), the new face will have only two edges.
+ * If (eOrg.Lnext == eDst), the old face is reduced to a single edge.
+ * If (eOrg.Lnext.Lnext == eDst), the old face is reduced to two edges.
+ */
+    static com.sun.opengl.impl.glu.tessellator.GLUhalfEdge __gl_meshConnect(com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eOrg, com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eDst) {
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eNewSym;
+        boolean joiningLoops = false;
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eNew = MakeEdge(eOrg);
+
+        eNewSym = eNew.Sym;
+
+        if (eDst.Lface != eOrg.Lface) {
+            /* We are connecting two disjoint loops -- destroy eDst.Lface */
+            joiningLoops = true;
+            KillFace(eDst.Lface, eOrg.Lface);
+        }
+
+        /* Connect the new edge appropriately */
+        Splice(eNew, eOrg.Lnext);
+        Splice(eNewSym, eDst);
+
+        /* Set the vertex and face information */
+        eNew.Org = eOrg.Sym.Org;
+        eNewSym.Org = eDst.Org;
+        eNew.Lface = eNewSym.Lface = eOrg.Lface;
+
+        /* Make sure the old face points to a valid half-edge */
+        eOrg.Lface.anEdge = eNewSym;
+
+        if (!joiningLoops) {
+            com.sun.opengl.impl.glu.tessellator.GLUface newFace = new com.sun.opengl.impl.glu.tessellator.GLUface();
+
+            /* We split one loop into two -- the new loop is eNew.Lface */
+            MakeFace(newFace, eNew, eOrg.Lface);
+        }
+        return eNew;
+    }
+
+
+    /******************** Other Operations **********************/
+
+/* __gl_meshZapFace( fZap ) destroys a face and removes it from the
+ * global face list.  All edges of fZap will have a null pointer as their
+ * left face.  Any edges which also have a null pointer as their right face
+ * are deleted entirely (along with any isolated vertices this produces).
+ * An entire mesh can be deleted by zapping its faces, one at a time,
+ * in any order.  Zapped faces cannot be used in further mesh operations!
+ */
+    static void __gl_meshZapFace(com.sun.opengl.impl.glu.tessellator.GLUface fZap) {
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eStart = fZap.anEdge;
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e, eNext, eSym;
+        com.sun.opengl.impl.glu.tessellator.GLUface fPrev, fNext;
+
+        /* walk around face, deleting edges whose right face is also null */
+        eNext = eStart.Lnext;
+        do {
+            e = eNext;
+            eNext = e.Lnext;
+
+            e.Lface = null;
+            if (e.Sym.Lface == null) {
+                /* delete the edge -- see __gl_MeshDelete above */
+
+                if (e.Onext == e) {
+                    KillVertex(e.Org, null);
+                } else {
+                    /* Make sure that e.Org points to a valid half-edge */
+                    e.Org.anEdge = e.Onext;
+                    Splice(e, e.Sym.Lnext);
+                }
+                eSym = e.Sym;
+                if (eSym.Onext == eSym) {
+                    KillVertex(eSym.Org, null);
+                } else {
+                    /* Make sure that eSym.Org points to a valid half-edge */
+                    eSym.Org.anEdge = eSym.Onext;
+                    Splice(eSym, eSym.Sym.Lnext);
+                }
+                KillEdge(e);
+            }
+        } while (e != eStart);
+
+        /* delete from circular doubly-linked list */
+        fPrev = fZap.prev;
+        fNext = fZap.next;
+        fNext.prev = fPrev;
+        fPrev.next = fNext;
+    }
+
+
+/* __gl_meshNewMesh() creates a new mesh with no edges, no vertices,
+ * and no loops (what we usually call a "face").
+ */
+    public static com.sun.opengl.impl.glu.tessellator.GLUmesh __gl_meshNewMesh() {
+        com.sun.opengl.impl.glu.tessellator.GLUvertex v;
+        com.sun.opengl.impl.glu.tessellator.GLUface f;
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e;
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eSym;
+        com.sun.opengl.impl.glu.tessellator.GLUmesh mesh = new com.sun.opengl.impl.glu.tessellator.GLUmesh();
+
+        v = mesh.vHead;
+        f = mesh.fHead;
+        e = mesh.eHead;
+        eSym = mesh.eHeadSym;
+
+        v.next = v.prev = v;
+        v.anEdge = null;
+        v.data = null;
+
+        f.next = f.prev = f;
+        f.anEdge = null;
+        f.data = null;
+        f.trail = null;
+        f.marked = false;
+        f.inside = false;
+
+        e.next = e;
+        e.Sym = eSym;
+        e.Onext = null;
+        e.Lnext = null;
+        e.Org = null;
+        e.Lface = null;
+        e.winding = 0;
+        e.activeRegion = null;
+
+        eSym.next = eSym;
+        eSym.Sym = e;
+        eSym.Onext = null;
+        eSym.Lnext = null;
+        eSym.Org = null;
+        eSym.Lface = null;
+        eSym.winding = 0;
+        eSym.activeRegion = null;
+
+        return mesh;
+    }
+
+
+/* __gl_meshUnion( mesh1, mesh2 ) forms the union of all structures in
+ * both meshes, and returns the new mesh (the old meshes are destroyed).
+ */
+    static com.sun.opengl.impl.glu.tessellator.GLUmesh __gl_meshUnion(com.sun.opengl.impl.glu.tessellator.GLUmesh mesh1, com.sun.opengl.impl.glu.tessellator.GLUmesh mesh2) {
+        com.sun.opengl.impl.glu.tessellator.GLUface f1 = mesh1.fHead;
+        com.sun.opengl.impl.glu.tessellator.GLUvertex v1 = mesh1.vHead;
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e1 = mesh1.eHead;
+        com.sun.opengl.impl.glu.tessellator.GLUface f2 = mesh2.fHead;
+        com.sun.opengl.impl.glu.tessellator.GLUvertex v2 = mesh2.vHead;
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e2 = mesh2.eHead;
+
+        /* Add the faces, vertices, and edges of mesh2 to those of mesh1 */
+        if (f2.next != f2) {
+            f1.prev.next = f2.next;
+            f2.next.prev = f1.prev;
+            f2.prev.next = f1;
+            f1.prev = f2.prev;
+        }
+
+        if (v2.next != v2) {
+            v1.prev.next = v2.next;
+            v2.next.prev = v1.prev;
+            v2.prev.next = v1;
+            v1.prev = v2.prev;
+        }
+
+        if (e2.next != e2) {
+            e1.Sym.next.Sym.next = e2.next;
+            e2.next.Sym.next = e1.Sym.next;
+            e2.Sym.next.Sym.next = e1;
+            e1.Sym.next = e2.Sym.next;
+        }
+
+        return mesh1;
+    }
+
+
+/* __gl_meshDeleteMesh( mesh ) will free all storage for any valid mesh.
+ */
+    static void __gl_meshDeleteMeshZap(com.sun.opengl.impl.glu.tessellator.GLUmesh mesh) {
+        com.sun.opengl.impl.glu.tessellator.GLUface fHead = mesh.fHead;
+
+        while (fHead.next != fHead) {
+            __gl_meshZapFace(fHead.next);
+        }
+        assert (mesh.vHead.next == mesh.vHead);
+    }
+
+/* __gl_meshDeleteMesh( mesh ) will free all storage for any valid mesh.
+ */
+    public static void __gl_meshDeleteMesh(com.sun.opengl.impl.glu.tessellator.GLUmesh mesh) {
+        com.sun.opengl.impl.glu.tessellator.GLUface f, fNext;
+        com.sun.opengl.impl.glu.tessellator.GLUvertex v, vNext;
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e, eNext;
+
+        for (f = mesh.fHead.next; f != mesh.fHead; f = fNext) {
+            fNext = f.next;
+        }
+
+        for (v = mesh.vHead.next; v != mesh.vHead; v = vNext) {
+            vNext = v.next;
+        }
+
+        for (e = mesh.eHead.next; e != mesh.eHead; e = eNext) {
+            /* One call frees both e and e.Sym (see EdgePair above) */
+            eNext = e.next;
+        }
+    }
+
+/* __gl_meshCheckMesh( mesh ) checks a mesh for self-consistency.
+ */
+    public static void __gl_meshCheckMesh(com.sun.opengl.impl.glu.tessellator.GLUmesh mesh) {
+        com.sun.opengl.impl.glu.tessellator.GLUface fHead = mesh.fHead;
+        com.sun.opengl.impl.glu.tessellator.GLUvertex vHead = mesh.vHead;
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eHead = mesh.eHead;
+        com.sun.opengl.impl.glu.tessellator.GLUface f, fPrev;
+        com.sun.opengl.impl.glu.tessellator.GLUvertex v, vPrev;
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e, ePrev;
+
+        fPrev = fHead;
+        for (fPrev = fHead; (f = fPrev.next) != fHead; fPrev = f) {
+            assert (f.prev == fPrev);
+            e = f.anEdge;
+            do {
+                assert (e.Sym != e);
+                assert (e.Sym.Sym == e);
+                assert (e.Lnext.Onext.Sym == e);
+                assert (e.Onext.Sym.Lnext == e);
+                assert (e.Lface == f);
+                e = e.Lnext;
+            } while (e != f.anEdge);
+        }
+        assert (f.prev == fPrev && f.anEdge == null && f.data == null);
+
+        vPrev = vHead;
+        for (vPrev = vHead; (v = vPrev.next) != vHead; vPrev = v) {
+            assert (v.prev == vPrev);
+            e = v.anEdge;
+            do {
+                assert (e.Sym != e);
+                assert (e.Sym.Sym == e);
+                assert (e.Lnext.Onext.Sym == e);
+                assert (e.Onext.Sym.Lnext == e);
+                assert (e.Org == v);
+                e = e.Onext;
+            } while (e != v.anEdge);
+        }
+        assert (v.prev == vPrev && v.anEdge == null && v.data == null);
+
+        ePrev = eHead;
+        for (ePrev = eHead; (e = ePrev.next) != eHead; ePrev = e) {
+            assert (e.Sym.next == ePrev.Sym);
+            assert (e.Sym != e);
+            assert (e.Sym.Sym == e);
+            assert (e.Org != null);
+            assert (e.Sym.Org != null);
+            assert (e.Lnext.Onext.Sym == e);
+            assert (e.Onext.Sym.Lnext == e);
+        }
+        assert (e.Sym.next == ePrev.Sym
+                && e.Sym == mesh.eHeadSym
+                && e.Sym.Sym == e
+                && e.Org == null && e.Sym.Org == null
+                && e.Lface == null && e.Sym.Lface == null);
+    }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/Normal.java b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/Normal.java
new file mode 100644
index 000000000..feb13dfd4
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/Normal.java
@@ -0,0 +1,288 @@
+/*
+* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
+* All rights reserved.
+*/
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** Author: Eric Veach, July 1994
+** Java Port: Pepijn Van Eeckhoudt, July 2003
+** Java Port: Nathan Parker Burg, August 2003
+*/
+package com.sun.opengl.impl.glu.tessellator;
+
+import javax.media.opengl.*;
+import javax.media.opengl.glu.*;
+
+class Normal {
+    private Normal() {
+    }
+
+    static boolean SLANTED_SWEEP = false;
+    static double S_UNIT_X;	/* Pre-normalized */
+    static double S_UNIT_Y;
+    private static final boolean TRUE_PROJECT = false;
+
+    static {
+        if (SLANTED_SWEEP) {
+/* The "feature merging" is not intended to be complete.  There are
+ * special cases where edges are nearly parallel to the sweep line
+ * which are not implemented.  The algorithm should still behave
+ * robustly (ie. produce a reasonable tesselation) in the presence
+ * of such edges, however it may miss features which could have been
+ * merged.  We could minimize this effect by choosing the sweep line
+ * direction to be something unusual (ie. not parallel to one of the
+ * coordinate axes).
+ */
+            S_UNIT_X = 0.50941539564955385;	/* Pre-normalized */
+            S_UNIT_Y = 0.86052074622010633;
+        } else {
+            S_UNIT_X = 1.0;
+            S_UNIT_Y = 0.0;
+        }
+    }
+
+    private static double Dot(double[] u, double[] v) {
+        return (u[0] * v[0] + u[1] * v[1] + u[2] * v[2]);
+    }
+
+    static void Normalize(double[] v) {
+        double len = v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
+
+        assert (len > 0);
+        len = Math.sqrt(len);
+        v[0] /= len;
+        v[1] /= len;
+        v[2] /= len;
+    }
+
+    static int LongAxis(double[] v) {
+        int i = 0;
+
+        if (Math.abs(v[1]) > Math.abs(v[0])) {
+            i = 1;
+        }
+        if (Math.abs(v[2]) > Math.abs(v[i])) {
+            i = 2;
+        }
+        return i;
+    }
+
+    static void ComputeNormal(GLUtessellatorImpl tess, double[] norm) {
+        com.sun.opengl.impl.glu.tessellator.GLUvertex v, v1, v2;
+        double c, tLen2, maxLen2;
+        double[] maxVal, minVal, d1, d2, tNorm;
+        com.sun.opengl.impl.glu.tessellator.GLUvertex[] maxVert, minVert;
+        com.sun.opengl.impl.glu.tessellator.GLUvertex vHead = tess.mesh.vHead;
+        int i;
+
+        maxVal = new double[3];
+        minVal = new double[3];
+        minVert = new com.sun.opengl.impl.glu.tessellator.GLUvertex[3];
+        maxVert = new com.sun.opengl.impl.glu.tessellator.GLUvertex[3];
+        d1 = new double[3];
+        d2 = new double[3];
+        tNorm = new double[3];
+
+        maxVal[0] = maxVal[1] = maxVal[2] = -2 * GLU.GLU_TESS_MAX_COORD;
+        minVal[0] = minVal[1] = minVal[2] = 2 * GLU.GLU_TESS_MAX_COORD;
+
+        for (v = vHead.next; v != vHead; v = v.next) {
+            for (i = 0; i < 3; ++i) {
+                c = v.coords[i];
+                if (c < minVal[i]) {
+                    minVal[i] = c;
+                    minVert[i] = v;
+                }
+                if (c > maxVal[i]) {
+                    maxVal[i] = c;
+                    maxVert[i] = v;
+                }
+            }
+        }
+
+/* Find two vertices separated by at least 1/sqrt(3) of the maximum
+         * distance between any two vertices
+         */
+        i = 0;
+        if (maxVal[1] - minVal[1] > maxVal[0] - minVal[0]) {
+            i = 1;
+        }
+        if (maxVal[2] - minVal[2] > maxVal[i] - minVal[i]) {
+            i = 2;
+        }
+        if (minVal[i] >= maxVal[i]) {
+/* All vertices are the same -- normal doesn't matter */
+            norm[0] = 0;
+            norm[1] = 0;
+            norm[2] = 1;
+            return;
+        }
+
+/* Look for a third vertex which forms the triangle with maximum area
+         * (Length of normal == twice the triangle area)
+         */
+        maxLen2 = 0;
+        v1 = minVert[i];
+        v2 = maxVert[i];
+        d1[0] = v1.coords[0] - v2.coords[0];
+        d1[1] = v1.coords[1] - v2.coords[1];
+        d1[2] = v1.coords[2] - v2.coords[2];
+        for (v = vHead.next; v != vHead; v = v.next) {
+            d2[0] = v.coords[0] - v2.coords[0];
+            d2[1] = v.coords[1] - v2.coords[1];
+            d2[2] = v.coords[2] - v2.coords[2];
+            tNorm[0] = d1[1] * d2[2] - d1[2] * d2[1];
+            tNorm[1] = d1[2] * d2[0] - d1[0] * d2[2];
+            tNorm[2] = d1[0] * d2[1] - d1[1] * d2[0];
+            tLen2 = tNorm[0] * tNorm[0] + tNorm[1] * tNorm[1] + tNorm[2] * tNorm[2];
+            if (tLen2 > maxLen2) {
+                maxLen2 = tLen2;
+                norm[0] = tNorm[0];
+                norm[1] = tNorm[1];
+                norm[2] = tNorm[2];
+            }
+        }
+
+        if (maxLen2 <= 0) {
+/* All points lie on a single line -- any decent normal will do */
+            norm[0] = norm[1] = norm[2] = 0;
+            norm[LongAxis(d1)] = 1;
+        }
+    }
+
+    static void CheckOrientation(GLUtessellatorImpl tess) {
+        double area;
+        com.sun.opengl.impl.glu.tessellator.GLUface f, fHead = tess.mesh.fHead;
+        com.sun.opengl.impl.glu.tessellator.GLUvertex v, vHead = tess.mesh.vHead;
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e;
+
+/* When we compute the normal automatically, we choose the orientation
+ * so that the the sum of the signed areas of all contours is non-negative.
+ */
+        area = 0;
+        for (f = fHead.next; f != fHead; f = f.next) {
+            e = f.anEdge;
+            if (e.winding <= 0) continue;
+            do {
+                area += (e.Org.s - e.Sym.Org.s) * (e.Org.t + e.Sym.Org.t);
+                e = e.Lnext;
+            } while (e != f.anEdge);
+        }
+        if (area < 0) {
+/* Reverse the orientation by flipping all the t-coordinates */
+            for (v = vHead.next; v != vHead; v = v.next) {
+                v.t = -v.t;
+            }
+            tess.tUnit[0] = -tess.tUnit[0];
+            tess.tUnit[1] = -tess.tUnit[1];
+            tess.tUnit[2] = -tess.tUnit[2];
+        }
+    }
+
+/* Determine the polygon normal and project vertices onto the plane
+ * of the polygon.
+ */
+    public static void __gl_projectPolygon(GLUtessellatorImpl tess) {
+        com.sun.opengl.impl.glu.tessellator.GLUvertex v, vHead = tess.mesh.vHead;
+        double w;
+        double[] norm = new double[3];
+        double[] sUnit, tUnit;
+        int i;
+        boolean computedNormal = false;
+
+        norm[0] = tess.normal[0];
+        norm[1] = tess.normal[1];
+        norm[2] = tess.normal[2];
+        if (norm[0] == 0 && norm[1] == 0 && norm[2] == 0) {
+            ComputeNormal(tess, norm);
+            computedNormal = true;
+        }
+        sUnit = tess.sUnit;
+        tUnit = tess.tUnit;
+        i = LongAxis(norm);
+
+        if (TRUE_PROJECT) {
+/* Choose the initial sUnit vector to be approximately perpendicular
+ * to the normal.
+ */
+            Normalize(norm);
+
+            sUnit[i] = 0;
+            sUnit[(i + 1) % 3] = S_UNIT_X;
+            sUnit[(i + 2) % 3] = S_UNIT_Y;
+
+/* Now make it exactly perpendicular */
+            w = Dot(sUnit, norm);
+            sUnit[0] -= w * norm[0];
+            sUnit[1] -= w * norm[1];
+            sUnit[2] -= w * norm[2];
+            Normalize(sUnit);
+
+/* Choose tUnit so that (sUnit,tUnit,norm) form a right-handed frame */
+            tUnit[0] = norm[1] * sUnit[2] - norm[2] * sUnit[1];
+            tUnit[1] = norm[2] * sUnit[0] - norm[0] * sUnit[2];
+            tUnit[2] = norm[0] * sUnit[1] - norm[1] * sUnit[0];
+            Normalize(tUnit);
+        } else {
+/* Project perpendicular to a coordinate axis -- better numerically */
+            sUnit[i] = 0;
+            sUnit[(i + 1) % 3] = S_UNIT_X;
+            sUnit[(i + 2) % 3] = S_UNIT_Y;
+
+            tUnit[i] = 0;
+            tUnit[(i + 1) % 3] = (norm[i] > 0) ? -S_UNIT_Y : S_UNIT_Y;
+            tUnit[(i + 2) % 3] = (norm[i] > 0) ? S_UNIT_X : -S_UNIT_X;
+        }
+
+/* Project the vertices onto the sweep plane */
+        for (v = vHead.next; v != vHead; v = v.next) {
+            v.s = Dot(v.coords, sUnit);
+            v.t = Dot(v.coords, tUnit);
+        }
+        if (computedNormal) {
+            CheckOrientation(tess);
+        }
+    }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/PriorityQ.java b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/PriorityQ.java
new file mode 100644
index 000000000..18f2cf32c
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/PriorityQ.java
@@ -0,0 +1,100 @@
+/*
+* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
+* All rights reserved.
+*/
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** Author: Eric Veach, July 1994
+** Java Port: Pepijn Van Eeckhoudt, July 2003
+** Java Port: Nathan Parker Burg, August 2003
+*/
+package com.sun.opengl.impl.glu.tessellator;
+
+abstract class PriorityQ {
+    public static final int INIT_SIZE = 32;
+
+    public static class PQnode {
+        int handle;
+    }
+
+    public static class PQhandleElem {
+        Object key;
+        int node;
+    }
+
+    public static interface Leq {
+        boolean leq(Object key1, Object key2);
+    }
+
+    //    #ifdef FOR_TRITE_TEST_PROGRAM
+//    private static boolean LEQ(PriorityQCommon.Leq leq, Object x,Object y) {
+//        return pq.leq.leq(x,y);
+//    }
+//    #else
+/* Violates modularity, but a little faster */
+//    #include "geom.h"
+    public static boolean LEQ(Leq leq, Object x, Object y) {
+        return com.sun.opengl.impl.glu.tessellator.Geom.VertLeq((com.sun.opengl.impl.glu.tessellator.GLUvertex) x, (com.sun.opengl.impl.glu.tessellator.GLUvertex) y);
+    }
+
+    static PriorityQ pqNewPriorityQ(Leq leq) {
+        return new PriorityQSort(leq);
+    }
+
+    abstract void pqDeletePriorityQ();
+
+    abstract boolean pqInit();
+
+    abstract int pqInsert(Object keyNew);
+
+    abstract Object pqExtractMin();
+
+    abstract void pqDelete(int hCurr);
+
+    abstract Object pqMinimum();
+
+    abstract boolean pqIsEmpty();
+//    #endif
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/PriorityQHeap.java b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/PriorityQHeap.java
new file mode 100644
index 000000000..2f856517a
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/PriorityQHeap.java
@@ -0,0 +1,262 @@
+/*
+* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
+* All rights reserved.
+*/
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** Author: Eric Veach, July 1994
+** Java Port: Pepijn Van Eeckhoudt, July 2003
+** Java Port: Nathan Parker Burg, August 2003
+*/
+package com.sun.opengl.impl.glu.tessellator;
+
+class PriorityQHeap extends com.sun.opengl.impl.glu.tessellator.PriorityQ {
+    com.sun.opengl.impl.glu.tessellator.PriorityQ.PQnode[] nodes;
+    com.sun.opengl.impl.glu.tessellator.PriorityQ.PQhandleElem[] handles;
+    int size, max;
+    int freeList;
+    boolean initialized;
+    com.sun.opengl.impl.glu.tessellator.PriorityQ.Leq leq;
+
+/* really __gl_pqHeapNewPriorityQ */
+    public PriorityQHeap(com.sun.opengl.impl.glu.tessellator.PriorityQ.Leq leq) {
+        size = 0;
+        max = com.sun.opengl.impl.glu.tessellator.PriorityQ.INIT_SIZE;
+        nodes = new com.sun.opengl.impl.glu.tessellator.PriorityQ.PQnode[com.sun.opengl.impl.glu.tessellator.PriorityQ.INIT_SIZE + 1];
+        for (int i = 0; i < nodes.length; i++) {
+            nodes[i] = new PQnode();
+        }
+        handles = new com.sun.opengl.impl.glu.tessellator.PriorityQ.PQhandleElem[com.sun.opengl.impl.glu.tessellator.PriorityQ.INIT_SIZE + 1];
+        for (int i = 0; i < handles.length; i++) {
+            handles[i] = new PQhandleElem();
+        }
+        initialized = false;
+        freeList = 0;
+        this.leq = leq;
+
+        nodes[1].handle = 1;	/* so that Minimum() returns NULL */
+        handles[1].key = null;
+    }
+
+/* really __gl_pqHeapDeletePriorityQ */
+    void pqDeletePriorityQ() {
+        handles = null;
+        nodes = null;
+    }
+
+    void FloatDown(int curr) {
+        com.sun.opengl.impl.glu.tessellator.PriorityQ.PQnode[] n = nodes;
+        com.sun.opengl.impl.glu.tessellator.PriorityQ.PQhandleElem[] h = handles;
+        int hCurr, hChild;
+        int child;
+
+        hCurr = n[curr].handle;
+        for (; ;) {
+            child = curr << 1;
+            if (child < size && LEQ(leq, h[n[child + 1].handle].key,
+                    h[n[child].handle].key)) {
+                ++child;
+            }
+
+            assert (child <= max);
+
+            hChild = n[child].handle;
+            if (child > size || LEQ(leq, h[hCurr].key, h[hChild].key)) {
+                n[curr].handle = hCurr;
+                h[hCurr].node = curr;
+                break;
+            }
+            n[curr].handle = hChild;
+            h[hChild].node = curr;
+            curr = child;
+        }
+    }
+
+
+    void FloatUp(int curr) {
+        com.sun.opengl.impl.glu.tessellator.PriorityQ.PQnode[] n = nodes;
+        com.sun.opengl.impl.glu.tessellator.PriorityQ.PQhandleElem[] h = handles;
+        int hCurr, hParent;
+        int parent;
+
+        hCurr = n[curr].handle;
+        for (; ;) {
+            parent = curr >> 1;
+            hParent = n[parent].handle;
+            if (parent == 0 || LEQ(leq, h[hParent].key, h[hCurr].key)) {
+                n[curr].handle = hCurr;
+                h[hCurr].node = curr;
+                break;
+            }
+            n[curr].handle = hParent;
+            h[hParent].node = curr;
+            curr = parent;
+        }
+    }
+
+/* really __gl_pqHeapInit */
+    boolean pqInit() {
+        int i;
+
+        /* This method of building a heap is O(n), rather than O(n lg n). */
+
+        for (i = size; i >= 1; --i) {
+            FloatDown(i);
+        }
+        initialized = true;
+
+        return true;
+    }
+
+/* really __gl_pqHeapInsert */
+/* returns LONG_MAX iff out of memory */
+    int pqInsert(Object keyNew) {
+        int curr;
+        int free;
+
+        curr = ++size;
+        if ((curr * 2) > max) {
+            com.sun.opengl.impl.glu.tessellator.PriorityQ.PQnode[] saveNodes = nodes;
+            com.sun.opengl.impl.glu.tessellator.PriorityQ.PQhandleElem[] saveHandles = handles;
+
+            /* If the heap overflows, double its size. */
+            max <<= 1;
+//            pq->nodes = (PQnode *)memRealloc( pq->nodes, (size_t) ((pq->max + 1) * sizeof( pq->nodes[0] )));
+            PriorityQ.PQnode[] pqNodes = new PriorityQ.PQnode[max + 1];
+            System.arraycopy( nodes, 0, pqNodes, 0, nodes.length );
+            for (int i = nodes.length; i < pqNodes.length; i++) {
+                pqNodes[i] = new PQnode();
+            }
+            nodes = pqNodes;
+            if (nodes == null) {
+                nodes = saveNodes;	/* restore ptr to free upon return */
+                return Integer.MAX_VALUE;
+            }
+
+//            pq->handles = (PQhandleElem *)memRealloc( pq->handles,(size_t)((pq->max + 1) * sizeof( pq->handles[0] )));
+            PriorityQ.PQhandleElem[] pqHandles = new PriorityQ.PQhandleElem[max + 1];
+            System.arraycopy( handles, 0, pqHandles, 0, handles.length );
+            for (int i = handles.length; i < pqHandles.length; i++) {
+                pqHandles[i] = new PQhandleElem();
+            }
+            handles = pqHandles;
+            if (handles == null) {
+                handles = saveHandles; /* restore ptr to free upon return */
+                return Integer.MAX_VALUE;
+            }
+        }
+
+        if (freeList == 0) {
+            free = curr;
+        } else {
+            free = freeList;
+            freeList = handles[free].node;
+        }
+
+        nodes[curr].handle = free;
+        handles[free].node = curr;
+        handles[free].key = keyNew;
+
+        if (initialized) {
+            FloatUp(curr);
+        }
+        assert (free != Integer.MAX_VALUE);
+        return free;
+    }
+
+/* really __gl_pqHeapExtractMin */
+    Object pqExtractMin() {
+        com.sun.opengl.impl.glu.tessellator.PriorityQ.PQnode[] n = nodes;
+        com.sun.opengl.impl.glu.tessellator.PriorityQ.PQhandleElem[] h = handles;
+        int hMin = n[1].handle;
+        Object min = h[hMin].key;
+
+        if (size > 0) {
+            n[1].handle = n[size].handle;
+            h[n[1].handle].node = 1;
+
+            h[hMin].key = null;
+            h[hMin].node = freeList;
+            freeList = hMin;
+
+            if (--size > 0) {
+                FloatDown(1);
+            }
+        }
+        return min;
+    }
+
+/* really __gl_pqHeapDelete */
+    void pqDelete(int hCurr) {
+        com.sun.opengl.impl.glu.tessellator.PriorityQ.PQnode[] n = nodes;
+        com.sun.opengl.impl.glu.tessellator.PriorityQ.PQhandleElem[] h = handles;
+        int curr;
+
+        assert (hCurr >= 1 && hCurr <= max && h[hCurr].key != null);
+
+        curr = h[hCurr].node;
+        n[curr].handle = n[size].handle;
+        h[n[curr].handle].node = curr;
+
+        if (curr <= --size) {
+            if (curr <= 1 || LEQ(leq, h[n[curr >> 1].handle].key, h[n[curr].handle].key)) {
+                FloatDown(curr);
+            } else {
+                FloatUp(curr);
+            }
+        }
+        h[hCurr].key = null;
+        h[hCurr].node = freeList;
+        freeList = hCurr;
+    }
+
+    Object pqMinimum() {
+        return handles[nodes[1].handle].key;
+    }
+
+    boolean pqIsEmpty() {
+        return size == 0;
+    }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/PriorityQSort.java b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/PriorityQSort.java
new file mode 100644
index 000000000..67924524d
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/PriorityQSort.java
@@ -0,0 +1,278 @@
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** Author: Eric Veach, July 1994
+** Java Port: Pepijn Van Eeckhoudt, July 2003
+** Java Port: Nathan Parker Burg, August 2003
+*/
+package com.sun.opengl.impl.glu.tessellator;
+
+class PriorityQSort extends com.sun.opengl.impl.glu.tessellator.PriorityQ {
+    com.sun.opengl.impl.glu.tessellator.PriorityQHeap heap;
+    Object[] keys;
+
+    // JAVA: 'order' contains indices into the keys array.
+    // This simulates the indirect pointers used in the original C code
+    // (from Frank Suykens, Luciad.com).
+    int[] order;
+    int size, max;
+    boolean initialized;
+    com.sun.opengl.impl.glu.tessellator.PriorityQ.Leq leq;
+
+    public PriorityQSort(com.sun.opengl.impl.glu.tessellator.PriorityQ.Leq leq) {
+        heap = new com.sun.opengl.impl.glu.tessellator.PriorityQHeap(leq);
+
+        keys = new Object[com.sun.opengl.impl.glu.tessellator.PriorityQ.INIT_SIZE];
+
+        size = 0;
+        max = com.sun.opengl.impl.glu.tessellator.PriorityQ.INIT_SIZE;
+        initialized = false;
+        this.leq = leq;
+    }
+
+/* really __gl_pqSortDeletePriorityQ */
+    void pqDeletePriorityQ() {
+        if (heap != null) heap.pqDeletePriorityQ();
+        order = null;
+        keys = null;
+    }
+
+    private static boolean LT(com.sun.opengl.impl.glu.tessellator.PriorityQ.Leq leq, Object x, Object y) {
+        return (!com.sun.opengl.impl.glu.tessellator.PriorityQHeap.LEQ(leq, y, x));
+    }
+
+    private static boolean GT(com.sun.opengl.impl.glu.tessellator.PriorityQ.Leq leq, Object x, Object y) {
+        return (!com.sun.opengl.impl.glu.tessellator.PriorityQHeap.LEQ(leq, x, y));
+    }
+
+    private static void Swap(int[] array, int a, int b) {
+        if (true) {
+            int tmp = array[a];
+            array[a] = array[b];
+            array[b] = tmp;
+        } else {
+
+        }
+    }
+
+    private static class Stack {
+        int p, r;
+    }
+
+/* really __gl_pqSortInit */
+    boolean pqInit() {
+        int p, r, i, j;
+        int piv;
+        Stack[] stack = new Stack[50];
+        for (int k = 0; k < stack.length; k++) {
+            stack[k] = new Stack();
+        }
+        int top = 0;
+
+        int seed = 2016473283;
+
+        /* Create an array of indirect pointers to the keys, so that we
+         * the handles we have returned are still valid.
+         */
+        order = new int[size + 1];
+/* the previous line is a patch to compensate for the fact that IBM */
+/* machines return a null on a malloc of zero bytes (unlike SGI),   */
+/* so we have to put in this defense to guard against a memory      */
+/* fault four lines down. from [email protected].               */
+        p = 0;
+        r = size - 1;
+        for (piv = 0, i = p; i <= r; ++piv, ++i) {
+            // indirect pointers: keep an index into the keys array, not a direct pointer to its contents
+            order[i] = piv;
+        }
+
+        /* Sort the indirect pointers in descending order,
+         * using randomized Quicksort
+         */
+        stack[top].p = p;
+        stack[top].r = r;
+        ++top;
+        while (--top >= 0) {
+            p = stack[top].p;
+            r = stack[top].r;
+            while (r > p + 10) {
+                seed = Math.abs( seed * 1539415821 + 1 );
+                i = p + seed % (r - p + 1);
+                piv = order[i];
+                order[i] = order[p];
+                order[p] = piv;
+                i = p - 1;
+                j = r + 1;
+                do {
+                    do {
+                        ++i;
+                    } while (GT(leq, keys[order[i]], keys[piv]));
+                    do {
+                        --j;
+                    } while (LT(leq, keys[order[j]], keys[piv]));
+                    Swap(order, i, j);
+                } while (i < j);
+                Swap(order, i, j);	/* Undo last swap */
+                if (i - p < r - j) {
+                    stack[top].p = j + 1;
+                    stack[top].r = r;
+                    ++top;
+                    r = i - 1;
+                } else {
+                    stack[top].p = p;
+                    stack[top].r = i - 1;
+                    ++top;
+                    p = j + 1;
+                }
+            }
+            /* Insertion sort small lists */
+            for (i = p + 1; i <= r; ++i) {
+                piv = order[i];
+                for (j = i; j > p && LT(leq, keys[order[j - 1]], keys[piv]); --j) {
+                    order[j] = order[j - 1];
+                }
+                order[j] = piv;
+            }
+        }
+        max = size;
+        initialized = true;
+        heap.pqInit();	/* always succeeds */
+
+/*        #ifndef NDEBUG
+        p = order;
+        r = p + size - 1;
+        for (i = p; i < r; ++i) {
+            Assertion.doAssert(LEQ(     * * (i + 1), **i ));
+        }
+        #endif*/
+
+        return true;
+    }
+
+/* really __gl_pqSortInsert */
+/* returns LONG_MAX iff out of memory */
+    int pqInsert(Object keyNew) {
+        int curr;
+
+        if (initialized) {
+            return heap.pqInsert(keyNew);
+        }
+        curr = size;
+        if (++size >= max) {
+            Object[] saveKey = keys;
+
+            /* If the heap overflows, double its size. */
+            max <<= 1;
+//            pq->keys = (PQHeapKey *)memRealloc( pq->keys,(size_t)(pq->max * sizeof( pq->keys[0] )));
+            Object[] pqKeys = new Object[max];
+            System.arraycopy( keys, 0, pqKeys, 0, keys.length );
+            keys = pqKeys;
+            if (keys == null) {
+                keys = saveKey;	/* restore ptr to free upon return */
+                return Integer.MAX_VALUE;
+            }
+        }
+        assert curr != Integer.MAX_VALUE;
+        keys[curr] = keyNew;
+
+        /* Negative handles index the sorted array. */
+        return -(curr + 1);
+    }
+
+/* really __gl_pqSortExtractMin */
+    Object pqExtractMin() {
+        Object sortMin, heapMin;
+
+        if (size == 0) {
+            return heap.pqExtractMin();
+        }
+        sortMin = keys[order[size - 1]];
+        if (!heap.pqIsEmpty()) {
+            heapMin = heap.pqMinimum();
+            if (LEQ(leq, heapMin, sortMin)) {
+                return heap.pqExtractMin();
+            }
+        }
+        do {
+            --size;
+        } while (size > 0 && keys[order[size - 1]] == null);
+        return sortMin;
+    }
+
+/* really __gl_pqSortMinimum */
+    Object pqMinimum() {
+        Object sortMin, heapMin;
+
+        if (size == 0) {
+            return heap.pqMinimum();
+        }
+        sortMin = keys[order[size - 1]];
+        if (!heap.pqIsEmpty()) {
+            heapMin = heap.pqMinimum();
+            if (com.sun.opengl.impl.glu.tessellator.PriorityQHeap.LEQ(leq, heapMin, sortMin)) {
+                return heapMin;
+            }
+        }
+        return sortMin;
+    }
+
+/* really __gl_pqSortIsEmpty */
+    boolean pqIsEmpty() {
+        return (size == 0) && heap.pqIsEmpty();
+    }
+
+/* really __gl_pqSortDelete */
+    void pqDelete(int curr) {
+        if (curr >= 0) {
+            heap.pqDelete(curr);
+            return;
+        }
+        curr = -(curr + 1);
+        assert curr < max && keys[curr] != null;
+
+        keys[curr] = null;
+        while (size > 0 && keys[order[size - 1]] == null) {
+            --size;
+        }
+    }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/Render.java b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/Render.java
new file mode 100644
index 000000000..cd6e02255
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/Render.java
@@ -0,0 +1,557 @@
+/*
+* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
+* All rights reserved.
+*/
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** Author: Eric Veach, July 1994
+** Java Port: Pepijn Van Eeckhoudt, July 2003
+** Java Port: Nathan Parker Burg, August 2003
+*/
+package com.sun.opengl.impl.glu.tessellator;
+
+import javax.media.opengl.*;
+import javax.media.opengl.glu.*;
+
+class Render {
+    private static final boolean USE_OPTIMIZED_CODE_PATH = false;
+
+    private Render() {
+    }
+
+    private static final RenderFan renderFan = new RenderFan();
+    private static final RenderStrip renderStrip = new RenderStrip();
+    private static final RenderTriangle renderTriangle = new RenderTriangle();
+
+/* This structure remembers the information we need about a primitive
+ * to be able to render it later, once we have determined which
+ * primitive is able to use the most triangles.
+ */
+    private static class FaceCount {
+        public FaceCount() {
+        }
+
+        public FaceCount(long size, com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eStart, renderCallBack render) {
+            this.size = size;
+            this.eStart = eStart;
+            this.render = render;
+        }
+
+        long size;		/* number of triangles used */
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eStart;	/* edge where this primitive starts */
+        renderCallBack render;
+    };
+
+    private static interface renderCallBack {
+        void render(GLUtessellatorImpl tess, com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e, long size);
+    }
+
+    /************************ Strips and Fans decomposition ******************/
+
+/* __gl_renderMesh( tess, mesh ) takes a mesh and breaks it into triangle
+ * fans, strips, and separate triangles.  A substantial effort is made
+ * to use as few rendering primitives as possible (ie. to make the fans
+ * and strips as large as possible).
+ *
+ * The rendering output is provided as callbacks (see the api).
+ */
+    public static void __gl_renderMesh(GLUtessellatorImpl tess, com.sun.opengl.impl.glu.tessellator.GLUmesh mesh) {
+        com.sun.opengl.impl.glu.tessellator.GLUface f;
+
+        /* Make a list of separate triangles so we can render them all at once */
+        tess.lonelyTriList = null;
+
+        for (f = mesh.fHead.next; f != mesh.fHead; f = f.next) {
+            f.marked = false;
+        }
+        for (f = mesh.fHead.next; f != mesh.fHead; f = f.next) {
+
+            /* We examine all faces in an arbitrary order.  Whenever we find
+             * an unprocessed face F, we output a group of faces including F
+             * whose size is maximum.
+             */
+            if (f.inside && !f.marked) {
+                RenderMaximumFaceGroup(tess, f);
+                assert (f.marked);
+            }
+        }
+        if (tess.lonelyTriList != null) {
+            RenderLonelyTriangles(tess, tess.lonelyTriList);
+            tess.lonelyTriList = null;
+        }
+    }
+
+
+    static void RenderMaximumFaceGroup(GLUtessellatorImpl tess, com.sun.opengl.impl.glu.tessellator.GLUface fOrig) {
+        /* We want to find the largest triangle fan or strip of unmarked faces
+         * which includes the given face fOrig.  There are 3 possible fans
+         * passing through fOrig (one centered at each vertex), and 3 possible
+         * strips (one for each CCW permutation of the vertices).  Our strategy
+         * is to try all of these, and take the primitive which uses the most
+         * triangles (a greedy approach).
+         */
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e = fOrig.anEdge;
+        FaceCount max = new FaceCount();
+        FaceCount newFace = new FaceCount();
+
+        max.size = 1;
+        max.eStart = e;
+        max.render = renderTriangle;
+
+        if (!tess.flagBoundary) {
+            newFace = MaximumFan(e);
+            if (newFace.size > max.size) {
+                max = newFace;
+            }
+            newFace = MaximumFan(e.Lnext);
+            if (newFace.size > max.size) {
+                max = newFace;
+            }
+            newFace = MaximumFan(e.Onext.Sym);
+            if (newFace.size > max.size) {
+                max = newFace;
+            }
+
+            newFace = MaximumStrip(e);
+            if (newFace.size > max.size) {
+                max = newFace;
+            }
+            newFace = MaximumStrip(e.Lnext);
+            if (newFace.size > max.size) {
+                max = newFace;
+            }
+            newFace = MaximumStrip(e.Onext.Sym);
+            if (newFace.size > max.size) {
+                max = newFace;
+            }
+        }
+        max.render.render(tess, max.eStart, max.size);
+    }
+
+
+/* Macros which keep track of faces we have marked temporarily, and allow
+ * us to backtrack when necessary.  With triangle fans, this is not
+ * really necessary, since the only awkward case is a loop of triangles
+ * around a single origin vertex.  However with strips the situation is
+ * more complicated, and we need a general tracking method like the
+ * one here.
+ */
+    private static boolean Marked(com.sun.opengl.impl.glu.tessellator.GLUface f) {
+        return !f.inside || f.marked;
+    }
+
+    private static GLUface AddToTrail(com.sun.opengl.impl.glu.tessellator.GLUface f, com.sun.opengl.impl.glu.tessellator.GLUface t) {
+        f.trail = t;
+        f.marked = true;
+        return f;
+    }
+
+    private static void FreeTrail(com.sun.opengl.impl.glu.tessellator.GLUface t) {
+        if (true) {
+            while (t != null) {
+                t.marked = false;
+                t = t.trail;
+            }
+        } else {
+            /* absorb trailing semicolon */
+        }
+    }
+
+    static FaceCount MaximumFan(com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eOrig) {
+        /* eOrig.Lface is the face we want to render.  We want to find the size
+         * of a maximal fan around eOrig.Org.  To do this we just walk around
+         * the origin vertex as far as possible in both directions.
+         */
+        FaceCount newFace = new FaceCount(0, null, renderFan);
+        com.sun.opengl.impl.glu.tessellator.GLUface trail = null;
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e;
+
+        for (e = eOrig; !Marked(e.Lface); e = e.Onext) {
+            trail = AddToTrail(e.Lface, trail);
+            ++newFace.size;
+        }
+        for (e = eOrig; !Marked(e.Sym.Lface); e = e.Sym.Lnext) {
+            trail = AddToTrail(e.Sym.Lface, trail);
+            ++newFace.size;
+        }
+        newFace.eStart = e;
+        /*LINTED*/
+        FreeTrail(trail);
+        return newFace;
+    }
+
+
+    private static boolean IsEven(long n) {
+        return (n & 0x1L) == 0;
+    }
+
+    static FaceCount MaximumStrip(com.sun.opengl.impl.glu.tessellator.GLUhalfEdge eOrig) {
+        /* Here we are looking for a maximal strip that contains the vertices
+         * eOrig.Org, eOrig.Dst, eOrig.Lnext.Dst (in that order or the
+         * reverse, such that all triangles are oriented CCW).
+         *
+         * Again we walk forward and backward as far as possible.  However for
+         * strips there is a twist: to get CCW orientations, there must be
+         * an *even* number of triangles in the strip on one side of eOrig.
+         * We walk the strip starting on a side with an even number of triangles;
+         * if both side have an odd number, we are forced to shorten one side.
+         */
+        FaceCount newFace = new FaceCount(0, null, renderStrip);
+        long headSize = 0, tailSize = 0;
+        com.sun.opengl.impl.glu.tessellator.GLUface trail = null;
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e, eTail, eHead;
+
+        for (e = eOrig; !Marked(e.Lface); ++tailSize, e = e.Onext) {
+            trail = AddToTrail(e.Lface, trail);
+            ++tailSize;
+            e = e.Lnext.Sym;
+            if (Marked(e.Lface)) break;
+            trail = AddToTrail(e.Lface, trail);
+        }
+        eTail = e;
+
+        for (e = eOrig; !Marked(e.Sym.Lface); ++headSize, e = e.Sym.Onext.Sym) {
+            trail = AddToTrail(e.Sym.Lface, trail);
+            ++headSize;
+            e = e.Sym.Lnext;
+            if (Marked(e.Sym.Lface)) break;
+            trail = AddToTrail(e.Sym.Lface, trail);
+        }
+        eHead = e;
+
+        newFace.size = tailSize + headSize;
+        if (IsEven(tailSize)) {
+            newFace.eStart = eTail.Sym;
+        } else if (IsEven(headSize)) {
+            newFace.eStart = eHead;
+        } else {
+            /* Both sides have odd length, we must shorten one of them.  In fact,
+             * we must start from eHead to guarantee inclusion of eOrig.Lface.
+             */
+            --newFace.size;
+            newFace.eStart = eHead.Onext;
+        }
+        /*LINTED*/
+        FreeTrail(trail);
+        return newFace;
+    }
+
+    private static class RenderTriangle implements renderCallBack {
+        public void render(GLUtessellatorImpl tess, com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e, long size) {
+            /* Just add the triangle to a triangle list, so we can render all
+             * the separate triangles at once.
+             */
+            assert (size == 1);
+            tess.lonelyTriList = AddToTrail(e.Lface, tess.lonelyTriList);
+        }
+    }
+
+
+    static void RenderLonelyTriangles(GLUtessellatorImpl tess, com.sun.opengl.impl.glu.tessellator.GLUface f) {
+        /* Now we render all the separate triangles which could not be
+         * grouped into a triangle fan or strip.
+         */
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e;
+        int newState;
+        int edgeState = -1;	/* force edge state output for first vertex */
+
+        tess.callBeginOrBeginData(GL.GL_TRIANGLES);
+
+        for (; f != null; f = f.trail) {
+            /* Loop once for each edge (there will always be 3 edges) */
+
+            e = f.anEdge;
+            do {
+                if (tess.flagBoundary) {
+                    /* Set the "edge state" to true just before we output the
+                     * first vertex of each edge on the polygon boundary.
+                     */
+                    newState = (!e.Sym.Lface.inside) ? 1 : 0;
+                    if (edgeState != newState) {
+                        edgeState = newState;
+                        tess.callEdgeFlagOrEdgeFlagData( edgeState != 0);
+                    }
+                }
+                tess.callVertexOrVertexData( e.Org.data);
+
+                e = e.Lnext;
+            } while (e != f.anEdge);
+        }
+        tess.callEndOrEndData();
+    }
+
+    private static class RenderFan implements renderCallBack {
+        public void render(GLUtessellatorImpl tess, com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e, long size) {
+            /* Render as many CCW triangles as possible in a fan starting from
+             * edge "e".  The fan *should* contain exactly "size" triangles
+             * (otherwise we've goofed up somewhere).
+             */
+            tess.callBeginOrBeginData( GL.GL_TRIANGLE_FAN);
+            tess.callVertexOrVertexData( e.Org.data);
+            tess.callVertexOrVertexData( e.Sym.Org.data);
+
+            while (!Marked(e.Lface)) {
+                e.Lface.marked = true;
+                --size;
+                e = e.Onext;
+                tess.callVertexOrVertexData( e.Sym.Org.data);
+            }
+
+            assert (size == 0);
+            tess.callEndOrEndData();
+        }
+    }
+
+    private static class RenderStrip implements renderCallBack {
+        public void render(GLUtessellatorImpl tess, com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e, long size) {
+            /* Render as many CCW triangles as possible in a strip starting from
+             * edge "e".  The strip *should* contain exactly "size" triangles
+             * (otherwise we've goofed up somewhere).
+             */
+            tess.callBeginOrBeginData( GL.GL_TRIANGLE_STRIP);
+            tess.callVertexOrVertexData( e.Org.data);
+            tess.callVertexOrVertexData( e.Sym.Org.data);
+
+            while (!Marked(e.Lface)) {
+                e.Lface.marked = true;
+                --size;
+                e = e.Lnext.Sym;
+                tess.callVertexOrVertexData( e.Org.data);
+                if (Marked(e.Lface)) break;
+
+                e.Lface.marked = true;
+                --size;
+                e = e.Onext;
+                tess.callVertexOrVertexData( e.Sym.Org.data);
+            }
+
+            assert (size == 0);
+            tess.callEndOrEndData();
+        }
+    }
+
+    /************************ Boundary contour decomposition ******************/
+
+/* __gl_renderBoundary( tess, mesh ) takes a mesh, and outputs one
+ * contour for each face marked "inside".  The rendering output is
+ * provided as callbacks (see the api).
+ */
+    public static void __gl_renderBoundary(GLUtessellatorImpl tess, com.sun.opengl.impl.glu.tessellator.GLUmesh mesh) {
+        com.sun.opengl.impl.glu.tessellator.GLUface f;
+        com.sun.opengl.impl.glu.tessellator.GLUhalfEdge e;
+
+        for (f = mesh.fHead.next; f != mesh.fHead; f = f.next) {
+            if (f.inside) {
+                tess.callBeginOrBeginData( GL.GL_LINE_LOOP);
+                e = f.anEdge;
+                do {
+                    tess.callVertexOrVertexData( e.Org.data);
+                    e = e.Lnext;
+                } while (e != f.anEdge);
+                tess.callEndOrEndData();
+            }
+        }
+    }
+
+
+    /************************ Quick-and-dirty decomposition ******************/
+
+    private static final int SIGN_INCONSISTENT = 2;
+
+    static int ComputeNormal(GLUtessellatorImpl tess, double[] norm, boolean check)
+/*
+ * If check==false, we compute the polygon normal and place it in norm[].
+ * If check==true, we check that each triangle in the fan from v0 has a
+ * consistent orientation with respect to norm[].  If triangles are
+ * consistently oriented CCW, return 1; if CW, return -1; if all triangles
+ * are degenerate return 0; otherwise (no consistent orientation) return
+ * SIGN_INCONSISTENT.
+ */ {
+        com.sun.opengl.impl.glu.tessellator.CachedVertex[] v = tess.cache;
+//            CachedVertex vn = v0 + tess.cacheCount;
+        int vn = tess.cacheCount;
+//            CachedVertex vc;
+        int vc;
+        double dot, xc, yc, zc, xp, yp, zp;
+        double[] n = new double[3];
+        int sign = 0;
+
+        /* Find the polygon normal.  It is important to get a reasonable
+         * normal even when the polygon is self-intersecting (eg. a bowtie).
+         * Otherwise, the computed normal could be very tiny, but perpendicular
+         * to the true plane of the polygon due to numerical noise.  Then all
+         * the triangles would appear to be degenerate and we would incorrectly
+         * decompose the polygon as a fan (or simply not render it at all).
+         *
+         * We use a sum-of-triangles normal algorithm rather than the more
+         * efficient sum-of-trapezoids method (used in CheckOrientation()
+         * in normal.c).  This lets us explicitly reverse the signed area
+         * of some triangles to get a reasonable normal in the self-intersecting
+         * case.
+         */
+        if (!check) {
+            norm[0] = norm[1] = norm[2] = 0.0;
+        }
+
+        vc = 1;
+        xc = v[vc].coords[0] - v[0].coords[0];
+        yc = v[vc].coords[1] - v[0].coords[1];
+        zc = v[vc].coords[2] - v[0].coords[2];
+        while (++vc < vn) {
+            xp = xc;
+            yp = yc;
+            zp = zc;
+            xc = v[vc].coords[0] - v[0].coords[0];
+            yc = v[vc].coords[1] - v[0].coords[1];
+            zc = v[vc].coords[2] - v[0].coords[2];
+
+            /* Compute (vp - v0) cross (vc - v0) */
+            n[0] = yp * zc - zp * yc;
+            n[1] = zp * xc - xp * zc;
+            n[2] = xp * yc - yp * xc;
+
+            dot = n[0] * norm[0] + n[1] * norm[1] + n[2] * norm[2];
+            if (!check) {
+                /* Reverse the contribution of back-facing triangles to get
+                 * a reasonable normal for self-intersecting polygons (see above)
+                 */
+                if (dot >= 0) {
+                    norm[0] += n[0];
+                    norm[1] += n[1];
+                    norm[2] += n[2];
+                } else {
+                    norm[0] -= n[0];
+                    norm[1] -= n[1];
+                    norm[2] -= n[2];
+                }
+            } else if (dot != 0) {
+                /* Check the new orientation for consistency with previous triangles */
+                if (dot > 0) {
+                    if (sign < 0) return SIGN_INCONSISTENT;
+                    sign = 1;
+                } else {
+                    if (sign > 0) return SIGN_INCONSISTENT;
+                    sign = -1;
+                }
+            }
+        }
+        return sign;
+    }
+
+/* __gl_renderCache( tess ) takes a single contour and tries to render it
+ * as a triangle fan.  This handles convex polygons, as well as some
+ * non-convex polygons if we get lucky.
+ *
+ * Returns true if the polygon was successfully rendered.  The rendering
+ * output is provided as callbacks (see the api).
+ */
+    public static boolean __gl_renderCache(GLUtessellatorImpl tess) {
+        com.sun.opengl.impl.glu.tessellator.CachedVertex[] v = tess.cache;
+//            CachedVertex vn = v0 + tess.cacheCount;
+        int vn = tess.cacheCount;
+//            CachedVertex vc;
+        int vc;
+        double[] norm = new double[3];
+        int sign;
+
+        if (tess.cacheCount < 3) {
+            /* Degenerate contour -- no output */
+            return true;
+        }
+
+        norm[0] = tess.normal[0];
+        norm[1] = tess.normal[1];
+        norm[2] = tess.normal[2];
+        if (norm[0] == 0 && norm[1] == 0 && norm[2] == 0) {
+            ComputeNormal( tess, norm, false);
+        }
+
+        sign = ComputeNormal( tess, norm, true);
+        if (sign == SIGN_INCONSISTENT) {
+            /* Fan triangles did not have a consistent orientation */
+            return false;
+        }
+        if (sign == 0) {
+            /* All triangles were degenerate */
+            return true;
+        }
+
+        if ( !USE_OPTIMIZED_CODE_PATH ) {
+            return false;
+        } else {
+            /* Make sure we do the right thing for each winding rule */
+            switch (tess.windingRule) {
+                case GLU.GLU_TESS_WINDING_ODD:
+                case GLU.GLU_TESS_WINDING_NONZERO:
+                    break;
+                case GLU.GLU_TESS_WINDING_POSITIVE:
+                    if (sign < 0) return true;
+                    break;
+                case GLU.GLU_TESS_WINDING_NEGATIVE:
+                    if (sign > 0) return true;
+                    break;
+                case GLU.GLU_TESS_WINDING_ABS_GEQ_TWO:
+                    return true;
+            }
+
+            tess.callBeginOrBeginData( tess.boundaryOnly ? GL.GL_LINE_LOOP
+                    : (tess.cacheCount > 3) ? GL.GL_TRIANGLE_FAN
+                    : GL.GL_TRIANGLES);
+
+            tess.callVertexOrVertexData( v[0].data);
+            if (sign > 0) {
+                for (vc = 1; vc < vn; ++vc) {
+                    tess.callVertexOrVertexData( v[vc].data);
+                }
+            } else {
+                for (vc = vn - 1; vc > 0; --vc) {
+                    tess.callVertexOrVertexData( v[vc].data);
+                }
+            }
+            tess.callEndOrEndData();
+            return true;
+        }
+    }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/Sweep.java b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/Sweep.java
new file mode 100644
index 000000000..105328d87
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/Sweep.java
@@ -0,0 +1,1353 @@
+/*
+* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
+* All rights reserved.
+*/
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** Author: Eric Veach, July 1994
+** Java Port: Pepijn Van Eeckhoudt, July 2003
+** Java Port: Nathan Parker Burg, August 2003
+*/
+package com.sun.opengl.impl.glu.tessellator;
+
+import javax.media.opengl.*;
+import javax.media.opengl.glu.*;
+
+class Sweep {
+    private Sweep() {
+    }
+
+//    #ifdef FOR_TRITE_TEST_PROGRAM
+//    extern void DebugEvent( GLUtessellator *tess );
+//    #else
+    private static void DebugEvent(GLUtessellatorImpl tess) {
+
+    }
+//    #endif
+
+/*
+ * Invariants for the Edge Dictionary.
+ * - each pair of adjacent edges e2=Succ(e1) satisfies EdgeLeq(e1,e2)
+ *   at any valid location of the sweep event
+ * - if EdgeLeq(e2,e1) as well (at any valid sweep event), then e1 and e2
+ *   share a common endpoint
+ * - for each e, e.Dst has been processed, but not e.Org
+ * - each edge e satisfies VertLeq(e.Dst,event) && VertLeq(event,e.Org)
+ *   where "event" is the current sweep line event.
+ * - no edge e has zero length
+ *
+ * Invariants for the Mesh (the processed portion).
+ * - the portion of the mesh left of the sweep line is a planar graph,
+ *   ie. there is *some* way to embed it in the plane
+ * - no processed edge has zero length
+ * - no two processed vertices have identical coordinates
+ * - each "inside" region is monotone, ie. can be broken into two chains
+ *   of monotonically increasing vertices according to VertLeq(v1,v2)
+ *   - a non-invariant: these chains may intersect (very slightly)
+ *
+ * Invariants for the Sweep.
+ * - if none of the edges incident to the event vertex have an activeRegion
+ *   (ie. none of these edges are in the edge dictionary), then the vertex
+ *   has only right-going edges.
+ * - if an edge is marked "fixUpperEdge" (it is a temporary edge introduced
+ *   by ConnectRightVertex), then it is the only right-going edge from
+ *   its associated vertex.  (This says that these edges exist only
+ *   when it is necessary.)
+ */
+
+/* When we merge two edges into one, we need to compute the combined
+ * winding of the new edge.
+ */
+    private static void AddWinding(GLUhalfEdge eDst, GLUhalfEdge eSrc) {
+        eDst.winding += eSrc.winding;
+        eDst.Sym.winding += eSrc.Sym.winding;
+    }
+
+
+    private static ActiveRegion RegionBelow(ActiveRegion r) {
+        return ((ActiveRegion) Dict.dictKey(Dict.dictPred(r.nodeUp)));
+    }
+
+    private static ActiveRegion RegionAbove(ActiveRegion r) {
+        return ((ActiveRegion) Dict.dictKey(Dict.dictSucc(r.nodeUp)));
+    }
+
+    static boolean EdgeLeq(GLUtessellatorImpl tess, ActiveRegion reg1, ActiveRegion reg2)
+/*
+ * Both edges must be directed from right to left (this is the canonical
+ * direction for the upper edge of each region).
+ *
+ * The strategy is to evaluate a "t" value for each edge at the
+ * current sweep line position, given by tess.event.  The calculations
+ * are designed to be very stable, but of course they are not perfect.
+ *
+ * Special case: if both edge destinations are at the sweep event,
+ * we sort the edges by slope (they would otherwise compare equally).
+ */ {
+        GLUvertex event = tess.event;
+        GLUhalfEdge e1, e2;
+        double t1, t2;
+
+        e1 = reg1.eUp;
+        e2 = reg2.eUp;
+
+        if (e1.Sym.Org == event) {
+            if (e2.Sym.Org == event) {
+                /* Two edges right of the sweep line which meet at the sweep event.
+                 * Sort them by slope.
+                 */
+                if (Geom.VertLeq(e1.Org, e2.Org)) {
+                    return Geom.EdgeSign(e2.Sym.Org, e1.Org, e2.Org) <= 0;
+                }
+                return Geom.EdgeSign(e1.Sym.Org, e2.Org, e1.Org) >= 0;
+            }
+            return Geom.EdgeSign(e2.Sym.Org, event, e2.Org) <= 0;
+        }
+        if (e2.Sym.Org == event) {
+            return Geom.EdgeSign(e1.Sym.Org, event, e1.Org) >= 0;
+        }
+
+        /* General case - compute signed distance *from* e1, e2 to event */
+        t1 = Geom.EdgeEval(e1.Sym.Org, event, e1.Org);
+        t2 = Geom.EdgeEval(e2.Sym.Org, event, e2.Org);
+        return (t1 >= t2);
+    }
+
+
+    static void DeleteRegion(GLUtessellatorImpl tess, ActiveRegion reg) {
+        if (reg.fixUpperEdge) {
+            /* It was created with zero winding number, so it better be
+             * deleted with zero winding number (ie. it better not get merged
+             * with a real edge).
+             */
+            assert (reg.eUp.winding == 0);
+        }
+        reg.eUp.activeRegion = null;
+        Dict.dictDelete(tess.dict, reg.nodeUp); /* __gl_dictListDelete */
+    }
+
+
+    static boolean FixUpperEdge(ActiveRegion reg, GLUhalfEdge newEdge)
+/*
+ * Replace an upper edge which needs fixing (see ConnectRightVertex).
+ */ {
+        assert (reg.fixUpperEdge);
+        if (!Mesh.__gl_meshDelete(reg.eUp)) return false;
+        reg.fixUpperEdge = false;
+        reg.eUp = newEdge;
+        newEdge.activeRegion = reg;
+
+        return true;
+    }
+
+    static ActiveRegion TopLeftRegion(ActiveRegion reg) {
+        GLUvertex org = reg.eUp.Org;
+        GLUhalfEdge e;
+
+        /* Find the region above the uppermost edge with the same origin */
+        do {
+            reg = RegionAbove(reg);
+        } while (reg.eUp.Org == org);
+
+        /* If the edge above was a temporary edge introduced by ConnectRightVertex,
+         * now is the time to fix it.
+         */
+        if (reg.fixUpperEdge) {
+            e = Mesh.__gl_meshConnect(RegionBelow(reg).eUp.Sym, reg.eUp.Lnext);
+            if (e == null) return null;
+            if (!FixUpperEdge(reg, e)) return null;
+            reg = RegionAbove(reg);
+        }
+        return reg;
+    }
+
+    static ActiveRegion TopRightRegion(ActiveRegion reg) {
+        GLUvertex dst = reg.eUp.Sym.Org;
+
+        /* Find the region above the uppermost edge with the same destination */
+        do {
+            reg = RegionAbove(reg);
+        } while (reg.eUp.Sym.Org == dst);
+        return reg;
+    }
+
+    static ActiveRegion AddRegionBelow(GLUtessellatorImpl tess,
+                                       ActiveRegion regAbove,
+                                       GLUhalfEdge eNewUp)
+/*
+ * Add a new active region to the sweep line, *somewhere* below "regAbove"
+ * (according to where the new edge belongs in the sweep-line dictionary).
+ * The upper edge of the new region will be "eNewUp".
+ * Winding number and "inside" flag are not updated.
+ */ {
+        ActiveRegion regNew = new ActiveRegion();
+        if (regNew == null) throw new RuntimeException();
+
+        regNew.eUp = eNewUp;
+        /* __gl_dictListInsertBefore */
+        regNew.nodeUp = Dict.dictInsertBefore(tess.dict, regAbove.nodeUp, regNew);
+        if (regNew.nodeUp == null) throw new RuntimeException();
+        regNew.fixUpperEdge = false;
+        regNew.sentinel = false;
+        regNew.dirty = false;
+
+        eNewUp.activeRegion = regNew;
+        return regNew;
+    }
+
+    static boolean IsWindingInside(GLUtessellatorImpl tess, int n) {
+        switch (tess.windingRule) {
+            case GLU.GLU_TESS_WINDING_ODD:
+                return (n & 1) != 0;
+            case GLU.GLU_TESS_WINDING_NONZERO:
+                return (n != 0);
+            case GLU.GLU_TESS_WINDING_POSITIVE:
+                return (n > 0);
+            case GLU.GLU_TESS_WINDING_NEGATIVE:
+                return (n < 0);
+            case GLU.GLU_TESS_WINDING_ABS_GEQ_TWO:
+                return (n >= 2) || (n <= -2);
+        }
+        /*LINTED*/
+//        assert (false);
+        throw new InternalError();
+        /*NOTREACHED*/
+    }
+
+
+    static void ComputeWinding(GLUtessellatorImpl tess, ActiveRegion reg) {
+        reg.windingNumber = RegionAbove(reg).windingNumber + reg.eUp.winding;
+        reg.inside = IsWindingInside(tess, reg.windingNumber);
+    }
+
+
+    static void FinishRegion(GLUtessellatorImpl tess, ActiveRegion reg)
+/*
+ * Delete a region from the sweep line.  This happens when the upper
+ * and lower chains of a region meet (at a vertex on the sweep line).
+ * The "inside" flag is copied to the appropriate mesh face (we could
+ * not do this before -- since the structure of the mesh is always
+ * changing, this face may not have even existed until now).
+ */ {
+        GLUhalfEdge e = reg.eUp;
+        GLUface f = e.Lface;
+
+        f.inside = reg.inside;
+        f.anEdge = e;   /* optimization for __gl_meshTessellateMonoRegion() */
+        DeleteRegion(tess, reg);
+    }
+
+
+    static GLUhalfEdge FinishLeftRegions(GLUtessellatorImpl tess,
+                                         ActiveRegion regFirst, ActiveRegion regLast)
+/*
+ * We are given a vertex with one or more left-going edges.  All affected
+ * edges should be in the edge dictionary.  Starting at regFirst.eUp,
+ * we walk down deleting all regions where both edges have the same
+ * origin vOrg.  At the same time we copy the "inside" flag from the
+ * active region to the face, since at this point each face will belong
+ * to at most one region (this was not necessarily true until this point
+ * in the sweep).  The walk stops at the region above regLast; if regLast
+ * is null we walk as far as possible.  At the same time we relink the
+ * mesh if necessary, so that the ordering of edges around vOrg is the
+ * same as in the dictionary.
+ */ {
+        ActiveRegion reg, regPrev;
+        GLUhalfEdge e, ePrev;
+
+        regPrev = regFirst;
+        ePrev = regFirst.eUp;
+        while (regPrev != regLast) {
+            regPrev.fixUpperEdge = false;	/* placement was OK */
+            reg = RegionBelow(regPrev);
+            e = reg.eUp;
+            if (e.Org != ePrev.Org) {
+                if (!reg.fixUpperEdge) {
+                    /* Remove the last left-going edge.  Even though there are no further
+                     * edges in the dictionary with this origin, there may be further
+                     * such edges in the mesh (if we are adding left edges to a vertex
+                     * that has already been processed).  Thus it is important to call
+                     * FinishRegion rather than just DeleteRegion.
+                     */
+                    FinishRegion(tess, regPrev);
+                    break;
+                }
+                /* If the edge below was a temporary edge introduced by
+                 * ConnectRightVertex, now is the time to fix it.
+                 */
+                e = Mesh.__gl_meshConnect(ePrev.Onext.Sym, e.Sym);
+                if (e == null) throw new RuntimeException();
+                if (!FixUpperEdge(reg, e)) throw new RuntimeException();
+            }
+
+            /* Relink edges so that ePrev.Onext == e */
+            if (ePrev.Onext != e) {
+                if (!Mesh.__gl_meshSplice(e.Sym.Lnext, e)) throw new RuntimeException();
+                if (!Mesh.__gl_meshSplice(ePrev, e)) throw new RuntimeException();
+            }
+            FinishRegion(tess, regPrev);	/* may change reg.eUp */
+            ePrev = reg.eUp;
+            regPrev = reg;
+        }
+        return ePrev;
+    }
+
+
+    static void AddRightEdges(GLUtessellatorImpl tess, ActiveRegion regUp,
+                              GLUhalfEdge eFirst, GLUhalfEdge eLast, GLUhalfEdge eTopLeft,
+                              boolean cleanUp)
+/*
+ * Purpose: insert right-going edges into the edge dictionary, and update
+ * winding numbers and mesh connectivity appropriately.  All right-going
+ * edges share a common origin vOrg.  Edges are inserted CCW starting at
+ * eFirst; the last edge inserted is eLast.Sym.Lnext.  If vOrg has any
+ * left-going edges already processed, then eTopLeft must be the edge
+ * such that an imaginary upward vertical segment from vOrg would be
+ * contained between eTopLeft.Sym.Lnext and eTopLeft; otherwise eTopLeft
+ * should be null.
+ */ {
+        ActiveRegion reg, regPrev;
+        GLUhalfEdge e, ePrev;
+        boolean firstTime = true;
+
+        /* Insert the new right-going edges in the dictionary */
+        e = eFirst;
+        do {
+            assert (Geom.VertLeq(e.Org, e.Sym.Org));
+            AddRegionBelow(tess, regUp, e.Sym);
+            e = e.Onext;
+        } while (e != eLast);
+
+        /* Walk *all* right-going edges from e.Org, in the dictionary order,
+         * updating the winding numbers of each region, and re-linking the mesh
+         * edges to match the dictionary ordering (if necessary).
+         */
+        if (eTopLeft == null) {
+            eTopLeft = RegionBelow(regUp).eUp.Sym.Onext;
+        }
+        regPrev = regUp;
+        ePrev = eTopLeft;
+        for (; ;) {
+            reg = RegionBelow(regPrev);
+            e = reg.eUp.Sym;
+            if (e.Org != ePrev.Org) break;
+
+            if (e.Onext != ePrev) {
+                /* Unlink e from its current position, and relink below ePrev */
+                if (!Mesh.__gl_meshSplice(e.Sym.Lnext, e)) throw new RuntimeException();
+                if (!Mesh.__gl_meshSplice(ePrev.Sym.Lnext, e)) throw new RuntimeException();
+            }
+            /* Compute the winding number and "inside" flag for the new regions */
+            reg.windingNumber = regPrev.windingNumber - e.winding;
+            reg.inside = IsWindingInside(tess, reg.windingNumber);
+
+            /* Check for two outgoing edges with same slope -- process these
+             * before any intersection tests (see example in __gl_computeInterior).
+             */
+            regPrev.dirty = true;
+            if (!firstTime && CheckForRightSplice(tess, regPrev)) {
+                AddWinding(e, ePrev);
+                DeleteRegion(tess, regPrev);
+                if (!Mesh.__gl_meshDelete(ePrev)) throw new RuntimeException();
+            }
+            firstTime = false;
+            regPrev = reg;
+            ePrev = e;
+        }
+        regPrev.dirty = true;
+        assert (regPrev.windingNumber - e.winding == reg.windingNumber);
+
+        if (cleanUp) {
+            /* Check for intersections between newly adjacent edges. */
+            WalkDirtyRegions(tess, regPrev);
+        }
+    }
+
+
+    static void CallCombine(GLUtessellatorImpl tess, GLUvertex isect,
+                            Object[] data, float[] weights, boolean needed) {
+        double[] coords = new double[3];
+
+        /* Copy coord data in case the callback changes it. */
+        coords[0] = isect.coords[0];
+        coords[1] = isect.coords[1];
+        coords[2] = isect.coords[2];
+
+        Object[] outData = new Object[1];
+        tess.callCombineOrCombineData(coords, data, weights, outData);
+        isect.data = outData[0];
+        if (isect.data == null) {
+            if (!needed) {
+                isect.data = data[0];
+            } else if (!tess.fatalError) {
+                /* The only way fatal error is when two edges are found to intersect,
+                 * but the user has not provided the callback necessary to handle
+                 * generated intersection points.
+                 */
+                tess.callErrorOrErrorData(GLU.GLU_TESS_NEED_COMBINE_CALLBACK);
+                tess.fatalError = true;
+            }
+        }
+    }
+
+    static void SpliceMergeVertices(GLUtessellatorImpl tess, GLUhalfEdge e1,
+                                    GLUhalfEdge e2)
+/*
+ * Two vertices with idential coordinates are combined into one.
+ * e1.Org is kept, while e2.Org is discarded.
+ */ {
+        Object[] data = new Object[4];
+        float[] weights = new float[]{0.5f, 0.5f, 0.0f, 0.0f};
+
+        data[0] = e1.Org.data;
+        data[1] = e2.Org.data;
+        CallCombine(tess, e1.Org, data, weights, false);
+        if (!Mesh.__gl_meshSplice(e1, e2)) throw new RuntimeException();
+    }
+
+    static void VertexWeights(GLUvertex isect, GLUvertex org, GLUvertex dst,
+                              float[] weights)
+/*
+ * Find some weights which describe how the intersection vertex is
+ * a linear combination of "org" and "dest".  Each of the two edges
+ * which generated "isect" is allocated 50% of the weight; each edge
+ * splits the weight between its org and dst according to the
+ * relative distance to "isect".
+ */ {
+        double t1 = Geom.VertL1dist(org, isect);
+        double t2 = Geom.VertL1dist(dst, isect);
+
+        weights[0] = (float) (0.5 * t2 / (t1 + t2));
+        weights[1] = (float) (0.5 * t1 / (t1 + t2));
+        isect.coords[0] += weights[0] * org.coords[0] + weights[1] * dst.coords[0];
+        isect.coords[1] += weights[0] * org.coords[1] + weights[1] * dst.coords[1];
+        isect.coords[2] += weights[0] * org.coords[2] + weights[1] * dst.coords[2];
+    }
+
+
+    static void GetIntersectData(GLUtessellatorImpl tess, GLUvertex isect,
+                                 GLUvertex orgUp, GLUvertex dstUp,
+                                 GLUvertex orgLo, GLUvertex dstLo)
+/*
+ * We've computed a new intersection point, now we need a "data" pointer
+ * from the user so that we can refer to this new vertex in the
+ * rendering callbacks.
+ */ {
+        Object[] data = new Object[4];
+        float[] weights = new float[4];
+        float[] weights1 = new float[2];
+        float[] weights2 = new float[2];
+
+        data[0] = orgUp.data;
+        data[1] = dstUp.data;
+        data[2] = orgLo.data;
+        data[3] = dstLo.data;
+
+        isect.coords[0] = isect.coords[1] = isect.coords[2] = 0;
+        VertexWeights(isect, orgUp, dstUp, weights1);
+        VertexWeights(isect, orgLo, dstLo, weights2);
+        System.arraycopy(weights1, 0, weights, 0, 2);
+        System.arraycopy(weights2, 0, weights, 2, 2);
+
+        CallCombine(tess, isect, data, weights, true);
+    }
+
+    static boolean CheckForRightSplice(GLUtessellatorImpl tess, ActiveRegion regUp)
+/*
+ * Check the upper and lower edge of "regUp", to make sure that the
+ * eUp.Org is above eLo, or eLo.Org is below eUp (depending on which
+ * origin is leftmost).
+ *
+ * The main purpose is to splice right-going edges with the same
+ * dest vertex and nearly identical slopes (ie. we can't distinguish
+ * the slopes numerically).  However the splicing can also help us
+ * to recover from numerical errors.  For example, suppose at one
+ * point we checked eUp and eLo, and decided that eUp.Org is barely
+ * above eLo.  Then later, we split eLo into two edges (eg. from
+ * a splice operation like this one).  This can change the result of
+ * our test so that now eUp.Org is incident to eLo, or barely below it.
+ * We must correct this condition to maintain the dictionary invariants.
+ *
+ * One possibility is to check these edges for intersection again
+ * (ie. CheckForIntersect).  This is what we do if possible.  However
+ * CheckForIntersect requires that tess.event lies between eUp and eLo,
+ * so that it has something to fall back on when the intersection
+ * calculation gives us an unusable answer.  So, for those cases where
+ * we can't check for intersection, this routine fixes the problem
+ * by just splicing the offending vertex into the other edge.
+ * This is a guaranteed solution, no matter how degenerate things get.
+ * Basically this is a combinatorial solution to a numerical problem.
+ */ {
+        ActiveRegion regLo = RegionBelow(regUp);
+        GLUhalfEdge eUp = regUp.eUp;
+        GLUhalfEdge eLo = regLo.eUp;
+
+        if (Geom.VertLeq(eUp.Org, eLo.Org)) {
+            if (Geom.EdgeSign(eLo.Sym.Org, eUp.Org, eLo.Org) > 0) return false;
+
+            /* eUp.Org appears to be below eLo */
+            if (!Geom.VertEq(eUp.Org, eLo.Org)) {
+                /* Splice eUp.Org into eLo */
+                if (Mesh.__gl_meshSplitEdge(eLo.Sym) == null) throw new RuntimeException();
+                if (!Mesh.__gl_meshSplice(eUp, eLo.Sym.Lnext)) throw new RuntimeException();
+                regUp.dirty = regLo.dirty = true;
+
+            } else if (eUp.Org != eLo.Org) {
+                /* merge the two vertices, discarding eUp.Org */
+                tess.pq.pqDelete(eUp.Org.pqHandle); /* __gl_pqSortDelete */
+                SpliceMergeVertices(tess, eLo.Sym.Lnext, eUp);
+            }
+        } else {
+            if (Geom.EdgeSign(eUp.Sym.Org, eLo.Org, eUp.Org) < 0) return false;
+
+            /* eLo.Org appears to be above eUp, so splice eLo.Org into eUp */
+            RegionAbove(regUp).dirty = regUp.dirty = true;
+            if (Mesh.__gl_meshSplitEdge(eUp.Sym) == null) throw new RuntimeException();
+            if (!Mesh.__gl_meshSplice(eLo.Sym.Lnext, eUp)) throw new RuntimeException();
+        }
+        return true;
+    }
+
+    static boolean CheckForLeftSplice(GLUtessellatorImpl tess, ActiveRegion regUp)
+/*
+ * Check the upper and lower edge of "regUp", to make sure that the
+ * eUp.Sym.Org is above eLo, or eLo.Sym.Org is below eUp (depending on which
+ * destination is rightmost).
+ *
+ * Theoretically, this should always be true.  However, splitting an edge
+ * into two pieces can change the results of previous tests.  For example,
+ * suppose at one point we checked eUp and eLo, and decided that eUp.Sym.Org
+ * is barely above eLo.  Then later, we split eLo into two edges (eg. from
+ * a splice operation like this one).  This can change the result of
+ * the test so that now eUp.Sym.Org is incident to eLo, or barely below it.
+ * We must correct this condition to maintain the dictionary invariants
+ * (otherwise new edges might get inserted in the wrong place in the
+ * dictionary, and bad stuff will happen).
+ *
+ * We fix the problem by just splicing the offending vertex into the
+ * other edge.
+ */ {
+        ActiveRegion regLo = RegionBelow(regUp);
+        GLUhalfEdge eUp = regUp.eUp;
+        GLUhalfEdge eLo = regLo.eUp;
+        GLUhalfEdge e;
+
+        assert (!Geom.VertEq(eUp.Sym.Org, eLo.Sym.Org));
+
+        if (Geom.VertLeq(eUp.Sym.Org, eLo.Sym.Org)) {
+            if (Geom.EdgeSign(eUp.Sym.Org, eLo.Sym.Org, eUp.Org) < 0) return false;
+
+            /* eLo.Sym.Org is above eUp, so splice eLo.Sym.Org into eUp */
+            RegionAbove(regUp).dirty = regUp.dirty = true;
+            e = Mesh.__gl_meshSplitEdge(eUp);
+            if (e == null) throw new RuntimeException();
+            if (!Mesh.__gl_meshSplice(eLo.Sym, e)) throw new RuntimeException();
+            e.Lface.inside = regUp.inside;
+        } else {
+            if (Geom.EdgeSign(eLo.Sym.Org, eUp.Sym.Org, eLo.Org) > 0) return false;
+
+            /* eUp.Sym.Org is below eLo, so splice eUp.Sym.Org into eLo */
+            regUp.dirty = regLo.dirty = true;
+            e = Mesh.__gl_meshSplitEdge(eLo);
+            if (e == null) throw new RuntimeException();
+            if (!Mesh.__gl_meshSplice(eUp.Lnext, eLo.Sym)) throw new RuntimeException();
+            e.Sym.Lface.inside = regUp.inside;
+        }
+        return true;
+    }
+
+
+    static boolean CheckForIntersect(GLUtessellatorImpl tess, ActiveRegion regUp)
+/*
+ * Check the upper and lower edges of the given region to see if
+ * they intersect.  If so, create the intersection and add it
+ * to the data structures.
+ *
+ * Returns true if adding the new intersection resulted in a recursive
+ * call to AddRightEdges(); in this case all "dirty" regions have been
+ * checked for intersections, and possibly regUp has been deleted.
+ */ {
+        ActiveRegion regLo = RegionBelow(regUp);
+        GLUhalfEdge eUp = regUp.eUp;
+        GLUhalfEdge eLo = regLo.eUp;
+        GLUvertex orgUp = eUp.Org;
+        GLUvertex orgLo = eLo.Org;
+        GLUvertex dstUp = eUp.Sym.Org;
+        GLUvertex dstLo = eLo.Sym.Org;
+        double tMinUp, tMaxLo;
+        GLUvertex isect = new GLUvertex();
+        GLUvertex orgMin;
+        GLUhalfEdge e;
+
+        assert (!Geom.VertEq(dstLo, dstUp));
+        assert (Geom.EdgeSign(dstUp, tess.event, orgUp) <= 0);
+        assert (Geom.EdgeSign(dstLo, tess.event, orgLo) >= 0);
+        assert (orgUp != tess.event && orgLo != tess.event);
+        assert (!regUp.fixUpperEdge && !regLo.fixUpperEdge);
+
+        if (orgUp == orgLo) return false;	/* right endpoints are the same */
+
+        tMinUp = Math.min(orgUp.t, dstUp.t);
+        tMaxLo = Math.max(orgLo.t, dstLo.t);
+        if (tMinUp > tMaxLo) return false;	/* t ranges do not overlap */
+
+        if (Geom.VertLeq(orgUp, orgLo)) {
+            if (Geom.EdgeSign(dstLo, orgUp, orgLo) > 0) return false;
+        } else {
+            if (Geom.EdgeSign(dstUp, orgLo, orgUp) < 0) return false;
+        }
+
+        /* At this point the edges intersect, at least marginally */
+        DebugEvent(tess);
+
+        Geom.EdgeIntersect(dstUp, orgUp, dstLo, orgLo, isect);
+        /* The following properties are guaranteed: */
+        assert (Math.min(orgUp.t, dstUp.t) <= isect.t);
+        assert (isect.t <= Math.max(orgLo.t, dstLo.t));
+        assert (Math.min(dstLo.s, dstUp.s) <= isect.s);
+        assert (isect.s <= Math.max(orgLo.s, orgUp.s));
+
+        if (Geom.VertLeq(isect, tess.event)) {
+            /* The intersection point lies slightly to the left of the sweep line,
+             * so move it until it''s slightly to the right of the sweep line.
+             * (If we had perfect numerical precision, this would never happen
+             * in the first place).  The easiest and safest thing to do is
+             * replace the intersection by tess.event.
+             */
+            isect.s = tess.event.s;
+            isect.t = tess.event.t;
+        }
+        /* Similarly, if the computed intersection lies to the right of the
+         * rightmost origin (which should rarely happen), it can cause
+         * unbelievable inefficiency on sufficiently degenerate inputs.
+         * (If you have the test program, try running test54.d with the
+         * "X zoom" option turned on).
+         */
+        orgMin = Geom.VertLeq(orgUp, orgLo) ? orgUp : orgLo;
+        if (Geom.VertLeq(orgMin, isect)) {
+            isect.s = orgMin.s;
+            isect.t = orgMin.t;
+        }
+
+        if (Geom.VertEq(isect, orgUp) || Geom.VertEq(isect, orgLo)) {
+            /* Easy case -- intersection at one of the right endpoints */
+            CheckForRightSplice(tess, regUp);
+            return false;
+        }
+
+        if ((!Geom.VertEq(dstUp, tess.event)
+                && Geom.EdgeSign(dstUp, tess.event, isect) >= 0)
+                || (!Geom.VertEq(dstLo, tess.event)
+                && Geom.EdgeSign(dstLo, tess.event, isect) <= 0)) {
+            /* Very unusual -- the new upper or lower edge would pass on the
+             * wrong side of the sweep event, or through it.  This can happen
+             * due to very small numerical errors in the intersection calculation.
+             */
+            if (dstLo == tess.event) {
+                /* Splice dstLo into eUp, and process the new region(s) */
+                if (Mesh.__gl_meshSplitEdge(eUp.Sym) == null) throw new RuntimeException();
+                if (!Mesh.__gl_meshSplice(eLo.Sym, eUp)) throw new RuntimeException();
+                regUp = TopLeftRegion(regUp);
+                if (regUp == null) throw new RuntimeException();
+                eUp = RegionBelow(regUp).eUp;
+                FinishLeftRegions(tess, RegionBelow(regUp), regLo);
+                AddRightEdges(tess, regUp, eUp.Sym.Lnext, eUp, eUp, true);
+                return true;
+            }
+            if (dstUp == tess.event) {
+                /* Splice dstUp into eLo, and process the new region(s) */
+                if (Mesh.__gl_meshSplitEdge(eLo.Sym) == null) throw new RuntimeException();
+                if (!Mesh.__gl_meshSplice(eUp.Lnext, eLo.Sym.Lnext)) throw new RuntimeException();
+                regLo = regUp;
+                regUp = TopRightRegion(regUp);
+                e = RegionBelow(regUp).eUp.Sym.Onext;
+                regLo.eUp = eLo.Sym.Lnext;
+                eLo = FinishLeftRegions(tess, regLo, null);
+                AddRightEdges(tess, regUp, eLo.Onext, eUp.Sym.Onext, e, true);
+                return true;
+            }
+            /* Special case: called from ConnectRightVertex.  If either
+             * edge passes on the wrong side of tess.event, split it
+             * (and wait for ConnectRightVertex to splice it appropriately).
+             */
+            if (Geom.EdgeSign(dstUp, tess.event, isect) >= 0) {
+                RegionAbove(regUp).dirty = regUp.dirty = true;
+                if (Mesh.__gl_meshSplitEdge(eUp.Sym) == null) throw new RuntimeException();
+                eUp.Org.s = tess.event.s;
+                eUp.Org.t = tess.event.t;
+            }
+            if (Geom.EdgeSign(dstLo, tess.event, isect) <= 0) {
+                regUp.dirty = regLo.dirty = true;
+                if (Mesh.__gl_meshSplitEdge(eLo.Sym) == null) throw new RuntimeException();
+                eLo.Org.s = tess.event.s;
+                eLo.Org.t = tess.event.t;
+            }
+            /* leave the rest for ConnectRightVertex */
+            return false;
+        }
+
+        /* General case -- split both edges, splice into new vertex.
+         * When we do the splice operation, the order of the arguments is
+         * arbitrary as far as correctness goes.  However, when the operation
+         * creates a new face, the work done is proportional to the size of
+         * the new face.  We expect the faces in the processed part of
+         * the mesh (ie. eUp.Lface) to be smaller than the faces in the
+         * unprocessed original contours (which will be eLo.Sym.Lnext.Lface).
+         */
+        if (Mesh.__gl_meshSplitEdge(eUp.Sym) == null) throw new RuntimeException();
+        if (Mesh.__gl_meshSplitEdge(eLo.Sym) == null) throw new RuntimeException();
+        if (!Mesh.__gl_meshSplice(eLo.Sym.Lnext, eUp)) throw new RuntimeException();
+        eUp.Org.s = isect.s;
+        eUp.Org.t = isect.t;
+        eUp.Org.pqHandle = tess.pq.pqInsert(eUp.Org); /* __gl_pqSortInsert */
+        if (eUp.Org.pqHandle == Long.MAX_VALUE) {
+            tess.pq.pqDeletePriorityQ();	/* __gl_pqSortDeletePriorityQ */
+            tess.pq = null;
+            throw new RuntimeException();
+        }
+        GetIntersectData(tess, eUp.Org, orgUp, dstUp, orgLo, dstLo);
+        RegionAbove(regUp).dirty = regUp.dirty = regLo.dirty = true;
+        return false;
+    }
+
+    static void WalkDirtyRegions(GLUtessellatorImpl tess, ActiveRegion regUp)
+/*
+ * When the upper or lower edge of any region changes, the region is
+ * marked "dirty".  This routine walks through all the dirty regions
+ * and makes sure that the dictionary invariants are satisfied
+ * (see the comments at the beginning of this file).  Of course
+ * new dirty regions can be created as we make changes to restore
+ * the invariants.
+ */ {
+        ActiveRegion regLo = RegionBelow(regUp);
+        GLUhalfEdge eUp, eLo;
+
+        for (; ;) {
+            /* Find the lowest dirty region (we walk from the bottom up). */
+            while (regLo.dirty) {
+                regUp = regLo;
+                regLo = RegionBelow(regLo);
+            }
+            if (!regUp.dirty) {
+                regLo = regUp;
+                regUp = RegionAbove(regUp);
+                if (regUp == null || !regUp.dirty) {
+                    /* We've walked all the dirty regions */
+                    return;
+                }
+            }
+            regUp.dirty = false;
+            eUp = regUp.eUp;
+            eLo = regLo.eUp;
+
+            if (eUp.Sym.Org != eLo.Sym.Org) {
+                /* Check that the edge ordering is obeyed at the Dst vertices. */
+                if (CheckForLeftSplice(tess, regUp)) {
+
+                    /* If the upper or lower edge was marked fixUpperEdge, then
+                     * we no longer need it (since these edges are needed only for
+                     * vertices which otherwise have no right-going edges).
+                     */
+                    if (regLo.fixUpperEdge) {
+                        DeleteRegion(tess, regLo);
+                        if (!Mesh.__gl_meshDelete(eLo)) throw new RuntimeException();
+                        regLo = RegionBelow(regUp);
+                        eLo = regLo.eUp;
+                    } else if (regUp.fixUpperEdge) {
+                        DeleteRegion(tess, regUp);
+                        if (!Mesh.__gl_meshDelete(eUp)) throw new RuntimeException();
+                        regUp = RegionAbove(regLo);
+                        eUp = regUp.eUp;
+                    }
+                }
+            }
+            if (eUp.Org != eLo.Org) {
+                if (eUp.Sym.Org != eLo.Sym.Org
+                        && !regUp.fixUpperEdge && !regLo.fixUpperEdge
+                        && (eUp.Sym.Org == tess.event || eLo.Sym.Org == tess.event)) {
+                    /* When all else fails in CheckForIntersect(), it uses tess.event
+                     * as the intersection location.  To make this possible, it requires
+                     * that tess.event lie between the upper and lower edges, and also
+                     * that neither of these is marked fixUpperEdge (since in the worst
+                     * case it might splice one of these edges into tess.event, and
+                     * violate the invariant that fixable edges are the only right-going
+                     * edge from their associated vertex).
+                         */
+                    if (CheckForIntersect(tess, regUp)) {
+                        /* WalkDirtyRegions() was called recursively; we're done */
+                        return;
+                    }
+                } else {
+                    /* Even though we can't use CheckForIntersect(), the Org vertices
+                     * may violate the dictionary edge ordering.  Check and correct this.
+                     */
+                    CheckForRightSplice(tess, regUp);
+                }
+            }
+            if (eUp.Org == eLo.Org && eUp.Sym.Org == eLo.Sym.Org) {
+                /* A degenerate loop consisting of only two edges -- delete it. */
+                AddWinding(eLo, eUp);
+                DeleteRegion(tess, regUp);
+                if (!Mesh.__gl_meshDelete(eUp)) throw new RuntimeException();
+                regUp = RegionAbove(regLo);
+            }
+        }
+    }
+
+
+    static void ConnectRightVertex(GLUtessellatorImpl tess, ActiveRegion regUp,
+                                   GLUhalfEdge eBottomLeft)
+/*
+ * Purpose: connect a "right" vertex vEvent (one where all edges go left)
+ * to the unprocessed portion of the mesh.  Since there are no right-going
+ * edges, two regions (one above vEvent and one below) are being merged
+ * into one.  "regUp" is the upper of these two regions.
+ *
+ * There are two reasons for doing this (adding a right-going edge):
+ *  - if the two regions being merged are "inside", we must add an edge
+ *    to keep them separated (the combined region would not be monotone).
+ *  - in any case, we must leave some record of vEvent in the dictionary,
+ *    so that we can merge vEvent with features that we have not seen yet.
+ *    For example, maybe there is a vertical edge which passes just to
+ *    the right of vEvent; we would like to splice vEvent into this edge.
+ *
+ * However, we don't want to connect vEvent to just any vertex.  We don''t
+ * want the new edge to cross any other edges; otherwise we will create
+ * intersection vertices even when the input data had no self-intersections.
+ * (This is a bad thing; if the user's input data has no intersections,
+ * we don't want to generate any false intersections ourselves.)
+ *
+ * Our eventual goal is to connect vEvent to the leftmost unprocessed
+ * vertex of the combined region (the union of regUp and regLo).
+ * But because of unseen vertices with all right-going edges, and also
+ * new vertices which may be created by edge intersections, we don''t
+ * know where that leftmost unprocessed vertex is.  In the meantime, we
+ * connect vEvent to the closest vertex of either chain, and mark the region
+ * as "fixUpperEdge".  This flag says to delete and reconnect this edge
+ * to the next processed vertex on the boundary of the combined region.
+ * Quite possibly the vertex we connected to will turn out to be the
+ * closest one, in which case we won''t need to make any changes.
+ */ {
+        GLUhalfEdge eNew;
+        GLUhalfEdge eTopLeft = eBottomLeft.Onext;
+        ActiveRegion regLo = RegionBelow(regUp);
+        GLUhalfEdge eUp = regUp.eUp;
+        GLUhalfEdge eLo = regLo.eUp;
+        boolean degenerate = false;
+
+        if (eUp.Sym.Org != eLo.Sym.Org) {
+            CheckForIntersect(tess, regUp);
+        }
+
+        /* Possible new degeneracies: upper or lower edge of regUp may pass
+         * through vEvent, or may coincide with new intersection vertex
+         */
+        if (Geom.VertEq(eUp.Org, tess.event)) {
+            if (!Mesh.__gl_meshSplice(eTopLeft.Sym.Lnext, eUp)) throw new RuntimeException();
+            regUp = TopLeftRegion(regUp);
+            if (regUp == null) throw new RuntimeException();
+            eTopLeft = RegionBelow(regUp).eUp;
+            FinishLeftRegions(tess, RegionBelow(regUp), regLo);
+            degenerate = true;
+        }
+        if (Geom.VertEq(eLo.Org, tess.event)) {
+            if (!Mesh.__gl_meshSplice(eBottomLeft, eLo.Sym.Lnext)) throw new RuntimeException();
+            eBottomLeft = FinishLeftRegions(tess, regLo, null);
+            degenerate = true;
+        }
+        if (degenerate) {
+            AddRightEdges(tess, regUp, eBottomLeft.Onext, eTopLeft, eTopLeft, true);
+            return;
+        }
+
+        /* Non-degenerate situation -- need to add a temporary, fixable edge.
+         * Connect to the closer of eLo.Org, eUp.Org.
+         */
+        if (Geom.VertLeq(eLo.Org, eUp.Org)) {
+            eNew = eLo.Sym.Lnext;
+        } else {
+            eNew = eUp;
+        }
+        eNew = Mesh.__gl_meshConnect(eBottomLeft.Onext.Sym, eNew);
+        if (eNew == null) throw new RuntimeException();
+
+        /* Prevent cleanup, otherwise eNew might disappear before we've even
+         * had a chance to mark it as a temporary edge.
+         */
+        AddRightEdges(tess, regUp, eNew, eNew.Onext, eNew.Onext, false);
+        eNew.Sym.activeRegion.fixUpperEdge = true;
+        WalkDirtyRegions(tess, regUp);
+    }
+
+/* Because vertices at exactly the same location are merged together
+ * before we process the sweep event, some degenerate cases can't occur.
+ * However if someone eventually makes the modifications required to
+ * merge features which are close together, the cases below marked
+ * TOLERANCE_NONZERO will be useful.  They were debugged before the
+ * code to merge identical vertices in the main loop was added.
+ */
+    private static final boolean TOLERANCE_NONZERO = false;
+
+    static void ConnectLeftDegenerate(GLUtessellatorImpl tess,
+                                      ActiveRegion regUp, GLUvertex vEvent)
+/*
+ * The event vertex lies exacty on an already-processed edge or vertex.
+ * Adding the new vertex involves splicing it into the already-processed
+ * part of the mesh.
+ */ {
+        GLUhalfEdge e, eTopLeft, eTopRight, eLast;
+        ActiveRegion reg;
+
+        e = regUp.eUp;
+        if (Geom.VertEq(e.Org, vEvent)) {
+            /* e.Org is an unprocessed vertex - just combine them, and wait
+             * for e.Org to be pulled from the queue
+             */
+            assert (TOLERANCE_NONZERO);
+            SpliceMergeVertices(tess, e, vEvent.anEdge);
+            return;
+        }
+
+        if (!Geom.VertEq(e.Sym.Org, vEvent)) {
+            /* General case -- splice vEvent into edge e which passes through it */
+            if (Mesh.__gl_meshSplitEdge(e.Sym) == null) throw new RuntimeException();
+            if (regUp.fixUpperEdge) {
+                /* This edge was fixable -- delete unused portion of original edge */
+                if (!Mesh.__gl_meshDelete(e.Onext)) throw new RuntimeException();
+                regUp.fixUpperEdge = false;
+            }
+            if (!Mesh.__gl_meshSplice(vEvent.anEdge, e)) throw new RuntimeException();
+            SweepEvent(tess, vEvent);	/* recurse */
+            return;
+        }
+
+        /* vEvent coincides with e.Sym.Org, which has already been processed.
+         * Splice in the additional right-going edges.
+         */
+        assert (TOLERANCE_NONZERO);
+        regUp = TopRightRegion(regUp);
+        reg = RegionBelow(regUp);
+        eTopRight = reg.eUp.Sym;
+        eTopLeft = eLast = eTopRight.Onext;
+        if (reg.fixUpperEdge) {
+            /* Here e.Sym.Org has only a single fixable edge going right.
+             * We can delete it since now we have some real right-going edges.
+             */
+            assert (eTopLeft != eTopRight);   /* there are some left edges too */
+            DeleteRegion(tess, reg);
+            if (!Mesh.__gl_meshDelete(eTopRight)) throw new RuntimeException();
+            eTopRight = eTopLeft.Sym.Lnext;
+        }
+        if (!Mesh.__gl_meshSplice(vEvent.anEdge, eTopRight)) throw new RuntimeException();
+        if (!Geom.EdgeGoesLeft(eTopLeft)) {
+            /* e.Sym.Org had no left-going edges -- indicate this to AddRightEdges() */
+            eTopLeft = null;
+        }
+        AddRightEdges(tess, regUp, eTopRight.Onext, eLast, eTopLeft, true);
+    }
+
+
+    static void ConnectLeftVertex(GLUtessellatorImpl tess, GLUvertex vEvent)
+/*
+ * Purpose: connect a "left" vertex (one where both edges go right)
+ * to the processed portion of the mesh.  Let R be the active region
+ * containing vEvent, and let U and L be the upper and lower edge
+ * chains of R.  There are two possibilities:
+ *
+ * - the normal case: split R into two regions, by connecting vEvent to
+ *   the rightmost vertex of U or L lying to the left of the sweep line
+ *
+ * - the degenerate case: if vEvent is close enough to U or L, we
+ *   merge vEvent into that edge chain.  The subcases are:
+ *	- merging with the rightmost vertex of U or L
+ *	- merging with the active edge of U or L
+ *	- merging with an already-processed portion of U or L
+ */ {
+        ActiveRegion regUp, regLo, reg;
+        GLUhalfEdge eUp, eLo, eNew;
+        ActiveRegion tmp = new ActiveRegion();
+
+        /* assert ( vEvent.anEdge.Onext.Onext == vEvent.anEdge ); */
+
+        /* Get a pointer to the active region containing vEvent */
+        tmp.eUp = vEvent.anEdge.Sym;
+        /* __GL_DICTLISTKEY */ /* __gl_dictListSearch */
+        regUp = (ActiveRegion) Dict.dictKey(Dict.dictSearch(tess.dict, tmp));
+        regLo = RegionBelow(regUp);
+        eUp = regUp.eUp;
+        eLo = regLo.eUp;
+
+        /* Try merging with U or L first */
+        if (Geom.EdgeSign(eUp.Sym.Org, vEvent, eUp.Org) == 0) {
+            ConnectLeftDegenerate(tess, regUp, vEvent);
+            return;
+        }
+
+        /* Connect vEvent to rightmost processed vertex of either chain.
+         * e.Sym.Org is the vertex that we will connect to vEvent.
+         */
+        reg = Geom.VertLeq(eLo.Sym.Org, eUp.Sym.Org) ? regUp : regLo;
+
+        if (regUp.inside || reg.fixUpperEdge) {
+            if (reg == regUp) {
+                eNew = Mesh.__gl_meshConnect(vEvent.anEdge.Sym, eUp.Lnext);
+                if (eNew == null) throw new RuntimeException();
+            } else {
+                GLUhalfEdge tempHalfEdge = Mesh.__gl_meshConnect(eLo.Sym.Onext.Sym, vEvent.anEdge);
+                if (tempHalfEdge == null) throw new RuntimeException();
+
+                eNew = tempHalfEdge.Sym;
+            }
+            if (reg.fixUpperEdge) {
+                if (!FixUpperEdge(reg, eNew)) throw new RuntimeException();
+            } else {
+                ComputeWinding(tess, AddRegionBelow(tess, regUp, eNew));
+            }
+            SweepEvent(tess, vEvent);
+        } else {
+            /* The new vertex is in a region which does not belong to the polygon.
+             * We don''t need to connect this vertex to the rest of the mesh.
+             */
+            AddRightEdges(tess, regUp, vEvent.anEdge, vEvent.anEdge, null, true);
+        }
+    }
+
+
+    static void SweepEvent(GLUtessellatorImpl tess, GLUvertex vEvent)
+/*
+ * Does everything necessary when the sweep line crosses a vertex.
+ * Updates the mesh and the edge dictionary.
+ */ {
+        ActiveRegion regUp, reg;
+        GLUhalfEdge e, eTopLeft, eBottomLeft;
+
+        tess.event = vEvent;		/* for access in EdgeLeq() */
+        DebugEvent(tess);
+
+        /* Check if this vertex is the right endpoint of an edge that is
+         * already in the dictionary.  In this case we don't need to waste
+         * time searching for the location to insert new edges.
+         */
+        e = vEvent.anEdge;
+        while (e.activeRegion == null) {
+            e = e.Onext;
+            if (e == vEvent.anEdge) {
+                /* All edges go right -- not incident to any processed edges */
+                ConnectLeftVertex(tess, vEvent);
+                return;
+            }
+        }
+
+        /* Processing consists of two phases: first we "finish" all the
+         * active regions where both the upper and lower edges terminate
+         * at vEvent (ie. vEvent is closing off these regions).
+         * We mark these faces "inside" or "outside" the polygon according
+         * to their winding number, and delete the edges from the dictionary.
+         * This takes care of all the left-going edges from vEvent.
+         */
+        regUp = TopLeftRegion(e.activeRegion);
+        if (regUp == null) throw new RuntimeException();
+        reg = RegionBelow(regUp);
+        eTopLeft = reg.eUp;
+        eBottomLeft = FinishLeftRegions(tess, reg, null);
+
+        /* Next we process all the right-going edges from vEvent.  This
+         * involves adding the edges to the dictionary, and creating the
+         * associated "active regions" which record information about the
+         * regions between adjacent dictionary edges.
+         */
+        if (eBottomLeft.Onext == eTopLeft) {
+            /* No right-going edges -- add a temporary "fixable" edge */
+            ConnectRightVertex(tess, regUp, eBottomLeft);
+        } else {
+            AddRightEdges(tess, regUp, eBottomLeft.Onext, eTopLeft, eTopLeft, true);
+        }
+    }
+
+
+/* Make the sentinel coordinates big enough that they will never be
+ * merged with real input features.  (Even with the largest possible
+ * input contour and the maximum tolerance of 1.0, no merging will be
+ * done with coordinates larger than 3 * GLU_TESS_MAX_COORD).
+ */
+    private static final double SENTINEL_COORD = (4.0 * GLU.GLU_TESS_MAX_COORD);
+
+    static void AddSentinel(GLUtessellatorImpl tess, double t)
+/*
+ * We add two sentinel edges above and below all other edges,
+ * to avoid special cases at the top and bottom.
+ */ {
+        GLUhalfEdge e;
+        ActiveRegion reg = new ActiveRegion();
+        if (reg == null) throw new RuntimeException();
+
+        e = Mesh.__gl_meshMakeEdge(tess.mesh);
+        if (e == null) throw new RuntimeException();
+
+        e.Org.s = SENTINEL_COORD;
+        e.Org.t = t;
+        e.Sym.Org.s = -SENTINEL_COORD;
+        e.Sym.Org.t = t;
+        tess.event = e.Sym.Org;		/* initialize it */
+
+        reg.eUp = e;
+        reg.windingNumber = 0;
+        reg.inside = false;
+        reg.fixUpperEdge = false;
+        reg.sentinel = true;
+        reg.dirty = false;
+        reg.nodeUp = Dict.dictInsert(tess.dict, reg); /* __gl_dictListInsertBefore */
+        if (reg.nodeUp == null) throw new RuntimeException();
+    }
+
+
+    static void InitEdgeDict(final GLUtessellatorImpl tess)
+/*
+ * We maintain an ordering of edge intersections with the sweep line.
+ * This order is maintained in a dynamic dictionary.
+ */ {
+        /* __gl_dictListNewDict */
+        tess.dict = Dict.dictNewDict(tess, new Dict.DictLeq() {
+            public boolean leq(Object frame, Object key1, Object key2) {
+                return EdgeLeq(tess, (ActiveRegion) key1, (ActiveRegion) key2);
+            }
+        });
+        if (tess.dict == null) throw new RuntimeException();
+
+        AddSentinel(tess, -SENTINEL_COORD);
+        AddSentinel(tess, SENTINEL_COORD);
+    }
+
+
+    static void DoneEdgeDict(GLUtessellatorImpl tess) {
+        ActiveRegion reg;
+        int fixedEdges = 0;
+
+        /* __GL_DICTLISTKEY */ /* __GL_DICTLISTMIN */
+        while ((reg = (ActiveRegion) Dict.dictKey(Dict.dictMin(tess.dict))) != null) {
+            /*
+             * At the end of all processing, the dictionary should contain
+             * only the two sentinel edges, plus at most one "fixable" edge
+             * created by ConnectRightVertex().
+             */
+            if (!reg.sentinel) {
+                assert (reg.fixUpperEdge);
+                assert (++fixedEdges == 1);
+            }
+            assert (reg.windingNumber == 0);
+            DeleteRegion(tess, reg);
+/*    __gl_meshDelete( reg.eUp );*/
+        }
+        Dict.dictDeleteDict(tess.dict);	/* __gl_dictListDeleteDict */
+    }
+
+
+    static void RemoveDegenerateEdges(GLUtessellatorImpl tess)
+/*
+ * Remove zero-length edges, and contours with fewer than 3 vertices.
+ */ {
+        GLUhalfEdge e, eNext, eLnext;
+        GLUhalfEdge eHead = tess.mesh.eHead;
+
+        /*LINTED*/
+        for (e = eHead.next; e != eHead; e = eNext) {
+            eNext = e.next;
+            eLnext = e.Lnext;
+
+            if (Geom.VertEq(e.Org, e.Sym.Org) && e.Lnext.Lnext != e) {
+                /* Zero-length edge, contour has at least 3 edges */
+
+                SpliceMergeVertices(tess, eLnext, e);	/* deletes e.Org */
+                if (!Mesh.__gl_meshDelete(e)) throw new RuntimeException(); /* e is a self-loop */
+                e = eLnext;
+                eLnext = e.Lnext;
+            }
+            if (eLnext.Lnext == e) {
+                /* Degenerate contour (one or two edges) */
+
+                if (eLnext != e) {
+                    if (eLnext == eNext || eLnext == eNext.Sym) {
+                        eNext = eNext.next;
+                    }
+                    if (!Mesh.__gl_meshDelete(eLnext)) throw new RuntimeException();
+                }
+                if (e == eNext || e == eNext.Sym) {
+                    eNext = eNext.next;
+                }
+                if (!Mesh.__gl_meshDelete(e)) throw new RuntimeException();
+            }
+        }
+    }
+
+    static boolean InitPriorityQ(GLUtessellatorImpl tess)
+/*
+ * Insert all vertices into the priority queue which determines the
+ * order in which vertices cross the sweep line.
+ */ {
+        PriorityQ pq;
+        GLUvertex v, vHead;
+
+        /* __gl_pqSortNewPriorityQ */
+        pq = tess.pq = PriorityQ.pqNewPriorityQ(new PriorityQ.Leq() {
+            public boolean leq(Object key1, Object key2) {
+                return Geom.VertLeq(((GLUvertex) key1), (GLUvertex) key2);
+            }
+        });
+        if (pq == null) return false;
+
+        vHead = tess.mesh.vHead;
+        for (v = vHead.next; v != vHead; v = v.next) {
+            v.pqHandle = pq.pqInsert(v); /* __gl_pqSortInsert */
+            if (v.pqHandle == Long.MAX_VALUE) break;
+        }
+        if (v != vHead || !pq.pqInit()) { /* __gl_pqSortInit */
+            tess.pq.pqDeletePriorityQ();	/* __gl_pqSortDeletePriorityQ */
+            tess.pq = null;
+            return false;
+        }
+
+        return true;
+    }
+
+
+    static void DonePriorityQ(GLUtessellatorImpl tess) {
+        tess.pq.pqDeletePriorityQ(); /* __gl_pqSortDeletePriorityQ */
+    }
+
+
+    static boolean RemoveDegenerateFaces(GLUmesh mesh)
+/*
+ * Delete any degenerate faces with only two edges.  WalkDirtyRegions()
+ * will catch almost all of these, but it won't catch degenerate faces
+ * produced by splice operations on already-processed edges.
+ * The two places this can happen are in FinishLeftRegions(), when
+ * we splice in a "temporary" edge produced by ConnectRightVertex(),
+ * and in CheckForLeftSplice(), where we splice already-processed
+ * edges to ensure that our dictionary invariants are not violated
+ * by numerical errors.
+ *
+ * In both these cases it is *very* dangerous to delete the offending
+ * edge at the time, since one of the routines further up the stack
+ * will sometimes be keeping a pointer to that edge.
+ */ {
+        GLUface f, fNext;
+        GLUhalfEdge e;
+
+        /*LINTED*/
+        for (f = mesh.fHead.next; f != mesh.fHead; f = fNext) {
+            fNext = f.next;
+            e = f.anEdge;
+            assert (e.Lnext != e);
+
+            if (e.Lnext.Lnext == e) {
+                /* A face with only two edges */
+                AddWinding(e.Onext, e);
+                if (!Mesh.__gl_meshDelete(e)) return false;
+            }
+        }
+        return true;
+    }
+
+    public static boolean __gl_computeInterior(GLUtessellatorImpl tess)
+/*
+ * __gl_computeInterior( tess ) computes the planar arrangement specified
+ * by the given contours, and further subdivides this arrangement
+ * into regions.  Each region is marked "inside" if it belongs
+ * to the polygon, according to the rule given by tess.windingRule.
+ * Each interior region is guaranteed be monotone.
+ */ {
+        GLUvertex v, vNext;
+
+        tess.fatalError = false;
+
+        /* Each vertex defines an event for our sweep line.  Start by inserting
+         * all the vertices in a priority queue.  Events are processed in
+         * lexicographic order, ie.
+         *
+         *	e1 < e2  iff  e1.x < e2.x || (e1.x == e2.x && e1.y < e2.y)
+         */
+        RemoveDegenerateEdges(tess);
+        if (!InitPriorityQ(tess)) return false; /* if error */
+        InitEdgeDict(tess);
+
+        /* __gl_pqSortExtractMin */
+        while ((v = (GLUvertex) tess.pq.pqExtractMin()) != null) {
+            for (; ;) {
+                vNext = (GLUvertex) tess.pq.pqMinimum(); /* __gl_pqSortMinimum */
+                if (vNext == null || !Geom.VertEq(vNext, v)) break;
+
+                /* Merge together all vertices at exactly the same location.
+                 * This is more efficient than processing them one at a time,
+                 * simplifies the code (see ConnectLeftDegenerate), and is also
+                 * important for correct handling of certain degenerate cases.
+                 * For example, suppose there are two identical edges A and B
+                 * that belong to different contours (so without this code they would
+                 * be processed by separate sweep events).  Suppose another edge C
+                 * crosses A and B from above.  When A is processed, we split it
+                 * at its intersection point with C.  However this also splits C,
+                 * so when we insert B we may compute a slightly different
+                 * intersection point.  This might leave two edges with a small
+                 * gap between them.  This kind of error is especially obvious
+                 * when using boundary extraction (GLU_TESS_BOUNDARY_ONLY).
+                 */
+                vNext = (GLUvertex) tess.pq.pqExtractMin(); /* __gl_pqSortExtractMin*/
+                SpliceMergeVertices(tess, v.anEdge, vNext.anEdge);
+            }
+            SweepEvent(tess, v);
+        }
+
+        /* Set tess.event for debugging purposes */
+        /* __GL_DICTLISTKEY */ /* __GL_DICTLISTMIN */
+        tess.event = ((ActiveRegion) Dict.dictKey(Dict.dictMin(tess.dict))).eUp.Org;
+        DebugEvent(tess);
+        DoneEdgeDict(tess);
+        DonePriorityQ(tess);
+
+        if (!RemoveDegenerateFaces(tess.mesh)) return false;
+        Mesh.__gl_meshCheckMesh(tess.mesh);
+
+        return true;
+    }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/TessMono.java b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/TessMono.java
new file mode 100644
index 000000000..fe0f7946c
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/TessMono.java
@@ -0,0 +1,241 @@
+/*
+* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
+* All rights reserved.
+*/
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** Author: Eric Veach, July 1994
+** Java Port: Pepijn Van Eeckhoudt, July 2003
+** Java Port: Nathan Parker Burg, August 2003
+*/
+package com.sun.opengl.impl.glu.tessellator;
+
+class TessMono {
+/* __gl_meshTessellateMonoRegion( face ) tessellates a monotone region
+ * (what else would it do??)  The region must consist of a single
+ * loop of half-edges (see mesh.h) oriented CCW.  "Monotone" in this
+ * case means that any vertical line intersects the interior of the
+ * region in a single interval.
+ *
+ * Tessellation consists of adding interior edges (actually pairs of
+ * half-edges), to split the region into non-overlapping triangles.
+ *
+ * The basic idea is explained in Preparata and Shamos (which I don''t
+ * have handy right now), although their implementation is more
+ * complicated than this one.  The are two edge chains, an upper chain
+ * and a lower chain.  We process all vertices from both chains in order,
+ * from right to left.
+ *
+ * The algorithm ensures that the following invariant holds after each
+ * vertex is processed: the untessellated region consists of two
+ * chains, where one chain (say the upper) is a single edge, and
+ * the other chain is concave.  The left vertex of the single edge
+ * is always to the left of all vertices in the concave chain.
+ *
+ * Each step consists of adding the rightmost unprocessed vertex to one
+ * of the two chains, and forming a fan of triangles from the rightmost
+ * of two chain endpoints.  Determining whether we can add each triangle
+ * to the fan is a simple orientation test.  By making the fan as large
+ * as possible, we restore the invariant (check it yourself).
+ */
+    static boolean __gl_meshTessellateMonoRegion(GLUface face, boolean avoidDegenerateTris) {
+        GLUhalfEdge up, lo;
+
+        /* All edges are oriented CCW around the boundary of the region.
+         * First, find the half-edge whose origin vertex is rightmost.
+         * Since the sweep goes from left to right, face->anEdge should
+         * be close to the edge we want.
+         */
+        up = face.anEdge;
+        assert (up.Lnext != up && up.Lnext.Lnext != up);
+
+        for (; Geom.VertLeq(up.Sym.Org, up.Org); up = up.Onext.Sym)
+            ;
+        for (; Geom.VertLeq(up.Org, up.Sym.Org); up = up.Lnext)
+            ;
+        lo = up.Onext.Sym;
+
+        boolean mustConnect = false; // hack for avoidDegenerateTris
+
+        while (up.Lnext != lo) {
+            if (avoidDegenerateTris && !mustConnect) {
+                // Skip over regions where several vertices are collinear,
+                // to try to avoid producing degenerate (zero-area) triangles
+                //
+                // The "mustConnect" flag is a hack to try to avoid
+                // skipping too large regions and causing incorrect
+                // triangulations. This entire modification is overall
+                // not robust and needs more work
+                if (Geom.EdgeCos(lo.Lnext.Org, lo.Org, lo.Lnext.Lnext.Org) <= -Geom.ONE_MINUS_EPSILON) {
+                    // Lines around lo
+                    do {
+                        lo = lo.Onext.Sym;
+                        mustConnect = true;
+                    } while (up.Lnext != lo &&
+                             Geom.EdgeCos(lo.Lnext.Org, lo.Org, lo.Lnext.Lnext.Org) <= -Geom.ONE_MINUS_EPSILON);
+                } else if (Geom.EdgeCos(up.Onext.Sym.Org, up.Org, up.Onext.Sym.Onext.Sym.Org) <= -Geom.ONE_MINUS_EPSILON) {
+                    // Lines around up
+                    do {
+                        up = up.Lnext;
+                        mustConnect = true;
+                    } while (up.Lnext != lo &&
+                             Geom.EdgeCos(up.Onext.Sym.Org, up.Org, up.Onext.Sym.Onext.Sym.Org) <= -Geom.ONE_MINUS_EPSILON);
+                }
+
+                if (up.Lnext == lo)
+                    break;
+            }
+
+            if (Geom.VertLeq(up.Sym.Org, lo.Org)) {
+                /* up.Sym.Org is on the left.  It is safe to form triangles from lo.Org.
+                 * The EdgeGoesLeft test guarantees progress even when some triangles
+                 * are CW, given that the upper and lower chains are truly monotone.
+                 */
+                while (lo.Lnext != up && (Geom.EdgeGoesLeft(lo.Lnext)
+                        || Geom.EdgeSign(lo.Org, lo.Sym.Org, lo.Lnext.Sym.Org) <= 0)) {
+                    GLUhalfEdge tempHalfEdge = Mesh.__gl_meshConnect(lo.Lnext, lo);
+                    mustConnect = false;
+                    if (tempHalfEdge == null) return false;
+                    lo = tempHalfEdge.Sym;
+                }
+                lo = lo.Onext.Sym;
+            } else {
+                /* lo.Org is on the left.  We can make CCW triangles from up.Sym.Org. */
+                while (lo.Lnext != up && (Geom.EdgeGoesRight(up.Onext.Sym)
+                        || Geom.EdgeSign(up.Sym.Org, up.Org, up.Onext.Sym.Org) >= 0)) {
+                    GLUhalfEdge tempHalfEdge = Mesh.__gl_meshConnect(up, up.Onext.Sym);
+                    mustConnect = false;
+                    if (tempHalfEdge == null) return false;
+                    up = tempHalfEdge.Sym;
+                }
+                up = up.Lnext;
+            }
+        }
+
+        /* Now lo.Org == up.Sym.Org == the leftmost vertex.  The remaining region
+         * can be tessellated in a fan from this leftmost vertex.
+         */
+        assert (lo.Lnext != up);
+        while (lo.Lnext.Lnext != up) {
+            GLUhalfEdge tempHalfEdge = Mesh.__gl_meshConnect(lo.Lnext, lo);
+            if (tempHalfEdge == null) return false;
+            lo = tempHalfEdge.Sym;
+        }
+
+        return true;
+    }
+
+
+/* __gl_meshTessellateInterior( mesh ) tessellates each region of
+ * the mesh which is marked "inside" the polygon.  Each such region
+ * must be monotone.
+ */
+    public static boolean __gl_meshTessellateInterior(GLUmesh mesh, boolean avoidDegenerateTris) {
+        GLUface f, next;
+
+        /*LINTED*/
+        for (f = mesh.fHead.next; f != mesh.fHead; f = next) {
+            /* Make sure we don''t try to tessellate the new triangles. */
+            next = f.next;
+            if (f.inside) {
+                if (!__gl_meshTessellateMonoRegion(f, avoidDegenerateTris)) return false;
+            }
+        }
+
+        return true;
+    }
+
+
+/* __gl_meshDiscardExterior( mesh ) zaps (ie. sets to NULL) all faces
+ * which are not marked "inside" the polygon.  Since further mesh operations
+ * on NULL faces are not allowed, the main purpose is to clean up the
+ * mesh so that exterior loops are not represented in the data structure.
+ */
+    public static void __gl_meshDiscardExterior(GLUmesh mesh) {
+        GLUface f, next;
+
+        /*LINTED*/
+        for (f = mesh.fHead.next; f != mesh.fHead; f = next) {
+            /* Since f will be destroyed, save its next pointer. */
+            next = f.next;
+            if (!f.inside) {
+                Mesh.__gl_meshZapFace(f);
+            }
+        }
+    }
+
+    private static final int MARKED_FOR_DELETION = 0x7fffffff;
+
+/* __gl_meshSetWindingNumber( mesh, value, keepOnlyBoundary ) resets the
+ * winding numbers on all edges so that regions marked "inside" the
+ * polygon have a winding number of "value", and regions outside
+ * have a winding number of 0.
+ *
+ * If keepOnlyBoundary is TRUE, it also deletes all edges which do not
+ * separate an interior region from an exterior one.
+ */
+    public static boolean __gl_meshSetWindingNumber(GLUmesh mesh, int value, boolean keepOnlyBoundary) {
+        GLUhalfEdge e, eNext;
+
+        for (e = mesh.eHead.next; e != mesh.eHead; e = eNext) {
+            eNext = e.next;
+            if (e.Sym.Lface.inside != e.Lface.inside) {
+
+                /* This is a boundary edge (one side is interior, one is exterior). */
+                e.winding = (e.Lface.inside) ? value : -value;
+            } else {
+
+                /* Both regions are interior, or both are exterior. */
+                if (!keepOnlyBoundary) {
+                    e.winding = 0;
+                } else {
+                    if (!Mesh.__gl_meshDelete(e)) return false;
+                }
+            }
+        }
+        return true;
+    }
+
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/TessState.java b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/TessState.java
new file mode 100644
index 000000000..9cf192529
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/glu/tessellator/TessState.java
@@ -0,0 +1,59 @@
+/*
+* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
+* All rights reserved.
+*/
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** NOTE:  The Original Code (as defined below) has been licensed to Sun
+** Microsystems, Inc. ("Sun") under the SGI Free Software License B
+** (Version 1.1), shown above ("SGI License").   Pursuant to Section
+** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
+** you under an alternative license ("Alternative License").  This
+** Alternative License includes all of the provisions of the SGI License
+** except that Section 2.2 and 11 are omitted.  Any differences between
+** the Alternative License and the SGI License are offered solely by Sun
+** and not by SGI.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+** Author: Eric Veach, July 1994
+** Java Port: Pepijn Van Eeckhoudt, July 2003
+** Java Port: Nathan Parker Burg, August 2003
+*/
+package com.sun.opengl.impl.glu.tessellator;
+
+class TessState {
+    public static final int T_DORMANT = 0;
+    public static final int T_IN_POLYGON = 1;
+    public static final int T_IN_CONTOUR = 2;
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/io/Locator.java b/src/jogl/classes/com/sun/opengl/impl/io/Locator.java
new file mode 100644
index 000000000..863829960
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/io/Locator.java
@@ -0,0 +1,106 @@
+package com.sun.opengl.impl.io;
+
+import javax.media.opengl.util.*;
+
+import java.util.*;
+import java.nio.*;
+import java.io.*;
+import java.net.*;
+
+/** Utilities for dealing with streams. */
+
+public class Locator {
+    private Locator() {}
+
+    /**
+     * Locates the resource using 'getResource(String path, ClassLoader cl)',
+     * with this context ClassLoader and the path as is,
+     * as well with the context's package name path plus the path.
+     *
+     * @see #getResource(String, ClassLoader)
+     */
+    public static URL getResource(Class context, String path) {
+        ClassLoader contextCL = (null!=context)?context.getClassLoader():null;
+        URL url = getResource(path, contextCL);
+        if (url == null && null!=context) {
+            // Try again by scoping the path within the class's package
+            String className = context.getName().replace('.', '/');
+            int lastSlash = className.lastIndexOf('/');
+            if (lastSlash >= 0) {
+                String tmpPath = className.substring(0, lastSlash + 1) + path;
+                url = getResource(tmpPath, contextCL);
+            }
+        }
+        return url;
+    }
+
+    /**
+     * Locates the resource using the ClassLoader's facility,
+     * the absolute URL and absolute file.
+     *
+     * @see ClassLoader#getResource(String)
+     * @see ClassLoader#getSystemResource(String)
+     * @see URL#URL(String)
+     * @see File#File(String)
+     */
+    public static URL getResource(String path, ClassLoader cl) {
+        URL url = null;
+        if (cl != null) {
+            url = cl.getResource(path);
+        } else {
+            url = ClassLoader.getSystemResource(path);
+        }
+        if(!urlExists(url)) {
+            url = null;
+            try {
+                url = new URL(path);
+            } catch (MalformedURLException e) { }
+        }
+        if(!urlExists(url)) {
+            url = null;
+            try {
+                File file = new File(path);
+                if(file.exists()) {
+                    url = file.toURL();
+                }
+            } catch (MalformedURLException e) {}
+        }
+        return url;
+    }
+
+    /**
+     * Generates a path for the 'relativeFile' relative to the 'absoluteFileLocation'
+     */
+    public static String getRelativeOf(String absoluteFileLocation, String relativeFile) {
+        File file = new File(absoluteFileLocation);
+        file = file.getParentFile();
+        while (file != null && relativeFile.startsWith("../")) {
+            file = file.getParentFile();
+            relativeFile = relativeFile.substring(3);
+        }
+        if (file != null) {
+            String res = new File(file, relativeFile).getPath();
+	        // Handle things on Windows
+            return res.replace('\\', '/');
+        } else {
+            return relativeFile;
+        }
+    }
+
+    /**
+     * Returns true, if the url exists,
+     * trying to open a connection.
+     */
+    public static boolean urlExists(URL url) {
+        boolean v = false;
+        if(null!=url) {
+            try {
+                URLConnection uc = url.openConnection();
+                v = true;
+            } catch (IOException ioe) { }
+        }
+        return v;
+    }
+
+}
+
diff --git a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLContext.java b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLContext.java
new file mode 100644
index 000000000..0bf9414e8
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLContext.java
@@ -0,0 +1,388 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.macosx.cgl;
+
+import java.nio.*;
+import java.util.*;
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.gluegen.runtime.ProcAddressTable;
+
+public abstract class MacOSXCGLContext extends GLContextImpl
+{	
+  protected MacOSXCGLDrawable drawable;
+  protected long nsContext; // NSOpenGLContext
+  private CGLExt cglExt;
+  // Table that holds the addresses of the native C-language entry points for
+  // CGL extension functions.
+  private CGLExtProcAddressTable cglExtProcAddressTable;
+  
+  public MacOSXCGLContext(MacOSXCGLDrawable drawable,
+                         GLContext shareWith)
+  {
+    super(shareWith);
+    this.drawable = drawable;
+  }
+	
+  public Object getPlatformGLExtensions() {
+    return getCGLExt();
+  }
+
+  public CGLExt getCGLExt() {
+    if (cglExt == null) {
+      cglExt = new CGLExtImpl(this);
+    }
+    return cglExt;
+  }
+
+  public final ProcAddressTable getPlatformExtProcAddressTable() {
+    return getCGLExtProcAddressTable();
+  }
+
+  public final CGLExtProcAddressTable getCGLExtProcAddressTable() {
+    return cglExtProcAddressTable;
+  }
+
+  public GLDrawable getGLDrawable() {
+    return drawable;
+  }
+
+  protected String mapToRealGLFunctionName(String glFunctionName)
+  {
+    return glFunctionName;
+  }
+	
+  protected String mapToRealGLExtensionName(String glExtensionName)
+  {
+    return glExtensionName;
+  }
+	
+  protected abstract boolean create();
+
+  /**
+   * Creates and initializes an appropriate OpenGl nsContext. Should only be
+   * called by {@link makeCurrentImpl()}.
+   */
+  protected boolean create(boolean pbuffer, boolean floatingPoint) {
+    MacOSXCGLContext other = (MacOSXCGLContext) GLContextShareSet.getShareContext(this);
+    long share = 0;
+    if (other != null) {
+      share = other.getNSContext();
+      if (share == 0) {
+        throw new GLException("GLContextShareSet returned an invalid OpenGL context");
+      }
+    }
+    int[] viewNotReady = new int[1];
+    NWCapabilities capabilities = drawable.getRequestedNWCapabilities();
+    int[] iattribs = new int[128];
+    int[] ivalues = new int[128];
+    int idx = 0;
+    if (pbuffer) {
+      iattribs[idx] = CGL.NSOpenGLPFAPixelBuffer;   ivalues[idx] = 1;  idx++;
+    }
+    if (floatingPoint) {
+      iattribs[idx] = CGL.kCGLPFAColorFloat;        ivalues[idx] = 1;  idx++;
+    }
+    iattribs[idx] = CGL.NSOpenGLPFADoubleBuffer;  ivalues[idx] = (capabilities.getDoubleBuffered() ? 1 : 0);  idx++;
+    iattribs[idx] = CGL.NSOpenGLPFAStereo;        ivalues[idx] = (capabilities.getStereo() ? 1 : 0);          idx++;
+    iattribs[idx] = CGL.NSOpenGLPFAColorSize;     ivalues[idx] = (capabilities.getRedBits() +
+                                                              capabilities.getGreenBits() +
+                                                              capabilities.getBlueBits());                    idx++;
+    iattribs[idx] = CGL.NSOpenGLPFAAlphaSize;     ivalues[idx] = capabilities.getAlphaBits();                 idx++;
+    iattribs[idx] = CGL.NSOpenGLPFADepthSize;     ivalues[idx] = capabilities.getDepthBits();                 idx++;
+    iattribs[idx] = CGL.NSOpenGLPFAAccumSize;     ivalues[idx] = (capabilities.getAccumRedBits() +
+                                                              capabilities.getAccumGreenBits() +
+                                                              capabilities.getAccumBlueBits() +
+                                                              capabilities.getAccumAlphaBits());              idx++;
+    iattribs[idx] = CGL.NSOpenGLPFAStencilSize;   ivalues[idx] = capabilities.getStencilBits();               idx++;
+    if (capabilities.getSampleBuffers()) {
+      iattribs[idx] = CGL.NSOpenGLPFASampleBuffers; ivalues[idx] = 1;                             idx++;
+      iattribs[idx] = CGL.NSOpenGLPFASamples;       ivalues[idx] = capabilities.getNumSamples();  idx++;
+    }
+
+    long pixelFormat = CGL.createPixelFormat(iattribs, 0, idx, ivalues, 0);
+    if (pixelFormat == 0) {
+      throw new GLException("Unable to allocate pixel format with requested NWCapabilities");
+    }
+    try {
+      // Try to allocate a context with this
+      nsContext = CGL.createContext(share,
+                                    drawable.getNativeWindow().getSurfaceHandle(),
+                                    pixelFormat,
+                                    viewNotReady, 0);
+      if (nsContext == 0) {
+        if (viewNotReady[0] == 1) {
+          if (DEBUG) {
+            System.err.println("!!! View not ready for " + getClass().getName());
+          }
+          // View not ready at the window system level -- this is OK
+          return false;
+        }
+        throw new GLException("Error creating NSOpenGLContext with requested pixel format");
+      }
+
+      if (!pbuffer && !capabilities.isBackgroundOpaque()) {
+          // Set the context opacity
+          CGL.setContextOpacity(nsContext, 0);
+      }
+
+      // On this platform the pixel format is associated with the
+      // context and not the drawable. However it's a reasonable
+      // approximation to just store the chosen pixel format up in the
+      // drawable since the public API doesn't provide for a different
+      // NWCapabilities per context.
+      if (drawable.getChosenNWCapabilities() == null) {
+        // Figure out what attributes we really got
+        NWCapabilities caps = new NWCapabilities();
+        CGL.queryPixelFormat(pixelFormat, iattribs, 0, idx, ivalues, 0);
+        for (int i = 0; i < idx; i++) {
+          int attr = iattribs[i];
+          switch (attr) {
+          case CGL.kCGLPFAColorFloat:
+            caps.setPbufferFloatingPointBuffers(ivalues[i] != 0);
+            break;
+
+          case CGL.NSOpenGLPFADoubleBuffer:
+            caps.setDoubleBuffered(ivalues[i] != 0);
+            break;
+
+          case CGL.NSOpenGLPFAStereo:
+            caps.setStereo(ivalues[i] != 0);
+            break;
+
+          case CGL.NSOpenGLPFAColorSize:
+            {
+              int bitSize = ivalues[i];
+              if (bitSize == 32)
+                bitSize = 24;
+              bitSize /= 3;
+              caps.setRedBits(bitSize);
+              caps.setGreenBits(bitSize);
+              caps.setBlueBits(bitSize);
+            }
+            break;
+
+          case CGL.NSOpenGLPFAAlphaSize:
+            caps.setAlphaBits(ivalues[i]);
+            break;
+
+          case CGL.NSOpenGLPFADepthSize:
+            caps.setDepthBits(ivalues[i]);
+            break;
+
+          case CGL.NSOpenGLPFAAccumSize:
+            {
+              int bitSize = ivalues[i] / 4;
+              caps.setAccumRedBits(bitSize);
+              caps.setAccumGreenBits(bitSize);
+              caps.setAccumBlueBits(bitSize);
+              caps.setAccumAlphaBits(bitSize);
+            }
+            break;
+
+          case CGL.NSOpenGLPFAStencilSize:
+            caps.setStencilBits(ivalues[i]);
+            break;
+
+          case CGL.NSOpenGLPFASampleBuffers:
+            caps.setSampleBuffers(ivalues[i] != 0);
+            break;
+
+          case CGL.NSOpenGLPFASamples:
+            caps.setNumSamples(ivalues[i]);
+            break;
+
+          default:
+            break;
+          }
+        }
+
+        drawable.setChosenNWCapabilities(caps);
+      }
+      
+      
+    } finally {
+      CGL.deletePixelFormat(pixelFormat);
+    }
+    GLContextShareSet.contextCreated(this);
+    return true;
+  }    
+	
+  protected int makeCurrentImpl() throws GLException {
+    if (drawable.getNativeWindow().getSurfaceHandle() == 0) {
+        if (DEBUG) {
+          System.err.println("drawable not properly initialized");
+        }
+        return CONTEXT_NOT_CURRENT;
+    }
+    boolean created = false;
+    if (nsContext == 0) {
+      if (!create()) {
+        return CONTEXT_NOT_CURRENT;
+      }
+      if (DEBUG) {
+        System.err.println("!!! Created OpenGL context " + toHexString(nsContext) + " for " + getClass().getName());
+      }
+      created = true;
+    }
+            
+    if (!CGL.makeCurrentContext(nsContext)) {
+      throw new GLException("Error making nsContext current");
+    }
+            
+    if (created) {
+      resetGLFunctionAvailability();
+      return CONTEXT_CURRENT_NEW;
+    }
+    return CONTEXT_CURRENT;
+  }
+	
+  protected void releaseImpl() throws GLException {
+    if (!CGL.clearCurrentContext(nsContext)) {
+      throw new GLException("Error freeing OpenGL nsContext");
+    }
+  }
+	
+  protected void destroyImpl() throws GLException {
+    if (nsContext != 0) {
+      if (!CGL.deleteContext(nsContext)) {
+        throw new GLException("Unable to delete OpenGL context");
+      }
+      if (DEBUG) {
+        System.err.println("!!! Destroyed OpenGL context " + nsContext);
+      }
+      nsContext = 0;
+      GLContextShareSet.contextDestroyed(this);
+    }
+  }
+
+  public boolean isCreated() {
+    return (nsContext != 0);
+  }
+	
+  public void copy(GLContext source, int mask) throws GLException {
+    long dst = getNSContext();
+    long src = ((MacOSXCGLContext) source).getNSContext();
+    if (src == 0) {
+      throw new GLException("Source OpenGL context has not been created");
+    }
+    if (dst == 0) {
+      throw new GLException("Destination OpenGL context has not been created");
+    }
+    CGL.copyContext(dst, src, mask);
+  }
+
+  protected void resetGLFunctionAvailability()
+  {
+    super.resetGLFunctionAvailability();
+    if (DEBUG) {
+      System.err.println("!!! Initializing CGL extension address table");
+    }
+    if (cglExtProcAddressTable == null) {
+      // FIXME: cache ProcAddressTables by capability bits so we can
+      // share them among contexts with the same capabilities
+      cglExtProcAddressTable = new CGLExtProcAddressTable();
+    }          
+    resetProcAddressTable(getCGLExtProcAddressTable());
+  }
+	
+  public String getPlatformExtensionsString()
+  {
+    return "";
+  }
+	
+  public void setSwapInterval(int interval) {
+    if (nsContext == 0) {
+      throw new GLException("OpenGL context not current");
+    }
+    CGL.setSwapInterval(nsContext, interval);
+  }
+
+  public ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3) {
+    // FIXME: apparently the Apple extension doesn't require a custom memory allocator
+    throw new GLException("Not yet implemented");
+  }
+
+  public boolean isFunctionAvailable(String glFunctionName)
+  {
+    return super.isFunctionAvailable(glFunctionName);
+  }
+  
+  public boolean isExtensionAvailable(String glExtensionName) {
+    if (glExtensionName.equals("GL_ARB_pbuffer") ||
+        glExtensionName.equals("GL_ARB_pixel_format")) {
+      return true;
+    }
+    return super.isExtensionAvailable(glExtensionName);
+  }
+  
+  public int getOffscreenContextPixelDataType() {
+    throw new GLException("Should not call this");
+  }
+
+  public int getOffscreenContextReadBuffer() {
+    throw new GLException("Should not call this");
+  }
+
+  public boolean offscreenImageNeedsVerticalFlip() {
+    throw new GLException("Should not call this");
+  }
+
+  public void bindPbufferToTexture() {
+    throw new GLException("Should not call this");
+  }
+    
+  public void releasePbufferFromTexture() {
+    throw new GLException("Should not call this");
+  }
+    
+  // Support for "mode switching" as described in MacOSXCGLDrawable
+  public abstract void setOpenGLMode(int mode);
+  public abstract int  getOpenGLMode();
+
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+	
+  public long getNSContext() {
+    return nsContext;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLDrawable.java b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLDrawable.java
new file mode 100644
index 000000000..01816b190
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLDrawable.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.macosx.cgl;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public abstract class MacOSXCGLDrawable extends GLDrawableImpl {
+  protected static final boolean DEBUG = Debug.debug("MacOSXCGLDrawable");
+
+  protected NWCapabilitiesChooser chooser;
+  
+  // The Java2D/OpenGL pipeline on OS X uses low-level CGLContextObjs
+  // to represent the contexts for e.g. the Java2D back buffer. When
+  // the Java2D/JOGL bridge is active, this means that if we want to
+  // be able to share textures and display lists with the Java2D
+  // contexts, we need to use the CGL APIs rather than the NSOpenGL
+  // APIs on the JOGL side. For example, if we create a pbuffer using
+  // the NSOpenGL APIs and want to share textures and display lists
+  // between it and the Java2D back buffer, there is no way to do so,
+  // because the Java2D context is actually a CGLContextObj and the
+  // NSOpenGLContext's initWithFormat:shareContext: only accepts an
+  // NSOpenGLContext as its second argument. Of course there is no way
+  // to wrap an NSOpenGLContext around an arbitrary CGLContextObj.
+  //
+  // The situation we care most about is allowing a GLPbuffer to share
+  // textures, etc. with a GLJPanel when the Java2D/JOGL bridge is
+  // active; several of the demos rely on this functionality. We aim
+  // to get there by allowing a GLPBuffer to switch its implementation
+  // between using an NSOpenGLPixelBuffer and a CGLPBufferObj. In
+  // order to track whether this has been done we need to have the
+  // notion of a "mode" of both the MacOSXCGLDrawable and the
+  // MacOSXGLContext. Initially the mode is "unspecified", meaning it
+  // leans toward the default (NSOpenGL). If sharing is requested
+  // between either a GLJPanel and a GLPbuffer or a GLCanvas and a
+  // GLPbuffer, the GLPbuffer will be switched into the appropriate
+  // mode: CGL mode for a GLJPanel and NSOpenGL mode for a GLCanvas.
+  // To avoid thrashing we support exactly one such switch during the
+  // lifetime of a given GLPbuffer. This is not a fully general
+  // solution (for example, you can't share textures among a
+  // GLPbuffer, a GLJPanel and a GLCanvas simultaneously) but should
+  // be enough to get things off the ground.
+  public static final int NSOPENGL_MODE = 1;
+  public static final int CGL_MODE      = 2;
+
+  public MacOSXCGLDrawable(GLDrawableFactory factory, NativeWindow comp, boolean realized,
+                           NWCapabilities requestedCapabilities, NWCapabilitiesChooser chooser) {
+    super(factory, comp, requestedCapabilities, realized);
+    this.chooser = chooser;
+ }
+
+  // These are public to allow access from a couple of context implementations
+  public void setChosenNWCapabilities(NWCapabilities caps) {
+    super.setChosenNWCapabilities(caps);
+  }
+
+  public NWCapabilities getRequestedNWCapabilities() {
+    return super.getRequestedNWCapabilities();
+  }
+
+  protected static String getThreadName() {
+    return Thread.currentThread().getName();
+  }
+
+  // Support for "mode switching" as per above
+  public abstract void setOpenGLMode(int mode);
+  public abstract int  getOpenGLMode();
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLDrawableFactory.java b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLDrawableFactory.java
new file mode 100644
index 000000000..ae09fa9ea
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXCGLDrawableFactory.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.macosx.cgl;
+
+import java.lang.reflect.InvocationTargetException;
+import java.nio.*;
+import java.util.*;
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public class MacOSXCGLDrawableFactory extends GLDrawableFactoryImpl {
+  public MacOSXCGLDrawableFactory() {
+    super();
+  }
+
+  public AbstractGraphicsConfiguration chooseGraphicsConfiguration(NWCapabilities capabilities,
+                                                                   NWCapabilitiesChooser chooser,
+                                                                   AbstractGraphicsDevice device) {
+    return null;
+  }
+
+  public GLDrawable createGLDrawable(NativeWindow target,
+                                     NWCapabilities capabilities,
+                                     NWCapabilitiesChooser chooser) {
+    if (target == null) {
+      throw new IllegalArgumentException("Null target");
+    }
+    target = NativeWindowFactory.getNativeWindow(target);
+    if (capabilities == null) {
+      capabilities = new NWCapabilities();
+    }
+    if (chooser == null) {
+      chooser = new DefaultNWCapabilitiesChooser();
+    }
+    return new MacOSXOnscreenCGLDrawable(this, target, capabilities, chooser);
+  }
+
+  public GLDrawableImpl createOffscreenDrawable(NWCapabilities capabilities,
+                                                NWCapabilitiesChooser chooser,
+                                                int width,
+                                                int height) {
+    return new MacOSXOffscreenCGLDrawable(this, capabilities, width, height);
+  }
+
+  public boolean canCreateGLPbuffer() {
+    return true;
+  }
+
+  public GLPbuffer createGLPbuffer(final NWCapabilities capabilities,
+                                   final NWCapabilitiesChooser chooser,
+                                   final int initialWidth,
+                                   final int initialHeight,
+                                   final GLContext shareWith) {
+    final List returnList = new ArrayList();
+    final GLDrawableFactory factory = this;
+    Runnable r = new Runnable() {
+        public void run() {
+          MacOSXPbufferCGLDrawable pbufferDrawable = new MacOSXPbufferCGLDrawable(factory, capabilities,
+										initialWidth,
+										initialHeight);
+          GLPbufferImpl pbuffer = new GLPbufferImpl(pbufferDrawable, shareWith);
+          returnList.add(pbuffer);
+        }
+      };
+    maybeDoSingleThreadedWorkaround(r);
+    return (GLPbuffer) returnList.get(0);
+  }
+
+  public GLContext createExternalGLContext() {
+    return new MacOSXExternalCGLContext();
+  }
+
+  public boolean canCreateExternalGLDrawable() {
+    return false;
+  }
+
+  public GLDrawable createExternalGLDrawable() {
+    // FIXME
+    throw new GLException("Not yet implemented");
+  }
+
+  public void loadGLULibrary() {
+    // Nothing to do; already loaded by native code; not much point in
+    // making it lazier on this platform
+  }
+
+  public long dynamicLookupFunction(String glFuncName) {
+    return CGL.getProcAddress(glFuncName);
+  }
+
+  private void maybeDoSingleThreadedWorkaround(Runnable action) {
+    if (Threading.isSingleThreaded() &&
+        !Threading.isOpenGLThread()) {
+      Threading.invokeOnOpenGLThread(action);
+    } else {
+      action.run();
+    }
+  }
+
+  public boolean canCreateContextOnJava2DSurface() {
+    return false;
+  }
+
+  public GLContext createContextOnJava2DSurface(Object graphics, GLContext shareWith)
+    throws GLException {
+    throw new GLException("not supported in non AWT enviroment");
+  }
+  
+  //------------------------------------------------------
+  // Gamma-related functionality
+  //
+
+  private static final int GAMMA_RAMP_LENGTH = 256;
+
+  /** Returns the length of the computed gamma ramp for this OS and
+      hardware. Returns 0 if gamma changes are not supported. */
+  protected int getGammaRampLength() {
+    return GAMMA_RAMP_LENGTH;
+  }
+
+  protected boolean setGammaRamp(float[] ramp) {
+    return CGL.setGammaRamp(ramp.length,
+                            ramp, 0,
+                            ramp, 0,
+                            ramp, 0);
+  }
+
+  protected Buffer getGammaRamp() {
+    return null;
+  }
+
+  protected void resetGammaRamp(Buffer originalGammaRamp) {
+    CGL.resetGammaRamp();
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXExternalCGLContext.java b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXExternalCGLContext.java
new file mode 100644
index 000000000..b19e221f0
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXExternalCGLContext.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.macosx.cgl;
+
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public class MacOSXExternalCGLContext extends MacOSXCGLContext {
+  private boolean firstMakeCurrent = true;
+  private boolean created = true;
+  private GLContext lastContext;
+
+  public MacOSXExternalCGLContext() {
+    super(null, null);
+
+    // FIXME: we don't have a "current context" primitive implemented
+    // yet on OS X. In the current implementation this would need to
+    // return an NSOpenGLContext*, but "external" toolkits are not
+    // guaranteed to be using the Cocoa OpenGL API. Additionally, if
+    // we switched this implementation to use the low-level CGL APIs,
+    // we would lose the ability to share textures and display lists
+    // between contexts since you need an NSOpenGLContext, not a
+    // CGLContextObj, in order to share textures and display lists
+    // between two NSOpenGLContexts.
+    //
+    // The ramifications here are that it is not currently possible to
+    // share textures and display lists between an OpenGL context
+    // created by JOGL and one created by a third-party library on OS
+    // X.
+
+    // context = CGL.CGLGetCurrentContext();
+
+    GLContextShareSet.contextCreated(this);
+    resetGLFunctionAvailability();
+  }
+
+  protected boolean create() {
+    return true;
+  }
+
+  public int makeCurrent() throws GLException {
+    // Save last context if necessary to allow external GLContexts to
+    // talk to other GLContexts created by this library
+    GLContext cur = getCurrent();
+    if (cur != null && cur != this) {
+      lastContext = cur;
+      setCurrent(null);
+    }
+    return super.makeCurrent();
+  }  
+
+  public void release() throws GLException {
+    super.release();
+    setCurrent(lastContext);
+    lastContext = null;
+  }
+
+  protected int makeCurrentImpl() throws GLException {
+    if (firstMakeCurrent) {
+      firstMakeCurrent = false;
+      return CONTEXT_CURRENT_NEW;
+    }
+    return CONTEXT_CURRENT;
+  }
+
+  protected void releaseImpl() throws GLException {
+  }
+
+  protected void destroyImpl() throws GLException {
+    created = false;
+    GLContextShareSet.contextDestroyed(this);
+  }
+
+  public boolean isCreated() {
+    return created;
+  }
+
+  public void setOpenGLMode(int mode) {
+    if (mode != MacOSXCGLDrawable.NSOPENGL_MODE)
+      throw new GLException("OpenGL mode switching not supported for external GLContexts");
+  }
+    
+  public int  getOpenGLMode() {
+    return MacOSXCGLDrawable.NSOPENGL_MODE;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXOffscreenCGLContext.java b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXOffscreenCGLContext.java
new file mode 100644
index 000000000..b60c48237
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXOffscreenCGLContext.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.macosx.cgl;
+
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public class MacOSXOffscreenCGLContext extends MacOSXPbufferCGLContext
+{  
+  public MacOSXOffscreenCGLContext(MacOSXPbufferCGLDrawable drawable,
+                                  GLContext shareWith) {
+    super(drawable, shareWith);
+  }
+	
+  public int getOffscreenContextPixelDataType() {
+    GL gl = getGL();
+    return gl.isGL2()?GL2.GL_UNSIGNED_INT_8_8_8_8_REV:GL.GL_UNSIGNED_SHORT_5_5_5_1;
+  }
+
+  public int getOffscreenContextReadBuffer() {
+    return GL.GL_FRONT;
+  }
+
+  public boolean offscreenImageNeedsVerticalFlip() {
+    return true;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXOffscreenCGLDrawable.java b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXOffscreenCGLDrawable.java
new file mode 100644
index 000000000..aaaf38277
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXOffscreenCGLDrawable.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.macosx.cgl;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public class MacOSXOffscreenCGLDrawable extends MacOSXPbufferCGLDrawable {
+
+  public MacOSXOffscreenCGLDrawable(GLDrawableFactory factory,
+                                    NWCapabilities capabilities,
+                                    int width,
+                                    int height) {
+    super(factory, capabilities, width, height);
+  }
+
+  public GLContext createContext(GLContext shareWith) {
+    return new MacOSXOffscreenCGLContext(this, shareWith);
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXOnscreenCGLContext.java b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXOnscreenCGLContext.java
new file mode 100644
index 000000000..0767f40ee
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXOnscreenCGLContext.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.macosx.cgl;
+
+import java.util.*;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public class MacOSXOnscreenCGLContext extends MacOSXCGLContext {
+  protected MacOSXOnscreenCGLDrawable drawable;
+
+  public MacOSXOnscreenCGLContext(MacOSXOnscreenCGLDrawable drawable,
+                                 GLContext shareWith) {
+    super(drawable, shareWith);
+    this.drawable = drawable;
+  }
+
+  protected int makeCurrentImpl() throws GLException {
+    int lockRes = drawable.lockSurface();
+    boolean exceptionOccurred = false;
+    try {
+      if (lockRes == NativeWindow.LOCK_SURFACE_NOT_READY) {
+        return CONTEXT_NOT_CURRENT;
+      }
+      if (lockRes == NativeWindow.LOCK_SURFACE_CHANGED) {
+        destroyImpl();
+      }
+      int ret = super.makeCurrentImpl();
+      if ((ret == CONTEXT_CURRENT) ||
+          (ret == CONTEXT_CURRENT_NEW)) {
+        // Assume the canvas might have been resized or moved and tell the OpenGL
+        // context to update itself. This used to be done only upon receiving a
+        // reshape event but that doesn't appear to be sufficient. An experiment
+        // was also done to add a HierarchyBoundsListener to the GLCanvas and
+        // do this updating only upon reshape of this component or reshape or movement
+        // of an ancestor, but this also wasn't sufficient and left garbage on the
+        // screen in some situations.
+        CGL.updateContext(nsContext);
+      } else {
+        if (!isOptimizable()) {
+          // This can happen if the window currently is zero-sized, for example.
+          // Make sure we don't leave the surface locked in this case.
+          drawable.unlockSurface();
+        }
+      }
+      return ret;
+    } catch (RuntimeException e) {
+      exceptionOccurred = true;
+      throw e;
+    } finally {
+      if (exceptionOccurred ||
+          (isOptimizable() && lockRes != NativeWindow.LOCK_SURFACE_NOT_READY)) {
+        drawable.unlockSurface();
+      }
+    }
+  }
+    
+  protected void releaseImpl() throws GLException {
+    try {
+      super.releaseImpl();
+    } finally {
+      if (!isOptimizable()) {
+        drawable.unlockSurface();
+      }
+    }
+  }
+
+  public void swapBuffers() throws GLException {
+    if (!CGL.flushBuffer(nsContext)) {
+      throw new GLException("Error swapping buffers");
+    }
+  }
+
+  protected void update() throws GLException {
+    if (nsContext == 0) {
+      throw new GLException("Context not created");
+    }
+    CGL.updateContext(nsContext);
+  }
+
+  protected boolean create() {
+    return create(false, false);
+  }
+
+  public void setOpenGLMode(int mode) {
+    if (mode != MacOSXCGLDrawable.NSOPENGL_MODE)
+      throw new GLException("OpenGL mode switching not supported for on-screen GLContexts");
+  }
+    
+  public int  getOpenGLMode() {
+    return MacOSXCGLDrawable.NSOPENGL_MODE;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXOnscreenCGLDrawable.java b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXOnscreenCGLDrawable.java
new file mode 100644
index 000000000..e17eee602
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXOnscreenCGLDrawable.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.macosx.cgl;
+
+import java.lang.ref.WeakReference;
+import java.security.*;
+import java.util.*;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public class MacOSXOnscreenCGLDrawable extends MacOSXCGLDrawable {
+  private List/*<WeakReference<GLContext>>*/ createdContexts =
+    new ArrayList();
+
+  protected MacOSXOnscreenCGLDrawable(GLDrawableFactory factory, NativeWindow component,
+                                  NWCapabilities capabilities,
+                                  NWCapabilitiesChooser chooser) {
+    super(factory, component, false, capabilities, chooser);
+  }
+
+  public GLContext createContext(GLContext shareWith) {
+    MacOSXOnscreenCGLContext context =
+      new MacOSXOnscreenCGLContext(this, shareWith);
+    // NOTE: we need to keep track of the created contexts in order to
+    // implement swapBuffers() because of how Mac OS X implements its
+    // OpenGL window interface
+    synchronized (this) {
+      List newContexts = new ArrayList();
+      newContexts.addAll(createdContexts);
+      newContexts.add(new WeakReference(context));
+      createdContexts = newContexts;
+    }
+    return context;
+  }
+
+  public int getWidth() {
+    return component.getWidth();
+  }
+
+  public int getHeight() {
+    return component.getHeight();
+  }
+
+  public void swapBuffers() throws GLException {
+    for (Iterator iter = createdContexts.iterator(); iter.hasNext(); ) {
+      WeakReference ref = (WeakReference) iter.next();
+      MacOSXOnscreenCGLContext ctx = (MacOSXOnscreenCGLContext) ref.get();
+      // FIXME: clear out unreachable contexts
+      if (ctx != null) {
+        ctx.swapBuffers();
+      }
+    }
+  }
+  
+  public void setOpenGLMode(int mode) {
+    if (mode != NSOPENGL_MODE)
+      throw new GLException("OpenGL mode switching not supported for on-screen GLDrawables");
+  }
+
+  public int  getOpenGLMode() {
+    return NSOPENGL_MODE;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXPbufferCGLContext.java b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXPbufferCGLContext.java
new file mode 100644
index 000000000..f927731eb
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXPbufferCGLContext.java
@@ -0,0 +1,341 @@
+package com.sun.opengl.impl.macosx.cgl;
+
+import java.security.*;
+import java.util.*;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public class MacOSXPbufferCGLContext extends MacOSXCGLContext {
+  protected MacOSXPbufferCGLDrawable drawable;
+
+  // State for render-to-texture and render-to-texture-rectangle support
+  private int textureTarget; // e.g. GL_TEXTURE_2D, GL_TEXTURE_RECTANGLE_NV
+  private int texture;       // actual texture object
+
+  private static boolean isTigerOrLater;
+
+  static {
+    String osVersion =
+      (String) AccessController.doPrivileged(new PrivilegedAction() {
+	  public Object run() {
+	    return System.getProperty("os.version");
+	  }
+	});
+    StringTokenizer tok = new StringTokenizer(osVersion, ". ");
+    int major = Integer.parseInt(tok.nextToken());
+    int minor = Integer.parseInt(tok.nextToken());
+    isTigerOrLater = ((major > 10) || (minor > 3));
+  }
+
+  public MacOSXPbufferCGLContext(MacOSXPbufferCGLDrawable drawable,
+                                GLContext shareWith) {
+    super(drawable, shareWith);
+    this.drawable = drawable;
+    initOpenGLImpl();
+  }
+
+  public void bindPbufferToTexture() {
+    GL gl = getGL();
+    gl.glBindTexture(textureTarget, texture);
+    // FIXME: not clear whether this is really necessary, but since
+    // the API docs seem to imply it is and since it doesn't seem to
+    // impact performance, leaving it in
+    CGL.setContextTextureImageToPBuffer(nsContext, drawable.getPbuffer(), GL.GL_FRONT);
+  }
+
+  public void releasePbufferFromTexture() {
+  }
+
+  protected int makeCurrentImpl() throws GLException {
+    if (drawable.getPbuffer() == 0) {
+      if (DEBUG) {
+        System.err.println("Pbuffer not instantiated yet for " + this);
+      }
+      // pbuffer not instantiated yet
+      return CONTEXT_NOT_CURRENT;
+    }
+
+    if (getOpenGLMode() != drawable.getOpenGLMode()) {
+      setOpenGLMode(drawable.getOpenGLMode());
+    }
+
+    boolean created = false;
+    if (nsContext == 0) {
+      if (!create()) {
+        return CONTEXT_NOT_CURRENT;
+      }
+      if (DEBUG) {
+        System.err.println("!!! Created OpenGL context " + toHexString(nsContext) + " for " + getClass().getName());
+      }
+      created = true;
+    }
+    
+    if (!impl.makeCurrent(nsContext)) {
+      throw new GLException("Error making nsContext current");
+    }
+            
+    if (created) {
+      resetGLFunctionAvailability();
+
+      // Initialize render-to-texture support if requested
+      GL gl = getGL();
+      boolean rect = gl.isGL2() && drawable.getRequestedNWCapabilities().getPbufferRenderToTextureRectangle();
+      if (rect) {
+        if (!gl.isExtensionAvailable("GL_EXT_texture_rectangle")) {
+          System.err.println("MacOSXPbufferCGLContext: WARNING: GL_EXT_texture_rectangle extension not " +
+                             "supported; skipping requested render_to_texture_rectangle support for pbuffer");
+          rect = false;
+        }
+      }
+      textureTarget = (rect ? GL2.GL_TEXTURE_RECTANGLE: GL.GL_TEXTURE_2D);
+      int[] tmp = new int[1];
+      gl.glGenTextures(1, tmp, 0);
+      texture = tmp[0];
+      gl.glBindTexture(textureTarget, texture);
+      gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST);
+      gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST);
+      gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP_TO_EDGE);
+      gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP_TO_EDGE);
+      gl.glCopyTexImage2D(textureTarget, 0, GL.GL_RGB, 0, 0, drawable.getWidth(), drawable.getHeight(), 0);
+
+      return CONTEXT_CURRENT_NEW;
+    }
+    return CONTEXT_CURRENT;
+  }
+
+  protected void releaseImpl() throws GLException {
+    if (!impl.release(nsContext)) {
+      throw new GLException("Error releasing OpenGL nsContext");
+    }
+  }
+
+  protected void destroyImpl() throws GLException {
+    if (nsContext != 0) {
+      if (!impl.destroy(nsContext)) {
+        throw new GLException("Unable to delete OpenGL context");
+      }
+      if (DEBUG) {
+        System.err.println("!!! Destroyed OpenGL context " + nsContext);
+      }
+      nsContext = 0;
+      GLContextShareSet.contextDestroyed(this);
+    }
+  }
+
+  public void setSwapInterval(int interval) {
+    if (nsContext == 0) {
+      throw new GLException("OpenGL context not current");
+    }
+    impl.setSwapInterval(nsContext, interval);
+  }
+
+  public int getFloatingPointMode() {
+    return GLPbuffer.APPLE_FLOAT;
+  }
+
+  protected boolean create() {
+    NWCapabilities capabilities = drawable.getRequestedNWCapabilities();
+    if (capabilities.getPbufferFloatingPointBuffers() &&
+	!isTigerOrLater) {
+      throw new GLException("Floating-point pbuffers supported only on OS X 10.4 or later");
+    }
+    // Change our OpenGL mode to match that of any share context before we create ourselves
+    MacOSXCGLContext other = (MacOSXCGLContext) GLContextShareSet.getShareContext(this);
+    if (other != null) {
+      setOpenGLMode(other.getOpenGLMode());
+    }
+    // Will throw exception upon error
+    nsContext = impl.create();
+    return true;
+  }
+
+  //---------------------------------------------------------------------------
+  // OpenGL "mode switching" functionality
+  //
+  private boolean haveSetOpenGLMode = false;
+  // FIXME: should consider switching the default mode based on
+  // whether the Java2D/JOGL bridge is active -- need to ask ourselves
+  // whether it's more likely that we will share with a GLCanvas or a
+  // GLJPanel when the bridge is turned on
+  private int     openGLMode = MacOSXCGLDrawable.NSOPENGL_MODE;
+  // Implementation object (either NSOpenGL-based or CGL-based)
+  protected Impl impl;
+
+  public void setOpenGLMode(int mode) {
+    if (mode == openGLMode) {
+      return;
+    }
+    if (haveSetOpenGLMode) {
+      throw new GLException("Can't switch between using NSOpenGLPixelBuffer and CGLPBufferObj more than once");
+    }
+    destroyImpl();
+    drawable.setOpenGLMode(mode);
+    openGLMode = mode;
+    haveSetOpenGLMode = true;
+    if (DEBUG) {
+      System.err.println("Switching PBuffer context mode to " +
+                         ((mode == MacOSXCGLDrawable.NSOPENGL_MODE) ? "NSOPENGL_MODE" : "CGL_MODE"));
+    }
+    initOpenGLImpl();
+  }
+
+  public int  getOpenGLMode() {
+    return openGLMode;
+  }
+
+  private void initOpenGLImpl() {
+    switch (openGLMode) {
+      case MacOSXCGLDrawable.NSOPENGL_MODE:
+        impl = new NSOpenGLImpl();
+        break;
+      case MacOSXCGLDrawable.CGL_MODE:
+        impl = new CGLImpl();
+        break;
+      default:
+        throw new InternalError("Illegal implementation mode " + openGLMode);
+    }
+  }
+
+  // Abstract interface for implementation of this context (either
+  // NSOpenGL-based or CGL-based)
+  interface Impl {
+    public long    create();
+    public boolean destroy(long ctx);
+    public boolean makeCurrent(long ctx);
+    public boolean release(long ctx);
+    public void    setSwapInterval(long ctx, int interval);
+  }
+
+  // NSOpenGLContext-based implementation
+  class NSOpenGLImpl implements Impl {
+    public long create() {
+      NWCapabilities capabilities = drawable.getRequestedNWCapabilities();
+      if (capabilities.getPbufferFloatingPointBuffers() &&
+          !isTigerOrLater) {
+        throw new GLException("Floating-point pbuffers supported only on OS X 10.4 or later");
+      }
+      if (!MacOSXPbufferCGLContext.this.create(true, capabilities.getPbufferFloatingPointBuffers())) {
+        throw new GLException("Error creating context for pbuffer");
+      }
+      // Must now associate the pbuffer with our newly-created context
+      CGL.setContextPBuffer(nsContext, drawable.getPbuffer());
+      return nsContext;
+    }
+
+    public boolean destroy(long ctx) {
+      return CGL.deleteContext(ctx);
+    }
+
+    public boolean makeCurrent(long ctx) {
+      return CGL.makeCurrentContext(ctx);
+    }
+
+    public boolean release(long ctx) {
+      return CGL.clearCurrentContext(ctx);
+    }
+
+    public void setSwapInterval(long ctx, int interval) {
+      CGL.setSwapInterval(ctx, interval);      
+    }
+  }
+
+  class CGLImpl implements Impl {
+    public long create() {
+      // Find and configure share context
+      MacOSXCGLContext other = (MacOSXCGLContext) GLContextShareSet.getShareContext(MacOSXPbufferCGLContext.this);
+      long share = 0;
+      if (other != null) {
+        // Reconfigure pbuffer-based GLContexts
+        if (other instanceof MacOSXPbufferCGLContext) {
+          MacOSXPbufferCGLContext ctx = (MacOSXPbufferCGLContext) other;
+          ctx.setOpenGLMode(MacOSXCGLDrawable.CGL_MODE);
+        } else {
+          if (other.getOpenGLMode() != MacOSXCGLDrawable.CGL_MODE) {
+            throw new GLException("Can't share between NSOpenGLContexts and CGLContextObjs");
+          }
+        }
+        share = other.getNSContext();
+        // Note we don't check for a 0 return value, since switching
+        // the context's mode causes it to be destroyed and not
+        // re-initialized until the next makeCurrent
+      }
+
+      // Set up pixel format attributes
+      int[] attrs = new int[256];
+      int i = 0;
+      attrs[i++] = CGL.kCGLPFAPBuffer;
+      NWCapabilities capabilities = drawable.getRequestedNWCapabilities();
+      if (capabilities.getPbufferFloatingPointBuffers())
+        attrs[i++] = CGL.kCGLPFAColorFloat;
+      if (capabilities.getDoubleBuffered())
+        attrs[i++] = CGL.kCGLPFADoubleBuffer;
+      if (capabilities.getStereo())
+        attrs[i++] = CGL.kCGLPFAStereo;
+      attrs[i++] = CGL.kCGLPFAColorSize;
+      attrs[i++] = (capabilities.getRedBits() +
+                    capabilities.getGreenBits() +
+                    capabilities.getBlueBits());
+      attrs[i++] = CGL.kCGLPFAAlphaSize;
+      attrs[i++] = capabilities.getAlphaBits();
+      attrs[i++] = CGL.kCGLPFADepthSize;
+      attrs[i++] = capabilities.getDepthBits();
+      // FIXME: should validate stencil size as is done in MacOSXWindowSystemInterface.m
+      attrs[i++] = CGL.kCGLPFAStencilSize;
+      attrs[i++] = capabilities.getStencilBits();
+      attrs[i++] = CGL.kCGLPFAAccumSize;
+      attrs[i++] = (capabilities.getAccumRedBits() +
+                    capabilities.getAccumGreenBits() +
+                    capabilities.getAccumBlueBits() +
+                    capabilities.getAccumAlphaBits());
+      if (capabilities.getSampleBuffers()) {
+        attrs[i++] = CGL.kCGLPFASampleBuffers;
+        attrs[i++] = 1;
+        attrs[i++] = CGL.kCGLPFASamples;
+        attrs[i++] = capabilities.getNumSamples();
+      }
+
+      // Use attribute array to select pixel format
+      long[] fmt = new long[1];
+      long[] numScreens = new long[1];
+      int res = CGL.CGLChoosePixelFormat(attrs, 0, fmt, 0, numScreens, 0);
+      if (res != CGL.kCGLNoError) {
+        throw new GLException("Error code " + res + " while choosing pixel format");
+      }
+      
+      // Create new context
+      long[] ctx = new long[1];
+      if (DEBUG) {
+        System.err.println("Share context for CGL-based pbuffer context is " + toHexString(share));
+      }
+      res = CGL.CGLCreateContext(fmt[0], share, ctx, 0);
+      CGL.CGLDestroyPixelFormat(fmt[0]);
+      if (res != CGL.kCGLNoError) {
+        throw new GLException("Error code " + res + " while creating context");
+      }
+      // Attach newly-created context to the pbuffer
+      res = CGL.CGLSetPBuffer(ctx[0], drawable.getPbuffer(), 0, 0, 0);
+      if (res != CGL.kCGLNoError) {
+        throw new GLException("Error code " + res + " while attaching context to pbuffer");
+      }
+      return ctx[0];
+    }
+    
+    public boolean destroy(long ctx) {
+      return (CGL.CGLDestroyContext(ctx) == CGL.kCGLNoError);
+    }
+
+    public boolean makeCurrent(long ctx) {
+      return CGL.CGLSetCurrentContext(ctx) == CGL.kCGLNoError;
+    }
+
+    public boolean release(long ctx) {
+      return (CGL.CGLSetCurrentContext(0) == CGL.kCGLNoError);
+    }
+
+    public void setSwapInterval(long ctx, int interval) {
+      // For now not supported (not really relevant for off-screen contexts anyway)
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXPbufferCGLDrawable.java b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXPbufferCGLDrawable.java
new file mode 100644
index 000000000..af5676d96
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/MacOSXPbufferCGLDrawable.java
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.macosx.cgl;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.nwi.impl.NullWindow;
+
+public class MacOSXPbufferCGLDrawable extends MacOSXCGLDrawable {
+  private static final boolean DEBUG = Debug.debug("MacOSXPbufferCGLDrawable");
+  
+  // State for render-to-texture and render-to-texture-rectangle support
+  private int textureTarget; // e.g. GL_TEXTURE_2D, GL_TEXTURE_RECTANGLE_NV
+  private int texture;       // actual texture object
+
+  // NSOpenGLPbuffer (for normal mode)
+  // CGLPbufferObj (for CGL_MODE situation, i.e., when Java2D/JOGL bridge is active)
+  // Note that we can not store this in the NativeWindow because the
+  // semantic is that contains an NSView
+  protected long pBuffer;
+
+  public MacOSXPbufferCGLDrawable(GLDrawableFactory factory, NWCapabilities capabilities, int width, int height) {
+    super(factory, new NullWindow(), true, capabilities, null);
+    NullWindow nw = (NullWindow) getNativeWindow();
+    nw.setSize(width, height);
+    initOpenGLImpl();
+    createPbuffer();
+  }
+
+  public GLContext createContext(GLContext shareWith) {
+    return new MacOSXPbufferCGLContext(this, shareWith);
+  }
+
+  public void destroy() {
+    if (this.pBuffer != 0) {
+      impl.destroy(pBuffer);
+      this.pBuffer = 0;
+      if (DEBUG) {
+        System.err.println("Destroyed pbuffer: " + pBuffer);
+      }
+    }
+  }
+
+  public long getPbuffer() {
+    return pBuffer;
+  }
+  
+  public void swapBuffers() throws GLException {
+    // FIXME: do we need to do anything if the pbuffer is double-buffered?
+  }
+
+  private void createPbuffer() {
+    NullWindow nw = (NullWindow) getNativeWindow();
+    int renderTarget;
+    NWCapabilities capabilities = getRequestedNWCapabilities();
+    if (GLProfile.isGL2() && capabilities.getPbufferRenderToTextureRectangle()) {
+      renderTarget = GL2.GL_TEXTURE_RECTANGLE;
+    } else {
+      int w = getNextPowerOf2(getWidth());
+      int h = getNextPowerOf2(getHeight());
+      nw.setSize(w, h);
+      renderTarget = GL.GL_TEXTURE_2D;
+    }
+
+    int internalFormat = GL.GL_RGBA;
+    if (capabilities.getPbufferFloatingPointBuffers()) {
+      // FIXME: want to check availability of GL_APPLE_float_pixels
+      // extension, but need valid OpenGL context in order to do so --
+      // in worst case would need to create dummy window / GLCanvas
+      // (undesirable) -- could maybe also do this with pbuffers
+      /*
+        if (!gl.isExtensionAvailable("GL_APPLE_float_pixels")) {
+        throw new GLException("Floating-point support (GL_APPLE_float_pixels) not available");
+        }
+      */
+      if(GLProfile.isGL2()) {
+        switch (capabilities.getRedBits()) {
+        case 16: internalFormat = GL2.GL_RGBA_FLOAT16_APPLE; break;
+        case 32: internalFormat = GL2.GL_RGBA_FLOAT32_APPLE; break;
+        default: throw new GLException("Invalid floating-point bit depth (only 16 and 32 supported)");
+        }
+      } else {
+        internalFormat = GL.GL_RGBA;
+      }
+    }
+            
+    pBuffer = impl.create(renderTarget, internalFormat, getWidth(), getHeight());
+    if (pBuffer == 0) {
+      throw new GLException("pbuffer creation error: CGL.createPBuffer() failed");
+    }
+        
+    if (DEBUG) {
+      System.err.println("Created pbuffer " + nw + " for " + this);
+    }
+  }
+
+  private int getNextPowerOf2(int number) {
+    if (((number-1) & number) == 0) {
+      //ex: 8 -> 0b1000; 8-1=7 -> 0b0111; 0b1000&0b0111 == 0
+      return number;
+    }
+    int power = 0;
+    while (number > 0) {
+      number = number>>1;
+      power++;
+    }
+    return (1<<power);
+  }
+
+  //---------------------------------------------------------------------------
+  // OpenGL "mode switching" functionality
+  //
+  private boolean haveSetOpenGLMode = false;
+  // FIXME: should consider switching the default mode based on
+  // whether the Java2D/JOGL bridge is active -- need to ask ourselves
+  // whether it's more likely that we will share with a GLCanvas or a
+  // GLJPanel when the bridge is turned on
+  private int     openGLMode = NSOPENGL_MODE;
+  // Implementation object (either NSOpenGL-based or CGL-based)
+  protected Impl impl;
+
+  public void setOpenGLMode(int mode) {
+    if (mode == openGLMode) {
+      return;
+    }
+    if (haveSetOpenGLMode) {
+      throw new GLException("Can't switch between using NSOpenGLPixelBuffer and CGLPBufferObj more than once");
+    }
+    destroy();
+    openGLMode = mode;
+    haveSetOpenGLMode = true;
+    if (DEBUG) {
+      System.err.println("Switching PBuffer drawable mode to " +
+                         ((mode == MacOSXCGLDrawable.NSOPENGL_MODE) ? "NSOPENGL_MODE" : "CGL_MODE"));
+    }
+    initOpenGLImpl();
+    createPbuffer();
+  }
+
+  public int getOpenGLMode() {
+    return openGLMode;
+  }
+
+  private void initOpenGLImpl() {
+    switch (openGLMode) {
+      case NSOPENGL_MODE:
+        impl = new NSOpenGLImpl();
+        break;
+      case CGL_MODE:
+        impl = new CGLImpl();
+        break;
+      default:
+        throw new InternalError("Illegal implementation mode " + openGLMode);
+    }
+  }
+
+  // Abstract interface for implementation of this drawable (either
+  // NSOpenGL-based or CGL-based)
+  interface Impl {
+    public long create(int renderTarget, int internalFormat, int width, int height);
+    public void destroy(long pbuffer);
+  }
+
+  // NSOpenGLPixelBuffer implementation
+  class NSOpenGLImpl implements Impl {
+    public long create(int renderTarget, int internalFormat, int width, int height) {
+      return CGL.createPBuffer(renderTarget, internalFormat, width, height);
+    }
+
+    public void destroy(long pbuffer) {
+      CGL.destroyPBuffer(0, pbuffer);
+    }
+  }
+
+  // CGL implementation
+  class CGLImpl implements Impl {
+    public long create(int renderTarget, int internalFormat, int width, int height) {
+      long[] pbuffer = new long[1];
+      int res = CGL.CGLCreatePBuffer(width, height, renderTarget, internalFormat, 0, pbuffer, 0);
+      if (res != CGL.kCGLNoError) {
+        throw new GLException("Error creating CGL-based pbuffer: error code " + res);
+      }
+      return pbuffer[0];
+    }
+
+    public void destroy(long pbuffer) {
+      int res = CGL.CGLDestroyPBuffer(pbuffer);
+      if (res != CGL.kCGLNoError) {
+        throw new GLException("Error destroying CGL-based pbuffer: error code " + res);
+      }
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/awt/MacOSXAWTCGLDrawableFactory.java b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/awt/MacOSXAWTCGLDrawableFactory.java
new file mode 100644
index 000000000..d100ab442
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/awt/MacOSXAWTCGLDrawableFactory.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.macosx.cgl.awt;
+
+import java.lang.reflect.InvocationTargetException;
+import java.nio.*;
+import java.util.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.opengl.impl.awt.*;
+import com.sun.opengl.impl.macosx.cgl.*;
+
+public class MacOSXAWTCGLDrawableFactory extends MacOSXCGLDrawableFactory {
+
+  public MacOSXAWTCGLDrawableFactory() {
+    super();
+  }
+
+  public boolean canCreateContextOnJava2DSurface() {
+    return true;
+  }
+
+  public GLContext createContextOnJava2DSurface(Object graphics, GLContext shareWith)
+    throws GLException {
+    return new MacOSXJava2DCGLContext(shareWith);
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/awt/MacOSXJava2DCGLContext.java b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/awt/MacOSXJava2DCGLContext.java
new file mode 100644
index 000000000..707d28ea8
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/macosx/cgl/awt/MacOSXJava2DCGLContext.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.macosx.cgl.awt;
+
+import com.sun.opengl.impl.macosx.cgl.*;
+
+import java.awt.Graphics;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.opengl.impl.awt.*;
+import com.sun.opengl.impl.macosx.cgl.*;
+
+/** MacOSXCGLContext implementation supporting the Java2D/JOGL bridge
+ * on Mac OS X. The external GLDrawable mechanism does not work on Mac
+ * OS X due to how drawables and contexts are operated upon on this
+ * platform, so it is necessary to supply an alternative means to
+ * create, make current, and destroy contexts on the Java2D "drawable"
+ * on the Mac platform.
+ */
+
+public class MacOSXJava2DCGLContext extends MacOSXCGLContext implements Java2DGLContext {
+  private Graphics graphics;
+
+  // FIXME: ignoring context sharing for the time being; will need to
+  // rethink this in particular if using FBOs to implement the
+  // Java2D/OpenGL pipeline on Mac OS X
+
+  public MacOSXJava2DCGLContext(GLContext shareWith) {
+    super(null, shareWith);
+  }
+
+  public void setGraphics(Graphics g) {
+    this.graphics = g;
+  }
+
+  protected int makeCurrentImpl() throws GLException {
+    boolean created = false;
+    if (nsContext == 0) {
+      if (!create()) {
+        return CONTEXT_NOT_CURRENT;
+      }
+      if (DEBUG) {
+        System.err.println("!!! Created GL nsContext for " + getClass().getName());
+      }
+      created = true;
+    }
+            
+    if (!Java2D.makeOGLContextCurrentOnSurface(graphics, nsContext)) {
+      throw new GLException("Error making context current");
+    }
+            
+    if (created) {
+      resetGLFunctionAvailability();
+      return CONTEXT_CURRENT_NEW;
+    }
+    return CONTEXT_CURRENT;
+  }
+
+  protected boolean create() {
+    // Find and configure share context
+    MacOSXCGLContext other = (MacOSXCGLContext) GLContextShareSet.getShareContext(this);
+    long share = 0;
+    if (other != null) {
+      // Reconfigure pbuffer-based GLContexts
+      if (other instanceof MacOSXPbufferCGLContext) {
+        MacOSXPbufferCGLContext ctx = (MacOSXPbufferCGLContext) other;
+        ctx.setOpenGLMode(MacOSXCGLDrawable.CGL_MODE);
+      } else {
+        if (other.getOpenGLMode() != MacOSXCGLDrawable.CGL_MODE) {
+          throw new GLException("Can't share between NSOpenGLContexts and CGLContextObjs");
+        }
+      }
+      share = other.getNSContext();
+      // Note we don't check for a 0 return value, since switching
+      // the context's mode causes it to be destroyed and not
+      // re-initialized until the next makeCurrent
+    }
+
+    if (DEBUG) {
+      System.err.println("!!! Share context is " + toHexString(share) + " for " + getClass().getName());
+    }
+
+    long ctx = Java2D.createOGLContextOnSurface(graphics, share);
+    if (ctx == 0) {
+      return false;
+    }
+    // FIXME: think about GLContext sharing
+    nsContext = ctx;
+    return true;
+  }
+
+  protected void releaseImpl() throws GLException {
+    // FIXME: would need another primitive in the Java2D class in
+    // order to implement this; hopefully should not matter for
+    // correctness
+  }
+
+  protected void destroyImpl() throws GLException {
+    if (nsContext != 0) {
+      Java2D.destroyOGLContext(nsContext);
+      if (DEBUG) {
+        System.err.println("!!! Destroyed OpenGL context " + nsContext);
+      }
+      nsContext = 0;
+      // FIXME
+      // GLContextShareSet.contextDestroyed(this);
+    }
+  }
+
+  public void setSwapInterval(int interval) {
+    // Not supported in this context implementation
+  }
+
+  public void setOpenGLMode(int mode) {
+    if (mode != MacOSXCGLDrawable.CGL_MODE)
+      throw new GLException("OpenGL mode switching not supported for Java2D GLContexts");
+  }
+
+  public int  getOpenGLMode() {
+    return MacOSXCGLDrawable.CGL_MODE;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/packrect/BackingStoreManager.java b/src/jogl/classes/com/sun/opengl/impl/packrect/BackingStoreManager.java
new file mode 100755
index 000000000..2ca5a5a7b
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/packrect/BackingStoreManager.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.packrect;
+
+/** This interface must be implemented by the end user and is called
+    in response to events like addition of rectangles into the
+    RectanglePacker. It is used both when a full re-layout must be
+    done as well as when the data in the backing store must be copied
+    to a new one. */
+
+public interface BackingStoreManager {
+  public Object allocateBackingStore(int w, int h);
+  public void   deleteBackingStore(Object backingStore);
+
+  /** Indication whether this BackingStoreManager supports compaction;
+      in other words, the allocation of a new backing store and
+      movement of the contents of the backing store from the old to
+      the new one. If it does not, then RectanglePacker.add() may
+      throw an exception if additionFailed() can not make enough room
+      available. If an implementation returns false, this also implies
+      that the backing store can not grow, so that preExpand() will
+      never be called. */
+  public boolean canCompact();
+
+  /** Notification that expansion of the backing store is about to be
+      done due to addition of the given rectangle. Gives the manager a
+      chance to do some compaction and potentially remove old entries
+      from the backing store, if it acts like a least-recently-used
+      cache. This method receives as argument the number of attempts
+      so far to add the given rectangle. Manager should return true if
+      the RectanglePacker should retry the addition (which may result
+      in this method being called again, with an increased attempt
+      number) or false if the RectanglePacker should just expand the
+      backing store. The caller should not call RectanglePacker.add()
+      in its preExpand() method. */
+  public boolean preExpand(Rect cause, int attemptNumber);
+
+  /** Notification that addition of the given Rect failed because a
+      maximum size was set in the RectanglePacker and the backing
+      store could not be expanded, or because compaction (and,
+      therefore, implicitly expansion) was not supported. Should
+      return false if the manager can do nothing more to handle the
+      failed addition, which will cause a RuntimeException to be
+      thrown from the RectanglePacker. */
+  public boolean additionFailed(Rect cause, int attemptNumber);
+
+  /** Notification that movement is starting. */
+  public void beginMovement(Object oldBackingStore, Object newBackingStore);
+
+  /** Tells the manager to move the contents of the given rect from
+      the old location on the old backing store to the new location on
+      the new backing store. The backing stores can be identical in
+      the case of compacting the existing backing store instead of
+      reallocating it. */
+  public void move(Object oldBackingStore,
+                   Rect   oldLocation,
+                   Object newBackingStore,
+                   Rect   newLocation);
+
+  /** Notification that movement is ending. */
+  public void endMovement(Object oldBackingStore, Object newBackingStore);
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/packrect/Level.java b/src/jogl/classes/com/sun/opengl/impl/packrect/Level.java
new file mode 100755
index 000000000..12a09cd9a
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/packrect/Level.java
@@ -0,0 +1,275 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.packrect;
+
+import java.util.*;
+
+public class Level {
+  private int width;
+  private int height;
+  private int yPos;
+  private LevelSet holder;
+
+  private List/*<Rect>*/ rects = new ArrayList/*<Rect>*/();
+  private List/*<Rect>*/ freeList;
+  private int nextAddX;
+
+  static class RectXComparator implements Comparator {
+    public int compare(Object o1, Object o2) {
+      Rect r1 = (Rect) o1;
+      Rect r2 = (Rect) o2;
+      return r1.x() - r2.x();
+    }
+
+    public boolean equals(Object obj) {
+      return this == obj;
+    }
+  }
+  private static final Comparator rectXComparator = new RectXComparator();
+
+  public Level(int width, int height, int yPos, LevelSet holder) {
+    this.width = width;
+    this.height = height;
+    this.yPos = yPos;
+    this.holder = holder;
+  }
+
+  public int w()    { return width;  }
+  public int h()    { return height; }
+  public int yPos() { return yPos;   }
+
+  /** Tries to add the given rectangle to this level only allowing
+      non-disruptive changes like trivial expansion of the last level
+      in the RectanglePacker and allocation from the free list. More
+      disruptive changes like compaction of the level must be
+      requested explicitly. */
+  public boolean add(Rect rect) {
+    if (rect.h() > height) {
+      // See whether it's worth trying to expand vertically
+      if (nextAddX + rect.w() > width) {
+        return false;
+      }
+
+      // See whether we're the last level and can expand
+      if (!holder.canExpand(this, rect.h())) {
+        return false;
+      }
+
+      // Trivially expand and try the allocation
+      holder.expand(this, height, rect.h());
+      height = rect.h();
+    }
+
+    // See whether we can add at the end
+    if (nextAddX + rect.w() <= width) {
+      rect.setPosition(nextAddX, yPos);
+      rects.add(rect);
+      nextAddX += rect.w();
+      return true;
+    }
+
+    // See whether we can add from the free list
+    if (freeList != null) {
+      Rect candidate = null;
+      for (Iterator iter = freeList.iterator(); iter.hasNext(); ) {
+        Rect cur = (Rect) iter.next();
+        if (cur.canContain(rect)) {
+          candidate = cur;
+          break;
+        }
+      }
+
+      if (candidate != null) {
+        // Remove the candidate from the free list
+        freeList.remove(candidate);
+        // Set up and add the real rect
+        rect.setPosition(candidate.x(), candidate.y());
+        rects.add(rect);
+        // Re-add any remaining free space
+        if (candidate.w() > rect.w()) {
+          candidate.setPosition(candidate.x() + rect.w(), candidate.y());
+          candidate.setSize(candidate.w() - rect.w(), height);
+          freeList.add(candidate);
+        }
+        
+        coalesceFreeList();
+
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /** Removes the given Rect from this Level. */
+  public boolean remove(Rect rect) {
+    if (!rects.remove(rect))
+      return false;
+
+    // If this is the rightmost rectangle, instead of adding its space
+    // to the free list, we can just decrease the nextAddX
+    if (rect.maxX() + 1 == nextAddX) {
+      nextAddX -= rect.w();
+    } else {
+      if (freeList == null) {
+        freeList = new ArrayList/*<Rect>*/();
+      }
+      freeList.add(new Rect(rect.x(), rect.y(), rect.w(), height, null));
+      coalesceFreeList();
+    }
+
+    return true;
+  }
+
+  /** Indicates whether this Level contains no rectangles. */
+  public boolean isEmpty() {
+    return rects.isEmpty();
+  }
+
+  /** Indicates whether this Level could satisfy an allocation request
+      if it were compacted. */
+  public boolean couldAllocateIfCompacted(Rect rect) {
+    if (rect.h() > height)
+      return false;
+    if (freeList == null)
+      return false;
+    int freeListWidth = 0;
+    for (Iterator iter = freeList.iterator(); iter.hasNext(); ) {
+      Rect cur = (Rect) iter.next();
+      freeListWidth += cur.w();
+    }
+    // Add on the remaining space at the end
+    freeListWidth += (width - nextAddX);
+    return (freeListWidth >= rect.w());
+  }
+
+  public void compact(Object backingStore, BackingStoreManager manager) {
+    Collections.sort(rects, rectXComparator);
+    int nextCompactionDest = 0;
+    manager.beginMovement(backingStore, backingStore);
+    for (Iterator iter = rects.iterator(); iter.hasNext(); ) {
+      Rect cur = (Rect) iter.next();
+      if (cur.x() != nextCompactionDest) {
+        manager.move(backingStore, cur,
+                     backingStore, new Rect(nextCompactionDest, cur.y(), cur.w(), cur.h(), null));
+        cur.setPosition(nextCompactionDest, cur.y());
+      }
+      nextCompactionDest += cur.w();
+    }
+    nextAddX = nextCompactionDest;
+    freeList.clear();
+    manager.endMovement(backingStore, backingStore);
+  }
+
+  public Iterator iterator() {
+    return rects.iterator();
+  }
+
+  /** Visits all Rects contained in this Level. */
+  public void visit(RectVisitor visitor) {
+    for (Iterator iter = rects.iterator(); iter.hasNext(); ) {
+      Rect rect = (Rect) iter.next();
+      visitor.visit(rect);
+    }
+  }
+
+  /** Updates the references to the Rect objects in this Level with
+      the "next locations" of those Rects. This is actually used to
+      update the new Rects in a newly laid-out LevelSet with the
+      original Rects. */
+  public void updateRectangleReferences() {
+    for (int i = 0; i < rects.size(); i++) {
+      Rect cur = (Rect) rects.get(i);
+      Rect next = cur.getNextLocation();
+      next.setPosition(cur.x(), cur.y());
+      if (cur.w() != next.w() || cur.h() != next.h())
+        throw new RuntimeException("Unexpected disparity in rectangle sizes during updateRectangleReferences");
+      rects.set(i, next);
+    }
+  }
+
+  private void coalesceFreeList() {
+    if (freeList == null)
+      return;
+    if (freeList.isEmpty())
+      return;
+
+    // Try to coalesce adjacent free blocks in the free list
+    Collections.sort(freeList, rectXComparator);
+    int i = 0;
+    while (i < freeList.size() - 1) {
+      Rect r1 = (Rect) freeList.get(i);
+      Rect r2 = (Rect) freeList.get(i+1);
+      if (r1.maxX() + 1 == r2.x()) {
+        // Coalesce r1 and r2 into one block
+        freeList.remove(i+1);
+        r1.setSize(r1.w() + r2.w(), r1.h());
+      } else {
+        ++i;
+      }
+    }
+    // See whether the last block bumps up against the addition point
+    Rect last = (Rect) freeList.get(freeList.size() - 1);
+    if (last.maxX() + 1 == nextAddX) {
+      nextAddX -= last.w();
+      freeList.remove(freeList.size() - 1);
+    }
+    if (freeList.isEmpty()) {
+      freeList = null;
+    }
+  }
+
+  //----------------------------------------------------------------------
+  // Debugging functionality
+  //
+
+  public void dumpFreeSpace() {
+    int freeListWidth = 0;
+    for (Iterator iter = freeList.iterator(); iter.hasNext(); ) {
+      Rect cur = (Rect) iter.next();
+      System.err.println(" Free rectangle at " + cur);
+      freeListWidth += cur.w();
+    }
+    // Add on the remaining space at the end
+    System.err.println(" Remaining free space " + (width - nextAddX));
+    freeListWidth += (width - nextAddX);
+    System.err.println(" Total free space " + freeListWidth);
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/packrect/LevelSet.java b/src/jogl/classes/com/sun/opengl/impl/packrect/LevelSet.java
new file mode 100755
index 000000000..97a1f2e74
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/packrect/LevelSet.java
@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.packrect;
+
+import java.util.*;
+
+/** Manages a list of Levels; this is the core data structure
+    contained within the RectanglePacker and encompasses the storage
+    algorithm for the contained Rects. */
+
+public class LevelSet {
+  // Maintained in sorted order by increasing Y coordinate
+  private List/*<Level>*/ levels = new ArrayList/*<Level>*/();
+  private int nextAddY;
+  private int w;
+  private int h;
+
+  /** A LevelSet manages all of the backing store for a region of a
+      specified width and height. */
+  public LevelSet(int w, int h) {
+    this.w = w;
+    this.h = h;
+  }
+
+  public int w() { return w; }
+  public int h() { return h; }
+
+  /** Returns true if the given rectangle was successfully added to
+      the LevelSet given its current dimensions, false if not. Caller
+      is responsible for performing compaction, expansion, etc. as a
+      consequence. */
+  public boolean add(Rect rect) {
+    if (rect.w() > w)
+      return false;
+
+    // Go in reverse order through the levels seeing whether we can
+    // trivially satisfy the allocation request
+    for (int i = levels.size() - 1; i >= 0; --i) {
+      Level level = (Level) levels.get(i);
+      if (level.add(rect))
+        return true;
+    }
+
+    // See whether compaction could satisfy this allocation. This
+    // increases the computational complexity of the addition process,
+    // but prevents us from expanding unnecessarily.
+    for (int i = levels.size() - 1; i >= 0; --i) {
+      Level level = (Level) levels.get(i);
+      if (level.couldAllocateIfCompacted(rect))
+        return false;
+    }
+
+    // OK, we need to either add a new Level or expand the backing
+    // store. Try to add a new Level.
+    if (nextAddY + rect.h() > h)
+      return false;
+
+    Level newLevel = new Level(w, rect.h(), nextAddY, this);
+    levels.add(newLevel);
+    nextAddY += rect.h();
+    boolean res = newLevel.add(rect);
+    if (!res)
+      throw new RuntimeException("Unexpected failure in addition to new Level");
+    return true;
+  }
+
+  /** Removes the given Rect from this LevelSet. */
+  public boolean remove(Rect rect) {
+    for (int i = levels.size() - 1; i >= 0; --i) {
+      Level level = (Level) levels.get(i);
+      if (level.remove(rect))
+        return true;
+    }
+    
+    return false;
+  }
+
+  /** Allocates the given Rectangle, performing compaction of a Level
+      if necessary. This is the correct fallback path to {@link
+      #add(Rect)} above. Returns true if allocated successfully, false
+      otherwise (indicating the need to expand the backing store). */
+  public boolean compactAndAdd(Rect rect,
+                               Object backingStore,
+                               BackingStoreManager manager) {
+    for (int i = levels.size() - 1; i >= 0; --i) {
+      Level level = (Level) levels.get(i);
+      if (level.couldAllocateIfCompacted(rect)) {
+        level.compact(backingStore, manager);
+        boolean res = level.add(rect);
+        if (!res)
+          throw new RuntimeException("Unexpected failure to add after compaction");
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /** Indicates whether it's legal to trivially increase the height of
+      the given Level. This is only possible if it's the last Level
+      added and there's enough room in the backing store. */
+  public boolean canExpand(Level level, int height) {
+    if (levels.isEmpty())
+      return false; // Should not happen
+    if (levels.get(levels.size() - 1) == level &&
+        (h - nextAddY >= height - level.h()))
+      return true;
+    return false;
+  }
+
+  public void expand(Level level, int oldHeight, int newHeight) {
+    nextAddY += (newHeight - oldHeight);
+  }
+
+  /** Gets the used height of the levels in this LevelSet. */
+  public int getUsedHeight() {
+    return nextAddY;
+  }
+
+  /** Sets the height of this LevelSet. It is only legal to reduce the
+      height to greater than or equal to the currently used height. */
+  public void setHeight(int height) throws IllegalArgumentException {
+    if (height < getUsedHeight()) {
+      throw new IllegalArgumentException("May not reduce height below currently used height");
+    }
+    h = height;
+  }
+
+  /** Returns the vertical fragmentation ratio of this LevelSet. This
+      is defined as the ratio of the sum of the heights of all
+      completely empty Levels divided by the overall used height of
+      the LevelSet. A high vertical fragmentation ratio indicates that
+      it may be profitable to perform a compaction. */
+  public float verticalFragmentationRatio() {
+    int freeHeight = 0;
+    int usedHeight = getUsedHeight();
+    if (usedHeight == 0)
+      return 0.0f;
+    for (Iterator iter = iterator(); iter.hasNext(); ) {
+      Level level = (Level) iter.next();
+      if (level.isEmpty()) {
+        freeHeight += level.h();
+      }
+    }
+    return (float) freeHeight / (float) usedHeight;
+  }
+
+  public Iterator iterator() {
+    return levels.iterator();
+  }
+
+  /** Visits all Rects contained in this LevelSet. */
+  public void visit(RectVisitor visitor) {
+    for (Iterator iter = levels.iterator(); iter.hasNext(); ) {
+      Level level = (Level) iter.next();
+      level.visit(visitor);
+    }
+  }
+
+  /** Updates the references to the Rect objects in this LevelSet with
+      the "next locations" of those Rects. This is actually used to
+      update the new Rects in a newly laid-out LevelSet with the
+      original Rects. */
+  public void updateRectangleReferences() {
+    for (Iterator iter = levels.iterator(); iter.hasNext(); ) {
+      Level level = (Level) iter.next();
+      level.updateRectangleReferences();
+    }
+  }
+
+  /** Clears out all Levels stored in this LevelSet. */
+  public void clear() {
+    levels.clear();
+    nextAddY = 0;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/packrect/Rect.java b/src/jogl/classes/com/sun/opengl/impl/packrect/Rect.java
new file mode 100755
index 000000000..f47660e94
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/packrect/Rect.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.packrect;
+
+/** Represents a rectangular region on the backing store. The edges of
+    the rectangle are the infinitely thin region between adjacent
+    pixels on the screen. The origin of the rectangle is its
+    upper-left corner. It is inclusive of the pixels on the top and
+    left edges and exclusive of the pixels on the bottom and right
+    edges. For example, a rect at position (0, 0) and of size (1, 1)
+    would include only the pixel at (0, 0). <P>
+
+    Negative coordinates and sizes are not supported, since they make
+    no sense in the context of the packer, which deals only with
+    positively sized regions. <P>
+
+    This class contains a user data field for efficient hookup to
+    external data structures as well as enough other hooks to
+    efficiently plug into the rectangle packer. */
+
+public class Rect {
+  private int x;
+  private int y;
+  private int w;
+  private int h;
+
+  // The level we're currently installed in in the parent
+  // RectanglePacker, or null if not hooked in to the table yet
+  private Level level;
+
+  // The user's object this rectangle represents.
+  private Object userData;
+
+  // Used transiently during re-layout of the backing store (when
+  // there is no room left due either to fragmentation or just being
+  // out of space)
+  private Rect nextLocation;
+  
+  public Rect() {
+    this(null);
+  }
+
+  public Rect(Object userData) {
+    this(0, 0, 0, 0, userData);
+  }
+
+  public Rect(int x, int y, int w, int h, Object userData) {
+    setPosition(x, y);
+    setSize(w, h);
+    setUserData(userData);
+  }
+
+  public int x() { return x; }
+  public int y() { return y; }
+  public int w() { return w; }
+  public int h() { return h; }
+  public Object getUserData() { return userData; }
+  public Rect getNextLocation() { return nextLocation; }
+
+  public void setPosition(int x, int y) {
+    if (x < 0)
+      throw new IllegalArgumentException("Negative x");
+    if (y < 0)
+      throw new IllegalArgumentException("Negative y");
+    this.x = x;
+    this.y = y;
+  }
+
+  public void setSize(int w, int h) throws IllegalArgumentException {
+    if (w < 0)
+      throw new IllegalArgumentException("Negative width");
+    if (h < 0)
+      throw new IllegalArgumentException("Negative height");
+    this.w = w;
+    this.h = h;
+  }
+
+  public void setUserData(Object obj) { userData = obj; }
+  public void setNextLocation(Rect nextLocation) { this.nextLocation = nextLocation; }
+
+  // Helpers for computations.
+
+  /** Returns the maximum x-coordinate contained within this
+      rectangle. Note that this returns a different result than Java
+      2D's rectangles; for a rectangle of position (0, 0) and size (1,
+      1) this will return 0, not 1. Returns -1 if the width of this
+      rectangle is 0. */
+  public int maxX() {
+    if (w() < 1)
+      return -1;
+    return x() + w() - 1;
+  }
+
+  /** Returns the maximum y-coordinate contained within this
+      rectangle. Note that this returns a different result than Java
+      2D's rectangles; for a rectangle of position (0, 0) and size (1,
+      1) this will return 0, not 1. Returns -1 if the height of this
+      rectangle is 0. */
+  public int maxY() {
+    if (h() < 1)
+      return -1;
+    return y() + h() - 1;
+  }
+
+  public boolean canContain(Rect other) {
+    return (w() >= other.w() &&
+            h() >= other.h());
+  }
+
+  public String toString() {
+    return "[Rect x: " + x() + " y: " + y() + " w: " + w() + " h: " + h() + "]";
+  }
+
+  // Unclear whether it's a good idea to override hashCode and equals
+  // for these objects
+  /*
+  public boolean equals(Object other) {
+    if (other == null || (!(other instanceof Rect))) {
+      return false;
+    }
+
+    Rect r = (Rect) other;
+    return (this.x() == r.x() &&
+            this.y() == r.y() &&
+            this.w() == r.w() &&
+            this.h() == r.h());
+  }
+
+  public int hashCode() {
+    return (x + y * 13 + w * 17 + h * 23);
+  }
+  */
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/packrect/RectVisitor.java b/src/jogl/classes/com/sun/opengl/impl/packrect/RectVisitor.java
new file mode 100755
index 000000000..6474f204e
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/packrect/RectVisitor.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.packrect;
+
+/** Iteration construct without exposing the internals of the
+    RectanglePacker and without implementing a complex Iterator. */
+
+public interface RectVisitor {
+  public void visit(Rect rect);
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/packrect/RectanglePacker.java b/src/jogl/classes/com/sun/opengl/impl/packrect/RectanglePacker.java
new file mode 100755
index 000000000..8520484cf
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/packrect/RectanglePacker.java
@@ -0,0 +1,306 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.packrect;
+
+import java.util.*;
+
+/** Packs rectangles supplied by the user (typically representing
+    image regions) into a larger backing store rectangle (typically
+    representing a large texture). Supports automatic compaction of
+    the space on the backing store, and automatic expansion of the
+    backing store, when necessary. */
+
+public class RectanglePacker {
+  private BackingStoreManager manager;
+  private Object backingStore;
+  private LevelSet levels;
+  private float EXPANSION_FACTOR = 0.5f;
+  private float SHRINK_FACTOR = 0.3f;
+
+  private int initialWidth;
+  private int initialHeight;
+
+  private int maxWidth  = -1;
+  private int maxHeight = -1;
+
+  static class RectHComparator implements Comparator {
+    public int compare(Object o1, Object o2) {
+      Rect r1 = (Rect) o1;
+      Rect r2 = (Rect) o2;
+      return r2.h() - r1.h();
+    }
+
+    public boolean equals(Object obj) {
+      return this == obj;
+    }
+  }
+  private static final Comparator rectHComparator = new RectHComparator();
+
+  public RectanglePacker(BackingStoreManager manager,
+                         int initialWidth,
+                         int initialHeight) {
+    this.manager = manager;
+    levels = new LevelSet(initialWidth, initialHeight);
+    this.initialWidth = initialWidth;
+    this.initialHeight = initialHeight;
+  }
+
+  public Object getBackingStore() {
+    if (backingStore == null) {
+      backingStore = manager.allocateBackingStore(levels.w(), levels.h());
+    }
+
+    return backingStore;
+  }
+
+  /** Sets up a maximum width and height for the backing store. These
+      are optional and if not specified the backing store will grow as
+      necessary. Setting up a maximum width and height introduces the
+      possibility that additions will fail; these are handled with the
+      BackingStoreManager's allocationFailed notification. */
+  public void setMaxSize(int maxWidth, int maxHeight) {
+    this.maxWidth  = maxWidth;
+    this.maxHeight = maxHeight;
+  }
+
+  /** Decides upon an (x, y) position for the given rectangle (leaving
+      its width and height unchanged) and places it on the backing
+      store. May provoke re-layout of other Rects already added. If
+      the BackingStoreManager does not support compaction, and {@link
+      BackingStoreManager#preExpand BackingStoreManager.preExpand}
+      does not clear enough space for the incoming rectangle, then
+      this method will throw a RuntimeException. */
+  public void add(Rect rect) throws RuntimeException {
+    // Allocate backing store if we don't have any yet
+    if (backingStore == null)
+      backingStore = manager.allocateBackingStore(levels.w(), levels.h());
+
+    int attemptNumber = 0;
+    boolean tryAgain = false;
+
+    do {
+      // Try to allocate
+      if (levels.add(rect))
+        return;
+
+      if (manager.canCompact()) {
+        // Try to allocate with horizontal compaction
+        if (levels.compactAndAdd(rect, backingStore, manager))
+          return;
+        // Let the manager have a chance at potentially evicting some entries
+        tryAgain = manager.preExpand(rect, attemptNumber++);
+      } else {
+        tryAgain = manager.additionFailed(rect, attemptNumber++);
+      }
+    } while (tryAgain);
+
+    if (!manager.canCompact()) {
+      throw new RuntimeException("BackingStoreManager does not support compaction or expansion, and didn't clear space for new rectangle");
+    }
+
+    compactImpl(rect);
+
+    // Retry the addition of the incoming rectangle
+    add(rect);
+    // Done
+  }
+
+  /** Removes the given rectangle from this RectanglePacker. */
+  public void remove(Rect rect) {
+    levels.remove(rect);
+  }
+
+  /** Visits all Rects contained in this RectanglePacker. */
+  public void visit(RectVisitor visitor) {
+    levels.visit(visitor);
+  }
+
+  /** Returns the vertical fragmentation ratio of this
+      RectanglePacker. This is defined as the ratio of the sum of the
+      heights of all completely empty Levels divided by the overall
+      used height of the LevelSet. A high vertical fragmentation ratio
+      indicates that it may be profitable to perform a compaction. */
+  public float verticalFragmentationRatio() {
+    return levels.verticalFragmentationRatio();
+  }
+
+  /** Forces a compaction cycle, which typically results in allocating
+      a new backing store and copying all entries to it. */
+  public void compact() {
+    compactImpl(null);
+  }
+
+  // The "cause" rect may be null
+  private void compactImpl(Rect cause) {
+    // Have to either expand, compact or both. Need to figure out what
+    // direction to go. Prefer to expand vertically. Expand
+    // horizontally only if rectangle being added is too wide. FIXME:
+    // may want to consider rebalancing the width and height to be
+    // more equal if it turns out we keep expanding in the vertical
+    // direction.
+    boolean done = false;
+    int newWidth = levels.w();
+    int newHeight = levels.h();
+    LevelSet nextLevelSet = null;
+    int attemptNumber = 0;
+    boolean needAdditionFailureNotification = false;
+
+    while (!done) {
+      if (cause != null) {
+        if (cause.w() > newWidth) {
+          newWidth = cause.w();
+        } else {
+          newHeight = (int) (newHeight * (1.0f + EXPANSION_FACTOR));
+        }
+      }
+
+      // Clamp to maximum values
+      needAdditionFailureNotification = false;
+      if (maxWidth > 0 && newWidth > maxWidth) {
+        newWidth = maxWidth;
+        needAdditionFailureNotification = true;
+      }
+      if (maxHeight > 0 && newHeight > maxHeight) {
+        newHeight = maxHeight;
+        needAdditionFailureNotification = true;
+      }
+
+      nextLevelSet = new LevelSet(newWidth, newHeight);
+      
+      // Make copies of all existing rectangles
+      List/*<Rect>*/ newRects = new ArrayList/*<Rect>*/();
+      for (Iterator i1 = levels.iterator(); i1.hasNext(); ) {
+        Level level = (Level) i1.next();
+        for (Iterator i2 = level.iterator(); i2.hasNext(); ) {
+          Rect cur = (Rect) i2.next();
+          Rect newRect = new Rect(0, 0, cur.w(), cur.h(), null);
+          cur.setNextLocation(newRect);
+          // Hook up the reverse mapping too for easier replacement
+          newRect.setNextLocation(cur);
+          newRects.add(newRect);
+        }
+      }
+      // Sort them by decreasing height (note: this isn't really
+      // guaranteed to improve the chances of a successful layout)
+      Collections.sort(newRects, rectHComparator);
+      // Try putting all of these rectangles into the new level set
+      done = true;
+      for (Iterator iter = newRects.iterator(); iter.hasNext(); ) {
+        if (!nextLevelSet.add((Rect) iter.next())) {
+          done = false;
+          break;
+        }
+      }
+
+      if (done && cause != null) {
+        // Try to add the new rectangle as well
+        if (nextLevelSet.add(cause)) {
+          // We're OK
+        } else {
+          done = false;
+        }
+      }
+
+      // Don't send addition failure notifications if we're only doing
+      // a compaction
+      if (!done && needAdditionFailureNotification && cause != null) {
+        manager.additionFailed(cause, attemptNumber);
+      }
+      ++attemptNumber;
+    }
+
+    // See whether the implicit compaction that just occurred has
+    // yielded excess empty space.
+    if (nextLevelSet.getUsedHeight() > 0 &&
+        nextLevelSet.getUsedHeight() < nextLevelSet.h() * SHRINK_FACTOR) {
+      int shrunkHeight = Math.max(initialHeight,
+                                  (int) (nextLevelSet.getUsedHeight() * (1.0f + EXPANSION_FACTOR)));
+      if (maxHeight > 0 && shrunkHeight > maxHeight) {
+        shrunkHeight = maxHeight;
+      }
+      nextLevelSet.setHeight(shrunkHeight);
+    }
+
+    // If we temporarily added the new rectangle to the new LevelSet,
+    // take it out since we don't "really" add it here but in add(), above
+    if (cause != null) {
+      nextLevelSet.remove(cause);
+    }
+
+    // OK, now we have a new layout and a mapping from the old to the
+    // new locations of rectangles on the backing store. Allocate a
+    // new backing store, move the contents over and deallocate the
+    // old one.
+    Object newBackingStore = manager.allocateBackingStore(nextLevelSet.w(),
+                                                          nextLevelSet.h());
+    manager.beginMovement(backingStore, newBackingStore);
+    for (Iterator i1 = levels.iterator(); i1.hasNext(); ) {
+      Level level = (Level) i1.next();
+      for (Iterator i2 = level.iterator(); i2.hasNext(); ) {
+        Rect cur = (Rect) i2.next();
+        manager.move(backingStore, cur,
+                     newBackingStore, cur.getNextLocation());
+      }
+    }
+    // Replace references to temporary rectangles with original ones
+    nextLevelSet.updateRectangleReferences();
+    manager.endMovement(backingStore, newBackingStore);
+    // Now delete the old backing store
+    manager.deleteBackingStore(backingStore);
+    // Update to new versions of backing store and LevelSet
+    backingStore = newBackingStore;
+    levels = nextLevelSet;
+  }
+
+  /** Clears all Rects contained in this RectanglePacker. */
+  public void clear() {
+    levels.clear();
+  }
+
+  /** Disposes the backing store allocated by the
+      BackingStoreManager. This RectanglePacker may no longer be used
+      after calling this method. */
+  public void dispose() {
+    if (backingStore != null)
+      manager.deleteBackingStore(backingStore);
+    backingStore = null;
+    levels = null;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/packrect/package.html b/src/jogl/classes/com/sun/opengl/impl/packrect/package.html
new file mode 100755
index 000000000..7f2522244
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/packrect/package.html
@@ -0,0 +1,7 @@
+This package implements a rectangle packing algorithm suitable for
+tracking the placement of multiple rectangles inside a larger one. It
+is useful for cases such as placing the contents of multiple windows
+on a larger backing store texture for a compositing window manager;
+placing multiple rasterized strings in a texture map for quick
+rendering to the screen; and many other situations where it is useful
+to carve up a larger texture into smaller pieces dynamically. <P>
diff --git a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsDummyWGLDrawable.java b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsDummyWGLDrawable.java
new file mode 100644
index 000000000..1f1359269
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsDummyWGLDrawable.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.windows.wgl;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.nwi.impl.NullWindow;
+
+public class WindowsDummyWGLDrawable extends WindowsWGLDrawable {
+  private long hwnd, hdc;
+
+  public WindowsDummyWGLDrawable(GLDrawableFactory factory) {
+    super(factory, new NullWindow(), true, new NWCapabilities(), null);
+    // All entries to CreateDummyWindow must synchronize on one object
+    // to avoid accidentally registering the dummy window class twice
+    synchronized (WindowsDummyWGLDrawable.class) {
+      hwnd = WGL.CreateDummyWindow(0, 0, 1, 1);
+    }
+    hdc = WGL.GetDC(hwnd);
+    NullWindow nw = (NullWindow) getNativeWindow();
+    nw.setSurfaceHandle(hdc);
+    // Choose a (hopefully hardware-accelerated) OpenGL pixel format for this device context
+    NWCapabilities caps = new NWCapabilities();
+    caps.setDepthBits(16);
+    PIXELFORMATDESCRIPTOR pfd = glCapabilities2PFD(caps, true);
+    int pixelFormat = WGL.ChoosePixelFormat(hdc, pfd);
+    if ((pixelFormat == 0) ||
+        (!WGL.SetPixelFormat(hdc, pixelFormat, pfd))) {
+      destroy();
+    }
+  }
+
+  public void setSize(int width, int height) {
+  }
+
+  public int getWidth() {
+    return 1;
+  }
+
+  public int getHeight() {
+    return 1;
+  }
+
+  public GLContext createContext(GLContext shareWith) {
+    if (hdc == 0) {
+      // Construction failed
+      return null;
+    }
+    // FIXME: figure out how to hook back in the Java 2D / JOGL bridge
+    return new WindowsWGLContext(this, shareWith);
+  }
+
+  public void destroy() {
+    if (hdc != 0) {
+      WGL.ReleaseDC(hwnd, hdc);
+      hdc = 0;
+    }
+    if (hwnd != 0) {
+      WGL.ShowWindow(hwnd, WGL.SW_HIDE);
+      WGL.DestroyWindow(hwnd);
+      hwnd = 0;
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsExternalWGLContext.java b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsExternalWGLContext.java
new file mode 100755
index 000000000..493b38061
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsExternalWGLContext.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.windows.wgl;
+
+import java.nio.*;
+import java.util.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public class WindowsExternalWGLContext extends WindowsWGLContext {
+  private boolean firstMakeCurrent = true;
+  private boolean created = true;
+  private GLContext lastContext;
+
+  public WindowsExternalWGLContext() {
+    // FIXME: figure out how to hook back in the Java 2D / JOGL bridge
+    super(null, null);
+    hglrc = WGL.wglGetCurrentContext();
+    if (hglrc == 0) {
+      throw new GLException("Error: attempted to make an external GLContext without a drawable/context current");
+    }
+    if (DEBUG) {
+      System.err.println(getThreadName() + ": !!! Created external OpenGL context " + toHexString(hglrc) + " for " + this);
+    }
+    GLContextShareSet.contextCreated(this);
+    resetGLFunctionAvailability();
+  }
+
+  public int makeCurrent() throws GLException {
+    // Save last context if necessary to allow external GLContexts to
+    // talk to other GLContexts created by this library
+    GLContext cur = getCurrent();
+    if (cur != null && cur != this) {
+      lastContext = cur;
+      setCurrent(null);
+    }
+    return super.makeCurrent();
+  }  
+
+  public void release() throws GLException {
+    super.release();
+    setCurrent(lastContext);
+    lastContext = null;
+  }
+
+  protected int makeCurrentImpl() throws GLException {
+    if (firstMakeCurrent) {
+      firstMakeCurrent = false;
+      return CONTEXT_CURRENT_NEW;
+    }
+    return CONTEXT_CURRENT;
+  }
+
+  protected void releaseImpl() throws GLException {
+  }
+
+  protected void destroyImpl() throws GLException {
+    created = false;
+    GLContextShareSet.contextDestroyed(this);
+  }
+
+  public boolean isCreated() {
+    return created;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsExternalWGLDrawable.java b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsExternalWGLDrawable.java
new file mode 100755
index 000000000..4a16749e3
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsExternalWGLDrawable.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.windows.wgl;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.nwi.impl.NullWindow;
+
+public class WindowsExternalWGLDrawable extends WindowsWGLDrawable {
+
+  public WindowsExternalWGLDrawable(GLDrawableFactory factory, NativeWindow component) {
+    super(factory, component, true, new NWCapabilities(), null);
+  }
+
+  public static WindowsExternalWGLDrawable create(GLDrawableFactory factory) {
+    long hdc = WGL.wglGetCurrentDC();
+    NullWindow nw = new NullWindow();
+    nw.setSurfaceHandle(hdc);
+    if (nw.getSurfaceHandle() == 0) {
+      throw new GLException("Error: attempted to make an external GLDrawable without a drawable/context current");
+    }
+    return new WindowsExternalWGLDrawable(factory, nw);
+  }
+
+  public GLContext createContext(GLContext shareWith) {
+    return new WindowsWGLContext(this, shareWith);
+  }
+  
+  public void setSize(int newWidth, int newHeight) {
+    throw new GLException("Should not call this");
+  }
+
+  public int getWidth() {
+    throw new GLException("Should not call this");
+  }  
+
+  public int getHeight() {
+    throw new GLException("Should not call this");
+  }  
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsOffscreenWGLContext.java b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsOffscreenWGLContext.java
new file mode 100644
index 000000000..9f0a5d2a6
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsOffscreenWGLContext.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.windows.wgl;
+
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public class WindowsOffscreenWGLContext extends WindowsWGLContext {
+  public WindowsOffscreenWGLContext(WindowsOffscreenWGLDrawable drawable,
+                                   GLContext shareWith) {
+    super(drawable, shareWith);
+  }
+
+  public int getOffscreenContextPixelDataType() {
+      return GL.GL_UNSIGNED_BYTE;
+  }
+  
+  public int getOffscreenContextReadBuffer() {
+    // On Windows these contexts are always single-buffered
+    return GL.GL_FRONT;
+  }
+
+  public boolean offscreenImageNeedsVerticalFlip() {
+    // We can take care of this in the DIB creation (see below)
+    return false;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsOffscreenWGLDrawable.java b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsOffscreenWGLDrawable.java
new file mode 100644
index 000000000..6318d1d26
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsOffscreenWGLDrawable.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.windows.wgl;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.nwi.impl.NullWindow;
+
+public class WindowsOffscreenWGLDrawable extends WindowsWGLDrawable {
+  private long origbitmap;
+  private long hbitmap;
+
+  public WindowsOffscreenWGLDrawable(GLDrawableFactory factory, 
+                                     NWCapabilities requestedCapabilities,
+                                     NWCapabilitiesChooser chooser,
+                                     int width,
+                                     int height) {
+    super(factory, new NullWindow(), true, requestedCapabilities, chooser);
+    ((NullWindow) getNativeWindow()).setSize(width, height);
+    create();
+  }
+
+  public GLContext createContext(GLContext shareWith) {
+    return new WindowsOffscreenWGLContext(this, shareWith);
+  }
+
+  private void create() {
+    NullWindow nw = (NullWindow) getNativeWindow();
+    NWCapabilities capabilities = getRequestedNWCapabilities();
+    int width = getWidth();
+    int height = getHeight();
+    BITMAPINFO info = BITMAPINFO.create();
+    BITMAPINFOHEADER header = info.bmiHeader();
+    int bitsPerPixel = (capabilities.getRedBits() +
+                        capabilities.getGreenBits() +
+                        capabilities.getBlueBits());
+    header.biSize(header.size());
+    header.biWidth(width);
+    // NOTE: negating the height causes the DIB to be in top-down row
+    // order rather than bottom-up; ends up being correct during pixel
+    // readback
+    header.biHeight(-1 * height);
+    header.biPlanes((short) 1);
+    header.biBitCount((short) bitsPerPixel);
+    header.biXPelsPerMeter(0);
+    header.biYPelsPerMeter(0);
+    header.biClrUsed(0);
+    header.biClrImportant(0);
+    header.biCompression(WGL.BI_RGB);
+    header.biSizeImage(width * height * bitsPerPixel / 8);
+
+    long hdc = WGL.CreateCompatibleDC(0);
+    if (hdc == 0) {
+      System.out.println("LastError: " + WGL.GetLastError());
+      throw new GLException("Error creating device context for offscreen OpenGL context");
+    }
+    nw.setSurfaceHandle(hdc);
+
+    hbitmap = WGL.CreateDIBSection(hdc, info, WGL.DIB_RGB_COLORS, 0, 0, 0);
+    if (hbitmap == 0) {
+      WGL.DeleteDC(hdc);
+      hdc = 0;
+      throw new GLException("Error creating offscreen bitmap of width " + width +
+                            ", height " + height);
+    }
+    if ((origbitmap = WGL.SelectObject(hdc, hbitmap)) == 0) {
+      WGL.DeleteObject(hbitmap);
+      hbitmap = 0;
+      WGL.DeleteDC(hdc);
+      hdc = 0;
+      throw new GLException("Error selecting bitmap into new device context");
+    }
+        
+    choosePixelFormat(false);
+  }
+  
+  public void destroy() {
+    NullWindow nw = (NullWindow) getNativeWindow();
+    if (nw.getSurfaceHandle() != 0) {
+      // Must destroy bitmap and device context
+      WGL.SelectObject(nw.getSurfaceHandle(), origbitmap);
+      WGL.DeleteObject(hbitmap);
+      WGL.DeleteDC(nw.getSurfaceHandle());
+      origbitmap = 0;
+      hbitmap = 0;
+      nw.setSurfaceHandle(0);
+      setChosenNWCapabilities(null);
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsOnscreenWGLContext.java b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsOnscreenWGLContext.java
new file mode 100644
index 000000000..7eb96c7dc
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsOnscreenWGLContext.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.windows.wgl;
+
+import java.util.*;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public class WindowsOnscreenWGLContext extends WindowsWGLContext {
+  protected WindowsOnscreenWGLDrawable drawable;
+
+  public WindowsOnscreenWGLContext(WindowsOnscreenWGLDrawable drawable,
+                                  GLContext shareWith) {
+    super(drawable, shareWith);
+    this.drawable = drawable;
+  }
+  
+  protected int makeCurrentImpl() throws GLException {
+    int lockRes = drawable.lockSurface();
+    boolean exceptionOccurred = false;
+    try {
+      if (lockRes == NativeWindow.LOCK_SURFACE_NOT_READY) {
+        return CONTEXT_NOT_CURRENT;
+      }
+      if (lockRes == NativeWindow.LOCK_SURFACE_CHANGED) {
+        destroyImpl();
+      }
+      int ret = super.makeCurrentImpl();
+      return ret;
+    } catch (RuntimeException e) {
+      exceptionOccurred = true;
+      throw e;
+    } finally {
+      if (exceptionOccurred ||
+          (isOptimizable() && lockRes != NativeWindow.LOCK_SURFACE_NOT_READY)) {
+        drawable.unlockSurface();
+      }
+    }
+  }
+
+  protected void releaseImpl() throws GLException {
+    try {
+      super.releaseImpl();
+    } finally {
+      if (!isOptimizable()) {
+        drawable.unlockSurface();
+      }
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsOnscreenWGLDrawable.java b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsOnscreenWGLDrawable.java
new file mode 100644
index 000000000..7c3cea255
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsOnscreenWGLDrawable.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.windows.wgl;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public class WindowsOnscreenWGLDrawable extends WindowsWGLDrawable {
+  private static final boolean PROFILING = Debug.debug("WindowsOnscreenWGLDrawable.profiling");
+  private static final int PROFILING_TICKS = 200;
+  private int  profilingLockSurfaceTicks;
+  private long profilingLockSurfaceTime;
+  private int  profilingUnlockSurfaceTicks;
+  private long profilingUnlockSurfaceTime;
+  private int  profilingSwapBuffersTicks;
+  private long profilingSwapBuffersTime;
+
+  protected WindowsOnscreenWGLDrawable(GLDrawableFactory factory, NativeWindow component,
+                                   NWCapabilities capabilities,
+                                   NWCapabilitiesChooser chooser) {
+    super(factory, component, false, capabilities, chooser);
+  }
+
+  public GLContext createContext(GLContext shareWith) {
+    return new WindowsOnscreenWGLContext(this, shareWith);
+  }
+
+  public int getWidth() {
+    return component.getWidth();
+  }
+
+  public int getHeight() {
+    return component.getHeight();
+  }
+
+  public void swapBuffers() throws GLException {
+    boolean didLock = false;
+
+    if (getNativeWindow().getSurfaceHandle() == 0) {
+      if (lockSurface() == NativeWindow.LOCK_SURFACE_NOT_READY) {
+        return;
+      }
+      didLock = true;
+    }
+
+    long startTime = 0;
+    if (PROFILING) {
+      startTime = System.currentTimeMillis();
+    }
+
+    if (!WGL.SwapBuffers(getNativeWindow().getSurfaceHandle()) && (WGL.GetLastError() != 0)) {
+      throw new GLException("Error swapping buffers");
+    }
+
+    if (PROFILING) {
+      long endTime = System.currentTimeMillis();
+      profilingSwapBuffersTime += (endTime - startTime);
+      int ticks = PROFILING_TICKS;
+      if (++profilingSwapBuffersTicks == ticks) {
+        System.err.println("SwapBuffers calls: " + profilingSwapBuffersTime + " ms / " + ticks + "  calls (" +
+                           ((float) profilingSwapBuffersTime / (float) ticks) + " ms/call)");
+        profilingSwapBuffersTime = 0;
+        profilingSwapBuffersTicks = 0;
+      }
+    }
+
+    if (didLock) {
+      unlockSurface();
+    }
+  }
+
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsPbufferWGLContext.java b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsPbufferWGLContext.java
new file mode 100644
index 000000000..e975670b4
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsPbufferWGLContext.java
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.windows.wgl;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public class WindowsPbufferWGLContext extends WindowsWGLContext {
+  private static final boolean DEBUG = Debug.debug("WindowsPbufferWGLContext");
+
+  // State for render-to-texture and render-to-texture-rectangle support
+  private WindowsPbufferWGLDrawable drawable;
+  private boolean rtt;       // render-to-texture?
+  private boolean hasRTT;    // render-to-texture extension available?
+  private boolean rect;      // render-to-texture-rectangle?
+  private int textureTarget; // e.g. GL_TEXTURE_2D, GL_TEXTURE_RECTANGLE_NV
+  private int texture;       // actual texture object
+
+  public WindowsPbufferWGLContext(WindowsPbufferWGLDrawable drawable,
+                                 GLContext shareWith) {
+    super(drawable, shareWith);
+    this.drawable = drawable;
+  }
+
+  public void bindPbufferToTexture() {
+    if (!rtt) {
+      throw new GLException("Shouldn't try to bind a pbuffer to a texture if render-to-texture hasn't been " +
+                            "specified in its NWCapabilities");
+    }
+    GL gl = getGL();
+    WGLExt wglExt = getWGLExt();
+    gl.glBindTexture(textureTarget, texture);
+    if (rtt && hasRTT) {
+      if (!wglExt.wglBindTexImage(drawable.getPbuffer(), WGLExt.WGL_FRONT_LEFT)) {
+        throw new GLException("Binding of pbuffer to texture failed: " + wglGetLastError());
+      }
+    }
+    // FIXME: comment is wrong now
+    // Note that if the render-to-texture extension is not supported,
+    // we perform a glCopyTexImage2D in swapBuffers().
+  }
+
+  public void releasePbufferFromTexture() {
+    if (!rtt) {
+      throw new GLException("Shouldn't try to bind a pbuffer to a texture if render-to-texture hasn't been " +
+                            "specified in its NWCapabilities");
+    }
+    if (rtt && hasRTT) {
+      WGLExt wglExt = getWGLExt();
+      if (!wglExt.wglReleaseTexImage(drawable.getPbuffer(), WGLExt.WGL_FRONT_LEFT)) {
+        throw new GLException("Releasing of pbuffer from texture failed: " + wglGetLastError());
+      }
+    }
+  }
+
+  protected int makeCurrentImpl() throws GLException {
+    int res = super.makeCurrentImpl();
+    if (DEBUG && VERBOSE) {
+      System.err.println("WindowsPbufferWGLContext: super.makeCurrentImpl() = " + res);
+    }
+    if (res == CONTEXT_CURRENT_NEW) {
+      NWCapabilities capabilities = drawable.getRequestedNWCapabilities();
+
+      // Initialize render-to-texture support if requested
+      GL gl = getGL();
+      rtt  = capabilities.getPbufferRenderToTexture();
+      rect = gl.isGL2() && capabilities.getPbufferRenderToTextureRectangle();
+
+      if (rtt) {
+        if (DEBUG) {
+          System.err.println("Initializing render-to-texture support");
+        }
+
+        if (!gl.isExtensionAvailable("WGL_ARB_render_texture")) {
+          System.err.println("WindowsPbufferWGLContext: WARNING: WGL_ARB_render_texture extension not " +
+                             "supported; implementing render_to_texture support using slow texture readback");
+        } else {
+          hasRTT = true;
+
+          if (rect && !gl.isExtensionAvailable("GL_NV_texture_rectangle")) {
+            System.err.println("WindowsPbufferWGLContext: WARNING: GL_NV_texture_rectangle extension not " +
+                               "supported; skipping requested render_to_texture_rectangle support for pbuffer");
+            rect = false;
+          }
+          if (rect) {
+            if (DEBUG) {
+              System.err.println("  Using render-to-texture-rectangle");
+            }
+            textureTarget = GL2.GL_TEXTURE_RECTANGLE;
+          } else {
+            if (DEBUG) {
+              System.err.println("  Using vanilla render-to-texture");
+            }
+            textureTarget = GL.GL_TEXTURE_2D;
+          }
+          int[] tmp = new int[1];
+          gl.glGenTextures(1, tmp, 0);
+          texture = tmp[0];
+          gl.glBindTexture(textureTarget, texture);
+          gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST);
+          gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST);
+          gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP_TO_EDGE);
+          gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP_TO_EDGE);
+          gl.glCopyTexImage2D(textureTarget, 0, GL.GL_RGB, 0, 0, drawable.getWidth(), drawable.getHeight(), 0);
+        }
+      }
+    }
+    return res;
+  }
+
+  public int getFloatingPointMode() {
+    return drawable.getFloatingPointMode();
+  }
+
+  private static String wglGetLastError() {
+    return WindowsWGLDrawableFactory.wglGetLastError();
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsPbufferWGLDrawable.java b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsPbufferWGLDrawable.java
new file mode 100644
index 000000000..b904ca913
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsPbufferWGLDrawable.java
@@ -0,0 +1,332 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.windows.wgl;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.nwi.impl.NullWindow;
+
+public class WindowsPbufferWGLDrawable extends WindowsWGLDrawable {
+  private long cachedParentHdc;
+  private WGLExt cachedWGLExt; // cached WGLExt instance from parent GLCanvas,
+                               // needed to destroy pbuffer
+  private long buffer; // pbuffer handle
+
+  private int floatMode;
+
+  public WindowsPbufferWGLDrawable(GLDrawableFactory factory,
+                                   NWCapabilities requestedCapabilities,
+                                   int width,
+                                   int height,
+                                   WindowsWGLDrawable dummyDrawable,
+                                   WGLExt wglExt) {
+    super(factory, new NullWindow(), true, requestedCapabilities, null);
+    if (width <= 0 || height <= 0) {
+      throw new GLException("Width and height of pbuffer must be positive (were (" +
+			    width + ", " + height + "))");
+    }
+    NullWindow nw = (NullWindow) getNativeWindow();
+    nw.setSize(width, height);
+
+    if (DEBUG) {
+      System.out.println("Pbuffer caps on init: " + requestedCapabilities +
+                         (requestedCapabilities.getPbufferRenderToTexture() ? " [rtt]" : "") +
+                         (requestedCapabilities.getPbufferRenderToTextureRectangle() ? " [rect]" : "") +
+                         (requestedCapabilities.getPbufferFloatingPointBuffers() ? " [float]" : ""));
+    }
+
+    createPbuffer(dummyDrawable.getNativeWindow().getSurfaceHandle(), wglExt);
+  }
+
+  public GLContext createContext(GLContext shareWith) {
+    return new WindowsPbufferWGLContext(this, shareWith);
+  }
+
+  public void destroy() {
+    NullWindow nw = (NullWindow) getNativeWindow();
+    if (nw.getSurfaceHandle() != 0) {
+      // Must release DC and pbuffer
+      // NOTE that since the context is not current, glGetError() can
+      // not be called here, so we skip the use of any composable
+      // pipelines (see WindowsOnscreenWGLContext.makeCurrentImpl)
+      WGLExt wglExt = cachedWGLExt;
+      if (wglExt.wglReleasePbufferDC(buffer, nw.getSurfaceHandle()) == 0) {
+        throw new GLException("Error releasing pbuffer device context: error code " + WGL.GetLastError());
+      }
+      nw.setSurfaceHandle(0);
+      if (!wglExt.wglDestroyPbuffer(buffer)) {
+        throw new GLException("Error destroying pbuffer: error code " + WGL.GetLastError());
+      }
+      buffer = 0;
+      setChosenNWCapabilities(null);
+    }
+  }
+
+  public long getPbuffer() {
+    return buffer;
+  }
+
+  public int getFloatingPointMode() {
+    return floatMode;
+  }
+
+  public void swapBuffers() throws GLException {
+    // FIXME: this doesn't make sense any more because we don't have
+    // access to our OpenGL context here
+    /*
+    // FIXME: do we need to do anything if the pbuffer is double-buffered?
+    // For now, just grab the pixels for the render-to-texture support.
+    if (rtt && !hasRTT) {
+      if (DEBUG) {
+        System.err.println("Copying pbuffer data to GL_TEXTURE_2D state");
+      }
+
+      GL gl = getGL();
+      gl.glCopyTexSubImage2D(textureTarget, 0, 0, 0, 0, 0, width, height);
+    }
+    */
+  }
+
+  // This is public to allow access from PbufferContext
+  public NWCapabilities getRequestedNWCapabilities() {
+    return super.getRequestedNWCapabilities();
+  }
+
+  private void createPbuffer(long parentHdc, WGLExt wglExt) {
+    int[]   iattributes = new int  [2*MAX_ATTRIBS];
+    float[] fattributes = new float[1];
+    int[]   floatModeTmp = new int[1];
+    int     niattribs   = 0;
+    int     width, height;
+
+    NWCapabilities capabilities = getRequestedNWCapabilities();
+
+    if (DEBUG) {
+      System.out.println("Pbuffer parentHdc = " + toHexString(parentHdc));
+      System.out.println("Pbuffer caps: " + capabilities +
+                         (capabilities.getPbufferRenderToTexture() ? " [rtt]" : "") +
+                         (capabilities.getPbufferRenderToTextureRectangle() ? " [rect]" : "") +
+                         (capabilities.getPbufferFloatingPointBuffers() ? " [float]" : ""));
+    }
+
+    if (!glCapabilities2iattributes(capabilities,
+                                    iattributes,
+                                    wglExt,
+                                    true,
+                                    floatModeTmp)) {
+      throw new GLException("Pbuffer-related extensions not supported");
+    }
+
+    floatMode = floatModeTmp[0];
+    boolean rtt      = capabilities.getPbufferRenderToTexture();
+    boolean rect     = capabilities.getPbufferRenderToTextureRectangle();
+    boolean useFloat = capabilities.getPbufferFloatingPointBuffers();
+    boolean ati      = false;
+
+    if (useFloat) {
+      ati = (floatMode == GLPbuffer.ATI_FLOAT);
+    }
+
+    int[] pformats = new int[MAX_PFORMATS];
+    int   nformats;
+    int[] nformatsTmp = new int[1];
+    if (!wglExt.wglChoosePixelFormat(parentHdc,
+                                     iattributes, 0,
+                                     fattributes, 0,
+                                     MAX_PFORMATS,
+                                     pformats, 0,
+                                     nformatsTmp, 0)) {
+      throw new GLException("pbuffer creation error: wglChoosePixelFormat() failed");
+    }
+    nformats = nformatsTmp[0];
+    if (nformats <= 0) {
+      throw new GLException("pbuffer creation error: Couldn't find a suitable pixel format");
+    }
+
+    boolean haveMultisample = wglExt.isExtensionAvailable("WGL_ARB_multisample");
+
+    if (DEBUG) {
+      System.err.println("" + nformats + " suitable pixel formats found");
+      // query pixel format
+      iattributes[0] = WGLExt.WGL_RED_BITS;
+      iattributes[1] = WGLExt.WGL_GREEN_BITS;
+      iattributes[2] = WGLExt.WGL_BLUE_BITS;
+      iattributes[3] = WGLExt.WGL_ALPHA_BITS;
+      iattributes[4] = WGLExt.WGL_DEPTH_BITS;
+      iattributes[5] = (useFloat ? (ati ? WGLExt.WGL_PIXEL_TYPE: WGLExt.WGL_FLOAT_COMPONENTS_NV) : WGLExt.WGL_RED_BITS);
+      iattributes[6] = (haveMultisample ? WGLExt.WGL_SAMPLE_BUFFERS: WGLExt.WGL_RED_BITS);
+      iattributes[7] = (haveMultisample ? WGLExt.WGL_SAMPLES: WGLExt.WGL_RED_BITS);
+      iattributes[8] = WGLExt.WGL_DRAW_TO_PBUFFER;
+      int[] ivalues = new int[9];
+      for (int i = 0; i < nformats; i++) {
+        if (!wglExt.wglGetPixelFormatAttribiv(parentHdc, pformats[i], 0, 9, iattributes, 0, ivalues, 0)) {
+          throw new GLException("Error while querying pixel format " + pformats[i] +
+                                "'s (index " + i + "'s) capabilities for debugging");
+        }
+        System.err.print("pixel format " + pformats[i] + " (index " + i + "): ");
+        System.err.print( "r: " + ivalues[0]);
+        System.err.print(" g: " + ivalues[1]);
+        System.err.print(" b: " + ivalues[2]);
+        System.err.print(" a: " + ivalues[3]);
+        System.err.print(" depth: " + ivalues[4]);
+        if (haveMultisample) {
+          System.err.print(" multisample: " + ivalues[6]);
+        }
+        System.err.print(" samples: " + ivalues[7]);
+        if (useFloat) {
+          if (ati) {
+            if (ivalues[5] == WGLExt.WGL_TYPE_RGBA_FLOAT) {
+              System.err.print(" [ati float]");
+            } else if (ivalues[5] != WGLExt.WGL_TYPE_RGBA) {
+              System.err.print(" [unknown pixel type " + ivalues[5] + "]");
+            }
+          } else {
+            if (ivalues[5] != 0) {
+              System.err.print(" [float]");
+            }
+          }
+        }
+
+        if (ivalues[8] != 0) {
+          System.err.print(" [pbuffer]");
+        }
+        System.err.println();
+      }
+    }
+
+    long tmpBuffer = 0;
+    int whichFormat = -1;
+    // Loop is a workaround for bugs in NVidia's recent drivers
+    for (whichFormat = 0; whichFormat < nformats; whichFormat++) {
+      int format = pformats[whichFormat];
+
+      // Create the p-buffer.
+      niattribs = 0;
+
+      if (rtt) {
+        iattributes[niattribs++]   = WGLExt.WGL_TEXTURE_FORMAT;
+        if (useFloat) {
+          iattributes[niattribs++] = WGLExt.WGL_TEXTURE_FLOAT_RGB_NV;
+        } else {
+          iattributes[niattribs++] = WGLExt.WGL_TEXTURE_RGBA;
+        }
+
+        iattributes[niattribs++] = WGLExt.WGL_TEXTURE_TARGET;
+        iattributes[niattribs++] = rect ? WGLExt.WGL_TEXTURE_RECTANGLE_NV : WGLExt.WGL_TEXTURE_2D;
+
+        iattributes[niattribs++] = WGLExt.WGL_MIPMAP_TEXTURE;
+        iattributes[niattribs++] = GL.GL_FALSE;
+
+        iattributes[niattribs++] = WGLExt.WGL_PBUFFER_LARGEST;
+        iattributes[niattribs++] = GL.GL_FALSE;
+      }
+
+      iattributes[niattribs++] = 0;
+
+      tmpBuffer = wglExt.wglCreatePbuffer(parentHdc, format, getWidth(), getHeight(), iattributes, 0);
+      if (tmpBuffer != 0) {
+        // Done
+        break;
+      }
+    }
+
+    if (tmpBuffer == 0) {
+      throw new GLException("pbuffer creation error: wglCreatePbuffer() failed: tried " + nformats +
+                            " pixel formats, last error was: " + wglGetLastError());
+    }
+
+    // Get the device context.
+    long tmpHdc = wglExt.wglGetPbufferDC(tmpBuffer);
+    if (tmpHdc == 0) {
+      throw new GLException("pbuffer creation error: wglGetPbufferDC() failed");
+    }
+
+    NullWindow nw = (NullWindow) getNativeWindow();
+    // Set up instance variables
+    buffer = tmpBuffer;
+    nw.setSurfaceHandle(tmpHdc);
+    cachedWGLExt = wglExt;
+    cachedParentHdc = parentHdc;
+
+    // Re-query chosen pixel format
+    {
+      niattribs = 0;
+      iattributes[niattribs++] = WGLExt.WGL_ACCELERATION;
+      iattributes[niattribs++] = WGLExt.WGL_RED_BITS;
+      iattributes[niattribs++] = WGLExt.WGL_GREEN_BITS;
+      iattributes[niattribs++] = WGLExt.WGL_BLUE_BITS;
+      iattributes[niattribs++] = WGLExt.WGL_ALPHA_BITS;
+      iattributes[niattribs++] = WGLExt.WGL_DEPTH_BITS;
+      iattributes[niattribs++] = WGLExt.WGL_STENCIL_BITS;
+      iattributes[niattribs++] = WGLExt.WGL_DOUBLE_BUFFER;
+      iattributes[niattribs++] = WGLExt.WGL_STEREO;
+      iattributes[niattribs++] = WGLExt.WGL_ACCUM_RED_BITS;
+      iattributes[niattribs++] = WGLExt.WGL_ACCUM_GREEN_BITS;
+      iattributes[niattribs++] = WGLExt.WGL_ACCUM_BLUE_BITS;
+      iattributes[niattribs++] = WGLExt.WGL_ACCUM_ALPHA_BITS;
+      iattributes[niattribs++] = (useFloat ? (ati ? WGLExt.WGL_PIXEL_TYPE: WGLExt.WGL_FLOAT_COMPONENTS_NV) : WGLExt.WGL_RED_BITS);
+      iattributes[niattribs++] = (haveMultisample ? WGLExt.WGL_SAMPLE_BUFFERS: WGLExt.WGL_RED_BITS);
+      iattributes[niattribs++] = (haveMultisample ? WGLExt.WGL_SAMPLES: WGLExt.WGL_RED_BITS);
+      iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_PBUFFER;
+      int[] ivalues = new int[niattribs];
+      // FIXME: usually prefer to throw exceptions, but failure here is not critical
+      if (wglExt.wglGetPixelFormatAttribiv(parentHdc, pformats[whichFormat], 0, niattribs, iattributes, 0, ivalues, 0)) {
+        setChosenNWCapabilities(iattributes2NWCapabilities(iattributes, niattribs, ivalues, false));
+      }
+    }
+
+    // Determine the actual width and height we were able to create.
+    int[] tmp = new int[1];
+    wglExt.wglQueryPbuffer( buffer, WGLExt.WGL_PBUFFER_WIDTH,  tmp, 0 );
+    width = tmp[0];
+    wglExt.wglQueryPbuffer( buffer, WGLExt.WGL_PBUFFER_HEIGHT, tmp, 0 );
+    height = tmp[0];
+    nw.setSize(width, height);
+
+    if (DEBUG) {
+      System.err.println("Created pbuffer " + width + " x " + height);
+    }
+  }
+
+  private static String wglGetLastError() {
+    return WindowsWGLDrawableFactory.wglGetLastError();
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLContext.java b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLContext.java
new file mode 100644
index 000000000..1ce190da3
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLContext.java
@@ -0,0 +1,307 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.windows.wgl;
+
+import java.nio.*;
+import java.util.*;
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.gluegen.runtime.ProcAddressTable;
+
+public class WindowsWGLContext extends GLContextImpl {
+  protected WindowsWGLDrawable drawable;
+  protected long hglrc;
+  private boolean wglGetExtensionsStringEXTInitialized;
+  private boolean wglGetExtensionsStringEXTAvailable;
+  private static final Map/*<String, String>*/ functionNameMap;
+  private static final Map/*<String, String>*/ extensionNameMap;
+  private WGLExt wglExt;
+  // Table that holds the addresses of the native C-language entry points for
+  // WGL extension functions.
+  private WGLExtProcAddressTable wglExtProcAddressTable;
+
+  static {
+    functionNameMap = new HashMap();
+    functionNameMap.put("glAllocateMemoryNV", "wglAllocateMemoryNV");
+    functionNameMap.put("glFreeMemoryNV", "wglFreeMemoryNV");
+
+    extensionNameMap = new HashMap();
+    extensionNameMap.put("GL_ARB_pbuffer", "WGL_ARB_pbuffer");
+    extensionNameMap.put("GL_ARB_pixel_format", "WGL_ARB_pixel_format");
+  }
+
+  // FIXME: figure out how to hook back in the Java 2D / JOGL bridge
+  public WindowsWGLContext(WindowsWGLDrawable drawable,
+                          GLContext shareWith) {
+    super(shareWith);
+    this.drawable = drawable;
+  }
+
+  public Object getPlatformGLExtensions() {
+    return getWGLExt();
+  }
+
+  public WGLExt getWGLExt() {
+    if (wglExt == null) {
+      wglExt = new WGLExtImpl(this);
+    }
+    return wglExt;
+  }
+
+  public final ProcAddressTable getPlatformExtProcAddressTable() {
+    return getWGLExtProcAddressTable();
+  }
+
+  public final WGLExtProcAddressTable getWGLExtProcAddressTable() {
+    return wglExtProcAddressTable;
+  }
+
+  public GLDrawable getGLDrawable() {
+    return drawable;
+  }
+
+  protected String mapToRealGLFunctionName(String glFunctionName) {
+    String lookup = (String) functionNameMap.get(glFunctionName);
+    if (lookup != null) {
+      return lookup;
+    }
+    return glFunctionName;
+  }
+
+  protected String mapToRealGLExtensionName(String glExtensionName) {
+    String lookup = (String) extensionNameMap.get(glExtensionName);
+    if (lookup != null) {
+      return lookup;
+    }
+    return glExtensionName;
+  }
+
+  /**
+   * Creates and initializes an appropriate OpenGL context. Should only be
+   * called by {@link #makeCurrentImpl()}.
+   */
+  protected void create() {
+    if (drawable.getNativeWindow().getSurfaceHandle() == 0) {
+      throw new GLException("Internal error: attempted to create OpenGL context without an associated drawable");
+    }
+    hglrc = WGL.wglCreateContext(drawable.getNativeWindow().getSurfaceHandle());
+    if (hglrc == 0) {
+      throw new GLException("Unable to create OpenGL context for device context " + toHexString(drawable.getNativeWindow().getSurfaceHandle()));
+    }
+    if (DEBUG) {
+      System.err.println(getThreadName() + ": !!! Created OpenGL context " + toHexString(hglrc) + " for " + this + ", device context " + toHexString(drawable.getNativeWindow().getSurfaceHandle()) + ", not yet sharing");
+    }
+    // Windows can set up sharing of display lists after creation time
+    WindowsWGLContext other = (WindowsWGLContext) GLContextShareSet.getShareContext(this);
+    long hglrc2 = 0;
+    if (other != null) {
+      hglrc2 = other.getHGLRC();
+      if (hglrc2 == 0) {
+        throw new GLException("GLContextShareSet returned an invalid OpenGL context");
+      }
+      if (!WGL.wglShareLists(hglrc2, hglrc)) {
+        throw new GLException("wglShareLists(" + toHexString(hglrc2) +
+                              ", " + toHexString(hglrc) + ") failed: error code " +
+                              WGL.GetLastError());
+      }
+    }
+    GLContextShareSet.contextCreated(this);
+    if (DEBUG) {
+      System.err.println(getThreadName() + ": !!! Created OpenGL context " + toHexString(hglrc) + " for " + this + ", device context " + toHexString(drawable.getNativeWindow().getSurfaceHandle()) + ", sharing with " + toHexString(hglrc2));
+    }
+  }
+  
+  protected int makeCurrentImpl() throws GLException {
+    if (drawable.getNativeWindow().getSurfaceHandle() == 0) {
+        if (DEBUG) {
+          System.err.println("drawable not properly initialized");
+        }
+        return CONTEXT_NOT_CURRENT;
+    }
+    boolean created = false;
+    if (hglrc == 0) {
+      create();
+      if (DEBUG) {
+        System.err.println(getThreadName() + ": !!! Created GL context for " + getClass().getName());
+      }
+      created = true;
+    }
+
+    if (WGL.wglGetCurrentContext() != hglrc) {
+      if (!WGL.wglMakeCurrent(drawable.getNativeWindow().getSurfaceHandle(), hglrc)) {
+        throw new GLException("Error making context current: " + WGL.GetLastError());
+      } else {
+        if (DEBUG && VERBOSE) {
+          System.err.println(getThreadName() + ": wglMakeCurrent(hdc " + toHexString(drawable.getNativeWindow().getSurfaceHandle()) +
+                             ", hglrc " + toHexString(hglrc) + ") succeeded");
+        }
+      }
+    }
+
+    if (created) {
+      resetGLFunctionAvailability();
+      return CONTEXT_CURRENT_NEW;
+    }
+    return CONTEXT_CURRENT;
+  }
+
+  protected void releaseImpl() throws GLException {
+    if (!NO_FREE) {
+      if (!WGL.wglMakeCurrent(0, 0)) {
+        throw new GLException("Error freeing OpenGL context: " + WGL.GetLastError());
+      }
+    }
+  }
+
+  protected void destroyImpl() throws GLException {
+    if (hglrc != 0) {
+      if (!WGL.wglDeleteContext(hglrc)) {
+        throw new GLException("Unable to delete OpenGL context");
+      }
+      if (DEBUG) {
+        System.err.println(getThreadName() + ": !!! Destroyed OpenGL context " + toHexString(hglrc));
+      }
+      hglrc = 0;
+      GLContextShareSet.contextDestroyed(this);
+    }
+  }
+
+  public boolean isCreated() {
+    return (hglrc != 0);
+  }
+
+  public void copy(GLContext source, int mask) throws GLException {
+    long dst = getHGLRC();
+    long src = ((WindowsWGLContext) source).getHGLRC();
+    if (src == 0) {
+      throw new GLException("Source OpenGL context has not been created");
+    }
+    if (dst == 0) {
+      throw new GLException("Destination OpenGL context has not been created");
+    }
+    if (!WGL.wglCopyContext(src, dst, mask)) {
+      throw new GLException("wglCopyContext failed");
+    }
+  }
+
+  protected void resetGLFunctionAvailability() {
+    super.resetGLFunctionAvailability();
+    if (DEBUG) {
+      System.err.println(getThreadName() + ": !!! Initializing WGL extension address table for " + this);
+    }
+    if (wglExtProcAddressTable == null) {
+      // FIXME: cache ProcAddressTables by capability bits so we can
+      // share them among contexts with the same capabilities
+      wglExtProcAddressTable = new WGLExtProcAddressTable();
+    }          
+    resetProcAddressTable(getWGLExtProcAddressTable());
+  }
+  
+  public String getPlatformExtensionsString() {
+    if (!wglGetExtensionsStringEXTInitialized) {
+      wglGetExtensionsStringEXTAvailable = (WGL.wglGetProcAddress("wglGetExtensionsStringEXT") != 0);
+      wglGetExtensionsStringEXTInitialized = true;
+    }
+    if (wglGetExtensionsStringEXTAvailable) {
+      return getWGLExt().wglGetExtensionsStringEXT();
+    } else {
+      return "";
+    }
+  }
+
+  public boolean isFunctionAvailable(String glFunctionName)
+  {
+    boolean available = super.isFunctionAvailable(glFunctionName);
+    
+    // Sanity check for implementations that use proc addresses for run-time
+    // linking: if the function IS available, then make sure there's a proc
+    // address for it if it's an extension or not part of the OpenGL 1.1 core
+    // (post GL 1.1 functions are run-time linked on windows).
+    /* FIXME: 
+    assert(!available ||
+           (getGLProcAddressTable().getAddressFor(mapToRealGLFunctionName(glFunctionName)) != 0 ||
+            FunctionAvailabilityCache.isPartOfGLCore("1.1", mapToRealGLFunctionName(glFunctionName)))
+           ); */
+
+    return available;
+  }
+  
+  public void setSwapInterval(int interval) {
+    // FIXME: make the context current first? Currently assumes that
+    // will not be necessary. Make the caller do this?
+    WGLExt wglExt = getWGLExt();
+    if (wglExt.isExtensionAvailable("WGL_EXT_swap_control")) {
+      wglExt.wglSwapIntervalEXT(interval);
+    }
+  }
+
+  public ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3) {
+    return getWGLExt().wglAllocateMemoryNV(arg0, arg1, arg2, arg3);
+  }
+
+  public int getOffscreenContextPixelDataType() {
+    throw new GLException("Should not call this");
+  }
+
+  public int getOffscreenContextReadBuffer() {
+    throw new GLException("Should not call this");
+  }
+
+  public boolean offscreenImageNeedsVerticalFlip() {
+    throw new GLException("Should not call this");
+  }
+
+  public void bindPbufferToTexture() {
+    throw new GLException("Should not call this");
+  }
+
+  public void releasePbufferFromTexture() {
+    throw new GLException("Should not call this");
+  }
+
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+
+  public long getHGLRC() {
+    return hglrc;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLDrawable.java b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLDrawable.java
new file mode 100644
index 000000000..430270e37
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLDrawable.java
@@ -0,0 +1,673 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.windows.wgl;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+
+public abstract class WindowsWGLDrawable extends GLDrawableImpl {
+  protected static final boolean DEBUG = Debug.debug("WindowsWGLDrawable");
+
+  protected NWCapabilitiesChooser chooser;
+  protected boolean pixelFormatChosen;
+
+  // Workaround for problems on Intel 82855 cards
+  private int  setPixelFormatFailCount;
+  private static final int MAX_SET_PIXEL_FORMAT_FAIL_COUNT = 5;
+
+  protected static final int MAX_PFORMATS = 256;
+  protected static final int MAX_ATTRIBS  = 256;
+
+  public WindowsWGLDrawable(GLDrawableFactory factory, NativeWindow comp, boolean realized,
+                            NWCapabilities requestedCapabilities,
+                            NWCapabilitiesChooser chooser) {
+    super(factory, comp, requestedCapabilities, realized);
+    this.chooser = chooser;
+  }
+
+  public int lockSurface() throws GLException {
+    int ret = super.lockSurface();
+    if(NativeWindow.LOCK_SURFACE_NOT_READY == ret) {
+      if (DEBUG) {
+          System.err.println("WindowsWGLDrawable.lockSurface: surface not ready");
+      }
+      return ret;
+    }
+    if (!pixelFormatChosen) {
+      try {
+        choosePixelFormat(true);
+        setPixelFormatFailCount = 0;
+      } catch (RuntimeException e) {
+        if (DEBUG) {
+          System.err.println("WindowsWGLDrawable.lockSurface: squelching exception");
+          e.printStackTrace();
+        }
+        // Workaround for problems seen on Intel 82855 cards in particular
+        // Make it look like the lockSurface() call didn't succeed
+        unlockSurface();
+        if (e instanceof GLException) {
+          if (++setPixelFormatFailCount == MAX_SET_PIXEL_FORMAT_FAIL_COUNT) {
+            setPixelFormatFailCount = 0;
+            throw e;
+          }
+          return NativeWindow.LOCK_SURFACE_NOT_READY;
+        } else {
+          // Probably a user error in the NWCapabilitiesChooser or similar.
+          // Don't propagate non-GLExceptions out because calling code
+          // expects to catch only that exception type
+          throw new GLException(e);
+        }
+      }
+    }
+    return ret;
+  }
+
+
+  protected void choosePixelFormat(boolean onscreen) {
+    PIXELFORMATDESCRIPTOR pfd = null;
+    int pixelFormat = 0;
+    NWCapabilities chosenCaps = null;
+    NWCapabilities capabilities = getRequestedNWCapabilities();
+    long hdc = getNativeWindow().getSurfaceHandle();
+    if (onscreen) {
+      if ((pixelFormat = WGL.GetPixelFormat(hdc)) != 0) {
+        // The Java2D/OpenGL pipeline probably already set a pixel
+        // format for this canvas.
+        if (DEBUG) {
+          System.err.println("NOTE: pixel format already chosen (by Java2D/OpenGL pipeline?) for window: " + 
+                             WGL.GetPixelFormat(hdc));
+        }
+        pfd = newPixelFormatDescriptor();
+        if (WGL.DescribePixelFormat(hdc, pixelFormat, pfd.size(), pfd) == 0) {
+          // FIXME: should this just be a warning? Not really critical...
+          throw new GLException("Unable to describe pixel format " + pixelFormat +
+                                " of window set by Java2D/OpenGL pipeline");
+        }
+        setChosenNWCapabilities(pfd2NWCapabilities(pfd));
+        pixelFormatChosen = true;
+        return;
+      }
+
+      NWCapabilities[] availableCaps = null;
+      int numFormats = 0;
+      pfd = newPixelFormatDescriptor();
+      // Produce a recommended pixel format selection for the NWCapabilitiesChooser.
+      // Use wglChoosePixelFormatARB if user requested multisampling and if we have it available
+      WindowsWGLDrawable dummyDrawable = null;
+      GLContextImpl     dummyContext  = null;
+      WGLExt            dummyWGLExt   = null;
+      if (capabilities.getSampleBuffers()) {
+        dummyDrawable = new WindowsDummyWGLDrawable(getFactory());
+        dummyContext  = (GLContextImpl) dummyDrawable.createContext(null);
+        if (dummyContext != null) {
+          dummyContext.makeCurrent();
+          dummyWGLExt = (WGLExt) dummyContext.getPlatformGLExtensions();
+        }
+      }      
+      int recommendedPixelFormat = -1;
+      boolean haveWGLChoosePixelFormatARB = false;
+      boolean haveWGLARBMultisample = false;
+      boolean gotAvailableCaps = false;
+      if (dummyWGLExt != null) {
+        try {
+          haveWGLChoosePixelFormatARB = dummyWGLExt.isExtensionAvailable("WGL_ARB_pixel_format");
+          if (haveWGLChoosePixelFormatARB) {
+            haveWGLARBMultisample = dummyWGLExt.isExtensionAvailable("WGL_ARB_multisample");
+
+            int[]   iattributes = new int  [2 * MAX_ATTRIBS];
+            int[]   iresults    = new int  [2 * MAX_ATTRIBS];
+            float[] fattributes = new float[1];
+
+            if (glCapabilities2iattributes(capabilities,
+                                           iattributes,
+                                           dummyWGLExt,
+                                           false,
+                                           null)) {
+              int[] pformats = new int[MAX_PFORMATS];
+              int[] numFormatsTmp = new int[1];
+              if (dummyWGLExt.wglChoosePixelFormat(hdc,
+                                                   iattributes, 0,
+                                                   fattributes, 0,
+                                                   MAX_PFORMATS,
+                                                   pformats, 0,
+                                                   numFormatsTmp, 0)) {
+                numFormats = numFormatsTmp[0];
+                if (numFormats > 0) {
+                  // Remove one-basing of pixel format (added on later)
+                  recommendedPixelFormat = pformats[0] - 1;
+                  if (DEBUG) {
+                    System.err.println(getThreadName() + ": Used wglChoosePixelFormatARB to recommend pixel format " + recommendedPixelFormat);
+                  }
+                }
+              } else {
+                if (DEBUG) {
+                  System.err.println(getThreadName() + ": wglChoosePixelFormatARB failed: " + WGL.GetLastError() );
+                  Thread.dumpStack();
+                }
+              }
+              if (DEBUG) {
+                if (recommendedPixelFormat < 0) {
+                  System.err.print(getThreadName() + ": wglChoosePixelFormatARB didn't recommend a pixel format");
+                  if (capabilities.getSampleBuffers()) {
+                    System.err.print(" for multisampled NWCapabilities");
+                  }
+                  System.err.println();
+                }
+              }
+
+              // Produce a list of NWCapabilities to give to the
+              // NWCapabilitiesChooser.
+              // Use wglGetPixelFormatAttribivARB instead of
+              // DescribePixelFormat to get higher-precision information
+              // about the pixel format (should make the NWCapabilities
+              // more precise as well...i.e., remove the
+              // "HardwareAccelerated" bit, which is basically
+              // meaningless, and put in whether it can render to a
+              // window, to a pbuffer, or to a pixmap)
+              int niattribs = 0;
+              iattributes[0] = WGLExt.WGL_NUMBER_PIXEL_FORMATS;
+              if (dummyWGLExt.wglGetPixelFormatAttribiv(hdc, 0, 0, 1, iattributes, 0, iresults, 0)) {
+                numFormats = iresults[0];
+
+                if (DEBUG) {
+                  System.err.println("wglGetPixelFormatAttribivARB reported WGL_NUMBER_PIXEL_FORMATS = " + numFormats);
+                }
+
+                // Should we be filtering out the pixel formats which aren't
+                // applicable, as we are doing here?
+                // We don't have enough information in the NWCapabilities to
+                // represent those that aren't...
+                iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_WINDOW;
+                iattributes[niattribs++] = WGLExt.WGL_ACCELERATION;
+                iattributes[niattribs++] = WGLExt.WGL_SUPPORT_OPENGL;
+                iattributes[niattribs++] = WGLExt.WGL_DEPTH_BITS;
+                iattributes[niattribs++] = WGLExt.WGL_STENCIL_BITS;
+                iattributes[niattribs++] = WGLExt.WGL_DOUBLE_BUFFER;
+                iattributes[niattribs++] = WGLExt.WGL_STEREO;
+                iattributes[niattribs++] = WGLExt.WGL_PIXEL_TYPE;
+                iattributes[niattribs++] = WGLExt.WGL_RED_BITS;
+                iattributes[niattribs++] = WGLExt.WGL_GREEN_BITS;
+                iattributes[niattribs++] = WGLExt.WGL_BLUE_BITS;
+                iattributes[niattribs++] = WGLExt.WGL_ALPHA_BITS;
+                iattributes[niattribs++] = WGLExt.WGL_ACCUM_RED_BITS;
+                iattributes[niattribs++] = WGLExt.WGL_ACCUM_GREEN_BITS;
+                iattributes[niattribs++] = WGLExt.WGL_ACCUM_BLUE_BITS;
+                iattributes[niattribs++] = WGLExt.WGL_ACCUM_ALPHA_BITS;
+                if (haveWGLARBMultisample) {
+                  iattributes[niattribs++] = WGLExt.WGL_SAMPLE_BUFFERS;
+                  iattributes[niattribs++] = WGLExt.WGL_SAMPLES;
+                }
+
+                availableCaps = new NWCapabilities[numFormats];
+                for (int i = 0; i < numFormats; i++) {
+                  if (!dummyWGLExt.wglGetPixelFormatAttribiv(hdc, i+1, 0, niattribs, iattributes, 0, iresults, 0)) {
+                    throw new GLException("Error getting pixel format attributes for pixel format " + (i + 1) + " of device context");
+                  }
+                  availableCaps[i] = iattributes2NWCapabilities(iattributes, niattribs, iresults, true);
+                }
+                gotAvailableCaps = true;
+              } else {
+                long lastErr = WGL.GetLastError();
+                // Intel Extreme graphics fails with a zero error code
+                if (lastErr != 0) {
+                  throw new GLException("Unable to enumerate pixel formats of window using wglGetPixelFormatAttribivARB: error code " + WGL.GetLastError());
+                }
+              }
+            }
+          }
+        } finally {
+          dummyContext.release();
+          dummyContext.destroy();
+          dummyDrawable.destroy();
+        }
+      }
+
+      // Fallback path for older cards, in particular Intel Extreme motherboard graphics
+      if (!gotAvailableCaps) {
+        if (DEBUG) {
+          if (!capabilities.getSampleBuffers()) {
+            System.err.println(getThreadName() + ": Using ChoosePixelFormat because multisampling not requested");
+          } else {
+            System.err.println(getThreadName() + ": Using ChoosePixelFormat because no wglChoosePixelFormatARB");
+          }
+        }
+        pfd = glCapabilities2PFD(capabilities, onscreen);
+        // Remove one-basing of pixel format (added on later)
+        recommendedPixelFormat = WGL.ChoosePixelFormat(hdc, pfd) - 1;
+        if (DEBUG) {
+          System.err.println(getThreadName() + ": Recommended pixel format = " + recommendedPixelFormat);
+        }
+
+        numFormats = WGL.DescribePixelFormat(hdc, 1, 0, null);
+        if (numFormats == 0) {
+          throw new GLException("Unable to enumerate pixel formats of window " +
+                                toHexString(hdc) + " for NWCapabilitiesChooser");
+        }
+        availableCaps = new NWCapabilities[numFormats];
+        for (int i = 0; i < numFormats; i++) {
+          if (WGL.DescribePixelFormat(hdc, 1 + i, pfd.size(), pfd) == 0) {
+            throw new GLException("Error describing pixel format " + (1 + i) + " of device context");
+          }
+          availableCaps[i] = pfd2NWCapabilities(pfd);
+        }
+      }
+
+      // NOTE: officially, should make a copy of all of these
+      // NWCapabilities to avoid mutation by the end user during the
+      // chooseCapabilities call, but for the time being, assume they
+      // won't be changed
+
+      // Supply information to chooser
+      pixelFormat = chooser.chooseCapabilities(capabilities, availableCaps, recommendedPixelFormat);
+      if ((pixelFormat < 0) || (pixelFormat >= numFormats)) {
+        throw new GLException("Invalid result " + pixelFormat +
+                              " from NWCapabilitiesChooser (should be between 0 and " +
+                              (numFormats - 1) + ")");
+      }
+      if (DEBUG) {
+        System.err.println(getThreadName() + ": Chosen pixel format (" + pixelFormat + "):");
+        System.err.println(availableCaps[pixelFormat]);
+      }
+      chosenCaps = availableCaps[pixelFormat];
+      pixelFormat += 1; // one-base the index
+      if (WGL.DescribePixelFormat(hdc, pixelFormat, pfd.size(), pfd) == 0) {
+        throw new GLException("Error re-describing the chosen pixel format: " + WGL.GetLastError());
+      }
+    } else {
+      // For now, use ChoosePixelFormat for offscreen surfaces until
+      // we figure out how to properly choose an offscreen-
+      // compatible pixel format
+      pfd = glCapabilities2PFD(capabilities, onscreen);
+      pixelFormat = WGL.ChoosePixelFormat(hdc, pfd);
+    }
+    if (!WGL.SetPixelFormat(hdc, pixelFormat, pfd)) {
+      long lastError = WGL.GetLastError();
+      if (DEBUG) {
+        System.err.println(getThreadName() + ": SetPixelFormat failed: current context = " + WGL.wglGetCurrentContext() +
+                           ", current DC = " + WGL.wglGetCurrentDC());
+        System.err.println(getThreadName() + ": GetPixelFormat(hdc " + toHexString(hdc) + ") returns " + WGL.GetPixelFormat(hdc));
+      }
+      throw new GLException("Unable to set pixel format " + pixelFormat + " for device context " + toHexString(hdc) + ": error code " + lastError);
+    }
+    // Reuse the previously-constructed NWCapabilities because it
+    // turns out that using DescribePixelFormat on some pixel formats
+    // (which, for example, support full-scene antialiasing) for some
+    // reason return that they are not OpenGL-capable
+    if (chosenCaps != null) {
+      setChosenNWCapabilities(chosenCaps);
+    } else {
+      setChosenNWCapabilities(pfd2NWCapabilities(pfd));
+    }
+    pixelFormatChosen = true;
+  }
+
+  protected static PIXELFORMATDESCRIPTOR glCapabilities2PFD(NWCapabilities caps, boolean onscreen) {
+    int colorDepth = (caps.getRedBits() +
+                      caps.getGreenBits() +
+                      caps.getBlueBits());
+    if (colorDepth < 15) {
+      throw new GLException("Bit depths < 15 (i.e., non-true-color) not supported");
+    }
+    PIXELFORMATDESCRIPTOR pfd = newPixelFormatDescriptor();
+    int pfdFlags = (WGL.PFD_SUPPORT_OPENGL |
+                    WGL.PFD_GENERIC_ACCELERATED);
+    if (caps.getDoubleBuffered()) {
+      pfdFlags |= WGL.PFD_DOUBLEBUFFER;
+    }
+    if (onscreen) {
+      pfdFlags |= WGL.PFD_DRAW_TO_WINDOW;
+    } else {
+      pfdFlags |= WGL.PFD_DRAW_TO_BITMAP;
+    }
+    if (caps.getStereo()) {
+      pfdFlags |= WGL.PFD_STEREO;
+    }
+    pfd.dwFlags(pfdFlags);
+    pfd.iPixelType((byte) WGL.PFD_TYPE_RGBA);
+    pfd.cColorBits((byte) colorDepth);
+    pfd.cRedBits  ((byte) caps.getRedBits());
+    pfd.cGreenBits((byte) caps.getGreenBits());
+    pfd.cBlueBits ((byte) caps.getBlueBits());
+    pfd.cAlphaBits((byte) caps.getAlphaBits());
+    int accumDepth = (caps.getAccumRedBits() +
+                      caps.getAccumGreenBits() +
+                      caps.getAccumBlueBits());
+    pfd.cAccumBits     ((byte) accumDepth);
+    pfd.cAccumRedBits  ((byte) caps.getAccumRedBits());
+    pfd.cAccumGreenBits((byte) caps.getAccumGreenBits());
+    pfd.cAccumBlueBits ((byte) caps.getAccumBlueBits());
+    pfd.cAccumAlphaBits((byte) caps.getAccumAlphaBits());
+    pfd.cDepthBits((byte) caps.getDepthBits());
+    pfd.cStencilBits((byte) caps.getStencilBits());
+    pfd.iLayerType((byte) WGL.PFD_MAIN_PLANE);
+    return pfd;
+  }
+
+  protected static PIXELFORMATDESCRIPTOR newPixelFormatDescriptor() {
+    PIXELFORMATDESCRIPTOR pfd = PIXELFORMATDESCRIPTOR.create();
+    pfd.nSize((short) pfd.size());
+    pfd.nVersion((short) 1);
+    return pfd;
+  }
+
+  protected static NWCapabilities pfd2NWCapabilities(PIXELFORMATDESCRIPTOR pfd) {
+    if ((pfd.dwFlags() & WGL.PFD_SUPPORT_OPENGL) == 0) {
+      return null;
+    }
+    NWCapabilities res = new NWCapabilities();
+    res.setRedBits       (pfd.cRedBits());
+    res.setGreenBits     (pfd.cGreenBits());
+    res.setBlueBits      (pfd.cBlueBits());
+    res.setAlphaBits     (pfd.cAlphaBits());
+    res.setAccumRedBits  (pfd.cAccumRedBits());
+    res.setAccumGreenBits(pfd.cAccumGreenBits());
+    res.setAccumBlueBits (pfd.cAccumBlueBits());
+    res.setAccumAlphaBits(pfd.cAccumAlphaBits());
+    res.setDepthBits     (pfd.cDepthBits());
+    res.setStencilBits   (pfd.cStencilBits());
+    res.setDoubleBuffered((pfd.dwFlags() & WGL.PFD_DOUBLEBUFFER) != 0);
+    res.setStereo        ((pfd.dwFlags() & WGL.PFD_STEREO) != 0);
+    res.setHardwareAccelerated(((pfd.dwFlags() & WGL.PFD_GENERIC_FORMAT) == 0) ||
+			       ((pfd.dwFlags() & WGL.PFD_GENERIC_ACCELERATED) != 0));
+    return res;
+  }
+
+  protected static boolean glCapabilities2iattributes(NWCapabilities capabilities,
+                                                      int[] iattributes,
+                                                      WGLExt wglExt,
+                                                      boolean pbuffer,
+                                                      int[] floatMode) throws GLException {
+    if (!wglExt.isExtensionAvailable("WGL_ARB_pixel_format")) {
+      return false;
+    }
+
+    int niattribs = 0;
+
+    iattributes[niattribs++] = WGLExt.WGL_SUPPORT_OPENGL;
+    iattributes[niattribs++] = GL.GL_TRUE;
+    if (pbuffer) {
+      iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_PBUFFER;
+      iattributes[niattribs++] = GL.GL_TRUE;
+    } else {
+      iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_WINDOW;
+      iattributes[niattribs++] = GL.GL_TRUE;
+    }
+
+    iattributes[niattribs++] = WGLExt.WGL_DOUBLE_BUFFER;
+    if (capabilities.getDoubleBuffered()) {
+      iattributes[niattribs++] = GL.GL_TRUE;
+    } else {
+      iattributes[niattribs++] = GL.GL_FALSE;
+    }
+
+    iattributes[niattribs++] = WGLExt.WGL_STEREO;
+    if (capabilities.getStereo()) {
+      iattributes[niattribs++] = GL.GL_TRUE;
+    } else {
+      iattributes[niattribs++] = GL.GL_FALSE;
+    }
+    
+    iattributes[niattribs++] = WGLExt.WGL_DEPTH_BITS;
+    iattributes[niattribs++] = capabilities.getDepthBits();
+    iattributes[niattribs++] = WGLExt.WGL_RED_BITS;
+    iattributes[niattribs++] = capabilities.getRedBits();
+    iattributes[niattribs++] = WGLExt.WGL_GREEN_BITS;
+    iattributes[niattribs++] = capabilities.getGreenBits();
+    iattributes[niattribs++] = WGLExt.WGL_BLUE_BITS;
+    iattributes[niattribs++] = capabilities.getBlueBits();
+    iattributes[niattribs++] = WGLExt.WGL_ALPHA_BITS;
+    iattributes[niattribs++] = capabilities.getAlphaBits();
+    iattributes[niattribs++] = WGLExt.WGL_STENCIL_BITS;
+    iattributes[niattribs++] = capabilities.getStencilBits();
+    if (capabilities.getAccumRedBits()   > 0 ||
+        capabilities.getAccumGreenBits() > 0 ||
+        capabilities.getAccumBlueBits()  > 0 ||
+        capabilities.getAccumAlphaBits() > 0) {
+      iattributes[niattribs++] = WGLExt.WGL_ACCUM_BITS;
+      iattributes[niattribs++] = (capabilities.getAccumRedBits() +
+                                  capabilities.getAccumGreenBits() +
+                                  capabilities.getAccumBlueBits() +
+                                  capabilities.getAccumAlphaBits());
+      iattributes[niattribs++] = WGLExt.WGL_ACCUM_RED_BITS;
+      iattributes[niattribs++] = capabilities.getAccumRedBits();
+      iattributes[niattribs++] = WGLExt.WGL_ACCUM_GREEN_BITS;
+      iattributes[niattribs++] = capabilities.getAccumGreenBits();
+      iattributes[niattribs++] = WGLExt.WGL_ACCUM_BLUE_BITS;
+      iattributes[niattribs++] = capabilities.getAccumBlueBits();
+      iattributes[niattribs++] = WGLExt.WGL_ACCUM_ALPHA_BITS;
+      iattributes[niattribs++] = capabilities.getAccumAlphaBits();
+    }
+
+    if (wglExt.isExtensionAvailable("WGL_ARB_multisample")) {
+      if (capabilities.getSampleBuffers()) {
+        iattributes[niattribs++] = WGLExt.WGL_SAMPLE_BUFFERS;
+        iattributes[niattribs++] = GL.GL_TRUE;
+        iattributes[niattribs++] = WGLExt.WGL_SAMPLES;
+        iattributes[niattribs++] = capabilities.getNumSamples();
+      }
+    }
+
+    boolean rtt      = capabilities.getPbufferRenderToTexture();
+    boolean rect     = capabilities.getPbufferRenderToTextureRectangle();
+    boolean useFloat = capabilities.getPbufferFloatingPointBuffers();
+    boolean ati      = false;
+    if (pbuffer) {
+      // Check some invariants and set up some state
+      if (rect && !rtt) {
+        throw new GLException("Render-to-texture-rectangle requires render-to-texture to be specified");
+      }
+
+      if (rect) {
+        if (!wglExt.isExtensionAvailable("GL_NV_texture_rectangle")) {
+          throw new GLException("Render-to-texture-rectangle requires GL_NV_texture_rectangle extension");
+        }
+      }
+
+      if (useFloat) {
+        if (!wglExt.isExtensionAvailable("WGL_ATI_pixel_format_float") &&
+            !wglExt.isExtensionAvailable("WGL_NV_float_buffer")) {
+          throw new GLException("Floating-point pbuffers not supported by this hardware");
+        }
+
+        // Prefer NVidia extension over ATI
+        if (wglExt.isExtensionAvailable("WGL_NV_float_buffer")) {
+          ati = false;
+          floatMode[0] = GLPbuffer.NV_FLOAT;
+        } else {
+          ati = true;
+          floatMode[0] = GLPbuffer.ATI_FLOAT;
+        }
+        if (DEBUG) {
+          System.err.println("Using " + (ati ? "ATI" : "NVidia") + " floating-point extension");
+        }
+      }
+
+      // See whether we need to change the pixel type to support ATI's
+      // floating-point pbuffers
+      if (useFloat && ati) {
+        if (rtt) {
+          throw new GLException("Render-to-floating-point-texture not supported on ATI hardware");
+        } else {
+          iattributes[niattribs++] = WGLExt.WGL_PIXEL_TYPE;
+          iattributes[niattribs++] = WGLExt.WGL_TYPE_RGBA_FLOAT;
+        }
+      } else {
+        if (!rtt) {
+          // Currently we don't support non-truecolor visuals in the
+          // NWCapabilities, so we don't offer the option of making
+          // color-index pbuffers.
+          iattributes[niattribs++] = WGLExt.WGL_PIXEL_TYPE;
+          iattributes[niattribs++] = WGLExt.WGL_TYPE_RGBA;
+        }
+      }
+
+      if (useFloat && !ati) {
+        iattributes[niattribs++] = WGLExt.WGL_FLOAT_COMPONENTS_NV;
+        iattributes[niattribs++] = GL.GL_TRUE;
+      }
+
+      if (rtt) {
+        if (useFloat) {
+          assert(!ati);
+          if (!rect) {
+            throw new GLException("Render-to-floating-point-texture only supported on NVidia hardware with render-to-texture-rectangle");
+          }
+          iattributes[niattribs++] = WGLExt.WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV;
+          iattributes[niattribs++] = GL.GL_TRUE;
+        } else {
+          iattributes[niattribs++] = rect ? WGLExt.WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV : WGLExt.WGL_BIND_TO_TEXTURE_RGB;
+          iattributes[niattribs++] = GL.GL_TRUE;
+        }
+      }
+    } else {
+      iattributes[niattribs++] = WGLExt.WGL_PIXEL_TYPE;
+      iattributes[niattribs++] = WGLExt.WGL_TYPE_RGBA;
+    }
+
+    return true;
+  }
+
+  protected static NWCapabilities iattributes2NWCapabilities(int[] iattribs,
+                                                             int niattribs,
+                                                             int[] iresults,
+                                                             boolean requireRenderToWindow) {
+    NWCapabilities res = new NWCapabilities();
+    for (int i = 0; i < niattribs; i++) {
+      int attr = iattribs[i];
+      switch (attr) {
+        case WGLExt.WGL_DRAW_TO_WINDOW:
+          if (requireRenderToWindow && iresults[i] != GL.GL_TRUE)
+            return null;
+          break;
+
+        case WGLExt.WGL_DRAW_TO_PBUFFER:
+          break;
+
+        case WGLExt.WGL_ACCELERATION:
+          res.setHardwareAccelerated(iresults[i] == WGLExt.WGL_FULL_ACCELERATION);
+          break;
+
+        case WGLExt.WGL_SUPPORT_OPENGL:
+          if (iresults[i] != GL.GL_TRUE)
+            return null;
+          break;
+
+        case WGLExt.WGL_DEPTH_BITS:
+          res.setDepthBits(iresults[i]);
+          break;
+
+        case WGLExt.WGL_STENCIL_BITS:
+          res.setStencilBits(iresults[i]);
+          break;
+
+        case WGLExt.WGL_DOUBLE_BUFFER:
+          res.setDoubleBuffered(iresults[i] == GL.GL_TRUE);
+          break;
+
+        case WGLExt.WGL_STEREO:
+          res.setStereo(iresults[i] == GL.GL_TRUE);
+          break;
+
+        case WGLExt.WGL_PIXEL_TYPE:
+          // Fail softly with unknown results here
+          if (iresults[i] == WGLExt.WGL_TYPE_RGBA||
+              iresults[i] == WGLExt.WGL_TYPE_RGBA_FLOAT) {
+            res.setPbufferFloatingPointBuffers(true);
+          }
+          break;
+
+        case WGLExt.WGL_FLOAT_COMPONENTS_NV:
+          if (iresults[i] != 0) {
+            res.setPbufferFloatingPointBuffers(true);
+          }
+          break;
+
+        case WGLExt.WGL_RED_BITS:
+          res.setRedBits(iresults[i]);
+          break;
+          
+        case WGLExt.WGL_GREEN_BITS:
+          res.setGreenBits(iresults[i]);
+          break;
+
+        case WGLExt.WGL_BLUE_BITS:
+          res.setBlueBits(iresults[i]);
+          break;
+
+        case WGLExt.WGL_ALPHA_BITS:
+          res.setAlphaBits(iresults[i]);
+          break;
+
+        case WGLExt.WGL_ACCUM_RED_BITS:
+          res.setAccumRedBits(iresults[i]);
+          break;
+
+        case WGLExt.WGL_ACCUM_GREEN_BITS:
+          res.setAccumGreenBits(iresults[i]);
+          break;
+
+        case WGLExt.WGL_ACCUM_BLUE_BITS:
+          res.setAccumBlueBits(iresults[i]);
+          break;
+
+        case WGLExt.WGL_ACCUM_ALPHA_BITS:
+          res.setAccumAlphaBits(iresults[i]);
+          break;
+
+        case WGLExt.WGL_SAMPLE_BUFFERS:
+          res.setSampleBuffers(iresults[i] != 0);
+          break;
+
+        case WGLExt.WGL_SAMPLES:
+          res.setNumSamples(iresults[i]);
+          break;
+
+        default:
+          throw new GLException("Unknown pixel format attribute " + iattribs[i]);
+      }
+    }
+    return res;
+  }
+
+  protected static String getThreadName() {
+    return Thread.currentThread().getName();
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLDrawableFactory.java b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLDrawableFactory.java
new file mode 100644
index 000000000..437b57db0
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLDrawableFactory.java
@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.windows.wgl;
+
+import java.nio.*;
+import java.util.*;
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import javax.media.opengl.util.BufferUtil;
+
+public class WindowsWGLDrawableFactory extends GLDrawableFactoryImpl {
+  private static final boolean DEBUG = Debug.debug("WindowsWGLDrawableFactory");
+  private static final boolean VERBOSE = Debug.verbose();
+
+  // Handle to GLU32.dll
+  // FIXME: this should go away once we delete support for the C GLU library
+  private long hglu32;
+
+  public WindowsWGLDrawableFactory() {
+    super();
+  }
+
+  public AbstractGraphicsConfiguration chooseGraphicsConfiguration(NWCapabilities capabilities,
+                                                                   NWCapabilitiesChooser chooser,
+                                                                   AbstractGraphicsDevice device) {
+    return null;
+  }
+
+  public GLDrawable createGLDrawable(NativeWindow target,
+                                  NWCapabilities capabilities,
+                                  NWCapabilitiesChooser chooser) {
+    if (target == null) {
+      throw new IllegalArgumentException("Null target");
+    }
+    target = NativeWindowFactory.getNativeWindow(target);
+    if (capabilities == null) {
+      capabilities = new NWCapabilities();
+    }
+    if (chooser == null) {
+      chooser = new DefaultNWCapabilitiesChooser();
+    }
+    return new WindowsOnscreenWGLDrawable(this, target, capabilities, chooser);
+  }
+
+  public GLDrawableImpl createOffscreenDrawable(NWCapabilities capabilities,
+                                                NWCapabilitiesChooser chooser,
+                                                int width,
+                                                int height) {
+    return new WindowsOffscreenWGLDrawable(this, capabilities, chooser, width, height);
+  }
+
+  private boolean pbufferSupportInitialized = false;
+  private boolean canCreateGLPbuffer = false;
+  public boolean canCreateGLPbuffer() {
+    if (!pbufferSupportInitialized) {
+      final GLDrawableFactory factory = this;
+      Runnable r = new Runnable() {
+          public void run() {
+            WindowsDummyWGLDrawable dummyDrawable = new WindowsDummyWGLDrawable(factory);
+            GLContext dummyContext  = dummyDrawable.createContext(null);
+            if (dummyContext != null) {
+              GLContext lastContext = GLContext.getCurrent();
+              if (lastContext != null) {
+                lastContext.release();
+              }
+              dummyContext.makeCurrent();
+              GL dummyGL = dummyContext.getGL();
+              canCreateGLPbuffer = dummyGL.isExtensionAvailable("GL_ARB_pbuffer");
+              pbufferSupportInitialized = true;
+              dummyContext.release();
+              dummyContext.destroy();
+              dummyDrawable.destroy();
+              if (lastContext != null) {
+                lastContext.makeCurrent();
+              }
+            }
+          }
+        };
+      maybeDoSingleThreadedWorkaround(r);
+    }
+    if (DEBUG) {
+      System.err.println("WindowsWGLDrawableFactory.canCreateGLPbuffer() = " + canCreateGLPbuffer);
+    }
+    return canCreateGLPbuffer;
+  }
+
+  public GLPbuffer createGLPbuffer(final NWCapabilities capabilities,
+                                   final NWCapabilitiesChooser chooser,
+                                   final int initialWidth,
+                                   final int initialHeight,
+                                   final GLContext shareWith) {
+    if (!canCreateGLPbuffer()) {
+      throw new GLException("Pbuffer support not available with current graphics card");
+    }
+    final List returnList = new ArrayList();
+    final GLDrawableFactory factory = this;
+    Runnable r = new Runnable() {
+        public void run() {
+          WindowsDummyWGLDrawable dummyDrawable = new WindowsDummyWGLDrawable(factory);
+          WindowsWGLContext       dummyContext  = (WindowsWGLContext) dummyDrawable.createContext(null);
+          GLContext lastContext = GLContext.getCurrent();
+          if (lastContext != null) {
+            lastContext.release();
+          }
+          dummyContext.makeCurrent();
+          WGLExt dummyWGLExt = dummyContext.getWGLExt();
+          try {
+            WindowsPbufferWGLDrawable pbufferDrawable = new WindowsPbufferWGLDrawable(factory, capabilities,
+                                                                                    initialWidth,
+                                                                                    initialHeight,
+                                                                                    dummyDrawable,
+                                                                                    dummyWGLExt);
+            GLPbufferImpl pbuffer = new GLPbufferImpl(pbufferDrawable, shareWith);
+            returnList.add(pbuffer);
+            dummyContext.release();
+            dummyContext.destroy();
+            dummyDrawable.destroy();
+          } finally {
+            if (lastContext != null) {
+              lastContext.makeCurrent();
+            }
+          }
+        }
+      };
+    maybeDoSingleThreadedWorkaround(r);
+    return (GLPbuffer) returnList.get(0);
+  }
+
+  public GLContext createExternalGLContext() {
+    return new WindowsExternalWGLContext();
+  }
+
+  public boolean canCreateExternalGLDrawable() {
+    return true;
+  }
+
+  public GLDrawable createExternalGLDrawable() {
+    return WindowsExternalWGLDrawable.create(this);
+  }
+
+  public void loadGLULibrary() {
+    if (hglu32 == 0) {
+      hglu32 = WGL.LoadLibraryA("GLU32");
+      if (hglu32 == 0) {
+        throw new GLException("Error loading GLU32.DLL");
+      }
+    }
+  }
+
+  public long dynamicLookupFunction(String glFuncName) {
+    long res = WGL.wglGetProcAddress(glFuncName);
+    if (res == 0) {
+      // GLU routines aren't known to the OpenGL function lookup
+      if (hglu32 != 0) {
+        res = WGL.GetProcAddress(hglu32, glFuncName);
+      }
+    }
+    return res;
+  }
+
+  static String wglGetLastError() {
+    long err = WGL.GetLastError();
+    String detail = null;
+    switch ((int) err) {
+      case WGL.ERROR_INVALID_PIXEL_FORMAT: detail = "ERROR_INVALID_PIXEL_FORMAT";       break;
+      case WGL.ERROR_NO_SYSTEM_RESOURCES:  detail = "ERROR_NO_SYSTEM_RESOURCES";        break;
+      case WGL.ERROR_INVALID_DATA:         detail = "ERROR_INVALID_DATA";               break;
+      case WGL.ERROR_PROC_NOT_FOUND:       detail = "ERROR_PROC_NOT_FOUND";             break;
+      case WGL.ERROR_INVALID_WINDOW_HANDLE:detail = "ERROR_INVALID_WINDOW_HANDLE";      break;
+      default:                             detail = "(Unknown error code " + err + ")"; break;
+    }
+    return detail;
+  }
+
+  private void maybeDoSingleThreadedWorkaround(Runnable action) {
+    if (Threading.isSingleThreaded() &&
+        !Threading.isOpenGLThread()) {
+      Threading.invokeOnOpenGLThread(action);
+    } else {
+      action.run();
+    }
+  }
+
+  public boolean canCreateContextOnJava2DSurface() {
+    return false;
+  }
+
+  public GLContext createContextOnJava2DSurface(Object graphics, GLContext shareWith)
+    throws GLException {
+    throw new GLException("Unimplemented on this platform");
+  }
+
+  //------------------------------------------------------
+  // Gamma-related functionality
+  //
+
+  private static final int GAMMA_RAMP_LENGTH = 256;
+
+  protected int getGammaRampLength() {
+    return GAMMA_RAMP_LENGTH;
+  }
+
+  protected boolean setGammaRamp(float[] ramp) {
+    short[] rampData = new short[3 * GAMMA_RAMP_LENGTH];
+    for (int i = 0; i < GAMMA_RAMP_LENGTH; i++) {
+      short scaledValue = (short) (ramp[i] * 65535);
+      rampData[i] = scaledValue;
+      rampData[i +     GAMMA_RAMP_LENGTH] = scaledValue;
+      rampData[i + 2 * GAMMA_RAMP_LENGTH] = scaledValue;
+    }
+
+    long screenDC = WGL.GetDC(0);
+    boolean res = WGL.SetDeviceGammaRamp(screenDC, ShortBuffer.wrap(rampData));
+    WGL.ReleaseDC(0, screenDC);
+    return res;
+  }
+
+  protected Buffer getGammaRamp() {
+    ShortBuffer rampData = ShortBuffer.allocate(3 * GAMMA_RAMP_LENGTH);
+    long screenDC = WGL.GetDC(0);
+    boolean res = WGL.GetDeviceGammaRamp(screenDC, rampData);
+    WGL.ReleaseDC(0, screenDC);
+    if (!res) {
+      return null;
+    }
+    return rampData;
+  }
+
+  protected void resetGammaRamp(Buffer originalGammaRamp) {
+    if (originalGammaRamp == null) {
+      // getGammaRamp failed earlier
+      return;
+    }
+    long screenDC = WGL.GetDC(0);
+    WGL.SetDeviceGammaRamp(screenDC, originalGammaRamp);
+    WGL.ReleaseDC(0, screenDC);
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/x11/glx/GLXUtil.java b/src/jogl/classes/com/sun/opengl/impl/x11/glx/GLXUtil.java
new file mode 100644
index 000000000..800396502
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/x11/glx/GLXUtil.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.sun.opengl.impl.x11.glx;
+
+import javax.media.opengl.*;
+
+import com.sun.opengl.impl.*;
+import javax.media.nwi.NativeWindowFactory;
+import com.sun.nwi.impl.NullWindow;
+import com.sun.nwi.impl.x11.*;
+
+public class GLXUtil {
+    private static final boolean DEBUG = Debug.debug("GLXUtil");
+
+    private GLXUtil() {}
+
+    // ATI's proprietary drivers apparently send GLX tokens even for
+    // direct contexts, so we need to disable the context optimizations
+    // in this case
+    private static boolean isVendorATI;
+
+    // Display connection for use by visual selection algorithm and by all offscreen surfaces
+    private static boolean multisampleAvailable=false;
+
+    private static long staticDisplay=0;
+
+    private static void init() {
+        if (staticDisplay == 0) {
+            staticDisplay = X11Util.getDisplayConnection();
+            if(staticDisplay!=0) {
+                NativeWindowFactory.getDefaultFactory().getToolkitLock().lock();
+                try {
+                    if (DEBUG) {
+                        long display = staticDisplay;
+                        int screen = X11Lib.DefaultScreen(display);
+                        System.err.println("!!! GLX server vendor : " +
+                                           GLX.glXQueryServerString(display, screen, GLX.GLX_VENDOR));
+                        System.err.println("!!! GLX server version: " +
+                                           GLX.glXQueryServerString(display, screen, GLX.GLX_VERSION));
+                        System.err.println("!!! GLX client vendor : " +
+                                           GLX.glXGetClientString(display, GLX.GLX_VENDOR));
+                        System.err.println("!!! GLX client version: " +
+                                           GLX.glXGetClientString(display, GLX.GLX_VERSION));
+                    }
+                    String vendor = GLX.glXGetClientString(staticDisplay, GLX.GLX_VENDOR);
+                    if (vendor != null && vendor.startsWith("ATI")) {
+                        isVendorATI = true;
+                    }
+                    String exts = GLX.glXGetClientString(staticDisplay, GLX.GLX_EXTENSIONS);
+                    if (exts != null) {
+                        multisampleAvailable = (exts.indexOf("GLX_ARB_multisample") >= 0);
+                    }
+                } finally {
+                    NativeWindowFactory.getDefaultFactory().getToolkitLock().unlock();
+                }
+            } else {
+                throw new GLException("Unable to open default display, needed for visual selection and offscreen surface handling");
+            }
+        }
+    }
+
+    public static boolean isMultisampleAvailable() {
+        init();
+        return multisampleAvailable;
+    }
+
+    /** Workaround for apparent issue with ATI's proprietary drivers
+        where direct contexts still send GLX tokens for GL calls */
+    public static boolean isVendorATI() {
+        init();
+        return isVendorATI;
+    }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11ExternalGLXContext.java b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11ExternalGLXContext.java
new file mode 100755
index 000000000..02eff5d3e
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11ExternalGLXContext.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.x11.glx;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.nwi.impl.NullWindow;
+import com.sun.nwi.impl.x11.*;
+
+public class X11ExternalGLXContext extends X11GLXContext {
+  private boolean firstMakeCurrent = true;
+  private boolean created = true;
+  private GLContext lastContext;
+
+  public X11ExternalGLXContext() {
+    super(null, null);
+    getDrawableImpl().getFactoryImpl().lockToolkit();
+    try {
+      context = GLX.glXGetCurrentContext();
+      if (context == 0) {
+        throw new GLException("Error: attempted to make an external GLContext without a drawable/context current");
+      }
+      NullWindow nw = new NullWindow();
+      nw.setDisplayHandle(GLX.glXGetCurrentDisplay());
+      drawable = new Drawable(getGLDrawable().getFactory(), nw);
+    } finally {
+      getDrawableImpl().getFactoryImpl().unlockToolkit();
+    }
+    GLContextShareSet.contextCreated(this);
+    resetGLFunctionAvailability();
+  }
+
+  protected void create() {
+  }
+
+  public int makeCurrent() throws GLException {
+    // Save last context if necessary to allow external GLContexts to
+    // talk to other GLContexts created by this library
+    GLContext cur = getCurrent();
+    if (cur != null && cur != this) {
+      lastContext = cur;
+      setCurrent(null);
+    }
+    return super.makeCurrent();
+  }  
+
+  public void release() throws GLException {
+    super.release();
+    setCurrent(lastContext);
+    lastContext = null;
+  }
+
+  protected int makeCurrentImpl() throws GLException {
+    if (firstMakeCurrent) {
+      firstMakeCurrent = false;
+      return CONTEXT_CURRENT_NEW;
+    }
+    return CONTEXT_CURRENT;
+  }
+
+  protected void releaseImpl() throws GLException {
+  }
+
+  protected void destroyImpl() throws GLException {
+    created = false;
+    GLContextShareSet.contextDestroyed(this);
+  }
+
+  public boolean isCreated() {
+    return created;
+  }
+
+  // Need to provide the display connection to extension querying APIs
+  class Drawable extends X11GLXDrawable {
+    Drawable(GLDrawableFactory factory, NativeWindow comp) {
+      super(factory, comp, true, null, null);
+    }
+
+    public GLContext createContext(GLContext shareWith) {
+      throw new GLException("Should not call this");
+    }
+
+    public int getWidth() {
+      throw new GLException("Should not call this");
+    }
+
+    public int getHeight() {
+      throw new GLException("Should not call this");
+    }
+
+    public void setSize(int width, int height) {
+      throw new GLException("Should not call this");
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11ExternalGLXDrawable.java b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11ExternalGLXDrawable.java
new file mode 100755
index 000000000..9d5331b9c
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11ExternalGLXDrawable.java
@@ -0,0 +1,228 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.x11.glx;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.nwi.impl.NullWindow;
+import com.sun.nwi.impl.x11.*;
+
+import java.nio.LongBuffer;
+
+public class X11ExternalGLXDrawable extends X11GLXDrawable {
+  private int fbConfigID;
+  private int renderType;
+  private long readDrawable;
+
+  private X11ExternalGLXDrawable(GLDrawableFactory factory, NativeWindow component) {
+    super(factory, component, true, null, null);
+
+    readDrawable = GLX.glXGetCurrentReadDrawable();
+
+    // Need GLXFBConfig ID in order to properly create new contexts
+    // on this drawable
+    long display = getNativeWindow().getDisplayHandle();
+    long context = GLX.glXGetCurrentContext();
+    int[] val = new int[1];
+    GLX.glXQueryContext(display, context, GLX.GLX_FBCONFIG_ID, val, 0);
+    fbConfigID = val[0];
+    renderType = GLX.GLX_RGBA_TYPE;
+    GLX.glXQueryContext(display, context, GLX.GLX_RENDER_TYPE, val, 0);
+    if ((val[0] & GLX.GLX_RGBA_BIT) == 0) {
+        if (DEBUG) {
+          System.err.println("X11ExternalGLXDrawable: WARNING: forcing GLX_RGBA_TYPE for newly created contexts");
+        }
+    }
+  }
+
+  protected static X11ExternalGLXDrawable create(GLDrawableFactory factory) {
+    ((GLDrawableFactoryImpl) factory).lockToolkit();
+    try {
+      long display = GLX.glXGetCurrentDisplay();
+      long drawable = GLX.glXGetCurrentDrawable();
+      if (drawable == 0) {
+        throw new GLException("Error: attempted to make an external GLDrawable without a drawable/context current");
+      }
+
+      long context = GLX.glXGetCurrentContext();
+      int[] val = new int[1];
+      GLX.glXQueryContext(display, context, GLX.GLX_SCREEN, val, 0);
+      int screen = val[0];
+      NullWindow nw = new NullWindow();
+      nw.setSurfaceHandle(drawable);
+      nw.setScreenIndex(screen);
+      return new X11ExternalGLXDrawable(factory, nw);
+    } finally {
+      ((GLDrawableFactoryImpl) factory).unlockToolkit();
+    }
+  }
+
+  public GLContext createContext(GLContext shareWith) {
+    return new Context(this, shareWith);
+  }
+
+  public void setSize(int newWidth, int newHeight) {
+    throw new GLException("Should not call this");
+  }
+
+  public int getWidth() {
+    throw new GLException("Should not call this");
+  }  
+
+  public int getHeight() {
+    throw new GLException("Should not call this");
+  }  
+
+  class Context extends X11GLXContext {
+    Context(X11GLXDrawable drawable, GLContext shareWith) {
+      super(drawable, shareWith);
+    }
+
+    protected int makeCurrentImpl() throws GLException {
+      if (drawable.getNativeWindow().getSurfaceHandle() == 0) {
+        // parent drawable not properly initialized
+        // FIXME: signal error?
+        if (DEBUG) {
+          System.err.println("parent drawable not properly initialized");
+        }
+        return CONTEXT_NOT_CURRENT;
+      }
+
+      // Note that we have to completely override makeCurrentImpl
+      // because the underlying makeCurrent call differs from the norm
+      getFactoryImpl().lockToolkit();
+      try {
+        boolean created = false;
+        if (context == 0) {
+          create();
+          if (DEBUG) {
+            System.err.println(getThreadName() + ": !!! Created GL context for " + getClass().getName());
+          }
+          created = true;
+        }
+
+        if (!GLX.glXMakeContextCurrent(drawable.getNativeWindow().getDisplayHandle(),
+                                       drawable.getNativeWindow().getSurfaceHandle(),
+                                       readDrawable,
+                                       context)) {
+          throw new GLException("Error making context current");
+        } else {
+          if (DEBUG && VERBOSE) {
+            System.err.println(getThreadName() + ": glXMakeCurrent(display " + toHexString(drawable.getNativeWindow().getDisplayHandle()) +
+                               ", drawable " + toHexString(drawable.getNativeWindow().getSurfaceHandle()) +
+                               ", context " + toHexString(context) + ") succeeded");
+          }
+        }
+
+        if (created) {
+          resetGLFunctionAvailability();
+          return CONTEXT_CURRENT_NEW;
+        }
+        return CONTEXT_CURRENT;
+      } finally {
+        getFactoryImpl().unlockToolkit();
+      }
+    }
+
+    protected void releaseImpl() throws GLException {
+      getFactoryImpl().lockToolkit();
+      try {
+        if (!GLX.glXMakeContextCurrent(drawable.getNativeWindow().getDisplayHandle(), 0, 0, 0)) {
+          throw new GLException("Error freeing OpenGL context");
+        }
+      } finally {
+        getFactoryImpl().unlockToolkit();
+      }
+    }
+
+    protected void create() {
+      long display = getNativeWindow().getDisplayHandle();
+      int screen = getNativeWindow().getScreenIndex();
+      // We already have the GLXFBConfig ID for the context. All we
+      // need to do is use it to choose the GLXFBConfig and then
+      // create a context with it.
+      int[]   iattributes = new int[] {
+        GLX.GLX_FBCONFIG_ID,
+        fbConfigID,
+        0,
+        0
+      };
+      float[] fattributes = new float[0];
+      int[] nelementsTmp = new int[1];
+      LongBuffer fbConfigs = GLX.glXChooseFBConfig(display, screen, iattributes, 0, nelementsTmp, 0);
+      int nelements = nelementsTmp[0];
+      if (nelements <= 0) {
+        throw new GLException("context creation error: couldn't find a suitable frame buffer configuration");
+      }
+      if (nelements != 1) {
+        throw new GLException("context creation error: shouldn't get more than one GLXFBConfig");
+      }
+      // Note that we currently don't allow selection of anything but
+      // the first GLXFBConfig in the returned list (there should be only one)
+      long fbConfig = fbConfigs.get(0);
+      // Create a gl context for the drawable
+      X11GLXContext other = (X11GLXContext) GLContextShareSet.getShareContext(this);
+      long share = 0;
+      if (other != null) {
+        share = other.getContext();
+        if (share == 0) {
+          throw new GLException("GLContextShareSet returned an invalid OpenGL context");
+        }
+      }
+      // FIXME: how to determine "direct" bit?
+      context = GLX.glXCreateNewContext(display, fbConfig, renderType, share, true);
+      if (context == 0) {
+        String detail = "  display=" + toHexString(display) +
+          " fbconfig=" + fbConfig +
+          " fbconfigID=" + toHexString(fbConfigID) +
+          " renderType=" + toHexString(renderType) +
+          " share=" + toHexString(share);
+        throw new GLException("context creation error: glXCreateNewContext() failed: " + detail);
+      }
+      GLContextShareSet.contextCreated(this);
+
+      if (DEBUG) {
+        System.err.println("Created context " + toHexString(context) +
+                           " for GLXDrawable " + toHexString(drawable.getNativeWindow().getSurfaceHandle()));
+      }
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11GLXContext.java b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11GLXContext.java
new file mode 100644
index 000000000..7f39db2af
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11GLXContext.java
@@ -0,0 +1,350 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.x11.glx;
+
+import java.nio.*;
+import java.util.*;
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.opengl.impl.x11.glx.*;
+import com.sun.nwi.impl.x11.*;
+import com.sun.gluegen.runtime.ProcAddressTable;
+
+public abstract class X11GLXContext extends GLContextImpl {
+  protected X11GLXDrawable drawable;
+  protected long context;
+  private boolean glXQueryExtensionsStringInitialized;
+  private boolean glXQueryExtensionsStringAvailable;
+  private static final Map/*<String, String>*/ functionNameMap;
+  private GLXExt glXExt;
+  // Table that holds the addresses of the native C-language entry points for
+  // GLX extension functions.
+  private GLXExtProcAddressTable glXExtProcAddressTable;
+
+  static {
+    functionNameMap = new HashMap();
+    functionNameMap.put("glAllocateMemoryNV", "glXAllocateMemoryNV");
+    functionNameMap.put("glFreeMemoryNV", "glXFreeMemoryNV");
+  }
+
+  public X11GLXContext(X11GLXDrawable drawable,
+                      GLContext shareWith) {
+    super(shareWith);
+    this.drawable = drawable;
+  }
+  
+  public final ProcAddressTable getPlatformExtProcAddressTable() {
+    return getGLXExtProcAddressTable();
+  }
+
+  public final GLXExtProcAddressTable getGLXExtProcAddressTable() {
+    return glXExtProcAddressTable;
+  }
+
+  public Object getPlatformGLExtensions() {
+    return getGLXExt();
+  }
+
+  public GLXExt getGLXExt() {
+    if (glXExt == null) {
+      glXExt = new GLXExtImpl(this);
+    }
+    return glXExt;
+  }
+
+  public GLDrawable getGLDrawable() {
+    return drawable;
+  }
+
+  protected String mapToRealGLFunctionName(String glFunctionName) {
+    String lookup = (String) functionNameMap.get(glFunctionName);
+    if (lookup != null) {
+      return lookup;
+    }
+    return glFunctionName;
+  }
+
+  protected String mapToRealGLExtensionName(String glExtensionName) {
+    return glExtensionName;
+  }
+
+  /** Helper routine which usually just turns around and calls
+   * createContext (except for pbuffers, which use a different context
+   * creation mechanism). Should only be called by {@link
+   * makeCurrentImpl()}.
+   */
+  protected abstract void create();
+
+  /**
+   * Creates and initializes an appropriate OpenGL context. Should only be
+   * called by {@link create()}.
+   */
+  protected void createContext(boolean onscreen) {
+    XVisualInfo vis = drawable.chooseVisual(onscreen);
+    X11GLXContext other = (X11GLXContext) GLContextShareSet.getShareContext(this);
+    long share = 0;
+    if (other != null) {
+      share = other.getContext();
+      if (share == 0) {
+        throw new GLException("GLContextShareSet returned an invalid OpenGL context");
+      }
+    }
+    context = GLX.glXCreateContext(drawable.getNativeWindow().getDisplayHandle(), vis, share, onscreen);
+    if (context == 0) {
+      throw new GLException("Unable to create OpenGL context");
+    }
+    GLContextShareSet.contextCreated(this);
+  }
+
+  protected int makeCurrentImpl() throws GLException {
+    if (drawable.getNativeWindow().getSurfaceHandle() == 0) {
+        if (DEBUG) {
+          System.err.println("drawable not properly initialized");
+        }
+        return CONTEXT_NOT_CURRENT;
+    }
+    boolean created = false;
+    if (context == 0) {
+      create();
+      if (DEBUG) {
+        System.err.println(getThreadName() + ": !!! Created GL context for " + getClass().getName());
+      }
+      created = true;
+    }
+
+    if (GLX.glXGetCurrentContext() != context) {
+        if (!GLX.glXMakeContextCurrent(drawable.getNativeWindow().getDisplayHandle(), 
+                                       drawable.getNativeWindow().getSurfaceHandle(), 
+                                       drawable.getNativeWindow().getSurfaceHandle(), 
+                                       context)) {
+          throw new GLException("Error making context current");
+        } else {
+          if (DEBUG && (VERBOSE || created)) {
+            System.err.println(getThreadName() + ": glXMakeCurrent(display " + 
+                               toHexString(drawable.getNativeWindow().getDisplayHandle()) +
+                               ", drawable " + toHexString(drawable.getNativeWindow().getSurfaceHandle()) +
+                               ", context " + toHexString(context) + ") succeeded");
+          }
+        }
+    }
+
+    if (created) {
+      resetGLFunctionAvailability();
+      return CONTEXT_CURRENT_NEW;
+    }
+    return CONTEXT_CURRENT;
+  }
+
+  protected void releaseImpl() throws GLException {
+    getDrawableImpl().getFactoryImpl().lockToolkit();
+    try {
+      if (!GLX.glXMakeContextCurrent(drawable.getNativeWindow().getDisplayHandle(), 0, 0, 0)) {
+        throw new GLException("Error freeing OpenGL context");
+      }
+    } finally {
+      getDrawableImpl().getFactoryImpl().unlockToolkit();
+    }
+  }
+
+  protected void destroyImpl() throws GLException {
+    getDrawableImpl().getFactoryImpl().lockToolkit();
+    try {
+      if (context != 0) {
+        if (DEBUG) {
+          System.err.println("glXDestroyContext(0x" +
+                             Long.toHexString(drawable.getNativeWindow().getDisplayHandle()) +
+                             ", 0x" +
+                             Long.toHexString(context) + ")");
+        }
+        GLX.glXDestroyContext(drawable.getNativeWindow().getDisplayHandle(), context);
+        if (DEBUG) {
+          System.err.println("!!! Destroyed OpenGL context " + context);
+        }
+        context = 0;
+        GLContextShareSet.contextDestroyed(this);
+      }
+    } finally {
+      getDrawableImpl().getFactoryImpl().unlockToolkit();
+    }
+  }
+
+  public boolean isCreated() {
+    return (context != 0);
+  }
+
+  public void copy(GLContext source, int mask) throws GLException {
+    long dst = getContext();
+    long src = ((X11GLXContext) source).getContext();
+    if (src == 0) {
+      throw new GLException("Source OpenGL context has not been created");
+    }
+    if (dst == 0) {
+      throw new GLException("Destination OpenGL context has not been created");
+    }
+    if (drawable.getNativeWindow().getDisplayHandle() == 0) {
+      throw new GLException("Connection to X display not yet set up");
+    }
+    getDrawableImpl().getFactoryImpl().lockToolkit();
+    try {
+      GLX.glXCopyContext(drawable.getNativeWindow().getDisplayHandle(), src, dst, mask);
+      // Should check for X errors and raise GLException
+    } finally {
+      getDrawableImpl().getFactoryImpl().unlockToolkit();
+    }
+  }
+
+  protected void resetGLFunctionAvailability() {
+    super.resetGLFunctionAvailability();
+    if (DEBUG) {
+      System.err.println(getThreadName() + ": !!! Initializing GLX extension address table");
+    }
+    if (glXExtProcAddressTable == null) {
+      // FIXME: cache ProcAddressTables by capability bits so we can
+      // share them among contexts with the same capabilities
+      glXExtProcAddressTable = new GLXExtProcAddressTable();
+    }          
+    resetProcAddressTable(getGLXExtProcAddressTable());
+  }
+  
+  public synchronized String getPlatformExtensionsString() {
+    if (!glXQueryExtensionsStringInitialized) {
+      glXQueryExtensionsStringAvailable =
+        getDrawableImpl().getFactoryImpl().dynamicLookupFunction("glXQueryExtensionsString") != 0;
+      glXQueryExtensionsStringInitialized = true;
+    }
+    if (glXQueryExtensionsStringAvailable) {
+      GLDrawableFactoryImpl factory = getDrawableImpl().getFactoryImpl();
+      factory.lockToolkit();
+      try {
+        String ret = GLX.glXQueryExtensionsString(drawable.getNativeWindow().getDisplayHandle(), 
+                                                  drawable.getNativeWindow().getScreenIndex());
+        if (DEBUG) {
+          System.err.println("!!! GLX extensions: " + ret);
+        }
+        return ret;
+      } finally {
+        factory.unlockToolkit();
+      }
+    } else {
+      return "";
+    }
+  }
+
+  /**
+   * using dynamic ProcAddressTable verification always
+   *
+  public boolean isFunctionAvailable(String glFunctionName)
+  {
+    boolean available = super.isFunctionAvailable(glFunctionName);
+    
+    // Sanity check for implementations that use proc addresses for run-time
+    // linking: if the function IS available, then make sure there's a proc
+    // address for it if it's an extension or not part of the OpenGL 1.1 core
+    // (post GL 1.1 functions are run-time linked on windows).
+    assert(!available ||
+           (getGLProcAddressTable().getAddressFor(mapToRealGLFunctionName(glFunctionName)) != 0 ||
+            FunctionAvailabilityCache.isPartOfGLCore("1.1", mapToRealGLFunctionName(glFunctionName)))
+           );
+
+    return available;
+  }*/
+  
+  public boolean isExtensionAvailable(String glExtensionName) {
+    if (glExtensionName.equals("GL_ARB_pbuffer") ||
+        glExtensionName.equals("GL_ARB_pixel_format")) {
+      return getGLDrawable().getFactory().canCreateGLPbuffer();
+    }
+    return super.isExtensionAvailable(glExtensionName);
+  }
+
+
+  public void setSwapInterval(int interval) {
+    getDrawableImpl().getFactoryImpl().lockToolkit();
+    try {
+      // FIXME: make the context current first? Currently assumes that
+      // will not be necessary. Make the caller do this?
+      GLXExt glXExt = getGLXExt();
+      if (glXExt.isExtensionAvailable("GLX_SGI_swap_control")) {
+        glXExt.glXSwapIntervalSGI(interval);
+      }
+    } finally {
+      getDrawableImpl().getFactoryImpl().unlockToolkit();
+    }
+  }
+
+  public ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3) {
+    return getGLXExt().glXAllocateMemoryNV(arg0, arg1, arg2, arg3);
+  }
+
+  public int getOffscreenContextPixelDataType() {
+    throw new GLException("Should not call this");
+  }
+
+  public int getOffscreenContextReadBuffer() {
+    throw new GLException("Should not call this");
+  }
+
+  public boolean offscreenImageNeedsVerticalFlip() {
+    throw new GLException("Should not call this");
+  }
+
+  public void bindPbufferToTexture() {
+    throw new GLException("Should not call this");
+  }
+
+  public void releasePbufferFromTexture() {
+    throw new GLException("Should not call this");
+  }
+
+  public boolean isOptimizable() {
+    return (super.isOptimizable() &&
+            !GLXUtil.isVendorATI());
+  }
+
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+
+  public long getContext() {
+    return context;
+  }
+
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11GLXDrawable.java b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11GLXDrawable.java
new file mode 100644
index 000000000..9f7b62dae
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11GLXDrawable.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.x11.glx;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.nwi.impl.x11.*;
+
+public abstract class X11GLXDrawable extends GLDrawableImpl {
+  protected static final boolean DEBUG = Debug.debug("X11GLXDrawable");
+
+  protected NWCapabilitiesChooser chooser;
+
+  protected X11GLXDrawable(GLDrawableFactory factory, NativeWindow comp, boolean realized,
+                           NWCapabilities requestedCapabilities,
+                           NWCapabilitiesChooser chooser) {
+    super(factory, comp, requestedCapabilities, realized);
+    this.chooser = chooser;
+  }
+
+  //---------------------------------------------------------------------------
+  // Internals only below this point
+  //
+
+  protected XVisualInfo chooseVisual(boolean onscreen) {
+    long display = getNativeWindow().getDisplayHandle();
+    long visualID = getNativeWindow().getVisualID();
+    if (display == 0) {
+      throw new GLException("null display");
+    }
+
+    // FIXME
+    if (onscreen) {
+      // The visual has already been chosen by the time we get here;
+      // it's specified by the GraphicsConfiguration of the
+      // GLCanvas. Fortunately, the JAWT supplies the visual ID for
+      // the component in a portable fashion, so all we have to do is
+      // use XGetVisualInfo with a VisualIDMask to get the
+      // corresponding XVisualInfo to pass into glXChooseVisual.
+      int[] count = new int[1];
+      XVisualInfo template = XVisualInfo.create();
+      // FIXME: probably not 64-bit clean
+      template.visualid((int) visualID);
+      getFactoryImpl().lockToolkit();
+      XVisualInfo[] infos = X11Lib.XGetVisualInfo(display, X11Lib.VisualIDMask, template, count, 0);
+      getFactoryImpl().unlockToolkit();
+      if (infos == null || infos.length == 0) {
+        throw new GLException("Error while getting XVisualInfo for visual ID " + visualID+", "+this);
+      }
+      if (DEBUG) {
+        System.err.println("!!! Fetched XVisualInfo for visual ID 0x" + Long.toHexString(visualID));
+        System.err.println("!!! Resulting XVisualInfo: visualid = 0x" + Long.toHexString(infos[0].visualid()));
+      }
+      // FIXME: the storage for the infos array is leaked (should
+      // clean it up somehow when we're done with the visual we're
+      // returning)
+      return infos[0];
+    } else {
+      // It isn't clear to me whether we need this much code to handle
+      // the offscreen case, where we're creating a pixmap into which
+      // to render...this is what we (incorrectly) used to do for the
+      // onscreen case
+
+      int screen = 0; // FIXME: provide way to specify this?
+      XVisualInfo vis = null;
+      int[] count = new int[1];
+      XVisualInfo template = XVisualInfo.create();
+      template.screen(screen);
+      XVisualInfo[] infos = null;
+      NWCapabilities[] caps = null;
+      getFactoryImpl().lockToolkit();
+      try {
+        infos = X11Lib.XGetVisualInfo(display, X11Lib.VisualScreenMask, template, count, 0);
+        if (infos == null) {
+          throw new GLException("Error while enumerating available XVisualInfos");
+        }
+        caps = new NWCapabilities[infos.length];
+        for (int i = 0; i < infos.length; i++) {
+          caps[i] = ((X11GLXDrawableFactory)getFactory()).xvi2NWCapabilities(display, infos[i]);
+        }
+      } finally {
+        getFactoryImpl().unlockToolkit();
+      }
+      NWCapabilities capabilities = getRequestedNWCapabilities();
+      int chosen = chooser.chooseCapabilities(capabilities, caps, -1);
+      if (chosen < 0 || chosen >= caps.length) {
+        throw new GLException("NWCapabilitiesChooser specified invalid index (expected 0.." + (caps.length - 1) + ")");
+      }
+      if (DEBUG) {
+        System.err.println("Chosen visual (" + chosen + "):");
+        System.err.println(caps[chosen]);
+      }
+      vis = infos[chosen];
+      if (vis == null) {
+        throw new GLException("NWCapabilitiesChooser chose an invalid visual");
+      }
+      // FIXME: the storage for the infos array is leaked (should
+      // clean it up somehow when we're done with the visual we're
+      // returning)
+
+      return vis;
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11GLXDrawableFactory.java b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11GLXDrawableFactory.java
new file mode 100644
index 000000000..170710633
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11GLXDrawableFactory.java
@@ -0,0 +1,574 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+package com.sun.opengl.impl.x11.glx;
+
+import java.nio.*;
+import java.security.*;
+import java.util.*;
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.gluegen.runtime.*;
+import com.sun.gluegen.runtime.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.opengl.impl.x11.glx.*;
+import com.sun.nwi.impl.NullWindow;
+import com.sun.nwi.impl.x11.*;
+
+public class X11GLXDrawableFactory extends GLDrawableFactoryImpl {
+  protected static final boolean DEBUG = Debug.debug("X11GLXDrawableFactory");
+
+  // Map for rediscovering the NWCapabilities associated with a
+  // particular screen and visualID after the fact
+  protected static Map visualToGLCapsMap = Collections.synchronizedMap(new HashMap());
+  // The screens for which we've already initialized it
+  protected static Set/*<Integer>*/ initializedScreenSet = Collections.synchronizedSet(new HashSet());
+  
+  public static class ScreenAndVisualIDKey {
+    private int screen;
+    private long visualID;
+
+    public ScreenAndVisualIDKey(int screen,
+                                long visualID) {
+      this.screen = screen;
+      this.visualID = visualID;
+    }
+
+    public int hashCode() {
+      return (int) (screen + 13 * visualID);
+    }
+
+    public boolean equals(Object obj) {
+      if ((obj == null) || (!(obj instanceof ScreenAndVisualIDKey))) {
+        return false;
+      }
+
+      ScreenAndVisualIDKey key = (ScreenAndVisualIDKey) obj;
+      return (screen == key.screen &&
+              visualID == key.visualID);
+    }
+
+    int  screen()   { return screen; }
+    long visualID() { return visualID; }
+  }
+
+  public X11GLXDrawableFactory() {
+    super();
+    // Must initialize GLX support eagerly in case a pbuffer is the
+    // first thing instantiated
+    GLProcAddressHelper.resetProcAddressTable(GLX.getGLXProcAddressTable(), this);
+  }
+
+  private static final int MAX_ATTRIBS = 128;
+
+  public AbstractGraphicsConfiguration chooseGraphicsConfiguration(NWCapabilities capabilities,
+                                                                   NWCapabilitiesChooser chooser,
+                                                                   AbstractGraphicsDevice absDevice) {
+    return null;
+  }
+
+  public GLDrawable createGLDrawable(NativeWindow target,
+                                     NWCapabilities capabilities,
+                                     NWCapabilitiesChooser chooser) {
+    if (target == null) {
+      throw new IllegalArgumentException("Null target");
+    }
+    target = NativeWindowFactory.getNativeWindow(target);
+    return new X11OnscreenGLXDrawable(this, target);
+  }
+
+  public void initializeVisualToNWCapabilitiesMap(int screen,
+                                                  XVisualInfo[] infos,
+                                                  NWCapabilities[] caps) {
+    Integer key = new Integer(screen);
+    if (!initializedScreenSet.contains(key)) {
+      for (int i = 0; i < infos.length; i++) {
+        if (caps[i] != null) {
+          visualToGLCapsMap.put(new ScreenAndVisualIDKey(screen, infos[i].visualid()),
+                                caps[i].clone());
+        }
+      }
+      initializedScreenSet.add(key);      
+    }
+  }
+
+  public NWCapabilities lookupCapabilitiesByScreenAndVisualID(int screenIndex,
+                                                              long visualID) {
+    return (NWCapabilities) visualToGLCapsMap.get(new ScreenAndVisualIDKey(screenIndex, visualID));
+  }
+
+  public GLDrawableImpl createOffscreenDrawable(NWCapabilities capabilities,
+                                                NWCapabilitiesChooser chooser,
+                                                int width,
+                                                int height) {
+    return new X11OffscreenGLXDrawable(this, capabilities, chooser, width, height);
+  }
+
+  private boolean pbufferSupportInitialized = false;
+  private boolean canCreateGLPbuffer = false;
+  public boolean canCreateGLPbuffer() {
+    if (!pbufferSupportInitialized) {
+      Runnable r = new Runnable() {
+          public void run() {
+            long display = X11Util.getDisplayConnection();
+            lockToolkit();
+            try {
+              int[] major = new int[1];
+              int[] minor = new int[1];
+              int screen = 0; // FIXME: provide way to specify this?
+
+              if (!GLX.glXQueryVersion(display, major, 0, minor, 0)) {
+                throw new GLException("glXQueryVersion failed");
+              }
+              if (DEBUG) {
+                System.err.println("!!! GLX version: major " + major[0] +
+                                   ", minor " + minor[0]);
+              }
+
+              // Work around bugs in ATI's Linux drivers where they report they
+              // only implement GLX version 1.2 on the server side
+              if (major[0] == 1 && minor[0] == 2) {
+                String str = GLX.glXGetClientString(display, GLX.GLX_VERSION);
+                if (str != null && str.startsWith("1.") &&
+		    (str.charAt(2) >= '3')) {
+                  canCreateGLPbuffer = true;
+                }
+              } else {
+                canCreateGLPbuffer = ((major[0] > 1) || (minor[0] > 2));
+              }
+        
+              pbufferSupportInitialized = true;        
+            } finally {
+              unlockToolkit();
+            }
+          }
+        };
+      maybeDoSingleThreadedWorkaround(r);
+    }
+    return canCreateGLPbuffer;
+  }
+
+  public GLPbuffer createGLPbuffer(final NWCapabilities capabilities,
+                                   final NWCapabilitiesChooser chooser,
+                                   final int initialWidth,
+                                   final int initialHeight,
+                                   final GLContext shareWith) {
+    if (!canCreateGLPbuffer()) {
+      throw new GLException("Pbuffer support not available with current graphics card");
+    }
+    final List returnList = new ArrayList();
+    final GLDrawableFactory factory = this;
+    Runnable r = new Runnable() {
+        public void run() {
+          X11PbufferGLXDrawable pbufferDrawable = new X11PbufferGLXDrawable(factory, capabilities,
+                                                                            initialWidth,
+                                                                            initialHeight);
+          GLPbufferImpl pbuffer = new GLPbufferImpl(pbufferDrawable, shareWith);
+          returnList.add(pbuffer);
+        }
+      };
+    maybeDoSingleThreadedWorkaround(r);
+    return (GLPbuffer) returnList.get(0);
+  }
+
+  public GLContext createExternalGLContext() {
+    return new X11ExternalGLXContext();
+  }
+
+  public boolean canCreateExternalGLDrawable() {
+    return canCreateGLPbuffer();
+  }
+
+  public GLDrawable createExternalGLDrawable() {
+    return X11ExternalGLXDrawable.create(this);
+  }
+
+  public void loadGLULibrary() {
+    X11Lib.dlopen("/usr/lib/libGLU.so");
+  }
+
+  public long dynamicLookupFunction(String glFuncName) {
+    long res = 0;
+    res = GLX.glXGetProcAddressARB(glFuncName);
+    if (res == 0) {
+      // GLU routines aren't known to the OpenGL function lookup
+      res = X11Lib.dlsym(glFuncName);
+    }
+    return res;
+  }
+
+  public NWCapabilities xvi2NWCapabilities(long display, XVisualInfo info) {
+    int[] tmp = new int[1];
+    int val = glXGetConfig(display, info, GLX.GLX_USE_GL, tmp, 0);
+    if (val == 0) {
+      // Visual does not support OpenGL
+      return null;
+    }
+    val = glXGetConfig(display, info, GLX.GLX_RGBA, tmp, 0);
+    if (val == 0) {
+      // Visual does not support RGBA
+      return null;
+    }
+    NWCapabilities res = new NWCapabilities();
+    res.setDoubleBuffered(glXGetConfig(display, info, GLX.GLX_DOUBLEBUFFER,     tmp, 0) != 0);
+    res.setStereo        (glXGetConfig(display, info, GLX.GLX_STEREO,           tmp, 0) != 0);
+    // Note: use of hardware acceleration is determined by
+    // glXCreateContext, not by the XVisualInfo. Optimistically claim
+    // that all NWCapabilities have the capability to be hardware
+    // accelerated.
+    res.setHardwareAccelerated(true);
+    res.setDepthBits     (glXGetConfig(display, info, GLX.GLX_DEPTH_SIZE,       tmp, 0));
+    res.setStencilBits   (glXGetConfig(display, info, GLX.GLX_STENCIL_SIZE,     tmp, 0));
+    res.setRedBits       (glXGetConfig(display, info, GLX.GLX_RED_SIZE,         tmp, 0));
+    res.setGreenBits     (glXGetConfig(display, info, GLX.GLX_GREEN_SIZE,       tmp, 0));
+    res.setBlueBits      (glXGetConfig(display, info, GLX.GLX_BLUE_SIZE,        tmp, 0));
+    res.setAlphaBits     (glXGetConfig(display, info, GLX.GLX_ALPHA_SIZE,       tmp, 0));
+    res.setAccumRedBits  (glXGetConfig(display, info, GLX.GLX_ACCUM_RED_SIZE,   tmp, 0));
+    res.setAccumGreenBits(glXGetConfig(display, info, GLX.GLX_ACCUM_GREEN_SIZE, tmp, 0));
+    res.setAccumBlueBits (glXGetConfig(display, info, GLX.GLX_ACCUM_BLUE_SIZE,  tmp, 0));
+    res.setAccumAlphaBits(glXGetConfig(display, info, GLX.GLX_ACCUM_ALPHA_SIZE, tmp, 0));
+    if (GLXUtil.isMultisampleAvailable()) {
+      res.setSampleBuffers(glXGetConfig(display, info, GLX.GLX_SAMPLE_BUFFERS, tmp, 0) != 0);
+      res.setNumSamples   (glXGetConfig(display, info, GLX.GLX_SAMPLES,        tmp, 0));
+    }
+    return res;
+  }
+
+  public static int[] glCapabilities2AttribList(NWCapabilities caps,
+                                                boolean isMultisampleAvailable,
+                                                boolean pbuffer,
+                                                long display,
+                                                int screen) {
+    int colorDepth = (caps.getRedBits() +
+                      caps.getGreenBits() +
+                      caps.getBlueBits());
+    if (colorDepth < 15) {
+      throw new GLException("Bit depths < 15 (i.e., non-true-color) not supported");
+    }
+    int[] res = new int[MAX_ATTRIBS];
+    int idx = 0;
+    if (pbuffer) {
+      res[idx++] = GLX.GLX_DRAWABLE_TYPE;
+      res[idx++] = GLX.GLX_PBUFFER_BIT;
+
+      res[idx++] = GLX.GLX_RENDER_TYPE;
+      res[idx++] = GLX.GLX_RGBA_BIT;
+    } else {
+      res[idx++] = GLX.GLX_RGBA;
+    }
+    if (caps.getDoubleBuffered()) {
+      res[idx++] = GLX.GLX_DOUBLEBUFFER;
+      if (pbuffer) {
+        res[idx++] = GL.GL_TRUE;
+      }
+    } else {
+      if (pbuffer) {
+        res[idx++] = GLX.GLX_DOUBLEBUFFER;
+        res[idx++] = GL.GL_FALSE;
+      }
+    }
+    if (caps.getStereo()) {
+      res[idx++] = GLX.GLX_STEREO;
+      if (pbuffer) {
+        res[idx++] = GL.GL_TRUE;
+      }
+    }
+    // NOTE: don't set (GLX_STEREO, GL_FALSE) in "else" branch for
+    // pbuffer case to work around Mesa bug
+
+    res[idx++] = GLX.GLX_RED_SIZE;
+    res[idx++] = caps.getRedBits();
+    res[idx++] = GLX.GLX_GREEN_SIZE;
+    res[idx++] = caps.getGreenBits();
+    res[idx++] = GLX.GLX_BLUE_SIZE;
+    res[idx++] = caps.getBlueBits();
+    res[idx++] = GLX.GLX_ALPHA_SIZE;
+    res[idx++] = caps.getAlphaBits();
+    res[idx++] = GLX.GLX_DEPTH_SIZE;
+    res[idx++] = caps.getDepthBits();
+    if (caps.getStencilBits() > 0) {
+      res[idx++] = GLX.GLX_STENCIL_SIZE;
+      res[idx++] = caps.getStencilBits();
+    }
+    if (caps.getAccumRedBits()   > 0 ||
+        caps.getAccumGreenBits() > 0 ||
+        caps.getAccumBlueBits()  > 0 ||
+        caps.getAccumAlphaBits() > 0) {
+      res[idx++] = GLX.GLX_ACCUM_RED_SIZE;
+      res[idx++] = caps.getAccumRedBits();
+      res[idx++] = GLX.GLX_ACCUM_GREEN_SIZE;
+      res[idx++] = caps.getAccumGreenBits();
+      res[idx++] = GLX.GLX_ACCUM_BLUE_SIZE;
+      res[idx++] = caps.getAccumBlueBits();
+      res[idx++] = GLX.GLX_ACCUM_ALPHA_SIZE;
+      res[idx++] = caps.getAccumAlphaBits();
+    }
+    if (isMultisampleAvailable && caps.getSampleBuffers()) {
+      res[idx++] = GLX.GLX_SAMPLE_BUFFERS;
+      res[idx++] = GL.GL_TRUE;
+      res[idx++] = GLX.GLX_SAMPLES;
+      res[idx++] = caps.getNumSamples();
+    }
+    if (pbuffer) {
+      if (caps.getPbufferFloatingPointBuffers()) {
+        String glXExtensions = GLX.glXQueryExtensionsString(display, screen);
+        if (glXExtensions == null ||
+            glXExtensions.indexOf("GLX_NV_float_buffer") < 0) {
+          throw new GLException("Floating-point pbuffers on X11 currently require NVidia hardware");
+        }
+        res[idx++] = GLXExt.GLX_FLOAT_COMPONENTS_NV;
+        res[idx++] = GL.GL_TRUE;
+      }
+    }
+    res[idx++] = 0;
+    return res;
+  }
+
+  public static NWCapabilities attribList2NWCapabilities(int[] iattribs,
+                                                         int niattribs,
+                                                         int[] ivalues,
+                                                         boolean pbuffer) {
+    NWCapabilities caps = new NWCapabilities();
+
+    for (int i = 0; i < niattribs; i++) {
+      int attr = iattribs[i];
+      switch (attr) {
+        case GLX.GLX_DOUBLEBUFFER:
+          caps.setDoubleBuffered(ivalues[i] != GL.GL_FALSE);
+          break;
+
+        case GLX.GLX_STEREO:
+          caps.setStereo(ivalues[i] != GL.GL_FALSE);
+          break;
+
+        case GLX.GLX_RED_SIZE:
+          caps.setRedBits(ivalues[i]);
+          break;
+
+        case GLX.GLX_GREEN_SIZE:
+          caps.setGreenBits(ivalues[i]);
+          break;
+
+        case GLX.GLX_BLUE_SIZE:
+          caps.setBlueBits(ivalues[i]);
+          break;
+
+        case GLX.GLX_ALPHA_SIZE:
+          caps.setAlphaBits(ivalues[i]);
+          break;
+
+        case GLX.GLX_DEPTH_SIZE:
+          caps.setDepthBits(ivalues[i]);
+          break;
+
+        case GLX.GLX_STENCIL_SIZE:
+          caps.setStencilBits(ivalues[i]);
+          break;
+
+        case GLX.GLX_ACCUM_RED_SIZE:
+          caps.setAccumRedBits(ivalues[i]);
+          break;
+
+        case GLX.GLX_ACCUM_GREEN_SIZE:
+          caps.setAccumGreenBits(ivalues[i]);
+          break;
+
+        case GLX.GLX_ACCUM_BLUE_SIZE:
+          caps.setAccumBlueBits(ivalues[i]);
+          break;
+
+        case GLX.GLX_ACCUM_ALPHA_SIZE:
+          caps.setAccumAlphaBits(ivalues[i]);
+          break;
+
+        case GLX.GLX_SAMPLE_BUFFERS:
+          caps.setSampleBuffers(ivalues[i] != GL.GL_FALSE);
+          break;
+
+        case GLX.GLX_SAMPLES:
+          caps.setNumSamples(ivalues[i]);
+          break;
+
+        case GLXExt.GLX_FLOAT_COMPONENTS_NV:
+          caps.setPbufferFloatingPointBuffers(ivalues[i] != GL.GL_FALSE);
+          break;
+
+        default:
+          break;
+      }
+    }
+
+    return caps;
+  }
+
+  private static String glXGetConfigErrorCode(int err) {
+    switch (err) {
+      case GLX.GLX_NO_EXTENSION:  return "GLX_NO_EXTENSION";
+      case GLX.GLX_BAD_SCREEN:    return "GLX_BAD_SCREEN";
+      case GLX.GLX_BAD_ATTRIBUTE: return "GLX_BAD_ATTRIBUTE";
+      case GLX.GLX_BAD_VISUAL:    return "GLX_BAD_VISUAL";
+      default:                return "Unknown error code " + err;
+    }
+  }
+
+  public static int glXGetConfig(long display, XVisualInfo info, int attrib, int[] tmp, int tmp_offset) {
+    if (display == 0) {
+      throw new GLException("No display connection");
+    }
+    int res = GLX.glXGetConfig(display, info, attrib, tmp, tmp_offset);
+    if (res != 0) {
+      throw new GLException("glXGetConfig failed: error code " + glXGetConfigErrorCode(res));
+    }
+    return tmp[tmp_offset];
+  }
+
+  private void maybeDoSingleThreadedWorkaround(Runnable action) {
+    if (Threading.isSingleThreaded() &&
+        !Threading.isOpenGLThread()) {
+      Threading.invokeOnOpenGLThread(action);
+    } else {
+      action.run();
+    }
+  }
+
+  public boolean canCreateContextOnJava2DSurface() {
+    return false;
+  }
+
+  public GLContext createContextOnJava2DSurface(Object graphics, GLContext shareWith)
+    throws GLException {
+    throw new GLException("Unimplemented on this platform");
+  }
+
+  //----------------------------------------------------------------------
+  // Gamma-related functionality
+  //
+
+  private boolean gotGammaRampLength;
+  private int gammaRampLength;
+  protected synchronized int getGammaRampLength() {
+    if (gotGammaRampLength) {
+      return gammaRampLength;
+    }
+
+    int[] size = new int[1];
+    lockToolkit();
+    long display = X11Util.getDisplayConnection();
+    boolean res = X11Lib.XF86VidModeGetGammaRampSize(display,
+                                                  X11Lib.DefaultScreen(display),
+                                                  size, 0);
+    unlockToolkit();
+    if (!res)
+      return 0;
+    gotGammaRampLength = true;
+    gammaRampLength = size[0];
+    return gammaRampLength;
+  }
+
+  protected boolean setGammaRamp(float[] ramp) {
+    int len = ramp.length;
+    short[] rampData = new short[len];
+    for (int i = 0; i < len; i++) {
+      rampData[i] = (short) (ramp[i] * 65535);
+    }
+
+    lockToolkit();
+    long display = X11Util.getDisplayConnection();
+    boolean res = X11Lib.XF86VidModeSetGammaRamp(display,
+                                              X11Lib.DefaultScreen(display),
+                                              rampData.length,
+                                              rampData, 0,
+                                              rampData, 0,
+                                              rampData, 0);
+    unlockToolkit();
+    return res;
+  }
+
+  protected Buffer getGammaRamp() {
+    int size = getGammaRampLength();
+    ShortBuffer rampData = ShortBuffer.allocate(3 * size);
+    rampData.position(0);
+    rampData.limit(size);
+    ShortBuffer redRampData = rampData.slice();
+    rampData.position(size);
+    rampData.limit(2 * size);
+    ShortBuffer greenRampData = rampData.slice();
+    rampData.position(2 * size);
+    rampData.limit(3 * size);
+    ShortBuffer blueRampData = rampData.slice();
+    lockToolkit();
+    long display = X11Util.getDisplayConnection();
+    boolean res = X11Lib.XF86VidModeGetGammaRamp(display,
+                                              X11Lib.DefaultScreen(display),
+                                              size,
+                                              redRampData,
+                                              greenRampData,
+                                              blueRampData);
+    unlockToolkit();
+    if (!res)
+      return null;
+    return rampData;
+  }
+
+  protected void resetGammaRamp(Buffer originalGammaRamp) {
+    if (originalGammaRamp == null)
+      return; // getGammaRamp failed originally
+    ShortBuffer rampData = (ShortBuffer) originalGammaRamp;
+    int capacity = rampData.capacity();
+    if ((capacity % 3) != 0) {
+      throw new IllegalArgumentException("Must not be the original gamma ramp");
+    }
+    int size = capacity / 3;
+    rampData.position(0);
+    rampData.limit(size);
+    ShortBuffer redRampData = rampData.slice();
+    rampData.position(size);
+    rampData.limit(2 * size);
+    ShortBuffer greenRampData = rampData.slice();
+    rampData.position(2 * size);
+    rampData.limit(3 * size);
+    ShortBuffer blueRampData = rampData.slice();
+    lockToolkit();
+    long display = X11Util.getDisplayConnection();
+    X11Lib.XF86VidModeSetGammaRamp(display,
+                                X11Lib.DefaultScreen(display),
+                                size,
+                                redRampData,
+                                greenRampData,
+                                blueRampData);
+    unlockToolkit();
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11GLXNativeWindowFactory.java b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11GLXNativeWindowFactory.java
new file mode 100644
index 000000000..f6c5a590f
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11GLXNativeWindowFactory.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.sun.opengl.impl.x11.glx;
+
+import javax.media.nwi.*;
+import javax.media.nwi.x11.X11GraphicsDevice;
+import javax.media.nwi.x11.X11GraphicsConfiguration;
+import com.sun.nwi.impl.NullWindow;
+import com.sun.nwi.impl.NativeWindowFactoryImpl;
+import com.sun.nwi.impl.x11.*;
+
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.opengl.impl.x11.glx.*;
+
+/** Subclass of NativeWindowFactory used when non-AWT tookits are used
+    on X11 platforms. Toolkits will likely need to subclass this one
+    to add synchronization in certain places and change the accepted
+    and returned types of the GraphicsDevice and GraphicsConfiguration
+    abstractions. */
+
+public class X11GLXNativeWindowFactory extends NativeWindowFactoryImpl {
+
+    public X11GLXNativeWindowFactory() {
+        NativeWindowFactory.registerFactory(javax.media.nwi.NativeWindow.class, this);
+    }
+
+    public AbstractGraphicsConfiguration chooseGraphicsConfiguration(NWCapabilities capabilities,
+                                                                     NWCapabilitiesChooser chooser,
+                                                                     AbstractGraphicsDevice absDevice) {
+        if (absDevice != null &&
+            !(absDevice instanceof X11GraphicsDevice)) {
+            throw new IllegalArgumentException("This NativeWindowFactory accepts only X11GraphicsDevice objects");
+        }
+
+        int screen = 0;
+        if (absDevice != null) {
+            screen = ((X11GraphicsDevice) absDevice).getScreen();
+        }
+
+        long visualID = chooseGraphicsConfigurationImpl(capabilities, chooser, screen);
+        return new X11GraphicsConfiguration(visualID);
+    }
+
+    /** Returns the visual ID of the chosen GraphicsConfiguration. */
+    protected long chooseGraphicsConfigurationImpl(NWCapabilities capabilities,
+                                                   NWCapabilitiesChooser chooser,
+                                                   int screen) {
+        if (capabilities == null) {
+            capabilities = new NWCapabilities();
+        }
+        if (chooser == null) {
+            chooser = new DefaultNWCapabilitiesChooser();
+        }
+
+        if (X11Util.isXineramaEnabled()) {
+            screen = 0;
+        }
+
+        // Until we have a rock-solid visual selection algorithm written
+        // in pure Java, we're going to provide the underlying window
+        // system's selection to the chooser as a hint
+
+        int[] attribs = X11GLXDrawableFactory.glCapabilities2AttribList(capabilities, GLXUtil.isMultisampleAvailable(), false, 0, 0);
+        XVisualInfo[] infos = null;
+        NWCapabilities[] caps = null;
+        int recommendedIndex = -1;
+        getDefaultFactory().getToolkitLock().lock();
+        try {
+            long display = X11Util.getDisplayConnection();
+            XVisualInfo recommendedVis = GLX.glXChooseVisual(display, screen, attribs, 0);
+            if (DEBUG) {
+                System.err.print("!!! glXChooseVisual recommended ");
+                if (recommendedVis == null) {
+                    System.err.println("null visual");
+                } else {
+                    System.err.println("visual id 0x" + Long.toHexString(recommendedVis.visualid()));
+                }
+            }
+            int[] count = new int[1];
+            XVisualInfo template = XVisualInfo.create();
+            template.screen(screen);
+            infos = X11Lib.XGetVisualInfo(display, X11Lib.VisualScreenMask, template, count, 0);
+            if (infos == null) {
+                throw new GLException("Error while enumerating available XVisualInfos");
+            }
+            caps = new NWCapabilities[infos.length];
+            for (int i = 0; i < infos.length; i++) {
+                caps[i] = ((X11GLXDrawableFactory) GLDrawableFactory.getFactory()).xvi2NWCapabilities(display, infos[i]);
+                // Attempt to find the visual chosen by glXChooseVisual
+                if (recommendedVis != null && recommendedVis.visualid() == infos[i].visualid()) {
+                    recommendedIndex = i;
+                }
+            }
+        } finally {
+            getDefaultFactory().getToolkitLock().unlock();
+        }
+        // Store these away for later
+        ((X11GLXDrawableFactory) GLDrawableFactory.getFactory()).
+            initializeVisualToNWCapabilitiesMap(screen, infos, caps);
+        int chosen = chooser.chooseCapabilities(capabilities, caps, recommendedIndex);
+        if (chosen < 0 || chosen >= caps.length) {
+            throw new GLException("NWCapabilitiesChooser specified invalid index (expected 0.." + (caps.length - 1) + ")");
+        }
+        XVisualInfo vis = infos[chosen];
+        if (vis == null) {
+            throw new GLException("NWCapabilitiesChooser chose an invalid visual");
+        }
+        return vis.visualid();
+    }
+
+    // On X11 platforms we need to do some locking; this basic
+    // implementation should suffice for some simple window toolkits
+    private ToolkitLock toolkitLock = new ToolkitLock() {
+            private Thread owner;
+            private int recursionCount;
+            
+            public synchronized void lock() {
+                Thread cur = Thread.currentThread();
+                if (owner == cur) {
+                    ++recursionCount;
+                    return;
+                }
+                while (owner != null) {
+                    try {
+                        wait();
+                    } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+                owner = cur;
+            }
+
+            public synchronized void unlock() {
+                if (owner != Thread.currentThread()) {
+                    throw new RuntimeException("Not owner");
+                }
+                if (recursionCount > 0) {
+                    --recursionCount;
+                    return;
+                }
+                owner = null;
+            }
+        };
+
+    public ToolkitLock getToolkitLock() {
+        return toolkitLock;
+    }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11OffscreenGLXContext.java b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11OffscreenGLXContext.java
new file mode 100644
index 000000000..c6d787f2b
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11OffscreenGLXContext.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.x11.glx;
+
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.opengl.impl.x11.*;
+
+public class X11OffscreenGLXContext extends X11GLXContext {
+  private X11OffscreenGLXDrawable drawable;
+
+  public X11OffscreenGLXContext(X11OffscreenGLXDrawable drawable,
+                               GLContext shareWith) {
+    super(drawable, shareWith);
+    this.drawable = drawable;
+  }
+
+  public int getOffscreenContextPixelDataType() {
+    GL gl = getGL();
+    return gl.isGL2()?GL2.GL_UNSIGNED_INT_8_8_8_8_REV:GL.GL_UNSIGNED_SHORT_5_5_5_1;
+  }
+  
+  public int getOffscreenContextReadBuffer() {
+    if (drawable.isDoubleBuffered()) {
+      return GL.GL_BACK;
+    }
+    return GL.GL_FRONT;
+  }
+
+  public boolean offscreenImageNeedsVerticalFlip() {
+    // There doesn't seem to be a way to do this in the construction
+    // of the Pixmap or GLXPixmap
+    return true;
+  }
+
+  protected int makeCurrentImpl() throws GLException {
+    getDrawableImpl().getFactoryImpl().lockToolkit();
+    try {
+      return super.makeCurrentImpl();
+    } finally {
+      getDrawableImpl().getFactoryImpl().unlockToolkit();
+    }
+  }
+
+  protected void create() {
+    createContext(false);
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11OffscreenGLXDrawable.java b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11OffscreenGLXDrawable.java
new file mode 100644
index 000000000..9b3dd98b3
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11OffscreenGLXDrawable.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.x11.glx;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.nwi.impl.NullWindow;
+import com.sun.nwi.impl.x11.*;
+
+public class X11OffscreenGLXDrawable extends X11GLXDrawable {
+  private long pixmap;
+  private boolean isDoubleBuffered;
+
+  protected X11OffscreenGLXDrawable(GLDrawableFactory factory,
+                                    NWCapabilities requestedCapabilities,
+                                    NWCapabilitiesChooser chooser,
+                                    int width,
+                                    int height) {
+    super(factory, new NullWindow(), true, requestedCapabilities, chooser);
+    ((NullWindow) getNativeWindow()).setSize(width, height);
+    create();
+  }
+
+  public GLContext createContext(GLContext shareWith) {
+    return new X11OffscreenGLXContext(this, shareWith);
+  }
+  
+  private void create() {
+    NullWindow nw = (NullWindow) getNativeWindow();
+    long dpy = X11Util.getDisplayConnection();
+    nw.setDisplayHandle(dpy);
+    XVisualInfo vis = chooseVisual(false);
+    int bitsPerPixel = vis.depth();
+
+    getFactoryImpl().lockToolkit();
+    try {
+      int screen = X11Lib.DefaultScreen(dpy);
+      nw.setScreenIndex(screen);
+      pixmap = X11Lib.XCreatePixmap(dpy, (int) X11Lib.RootWindow(dpy, screen), 
+                                 component.getWidth(), component.getHeight(), bitsPerPixel);
+      if (pixmap == 0) {
+        throw new GLException("XCreatePixmap failed");
+      }
+      long drawable = GLX.glXCreateGLXPixmap(dpy, vis, pixmap);
+      if (drawable == 0) {
+        X11Lib.XFreePixmap(dpy, pixmap);
+        pixmap = 0;
+        throw new GLException("glXCreateGLXPixmap failed");
+      }
+      nw.setSurfaceHandle(drawable);
+      isDoubleBuffered = (X11GLXDrawableFactory.glXGetConfig(dpy, vis, GLX.GLX_DOUBLEBUFFER, new int[1], 0) != 0);
+      if (DEBUG) {
+        System.err.println("Created pixmap " + toHexString(pixmap) +
+                           ", GLXPixmap " + toHexString(drawable) +
+                           ", display " + toHexString(dpy));
+      }
+      setChosenNWCapabilities(((X11GLXDrawableFactory)getFactory()).xvi2NWCapabilities(dpy, vis));
+    } finally {
+      getFactoryImpl().unlockToolkit();
+    }
+  }
+
+  public void destroy() {
+    if (pixmap == 0) return;
+    try {
+      NativeWindow nw = getNativeWindow();
+      long display = nw.getDisplayHandle();
+      long drawable = nw.getSurfaceHandle();
+      if (DEBUG) {
+        System.err.println("Destroying pixmap " + toHexString(pixmap) +
+                           ", GLXPixmap " + toHexString(drawable) +
+                           ", display " + toHexString(display));
+      }
+
+      // Must destroy pixmap and GLXPixmap
+      getFactoryImpl().lockToolkit();
+
+      if (DEBUG) {
+        long cur = GLX.glXGetCurrentContext();
+        if (cur != 0) {
+          System.err.println("WARNING: found context " + toHexString(cur) + " current during pixmap destruction");
+        }
+      }
+
+      // FIXME: workaround for crashes on NVidia hardware when
+      // destroying pixmap (no context is current at the point of the
+      // crash, at least from the point of view of
+      // glXGetCurrentContext)
+      GLX.glXMakeCurrent(display, 0, 0);
+
+      GLX.glXDestroyGLXPixmap(display, drawable);
+      X11Lib.XFreePixmap(display, pixmap);
+      drawable = 0;
+      pixmap = 0;
+      display = 0;
+      setChosenNWCapabilities(null);
+    } finally {
+      getFactoryImpl().unlockToolkit();
+    }
+  }
+
+  public boolean isDoubleBuffered() {
+    return isDoubleBuffered;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11OnscreenGLXContext.java b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11OnscreenGLXContext.java
new file mode 100644
index 000000000..ed6b4018e
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11OnscreenGLXContext.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.x11.glx;
+
+import java.util.*;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.opengl.impl.x11.*;
+
+public class X11OnscreenGLXContext extends X11GLXContext {
+  protected X11OnscreenGLXDrawable drawable;
+  // This indicates whether the context we have created is indirect
+  // and therefore requires the toolkit to be locked around all GL
+  // calls rather than just all GLX calls
+  protected boolean isIndirect;
+
+  public X11OnscreenGLXContext(X11OnscreenGLXDrawable drawable,
+                              GLContext shareWith) {
+    super(drawable, shareWith);
+    this.drawable = drawable;
+  }
+  
+  protected int makeCurrentImpl() throws GLException {
+    int lockRes = drawable.lockSurface();
+    if (drawable.getChosenNWCapabilities() == null) {
+      X11GLXDrawableFactory factory = (X11GLXDrawableFactory) drawable.getFactory();
+      NativeWindow window = drawable.getNativeWindow();
+      drawable.setChosenNWCapabilities(factory.lookupCapabilitiesByScreenAndVisualID(window.getScreenIndex(),
+                                                                                     window.getVisualID()));
+    }
+    boolean exceptionOccurred = false;
+    try {
+      if (lockRes == NativeWindow.LOCK_SURFACE_NOT_READY) {
+        return CONTEXT_NOT_CURRENT;
+      }
+      if (lockRes == NativeWindow.LOCK_SURFACE_CHANGED) {
+        destroyImpl();
+      }
+      return super.makeCurrentImpl();
+    } catch (RuntimeException e) {
+      exceptionOccurred = true;
+      throw e;
+    } finally {
+      if (exceptionOccurred ||
+          (isOptimizable() && lockRes != NativeWindow.LOCK_SURFACE_NOT_READY)) {
+        drawable.unlockSurface();
+      }
+    }
+  }
+
+  protected void releaseImpl() throws GLException {
+    try {
+      super.releaseImpl();
+    } finally {
+      if (!isOptimizable()) {
+        drawable.unlockSurface();
+      }
+    }
+  }
+
+  public boolean isOptimizable() {
+    return super.isOptimizable() && !isIndirect;
+  }
+
+  protected void create() {
+    createContext(true);
+    isIndirect = !GLX.glXIsDirect(drawable.getNativeWindow().getDisplayHandle(), context);
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11OnscreenGLXDrawable.java b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11OnscreenGLXDrawable.java
new file mode 100644
index 000000000..ee92b82f2
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11OnscreenGLXDrawable.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.x11.glx;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.opengl.impl.x11.*;
+
+public class X11OnscreenGLXDrawable extends X11GLXDrawable {
+  protected X11OnscreenGLXDrawable(GLDrawableFactory factory, NativeWindow component) {
+    super(factory, component, false, null, null);
+  }
+
+  public GLContext createContext(GLContext shareWith) {
+    return new X11OnscreenGLXContext(this, shareWith);
+  }
+
+  public int getWidth() {
+    return component.getWidth();
+  }
+
+  public int getHeight() {
+    return component.getHeight();
+  }
+
+  public void swapBuffers() throws GLException {
+    getFactoryImpl().lockToolkit();
+    try {
+      if (component.getSurfaceHandle() == 0) {
+        if (lockSurface() == NativeWindow.LOCK_SURFACE_NOT_READY) {
+          return;
+        }
+      }
+
+      GLX.glXSwapBuffers(component.getDisplayHandle(), component.getSurfaceHandle());
+
+    } finally {
+      unlockSurface();
+      getFactoryImpl().unlockToolkit();
+    }
+  }
+
+  // This is public to allow access from the DrawableFactory
+  protected void setChosenNWCapabilities(NWCapabilities caps) {
+    super.setChosenNWCapabilities(caps);
+  }
+
+  public void setRealized(boolean realized) {
+    if (realized) {
+      X11GLXDrawableFactory factory = (X11GLXDrawableFactory) getFactory();
+      NativeWindow window = getNativeWindow();
+      setChosenNWCapabilities(factory.lookupCapabilitiesByScreenAndVisualID(window.getScreenIndex(),
+                                                                            window.getVisualID()));
+    } 
+    super.setRealized(realized);
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11PbufferGLXContext.java b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11PbufferGLXContext.java
new file mode 100644
index 000000000..a858935fc
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11PbufferGLXContext.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.x11.glx;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.opengl.impl.x11.*;
+
+public class X11PbufferGLXContext extends X11GLXContext {
+  private X11PbufferGLXDrawable drawable;
+
+  public X11PbufferGLXContext(X11PbufferGLXDrawable drawable,
+                             GLContext shareWith) {
+    super(drawable, shareWith);
+    this.drawable = drawable;
+  }
+
+  public void bindPbufferToTexture() {
+    // FIXME: figure out how to implement this
+    throw new GLException("Not yet implemented");
+  }
+
+  public void releasePbufferFromTexture() {
+    // FIXME: figure out how to implement this
+    throw new GLException("Not yet implemented");
+  }
+
+
+  public int getFloatingPointMode() {
+    return drawable.getFloatingPointMode();
+  }
+
+  protected void create() {
+    if (DEBUG) {
+      System.err.println("Creating context for pbuffer " + drawable.getWidth() +
+                         " x " + drawable.getHeight());
+    }
+
+    // Create a gl context for the p-buffer.
+    X11GLXContext other = (X11GLXContext) GLContextShareSet.getShareContext(this);
+    long share = 0;
+    if (other != null) {
+      share = other.getContext();
+      if (share == 0) {
+        throw new GLException("GLContextShareSet returned an invalid OpenGL context");
+      }
+    }
+    context = GLX.glXCreateNewContext(drawable.getNativeWindow().getDisplayHandle(), 
+                                      drawable.getFBConfig(), GLX.GLX_RGBA_TYPE, share, true);
+    if (context == 0) {
+      throw new GLException("pbuffer creation error: glXCreateNewContext() failed");
+    }
+    GLContextShareSet.contextCreated(this);
+
+    if (DEBUG) {
+      System.err.println("Created context for pbuffer " + drawable.getWidth() +
+                         " x " + drawable.getHeight());
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11PbufferGLXDrawable.java b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11PbufferGLXDrawable.java
new file mode 100644
index 000000000..4d7b2e5d5
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/x11/glx/X11PbufferGLXDrawable.java
@@ -0,0 +1,242 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.opengl.impl.x11.glx;
+
+import javax.media.nwi.*;
+import javax.media.opengl.*;
+import com.sun.opengl.impl.*;
+import com.sun.opengl.impl.x11.glx.*;
+import com.sun.nwi.impl.NullWindow;
+import com.sun.nwi.impl.x11.*;
+
+import java.nio.LongBuffer;
+
+public class X11PbufferGLXDrawable extends X11GLXDrawable {
+  // drawable in superclass is a GLXPbuffer
+  private long fbConfig;
+
+  protected static final int MAX_PFORMATS = 256;
+  protected static final int MAX_ATTRIBS  = 256;
+
+  protected X11PbufferGLXDrawable(GLDrawableFactory factory,
+                                  NWCapabilities requestedCapabilities, 
+                                  int width, int height) {
+    super(factory, new NullWindow(), true, requestedCapabilities, null);
+    if (width <= 0 || height <= 0) {
+      throw new GLException("Width and height of pbuffer must be positive (were (" +
+			    width + ", " + height + "))");
+    }
+    NullWindow nw = (NullWindow) getNativeWindow();
+    nw.setSize(width, height);
+
+    if (DEBUG) {
+      System.out.println("Pbuffer caps on init: " + requestedCapabilities +
+                         (requestedCapabilities.getPbufferRenderToTexture() ? " [rtt]" : "") +
+                         (requestedCapabilities.getPbufferRenderToTextureRectangle() ? " [rect]" : "") +
+                         (requestedCapabilities.getPbufferFloatingPointBuffers() ? " [float]" : ""));
+    }
+
+    nw.setDisplayHandle(X11Util.getDisplayConnection());
+    createPbuffer();
+  }
+
+  public GLContext createContext(GLContext shareWith) {
+    return new X11PbufferGLXContext(this, shareWith);
+  }
+
+  public void destroy() {
+    getFactoryImpl().lockToolkit();
+    try {
+        NullWindow nw = (NullWindow) getNativeWindow();
+        if (nw.getSurfaceHandle() != 0) {
+          GLX.glXDestroyPbuffer(nw.getDisplayHandle(), nw.getSurfaceHandle());
+          nw.setSurfaceHandle(0);
+        }
+        nw.setDisplayHandle(0);
+    } finally {
+        getFactoryImpl().unlockToolkit();
+    }
+  }
+
+  private void createPbuffer() {
+    getFactoryImpl().lockToolkit();
+    try {
+      NullWindow nw = (NullWindow) getNativeWindow();
+      long display = nw.getDisplayHandle();
+      if (nw.getDisplayHandle()== 0) {
+        throw new GLException("Null display");
+      }
+      int screen = X11Lib.DefaultScreen(display);
+      nw.setScreenIndex(screen);
+    
+      NWCapabilities capabilities = getRequestedNWCapabilities();
+
+      if (capabilities.getPbufferRenderToTexture()) {
+        throw new GLException("Render-to-texture pbuffers not supported yet on X11");
+      }
+
+      if (capabilities.getPbufferRenderToTextureRectangle()) {
+        throw new GLException("Render-to-texture-rectangle pbuffers not supported yet on X11");
+      }
+
+      int[] iattributes = X11GLXDrawableFactory.glCapabilities2AttribList(capabilities,
+                                                                         GLXUtil.isMultisampleAvailable(),
+                                                                         true, display, screen);
+
+      int[] nelementsTmp = new int[1];
+      // FIXME: we inherently leak the memory from the underlying call
+      // to glXChooseFBConfig because a copy of the original Buffer is
+      // made to expand each pointer from 32 to 64 bits
+      LongBuffer fbConfigs = GLX.glXChooseFBConfig(display, screen, iattributes, 0, nelementsTmp, 0);
+      if (fbConfigs == null || fbConfigs.limit() == 0 || fbConfigs.get(0) == 0) {
+        throw new GLException("pbuffer creation error: glXChooseFBConfig() failed");
+      }
+      int nelements = nelementsTmp[0];
+      if (nelements <= 0) {
+        throw new GLException("pbuffer creation error: couldn't find a suitable frame buffer configuration");
+      }
+      // Note that we currently don't allow selection of anything but
+      // the first GLXFBConfig in the returned list
+      long fbConfig = fbConfigs.get(0);
+
+      if (DEBUG) {
+        System.err.println("Found " + fbConfigs.limit() + " matching GLXFBConfigs");
+        System.err.println("Parameters of default one:");
+        System.err.println("render type: 0x" + Integer.toHexString(queryFBConfig(display, fbConfig, GLX.GLX_RENDER_TYPE)));
+        System.err.println("rgba: " + ((queryFBConfig(display, fbConfig, GLX.GLX_RENDER_TYPE) & GLX.GLX_RGBA_BIT) != 0));
+        System.err.println("r: " + queryFBConfig(display, fbConfig, GLX.GLX_RED_SIZE));
+        System.err.println("g: " + queryFBConfig(display, fbConfig, GLX.GLX_GREEN_SIZE));
+        System.err.println("b: " + queryFBConfig(display, fbConfig, GLX.GLX_BLUE_SIZE));
+        System.err.println("a: " + queryFBConfig(display, fbConfig, GLX.GLX_ALPHA_SIZE));
+        System.err.println("depth: " + queryFBConfig(display, fbConfig, GLX.GLX_DEPTH_SIZE));
+        System.err.println("double buffered: " + queryFBConfig(display, fbConfig, GLX.GLX_DOUBLEBUFFER));
+      }
+
+      // Create the p-buffer.
+      int niattribs = 0;
+
+      iattributes[niattribs++] = GLX.GLX_PBUFFER_WIDTH;
+      iattributes[niattribs++] = nw.getWidth();
+      iattributes[niattribs++] = GLX.GLX_PBUFFER_HEIGHT;
+      iattributes[niattribs++] = nw.getHeight();
+
+      iattributes[niattribs++] = 0;
+
+      long drawable = GLX.glXCreatePbuffer(display, fbConfig, iattributes, 0);
+      if (drawable == 0) {
+        // FIXME: query X error code for detail error message
+        throw new GLException("pbuffer creation error: glXCreatePbuffer() failed");
+      }
+
+      // Set up instance variables
+      nw.setSurfaceHandle(drawable);
+      this.fbConfig = fbConfig;
+      
+      // Pick innocent query values if multisampling or floating point buffers not available
+      int sbAttrib      = GLXUtil.isMultisampleAvailable() ? GLX.GLX_SAMPLE_BUFFERS: GLX.GLX_RED_SIZE;
+      int samplesAttrib = GLXUtil.isMultisampleAvailable() ? GLX.GLX_SAMPLES: GLX.GLX_RED_SIZE;
+      int floatNV       = capabilities.getPbufferFloatingPointBuffers() ? GLXExt.GLX_FLOAT_COMPONENTS_NV : GLX.GLX_RED_SIZE;
+
+      // Query the fbconfig to determine its NWCapabilities
+      int[] iattribs = {
+        GLX.GLX_DOUBLEBUFFER,
+        GLX.GLX_STEREO,
+        GLX.GLX_RED_SIZE,
+        GLX.GLX_GREEN_SIZE,
+        GLX.GLX_BLUE_SIZE,
+        GLX.GLX_ALPHA_SIZE,
+        GLX.GLX_DEPTH_SIZE,
+        GLX.GLX_STENCIL_SIZE,
+        GLX.GLX_ACCUM_RED_SIZE,
+        GLX.GLX_ACCUM_GREEN_SIZE,
+        GLX.GLX_ACCUM_BLUE_SIZE,
+        GLX.GLX_ACCUM_ALPHA_SIZE,
+        sbAttrib,
+        samplesAttrib,        
+        floatNV
+      };
+
+      int[] ivalues = new int[iattribs.length];
+      queryFBConfig(display, fbConfig, iattribs, iattribs.length, ivalues);
+      setChosenNWCapabilities(X11GLXDrawableFactory.attribList2NWCapabilities(iattribs, iattribs.length, ivalues, true));
+
+      // Determine the actual width and height we were able to create.
+      int[] tmp = new int[1];
+      GLX.glXQueryDrawable(display, drawable, GLX.GLX_WIDTH, tmp, 0);
+      int width = tmp[0];
+      GLX.glXQueryDrawable(display, drawable, GLX.GLX_HEIGHT, tmp, 0);
+      int height = tmp[0];
+      nw.setSize(width, height);
+
+      if (DEBUG) {
+        System.err.println("Created pbuffer " + width + " x " + height);
+      }
+    } finally {
+      getFactoryImpl().unlockToolkit();
+    }
+  }
+
+  public int getFloatingPointMode() {
+    // Floating-point pbuffers currently require NVidia hardware on X11
+    return GLPbuffer.NV_FLOAT;
+  }
+  
+  public long getFBConfig() {
+    return fbConfig;
+  }
+
+  private int queryFBConfig(long display, long fbConfig, int attrib) {
+    int[] tmp = new int[1];
+    if (GLX.glXGetFBConfigAttrib(display, fbConfig, attrib, tmp, 0) != 0) {
+      throw new GLException("glXGetFBConfigAttrib failed");
+    }
+    return tmp[0];
+  }
+
+  private void queryFBConfig(long display, long fbConfig, int[] attribs, int nattribs, int[] values) {
+    int[] tmp = new int[1];
+    for (int i = 0; i < nattribs; i++) {
+      if (GLX.glXGetFBConfigAttrib(display, fbConfig, attribs[i], tmp, 0) != 0) {
+        throw new GLException("glXGetFBConfigAttrib failed");
+      }
+      values[i] = tmp[0];
+    }
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/impl/x11/glx/awt/X11AWTGLXNativeWindowFactory.java b/src/jogl/classes/com/sun/opengl/impl/x11/glx/awt/X11AWTGLXNativeWindowFactory.java
new file mode 100644
index 000000000..34a6a6fa1
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/impl/x11/glx/awt/X11AWTGLXNativeWindowFactory.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.sun.opengl.impl.x11.glx.awt;
+
+import java.awt.GraphicsConfiguration;
+import java.awt.GraphicsDevice;
+import java.awt.GraphicsEnvironment;
+import javax.media.nwi.*;
+import javax.media.nwi.awt.AWTGraphicsDevice;
+import javax.media.nwi.awt.AWTGraphicsConfiguration;
+import javax.media.opengl.*;
+import javax.media.opengl.awt.*;
+
+import com.sun.opengl.impl.*;
+import com.sun.nwi.impl.jawt.*;
+import com.sun.nwi.impl.jawt.x11.*;
+import com.sun.opengl.impl.x11.*;
+import com.sun.opengl.impl.x11.glx.*;
+
+public class X11AWTGLXNativeWindowFactory extends X11GLXNativeWindowFactory {
+
+    public X11AWTGLXNativeWindowFactory() {
+        Class componentClass = null;
+        try {
+            componentClass = Class.forName("java.awt.Component");
+        } catch (Exception e) { 
+            throw new GLException(e);
+        }
+
+        NativeWindowFactory.registerFactory(componentClass, this);
+    }
+
+    public AbstractGraphicsConfiguration chooseGraphicsConfiguration(NWCapabilities capabilities,
+                                                                     NWCapabilitiesChooser chooser,
+                                                                     AbstractGraphicsDevice absDevice) {
+        GraphicsDevice device = null;
+        if (absDevice != null &&
+            !(absDevice instanceof AWTGraphicsDevice)) {
+            throw new IllegalArgumentException("This NativeWindowFactory accepts only AWTGraphicsDevice objects");
+        }
+
+        if ((absDevice == null) ||
+            (((AWTGraphicsDevice) absDevice).getGraphicsDevice() == null)) {
+            device = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
+        } else {
+            device = ((AWTGraphicsDevice) absDevice).getGraphicsDevice();
+        }
+
+        long visualID = chooseGraphicsConfigurationImpl(capabilities, chooser,
+                                                        X11SunJDKReflection.graphicsDeviceGetScreen(device));
+
+        // Now figure out which GraphicsConfiguration corresponds to this
+        // visual by matching the visual ID
+        GraphicsConfiguration[] configs = device.getConfigurations();
+        for (int i = 0; i < configs.length; i++) {
+            GraphicsConfiguration config = configs[i];
+            if (config != null) {
+                if (X11SunJDKReflection.graphicsConfigurationGetVisualID(config) == visualID) {
+                    return new AWTGraphicsConfiguration(config);
+                }
+            }
+        }
+
+        // Either we weren't able to reflectively introspect on the
+        // X11GraphicsConfig or something went wrong in the steps above;
+        // we're going to return null without signaling an error condition
+        // in this case (although we should distinguish between the two
+        // and possibly report more of an error in the latter case)
+        return null;
+    }
+
+    // When running the AWT on X11 platforms, we use the AWT native
+    // interface (JAWT) to lock and unlock the toolkit
+    private ToolkitLock toolkitLock = new ToolkitLock() {
+            private Thread owner;
+            private int recursionCount;
+            
+            public synchronized void lock() {
+                Thread cur = Thread.currentThread();
+                if (owner == cur) {
+                    ++recursionCount;
+                    return;
+                }
+                while (owner != null) {
+                    try {
+                        wait();
+                    } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+                owner = cur;
+                JAWTUtil.lockToolkit();
+            }
+
+            public synchronized void unlock() {
+                if (owner != Thread.currentThread()) {
+                    throw new RuntimeException("Not owner");
+                }
+                if (recursionCount > 0) {
+                    --recursionCount;
+                    return;
+                }
+                owner = null;
+                JAWTUtil.unlockToolkit();
+            }
+        };
+
+    public ToolkitLock getToolkitLock() {
+        return toolkitLock;
+    }
+}