Copied JOGL_2_SANDBOX r1957 on to trunk; JOGL_2_SANDBOX branch is now closed

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

67 files changed, 8472 insertions, 0 deletions

diff --git a/make/config/intptr.cfg b/make/config/intptr.cfg
new file mode 100755
index 000000000..c946e4851
--- /dev/null
+++ b/make/config/intptr.cfg
@@ -0,0 +1,17 @@
+CustomCCode #ifdef _WIN32
+CustomCCode  #ifdef _MSC_VER
+CustomCCode  /* This typedef is apparently needed for Microsoft compilers before VC8,
+CustomCCode     and on Windows CE */
+CustomCCode   #if (_MSC_VER < 1400) || defined(UNDER_CE)
+CustomCCode    #ifdef _WIN64
+CustomCCode     typedef long long intptr_t;
+CustomCCode    #else
+CustomCCode     typedef int intptr_t;
+CustomCCode    #endif
+CustomCCode   #endif
+CustomCCode  #else
+CustomCCode   #include <inttypes.h>
+CustomCCode  #endif
+CustomCCode #else
+CustomCCode  #include <inttypes.h>
+CustomCCode #endif
diff --git a/make/config/jogl/cg-common-CustomJavaCode.java b/make/config/jogl/cg-common-CustomJavaCode.java
new file mode 100755
index 000000000..1f109d9f6
--- /dev/null
+++ b/make/config/jogl/cg-common-CustomJavaCode.java
@@ -0,0 +1,29 @@
+static {
+  com.sun.opengl.impl.NativeLibLoader.loadCgImpl();
+}
+
+/** A convenience method which reads all available data from the InputStream and then calls cgCreateProgram. */
+public static CGprogram cgCreateProgramFromStream(CGcontext ctx, int program_type, java.io.InputStream stream, int profile, java.lang.String entry, java.lang.String[] args) throws java.io.IOException {
+  if (stream == null) {
+    throw new java.io.IOException("null stream");
+  }
+  stream = new java.io.BufferedInputStream(stream);
+  int avail = stream.available();
+  byte[] data = new byte[avail];
+  int numRead = 0;
+  int pos = 0;
+  do {
+    if (pos + avail > data.length) {
+      byte[] newData = new byte[pos + avail];
+      System.arraycopy(data, 0, newData, 0, pos);
+      data = newData;
+    }
+    numRead = stream.read(data, pos, avail);
+    if (numRead >= 0) {
+      pos += numRead;
+    }
+    avail = stream.available();
+  } while (avail > 0 && numRead >= 0);
+  String program = new String(data, 0, pos, "US-ASCII");
+  return cgCreateProgram(ctx, program_type, program, profile, entry, args);
+}
diff --git a/make/config/jogl/cg-common.cfg b/make/config/jogl/cg-common.cfg
new file mode 100644
index 000000000..9b8dba079
--- /dev/null
+++ b/make/config/jogl/cg-common.cfg
@@ -0,0 +1,118 @@
+# This .cfg file provides common options used among all Cg glue code
+# generated for Jogl on all platforms.
+Package com.sun.opengl.cg
+JavaClass CgGL
+Style AllStatic
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/jogl_cg
+HierarchicalNativeOutput false
+
+#
+# Map const char* return values to Java strings for these functions
+#
+ReturnsString cgGetAnnotationName
+ReturnsString cgGetEnumString
+ReturnsString cgGetErrorString
+ReturnsString cgGetLastErrorString
+ReturnsString cgGetLastListing
+ReturnsString cgGetParameterName
+ReturnsString cgGetParameterSemantic
+ReturnsString cgGetPassName
+ReturnsString cgGetProfileString
+ReturnsString cgGetProgramString
+ReturnsString cgGetResourceString
+ReturnsString cgGetStateName
+ReturnsString cgGetString
+ReturnsString cgGetStringAnnotationValue
+ReturnsString cgGetStringParameterValue
+ReturnsString cgGetStringStateAssignmentValue
+ReturnsString cgGetTechniqueName
+ReturnsString cgGetTypeString
+
+ArgumentIsString cgAddStateEnumerant 1
+ArgumentIsString cgCreateArrayState 1
+ArgumentIsString cgCreateArraySamplerState 1
+ArgumentIsString cgCreateEffect 1 2
+ArgumentIsString cgCreateEffectFromFile 1 2
+ArgumentIsString cgCreateProgram 2 4 5
+ArgumentIsString cgCreateProgramFromFile 2 4 5
+ArgumentIsString cgCreateProgramFromEffect 2 3
+ArgumentIsString cgCreateSamplerState 1
+ArgumentIsString cgCreateState 1
+ArgumentIsString cgGetEffectParameterBySemantic 1
+ArgumentIsString cgGetEnum 0
+ArgumentIsString cgGetNamedEffectParameter 1
+ArgumentIsString cgGetNamedParameter 1
+ArgumentIsString cgGetNamedPass 1
+ArgumentIsString cgGetNamedProgramParameter 2
+ArgumentIsString cgGetNamedSamplerState 1
+ArgumentIsString cgGetNamedState 1
+ArgumentIsString cgGetNamedSamplerStateAssignment 1
+ArgumentIsString cgGetNamedStateAssignment 1
+ArgumentIsString cgGetNamedStructParameter 1
+ArgumentIsString cgGetNamedTechnique 1
+ArgumentIsString cgGetNamedTechniqueAnnotation 1
+ArgumentIsString cgGetNamedPassAnnotation 1
+ArgumentIsString cgGetNamedParameterAnnotation 1
+ArgumentIsString cgGetNamedProgramAnnotation 1
+ArgumentIsString cgGetNamedUserType 1
+ArgumentIsString cgGetProfile 0
+ArgumentIsString cgGetType 0
+ArgumentIsString cgGetResource 0
+ArgumentIsString cgSetLastListing 1
+ArgumentIsString cgSetParameterSemantic 1
+ArgumentIsString cgSetStringParameterValue 1
+
+# Opaque definitions
+Opaque boolean CGbool
+
+#
+# FIXME!!!!  Ignore these functions for now because we can't
+# automatically handle C callbacks
+#
+Ignore cgSetErrorCallback
+Ignore cgGetErrorCallback
+Ignore cgSetErrorHandler
+Ignore cgGetErrorHandler
+Ignore cgSetStateCallbacks
+Ignore cgGetStateSetCallback
+Ignore cgGetStateResetCallback
+Ignore cgGetStateValidateCallback
+
+#
+# FIXME!!!!  Ignore these functions for now because bugs in the
+# emitter code can't handle them
+#
+Ignore cgGetBooleanAnnotationValues
+Ignore cgGetBoolStateAssignmentValues
+Ignore cgGetFloatAnnotationValues
+Ignore cgGetFloatStateAssignmentValues
+Ignore cgGetIntAnnotationValues
+Ignore cgGetIntStateAssignmentValues
+Ignore cgGetParameterValues
+Ignore cgGetProgramOptions
+
+#
+# Need to import New IO for Buffer classes
+#
+Import java.nio.*
+# And NativeLibLoader for help loading the native libraries
+Import com.sun.opengl.impl.*
+
+#
+# NIODirectOnly directives for routines requiring them for semantic reasons
+#
+NIODirectOnly cgGLSetParameterPointer
+
+# Raise CgException instead of RuntimeException in glue code
+RuntimeExceptionType CgException
+
+#
+# Make sure the right definitions and include files are added to the
+# generated C code
+#
+
+CustomCCode #include <stdlib.h>
+CustomCCode #include <Cg/cgGL.h>
+
+IncludeAs CustomJavaCode CgGL cg-common-CustomJavaCode.java
diff --git a/make/config/jogl/cgl-macosx.cfg b/make/config/jogl/cgl-macosx.cfg
new file mode 100644
index 000000000..780afcf5b
--- /dev/null
+++ b/make/config/jogl/cgl-macosx.cfg
@@ -0,0 +1,41 @@
+# This .cfg file is used to generate the interface to the CGL routines
+# used internally by the MacOSXGLContext implementation.
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/jogl/MacOSX
+
+Package com.sun.opengl.impl.macosx.cgl
+JavaClass CGL
+Style allstatic
+Include gl-common-gl2.cfg
+Include gl-common-extensions.cfg
+Include gl-desktop.cfg
+
+Opaque long void *
+
+# Opaque directives for low-level CGL binding (for Java2D/JOGL bridge)
+Opaque long CGLContextObj
+Opaque long CGLPBufferObj
+Opaque long CGLPixelFormatObj
+
+CustomCCode #include </usr/include/machine/types.h>
+CustomCCode #include "macosx-window-system.h"
+
+# Implement the first argument to getProcAddress as String instead
+# of byte[]
+ArgumentIsString getProcAddress 0
+
+DropUniqVendorExtensions AMD
+# We need GL_APPLE_float_pixels for our pbuffer implementation
+# DropUniqVendorExtensions APPLE
+DropUniqVendorExtensions ATI
+DropUniqVendorExtensions HP
+DropUniqVendorExtensions IBM
+DropUniqVendorExtensions MESA
+DropUniqVendorExtensions MESAX
+DropUniqVendorExtensions NV
+DropUniqVendorExtensions SGI
+DropUniqVendorExtensions SGIS
+DropUniqVendorExtensions SGIX
+DropUniqVendorExtensions SUN
+DropUniqVendorExtensions WIN
+
diff --git a/make/config/jogl/cglext.cfg b/make/config/jogl/cglext.cfg
new file mode 100755
index 000000000..4000ecb2b
--- /dev/null
+++ b/make/config/jogl/cglext.cfg
@@ -0,0 +1,44 @@
+# This .cfg file is used to generate the interface and implementing
+# class for the CGL extensions.
+# Note that there are currently no such extensions exposed on Mac OS
+# X, but if in the future there are, this structure will allow them to
+# be easily exposed.
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/jogl/MacOSX
+
+Package com.sun.opengl.impl.macosx.cgl
+Style InterfaceAndImpl
+JavaClass CGLExt
+ImplPackage com.sun.opengl.impl.macosx.cgl
+ImplJavaClass CGLExtImpl
+Include gl-common-gl2.cfg
+Include gl-desktop.cfg
+
+EmitProcAddressTable true
+ProcAddressTableClassName CGLExtProcAddressTable
+GetProcAddressTableExpr _context.getCGLExtProcAddressTable()
+
+# Ignore everything that doesn't start with cgl or CGL
+IgnoreNot ^(cgl|CGL).+
+
+Include gl-headers.cfg
+Include ../intptr.cfg
+
+CustomJavaCode CGLExt      public boolean isFunctionAvailable(String glFunctionName);
+CustomJavaCode CGLExt      public boolean isExtensionAvailable(String glExtensionName);
+
+CustomJavaCode CGLExtImpl  public CGLExtImpl(MacOSXCGLContext context) {
+CustomJavaCode CGLExtImpl    this._context = context; 
+CustomJavaCode CGLExtImpl  }
+
+CustomJavaCode CGLExtImpl  public boolean isFunctionAvailable(String glFunctionName)
+CustomJavaCode CGLExtImpl  {
+CustomJavaCode CGLExtImpl    return _context.isFunctionAvailable(glFunctionName);
+CustomJavaCode CGLExtImpl  }
+
+CustomJavaCode CGLExtImpl  public boolean isExtensionAvailable(String glExtensionName)
+CustomJavaCode CGLExtImpl  {
+CustomJavaCode CGLExtImpl    return _context.isExtensionAvailable(glExtensionName);
+CustomJavaCode CGLExtImpl  }
+
+CustomJavaCode CGLExtImpl  private MacOSXCGLContext _context;
diff --git a/make/config/jogl/egl.cfg b/make/config/jogl/egl.cfg
new file mode 100755
index 000000000..6457ab21a
--- /dev/null
+++ b/make/config/jogl/egl.cfg
@@ -0,0 +1,70 @@
+# This .cfg file is used to generate the interface to the EGL routines
+# used internally by the EGLContext implementation.
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/jogl/egl
+
+Package com.sun.opengl.impl.egl
+JavaClass EGL
+Style allstatic
+# Shouldn't matter which one of these we pick up
+
+HierarchicalNativeOutput false
+Include gl-common.cfg
+
+# Use a ProcAddressTable so we dynamically look up the routines
+EmitProcAddressTable true
+ProcAddressTableClassName EGLProcAddressTable
+GetProcAddressTableExpr _table
+
+# Translate EGLBoolean as Java boolean
+Opaque boolean EGLBoolean
+
+# Implement the first argument to eglGetProcAddress as String instead
+# of byte[]
+ArgumentIsString eglGetProcAddress 0
+ReturnsString eglQueryString
+
+# Make eglGetProcAddress return an opaque long
+Opaque long __EGLFuncPtr
+
+# Force all of the methods to be emitted using dynamic linking so we
+# don't need to link against any emulation library on the desktop or
+# depend on the presence of an import library for a particular device
+ForceProcAddressGen __ALL__
+
+# Treat all of the EGL types as opaque longs
+Opaque long EGLContext
+Opaque long EGLDisplay
+Opaque long EGLSurface
+Opaque long EGLNativeDisplayType
+Opaque long EGLNativeWindowType
+Opaque long EGLNativePixmapType
+Opaque long EGLClientBuffer
+
+CustomCCode #include <EGL/egl.h>
+
+Include ../intptr.cfg
+
+CustomJavaCode EGL  private static EGLProcAddressTable _table = new EGLProcAddressTable();
+CustomJavaCode EGL  public static void resetProcAddressTable(DynamicLookupHelper lookup) {
+CustomJavaCode EGL      GLProcAddressHelper.resetProcAddressTable(_table, lookup);
+CustomJavaCode EGL  }
+
+# There are some #defines in egl.h that GlueGen and PCPP don't currently handle
+CustomJavaCode EGL  public static final long EGL_DEFAULT_DISPLAY = 0;
+CustomJavaCode EGL  public static final long EGL_NO_CONTEXT = 0;
+CustomJavaCode EGL  public static final long EGL_NO_DISPLAY = 0;
+CustomJavaCode EGL  public static final long EGL_NO_SURFACE = 0;
+CustomJavaCode EGL  public static final int  EGL_DONT_CARE  = -1;
+CustomJavaCode EGL  public static final int  EGL_UNKNOWN    = -1;
+CustomJavaCode EGL 
+CustomJavaCode EGL  protected static long eglGetProcAddress(long eglGetProcAddressHandle, java.lang.String procname)
+CustomJavaCode EGL  {
+CustomJavaCode EGL    if (eglGetProcAddressHandle == 0) {
+CustomJavaCode EGL      throw new GLException("Passed null pointer for method \"eglGetProcAddress\"");
+CustomJavaCode EGL    }
+CustomJavaCode EGL    return dispatch_eglGetProcAddress0(procname, eglGetProcAddressHandle);
+CustomJavaCode EGL  }
+
+
+Import com.sun.gluegen.runtime.opengl.GLProcAddressHelper
diff --git a/make/config/jogl/eglext.cfg b/make/config/jogl/eglext.cfg
new file mode 100755
index 000000000..bdd9a3655
--- /dev/null
+++ b/make/config/jogl/eglext.cfg
@@ -0,0 +1,126 @@
+# This .cfg file is used to generate the interface to the EGL routines
+# used internally by the EGLContext implementation.
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/jogl/egl
+
+Package com.sun.opengl.impl.egl
+Style InterfaceAndImpl
+JavaClass EGLExt
+ImplPackage com.sun.opengl.impl.egl
+ImplJavaClass EGLExtImpl
+# Shouldn't matter which one of these we pick up
+
+ExtendedInterfaceSymbols ../build-temp/gensrc/classes/com/sun/opengl/impl/egl/EGL.java
+HierarchicalNativeOutput false
+Include gl-common.cfg
+
+# Use a ProcAddressTable so we dynamically look up the routines
+EmitProcAddressTable true
+ProcAddressTableClassName EGLExtProcAddressTable
+GetProcAddressTableExpr _context.getEGLExtProcAddressTable()
+
+# Translate EGLBoolean as Java boolean
+Opaque boolean EGLBoolean
+
+# Implement the first argument to eglGetProcAddress as String instead
+# of byte[]
+ArgumentIsString eglGetProcAddress 0
+ReturnsString eglQueryString
+
+# Make eglGetProcAddress return an opaque long
+Opaque long __EGLFuncPtr
+
+# Force all of the methods to be emitted using dynamic linking so we
+# don't need to link against any emulation library on the desktop or
+# depend on the presence of an import library for a particular device
+ForceProcAddressGen __ALL__
+
+# Also force the calling conventions of the locally generated function
+# pointer typedefs for these routines to EGLAPIENTRY
+LocalProcAddressCallingConvention __ALL__ EGLAPIENTRY
+
+# Treat all of the EGL types as opaque longs
+# Opaque long EGLConfig
+Opaque long EGLContext
+Opaque long EGLDisplay
+Opaque long EGLSurface
+Opaque long EGLNativeDisplayType
+Opaque long EGLNativeWindowType
+Opaque long EGLNativePixmapType
+Opaque long EGLClientBuffer
+Opaque long EGLImageKHR
+#Opaque long EGLPerfMonitorNV
+#Opaque long EGLPerfCounterNV
+#Opaque long EGLPerfMarkerNV
+Opaque long EGLSyncKHR
+Opaque long NativeSyncKHR
+
+# Opaque long EGLClientBuffer
+
+CustomCCode /* Define EGL_EGLEXT_PROTOTYPES so that the EGL extension prototypes in
+CustomCCode    "eglext.h" are parsed. */
+CustomCCode #define EGL_EGLEXT_PROTOTYPES
+CustomCCode
+CustomCCode #include <EGL/eglext.h>
+
+Include ../intptr.cfg
+
+# There are some #defines in eglext.h that GlueGen and PCPP don't currently handle
+CustomJavaCode EGLExt      public static final long EGL_NO_IMAGE = 0;
+CustomJavaCode EGLExt      public static final long EGL_NO_PERFMONITOR = 0;
+CustomJavaCode EGLExt      public static final long EGL_DEFAULT_PERFMARKER = 0;
+CustomJavaCode EGLExt      public boolean isFunctionAvailable(String glFunctionName);
+CustomJavaCode EGLExt      public boolean isExtensionAvailable(String glExtensionName);
+
+CustomJavaCode EGLExtImpl  public EGLExtImpl(EGLContext context) {
+CustomJavaCode EGLExtImpl    this._context = context; 
+CustomJavaCode EGLExtImpl  }
+
+CustomJavaCode EGLExtImpl  public boolean isFunctionAvailable(String glFunctionName)
+CustomJavaCode EGLExtImpl  {
+CustomJavaCode EGLExtImpl    return _context.isFunctionAvailable(glFunctionName);
+CustomJavaCode EGLExtImpl  }
+
+CustomJavaCode EGLExtImpl  public boolean isExtensionAvailable(String glExtensionName)
+CustomJavaCode EGLExtImpl  {
+CustomJavaCode EGLExtImpl    return _context.isExtensionAvailable(glExtensionName);
+CustomJavaCode EGLExtImpl  }
+
+CustomJavaCode EGLExtImpl  private EGLContext _context;
+
+# These Ignores cause the core EGL routines to be ignored from the
+# EGLExt interface and EGLExtImpl implementing class.
+Ignore eglBindAPI
+Ignore eglBindTexImage
+Ignore eglChooseConfig
+Ignore eglCopyBuffers
+Ignore eglCreateContext
+Ignore eglCreatePbufferFromClientBuffer
+Ignore eglCreatePbufferSurface
+Ignore eglCreatePixmapSurface
+Ignore eglCreateWindowSurface
+Ignore eglDestroyContext
+Ignore eglDestroySurface
+Ignore eglGetConfigAttrib
+Ignore eglGetConfigs
+Ignore eglGetCurrentContext
+Ignore eglGetCurrentDisplay
+Ignore eglGetCurrentSurface
+Ignore eglGetDisplay
+Ignore eglGetError
+Ignore eglGetProcAddress
+Ignore eglInitialize
+Ignore eglMakeCurrent
+Ignore eglQueryAPI
+Ignore eglQueryContext
+Ignore eglQueryString
+Ignore eglQuerySurface
+Ignore eglReleaseTexImage
+Ignore eglReleaseThread
+Ignore eglSurfaceAttrib
+Ignore eglSwapBuffers
+Ignore eglSwapInterval
+Ignore eglTerminate
+Ignore eglWaitClient
+Ignore eglWaitGL
+Ignore eglWaitNative
diff --git a/make/config/jogl/gl-common-extensions.cfg b/make/config/jogl/gl-common-extensions.cfg
new file mode 100644
index 000000000..fb46e43ca
--- /dev/null
+++ b/make/config/jogl/gl-common-extensions.cfg
@@ -0,0 +1,127 @@
+
+# Note: we keep the Apple, ATI and NVidia extensions since they are generally
+# the most useful and up-to-date
+DropUniqVendorExtensions 3DFX
+DropUniqVendorExtensions AMD
+# DropUniqVendorExtensions APPLE
+# DropUniqVendorExtensions ATI
+DropUniqVendorExtensions HP
+DropUniqVendorExtensions IBM
+DropUniqVendorExtensions INGR
+DropUniqVendorExtensions MESA
+DropUniqVendorExtensions MESAX
+# DropUniqVendorExtensions NV
+DropUniqVendorExtensions PGI
+DropUniqVendorExtensions SGI
+DropUniqVendorExtensions SGIS
+DropUniqVendorExtensions SGIX
+DropUniqVendorExtensions SUN
+DropUniqVendorExtensions WIN
+
+# Drop some obsolete or mostly-integrated vendor extensions that the above directives let in
+# Note that some of these are in LWJGL, so perhaps there is justification for leaving them in
+IgnoreExtension GL_APPLE_element_array
+IgnoreExtension GL_APPLE_vertex_array_object
+IgnoreExtension GL_ATI_element_array
+IgnoreExtension GL_ATI_envmap_bumpmap
+IgnoreExtension GL_ATI_fragment_shader
+IgnoreExtension GL_ATI_map_object_buffer
+IgnoreExtension GL_ATI_separate_stencil
+IgnoreExtension GL_ATI_text_fragment_shader
+IgnoreExtension GL_ATI_texture_env_combine3
+IgnoreExtension GL_ATI_texture_mirror_once
+IgnoreExtension GL_ATI_vertex_array_object
+IgnoreExtension GL_ATI_vertex_attrib_array_object
+IgnoreExtension GL_ATI_vertex_streams
+IgnoreExtension GL_NV_depth_buffer_float
+IgnoreExtension GL_NV_fragment_program
+IgnoreExtension GL_NV_fragment_program2
+IgnoreExtension GL_NV_packed_depth_stencil
+IgnoreExtension GL_NV_point_sprite
+IgnoreExtension GL_NV_register_combiners
+IgnoreExtension GL_NV_register_combiners2
+IgnoreExtension GL_NV_texgen_reflection
+IgnoreExtension GL_NV_texture_env_combine4
+IgnoreExtension GL_NV_texture_rectangle
+IgnoreExtension GL_NV_vertex_program
+# This one would require more work -- has associated GLX and WGL bindings
+IgnoreExtension GL_NV_present_video
+
+# For the time being, ignore these extensions which are in the ES 2.0 spec
+IgnoreExtension GL_NV_coverage_sample
+IgnoreExtension GL_NV_framebuffer_vertex_attrib_array
+
+# Remove extension suffixes from extensions which are common
+RenameExtensionIntoCore GL_ARB_framebuffer_object
+IgnoreExtension GL_EXT_framebuffer_object
+RenameExtensionIntoCore GL_OES_framebuffer_object
+
+# Remove extension suffixes from extensions which are common between OpenGL and OpenGL ES
+RenameExtensionIntoCore GL_ARB_half_float_pixel
+RenameExtensionIntoCore GL_ARB_point_sprite
+RenameExtensionIntoCore GL_OES_blend_equation_separate
+RenameExtensionIntoCore GL_OES_blend_func_separate
+RenameExtensionIntoCore GL_OES_blend_subtract
+RenameExtensionIntoCore GL_OES_compressed_paletted_texture
+RenameExtensionIntoCore GL_OES_depth24
+RenameExtensionIntoCore GL_OES_depth32
+RenameExtensionIntoCore GL_OES_mapbuffer
+RenameExtensionIntoCore GL_OES_point_sprite
+RenameExtensionIntoCore GL_OES_rgb8_rgba8
+RenameExtensionIntoCore GL_OES_read_format
+RenameExtensionIntoCore GL_OES_stencil1
+RenameExtensionIntoCore GL_OES_stencil4
+RenameExtensionIntoCore GL_OES_stencil8
+RenameExtensionIntoCore GL_OES_stencil_wrap
+RenameExtensionIntoCore GL_OES_texture_cube_map
+RenameExtensionIntoCore GL_OES_texture_half_float
+RenameExtensionIntoCore GL_OES_texture_mirrored_repeat
+
+# The following extensions have some differences requiring us to
+# manually rename some symbols and leave others alone for best
+# correctness
+# RenameExtensionIntoCore GL_ARB_matrix_palette
+# We do not want to pull in all of this extension into the core namespace
+# RenameExtensionIntoCore GL_ARB_vertex_blend
+
+RenameJavaSymbol GL_MAX_VERTEX_UNITS_ARB GL_MAX_VERTEX_UNITS
+RenameJavaSymbol GL_MAX_PALETTE_MATRICES_ARB GL_MAX_PALETTE_MATRICES
+RenameJavaSymbol GL_MATRIX_PALETTE_ARB GL_MATRIX_PALETTE
+RenameJavaSymbol GL_MATRIX_INDEX_ARRAY_ARB GL_MATRIX_INDEX_ARRAY
+RenameJavaSymbol GL_WEIGHT_ARRAY_ARB GL_WEIGHT_ARRAY
+RenameJavaSymbol GL_CURRENT_PALETTE_MATRIX_ARB GL_CURRENT_PALETTE_MATRIX
+RenameJavaSymbol GL_MATRIX_INDEX_ARRAY_SIZE_ARB GL_MATRIX_INDEX_ARRAY_SIZE
+RenameJavaSymbol GL_MATRIX_INDEX_ARRAY_TYPE_ARB GL_MATRIX_INDEX_ARRAY_TYPE
+RenameJavaSymbol GL_MATRIX_INDEX_ARRAY_STRIDE_ARB GL_MATRIX_INDEX_ARRAY_STRIDE
+RenameJavaSymbol GL_MATRIX_INDEX_ARRAY_POINTER_ARB GL_MATRIX_INDEX_ARRAY_POINTER
+RenameJavaSymbol GL_WEIGHT_ARRAY_SIZE_ARB GL_WEIGHT_ARRAY_SIZE
+RenameJavaSymbol GL_WEIGHT_ARRAY_TYPE_ARB GL_WEIGHT_ARRAY_TYPE
+RenameJavaSymbol GL_WEIGHT_ARRAY_STRIDE_ARB GL_WEIGHT_ARRAY_STRIDE
+RenameJavaSymbol GL_WEIGHT_ARRAY_POINTER_ARB GL_WEIGHT_ARRAY_POINTER
+RenameJavaSymbol glCurrentPaletteMatrixARB glCurrentPaletteMatrix
+RenameJavaSymbol glMatrixIndexPointerARB glMatrixIndexPointer
+RenameJavaSymbol glWeightPointerARB glWeightPointer
+
+# There are some definitions in this extension that don't exist in desktop OpenGL,
+# so we shouldn't remove the suffixes of those OES-only variants
+# RenameExtensionIntoCore GL_OES_matrix_palette
+RenameJavaSymbol GL_MAX_VERTEX_UNITS_OES GL_MAX_VERTEX_UNITS
+RenameJavaSymbol GL_MAX_PALETTE_MATRICES_OES GL_MAX_PALETTE_MATRICES
+RenameJavaSymbol GL_MATRIX_PALETTE_OES GL_MATRIX_PALETTE
+RenameJavaSymbol GL_MATRIX_INDEX_ARRAY_OES GL_MATRIX_INDEX_ARRAY
+RenameJavaSymbol GL_WEIGHT_ARRAY_OES GL_WEIGHT_ARRAY
+RenameJavaSymbol GL_CURRENT_PALETTE_MATRIX_OES GL_CURRENT_PALETTE_MATRIX
+RenameJavaSymbol GL_MATRIX_INDEX_ARRAY_SIZE_OES GL_MATRIX_INDEX_ARRAY_SIZE
+RenameJavaSymbol GL_MATRIX_INDEX_ARRAY_TYPE_OES GL_MATRIX_INDEX_ARRAY_TYPE
+RenameJavaSymbol GL_MATRIX_INDEX_ARRAY_STRIDE_OES GL_MATRIX_INDEX_ARRAY_STRIDE
+RenameJavaSymbol GL_MATRIX_INDEX_ARRAY_POINTER_OES GL_MATRIX_INDEX_ARRAY_POINTER
+RenameJavaSymbol GL_WEIGHT_ARRAY_SIZE_OES GL_WEIGHT_ARRAY_SIZE
+RenameJavaSymbol GL_WEIGHT_ARRAY_TYPE_OES GL_WEIGHT_ARRAY_TYPE
+RenameJavaSymbol GL_WEIGHT_ARRAY_STRIDE_OES GL_WEIGHT_ARRAY_STRIDE
+RenameJavaSymbol GL_WEIGHT_ARRAY_POINTER_OES GL_WEIGHT_ARRAY_POINTER
+RenameJavaSymbol GL_WEIGHT_ARRAY_BUFFER_BINDING_OES GL_WEIGHT_ARRAY_BUFFER_BINDING
+RenameJavaSymbol glCurrentPaletteMatrixOES glCurrentPaletteMatrix
+RenameJavaSymbol glMatrixIndexPointerOES glMatrixIndexPointer
+RenameJavaSymbol glWeightPointerOES glWeightPointer
+
+
diff --git a/make/config/jogl/gl-common-gl2.cfg b/make/config/jogl/gl-common-gl2.cfg
new file mode 100644
index 000000000..4d86d74cd
--- /dev/null
+++ b/make/config/jogl/gl-common-gl2.cfg
@@ -0,0 +1,8 @@
+# This .cfg file provides common options used among all GL glue code
+# generated for Jogl on Windows.
+
+HierarchicalNativeOutput false
+Include gl-common.cfg
+
+# XID needs to be treated as a long for 32/64 bit compatibility
+Opaque long XID
diff --git a/make/config/jogl/gl-common.cfg b/make/config/jogl/gl-common.cfg
new file mode 100644
index 000000000..50c2ff004
--- /dev/null
+++ b/make/config/jogl/gl-common.cfg
@@ -0,0 +1,641 @@
+# This .cfg file provides common options used among all glue code
+# generated for Jogl on all platforms.
+
+# Raise GLException instead of RuntimeException in glue code
+RuntimeExceptionType GLException
+UnsupportedExceptionType GLException
+
+# Imports needed by all glue code
+Import java.nio.*
+Import java.util.*
+Import javax.media.opengl.*
+Import javax.media.opengl.fixedfunc.*
+Import com.sun.opengl.impl.*
+
+#####################################################################
+# Mostly desktop OpenGL stuff below
+#
+
+# Don't output #defines of GL version identifier strings as constants, 
+# because we don't need them java-side. 
+Ignore GL_VERSION_.+
+
+# There are a few routines we don't handle yet
+Ignore glGetBufferPointerivNV
+Ignore glGetBufferPointerv
+
+# Ignore GL functions that deal with explicit pointer values in such a
+# way that we cannot implement the functionality in Java
+Ignore glGetBufferPointerv
+Ignore glGetBufferPointervARB
+Ignore glGetPointerv
+Ignore glGetPointervEXT
+Ignore glGetTexParameterPointervAPPLE
+Ignore glGetVertexAttribPointerv
+Ignore glGetVertexAttribPointervARB
+Ignore glGetVertexAttribPointervNV
+Ignore glTracePointerRangeMESA 
+
+# Manually implement glMapBuffer as the size of the returned buffer
+# can only be computed by calling another routine
+ManuallyImplement glMapBuffer
+ManuallyImplement glMapBufferOES
+
+# Ignore the ATI_map_object_buffer extension for now unless someone
+# claims they need it, as it will undoubtedly require a similar
+# construct to glMapBuffer
+Ignore glMapObjectBufferATI
+Ignore glUnmapObjectBufferATI
+
+# Ignore some GL functions that have outgoing void** parameters; we cannot yet deal with them
+Ignore glGetVariantPointervEXT
+
+# Don't output #defines of GL name strings as constants, because we
+# don't need them java-side. 
+# Format of name strings is found at:
+#    http://oss.sgi.com/projects/ogl-sample/registry/doc/template.txt
+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_EXT_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_ARB_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_OES_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_PGI_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_SGI_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_SGIS_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_SGIX_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_MESA_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_HP_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_ATI_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_NV_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_IBM_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_WIN_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_REND_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_APPLE_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_INTEL_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_INGR_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_SUN_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_SUNX_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_3DFX_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_OML_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_I3D_.+
+Ignore (GL|GLU|GLX|WGL|AGL|CGL)_S3_.+
+Ignore GL_KTX_buffer_region
+
+# FIXME: these extensions require either a handle to a device context
+# or take void** parameters or both. Until we think through the
+# semantics of each of these individually we need to disable them.
+# WGL_ARB_buffer_region
+Ignore wglCreateBufferRegion
+Ignore wglDeleteBufferRegion
+Ignore wglSaveBufferRegion
+Ignore wglRestoreBufferRegion
+Ignore wglGetSyncValuesOML
+Ignore wglGetMscRateOML
+Ignore wglSwapBuffersMscOML
+Ignore wglSwapLayerBuffersMscOML
+Ignore wglWaitForMscOML
+Ignore wglWaitForSbcOML
+Ignore wglGetDigitalVideoParametersI3D
+Ignore wglSetDigitalVideoParametersI3D
+Ignore wglGetGammaTableParametersI3D
+Ignore wglSetGammaTableParametersI3D
+Ignore wglGetGammaTableI3D
+Ignore wglSetGammaTableI3D
+Ignore wglEnableGenlockI3D
+Ignore wglDisableGenlockI3D
+Ignore wglIsEnabledGenlockI3D
+Ignore wglGenlockSourceI3D
+Ignore wglGetGenlockSourceI3D
+Ignore wglGenlockSourceEdgeI3D
+Ignore wglGetGenlockSourceEdgeI3D
+Ignore wglGenlockSampleRateI3D
+Ignore wglGetGenlockSampleRateI3D
+Ignore wglGenlockSourceDelayI3D
+Ignore wglGetGenlockSourceDelayI3D
+Ignore wglQueryGenlockMaxSourceDelayI3D
+Ignore wglCreateImageBufferI3D
+Ignore wglDestroyImageBufferI3D
+Ignore wglAssociateImageBufferEventsI3D
+Ignore wglReleaseImageBufferEventsI3D
+
+#
+# IgnoreExtension directives
+#
+
+# Ignore extensions requiring persistent pointer-to-pointer storage as
+# there is no such thing as a direct "BufferBuffer"
+IgnoreExtension GL_IBM_vertex_array_lists
+IgnoreExtension GL_INTEL_parallel_arrays
+IgnoreExtension GL_SUN_triangle_list
+
+# Ignore extensions never approved by the ARB
+IgnoreExtension GL_EXT_coordinate_frame
+
+# Ignore discontinued extensions
+IgnoreExtension GL_NV_element_array
+
+# Ignore extensions subsumed in OpenGL 1.1 (from OpenGL 1.1 spec, Appendix C)
+IgnoreExtension GL_EXT_vertex_array
+IgnoreExtension GL_EXT_blend_logic_op
+IgnoreExtension GL_EXT_copy_texture
+IgnoreExtension GL_EXT_polygon_offset
+IgnoreExtension GL_EXT_subtexture
+IgnoreExtension GL_EXT_texture
+IgnoreExtension GL_EXT_texture_object
+
+# Ignore extensions subsumed in OpenGL 1.2 and 1.2.1 (from OpenGL 1.2.1 spec, Appendix D)
+IgnoreExtension GL_EXT_bgra
+IgnoreExtension GL_EXT_blend_color
+IgnoreExtension GL_EXT_blend_minmax
+IgnoreExtension GL_EXT_blend_subtract
+IgnoreExtension GL_EXT_color_subtable
+IgnoreExtension GL_EXT_convolution
+IgnoreExtension GL_EXT_draw_range_elements
+IgnoreExtension GL_EXT_histogram
+IgnoreExtension GL_EXT_packed_pixels
+# NOTE: also ignoring GL_EXT_paletted_texture because it appears that it was subsumed
+# into the core even though that isn't stated explicitly in the spec
+IgnoreExtension GL_EXT_paletted_texture
+IgnoreExtension GL_EXT_rescale_normal
+IgnoreExtension GL_EXT_separate_specular_color
+IgnoreExtension GL_EXT_texture3D
+IgnoreExtension GL_HP_convolution_border_modes
+IgnoreExtension GL_SGI_color_matrix
+IgnoreExtension GL_SGI_color_table
+IgnoreExtension GL_SGIS_texture_edge_clamp
+IgnoreExtension GL_SGIS_texture_lod
+
+# Ignore extensions subsumed in OpenGL 1.3 (from OpenGL 1.3 spec, Appendix F)
+IgnoreExtension GL_ARB_multisample
+IgnoreExtension GL_ARB_multitexture
+IgnoreExtension GL_ARB_texture_compression
+IgnoreExtension GL_ARB_texture_cube_map
+IgnoreExtension GL_ARB_texture_border_clamp
+IgnoreExtension GL_ARB_texture_env_add
+IgnoreExtension GL_ARB_texture_env_combine
+IgnoreExtension GL_ARB_texture_env_dot3
+IgnoreExtension GL_ARB_transpose_matrix
+IgnoreExtension GL_EXT_texture_cube_map
+IgnoreExtension GL_EXT_texture_env_add
+IgnoreExtension GL_EXT_texture_env_combine
+IgnoreExtension GL_EXT_texture_env_dot3
+IgnoreExtension GL_SGIS_texture_border_clamp
+
+# Ignore extensions subsumed in OpenGL 1.4 (from OpenGL 1.4 spec, Appendix G)
+IgnoreExtension GL_ARB_depth_texture
+IgnoreExtension GL_ARB_point_parameters
+IgnoreExtension GL_ARB_shadow
+IgnoreExtension GL_ARB_texture_env_crossbar
+IgnoreExtension GL_ARB_texture_mirrored_repeat
+IgnoreExtension GL_ARB_window_pos
+IgnoreExtension GL_EXT_blend_func_separate
+IgnoreExtension GL_EXT_fog_coord
+IgnoreExtension GL_EXT_texture_lod_bias
+IgnoreExtension GL_EXT_multi_draw_arrays
+IgnoreExtension GL_EXT_secondary_color
+IgnoreExtension GL_EXT_stencil_wrap
+IgnoreExtension GL_NV_blend_square
+IgnoreExtension GL_SGIS_generate_mipmap
+
+# Ignore extensions subsumed in OpenGL 1.5 (from OpenGL 1.5 spec, Appendix H)
+IgnoreExtension GL_ARB_occlusion_query
+IgnoreExtension GL_ARB_vertex_buffer_object
+IgnoreExtension GL_EXT_shadow_funcs
+
+# Ignore extensions subsumed in OpenGL 2.0 (from OpenGL 2.0 spec, Appendix I)
+# NOTE that GL_ARB_shader_objects is NOT ignored here, because the
+# naming convention is too different for us to pick up the entry
+# points automatically (e.g. glCreateShaderObjectARB was exposed as
+# glCreateShader)
+IgnoreExtension GL_ARB_vertex_shader
+IgnoreExtension GL_ARB_fragment_shader
+IgnoreExtension GL_ARB_draw_buffers
+IgnoreExtension GL_ARB_texture_non_power_of_two
+IgnoreExtension GL_ARB_point_sprite
+IgnoreExtension GL_EXT_blend_equation_separate
+# Don't ignore the following one since the entry point is different from anything in the core
+# IgnoreExtension GL_EXT_stencil_two_side
+
+# Ignore extensions subsumed in OpenGL 2.1 (from OpenGL 2.1 spec, Appendix J)
+IgnoreExtension GL_ARB_pixel_buffer_object
+IgnoreExtension GL_EXT_texture_sRGB
+
+# Ignore a few obsolete versions of extensions that have been subsumed into the core or ARB extensions
+IgnoreExtension GL_EXT_multisample
+IgnoreExtension GL_EXT_point_parameters
+IgnoreExtension GL_EXT_texture_rectangle
+
+#
+# Opaques and other directives for platform-independent routines
+#
+
+Opaque boolean GLboolean
+ReturnsString glGetString
+
+# Experimental: Only NIO function, no arrays ..
+# NIOOnly __ALL__
+
+#
+# NIODirectOnly directives for vertex arrays and other core routines
+#
+
+NIODirectOnly glColorPointer
+NIODirectOnly glEdgeFlagPointer
+NIODirectOnly glFeedbackBuffer
+NIODirectOnly glIndexPointer
+NIODirectOnly glNormalPointer
+NIODirectOnly glSelectBuffer
+NIODirectOnly glTexCoordPointer
+NIODirectOnly glVertexPointer
+#
+# FIXME: we should probably be ignoring the "EXT" variants of these
+#
+NIODirectOnly glColorPointerEXT
+NIODirectOnly glEdgeFlagPointerEXT
+NIODirectOnly glIndexPointerEXT
+NIODirectOnly glNormalPointerEXT
+NIODirectOnly glTexCoordPointerEXT
+NIODirectOnly glVertexPointerEXT
+#
+# NIODirectOnly directives for other extensions
+#
+NIODirectOnly glBinormalPointerEXT
+NIODirectOnly glGetBufferSubDataARB
+# FIXME: should add way to restrict argument to be a direct ByteBuffer
+NIODirectOnly glGetProgramStringARB
+NIODirectOnly glElementPointerATI
+NIODirectOnly glElementPointerNV
+NIODirectOnly glElementPointerAPPLE
+NIODirectOnly glFogCoordPointer
+NIODirectOnly glFogCoordPointerEXT
+NIODirectOnly glMatrixIndexPointerARB
+NIODirectOnly glPixelDataRangeNV
+NIODirectOnly glSecondaryColorPointer
+NIODirectOnly glSecondaryColorPointerEXT
+NIODirectOnly glTangentPointerEXT
+NIODirectOnly glVertexArrayRangeNV
+NIODirectOnly glVertexArrayRangeApple
+NIODirectOnly glVertexAttribPointerARB
+NIODirectOnly glVertexAttribPointerNV
+NIODirectOnly glVertexWeightPointerEXT
+NIODirectOnly glWeightPointerARB
+NIODirectOnly wglFreeMemoryNV
+NIODirectOnly glXFreeMemoryNV
+
+# Capacity of wglAllocateMemoryNV/glXAllocateMemoryNV return value is
+# same as value of first argument
+ReturnValueCapacity wglAllocateMemoryNV {0}
+ReturnValueCapacity glXAllocateMemoryNV {0}
+
+# Pass arguments to ARB_vertex_program, ARB_fragment_program,
+# ARB_shader_objects, NV_vertex_program, NV_fragment_program, and
+# ARB_vertex_shader as Strings
+ArgumentIsString glLoadProgramNV 3
+ArgumentIsString glProgramString 3
+ArgumentIsString glProgramStringARB 3
+ArgumentIsString glProgramNamedParameter4fNV 2
+ArgumentIsString glProgramNamedParameter4dNV 2
+ArgumentIsString glProgramNamedParameter4fvNV 2
+ArgumentIsString glProgramNamedParameter4dvNV 2
+ArgumentIsString glGetProgramNamedParameterfvNV 2
+ArgumentIsString glGetProgramNamedParameterdvNV 2
+ArgumentIsString glShaderSource 2
+ArgumentIsString glShaderSourceARB 2
+ArgumentIsString glGetUniformLocation 1
+ArgumentIsString glGetUniformLocationARB 1
+ArgumentIsString glBindAttribLocation 2
+ArgumentIsString glBindAttribLocationARB 2
+ArgumentIsString glGetAttribLocation 1
+ArgumentIsString glGetAttribLocationARB 1
+
+#
+# Directives for Vertex Buffer Object and Pixel Buffer Object checking
+#
+# NOTE: we currently don't emit glue code for some of these but
+# include them for completeness.
+#
+# FIXME: what about glMultiDrawElements? Do we want to add a VBO
+# variant for that, or simply add checks to the top of the current
+# implementation?
+# 
+JavaPrologue glBegin inBeginEndPair = true;
+JavaEpilogue glEnd   inBeginEndPair = false;
+JavaEpilogue glBindBuffer       bufferStateTracker.setBoundBufferObject({0}, {1});
+JavaEpilogue glBindBufferARB    bufferStateTracker.setBoundBufferObject({0}, {1});
+JavaEpilogue glPushClientAttrib bufferStateTracker.clearBufferObjectState();
+JavaEpilogue glPopClientAttrib  bufferStateTracker.clearBufferObjectState();
+JavaEpilogue glBufferData       bufferSizeTracker.setBufferSize(bufferStateTracker, {0}, this, {1});
+
+BufferObjectKind Array glColorPointer
+BufferObjectKind Array glEdgeFlagPointer
+BufferObjectKind Array glElementPointerATI
+BufferObjectKind Array glFogCoordPointer
+BufferObjectKind Array glFogCoordPointerEXT
+# The next one is problematic. It isn't discussed by the specs and
+# doesn't have any associated state.
+BufferObjectKind Array glInterleavedArrays
+BufferObjectKind Array glMatrixIndexPointerARB
+BufferObjectKind Array glNormalPointer
+BufferObjectKind Array glSecondaryColorPointer
+BufferObjectKind Array glSecondaryColorPointerEXT
+BufferObjectKind Array glTexCoordPointer
+BufferObjectKind Array glVariantPointerEXT
+BufferObjectKind Array glVertexPointer
+BufferObjectKind Array glVertexAttribPointer
+BufferObjectKind Array glVertexAttribPointerARB
+BufferObjectKind Array glVertexAttribPointerNV
+BufferObjectKind Array glVertexWeightPointerEXT
+BufferObjectKind Array glWeightPointerARB
+
+BufferObjectKind Element glDrawElements
+BufferObjectKind Element glDrawRangeElements
+BufferObjectKind Element glDrawRangeElementsEXT
+
+# There are no PBOs in the embedded OpenGL variants right now
+BufferObjectKind UnpackPixel glBitmap
+BufferObjectKind UnpackPixel glColorTable
+BufferObjectKind UnpackPixel glColorSubTable
+BufferObjectKind UnpackPixel glCompressedTexImage1D
+BufferObjectKind UnpackPixel glCompressedTexImage1DARB
+BufferObjectKind UnpackPixel glCompressedTexImage2D
+BufferObjectKind UnpackPixel glCompressedTexImage2DARB
+BufferObjectKind UnpackPixel glCompressedTexImage3D
+BufferObjectKind UnpackPixel glCompressedTexImage3DARB
+BufferObjectKind UnpackPixel glCompressedTexSubImage1D
+BufferObjectKind UnpackPixel glCompressedTexSubImage1DARB
+BufferObjectKind UnpackPixel glCompressedTexSubImage2D
+BufferObjectKind UnpackPixel glCompressedTexSubImage2DARB
+BufferObjectKind UnpackPixel glCompressedTexSubImage3D
+BufferObjectKind UnpackPixel glCompressedTexSubImage3DARB
+BufferObjectKind UnpackPixel glConvolutionFilter1D
+BufferObjectKind UnpackPixel glConvolutionFilter2D
+BufferObjectKind UnpackPixel glDrawPixels
+BufferObjectKind UnpackPixel glPixelMapfv
+BufferObjectKind UnpackPixel glPixelMapuiv
+BufferObjectKind UnpackPixel glPixelMapusv
+BufferObjectKind UnpackPixel glPolygonStipple
+BufferObjectKind UnpackPixel glSeparableFilter2D
+BufferObjectKind UnpackPixel glTexImage1D
+BufferObjectKind UnpackPixel glTexImage2D
+BufferObjectKind UnpackPixel glTexImage3D
+BufferObjectKind UnpackPixel glTexSubImage1D
+BufferObjectKind UnpackPixel glTexSubImage2D
+BufferObjectKind UnpackPixel glTexSubImage3D
+
+BufferObjectKind PackPixel glGetColorTable
+BufferObjectKind PackPixel glGetCompressedTexImage
+BufferObjectKind PackPixel glGetCompressedTexImageARB
+BufferObjectKind PackPixel glGetConvolutionFilter
+BufferObjectKind PackPixel glGetHistogram
+BufferObjectKind PackPixel glGetMinmax
+BufferObjectKind PackPixel glGetPixelMapfv
+BufferObjectKind PackPixel glGetPixelMapuiv
+BufferObjectKind PackPixel glGetPixelMapusv
+BufferObjectKind PackPixel glGetPolygonStipple
+BufferObjectKind PackPixel glGetSeparableFilter
+BufferObjectKind PackPixel glGetTexImage
+BufferObjectKind PackPixel glReadPixels
+
+# Range check directives for various routines
+# FIXME: some of these are really the bare minimum and won't catch
+# many classes of errors. Should extend the DebugGL to perform much
+# more error checking with e.g. glDrawElements.
+RangeCheck glColorPointer             3 1
+RangeCheck glDrawElements             3 {1}
+RangeCheck glDrawRangeElements        5 {3}
+RangeCheck glEdgeFlagPointer          1 1
+RangeCheck glElementPointerATI        1 1
+RangeCheck glFogCoordPointer          2 1
+RangeCheck glFogCoordPointerEXT       2 1
+RangeCheck glInterleavedArrays        2 1
+RangeCheck glMatrixIndexPointerARB    3 1
+RangeCheck glNormalPointer            2 1
+RangeCheck glSecondaryColorPointer    3 1
+RangeCheck glSecondaryColorPointerEXT 3 1
+RangeCheck glTexCoordPointer          3 1
+RangeCheck glVariantPointerEXT        3 1
+RangeCheck glVertexPointer            3 1
+RangeCheck glVertexAttribPointer      5 1
+RangeCheck glVertexAttribPointerARB   5 1
+RangeCheck glWeightPointerARB         3 1
+
+# Give ourselves the texture width and height for range checking inside glGetTexImage
+JavaPrologue glGetTexImage int width = 0, height = 0, depth = 1;
+JavaPrologue glGetTexImage int[] tmp = new int[1];
+JavaPrologue glGetTexImage glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, tmp, 0);
+JavaPrologue glGetTexImage width = tmp[0];
+JavaPrologue glGetTexImage glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, tmp, 0);
+JavaPrologue glGetTexImage height = tmp[0];
+JavaPrologue glGetTexImage if (target == GL_TEXTURE_3D) {
+JavaPrologue glGetTexImage     glGetTexLevelParameteriv(target, level, GL_TEXTURE_DEPTH, tmp, 0);
+JavaPrologue glGetTexImage     depth = tmp[0];
+JavaPrologue glGetTexImage }
+
+# Range check directives for various image-related routines
+RangeCheckBytes glColorTable          5 imageSizeInBytes({3}, {4}, {2}            , 1              , 1    , 1, false)
+RangeCheckBytes glColorTableEXT       5 imageSizeInBytes({3}, {4}, {2}            , 1              , 1    , 1, false)
+RangeCheckBytes glConvolutionFilter1D 5 imageSizeInBytes({3}, {4}, {2}            , 1              , 1    , 1, false)
+RangeCheckBytes glConvolutionFilter2D 6 imageSizeInBytes({4}, {5}, {2}            , {3}            , 1    , 2, false)
+RangeCheckBytes glDrawPixels          4 imageSizeInBytes({2}, {3}, {0}            , {1}            , 1    , 2, false)
+RangeCheckBytes glReadPixels          6 imageSizeInBytes({4}, {5}, {2}            , {3}            , 1    , 2, true)
+RangeCheckBytes glTexImage1D          7 imageSizeInBytes({5}, {6}, {3}            , 1              , 1    , 1, false)
+RangeCheckBytes glTexImage2D          8 imageSizeInBytes({6}, {7}, {3}            , {4}            , 1    , 2, false)
+RangeCheckBytes glTexImage3D          9 imageSizeInBytes({7}, {8}, {3}            , {4}            , {5}  , 3, false)
+RangeCheckBytes glTexSubImage1D       6 imageSizeInBytes({4}, {5}, {3}            , 1              , 1    , 1, false)
+RangeCheckBytes glTexSubImage2D       8 imageSizeInBytes({6}, {7}, {4}            , {5}            , 1    , 2, false)
+RangeCheckBytes glTexSubImage3D      10 imageSizeInBytes({8}, {9}, {5}            , {6}            , {7}  , 3, false)
+# This may produce wrong answers for 1D textures
+RangeCheckBytes glGetTexImage         4 imageSizeInBytes({2}, {3}, width          , height         , depth, ((depth > 1) ? 3 : 2), true)
+# Note we don't support glTexImage4DSGIS / glTexSubImage4DSGIS
+# FIXME: add the following unpack operations:
+#   glBitmap, glPolygonStipple
+# and the following pack operations:
+#   glGetColorTable, glGetConvolutionFilter, glGetSeparableFilter, glGetHistogram, glGetMinmax
+
+# Range checks for server-side object creation and deletion methods
+RangeCheck glGenBuffers               1 {0}
+RangeCheck glDeleteBuffers            1 {0}
+RangeCheck glGenBuffersARB            1 {0}
+RangeCheck glDeleteBuffersARB         1 {0}
+RangeCheck glGenFencesAPPLE           1 {0}
+RangeCheck glDeleteFencesAPPLE        1 {0}
+RangeCheck glGenFencesNV              1 {0}
+RangeCheck glDeleteFencesNV           1 {0}
+RangeCheck glGenFramebuffersEXT       1 {0}
+RangeCheck glDeleteFramebuffersEXT    1 {0}
+RangeCheck glGenOcclusionQueriesNV    1 {0}
+RangeCheck glDeleteOcclusionQueriesNV 1 {0}
+RangeCheck glGenProgramsARB           1 {0}
+RangeCheck glDeleteProgramsARB        1 {0}
+RangeCheck glGenProgramsNV            1 {0}
+RangeCheck glDeleteProgramsNV         1 {0}
+RangeCheck glGenQueries               1 {0}
+RangeCheck glDeleteQueries            1 {0}
+RangeCheck glGenQueriesARB            1 {0}
+RangeCheck glDeleteQueriesARB         1 {0}
+RangeCheck glGenRenderbuffersEXT      1 {0}
+RangeCheck glDeleteRenderbuffersEXT   1 {0}
+RangeCheck glGenTextures              1 {0}
+RangeCheck glDeleteTextures           1 {0}
+RangeCheck glGenVertexArraysAPPLE     1 {0}
+RangeCheck glDeleteVertexArraysAPPLE  1 {0}
+
+# Javadoc for the GL class
+ClassJavadoc GL /**
+ClassJavadoc GL  * <P> The basic interface to OpenGL, providing access to core
+ClassJavadoc GL  * functionality up through the OpenGL 2.0 specification as well as
+ClassJavadoc GL  * all vendor extensions. </P>
+ClassJavadoc GL  *
+ClassJavadoc GL  * <P> While the APIs for vendor extensions are unconditionally
+ClassJavadoc GL  * exposed, the underlying functions may not be present. The method
+ClassJavadoc GL  * {@link #isFunctionAvailable} should be used to query the
+ClassJavadoc GL  * availability of any non-core function before it is used for the
+ClassJavadoc GL  * first time; for example,
+ClassJavadoc GL  * <code>gl.isFunctionAvailable("glProgramStringARB")</code>. On
+ClassJavadoc GL  * certain platforms (Windows in particular), the most "core"
+ClassJavadoc GL  * functionality is only OpenGL 1.1, so in theory any routines first
+ClassJavadoc GL  * exposed in OpenGL 1.2, 1.3, and 1.4, 1.5, or 2.0 as well as vendor
+ClassJavadoc GL  * extensions should all be queried. Calling an unavailable function
+ClassJavadoc GL  * will cause a {@link GLException} to be raised. </P>
+ClassJavadoc GL  *
+ClassJavadoc GL  * {@link #isExtensionAvailable} may also be used to determine whether
+ClassJavadoc GL  * a specific extension is available before calling the routines or
+ClassJavadoc GL  * using the functionality it exposes: for example,
+ClassJavadoc GL  * <code>gl.isExtensionAvailable("GL_ARB_vertex_program");</code>.
+ClassJavadoc GL  * However, in this case it is up to the end user to know which
+ClassJavadoc GL  * routines or functionality are associated with which OpenGL
+ClassJavadoc GL  * extensions. It may also be used to test for the availability of a
+ClassJavadoc GL  * particular version of OpenGL: for example,
+ClassJavadoc GL  * <code>gl.isExtensionAvailable("GL_VERSION_1_5");</code>.
+ClassJavadoc GL  *
+ClassJavadoc GL  * <P> Exceptions to the window system extension naming rules:
+ClassJavadoc GL  *
+ClassJavadoc GL  * <UL>
+ClassJavadoc GL  *
+ClassJavadoc GL  * <LI> The memory allocators for the NVidia vertex_array_range (VAR)
+ClassJavadoc GL  * extension, in particular <code>wglAllocateMemoryNV</code> /
+ClassJavadoc GL  * <code>glXAllocateMemoryNV</code> and associated routines. {@link
+ClassJavadoc GL  * #glAllocateMemoryNV} has been provided for window system-independent
+ClassJavadoc GL  * access to VAR. {@link #isFunctionAvailable} will translate an argument
+ClassJavadoc GL  * of "glAllocateMemoryNV" or "glFreeMemoryNV" into the appropriate
+ClassJavadoc GL  * window system-specific name. </P>
+ClassJavadoc GL  *
+ClassJavadoc GL  * <LI> WGL_ARB_pbuffer, WGL_ARB_pixel_format, and other
+ClassJavadoc GL  * platform-specific pbuffer functionality; the availability of
+ClassJavadoc GL  * pbuffers can be queried on Windows, X11 and Mac OS X platforms by
+ClassJavadoc GL  * querying {@link #isExtensionAvailable} with an argument of
+ClassJavadoc GL  * "GL_ARB_pbuffer" or "GL_ARB_pixel_format".
+ClassJavadoc GL  *
+ClassJavadoc GL  * </UL> <P>
+ClassJavadoc GL  *
+ClassJavadoc GL  */
+
+# Javadoc for the WGL class
+ClassJavadoc WGL /**
+ClassJavadoc WGL  * Provides access to the Windows-specific OpenGL vendor extensions.
+ClassJavadoc WGL  * See {@link GL} for more information.
+ClassJavadoc WGL  */
+
+# Javadoc for the GLX class
+ClassJavadoc GLX /**
+ClassJavadoc GLX  * Provides access to the X11-specific OpenGL vendor extensions.
+ClassJavadoc GLX  * See {@link GL} for more information.
+ClassJavadoc GLX  */
+
+# Javadoc for the CGL class
+ClassJavadoc CGL /**
+ClassJavadoc CGL  * Provides access to the MacOSX-specific OpenGL vendor extensions.
+ClassJavadoc CGL  * See {@link GL} for more information.
+ClassJavadoc CGL  */
+
+# Javadoc for the XVisualInfo class
+ClassJavadoc XVisualInfo /**
+ClassJavadoc XVisualInfo  * Wrapper for the XVisualInfo data structure, referenced by some GLX OpenGL
+ClassJavadoc XVisualInfo  * extensions. No other access is provided to these data structures so currently
+ClassJavadoc XVisualInfo  * this wrapper is not useful to end users, though it is used in the implementation.
+ClassJavadoc XVisualInfo  */
+
+# Custom code for querying extensions and exposing
+# wglAllocateMemoryNV/glXAllocateMemoryNV
+CustomJavaCode GL   /**
+CustomJavaCode GL    * Returns true if the specified OpenGL core- or extension-function can be
+CustomJavaCode GL    * used successfully through this GL instance given the current host (OpenGL
+CustomJavaCode GL    * <i>client</i>) and display (OpenGL <i>server</i>) configuration.<P> 
+CustomJavaCode GL    * By "successfully" we mean that the function is both <i>callable</i> 
+CustomJavaCode GL    * on the machine running the program and <i>available</i> on the current 
+CustomJavaCode GL    * display.<P> 
+CustomJavaCode GL    *
+CustomJavaCode GL    * In order to call a function successfully, the function must be both
+CustomJavaCode GL    * <i>callable</i> on the machine running the program and <i>available</i> on 
+CustomJavaCode GL    * the display device that is rendering the output (note: on non-networked, 
+CustomJavaCode GL    * single-display machines these two conditions are identical; on networked and/or
+CustomJavaCode GL    * multi-display machines this becomes more complicated). These conditions are
+CustomJavaCode GL    * met if the function is either part of the core OpenGL version supported by
+CustomJavaCode GL    * both the host and display, or it is an OpenGL extension function that both
+CustomJavaCode GL    * the host and display support. <P>
+CustomJavaCode GL    *
+CustomJavaCode GL    * A GL function is <i>callable</i> if it is successfully linked at runtime,
+CustomJavaCode GL    * hence the GLContext must be made current at least once.
+CustomJavaCode GL    * 
+CustomJavaCode GL    * @param glFunctionName the name of the OpenGL function (e.g., use
+CustomJavaCode GL    * "glBindRenderbufferEXT" or "glBindRenderbuffer" to check if {@link
+CustomJavaCode GL    * #glBindRenderbuffer(int,int)} is available).
+CustomJavaCode GL    */
+CustomJavaCode GL   public boolean isFunctionAvailable(String glFunctionName);
+
+CustomJavaCode GL   /**
+CustomJavaCode GL    * Returns true if the specified OpenGL extension can be
+CustomJavaCode GL    * used successfully through this GL instance given the current host (OpenGL
+CustomJavaCode GL    * <i>client</i>) and display (OpenGL <i>server</i>) configuration.<P> 
+CustomJavaCode GL    *
+CustomJavaCode GL    * @param glExtensionName the name of the OpenGL extension (e.g.,
+CustomJavaCode GL    * "GL_ARB_vertex_program").
+CustomJavaCode GL    */
+CustomJavaCode GL   public boolean isExtensionAvailable(String glExtensionName);
+
+CustomJavaCode GL   /**
+CustomJavaCode GL    * Provides platform-independent access to the <code>wglAllocateMemoryNV</code> /
+CustomJavaCode GL    * <code>glXAllocateMemoryNV</code> extension.
+CustomJavaCode GL    */
+CustomJavaCode GL   public java.nio.ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3);
+
+CustomJavaCode GL   /** Provides a platform-independent way to specify the minimum swap
+CustomJavaCode GL       interval for buffer swaps. An argument of 0 disables
+CustomJavaCode GL       sync-to-vertical-refresh completely, while an argument of 1
+CustomJavaCode GL       causes the application to wait until the next vertical refresh
+CustomJavaCode GL       until swapping buffers. The default, which is platform-specific,
+CustomJavaCode GL       is usually either 0 or 1. This function is not guaranteed to
+CustomJavaCode GL       have an effect, and in particular only affects heavyweight
+CustomJavaCode GL       onscreen components. */
+CustomJavaCode GL   public void setSwapInterval(int interval);
+
+CustomJavaCode GL   /**
+CustomJavaCode GL    * Returns an object through which platform-specific OpenGL extensions
+CustomJavaCode GL    * (WGL, GLX, etc.) may be accessed. The data type of the returned
+CustomJavaCode GL    * object and its associated capabilities are undefined. Most
+CustomJavaCode GL    * applications will never need to call this method. It is highly
+CustomJavaCode GL    * recommended that any applications which do call this method perform
+CustomJavaCode GL    * all accesses on the returned object reflectively to guard
+CustomJavaCode GL    * themselves against changes to the implementation.
+CustomJavaCode GL    */
+CustomJavaCode GL   public Object getPlatformGLExtensions();
+
+CustomJavaCode GL   /**
+CustomJavaCode GL    * Returns an object providing access to the specified OpenGL
+CustomJavaCode GL    * extension. This is intended to provide a mechanism for vendors who
+CustomJavaCode GL    * which to provide access to new OpenGL extensions without changing
+CustomJavaCode GL    * the public API of the core package. For example, a user may request
+CustomJavaCode GL    * access to extension "GL_VENDOR_foo" and receive back an object
+CustomJavaCode GL    * which implements a vendor-specified interface which can call the
+CustomJavaCode GL    * OpenGL extension functions corresponding to that extension. It is
+CustomJavaCode GL    * up to the vendor to specify both the extension name and Java API
+CustomJavaCode GL    * for accessing it, including which class or interface contains the
+CustomJavaCode GL    * functions.
+CustomJavaCode GL    *
+CustomJavaCode GL    * <P>
+CustomJavaCode GL    *
+CustomJavaCode GL    * Note: it is the intent to add new extensions as quickly as possible
+CustomJavaCode GL    * to the core GL API. Therefore it is unlikely that most vendors will
+CustomJavaCode GL    * use this extension mechanism, but it is being provided for
+CustomJavaCode GL    * completeness.
+CustomJavaCode GL    */
+CustomJavaCode GL   public Object getExtension(String extensionName);
diff --git a/make/config/jogl/gl-desktop-tracker.cfg b/make/config/jogl/gl-desktop-tracker.cfg
new file mode 100644
index 000000000..4b9a7edb7
--- /dev/null
+++ b/make/config/jogl/gl-desktop-tracker.cfg
@@ -0,0 +1,38 @@
+
+# Track server-side object creation and deletion when necessary
+# Note that this is only necessary when the Java 2D / JOGL bridge is active,
+# so will never be needed for the embedded OpenGL variants
+JavaEpilogue glGenBuffers               if (tracker != null) tracker.addBuffers({0}, {1});
+JavaEpilogue glGenFencesAPPLE           if (tracker != null) tracker.addFencesAPPLE({0}, {1});
+JavaEpilogue glGenFencesNV              if (tracker != null) tracker.addFencesNV({0}, {1});
+JavaEpilogue glGenFragmentShadersATI    if (tracker != null) tracker.addFragmentShadersATI(_res, {0});
+JavaEpilogue glGenFramebuffersEXT       if (tracker != null) tracker.addFramebuffersEXT({0}, {1});
+JavaEpilogue glGenLists                 if (tracker != null) tracker.addLists(_res, {0});
+JavaEpilogue glGenOcclusionQueriesNV    if (tracker != null) tracker.addOcclusionQueriesNV({0}, {1});
+JavaEpilogue glCreateProgram            if (tracker != null) tracker.addProgramObject(_res);
+JavaEpilogue glGenPrograms              if (tracker != null) tracker.addPrograms({0}, {1});
+JavaEpilogue glGenQueries               if (tracker != null) tracker.addQueries({0}, {1});
+JavaEpilogue glGenRenderbuffersEXT      if (tracker != null) tracker.addRenderbuffersEXT({0}, {1});
+JavaEpilogue glCreateShader             if (tracker != null) tracker.addShaderObject(_res);
+JavaEpilogue glGenTextures              if (tracker != null) tracker.addTextures({0}, {1});
+JavaEpilogue glGenVertexArraysAPPLE     if (tracker != null) tracker.addVertexArraysAPPLE({0}, {1});
+JavaEpilogue glGenVertexShadersEXT      if (tracker != null) tracker.addVertexShadersEXT(_res, {0});
+
+JavaEpilogue glDeleteBuffers            if (tracker != null) tracker.removeBuffers({0}, {1});
+JavaEpilogue glDeleteFencesAPPLE        if (tracker != null) tracker.removeFencesAPPLE({0}, {1});
+JavaEpilogue glDeleteFencesNV           if (tracker != null) tracker.removeFencesNV({0}, {1});
+JavaEpilogue glDeleteFragmentShaderATI  if (tracker != null) tracker.removeFragmentShaderATI({0});
+JavaEpilogue glDeleteFramebuffersEXT    if (tracker != null) tracker.removeFramebuffersEXT({0}, {1});
+JavaEpilogue glDeleteLists              if (tracker != null) tracker.removeLists({0}, {1});
+JavaEpilogue glDeleteOcclusionQueriesNV if (tracker != null) tracker.removeOcclusionQueriesNV({0}, {1});
+JavaEpilogue glDeleteProgram            if (tracker != null) tracker.removeProgramObject({0});
+JavaEpilogue glDeleteObject             if (tracker != null) tracker.removeProgramOrShaderObject({0});
+JavaEpilogue glDeletePrograms           if (tracker != null) tracker.removePrograms({0}, {1});
+JavaEpilogue glDeleteProgramsNV         if (tracker != null) tracker.removeProgramsNV({0}, {1});
+JavaEpilogue glDeleteQueries            if (tracker != null) tracker.removeQueries({0}, {1});
+JavaEpilogue glDeleteRenderbuffersEXT   if (tracker != null) tracker.removeRenderbuffersEXT({0}, {1});
+JavaEpilogue glDeleteShader             if (tracker != null) tracker.removeShaderObject({0});
+JavaEpilogue glDeleteTextures           if (tracker != null) tracker.removeTextures({0}, {1});
+JavaEpilogue glDeleteVertexArraysAPPLE  if (tracker != null) tracker.removeVertexArraysAPPLE({0}, {1});
+JavaEpilogue glDeleteVertexShaderEXT    if (tracker != null) tracker.removeVertexShaderEXT({0});
+
diff --git a/make/config/jogl/gl-desktop.cfg b/make/config/jogl/gl-desktop.cfg
new file mode 100755
index 000000000..d6a610c59
--- /dev/null
+++ b/make/config/jogl/gl-desktop.cfg
@@ -0,0 +1,67 @@
+# This .cfg file provides common options used by the desktop OpenGL
+# implementation on all platforms.
+
+# Inform the glue code generator of the association between #defines
+# and functions and the extensions in which they are defined
+GLHeader GL/gl.h
+GLHeader GL/glext.h
+
+#Include gl-desktop-tracker.cfg
+
+
+#
+# Directives needed when processing wglext.h on Windows and other platforms
+#
+Opaque boolean BOOL
+ReturnsString wglGetExtensionsStringARB
+ReturnsString wglGetExtensionsStringEXT
+Opaque long HANDLE
+Opaque long HBITMAP
+Opaque long HDC
+Opaque long HGDIOBJ
+Opaque long HGLRC
+Opaque long HPBUFFERARB
+Opaque long HPBUFFEREXT
+Opaque boolean BOOL
+Opaque long PROC
+Opaque long void **
+
+#
+# Directives needed when processing cglext.h on MacOSX and other platforms
+#
+Opaque long CGContextRef
+Opaque long void **
+# Implement the first argument to cglGetProcAddress as String instead
+# of byte[]
+ArgumentIsString cglGetProcAddress 0
+
+#
+# Directives needed when processing glxext.h on X11 and other platforms
+#
+Opaque long __GLXextFuncPtr
+Opaque boolean Bool
+Opaque long Display *
+Opaque long GLXContext
+Opaque long Visual *
+# Ignore the empty Display and Visual data structures (though made
+# opaque, the references from XVisualInfo and elsewhere are still
+# traversed)
+Ignore Display
+Ignore Visual
+# Implement the first argument to glXGetProcAddress as String instead
+# of byte[]
+ArgumentIsString glXGetProcAddress 0
+ArgumentIsString glXGetProcAddressARB 0
+ReturnsString glXQueryExtensionsString
+ReturnsString glXQueryServerString
+ReturnsString glXGetClientString
+TemporaryCVariableDeclaration glXChooseFBConfig     int count;
+TemporaryCVariableAssignment  glXChooseFBConfig     count = _ptr3[0];
+ReturnValueCapacity           glXChooseFBConfig     count * sizeof(GLXFBConfig)
+TemporaryCVariableDeclaration glXChooseFBConfigSGIX int count;
+TemporaryCVariableAssignment  glXChooseFBConfigSGIX count = _ptr3[0];
+ReturnValueCapacity           glXChooseFBConfigSGIX count * sizeof(GLXFBConfig)
+TemporaryCVariableDeclaration glXGetFBConfigs       int count;
+TemporaryCVariableAssignment  glXGetFBConfigs       count = _ptr2[0];
+ReturnValueCapacity           glXGetFBConfigs       count * sizeof(GLXFBConfig)
+
diff --git a/make/config/jogl/gl-es1.cfg b/make/config/jogl/gl-es1.cfg
new file mode 100755
index 000000000..02aae2860
--- /dev/null
+++ b/make/config/jogl/gl-es1.cfg
@@ -0,0 +1,88 @@
+# This .cfg file is used to generate the GL interface and implementing class.
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/jogl/es1
+
+ExtendedInterfaceSymbols ../build-temp/gensrc/classes/javax/media/opengl/GL.java
+ExtendedInterfaceSymbols ../build-temp/gensrc/classes/javax/media/opengl/GL2ES1.java
+ExtendedInterfaceSymbols ../src/jogl/classes/javax/media/opengl/GLBase.java
+ExtendedInterfaceSymbols ../src/jogl/classes/javax/media/opengl/fixedfunc/GLMatrixFunc.java
+ExtendedInterfaceSymbols ../src/jogl/classes/javax/media/opengl/fixedfunc/GLPointerFunc.java
+ExtendedInterfaceSymbols ../src/jogl/classes/javax/media/opengl/fixedfunc/GLLightingFunc.java
+
+# There are a few routines we don't handle yet
+Ignore glGetBufferPointervOES
+Package javax.media.opengl
+Style InterfaceAndImpl
+JavaClass GLES1
+Extends GLES1 GLBase
+Extends GLES1 GL
+Extends GLES1 GL2ES1
+ImplPackage com.sun.opengl.impl.es1
+ImplJavaClass GLES1Impl
+Implements GLES1Impl GLBase
+Implements GLES1Impl GL
+Implements GLES1Impl GL2ES1
+HierarchicalNativeOutput false
+Include gl-common.cfg
+Include gl-common-extensions.cfg
+
+EmitProcAddressTable true
+ProcAddressTableClassName GLES1ProcAddressTable
+GetProcAddressTableExpr ((GLES1ProcAddressTable)_context.getGLProcAddressTable())
+
+# Inform the glue code generator of the association between #defines
+# and functions and the extensions in which they are defined
+GLHeader GLES/gl.h
+GLHeader GLES/glext.h
+GLHeader GL/gl.h
+GLHeader GL/glext.h
+
+# Force all of the methods to be emitted using dynamic linking so we
+# don't need to link against any emulation library on the desktop or
+# depend on the presence of an import library for a particular device
+ForceProcAddressGen __ALL__
+
+# Also force the calling conventions of the locally generated function
+# pointer typedefs for these routines to GL_APIENTRY
+LocalProcAddressCallingConvention __ALL__ GL_APIENTRY
+
+# Pick up on-line OpenGL javadoc thanks to user cylab on javagaming.org forums
+TagNativeBinding true
+
+# Ignore certain extensions that will be picked up by the dynamic
+# lookup mechanism anyway if they are present
+IgnoreExtension GL_OES_fixed_point
+IgnoreExtension GL_OES_single_precision
+
+CustomJavaCode GLES1Impl  public void glOrtho(double left, double right, double bottom, double top, double near_val, double far_val) {
+CustomJavaCode GLES1Impl    glOrtho((float) left, (float) right, (float) bottom, (float) top, (float) near_val, (float) far_val); }
+                
+CustomJavaCode GLES1Impl  public void glFrustum(double left, double right, double bottom, double top, double zNear, double zFar) {
+CustomJavaCode GLES1Impl    glFrustumf((float) left, (float) right, (float) bottom, (float) top, (float) zNear, (float) zFar); }
+                
+CustomJavaCode GLES1Impl  public void glClearDepth(double depth) {
+CustomJavaCode GLES1Impl   glClearDepthf((float)depth); }
+
+CustomJavaCode GLES1Impl  public void glDepthRange(double zNear, double zFar) {
+CustomJavaCode GLES1Impl   glDepthRangef((float)zNear, (float)zFar); }
+
+CustomCCode /* Define GL_GLEXT_PROTOTYPES so that the OpenGL extension prototypes in
+CustomCCode    "glext.h" are parsed. */
+CustomCCode #define GL_GLEXT_PROTOTYPES
+
+CustomCCode /* Include the OpenGL headers */
+CustomCCode /* #define GL_APICALL __declspec(dllimport) */
+CustomCCode #include <GLES/gl.h>
+CustomCCode #include <GLES/glext.h>
+CustomCCode #include <stdlib.h>
+Include ../intptr.cfg
+
+IncludeAs CustomJavaCode GLES1Impl gl-impl-CustomJavaCode-common.java
+IncludeAs CustomJavaCode GLES1Impl gl-impl-CustomJavaCode-gles1.java
+IncludeAs CustomJavaCode GLES1Impl gl-impl-CustomJavaCode-embedded.java
+IncludeAs CustomCCode gl-impl-CustomCCode-gles1.c
+
+Import javax.media.opengl.GLES1
+Import javax.media.opengl.GLES2
+Import javax.media.opengl.GL2
+Import com.sun.opengl.impl.InternalBufferUtil
diff --git a/make/config/jogl/gl-es2.cfg b/make/config/jogl/gl-es2.cfg
new file mode 100755
index 000000000..244f1944f
--- /dev/null
+++ b/make/config/jogl/gl-es2.cfg
@@ -0,0 +1,72 @@
+# This .cfg file is used to generate the GL interface and implementing class.
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/jogl/es2
+
+ExtendedInterfaceSymbols ../build-temp/gensrc/classes/javax/media/opengl/GL.java
+ExtendedInterfaceSymbols ../build-temp/gensrc/classes/javax/media/opengl/GL2ES2.java
+ExtendedInterfaceSymbols ../src/jogl/classes/javax/media/opengl/GLBase.java
+
+Package javax.media.opengl
+Style InterfaceAndImpl
+JavaClass GLES2
+Extends GLES2 GLBase
+Extends GLES2 GL
+Extends GLES2 GL2ES2
+ImplPackage com.sun.opengl.impl.es2
+ImplJavaClass GLES2Impl
+Implements GLES2Impl GLBase
+Implements GLES2Impl GL
+Implements GLES2Impl GL2ES2
+HierarchicalNativeOutput false
+Include gl-common.cfg
+Include gl-common-extensions.cfg
+
+EmitProcAddressTable true
+ProcAddressTableClassName GLES2ProcAddressTable
+GetProcAddressTableExpr ((GLES2ProcAddressTable)_context.getGLProcAddressTable())
+
+# Inform the glue code generator of the association between #defines
+# and functions and the extensions in which they are defined
+GLHeader GLES2/gl2.h
+GLHeader GLES2/gl2ext.h
+GLHeader GL/gl.h
+GLHeader GL/glext.h
+
+# Force all of the methods to be emitted using dynamic linking so we
+# don't need to link against any emulation library on the desktop or
+# depend on the presence of an import library for a particular device
+ForceProcAddressGen __ALL__
+
+# Also force the calling conventions of the locally generated function
+# pointer typedefs for these routines to GL_APIENTRY
+LocalProcAddressCallingConvention __ALL__ GL_APIENTRY
+
+# Pick up on-line OpenGL javadoc thanks to user cylab on javagaming.org forums
+TagNativeBinding true
+
+IncludeAs CustomJavaCode GLES2 gl-if-CustomJavaCode-gles2.java
+
+CustomCCode /* Define GL_GLEXT_PROTOTYPES so that the OpenGL extension prototypes in
+CustomCCode    "glext.h" are parsed. */
+CustomCCode #define GL_GLEXT_PROTOTYPES
+
+CustomCCode /* Include the OpenGL headers */
+CustomCCode /* #define GL_APICALL __declspec(dllimport) */
+CustomCCode #include <GLES2/gl2ext.h>
+CustomCCode #include <stdlib.h>
+Include ../intptr.cfg
+
+IncludeAs CustomJavaCode GLES2Impl gl-impl-CustomJavaCode-common.java
+IncludeAs CustomJavaCode GLES2Impl gl-impl-CustomJavaCode-gles2.java
+IncludeAs CustomJavaCode GLES2Impl gl-impl-CustomJavaCode-embedded.java
+IncludeAs CustomJavaCode GLES2Impl gl-impl-CustomJavaCode-gl2_es2.java
+IncludeAs CustomCCode gl-impl-CustomCCode-gles2.c
+
+Import javax.media.opengl.GLES1
+Import javax.media.opengl.GLES2
+Import javax.media.opengl.GL2
+Import javax.media.opengl.GLArrayData
+Import javax.media.opengl.GLUniformData
+Import com.sun.opengl.impl.InternalBufferUtil
+Import java.io.PrintStream
+
diff --git a/make/config/jogl/gl-gl2.cfg b/make/config/jogl/gl-gl2.cfg
new file mode 100644
index 000000000..8dfe76758
--- /dev/null
+++ b/make/config/jogl/gl-gl2.cfg
@@ -0,0 +1,70 @@
+# This .cfg file is used to generate the GL interface and implementing class.
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/jogl/gl2
+
+ExtendedInterfaceSymbols ../build-temp/gensrc/classes/javax/media/opengl/GL.java
+ExtendedInterfaceSymbols ../build-temp/gensrc/classes/javax/media/opengl/GL2ES1.java
+ExtendedInterfaceSymbols ../build-temp/gensrc/classes/javax/media/opengl/GL2ES2.java
+ExtendedInterfaceSymbols ../src/jogl/classes/javax/media/opengl/GLBase.java
+ExtendedInterfaceSymbols ../src/jogl/classes/javax/media/opengl/fixedfunc/GLMatrixFunc.java
+ExtendedInterfaceSymbols ../src/jogl/classes/javax/media/opengl/fixedfunc/GLPointerFunc.java
+ExtendedInterfaceSymbols ../src/jogl/classes/javax/media/opengl/fixedfunc/GLLightingFunc.java
+
+Package javax.media.opengl
+Style InterfaceAndImpl
+JavaClass GL2
+Extends GL2 GLBase
+Extends GL2 GL
+Extends GL2 GL2ES1
+Extends GL2 GL2ES2
+ImplPackage com.sun.opengl.impl.gl2
+ImplJavaClass GL2Impl
+Implements GL2Impl GLBase
+Implements GL2Impl GL
+Implements GL2Impl GL2ES1
+Implements GL2Impl GL2ES2
+Include gl-common-gl2.cfg
+Include gl-common-extensions.cfg
+Include gl-desktop.cfg
+
+EmitProcAddressTable true
+ProcAddressTableClassName GL2ProcAddressTable
+GetProcAddressTableExpr ((GL2ProcAddressTable)_context.getGLProcAddressTable())
+
+# Pick up on-line OpenGL javadoc thanks to user cylab on javagaming.org forums
+TagNativeBinding true
+
+# Ignore extensions that are already picked up via the GL2ES1 interface
+IgnoreExtension GL_EXT_point_parameters
+
+CustomJavaCode GL2     public boolean glIsPBOPackEnabled();
+CustomJavaCode GL2     public boolean glIsPBOUnpackEnabled();
+
+CustomJavaCode GL2Impl public void glFrustumf(float left, float right, float bottom, float top, float zNear, float zFar) {
+CustomJavaCode GL2Impl   glFrustum((double)left, (double)right, (double)bottom, (double)top, (double)zNear, (double)zFar); }
+
+CustomJavaCode GL2Impl public void glOrthof(float left, float right, float bottom, float top, float zNear, float zFar) {
+CustomJavaCode GL2Impl   glOrtho((double)left, (double)right, (double)bottom, (double)top, (double)zNear, (double)zFar); }
+
+CustomJavaCode GL2Impl public void glClearDepthf(float depth) {
+CustomJavaCode GL2Impl   glClearDepth((double)depth); }
+
+CustomJavaCode GL2Impl public void glDepthRangef(float zNear, float zFar) {
+CustomJavaCode GL2Impl    glDepthRange((double)zNear, (double)zFar); }
+
+Include gl-headers.cfg
+Include ../intptr.cfg
+
+IncludeAs CustomJavaCode GL2Impl gl-impl-CustomJavaCode-common.java
+IncludeAs CustomJavaCode GL2Impl gl-impl-CustomJavaCode-gl2.java
+IncludeAs CustomJavaCode GL2Impl gl-impl-CustomJavaCode-desktop.java
+IncludeAs CustomJavaCode GL2Impl gl-impl-CustomJavaCode-gl2_es2.java
+IncludeAs CustomCCode gl-impl-CustomCCode-gl2.c
+
+Import javax.media.opengl.GLES1
+Import javax.media.opengl.GLES2
+Import javax.media.opengl.GL2
+Import javax.media.opengl.GLArrayData
+Import javax.media.opengl.GLUniformData
+Import com.sun.opengl.impl.InternalBufferUtil
+Import java.io.PrintStream
diff --git a/make/config/jogl/gl-gl2es12.cfg b/make/config/jogl/gl-gl2es12.cfg
new file mode 100644
index 000000000..b46bc99ab
--- /dev/null
+++ b/make/config/jogl/gl-gl2es12.cfg
@@ -0,0 +1,74 @@
+# This .cfg file is used to generate the GL interface and implementing class.
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/jogl/gl2es12
+
+ExtendedInterfaceSymbols ../build-temp/gensrc/classes/javax/media/opengl/GL.java
+ExtendedInterfaceSymbols ../build-temp/gensrc/classes/javax/media/opengl/GL2ES1.java
+ExtendedInterfaceSymbols ../build-temp/gensrc/classes/javax/media/opengl/GL2ES2.java
+ExtendedInterfaceSymbols ../src/jogl/classes/javax/media/opengl/GLBase.java
+ExtendedInterfaceSymbols ../src/jogl/classes/javax/media/opengl/fixedfunc/GLMatrixFunc.java
+ExtendedInterfaceSymbols ../src/jogl/classes/javax/media/opengl/fixedfunc/GLPointerFunc.java
+ExtendedInterfaceSymbols ../src/jogl/classes/javax/media/opengl/fixedfunc/GLLightingFunc.java
+
+Style ImplOnly
+ImplPackage com.sun.opengl.impl.gl2es12
+ImplJavaClass GL2ES12Impl
+Implements GL2ES12Impl GL
+Implements GL2ES12Impl GL2ES1
+Implements GL2ES12Impl GL2ES2
+Implements GL2ES12Impl GLBase
+
+Include gl-common-gl2.cfg
+Include gl-common-extensions.cfg
+Include gl-desktop.cfg
+
+# Because we're manually implementing glMapBuffer but only producing
+# the implementing class, GlueGen doesn't notice that it has to emit a
+# proc address table entry for it. Force it to here.
+ForceProcAddressGen glMapBuffer
+
+EmitProcAddressTable true
+ProcAddressTableClassName GL2ES12ProcAddressTable
+GetProcAddressTableExpr ((GL2ES12ProcAddressTable)_context.getGLProcAddressTable())
+
+# Pick up on-line OpenGL javadoc thanks to user cylab on javagaming.org forums
+TagNativeBinding true
+
+# There seem to be some errors in the glue code generation where we are not ignoring
+# enough routines from desktop GL in GL2ES12Impl. For now manually ignore those which
+# we know shouldn't be in there
+Ignore glGetTexImage
+Ignore glPixelStoref
+
+# Add input validation to glPixelStorei to make sure that, even if we
+# are running on top of desktop OpenGL, parameters not exposed in
+# OpenGL ES can not be changed
+JavaPrologue glPixelStorei if (param != GL_PACK_ALIGNMENT && param != GL_UNPACK_ALIGNMENT) {
+JavaPrologue glPixelStorei     throw new GLException("Unsupported pixel store parameter 0x" + Integer.toHexString(param));
+JavaPrologue glPixelStorei }
+
+CustomJavaCode GL2ES12Impl public void glFrustumf(float left, float right, float bottom, float top, float zNear, float zFar) {
+CustomJavaCode GL2ES12Impl   glFrustum((double)left, (double)right, (double)bottom, (double)top, (double)zNear, (double)zFar); }
+
+CustomJavaCode GL2ES12Impl public void glOrthof(float left, float right, float bottom, float top, float zNear, float zFar) {
+CustomJavaCode GL2ES12Impl   glOrtho((double)left, (double)right, (double)bottom, (double)top, (double)zNear, (double)zFar); }
+
+CustomJavaCode GL2ES12Impl public void glClearDepthf(float depth) {
+CustomJavaCode GL2ES12Impl   glClearDepth((double)depth); }
+
+CustomJavaCode GL2ES12Impl public void glDepthRangef(float zNear, float zFar) {
+CustomJavaCode GL2ES12Impl    glDepthRange((double)zNear, (double)zFar); }
+
+Include gl-headers.cfg
+Include ../intptr.cfg
+
+IncludeAs CustomJavaCode GL2ES12Impl gl-impl-CustomJavaCode-common.java
+IncludeAs CustomJavaCode GL2ES12Impl gl-impl-CustomJavaCode-gl2es12.java
+IncludeAs CustomJavaCode GL2ES12Impl gl-impl-CustomJavaCode-embedded.java
+IncludeAs CustomJavaCode GL2ES12Impl gl-impl-CustomJavaCode-gl2_es2.java
+IncludeAs CustomCCode gl-impl-CustomCCode-gl2es12.c
+
+Import javax.media.opengl.GLES1
+Import javax.media.opengl.GLES2
+Import com.sun.opengl.impl.InternalBufferUtil
+Import java.io.PrintStream
diff --git a/make/config/jogl/gl-gl3.cfg b/make/config/jogl/gl-gl3.cfg
new file mode 100644
index 000000000..2b521e30a
--- /dev/null
+++ b/make/config/jogl/gl-gl3.cfg
@@ -0,0 +1,51 @@
+# This .cfg file is used to generate the GL interface and implementing class.
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/jogl/gl3
+
+ExtendedInterfaceSymbols ../build-temp/gensrc/classes/javax/media/opengl/GL.java
+ExtendedInterfaceSymbols ../build-temp/gensrc/classes/javax/media/opengl/GL2ES2.java
+ExtendedInterfaceSymbols ../src/jogl/classes/javax/media/opengl/GLBase.java
+
+Package javax.media.opengl
+Style InterfaceAndImpl
+JavaClass GL3
+Extends GL3 GLBase
+Extends GL3 GL
+Extends GL3 GL2ES2
+ImplPackage com.sun.opengl.impl.gl3
+ImplJavaClass GL3Impl
+Implements GL3Impl GLBase
+Implements GL3Impl GL
+Implements GL3Impl GL2ES2
+Include gl-common-gl2.cfg
+Include gl-common-extensions.cfg
+Include gl3-desktop.cfg
+
+EmitProcAddressTable true
+ProcAddressTableClassName GL3ProcAddressTable
+GetProcAddressTableExpr ((GL3ProcAddressTable)_context.getGLProcAddressTable())
+
+# Pick up on-line OpenGL javadoc thanks to user cylab on javagaming.org forums
+TagNativeBinding true
+
+CustomJavaCode GL3Impl public void glClearDepthf(float depth) {
+CustomJavaCode GL3Impl   glClearDepth((double)depth); }
+
+CustomJavaCode GL3Impl public void glDepthRangef(float zNear, float zFar) {
+CustomJavaCode GL3Impl    glDepthRange((double)zNear, (double)zFar); }
+
+Include gl3-headers.cfg
+Include ../intptr.cfg
+
+IncludeAs CustomJavaCode GL3Impl gl-impl-CustomJavaCode-common.java
+IncludeAs CustomJavaCode GL3Impl gl-impl-CustomJavaCode-gl3.java
+IncludeAs CustomJavaCode GL3Impl gl-impl-CustomJavaCode-desktop.java
+IncludeAs CustomJavaCode GL3Impl gl-impl-CustomJavaCode-gl2_es2.java
+IncludeAs CustomCCode gl-impl-CustomCCode-gl3.c
+
+Import javax.media.opengl.GLES2
+Import javax.media.opengl.GL3
+Import javax.media.opengl.GLArrayData
+Import javax.media.opengl.GLUniformData
+Import com.sun.opengl.impl.InternalBufferUtil
+Import java.io.PrintStream
diff --git a/make/config/jogl/gl-headers.cfg b/make/config/jogl/gl-headers.cfg
new file mode 100755
index 000000000..1cc5bf05b
--- /dev/null
+++ b/make/config/jogl/gl-headers.cfg
@@ -0,0 +1,41 @@
+CustomCCode /* Define GL_GLEXT_PROTOTYPES so that the OpenGL extension prototypes in
+CustomCCode    "glext.h" are parsed. */
+CustomCCode #define GL_GLEXT_PROTOTYPES
+CustomCCode #if defined(_WIN32)
+CustomCCode   #define WIN32_LEAN_AND_MEAN
+CustomCCode   #include <windows.h>
+CustomCCode   #undef WIN32_LEAN_AND_MEAN
+CustomCCode   #include <stdlib.h>
+CustomCCode   #include <stddef.h>
+CustomCCode   #include <malloc.h>
+CustomCCode   /* Define WGL_GLEXT_PROTOTYPES so that the OpenGL extension prototypes in
+CustomCCode      "wglext.h" are parsed. */
+CustomCCode   #define WGL_GLEXT_PROTOTYPES
+CustomCCode   /* Include the OpenGL headers */
+CustomCCode   #include <GL/gl.h>
+CustomCCode   #include <GL/wglext.h>
+CustomCCode #elif defined(macosx)
+CustomCCode   #include <inttypes.h>
+CustomCCode   #include <stdlib.h>
+CustomCCode   /* Include the OpenGL headers */
+CustomCCode   #include <GL/gl.h>
+CustomCCode   #include </usr/include/machine/types.h>
+CustomCCode   /* Provide Windows typedefs */
+CustomCCode   typedef void* LPVOID;
+CustomCCode   typedef unsigned int* PUINT;
+CustomCCode #elif defined(linux) || defined(__sun) || defined(__FreeBSD__) || defined(_HPUX)
+CustomCCode   #include <inttypes.h>
+CustomCCode   #include <stdlib.h>
+CustomCCode   #include <X11/Xlib.h>
+CustomCCode   /* Define GLX_GLXEXT_PROTOTYPES so that the OpenGL extension prototypes in
+CustomCCode      "glxext.h" are parsed. */
+CustomCCode   #define GLX_GLXEXT_PROTOTYPES
+CustomCCode   /* Include the OpenGL headers */
+CustomCCode   #include <GL/gl.h>
+CustomCCode   #include <GL/glx.h>
+CustomCCode   #include <GL/glxext.h>
+CustomCCode #endif
+CustomCCode /* Provide GLES #define for locally generated function pointer typedefs */
+CustomCCode #ifndef GL_APIENTRY
+CustomCCode #define GL_APIENTRY GLAPIENTRY
+CustomCCode #endif
diff --git a/make/config/jogl/gl-if-CustomJavaCode-gl.java b/make/config/jogl/gl-if-CustomJavaCode-gl.java
new file mode 100644
index 000000000..28d24c072
--- /dev/null
+++ b/make/config/jogl/gl-if-CustomJavaCode-gl.java
@@ -0,0 +1,12 @@
+
+  public GLProfile getGLProfile();
+
+  public void glClearDepth( double depth );
+
+  public void glDepthRange(double zNear, double zFar);
+
+  public int glGetBoundBuffer(int target);
+
+  public boolean glIsVBOArrayEnabled();
+  public boolean glIsVBOElementEnabled();
+
diff --git a/make/config/jogl/gl-if-CustomJavaCode-gles2.java b/make/config/jogl/gl-if-CustomJavaCode-gles2.java
new file mode 100644
index 000000000..ea40f6329
--- /dev/null
+++ b/make/config/jogl/gl-if-CustomJavaCode-gles2.java
@@ -0,0 +1,3 @@
+
+  public static final int GL_NVIDIA_PLATFORM_BINARY_NV = 0x890B;
+
diff --git a/make/config/jogl/gl-if-gl-ignores.cfg b/make/config/jogl/gl-if-gl-ignores.cfg
new file mode 100644
index 000000000..1fa439702
--- /dev/null
+++ b/make/config/jogl/gl-if-gl-ignores.cfg
@@ -0,0 +1,523 @@
+# FIXME: some of these definitions like the ARB_imaging subset should end up in the GL interface
+Ignore GL.+_NV
+Ignore GL.+_ATI
+Ignore GL.+_AMD
+Ignore GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
+Ignore GL_ACTIVE_ATTRIBUTES
+Ignore GL_ACTIVE_UNIFORM_MAX_LENGTH
+Ignore GL_ACTIVE_UNIFORMS
+Ignore GL_ADD
+Ignore GL_ADD_SIGNED
+Ignore GL_ALPHA_SCALE
+Ignore GL_ALPHA_TEST
+Ignore GL_ALPHA_TEST_FUNC
+Ignore GL_ALPHA_TEST_REF
+Ignore GL_AMBIENT
+Ignore GL_AMBIENT_AND_DIFFUSE
+Ignore GL_AND
+Ignore GL_AND_INVERTED
+Ignore GL_AND_REVERSE
+Ignore GL_ATTACHED_SHADERS
+Ignore GL_BLEND_COLOR
+Ignore GL_BLEND_DST
+#Ignore GL_BLEND_DST_ALPHA
+#Ignore GL_BLEND_DST_RGB
+#Ignore GL_BLEND_EQUATION
+#Ignore GL_BLEND_EQUATION_ALPHA
+#Ignore GL_BLEND_EQUATION_ALPHA_OES
+Ignore GL_BLEND_EQUATION_OES
+#Ignore GL_BLEND_EQUATION_RGB
+#Ignore GL_BLEND_EQUATION_RGB_OES
+Ignore GL_BLEND_SRC
+#Ignore GL_BLEND_SRC_ALPHA
+#Ignore GL_BLEND_SRC_ALPHA_OES
+#Ignore GL_BLEND_SRC_RGB
+#Ignore GL_BLEND_SRC_RGB_OES
+Ignore GL_BOOL
+Ignore GL_BOOL_VEC2
+Ignore GL_BOOL_VEC3
+Ignore GL_BOOL_VEC4
+Ignore GL_BUFFER_ACCESS_OES
+Ignore GL_CLEAR
+Ignore GL_CLIENT_ACTIVE_TEXTURE
+Ignore GL_CLIP_PLANE0
+Ignore GL_CLIP_PLANE1
+Ignore GL_CLIP_PLANE2
+Ignore GL_CLIP_PLANE3
+Ignore GL_CLIP_PLANE4
+Ignore GL_CLIP_PLANE5
+Ignore GL_COLOR_ARRAY
+Ignore GL_COLOR_ARRAY_BUFFER_BINDING
+Ignore GL_COLOR_ARRAY_POINTER
+Ignore GL_COLOR_ARRAY_SIZE
+Ignore GL_COLOR_ARRAY_STRIDE
+Ignore GL_COLOR_ARRAY_TYPE
+Ignore GL_COLOR_LOGIC_OP
+Ignore GL_COLOR_MATERIAL
+Ignore GL_COMBINE
+Ignore GL_COMBINE_ALPHA
+Ignore GL_COMBINE_RGB
+Ignore GL_COMPILE_STATUS
+Ignore GL_CONSTANT
+Ignore GL_CONSTANT_ALPHA
+Ignore GL_CONSTANT_ATTENUATION
+Ignore GL_CONSTANT_COLOR
+Ignore GL_COORD_REPLACE_OES
+Ignore GL_COPY
+Ignore GL_COPY_INVERTED
+Ignore GL_CURRENT_COLOR
+Ignore GL_CURRENT_NORMAL
+Ignore GL_CURRENT_PALETTE_MATRIX_OES
+Ignore GL_CURRENT_PROGRAM
+Ignore GL_CURRENT_TEXTURE_COORDS
+Ignore GL_CURRENT_VERTEX_ATTRIB
+Ignore GL_DECAL
+#Ignore GL_DECR_WRAP
+#Ignore GL_DECR_WRAP_OES
+Ignore GL_DELETE_STATUS
+Ignore GL_DEPTH_COMPONENT
+Ignore GL_DEPTH_COMPONENT24_OES
+Ignore GL_DEPTH_COMPONENT32_OES
+Ignore GL_DIFFUSE
+Ignore GL_DOT3_RGB
+Ignore GL_DOT3_RGBA
+Ignore GL_EMISSION
+Ignore GL_EQUIV
+Ignore GL_ES_VERSION_2_0
+Ignore GL_ETC1_RGB8_OES
+Ignore GL_EXP
+Ignore GL_EXP2
+#Ignore GL_FIXED_OES
+#Ignore GL_FIXED
+Ignore GL_FLAT
+Ignore GL_FLOAT_MAT2
+Ignore GL_FLOAT_MAT3
+Ignore GL_FLOAT_MAT4
+Ignore GL_FLOAT_VEC2
+Ignore GL_FLOAT_VEC3
+Ignore GL_FLOAT_VEC4
+Ignore GL_FOG
+Ignore GL_FOG_COLOR
+Ignore GL_FOG_DENSITY
+Ignore GL_FOG_END
+Ignore GL_FOG_HINT
+Ignore GL_FOG_MODE
+Ignore GL_FOG_START
+Ignore GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT
+Ignore GL_FRAGMENT_SHADER
+Ignore GL_FRAGMENT_SHADER_DERIVATIVE_HINT
+#Ignore GL_FUNC_ADD
+#Ignore GL_FUNC_ADD_OES
+#Ignore GL_FUNC_REVERSE_SUBTRACT
+#Ignore GL_FUNC_REVERSE_SUBTRACT_OES
+#Ignore GL_FUNC_SUBTRACT
+#Ignore GL_FUNC_SUBTRACT_OES
+Ignore GL_GENERATE_MIPMAP
+Ignore GL_HIGH_FLOAT
+Ignore GL_HIGH_INT
+#Ignore GL_IMPLEMENTATION_COLOR_READ_FORMAT
+#Ignore GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES
+#Ignore GL_IMPLEMENTATION_COLOR_READ_TYPE
+#Ignore GL_IMPLEMENTATION_COLOR_READ_TYPE_OES
+#Ignore GL_INCR_WRAP
+#Ignore GL_INCR_WRAP_OES
+Ignore GL_INFO_LOG_LENGTH
+Ignore GL_INT
+Ignore GL_INTERPOLATE
+Ignore GL_INT_VEC2
+Ignore GL_INT_VEC3
+Ignore GL_INT_VEC4
+Ignore GL_LIGHT0
+Ignore GL_LIGHT1
+Ignore GL_LIGHT2
+Ignore GL_LIGHT3
+Ignore GL_LIGHT4
+Ignore GL_LIGHT5
+Ignore GL_LIGHT6
+Ignore GL_LIGHT7
+Ignore GL_LIGHTING
+Ignore GL_LIGHT_MODEL_AMBIENT
+Ignore GL_LIGHT_MODEL_TWO_SIDE
+Ignore GL_LINEAR_ATTENUATION
+Ignore GL_LINE_SMOOTH
+Ignore GL_LINE_SMOOTH_HINT
+Ignore GL_LINK_STATUS
+Ignore GL_LOGIC_OP_MODE
+Ignore GL_LOW_FLOAT
+Ignore GL_LOW_INT
+Ignore GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES
+Ignore GL_MATRIX_INDEX_ARRAY_OES
+Ignore GL_MATRIX_INDEX_ARRAY_POINTER_OES
+Ignore GL_MATRIX_INDEX_ARRAY_SIZE_OES
+Ignore GL_MATRIX_INDEX_ARRAY_STRIDE_OES
+Ignore GL_MATRIX_INDEX_ARRAY_TYPE_OES
+Ignore GL_MATRIX_MODE
+Ignore GL_MATRIX_PALETTE_OES
+Ignore GL_MAX_ARRAY_TEXTURE_LAYERS_EXT
+Ignore GL_MAX_CLIP_PLANES
+Ignore GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS
+Ignore GL_MAX_FRAGMENT_UNIFORM_VECTORS
+Ignore GL_MAX_LIGHTS
+Ignore GL_MAX_MODELVIEW_STACK_DEPTH
+Ignore GL_MAX_PALETTE_MATRICES_OES
+Ignore GL_MAX_PROJECTION_STACK_DEPTH
+Ignore GL_MAX_TEXTURE_IMAGE_UNITS
+Ignore GL_MAX_TEXTURE_STACK_DEPTH
+Ignore GL_MAX_TEXTURE_UNITS
+Ignore GL_MAX_VARYING_VECTORS
+Ignore GL_MAX_VERTEX_ATTRIBS
+Ignore GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS
+Ignore GL_MAX_VERTEX_UNIFORM_VECTORS
+Ignore GL_MAX_VERTEX_UNITS_OES
+Ignore GL_MEDIUM_FLOAT
+Ignore GL_MEDIUM_INT
+#Ignore GL_MIRRORED_REPEAT
+#Ignore GL_MIRRORED_REPEAT_OES
+Ignore GL_MODELVIEW
+Ignore GL_MODELVIEW_MATRIX
+Ignore GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES
+Ignore GL_MODELVIEW_STACK_DEPTH
+Ignore GL_MODULATE
+Ignore GL_MULTISAMPLE
+Ignore GL_NAND
+Ignore GL_NOOP
+Ignore GL_NOR
+Ignore GL_NORMAL_ARRAY
+Ignore GL_NORMAL_ARRAY_BUFFER_BINDING
+Ignore GL_NORMAL_ARRAY_POINTER
+Ignore GL_NORMAL_ARRAY_STRIDE
+Ignore GL_NORMAL_ARRAY_TYPE
+Ignore GL_NORMALIZE
+Ignore GL_NORMAL_MAP_OES
+Ignore GL_NUM_SHADER_BINARY_FORMATS
+Ignore GL_OES_blend_equation_separate
+Ignore GL_OES_blend_func_separate
+Ignore GL_OES_blend_subtract
+Ignore GL_OES_byte_coordinates
+Ignore GL_OES_compressed_ETC1_RGB8_texture
+Ignore GL_OES_compressed_paletted_texture
+Ignore GL_OES_depth24
+Ignore GL_OES_depth32
+Ignore GL_OES_draw_texture
+Ignore GL_OES_element_index_uint
+Ignore GL_OES_extended_matrix_palette
+Ignore GL_OES_fbo_render_mipmap
+Ignore GL_OES_fixed_point
+Ignore GL_OES_framebuffer_object
+Ignore GL_OES_matrix_get
+Ignore GL_OES_matrix_palette
+Ignore GL_OES_point_size_array
+Ignore GL_OES_point_sprite
+Ignore GL_OES_query_matrix
+Ignore GL_OES_read_format
+Ignore GL_OES_single_precision
+Ignore GL_OES_stencil1
+Ignore GL_OES_stencil4
+Ignore GL_OES_stencil8
+Ignore GL_OES_stencil_wrap
+Ignore GL_OES_texture_cube_map
+Ignore GL_OES_texture_env_crossbar
+Ignore GL_OES_texture_half_float
+Ignore GL_OES_texture_mirrored_repeat
+Ignore GL_OES_vertex_half_float
+Ignore GL_ONE_MINUS_CONSTANT_ALPHA
+Ignore GL_ONE_MINUS_CONSTANT_COLOR
+Ignore GL_OPERAND0_ALPHA
+Ignore GL_OPERAND0_RGB
+Ignore GL_OPERAND1_ALPHA
+Ignore GL_OPERAND1_RGB
+Ignore GL_OPERAND2_ALPHA
+Ignore GL_OPERAND2_RGB
+Ignore GL_OR
+Ignore GL_OR_INVERTED
+Ignore GL_OR_REVERSE
+Ignore GL_PALETTE4_R5_G6_B5_OES
+Ignore GL_PALETTE4_RGB5_A1_OES
+Ignore GL_PALETTE4_RGB8_OES
+Ignore GL_PALETTE4_RGBA4_OES
+Ignore GL_PALETTE4_RGBA8_OES
+Ignore GL_PALETTE8_R5_G6_B5_OES
+Ignore GL_PALETTE8_RGB5_A1_OES
+Ignore GL_PALETTE8_RGB8_OES
+Ignore GL_PALETTE8_RGBA4_OES
+Ignore GL_PALETTE8_RGBA8_OES
+Ignore GL_PERSPECTIVE_CORRECTION_HINT
+Ignore GL_PLATFORM_BINARY
+Ignore GL_POINT_DISTANCE_ATTENUATION
+Ignore GL_POINT_FADE_THRESHOLD_SIZE
+Ignore GL_POINT_SIZE
+Ignore GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES
+Ignore GL_POINT_SIZE_ARRAY_OES
+Ignore GL_POINT_SIZE_ARRAY_POINTER_OES
+Ignore GL_POINT_SIZE_ARRAY_STRIDE_OES
+Ignore GL_POINT_SIZE_ARRAY_TYPE_OES
+Ignore GL_POINT_SIZE_MAX
+Ignore GL_POINT_SIZE_MIN
+Ignore GL_POINT_SMOOTH
+Ignore GL_POINT_SMOOTH_HINT
+Ignore GL_POINT_SPRITE_OES
+Ignore GL_POSITION
+Ignore GL_PREVIOUS
+Ignore GL_PRIMARY_COLOR
+Ignore GL_PROJECTION
+Ignore GL_PROJECTION_MATRIX
+Ignore GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES
+Ignore GL_PROJECTION_STACK_DEPTH
+Ignore GL_QUADRATIC_ATTENUATION
+Ignore GL_R11F_G11F_B10F_EXT
+Ignore GL_REFLECTION_MAP_OES
+Ignore GL_RESCALE_NORMAL
+Ignore GL_RGBA_SIGNED_COMPONENTS_EXT
+Ignore GL_RGB_SCALE
+Ignore GL_SAMPLE_ALPHA_TO_ONE
+Ignore GL_SAMPLER_2D
+Ignore GL_SAMPLER_2D_ARRAY_EXT
+Ignore GL_SAMPLER_CUBE
+Ignore GL_SET
+Ignore GL_SHADE_MODEL
+Ignore GL_SHADER_BINARY_FORMATS
+Ignore GL_SHADER_COMPILER
+Ignore GL_SHADER_SOURCE_LENGTH
+Ignore GL_SHADER_TYPE
+Ignore GL_SHADING_LANGUAGE_VERSION
+Ignore GL_SHININESS
+Ignore GL_SMOOTH
+Ignore GL_SMOOTH_LINE_WIDTH_RANGE
+Ignore GL_SMOOTH_POINT_SIZE_RANGE
+Ignore GL_SPECULAR
+Ignore GL_SPOT_CUTOFF
+Ignore GL_SPOT_DIRECTION
+Ignore GL_SPOT_EXPONENT
+Ignore GL_SRC0_ALPHA
+Ignore GL_SRC0_RGB
+Ignore GL_SRC1_ALPHA
+Ignore GL_SRC1_RGB
+Ignore GL_SRC2_ALPHA
+Ignore GL_SRC2_RGB
+Ignore GL_STACK_OVERFLOW
+Ignore GL_STACK_UNDERFLOW
+Ignore GL_STENCIL_BACK_FAIL
+Ignore GL_STENCIL_BACK_FUNC
+Ignore GL_STENCIL_BACK_PASS_DEPTH_FAIL
+Ignore GL_STENCIL_BACK_PASS_DEPTH_PASS
+Ignore GL_STENCIL_BACK_REF
+Ignore GL_STENCIL_BACK_VALUE_MASK
+Ignore GL_STENCIL_BACK_WRITEMASK
+Ignore GL_STENCIL_INDEX
+Ignore GL_STENCIL_INDEX1_OES
+Ignore GL_STENCIL_INDEX4_OES
+Ignore GL_STREAM_DRAW
+Ignore GL_SUBTRACT
+Ignore GL_TEXTURE_2D_ARRAY_EXT
+Ignore GL_TEXTURE_2D_OES
+Ignore GL_TEXTURE_BINDING_2D_ARRAY_EXT
+Ignore GL_TEXTURE_COORD_ARRAY
+Ignore GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING
+Ignore GL_TEXTURE_COORD_ARRAY_POINTER
+Ignore GL_TEXTURE_COORD_ARRAY_SIZE
+Ignore GL_TEXTURE_COORD_ARRAY_STRIDE
+Ignore GL_TEXTURE_COORD_ARRAY_TYPE
+Ignore GL_TEXTURE_CROP_RECT_OES
+Ignore GL_TEXTURE_ENV
+Ignore GL_TEXTURE_ENV_COLOR
+Ignore GL_TEXTURE_ENV_MODE
+Ignore GL_TEXTURE_GEN_MODE_OES
+Ignore GL_TEXTURE_GEN_STR_OES
+Ignore GL_TEXTURE_MATRIX
+Ignore GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES
+Ignore GL_TEXTURE_RECTANGLE_NV_OES
+Ignore GL_TEXTURE_STACK_DEPTH
+Ignore GL_UNSIGNED_INT
+Ignore GL_UNSIGNED_INT_10F_11F_11F_REV_EXT
+Ignore GL_VALIDATE_STATUS
+Ignore GL_VERTEX_ARRAY
+Ignore GL_VERTEX_ARRAY_BUFFER_BINDING
+Ignore GL_VERTEX_ARRAY_POINTER
+Ignore GL_VERTEX_ARRAY_SIZE
+Ignore GL_VERTEX_ARRAY_STRIDE
+Ignore GL_VERTEX_ARRAY_TYPE
+Ignore GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING
+Ignore GL_VERTEX_ATTRIB_ARRAY_ENABLED
+Ignore GL_VERTEX_ATTRIB_ARRAY_NORMALIZED
+Ignore GL_VERTEX_ATTRIB_ARRAY_POINTER
+Ignore GL_VERTEX_ATTRIB_ARRAY_SIZE
+Ignore GL_VERTEX_ATTRIB_ARRAY_STRIDE
+Ignore GL_VERTEX_ATTRIB_ARRAY_TYPE
+Ignore GL_VERTEX_SHADER
+Ignore GL_WEIGHT_ARRAY_BUFFER_BINDING_OES
+Ignore GL_WEIGHT_ARRAY_OES
+Ignore GL_WEIGHT_ARRAY_POINTER_OES
+Ignore GL_WEIGHT_ARRAY_SIZE_OES
+Ignore GL_WEIGHT_ARRAY_STRIDE_OES
+Ignore GL_WEIGHT_ARRAY_TYPE_OES
+Ignore GL_WRITE_ONLY_OES
+Ignore GL_XOR
+Ignore glIsProgram
+Ignore glIsShader
+Ignore glUnmapBufferOES
+Ignore glCreateProgram
+Ignore glCreateShader
+Ignore glGetAttribLocation
+Ignore glGetUniformLocation
+Ignore glAlphaFunc
+Ignore glAttachShader
+Ignore glBindAttribLocation
+Ignore glBlendColor
+Ignore glBlendEquation
+Ignore glBlendEquationOES
+Ignore glBlendEquationSeparate
+Ignore glBlendEquationSeparateOES
+Ignore glBlendFuncSeparate
+Ignore glBlendFuncSeparateOES
+Ignore glClearDepthfOES
+Ignore glClientActiveTexture
+Ignore glClipPlanef
+Ignore glClipPlanefOES
+Ignore glColor4f
+Ignore glColor4ub
+Ignore glColorPointer
+Ignore glCompileShader
+Ignore glCoverageMaskNV
+Ignore glCoverageOperationNV
+Ignore glDeleteProgram
+Ignore glDeleteShader
+Ignore glDepthRangefOES
+Ignore glDetachShader
+Ignore glDisableClientState
+Ignore glDisableVertexAttribArray
+Ignore glDrawTexfOES
+Ignore glDrawTexfvOES
+Ignore glDrawTexiOES
+Ignore glDrawTexivOES
+Ignore glDrawTexsOES
+Ignore glDrawTexsvOES
+Ignore glDrawTexxvOES
+Ignore glEnableClientState
+Ignore glEnableVertexAttribArray
+Ignore glFogf
+Ignore glFogfv
+Ignore glFogxv
+Ignore glFogxvOES
+Ignore glFramebufferVertexAttribArrayNV
+Ignore glFrustumf
+Ignore glFrustumfOES
+Ignore glGenerateMipmap
+Ignore glGenerateMipmapOES
+Ignore glGetActiveAttrib
+Ignore glGetActiveUniform
+Ignore glGetAttachedShaders
+Ignore glGetClipPlanef
+Ignore glGetClipPlanefOES
+Ignore glGetFixedv
+Ignore glGetFixedvOES
+Ignore glGetLightfv
+Ignore glGetLightxv
+Ignore glGetLightxvOES
+Ignore glGetMaterialfv
+Ignore glGetMaterialxv
+Ignore glGetMaterialxvOES
+Ignore glGetProgramInfoLog
+Ignore glGetProgramiv
+Ignore glGetShaderInfoLog
+Ignore glGetShaderiv
+Ignore glGetShaderPrecisionFormat
+Ignore glGetShaderSource
+Ignore glGetTexEnvfv
+Ignore glGetTexEnviv
+Ignore glGetTexEnvxv
+Ignore glGetTexEnvxvOES
+Ignore glGetTexGenfvOES
+Ignore glGetTexGenivOES
+Ignore glGetTexGenxvOES
+Ignore glGetTexParameterxv
+Ignore glGetTexParameterxvOES
+Ignore glGetUniformfv
+Ignore glGetUniformiv
+Ignore glGetVertexAttribfv
+Ignore glGetVertexAttribiv
+Ignore glLightf
+Ignore glLightfv
+Ignore glLightModelf
+Ignore glLightModelfv
+Ignore glLightModelxv
+Ignore glLightModelxvOES
+Ignore glLightxv
+Ignore glLightxvOES
+Ignore glLinkProgram
+Ignore glLoadIdentity
+Ignore glLoadMatrixf
+Ignore glLogicOp
+Ignore glMaterialf
+Ignore glMaterialfv
+Ignore glMaterialxv
+Ignore glMaterialxvOES
+Ignore glMatrixIndexPointerOES
+Ignore glMatrixMode
+Ignore glMultiTexCoord4f
+Ignore glMultMatrixf
+Ignore glNormal3f
+Ignore glNormalPointer
+Ignore glOrthof
+Ignore glOrthofOES
+Ignore glPointParameterf
+Ignore glPointParameterfv
+Ignore glPointParameterxv
+Ignore glPointParameterxvOES
+Ignore glPointSize
+Ignore glPointSizePointer
+Ignore glReleaseShaderCompiler
+Ignore glRotatef
+Ignore glScalef
+Ignore glShadeModel
+Ignore glShaderBinary
+Ignore glShaderSource
+Ignore glStencilFuncSeparate
+Ignore glStencilMaskSeparate
+Ignore glStencilOpSeparate
+Ignore glTexCoordPointer
+Ignore glTexEnvf
+Ignore glTexEnvfv
+Ignore glTexEnvi
+Ignore glTexEnviv
+Ignore glTexEnvxv
+Ignore glTexEnvxvOES
+Ignore glTexGenfOES
+Ignore glTexGenfvOES
+Ignore glTexGeniOES
+Ignore glTexGenivOES
+Ignore glTexGenxvOES
+Ignore glTexParameterxv
+Ignore glTexParameterxvOES
+Ignore glTranslatef
+Ignore glUniform1f
+Ignore glUniform1fv
+Ignore glUniform1i
+Ignore glUniform1iv
+Ignore glUniform2f
+Ignore glUniform2fv
+Ignore glUniform2i
+Ignore glUniform2iv
+Ignore glUniform3f
+Ignore glUniform3fv
+Ignore glUniform3i
+Ignore glUniform3iv
+Ignore glUniform4f
+Ignore glUniform4fv
+Ignore glUniform4i
+Ignore glUniform4iv
+Ignore glUniformMatrix2fv
+Ignore glUniformMatrix3fv
+Ignore glUniformMatrix4fv
+Ignore glUseProgram
+Ignore glValidateProgram
+Ignore glVertexAttrib1f
+Ignore glVertexAttrib1fv
+Ignore glVertexAttrib2f
+Ignore glVertexAttrib2fv
+Ignore glVertexAttrib3f
+Ignore glVertexAttrib3fv
+Ignore glVertexAttrib4f
+Ignore glVertexAttrib4fv
+Ignore glVertexAttribPointer
+Ignore glVertexPointer
+Ignore glWeightPointerOES
diff --git a/make/config/jogl/gl-if-gl.cfg b/make/config/jogl/gl-if-gl.cfg
new file mode 100755
index 000000000..46e11fdd4
--- /dev/null
+++ b/make/config/jogl/gl-if-gl.cfg
@@ -0,0 +1,40 @@
+# This .cfg file is used to generate the GL interface and implementing class.
+Package javax.media.opengl
+Style InterfaceOnly
+JavaClass GL
+Extends GL GLBase
+
+ExtendedInterfaceSymbols ../src/jogl/classes/javax/media/opengl/GLBase.java
+
+HierarchicalNativeOutput false
+Include gl-common.cfg
+Include gl-common-extensions.cfg
+Include gl-if-gl-ignores.cfg
+
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/jogl
+
+Import javax.media.opengl.GLES1
+Import javax.media.opengl.GLES2
+Import javax.media.opengl.GL2
+
+# Ignore all ES 2.X only stuff ..
+Ignore ^gl.*x
+Ignore ^gl.*xOES
+Ignore glEGL.*
+
+EmitProcAddressTable false
+ProcAddressTableClassName DontGenerateProcAddressTableStuff
+GetProcAddressTableExpr DontGenerateProcAddressTableStuff
+
+# Inform the glue code generator of the association between #defines
+# and functions and the extensions in which they are defined
+GLHeader GLES2/gl2.h
+GLHeader GLES2/gl2ext.h
+GLHeader GL/gl.h
+GLHeader GL/glext.h
+
+# Pick up on-line OpenGL javadoc thanks to user cylab on javagaming.org forums
+TagNativeBinding true
+
+IncludeAs CustomJavaCode GL gl-if-CustomJavaCode-gl.java
diff --git a/make/config/jogl/gl-if-gl2_es1.cfg b/make/config/jogl/gl-if-gl2_es1.cfg
new file mode 100755
index 000000000..d09ebcb30
--- /dev/null
+++ b/make/config/jogl/gl-if-gl2_es1.cfg
@@ -0,0 +1,96 @@
+# This .cfg file is used to generate the GL interface and implementing class.
+Package javax.media.opengl
+Style InterfaceOnly
+JavaClass GL2ES1
+Extends GL2ES1 GLBase
+Extends GL2ES1 GL
+Extends GL2ES1 GLMatrixFunc
+Extends GL2ES1 GLPointerFunc
+Extends GL2ES1 GLLightingFunc
+
+ExtendedInterfaceSymbols ../build-temp/gensrc/classes/javax/media/opengl/GL.java
+ExtendedInterfaceSymbols ../src/jogl/classes/javax/media/opengl/GLBase.java
+ExtendedInterfaceSymbols ../src/jogl/classes/javax/media/opengl/fixedfunc/GLMatrixFunc.java
+ExtendedInterfaceSymbols ../src/jogl/classes/javax/media/opengl/fixedfunc/GLPointerFunc.java
+ExtendedInterfaceSymbols ../src/jogl/classes/javax/media/opengl/fixedfunc/GLLightingFunc.java
+
+HierarchicalNativeOutput false
+Include gl-common.cfg
+Include gl-common-extensions.cfg
+
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/jogl
+
+# Ignore all ES 1.X only stuff not in GL2
+IgnoreExtension GL_OES_compressed_ETC1_RGB8_texture
+IgnoreExtension GL_OES_draw_texture
+IgnoreExtension GL_OES_fixed_point
+IgnoreExtension GL_OES_matrix_get
+IgnoreExtension GL_OES_point_size_array
+IgnoreExtension GL_OES_query_matrix
+IgnoreExtension GL_OES_vertex_half_float
+Ignore glGetFixedv
+
+# Ignore OES variants of single precision floating point routines
+IgnoreExtension GL_OES_single_precision
+
+# Ignore fixed point versions of routines in ES 1.x core
+Ignore glAlphaFuncx
+Ignore glClearColorx
+Ignore glClearDepthx
+Ignore glClipPlanex
+Ignore glColor4x
+Ignore glDepthRangex
+Ignore glFogx
+Ignore glFrustumx
+Ignore glGetClipPlanex
+Ignore glLightModelx
+Ignore glLightx
+Ignore glLineWidthx
+Ignore glLoadMatrixx
+Ignore glMaterialx
+Ignore glMultMatrixx
+Ignore glMultiTexCoord4x
+Ignore glNormal3x
+Ignore glOrthox
+Ignore glPointParameterx
+Ignore glPointSizex
+Ignore glPolygonOffsetx
+Ignore glQueryMatrixx
+Ignore glRotatex
+Ignore glSampleCoveragex
+Ignore glScalex
+Ignore glTexEnvx
+Ignore glTexGenx
+Ignore glTexParameterx
+Ignore glTranslatex
+
+#heavy float/double array diff to GL2
+Ignore glClipPlanef
+Ignore ^glGetClipPlanef(OES)?
+
+#impl diff
+Ignore ^glEGL.*
+Ignore ^gl.*(xv)(OES)?
+Ignore glTexGenxOES
+Ignore GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES
+Ignore glLoadPaletteFromModelViewMatrixOES
+Ignore glGetFixedv
+
+CustomJavaCode GL2ES1 public void glOrtho(double left, double right, double bottom, double top, double near_val, double far_val);
+CustomJavaCode GL2ES1 public void glFrustum(double left, double right, double bottom, double top, double zNear, double zFar);
+
+EmitProcAddressTable false
+ProcAddressTableClassName DontGenerateProcAddressTableStuff
+GetProcAddressTableExpr DontGenerateProcAddressTableStuff
+
+# Inform the glue code generator of the association between #defines
+# and functions and the extensions in which they are defined
+GLHeader GLES/gl.h
+GLHeader GLES/glext.h
+GLHeader GL/gl.h
+GLHeader GL/glext.h
+
+# Pick up on-line OpenGL javadoc thanks to user cylab on javagaming.org forums
+TagNativeBinding true
+
diff --git a/make/config/jogl/gl-if-gl2_es2.cfg b/make/config/jogl/gl-if-gl2_es2.cfg
new file mode 100755
index 000000000..5345c3ba1
--- /dev/null
+++ b/make/config/jogl/gl-if-gl2_es2.cfg
@@ -0,0 +1,47 @@
+# This .cfg file is used to generate the GL interface and implementing class.
+Package javax.media.opengl
+Style InterfaceOnly
+JavaClass GL2ES2
+Extends GL2ES2 GLBase
+Extends GL2ES2 GL
+
+ExtendedInterfaceSymbols ../build-temp/gensrc/classes/javax/media/opengl/GL.java
+ExtendedInterfaceSymbols ../src/jogl/classes/javax/media/opengl/GLBase.java
+HierarchicalNativeOutput false
+Include gl-common.cfg
+Include gl-common-extensions.cfg
+
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/jogl
+
+# Ignore all ES 2.X only stuff ..
+# Ignore ^gl.*x(v)?(OES)?
+Ignore glGetShaderPrecisionFormat
+Ignore glEGL.*
+#Ignore glFramebufferVertexAttribArrayNV
+#Ignore glCoverageOperationNV
+#Ignore glCoverageMaskNV
+
+CustomJavaCode GL2ES2 public void glClearDepth( double depth );
+CustomJavaCode GL2ES2 public void glDepthRange(double zNear, double zFar);
+
+EmitProcAddressTable false
+ProcAddressTableClassName DontGenerateProcAddressTableStuff
+GetProcAddressTableExpr DontGenerateProcAddressTableStuff
+
+# Inform the glue code generator of the association between #defines
+# and functions and the extensions in which they are defined
+GLHeader GLES2/gl2.h
+GLHeader GLES2/gl2ext.h
+GLHeader GL/gl.h
+GLHeader GL/glext.h
+
+# Pick up on-line OpenGL javadoc thanks to user cylab on javagaming.org forums
+TagNativeBinding true
+
+CustomJavaCode GL2ES2  public void glVertexAttribPointer(GLArrayData array);
+CustomJavaCode GL2ES2  public void glUniform(GLUniformData data);
+CustomJavaCode GL2ES2
+
+Import java.io.PrintStream
+
diff --git a/make/config/jogl/gl-impl-CustomCCode-gl2.c b/make/config/jogl/gl-impl-CustomCCode-gl2.c
new file mode 100644
index 000000000..f97b8eaff
--- /dev/null
+++ b/make/config/jogl/gl-impl-CustomCCode-gl2.c
@@ -0,0 +1,24 @@
+/*   Java->C glue code:
+ *   Java package: com.sun.opengl.impl.gl2.GL2Impl
+ *    Java method: long dispatch_glMapBuffer(int target, int access)
+ *     C function: void * glMapBuffer(GLenum target, GLenum access);
+ */
+JNIEXPORT jlong JNICALL 
+Java_com_sun_opengl_impl_gl2_GL2Impl_dispatch_1glMapBuffer(JNIEnv *env, jobject _unused, jint target, jint access, jlong glProcAddress) {
+  PFNGLMAPBUFFERPROC ptr_glMapBuffer;
+  void * _res;
+  ptr_glMapBuffer = (PFNGLMAPBUFFERPROC) (intptr_t) glProcAddress;
+  assert(ptr_glMapBuffer != NULL);
+  _res = (* ptr_glMapBuffer) ((GLenum) target, (GLenum) access);
+  return (jlong) (intptr_t) _res;
+}
+
+/*   Java->C glue code:
+ *   Java package: com.sun.opengl.impl.gl2.GL2Impl
+ *    Java method: ByteBuffer newDirectByteBuffer(long addr, int capacity);
+ *     C function: jobject newDirectByteBuffer(jlong addr, jint capacity);
+ */
+JNIEXPORT jobject JNICALL
+Java_com_sun_opengl_impl_gl2_GL2Impl_newDirectByteBuffer(JNIEnv *env, jobject _unused, jlong addr, jint capacity) {
+  return (*env)->NewDirectByteBuffer(env, (void*) (intptr_t) addr, capacity);
+}
diff --git a/make/config/jogl/gl-impl-CustomCCode-gl2es12.c b/make/config/jogl/gl-impl-CustomCCode-gl2es12.c
new file mode 100644
index 000000000..e2d5cb58d
--- /dev/null
+++ b/make/config/jogl/gl-impl-CustomCCode-gl2es12.c
@@ -0,0 +1,24 @@
+/*   Java->C glue code:
+ *   Java package: com.sun.opengl.impl.gl2es12.GL2ES12Impl
+ *    Java method: long dispatch_glMapBuffer(int target, int access)
+ *     C function: void * glMapBuffer(GLenum target, GLenum access);
+ */
+JNIEXPORT jlong JNICALL 
+Java_com_sun_opengl_impl_gl2es12_GL2ES12Impl_dispatch_1glMapBuffer(JNIEnv *env, jobject _unused, jint target, jint access, jlong glProcAddress) {
+  PFNGLMAPBUFFERPROC ptr_glMapBuffer;
+  void * _res;
+  ptr_glMapBuffer = (PFNGLMAPBUFFERPROC) (intptr_t) glProcAddress;
+  assert(ptr_glMapBuffer != NULL);
+  _res = (* ptr_glMapBuffer) ((GLenum) target, (GLenum) access);
+  return (jlong) (intptr_t) _res;
+}
+
+/*   Java->C glue code:
+ *   Java package: com.sun.opengl.impl.gl2es12.GL2ES12Impl
+ *    Java method: ByteBuffer newDirectByteBuffer(long addr, int capacity);
+ *     C function: jobject newDirectByteBuffer(jlong addr, jint capacity);
+ */
+JNIEXPORT jobject JNICALL
+Java_com_sun_opengl_impl_gl2es12_GL2ES12Impl_newDirectByteBuffer(JNIEnv *env, jobject _unused, jlong addr, jint capacity) {
+  return (*env)->NewDirectByteBuffer(env, (void*) (intptr_t) addr, capacity);
+}
diff --git a/make/config/jogl/gl-impl-CustomCCode-gl3.c b/make/config/jogl/gl-impl-CustomCCode-gl3.c
new file mode 100644
index 000000000..a5f78a460
--- /dev/null
+++ b/make/config/jogl/gl-impl-CustomCCode-gl3.c
@@ -0,0 +1,24 @@
+/*   Java->C glue code:
+ *   Java package: com.sun.opengl.impl.gl3.GL3Impl
+ *    Java method: long dispatch_glMapBuffer(int target, int access)
+ *     C function: void * glMapBuffer(GLenum target, GLenum access);
+ */
+JNIEXPORT jlong JNICALL 
+Java_com_sun_opengl_impl_gl3_GL3Impl_dispatch_1glMapBuffer(JNIEnv *env, jobject _unused, jint target, jint access, jlong glProcAddress) {
+  PFNGLMAPBUFFERPROC ptr_glMapBuffer;
+  void * _res;
+  ptr_glMapBuffer = (PFNGLMAPBUFFERPROC) (intptr_t) glProcAddress;
+  assert(ptr_glMapBuffer != NULL);
+  _res = (* ptr_glMapBuffer) ((GLenum) target, (GLenum) access);
+  return (jlong) (intptr_t) _res;
+}
+
+/*   Java->C glue code:
+ *   Java package: com.sun.opengl.impl.gl3.GL3Impl
+ *    Java method: ByteBuffer newDirectByteBuffer(long addr, int capacity);
+ *     C function: jobject newDirectByteBuffer(jlong addr, jint capacity);
+ */
+JNIEXPORT jobject JNICALL
+Java_com_sun_opengl_impl_gl3_GL3Impl_newDirectByteBuffer(JNIEnv *env, jobject _unused, jlong addr, jint capacity) {
+  return (*env)->NewDirectByteBuffer(env, (void*) (intptr_t) addr, capacity);
+}
diff --git a/make/config/jogl/gl-impl-CustomCCode-gles1.c b/make/config/jogl/gl-impl-CustomCCode-gles1.c
new file mode 100644
index 000000000..efc614e64
--- /dev/null
+++ b/make/config/jogl/gl-impl-CustomCCode-gles1.c
@@ -0,0 +1,25 @@
+typedef GLvoid* (GL_APIENTRY* PFNGLMAPBUFFERPROC) (GLenum target, GLenum access);
+/*   Java->C glue code:
+ *   Java package: com.sun.opengl.impl.es1.GLES1Impl
+ *    Java method: long dispatch_glMapBuffer(int target, int access)
+ *     C function: void * glMapBuffer(GLenum target, GLenum access);
+ */
+JNIEXPORT jlong JNICALL 
+Java_com_sun_opengl_impl_es1_GLES1Impl_dispatch_1glMapBuffer(JNIEnv *env, jobject _unused, jint target, jint access, jlong glProcAddress) {
+  PFNGLMAPBUFFERPROC ptr_glMapBuffer;
+  void * _res;
+  ptr_glMapBuffer = (PFNGLMAPBUFFERPROC) (intptr_t) glProcAddress;
+  assert(ptr_glMapBuffer != NULL);
+  _res = (* ptr_glMapBuffer) ((GLenum) target, (GLenum) access);
+  return (jlong) (intptr_t) _res;
+}
+
+/*   Java->C glue code:
+ *   Java package: com.sun.opengl.impl.es1.GLES1Impl
+ *    Java method: ByteBuffer newDirectByteBuffer(long addr, int capacity);
+ *     C function: jobject newDirectByteBuffer(jlong addr, jint capacity);
+ */
+JNIEXPORT jobject JNICALL
+Java_com_sun_opengl_impl_es1_GLES1Impl_newDirectByteBuffer(JNIEnv *env, jobject _unused, jlong addr, jint capacity) {
+  return (*env)->NewDirectByteBuffer(env, (void*) (intptr_t) addr, capacity);
+}
diff --git a/make/config/jogl/gl-impl-CustomCCode-gles2.c b/make/config/jogl/gl-impl-CustomCCode-gles2.c
new file mode 100644
index 000000000..27be04749
--- /dev/null
+++ b/make/config/jogl/gl-impl-CustomCCode-gles2.c
@@ -0,0 +1,25 @@
+typedef GLvoid* (GL_APIENTRY* PFNGLMAPBUFFERPROC) (GLenum target, GLenum access);
+/*   Java->C glue code:
+ *   Java package: com.sun.opengl.impl.es2.GLES2Impl
+ *    Java method: long dispatch_glMapBuffer(int target, int access)
+ *     C function: void * glMapBuffer(GLenum target, GLenum access);
+ */
+JNIEXPORT jlong JNICALL 
+Java_com_sun_opengl_impl_es2_GLES2Impl_dispatch_1glMapBuffer(JNIEnv *env, jobject _unused, jint target, jint access, jlong glProcAddress) {
+  PFNGLMAPBUFFERPROC ptr_glMapBuffer;
+  void * _res;
+  ptr_glMapBuffer = (PFNGLMAPBUFFERPROC) (intptr_t) glProcAddress;
+  assert(ptr_glMapBuffer != NULL);
+  _res = (* ptr_glMapBuffer) ((GLenum) target, (GLenum) access);
+  return (jlong) (intptr_t) _res;
+}
+
+/*   Java->C glue code:
+ *   Java package: com.sun.opengl.impl.es2.GLES2Impl
+ *    Java method: ByteBuffer newDirectByteBuffer(long addr, int capacity);
+ *     C function: jobject newDirectByteBuffer(jlong addr, jint capacity);
+ */
+JNIEXPORT jobject JNICALL
+Java_com_sun_opengl_impl_es2_GLES2Impl_newDirectByteBuffer(JNIEnv *env, jobject _unused, jlong addr, jint capacity) {
+  return (*env)->NewDirectByteBuffer(env, (void*) (intptr_t) addr, capacity);
+}
diff --git a/make/config/jogl/gl-impl-CustomJavaCode-common.java b/make/config/jogl/gl-impl-CustomJavaCode-common.java
new file mode 100644
index 000000000..564606799
--- /dev/null
+++ b/make/config/jogl/gl-impl-CustomJavaCode-common.java
@@ -0,0 +1,16 @@
+  public GLProfile getGLProfile() {
+    return this.glProfile;
+  }
+  private GLProfile glProfile;
+
+  public int glGetBoundBuffer(int target) {
+    return bufferStateTracker.getBoundBufferObject(target, this);
+  }
+
+  public boolean glIsVBOArrayEnabled() {
+    return checkArrayVBOEnabled(false);
+  }
+
+  public boolean glIsVBOElementEnabled() {
+    return checkElementVBOEnabled(false);
+  }
diff --git a/make/config/jogl/gl-impl-CustomJavaCode-desktop.java b/make/config/jogl/gl-impl-CustomJavaCode-desktop.java
new file mode 100644
index 000000000..0d01aaec4
--- /dev/null
+++ b/make/config/jogl/gl-impl-CustomJavaCode-desktop.java
@@ -0,0 +1,74 @@
+private int[] imageSizeTemp = new int[1];
+
+/** Helper for more precise computation of number of bytes that will
+    be touched by a pixel pack or unpack operation. */
+private int imageSizeInBytes(int bytesPerElement,
+                             int w, int h, int d,
+                             int dimensions,
+                             boolean pack) {
+    int rowLength = 0;
+    int skipRows = 0;
+    int skipPixels = 0;
+    int alignment = 1;
+    int imageHeight = 0;
+    int skipImages = 0;
+
+    if (pack) {
+        glGetIntegerv(GL_PACK_ROW_LENGTH, imageSizeTemp, 0);
+        rowLength = imageSizeTemp[0];
+        glGetIntegerv(GL_PACK_SKIP_ROWS, imageSizeTemp, 0);
+        skipRows = imageSizeTemp[0];
+        glGetIntegerv(GL_PACK_SKIP_PIXELS, imageSizeTemp, 0);
+        skipPixels = imageSizeTemp[0];
+        glGetIntegerv(GL_PACK_ALIGNMENT, imageSizeTemp, 0);
+        alignment = imageSizeTemp[0];
+        if (dimensions > 2) {
+            glGetIntegerv(GL_PACK_IMAGE_HEIGHT, imageSizeTemp, 0);
+            imageHeight = imageSizeTemp[0];
+            glGetIntegerv(GL_PACK_SKIP_IMAGES, imageSizeTemp, 0);
+            skipImages = imageSizeTemp[0];
+        }
+    } else {
+        glGetIntegerv(GL_UNPACK_ROW_LENGTH, imageSizeTemp, 0);
+        rowLength = imageSizeTemp[0];
+        glGetIntegerv(GL_UNPACK_SKIP_ROWS, imageSizeTemp, 0);
+        skipRows = imageSizeTemp[0];
+        glGetIntegerv(GL_UNPACK_SKIP_PIXELS, imageSizeTemp, 0);
+        skipPixels = imageSizeTemp[0];
+        glGetIntegerv(GL_UNPACK_ALIGNMENT, imageSizeTemp, 0);
+        alignment = imageSizeTemp[0];
+        if (dimensions > 2) {
+            glGetIntegerv(GL_UNPACK_IMAGE_HEIGHT, imageSizeTemp, 0);
+            imageHeight = imageSizeTemp[0];
+            glGetIntegerv(GL_UNPACK_SKIP_IMAGES, imageSizeTemp, 0);
+            skipImages = imageSizeTemp[0];
+        }
+    }
+    // Try to deal somewhat correctly with potentially invalid values
+    rowLength   = Math.max(0, rowLength);
+    skipRows    = Math.max(0, skipRows);
+    skipPixels  = Math.max(0, skipPixels);
+    alignment   = Math.max(1, alignment);
+    imageHeight = Math.max(0, imageHeight);
+    skipImages  = Math.max(0, skipImages);
+    rowLength   = Math.max(rowLength, w + skipPixels);
+    int rowLengthInBytes = rowLength * bytesPerElement;
+    if (alignment > 1) {
+        int modulus = rowLengthInBytes % alignment;
+        if (modulus > 0) {
+            rowLengthInBytes += alignment - modulus;
+        }
+    }
+
+    int size = 0;
+    if (dimensions == 1) {
+        return (w + skipPixels) * bytesPerElement;
+    } else {
+        int size2D = ((skipRows + h - 1) * rowLengthInBytes) + (w + skipPixels) * bytesPerElement;
+        if (dimensions == 2) {
+            return size2D;
+        }
+        int imageSizeInBytes = imageHeight * rowLength;
+        return ((skipImages + d - 1) * imageSizeInBytes) + size2D;
+    }
+}
diff --git a/make/config/jogl/gl-impl-CustomJavaCode-embedded.java b/make/config/jogl/gl-impl-CustomJavaCode-embedded.java
new file mode 100644
index 000000000..2d4cd1372
--- /dev/null
+++ b/make/config/jogl/gl-impl-CustomJavaCode-embedded.java
@@ -0,0 +1,37 @@
+private int[] imageSizeTemp = new int[1];
+
+/** Helper for more precise computation of number of bytes that will
+    be touched by a pixel pack or unpack operation. */
+private int imageSizeInBytes(int bytesPerElement,
+                             int w, int h, int d,
+                             int dimensions,
+                             boolean pack) {
+    int rowLength = w;
+    int alignment = 1;
+
+    if (pack) {
+        glGetIntegerv(GL_PACK_ALIGNMENT, imageSizeTemp, 0);
+        alignment = imageSizeTemp[0];
+    } else {
+        glGetIntegerv(GL_UNPACK_ALIGNMENT, imageSizeTemp, 0);
+        alignment = imageSizeTemp[0];
+    }
+    // Try to deal somewhat correctly with potentially invalid values
+    rowLength   = Math.max(0, rowLength);
+    alignment   = Math.max(1, alignment);
+    h           = Math.max(0, h);
+    int rowLengthInBytes = rowLength * bytesPerElement;
+    if (alignment > 1) {
+        int modulus = rowLengthInBytes % alignment;
+        if (modulus > 0) {
+            rowLengthInBytes += alignment - modulus;
+        }
+    }
+
+    int size = 0;
+    if (dimensions == 1) {
+        return rowLengthInBytes;
+    } else {
+        return h * rowLengthInBytes;
+    }
+}
diff --git a/make/config/jogl/gl-impl-CustomJavaCode-gl2.java b/make/config/jogl/gl-impl-CustomJavaCode-gl2.java
new file mode 100644
index 000000000..b3410040b
--- /dev/null
+++ b/make/config/jogl/gl-impl-CustomJavaCode-gl2.java
@@ -0,0 +1,474 @@
+// Tracks glBegin/glEnd calls to determine whether it is legal to
+// query Vertex Buffer Object state
+private boolean inBeginEndPair;
+
+/* FIXME: refactor dependence on Java 2D / JOGL bridge
+
+// Tracks creation and destruction of server-side OpenGL objects when
+// the Java2D/OpenGL pipeline is enabled and it is using frame buffer
+// objects (FBOs) to do its rendering
+private GLObjectTracker tracker;
+
+public void setObjectTracker(GLObjectTracker tracker) {
+  this.tracker = tracker;
+}
+
+*/
+
+public GL2Impl(GLProfile glp, GLContextImpl context) {
+  this._context = context; 
+  this.bufferSizeTracker = context.getBufferSizeTracker();
+  this.glProfile = glp;
+}
+
+public final boolean isGL() {
+    return true;
+}
+  
+public final boolean isGL3() {
+    return false;
+}
+
+public final boolean isGL2() {
+    return true;
+}
+  
+public final boolean isGLES1() {
+    return false;
+}
+
+public final boolean isGLES2() {
+    return false;
+}
+
+public final boolean isGLES() {
+    return false;
+}
+
+public final boolean isGL2ES1() {
+    return true;
+}
+
+public final boolean isGL2ES2() {
+    return true;
+}
+
+public final boolean hasGLSL() {
+    return true;
+}
+
+public final GL getGL() throws GLException {
+    return this;
+}
+
+public final GL3 getGL3() throws GLException {
+    throw new GLException("Not a GL3 implementation");
+}
+
+public final GL2 getGL2() throws GLException {
+    return this;
+}
+
+public final GLES1 getGLES1() throws GLException {
+    throw new GLException("Not a GLES1 implementation");
+}
+
+public final GLES2 getGLES2() throws GLException {
+    throw new GLException("Not a GLES2 implementation");
+}
+
+public final GL2ES1 getGL2ES1() throws GLException {
+    return this;
+}
+
+public final GL2ES2 getGL2ES2() throws GLException {
+    return this;
+}
+
+public boolean isFunctionAvailable(String glFunctionName) {
+  return _context.isFunctionAvailable(glFunctionName);
+}
+
+public boolean isExtensionAvailable(String glExtensionName) {
+  return _context.isExtensionAvailable(glExtensionName);
+}
+
+public Object getExtension(String extensionName) {
+  // At this point we don't expose any extensions using this mechanism
+  return null;
+}
+
+/** Returns the context this GL object is associated with for better
+    error checking by DebugGL. */
+public GLContext getContext() {
+  return _context;
+}
+
+private GLContextImpl _context;
+
+/**
+ * Provides platform-independent access to the wglAllocateMemoryNV /
+ * glXAllocateMemoryNV extension.
+ */
+public java.nio.ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3) {
+  return _context.glAllocateMemoryNV(arg0, arg1, arg2, arg3);
+}
+
+public void setSwapInterval(int interval) {
+  _context.setSwapInterval(interval);
+}
+
+public Object getPlatformGLExtensions() {
+  return _context.getPlatformGLExtensions();
+}
+
+//
+// Helpers for ensuring the correct amount of texture data
+//
+
+/** Returns the number of bytes required to fill in the appropriate
+    texture. This is computed as closely as possible based on the
+    pixel pack or unpack parameters. The logic in this routine is
+    based on code in the SGI OpenGL sample implementation. */
+
+private int imageSizeInBytes(int format, int type, int w, int h, int d,
+                             int dimensions, boolean pack) {
+  int elements = 0;
+  int esize = 0;
+  
+  if (w < 0) return 0;
+  if (h < 0) return 0;
+  if (d < 0) return 0;
+  switch (format) {
+  case GL_COLOR_INDEX:
+  case GL_STENCIL_INDEX:
+    elements = 1;
+    break;
+  case GL_RED:
+  case GL_GREEN:
+  case GL_BLUE:
+  case GL_ALPHA:
+  case GL_LUMINANCE:
+  case GL_DEPTH_COMPONENT:
+    elements = 1;
+    break;
+  case GL_LUMINANCE_ALPHA:
+    elements = 2;
+    break;
+  case GL_RGB:
+  case GL_BGR:
+    elements = 3;
+    break;
+  case GL_RGBA:
+  case GL_BGRA:
+  case GL_ABGR_EXT:
+    elements = 4;
+    break;
+  /* FIXME ?? 
+   case GL_HILO_NV:
+    elements = 2;
+    break; */
+  default:
+    return 0;
+  }
+  switch (type) {
+  case GL_BITMAP:
+    if (format == GL_COLOR_INDEX) {
+      return (d * (h * ((w+7)/8)));
+    } else {
+      return 0;
+    }
+  case GL_BYTE:
+  case GL_UNSIGNED_BYTE:
+    esize = 1;
+    break;
+  case GL_UNSIGNED_BYTE_3_3_2:
+  case GL_UNSIGNED_BYTE_2_3_3_REV:
+    esize = 1;
+    elements = 1;
+    break;
+  case GL_SHORT:
+  case GL_UNSIGNED_SHORT:
+    esize = 2;
+    break;
+  case GL_UNSIGNED_SHORT_5_6_5:
+  case GL_UNSIGNED_SHORT_5_6_5_REV:
+  case GL_UNSIGNED_SHORT_4_4_4_4:
+  case GL_UNSIGNED_SHORT_4_4_4_4_REV:
+  case GL_UNSIGNED_SHORT_5_5_5_1:
+  case GL_UNSIGNED_SHORT_1_5_5_5_REV:
+    esize = 2;
+    elements = 1;
+    break;
+  case GL_INT:
+  case GL_UNSIGNED_INT:
+  case GL_FLOAT:
+    esize = 4;
+    break;
+  case GL_UNSIGNED_INT_8_8_8_8:
+  case GL_UNSIGNED_INT_8_8_8_8_REV:
+  case GL_UNSIGNED_INT_10_10_10_2:
+  case GL_UNSIGNED_INT_2_10_10_10_REV:
+    esize = 4;
+    elements = 1;
+    break;
+  default:
+    return 0;
+  }
+  return imageSizeInBytes(elements * esize, w, h, d, dimensions, pack);
+}
+
+private GLBufferStateTracker bufferStateTracker = new GLBufferStateTracker();
+private GLBufferSizeTracker  bufferSizeTracker;
+
+private boolean bufferObjectExtensionsInitialized = false;
+private boolean haveARBPixelBufferObject;
+private boolean haveEXTPixelBufferObject;
+private boolean haveGL15;
+private boolean haveGL21;
+private boolean haveARBVertexBufferObject;
+
+private void initBufferObjectExtensionChecks() {
+  if (bufferObjectExtensionsInitialized)
+    return;
+  bufferObjectExtensionsInitialized = true;
+  haveARBPixelBufferObject  = isExtensionAvailable("GL_ARB_pixel_buffer_object");
+  haveEXTPixelBufferObject  = isExtensionAvailable("GL_EXT_pixel_buffer_object");
+  haveGL15                  = isExtensionAvailable("GL_VERSION_1_5");
+  haveGL21                  = isExtensionAvailable("GL_VERSION_2_1");
+  haveARBVertexBufferObject = isExtensionAvailable("GL_ARB_vertex_buffer_object");
+}
+
+private boolean checkBufferObject(boolean extension1,
+                                  boolean extension2,
+                                  boolean extension3,
+                                  boolean enabled,
+                                  int state,
+                                  String kind, boolean throwException) {
+  if (inBeginEndPair) {
+    throw new GLException("May not call this between glBegin and glEnd");
+  }
+  boolean avail = (extension1 || extension2 || extension3);
+  if (!avail) {
+    if (!enabled)
+      return true;
+    if(throwException) {
+        throw new GLException("Required extensions not available to call this function");
+    }
+    return false;
+  }
+  int buffer = bufferStateTracker.getBoundBufferObject(state, this);
+  if (enabled) {
+    if (buffer == 0) {
+      if(throwException) {
+          throw new GLException(kind + " must be enabled to call this method");
+      }
+      return false;
+    }
+  } else {
+    if (buffer != 0) {
+      if(throwException) {
+          throw new GLException(kind + " must be disabled to call this method");
+      }
+      return false;
+    }
+  }
+  return true;
+}  
+
+private boolean checkArrayVBODisabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(haveGL15,
+                    haveARBVertexBufferObject,
+                    false,
+                    false,
+                    GL.GL_ARRAY_BUFFER,
+                    "array vertex_buffer_object", throwException);
+}
+
+private boolean checkArrayVBOEnabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(haveGL15,
+                    haveARBVertexBufferObject,
+                    false,
+                    true,
+                    GL.GL_ARRAY_BUFFER,
+                    "array vertex_buffer_object", throwException);
+}
+
+private boolean checkElementVBODisabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(haveGL15,
+                    haveARBVertexBufferObject,
+                    false,
+                    false,
+                    GL.GL_ELEMENT_ARRAY_BUFFER,
+                    "element vertex_buffer_object", throwException);
+}
+
+private boolean checkElementVBOEnabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(haveGL15,
+                    haveARBVertexBufferObject,
+                    false,
+                    true,
+                    GL.GL_ELEMENT_ARRAY_BUFFER,
+                    "element vertex_buffer_object", throwException);
+}
+
+private boolean checkUnpackPBODisabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(haveARBPixelBufferObject,
+                    haveEXTPixelBufferObject,
+                    haveGL21,
+                    false,
+                    GL2.GL_PIXEL_UNPACK_BUFFER,
+                    "unpack pixel_buffer_object", throwException);
+}
+
+private boolean checkUnpackPBOEnabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(haveARBPixelBufferObject,
+                    haveEXTPixelBufferObject,
+                    haveGL21,
+                    true,
+                    GL2.GL_PIXEL_UNPACK_BUFFER,
+                    "unpack pixel_buffer_object", throwException);
+}
+
+private boolean checkPackPBODisabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(haveARBPixelBufferObject,
+                    haveEXTPixelBufferObject,
+                    haveGL21,
+                    false,
+                    GL2.GL_PIXEL_PACK_BUFFER,
+                    "pack pixel_buffer_object", throwException);
+}
+
+private boolean checkPackPBOEnabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(haveARBPixelBufferObject,
+                    haveEXTPixelBufferObject,
+                    haveGL21,
+                    true,
+                    GL2.GL_PIXEL_PACK_BUFFER,
+                    "pack pixel_buffer_object", throwException);
+}
+
+public boolean glIsPBOPackEnabled() {
+    return checkPackPBOEnabled(false);
+}
+
+public boolean glIsPBOUnpackEnabled() {
+    return checkUnpackPBOEnabled(false);
+}
+
+// Attempt to return the same ByteBuffer object from glMapBuffer if
+// the vertex buffer object's base address and size haven't changed
+private static class ARBVBOKey {
+  private long addr;
+  private int  capacity;
+
+  ARBVBOKey(long addr, int capacity) {
+    this.addr = addr;
+    this.capacity = capacity;
+  }
+
+  public int hashCode() {
+    return (int) addr;
+  }
+
+  public boolean equals(Object o) {
+    if ((o == null) || (!(o instanceof ARBVBOKey))) {
+      return false;
+    }
+
+    ARBVBOKey other = (ARBVBOKey) o;
+    return ((addr == other.addr) && (capacity == other.capacity));
+  }
+}
+
+private Map/*<ARBVBOKey, ByteBuffer>*/ arbVBOCache = new HashMap();
+
+/** Entry point to C language function: <br> <code> LPVOID glMapBuffer(GLenum target, GLenum access); </code>    */
+public java.nio.ByteBuffer glMapBuffer(int target, int access) {
+  final long __addr_ = ((GL2ProcAddressTable)_context.getGLProcAddressTable())._addressof_glMapBuffer;
+  if (__addr_ == 0) {
+    throw new GLException("Method \"glMapBuffer\" not available");
+  }
+  int sz = bufferSizeTracker.getBufferSize(bufferStateTracker,
+                                           target,
+                                           this);
+  long addr;
+  addr = dispatch_glMapBuffer(target, access, __addr_);
+  if (addr == 0 || sz == 0) {
+    return null;
+  }
+  ARBVBOKey key = new ARBVBOKey(addr, sz);
+  ByteBuffer _res = (ByteBuffer) arbVBOCache.get(key);
+  if (_res == null) {
+    _res = newDirectByteBuffer(addr, sz);
+    InternalBufferUtil.nativeOrder(_res);
+    arbVBOCache.put(key, _res);
+  }
+  _res.position(0);
+  return _res;
+}
+
+/** Encapsulates function pointer for OpenGL function <br>: <code> LPVOID glMapBuffer(GLenum target, GLenum access); </code>    */
+native private long dispatch_glMapBuffer(int target, int access, long glProcAddress);
+
+native private ByteBuffer newDirectByteBuffer(long addr, int capacity);
+
+  /** Dummy implementation for the ES 2.0 function: <br> <code> void {@native glShaderBinary}(GLint n, const GLuint *  shaders, GLenum binaryformat, const void *  binary, GLint length); </code>  <br> Always throws a GLException!  */
+  public void glShaderBinary(int n, java.nio.IntBuffer shaders, int binaryformat, java.nio.Buffer binary, int length) {
+    throw new GLException("Method \"glShaderBinary\" not available");
+  }
+
+  /** Dummy implementation for the ES 2.0 function: <br> <code> void {@native glShaderBinary}(GLint n, const GLuint *  shaders, GLenum binaryformat, const void *  binary, GLint length); </code>  <br> Always throws a GLException!  */
+  public void glShaderBinary(int n, int[] shaders, int shaders_offset, int binaryformat, java.nio.Buffer binary, int length) {
+    throw new GLException("Method \"glShaderBinary\" not available");
+  }
+
+  public void glReleaseShaderCompiler() {
+    // nothing to do 
+  }
+
+    public void glVertexPointer(GLArrayData array) {
+      if(array.getComponentNumber()==0) return;
+      if(array.isVBO()) {
+          glVertexPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getOffset());
+      } else {
+          glVertexPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getBuffer());
+      }
+    }
+    public void glColorPointer(GLArrayData array) {
+      if(array.getComponentNumber()==0) return;
+      if(array.isVBO()) {
+          glColorPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getOffset());
+      } else {
+          glColorPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getBuffer());
+      }
+
+    }
+    public void glNormalPointer(GLArrayData array) {
+      if(array.getComponentNumber()==0) return;
+      if(array.getComponentNumber()!=3) {
+        throw new GLException("Only 3 components per normal allowed");
+      }
+      if(array.isVBO()) {
+          glNormalPointer(array.getComponentType(), array.getStride(), array.getOffset());
+      } else {
+          glNormalPointer(array.getComponentType(), array.getStride(), array.getBuffer());
+      }
+    }
+    public void glTexCoordPointer(GLArrayData array) {
+      if(array.getComponentNumber()==0) return;
+      if(array.isVBO()) {
+          glTexCoordPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getOffset());
+      } else {
+          glTexCoordPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getBuffer());
+      }
+    }
+
diff --git a/make/config/jogl/gl-impl-CustomJavaCode-gl2_es2.java b/make/config/jogl/gl-impl-CustomJavaCode-gl2_es2.java
new file mode 100644
index 000000000..0d0daf463
--- /dev/null
+++ b/make/config/jogl/gl-impl-CustomJavaCode-gl2_es2.java
@@ -0,0 +1,60 @@
+  public void glVertexAttribPointer(GLArrayData array) {
+    if(array.getComponentNumber()==0) return;
+    if(array.isVBO()) {
+        glVertexAttribPointer(array.getLocation(), array.getComponentNumber(), array.getComponentType(), 
+                              array.getNormalized(), array.getStride(), array.getOffset());
+    } else {
+        glVertexAttribPointer(array.getLocation(), array.getComponentNumber(), array.getComponentType(), 
+                              array.getNormalized(), array.getStride(), array.getBuffer());
+    }
+  }
+
+  public void glUniform(GLUniformData data) {
+    boolean done=false;
+    if(data.isBuffer()) {
+        Buffer buffer = data.getBuffer();
+        if(data.isMatrix()) {
+            if(buffer instanceof FloatBuffer) {
+                switch(data.columns()) {
+                    case 2: glUniformMatrix2fv(data.getLocation(), data.count(), false, (FloatBuffer)buffer); done=true; break;
+                    case 3: glUniformMatrix3fv(data.getLocation(), data.count(), false, (FloatBuffer)buffer); done=true; break;
+                    case 4: glUniformMatrix4fv(data.getLocation(), data.count(), false, (FloatBuffer)buffer); done=true; break;
+                }
+            }
+            if(!done) {
+                throw new GLException("glUniformMatrix only available for 2fv, 3fv and 4fv");
+            }
+        } else {
+            if(buffer instanceof IntBuffer) {
+                switch(data.components()) {
+                    case 1: glUniform1iv(data.getLocation(), data.count(), (IntBuffer)buffer); done=true; break;
+                    case 2: glUniform2iv(data.getLocation(), data.count(), (IntBuffer)buffer); done=true; break;
+                    case 3: glUniform3iv(data.getLocation(), data.count(), (IntBuffer)buffer); done=true; break;
+                    case 4: glUniform4iv(data.getLocation(), data.count(), (IntBuffer)buffer); done=true; break;
+                }
+            } else if(buffer instanceof FloatBuffer) {
+                switch(data.components()) {
+                    case 1: glUniform1fv(data.getLocation(), data.count(), (FloatBuffer)buffer); done=true; break;
+                    case 2: glUniform2fv(data.getLocation(), data.count(), (FloatBuffer)buffer); done=true; break;
+                    case 3: glUniform3fv(data.getLocation(), data.count(), (FloatBuffer)buffer); done=true; break;
+                    case 4: glUniform4fv(data.getLocation(), data.count(), (FloatBuffer)buffer); done=true; break;
+                }
+            }
+            if(!done) {
+                throw new GLException("glUniform vector only available for 1[if]v 2[if]v, 3[if]v and 4[if]v");
+            }
+        }
+    } else {
+        Object obj = data.getObject();
+        if(obj instanceof Integer) {
+            glUniform1i(data.getLocation(), ((Integer)obj).intValue());
+            done=true;
+        } else if (obj instanceof Float) {
+            glUniform1f(data.getLocation(), ((Float)obj).floatValue());
+            done=true;
+        }
+        if(!done) {
+            throw new GLException("glUniform atom only available for 1i and 1f");
+        }
+    }
+  }
diff --git a/make/config/jogl/gl-impl-CustomJavaCode-gl2es12.java b/make/config/jogl/gl-impl-CustomJavaCode-gl2es12.java
new file mode 100644
index 000000000..d7b3de789
--- /dev/null
+++ b/make/config/jogl/gl-impl-CustomJavaCode-gl2es12.java
@@ -0,0 +1,424 @@
+// Tracks glBegin/glEnd calls to determine whether it is legal to
+// query Vertex Buffer Object state
+private boolean inBeginEndPair;
+
+/* FIXME: refactor dependence on Java 2D / JOGL bridge
+
+// Tracks creation and destruction of server-side OpenGL objects when
+// the Java2D/OpenGL pipeline is enabled and it is using frame buffer
+// objects (FBOs) to do its rendering
+private GLObjectTracker tracker;
+
+public void setObjectTracker(GLObjectTracker tracker) {
+  this.tracker = tracker;
+}
+
+*/
+
+public GL2ES12Impl(GLProfile glp, GLContextImpl context) {
+  this._context = context; 
+  this.bufferSizeTracker = context.getBufferSizeTracker();
+  this.isGL2ES2 = glp.isGL2ES2();
+  this.glProfile = glp;
+}
+
+private boolean isGL2ES2;
+
+public final boolean isGL() {
+    return true;
+}
+
+public final boolean isGL3() {
+    return false;
+}
+
+public final boolean isGL2() {
+    return false;
+}
+
+public final boolean isGLES1() {
+    return false;
+}
+
+public final boolean isGLES2() {
+    return false;
+}
+
+public final boolean isGLES() {
+    return false;
+}
+
+public final boolean isGL2ES1() {
+    return !isGL2ES2;
+}
+
+public final boolean isGL2ES2() {
+    return isGL2ES2;
+}
+
+public final boolean hasGLSL() {
+    return isGL2ES2;
+}
+
+public final GL getGL() throws GLException {
+    return this;
+}
+
+public final GL3 getGL3() throws GLException {
+    throw new GLException("Not a GL3 implementation");
+}
+
+public final GL2 getGL2() throws GLException {
+    throw new GLException("Not a GL2 implementation");
+}
+
+public final GLES1 getGLES1() throws GLException {
+    throw new GLException("Not a GLES1 implementation");
+}
+
+public final GLES2 getGLES2() throws GLException {
+    throw new GLException("Not a GLES2 implementation");
+}
+
+public final GL2ES1 getGL2ES1() throws GLException {
+    if (isGL2ES1()) {
+        return this;
+    }
+    throw new GLException("Not a GL2ES1 implementation");
+}
+
+public final GL2ES2 getGL2ES2() throws GLException {
+    if (isGL2ES2()) {
+        return this;
+    }
+    throw new GLException("Not a GL2ES2 implementation");
+}
+
+public boolean isFunctionAvailable(String glFunctionName) {
+  return _context.isFunctionAvailable(glFunctionName);
+}
+
+public boolean isExtensionAvailable(String glExtensionName) {
+  return _context.isExtensionAvailable(glExtensionName);
+}
+
+public Object getExtension(String extensionName) {
+  // At this point we don't expose any extensions using this mechanism
+  return null;
+}
+
+/** Returns the context this GL object is associated with for better
+    error checking by DebugGL. */
+public GLContext getContext() {
+  return _context;
+}
+
+private GLContextImpl _context;
+
+/**
+ * Provides platform-independent access to the wglAllocateMemoryNV /
+ * glXAllocateMemoryNV extension.
+ */
+public java.nio.ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3) {
+  return _context.glAllocateMemoryNV(arg0, arg1, arg2, arg3);
+}
+
+public void setSwapInterval(int interval) {
+  _context.setSwapInterval(interval);
+}
+
+public Object getPlatformGLExtensions() {
+  return _context.getPlatformGLExtensions();
+}
+
+//
+// Helpers for ensuring the correct amount of texture data
+//
+
+/** Returns the number of bytes required to fill in the appropriate
+    texture. This is computed as closely as possible based on the
+    pixel pack or unpack parameters. The logic in this routine is
+    based on code in the SGI OpenGL sample implementation. */
+
+private int imageSizeInBytes(int format, int type, int w, int h, int d,
+                             int dimensions, boolean pack) {
+  int elements = 0;
+  int esize = 0;
+  
+  if (w < 0) return 0;
+  if (h < 0) return 0;
+  if (d < 0) return 0;
+  switch (format) {
+  case GL_STENCIL_INDEX:
+    elements = 1;
+    break;
+  case GL_ALPHA:
+  case GL_LUMINANCE:
+  case GL_DEPTH_COMPONENT:
+    elements = 1;
+    break;
+  case GL_LUMINANCE_ALPHA:
+    elements = 2;
+    break;
+  case GL_RGB:
+    elements = 3;
+    break;
+  case GL_RGBA:
+    elements = 4;
+    break;
+  /* FIXME ?? 
+   case GL_HILO_NV:
+    elements = 2;
+    break; */
+  default:
+    return 0;
+  }
+  switch (type) {
+  case GL_BYTE:
+  case GL_UNSIGNED_BYTE:
+    esize = 1;
+    break;
+  case GL_SHORT:
+  case GL_UNSIGNED_SHORT:
+    esize = 2;
+    break;
+  case GL_UNSIGNED_SHORT_5_6_5:
+  case GL_UNSIGNED_SHORT_4_4_4_4:
+  case GL_UNSIGNED_SHORT_5_5_5_1:
+    esize = 2;
+    elements = 1;
+    break;
+  case GL_INT:
+  case GL_UNSIGNED_INT:
+  case GL_FLOAT:
+    esize = 4;
+    break;
+  default:
+    return 0;
+  }
+  return imageSizeInBytes(elements * esize, w, h, d, dimensions, pack);
+}
+
+private GLBufferStateTracker bufferStateTracker = new GLBufferStateTracker();
+private GLBufferSizeTracker  bufferSizeTracker;
+
+private boolean bufferObjectExtensionsInitialized = false;
+private boolean haveGL15;
+private boolean haveGL21;
+private boolean haveARBVertexBufferObject;
+
+private void initBufferObjectExtensionChecks() {
+  if (bufferObjectExtensionsInitialized)
+    return;
+  bufferObjectExtensionsInitialized = true;
+  haveGL15                  = isExtensionAvailable("GL_VERSION_1_5");
+  haveGL21                  = isExtensionAvailable("GL_VERSION_2_1");
+  haveARBVertexBufferObject = isExtensionAvailable("GL_ARB_vertex_buffer_object");
+}
+
+private boolean checkBufferObject(boolean extension1,
+                                  boolean extension2,
+                                  boolean extension3,
+                                  boolean enabled,
+                                  int state,
+                                  String kind, boolean throwException) {
+  if (inBeginEndPair) {
+    throw new GLException("May not call this between glBegin and glEnd");
+  }
+  boolean avail = (extension1 || extension2 || extension3);
+  if (!avail) {
+    if (!enabled)
+      return true;
+    if(throwException) {
+        throw new GLException("Required extensions not available to call this function");
+    }
+    return false;
+  }
+  int buffer = bufferStateTracker.getBoundBufferObject(state, this);
+  if (enabled) {
+    if (buffer == 0) {
+      if(throwException) {
+          throw new GLException(kind + " must be enabled to call this method");
+      }
+      return false;
+    }
+  } else {
+    if (buffer != 0) {
+      if(throwException) {
+          throw new GLException(kind + " must be disabled to call this method");
+      }
+      return false;
+    }
+  }
+  return true;
+}  
+
+private boolean checkArrayVBODisabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(haveGL15,
+                    haveARBVertexBufferObject,
+                    false,
+                    false,
+                    GL.GL_ARRAY_BUFFER,
+                    "array vertex_buffer_object", throwException);
+}
+
+private boolean checkArrayVBOEnabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(haveGL15,
+                    haveARBVertexBufferObject,
+                    false,
+                    true,
+                    GL.GL_ARRAY_BUFFER,
+                    "array vertex_buffer_object", throwException);
+}
+
+private boolean checkElementVBODisabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(haveGL15,
+                    haveARBVertexBufferObject,
+                    false,
+                    false,
+                    GL.GL_ELEMENT_ARRAY_BUFFER,
+                    "element vertex_buffer_object", throwException);
+}
+
+private boolean checkElementVBOEnabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(haveGL15,
+                    haveARBVertexBufferObject,
+                    false,
+                    true,
+                    GL.GL_ELEMENT_ARRAY_BUFFER,
+                    "element vertex_buffer_object", throwException);
+}
+
+private boolean checkUnpackPBODisabled(boolean throwException) { 
+  // PBO n/a for ES 1.1 or ES 2.0
+  return true;
+}
+
+private boolean checkUnpackPBOEnabled(boolean throwException) { 
+  // PBO n/a for ES 1.1 or ES 2.0
+  return false;
+}
+
+private boolean checkPackPBODisabled(boolean throwException) { 
+  // PBO n/a for ES 1.1 or ES 2.0
+  return true;
+}
+
+private boolean checkPackPBOEnabled(boolean throwException) { 
+  // PBO n/a for ES 1.1 or ES 2.0
+  return false;
+}
+
+// Attempt to return the same ByteBuffer object from glMapBuffer if
+// the vertex buffer object's base address and size haven't changed
+private static class ARBVBOKey {
+  private long addr;
+  private int  capacity;
+
+  ARBVBOKey(long addr, int capacity) {
+    this.addr = addr;
+    this.capacity = capacity;
+  }
+
+  public int hashCode() {
+    return (int) addr;
+  }
+
+  public boolean equals(Object o) {
+    if ((o == null) || (!(o instanceof ARBVBOKey))) {
+      return false;
+    }
+
+    ARBVBOKey other = (ARBVBOKey) o;
+    return ((addr == other.addr) && (capacity == other.capacity));
+  }
+}
+
+private Map/*<ARBVBOKey, ByteBuffer>*/ arbVBOCache = new HashMap();
+
+/** Entry point to C language function: <br> <code> LPVOID glMapBuffer(GLenum target, GLenum access); </code>    */
+public java.nio.ByteBuffer glMapBuffer(int target, int access) {
+  final long __addr_ = ((GL2ES12ProcAddressTable)_context.getGLProcAddressTable())._addressof_glMapBuffer;
+  if (__addr_ == 0) {
+    throw new GLException("Method \"glMapBuffer\" not available");
+  }
+  int sz = bufferSizeTracker.getBufferSize(bufferStateTracker,
+                                           target,
+                                           this);
+  long addr;
+  addr = dispatch_glMapBuffer(target, access, __addr_);
+  if (addr == 0 || sz == 0) {
+    return null;
+  }
+  ARBVBOKey key = new ARBVBOKey(addr, sz);
+  ByteBuffer _res = (ByteBuffer) arbVBOCache.get(key);
+  if (_res == null) {
+    _res = newDirectByteBuffer(addr, sz);
+    InternalBufferUtil.nativeOrder(_res);
+    arbVBOCache.put(key, _res);
+  }
+  _res.position(0);
+  return _res;
+}
+
+/** Encapsulates function pointer for OpenGL function <br>: <code> LPVOID glMapBuffer(GLenum target, GLenum access); </code>    */
+native private long dispatch_glMapBuffer(int target, int access, long glProcAddress);
+
+native private ByteBuffer newDirectByteBuffer(long addr, int capacity);
+
+  /** Dummy implementation for the ES 2.0 function: <br> <code> void {@native glShaderBinary}(GLint n, const GLuint *  shaders, GLenum binaryformat, const void *  binary, GLint length); </code>  <br> Always throws a GLException!  */
+  public void glShaderBinary(int n, java.nio.IntBuffer shaders, int binaryformat, java.nio.Buffer binary, int length) {
+    throw new GLException("Method \"glShaderBinary\" not available");
+  }
+
+  /** Dummy implementation for the ES 2.0 function: <br> <code> void {@native glShaderBinary}(GLint n, const GLuint *  shaders, GLenum binaryformat, const void *  binary, GLint length); </code>  <br> Always throws a GLException!  */
+  public void glShaderBinary(int n, int[] shaders, int shaders_offset, int binaryformat, java.nio.Buffer binary, int length) {
+    throw new GLException("Method \"glShaderBinary\" not available");
+  }
+
+  public void glReleaseShaderCompiler() {
+    // nothing to do 
+  }
+
+    public void glVertexPointer(GLArrayData array) {
+      if(array.getComponentNumber()==0) return;
+      if(array.isVBO()) {
+          glVertexPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getOffset());
+      } else {
+          glVertexPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getBuffer());
+      }
+    }
+    public void glColorPointer(GLArrayData array) {
+      if(array.getComponentNumber()==0) return;
+      if(array.isVBO()) {
+          glColorPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getOffset());
+      } else {
+          glColorPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getBuffer());
+      }
+
+    }
+    public void glNormalPointer(GLArrayData array) {
+      if(array.getComponentNumber()==0) return;
+      if(array.getComponentNumber()!=3) {
+        throw new GLException("Only 3 components per normal allowed");
+      }
+      if(array.isVBO()) {
+          glNormalPointer(array.getComponentType(), array.getStride(), array.getOffset());
+      } else {
+          glNormalPointer(array.getComponentType(), array.getStride(), array.getBuffer());
+      }
+    }
+    public void glTexCoordPointer(GLArrayData array) {
+      if(array.getComponentNumber()==0) return;
+      if(array.isVBO()) {
+          glTexCoordPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getOffset());
+      } else {
+          glTexCoordPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getBuffer());
+      }
+    }
+
+
diff --git a/make/config/jogl/gl-impl-CustomJavaCode-gl3.java b/make/config/jogl/gl-impl-CustomJavaCode-gl3.java
new file mode 100644
index 000000000..aa1ef6575
--- /dev/null
+++ b/make/config/jogl/gl-impl-CustomJavaCode-gl3.java
@@ -0,0 +1,429 @@
+// Tracks glBegin/glEnd calls to determine whether it is legal to
+// query Vertex Buffer Object state
+private boolean inBeginEndPair;
+
+/* FIXME: refactor dependence on Java 2D / JOGL bridge
+
+// Tracks creation and destruction of server-side OpenGL objects when
+// the Java2D/OpenGL pipeline is enabled and it is using frame buffer
+// objects (FBOs) to do its rendering
+private GLObjectTracker tracker;
+
+public void setObjectTracker(GLObjectTracker tracker) {
+  this.tracker = tracker;
+}
+
+*/
+
+public GL3Impl(GLProfile glp, GLContextImpl context) {
+  this._context = context; 
+  this.bufferSizeTracker = context.getBufferSizeTracker();
+  this.glProfile = glp;
+}
+
+public final boolean isGL() {
+    return true;
+}
+  
+public final boolean isGL3() {
+    return true;
+}
+
+public final boolean isGL2() {
+    return false;
+}
+  
+public final boolean isGLES1() {
+    return false;
+}
+
+public final boolean isGLES2() {
+    return false;
+}
+
+public final boolean isGLES() {
+    return false;
+}
+
+public final boolean isGL2ES1() {
+    return false;
+}
+
+public final boolean isGL2ES2() {
+    return true;
+}
+
+public final boolean hasGLSL() {
+    return true;
+}
+
+public final GL getGL() throws GLException {
+    return this;
+}
+
+public final GL3 getGL3() throws GLException {
+    return this;
+}
+
+public final GL2 getGL2() throws GLException {
+    throw new GLException("Not a GL2 implementation");
+}
+
+public final GLES1 getGLES1() throws GLException {
+    throw new GLException("Not a GLES1 implementation");
+}
+
+public final GLES2 getGLES2() throws GLException {
+    throw new GLException("Not a GLES2 implementation");
+}
+
+public final GL2ES1 getGL2ES1() throws GLException {
+    throw new GLException("Not a GLES2ES1 implementation");
+}
+
+public final GL2ES2 getGL2ES2() throws GLException {
+    return this;
+}
+
+public boolean isFunctionAvailable(String glFunctionName) {
+  return _context.isFunctionAvailable(glFunctionName);
+}
+
+public boolean isExtensionAvailable(String glExtensionName) {
+  return _context.isExtensionAvailable(glExtensionName);
+}
+
+public Object getExtension(String extensionName) {
+  // At this point we don't expose any extensions using this mechanism
+  return null;
+}
+
+/** Returns the context this GL object is associated with for better
+    error checking by DebugGL. */
+public GLContext getContext() {
+  return _context;
+}
+
+private GLContextImpl _context;
+
+/**
+ * Provides platform-independent access to the wglAllocateMemoryNV /
+ * glXAllocateMemoryNV extension.
+ */
+public java.nio.ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3) {
+  return _context.glAllocateMemoryNV(arg0, arg1, arg2, arg3);
+}
+
+public void setSwapInterval(int interval) {
+  _context.setSwapInterval(interval);
+}
+
+public Object getPlatformGLExtensions() {
+  return _context.getPlatformGLExtensions();
+}
+
+//
+// Helpers for ensuring the correct amount of texture data
+//
+
+/** Returns the number of bytes required to fill in the appropriate
+    texture. This is computed as closely as possible based on the
+    pixel pack or unpack parameters. The logic in this routine is
+    based on code in the SGI OpenGL sample implementation. */
+
+private int imageSizeInBytes(int format, int type, int w, int h, int d,
+                             int dimensions, boolean pack) {
+  int elements = 0;
+  int esize = 0;
+  
+  if (w < 0) return 0;
+  if (h < 0) return 0;
+  if (d < 0) return 0;
+  switch (format) {
+  case GL_STENCIL_INDEX:
+    elements = 1;
+    break;
+  case GL_RED:
+  case GL_GREEN:
+  case GL_BLUE:
+  case GL_ALPHA:
+  case GL_LUMINANCE:
+  case GL_DEPTH_COMPONENT:
+    elements = 1;
+    break;
+  case GL_LUMINANCE_ALPHA:
+    elements = 2;
+    break;
+  case GL_RGB:
+  case GL_BGR:
+    elements = 3;
+    break;
+  case GL_RGBA:
+  case GL_BGRA:
+    elements = 4;
+    break;
+  /* FIXME ?? 
+   case GL_HILO_NV:
+    elements = 2;
+    break; */
+  default:
+    return 0;
+  }
+  switch (type) {
+  case GL_BYTE:
+  case GL_UNSIGNED_BYTE:
+    esize = 1;
+    break;
+  case GL_UNSIGNED_BYTE_3_3_2:
+  case GL_UNSIGNED_BYTE_2_3_3_REV:
+    esize = 1;
+    elements = 1;
+    break;
+  case GL_SHORT:
+  case GL_UNSIGNED_SHORT:
+    esize = 2;
+    break;
+  case GL_UNSIGNED_SHORT_5_6_5:
+  case GL_UNSIGNED_SHORT_5_6_5_REV:
+  case GL_UNSIGNED_SHORT_4_4_4_4:
+  case GL_UNSIGNED_SHORT_4_4_4_4_REV:
+  case GL_UNSIGNED_SHORT_5_5_5_1:
+  case GL_UNSIGNED_SHORT_1_5_5_5_REV:
+    esize = 2;
+    elements = 1;
+    break;
+  case GL_INT:
+  case GL_UNSIGNED_INT:
+  case GL_FLOAT:
+    esize = 4;
+    break;
+  case GL_UNSIGNED_INT_8_8_8_8:
+  case GL_UNSIGNED_INT_8_8_8_8_REV:
+  case GL_UNSIGNED_INT_10_10_10_2:
+  case GL_UNSIGNED_INT_2_10_10_10_REV:
+    esize = 4;
+    elements = 1;
+    break;
+  default:
+    return 0;
+  }
+  return imageSizeInBytes(elements * esize, w, h, d, dimensions, pack);
+}
+
+private GLBufferStateTracker bufferStateTracker = new GLBufferStateTracker();
+private GLBufferSizeTracker  bufferSizeTracker;
+
+private boolean bufferObjectExtensionsInitialized = false;
+private boolean haveARBPixelBufferObject;
+private boolean haveEXTPixelBufferObject;
+private boolean haveGL15;
+private boolean haveGL21;
+private boolean haveARBVertexBufferObject;
+
+private void initBufferObjectExtensionChecks() {
+  if (bufferObjectExtensionsInitialized)
+    return;
+  bufferObjectExtensionsInitialized = true;
+  haveARBPixelBufferObject  = isExtensionAvailable("GL_ARB_pixel_buffer_object");
+  haveEXTPixelBufferObject  = isExtensionAvailable("GL_EXT_pixel_buffer_object");
+  haveGL15                  = isExtensionAvailable("GL_VERSION_1_5");
+  haveGL21                  = isExtensionAvailable("GL_VERSION_2_1");
+  haveARBVertexBufferObject = isExtensionAvailable("GL_ARB_vertex_buffer_object");
+}
+
+private boolean checkBufferObject(boolean extension1,
+                                  boolean extension2,
+                                  boolean extension3,
+                                  boolean enabled,
+                                  int state,
+                                  String kind, boolean throwException) {
+  if (inBeginEndPair) {
+    throw new GLException("May not call this between glBegin and glEnd");
+  }
+  boolean avail = (extension1 || extension2 || extension3);
+  if (!avail) {
+    if (!enabled)
+      return true;
+    if(throwException) {
+        throw new GLException("Required extensions not available to call this function");
+    }
+    return false;
+  }
+  int buffer = bufferStateTracker.getBoundBufferObject(state, this);
+  if (enabled) {
+    if (buffer == 0) {
+      if(throwException) {
+          throw new GLException(kind + " must be enabled to call this method");
+      }
+      return false;
+    }
+  } else {
+    if (buffer != 0) {
+      if(throwException) {
+          throw new GLException(kind + " must be disabled to call this method");
+      }
+      return false;
+    }
+  }
+  return true;
+}  
+
+private boolean checkArrayVBODisabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(haveGL15,
+                    haveARBVertexBufferObject,
+                    false,
+                    false,
+                    GL.GL_ARRAY_BUFFER,
+                    "array vertex_buffer_object", throwException);
+}
+
+private boolean checkArrayVBOEnabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(haveGL15,
+                    haveARBVertexBufferObject,
+                    false,
+                    true,
+                    GL.GL_ARRAY_BUFFER,
+                    "array vertex_buffer_object", throwException);
+}
+
+private boolean checkElementVBODisabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(haveGL15,
+                    haveARBVertexBufferObject,
+                    false,
+                    false,
+                    GL.GL_ELEMENT_ARRAY_BUFFER,
+                    "element vertex_buffer_object", throwException);
+}
+
+private boolean checkElementVBOEnabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(haveGL15,
+                    haveARBVertexBufferObject,
+                    false,
+                    true,
+                    GL.GL_ELEMENT_ARRAY_BUFFER,
+                    "element vertex_buffer_object", throwException);
+}
+
+private boolean checkUnpackPBODisabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(haveARBPixelBufferObject,
+                    haveEXTPixelBufferObject,
+                    haveGL21,
+                    false,
+                    GL2.GL_PIXEL_UNPACK_BUFFER,
+                    "unpack pixel_buffer_object", throwException);
+}
+
+private boolean checkUnpackPBOEnabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(haveARBPixelBufferObject,
+                    haveEXTPixelBufferObject,
+                    haveGL21,
+                    true,
+                    GL2.GL_PIXEL_UNPACK_BUFFER,
+                    "unpack pixel_buffer_object", throwException);
+}
+
+private boolean checkPackPBODisabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(haveARBPixelBufferObject,
+                    haveEXTPixelBufferObject,
+                    haveGL21,
+                    false,
+                    GL2.GL_PIXEL_PACK_BUFFER,
+                    "pack pixel_buffer_object", throwException);
+}
+
+private boolean checkPackPBOEnabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(haveARBPixelBufferObject,
+                    haveEXTPixelBufferObject,
+                    haveGL21,
+                    true,
+                    GL2.GL_PIXEL_PACK_BUFFER,
+                    "pack pixel_buffer_object", throwException);
+}
+
+public boolean glIsPBOPackEnabled() {
+    return checkPackPBOEnabled(false);
+}
+
+public boolean glIsPBOUnpackEnabled() {
+    return checkUnpackPBOEnabled(false);
+}
+
+// Attempt to return the same ByteBuffer object from glMapBuffer if
+// the vertex buffer object's base address and size haven't changed
+private static class ARBVBOKey {
+  private long addr;
+  private int  capacity;
+
+  ARBVBOKey(long addr, int capacity) {
+    this.addr = addr;
+    this.capacity = capacity;
+  }
+
+  public int hashCode() {
+    return (int) addr;
+  }
+
+  public boolean equals(Object o) {
+    if ((o == null) || (!(o instanceof ARBVBOKey))) {
+      return false;
+    }
+
+    ARBVBOKey other = (ARBVBOKey) o;
+    return ((addr == other.addr) && (capacity == other.capacity));
+  }
+}
+
+private Map/*<ARBVBOKey, ByteBuffer>*/ arbVBOCache = new HashMap();
+
+/** Entry point to C language function: <br> <code> LPVOID glMapBuffer(GLenum target, GLenum access); </code>    */
+public java.nio.ByteBuffer glMapBuffer(int target, int access) {
+  final long __addr_ = ((GL3ProcAddressTable)_context.getGLProcAddressTable())._addressof_glMapBuffer;
+  if (__addr_ == 0) {
+    throw new GLException("Method \"glMapBuffer\" not available");
+  }
+  int sz = bufferSizeTracker.getBufferSize(bufferStateTracker,
+                                           target,
+                                           this);
+  long addr;
+  addr = dispatch_glMapBuffer(target, access, __addr_);
+  if (addr == 0 || sz == 0) {
+    return null;
+  }
+  ARBVBOKey key = new ARBVBOKey(addr, sz);
+  ByteBuffer _res = (ByteBuffer) arbVBOCache.get(key);
+  if (_res == null) {
+    _res = newDirectByteBuffer(addr, sz);
+    InternalBufferUtil.nativeOrder(_res);
+    arbVBOCache.put(key, _res);
+  }
+  _res.position(0);
+  return _res;
+}
+
+/** Encapsulates function pointer for OpenGL function <br>: <code> LPVOID glMapBuffer(GLenum target, GLenum access); </code>    */
+native private long dispatch_glMapBuffer(int target, int access, long glProcAddress);
+
+native private ByteBuffer newDirectByteBuffer(long addr, int capacity);
+
+  /** Dummy implementation for the ES 2.0 function: <br> <code> void {@native glShaderBinary}(GLint n, const GLuint *  shaders, GLenum binaryformat, const void *  binary, GLint length); </code>  <br> Always throws a GLException!  */
+  public void glShaderBinary(int n, java.nio.IntBuffer shaders, int binaryformat, java.nio.Buffer binary, int length) {
+    throw new GLException("Method \"glShaderBinary\" not available");
+  }
+
+  /** Dummy implementation for the ES 2.0 function: <br> <code> void {@native glShaderBinary}(GLint n, const GLuint *  shaders, GLenum binaryformat, const void *  binary, GLint length); </code>  <br> Always throws a GLException!  */
+  public void glShaderBinary(int n, int[] shaders, int shaders_offset, int binaryformat, java.nio.Buffer binary, int length) {
+    throw new GLException("Method \"glShaderBinary\" not available");
+  }
+
+  public void glReleaseShaderCompiler() {
+    // nothing to do 
+  }
+
diff --git a/make/config/jogl/gl-impl-CustomJavaCode-gles1.java b/make/config/jogl/gl-impl-CustomJavaCode-gles1.java
new file mode 100755
index 000000000..d349f8018
--- /dev/null
+++ b/make/config/jogl/gl-impl-CustomJavaCode-gles1.java
@@ -0,0 +1,355 @@
+public GLES1Impl(GLProfile glp, GLContextImpl context) {
+  this._context = context; 
+  this.bufferSizeTracker = context.getBufferSizeTracker();
+  this.glProfile = glp;
+}
+
+public final boolean isGL() {
+    return true;
+}
+  
+public final boolean isGL3() {
+    return false;
+}
+
+public final boolean isGL2() {
+    return false;
+}
+
+public final boolean isGLES1() {
+    return true;
+}
+
+public final boolean isGLES2() {
+    return false;
+}
+
+public final boolean isGLES() {
+    return true;
+}
+
+public final boolean isGL2ES1() {
+    return true;
+}
+
+public final boolean isGL2ES2() {
+    return false;
+}
+
+public final boolean hasGLSL() {
+    return false;
+}
+
+public final GL getGL() throws GLException {
+    return this;
+}
+
+public final GL3 getGL3() throws GLException {
+    throw new GLException("Not a GL3 implementation");
+}
+
+public final GL2 getGL2() throws GLException {
+    throw new GLException("Not a GL2 implementation");
+}
+
+public final GLES1 getGLES1() throws GLException {
+    return this;
+}
+
+public final GLES2 getGLES2() throws GLException {
+    throw new GLException("Not a GLES2 implementation");
+}
+
+public final GL2ES1 getGL2ES1() throws GLException {
+    return this;
+}
+
+public final GL2ES2 getGL2ES2() throws GLException {
+    throw new GLException("Not a GL2ES2 implementation");
+}
+
+public boolean isFunctionAvailable(String glFunctionName) {
+  return _context.isFunctionAvailable(glFunctionName);
+}
+
+public boolean isExtensionAvailable(String glExtensionName) {
+  return _context.isExtensionAvailable(glExtensionName);
+}
+
+public Object getExtension(String extensionName) {
+  // At this point we don't expose any extensions using this mechanism
+  return null;
+}
+
+/** Returns the context this GL object is associated with for better
+    error checking by DebugGL. */
+public GLContext getContext() {
+  return _context;
+}
+
+private GLContextImpl _context;
+
+/**
+ * Provides platform-independent access to the wglAllocateMemoryNV /
+ * glXAllocateMemoryNV extension.
+ */
+public java.nio.ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3) {
+  return _context.glAllocateMemoryNV(arg0, arg1, arg2, arg3);
+}
+
+public void setSwapInterval(int interval) {
+  _context.setSwapInterval(interval);
+}
+
+public Object getPlatformGLExtensions() {
+  return _context.getPlatformGLExtensions();
+}
+
+//
+// Helpers for ensuring the correct amount of texture data
+//
+
+/** Returns the number of bytes required to fill in the appropriate
+    texture. This is computed as closely as possible based on the
+    pixel pack or unpack parameters. The logic in this routine is
+    based on code in the SGI OpenGL sample implementation. */
+
+private int imageSizeInBytes(int format, int type, int w, int h, int d,
+                             int dimensions, boolean pack) {
+  int elements = 0;
+  int esize = 0;
+  
+  if (w < 0) return 0;
+  if (h < 0) return 0;
+  if (d < 0) return 0;
+  switch (format) {
+  case GL_ALPHA:
+  case GL_LUMINANCE:
+    elements = 1;
+    break;
+  case GL_LUMINANCE_ALPHA:
+    elements = 2;
+    break;
+  case GL_RGB:
+    elements = 3;
+    break;
+  case GL_RGBA:
+    elements = 4;
+    break;
+  default:
+    return 0;
+  }
+  switch (type) {
+  case GL_BYTE:
+  case GL_UNSIGNED_BYTE:
+    esize = 1;
+    break;
+  case GL_SHORT:
+  case GL_UNSIGNED_SHORT:
+    esize = 2;
+    break;
+  case GL_UNSIGNED_SHORT_5_6_5:
+  case GL_UNSIGNED_SHORT_4_4_4_4:
+  case GL_UNSIGNED_SHORT_5_5_5_1:
+    esize = 2;
+    elements = 1;
+    break;
+  case GL_FLOAT:
+    esize = 4;
+    break;
+  default:
+    return 0;
+  }
+  return imageSizeInBytes(elements * esize, w, h, d, dimensions, pack);
+}
+
+private GLBufferStateTracker bufferStateTracker = new GLBufferStateTracker();
+private GLBufferSizeTracker  bufferSizeTracker;
+
+private boolean bufferObjectExtensionsInitialized = false;
+private boolean haveOESFramebufferObject;
+
+private void initBufferObjectExtensionChecks() {
+  if (bufferObjectExtensionsInitialized)
+    return;
+  bufferObjectExtensionsInitialized = true;
+  haveOESFramebufferObject  = isExtensionAvailable("GL_OES_framebuffer_object");
+}
+
+private boolean checkBufferObject(boolean avail,
+                                  boolean enabled,
+                                  int state,
+                                  String kind, boolean throwException) {
+  if (!avail) {
+    if (!enabled)
+      return true;
+    if(throwException) {
+        throw new GLException("Required extensions not available to call this function");
+    }
+    return false;
+  }
+  int buffer = bufferStateTracker.getBoundBufferObject(state, this);
+  if (enabled) {
+    if (buffer == 0) {
+      if(throwException) {
+          throw new GLException(kind + " must be enabled to call this method");
+      }
+      return false;
+    }
+  } else {
+    if (buffer != 0) {
+      if(throwException) {
+          throw new GLException(kind + " must be disabled to call this method");
+      }
+      return false;
+    }
+  }
+  return true;
+}  
+
+private boolean checkArrayVBODisabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(true,
+                    false,
+                    GL.GL_ARRAY_BUFFER,
+                    "array vertex_buffer_object", throwException);
+}
+
+private boolean checkArrayVBOEnabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(true,
+                    true,
+                    GL.GL_ARRAY_BUFFER,
+                    "array vertex_buffer_object", throwException);
+}
+
+private boolean checkElementVBODisabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(true,
+                    false,
+                    GL.GL_ELEMENT_ARRAY_BUFFER,
+                    "element vertex_buffer_object", throwException);
+}
+
+private boolean checkElementVBOEnabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(true,
+                    true,
+                    GL.GL_ELEMENT_ARRAY_BUFFER,
+                    "element vertex_buffer_object", throwException);
+}
+
+private boolean checkUnpackPBODisabled(boolean throwException) { 
+    // PBO n/a for ES 1.1 or ES 2.0
+    return true;
+}
+
+private boolean checkUnpackPBOEnabled(boolean throwException) { 
+    // PBO n/a for ES 1.1 or ES 2.0
+    return false;
+}
+
+private boolean checkPackPBODisabled(boolean throwException) { 
+    // PBO n/a for ES 1.1 or ES 2.0
+    return true;
+}
+
+private boolean checkPackPBOEnabled(boolean throwException) { 
+    // PBO n/a for ES 1.1 or ES 2.0
+    return false;
+}
+
+// Attempt to return the same ByteBuffer object from glMapBufferARB if
+// the vertex buffer object's base address and size haven't changed
+private static class ARBVBOKey {
+  private long addr;
+  private int  capacity;
+
+  ARBVBOKey(long addr, int capacity) {
+    this.addr = addr;
+    this.capacity = capacity;
+  }
+
+  public int hashCode() {
+    return (int) addr;
+  }
+
+  public boolean equals(Object o) {
+    if ((o == null) || (!(o instanceof ARBVBOKey))) {
+      return false;
+    }
+
+    ARBVBOKey other = (ARBVBOKey) o;
+    return ((addr == other.addr) && (capacity == other.capacity));
+  }
+}
+
+private Map/*<ARBVBOKey, ByteBuffer>*/ arbVBOCache = new HashMap();
+
+/** Entry point to C language function: <br> <code> LPVOID glMapBuffer(GLenum target, GLenum access); </code>    */
+public java.nio.ByteBuffer glMapBuffer(int target, int access) {
+  final long __addr_ = ((GLES1ProcAddressTable)_context.getGLProcAddressTable())._addressof_glMapBufferOES;
+  if (__addr_ == 0) {
+    throw new GLException("Method \"glMapBuffer\" not available");
+  }
+  int sz = bufferSizeTracker.getBufferSize(bufferStateTracker,
+                                           target,
+                                           this);
+  long addr;
+  addr = dispatch_glMapBuffer(target, access, __addr_);
+  if (addr == 0 || sz == 0) {
+    return null;
+  }
+  ARBVBOKey key = new ARBVBOKey(addr, sz);
+  java.nio.ByteBuffer _res = (java.nio.ByteBuffer) arbVBOCache.get(key);
+  if (_res == null) {
+    _res = newDirectByteBuffer(addr, sz);
+    InternalBufferUtil.nativeOrder(_res);
+    arbVBOCache.put(key, _res);
+  }
+  _res.position(0);
+  return _res;
+}
+
+/** Encapsulates function pointer for OpenGL function <br>: <code> LPVOID glMapBuffer(GLenum target, GLenum access); </code>    */
+native private long dispatch_glMapBuffer(int target, int access, long glProcAddress);
+
+native private ByteBuffer newDirectByteBuffer(long addr, int capacity);
+
+public void glVertexPointer(GLArrayData array) {
+  if(array.getComponentNumber()==0) return;
+  if(array.isVBO()) {
+      glVertexPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getOffset());
+  } else {
+      glVertexPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getBuffer());
+  }
+}
+public void glColorPointer(GLArrayData array) {
+  if(array.getComponentNumber()==0) return;
+  if(array.isVBO()) {
+      glColorPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getOffset());
+  } else {
+      glColorPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getBuffer());
+  }
+
+}
+public void glNormalPointer(GLArrayData array) {
+  if(array.getComponentNumber()==0) return;
+  if(array.getComponentNumber()!=3) {
+    throw new GLException("Only 3 components per normal allowed");
+  }
+  if(array.isVBO()) {
+      glNormalPointer(array.getComponentType(), array.getStride(), array.getOffset());
+  } else {
+      glNormalPointer(array.getComponentType(), array.getStride(), array.getBuffer());
+  }
+}
+public void glTexCoordPointer(GLArrayData array) {
+  if(array.getComponentNumber()==0) return;
+  if(array.isVBO()) {
+      glTexCoordPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getOffset());
+  } else {
+      glTexCoordPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getBuffer());
+  }
+}
+
diff --git a/make/config/jogl/gl-impl-CustomJavaCode-gles2.java b/make/config/jogl/gl-impl-CustomJavaCode-gles2.java
new file mode 100755
index 000000000..28edd7a63
--- /dev/null
+++ b/make/config/jogl/gl-impl-CustomJavaCode-gles2.java
@@ -0,0 +1,336 @@
+// Tracks glBegin/glEnd calls to determine whether it is legal to
+// query Vertex Buffer Object state
+private boolean inBeginEndPair;
+
+public GLES2Impl(GLProfile glp, GLContextImpl context) {
+  this._context = context; 
+  this.bufferSizeTracker = context.getBufferSizeTracker();
+  this.glProfile = glp;
+}
+
+public final boolean isGL() {
+    return true;
+}
+  
+public final boolean isGL3() {
+    return false;
+}
+
+public final boolean isGL2() {
+    return false;
+}
+
+public final boolean isGLES1() {
+    return false;
+}
+
+public final boolean isGLES2() {
+    return true;
+}
+
+public final boolean isGLES() {
+    return true;
+}
+
+public final boolean isGL2ES1() {
+    return false;
+}
+
+public final boolean isGL2ES2() {
+    return true;
+}
+
+public final boolean hasGLSL() {
+    return true;
+}
+
+public final GL getGL() throws GLException {
+    return this;
+}
+
+public final GL3 getGL3() throws GLException {
+    throw new GLException("Not a GL3 implementation");
+}
+
+public final GL2 getGL2() throws GLException {
+    throw new GLException("Not a GL2 implementation");
+}
+
+public final GLES1 getGLES1() throws GLException {
+    throw new GLException("Not a GLES1 implementation");
+}
+
+public final GLES2 getGLES2() throws GLException {
+    return this;
+}
+
+public final GL2ES1 getGL2ES1() throws GLException {
+    throw new GLException("Not a GL2ES1 implementation");
+}
+
+public final GL2ES2 getGL2ES2() throws GLException {
+    return this;
+}
+
+public boolean isFunctionAvailable(String glFunctionName) {
+  return _context.isFunctionAvailable(glFunctionName);
+}
+
+public boolean isExtensionAvailable(String glExtensionName) {
+  return _context.isExtensionAvailable(glExtensionName);
+}
+
+public Object getExtension(String extensionName) {
+  // At this point we don't expose any extensions using this mechanism
+  return null;
+}
+
+/** Returns the context this GL object is associated with for better
+    error checking by DebugGL. */
+public GLContext getContext() {
+  return _context;
+}
+
+private GLContextImpl _context;
+
+/**
+ * Provides platform-independent access to the wglAllocateMemoryNV /
+ * glXAllocateMemoryNV extension.
+ */
+public java.nio.ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3) {
+  return _context.glAllocateMemoryNV(arg0, arg1, arg2, arg3);
+}
+
+public void setSwapInterval(int interval) {
+  _context.setSwapInterval(interval);
+}
+
+public Object getPlatformGLExtensions() {
+  return _context.getPlatformGLExtensions();
+}
+
+//
+// Helpers for ensuring the correct amount of texture data
+//
+
+/** Returns the number of bytes required to fill in the appropriate
+    texture. This is computed as closely as possible based on the
+    pixel pack or unpack parameters. The logic in this routine is
+    based on code in the SGI OpenGL sample implementation. */
+
+private int imageSizeInBytes(int format, int type, int w, int h, int d,
+                             int dimensions, boolean pack) {
+  int elements = 0;
+  int esize = 0;
+  
+  if (w < 0) return 0;
+  if (h < 0) return 0;
+  if (d < 0) return 0;
+  switch (format) {
+  case GL_STENCIL_INDEX:
+    elements = 1;
+    break;
+  case GL_ALPHA:
+  case GL_LUMINANCE:
+  case GL_DEPTH_COMPONENT:
+    elements = 1;
+    break;
+  case GL_LUMINANCE_ALPHA:
+    elements = 2;
+    break;
+  case GL_RGB:
+    elements = 3;
+    break;
+  case GL_RGBA:
+    elements = 4;
+    break;
+  default:
+    return 0;
+  }
+  switch (type) {
+  case GL_BYTE:
+  case GL_UNSIGNED_BYTE:
+    esize = 1;
+    break;
+  case GL_SHORT:
+  case GL_UNSIGNED_SHORT:
+    esize = 2;
+    break;
+  case GL_UNSIGNED_SHORT_5_6_5:
+  case GL_UNSIGNED_SHORT_4_4_4_4:
+  case GL_UNSIGNED_SHORT_5_5_5_1:
+    esize = 2;
+    elements = 1;
+    break;
+  case GL_INT:
+  case GL_UNSIGNED_INT:
+  case GL_FLOAT:
+    esize = 4;
+    break;
+  default:
+    return 0;
+  }
+  return imageSizeInBytes(elements * esize, w, h, d, dimensions, pack);
+}
+
+private GLBufferStateTracker bufferStateTracker = new GLBufferStateTracker();
+private GLBufferSizeTracker  bufferSizeTracker;
+
+private boolean bufferObjectExtensionsInitialized = false;
+private boolean haveOESFramebufferObject;
+
+private void initBufferObjectExtensionChecks() {
+  if (bufferObjectExtensionsInitialized)
+    return;
+  bufferObjectExtensionsInitialized = true;
+  haveOESFramebufferObject  = isExtensionAvailable("GL_OES_framebuffer_object");
+}
+
+private boolean checkBufferObject(boolean avail,
+                                  boolean enabled,
+                                  int state,
+                                  String kind, boolean throwException) {
+  if (!avail) {
+    if (!enabled)
+      return true;
+    if(throwException) {
+        throw new GLException("Required extensions not available to call this function");
+    }
+    return false;
+  }
+  int buffer = bufferStateTracker.getBoundBufferObject(state, this);
+  if (enabled) {
+    if (buffer == 0) {
+      if(throwException) {
+          throw new GLException(kind + " must be enabled to call this method");
+      }
+      return false;
+    }
+  } else {
+    if (buffer != 0) {
+      if(throwException) {
+          throw new GLException(kind + " must be disabled to call this method");
+      }
+      return false;
+    }
+  }
+  return true;
+}  
+
+private boolean checkArrayVBODisabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(true,
+                    false,
+                    GL.GL_ARRAY_BUFFER,
+                    "array vertex_buffer_object", throwException);
+}
+
+private boolean checkArrayVBOEnabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(true,
+                    true,
+                    GL.GL_ARRAY_BUFFER,
+                    "array vertex_buffer_object", throwException);
+}
+
+private boolean checkElementVBODisabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(true,
+                    false,
+                    GL.GL_ELEMENT_ARRAY_BUFFER,
+                    "element vertex_buffer_object", throwException);
+}
+
+private boolean checkElementVBOEnabled(boolean throwException) { 
+  initBufferObjectExtensionChecks();
+  return checkBufferObject(true,
+                    true,
+                    GL.GL_ELEMENT_ARRAY_BUFFER,
+                    "element vertex_buffer_object", throwException);
+}
+
+private boolean checkUnpackPBODisabled(boolean throwException) { 
+    // PBO n/a for ES 1.1 or ES 2.0
+    return true;
+}
+
+private boolean checkUnpackPBOEnabled(boolean throwException) { 
+    // PBO n/a for ES 1.1 or ES 2.0
+    return false;
+}
+
+private boolean checkPackPBODisabled(boolean throwException) { 
+    // PBO n/a for ES 1.1 or ES 2.0
+    return true;
+}
+
+private boolean checkPackPBOEnabled(boolean throwException) { 
+    // PBO n/a for ES 1.1 or ES 2.0
+    return false;
+}
+
+// Attempt to return the same ByteBuffer object from glMapBufferARB if
+// the vertex buffer object's base address and size haven't changed
+private static class ARBVBOKey {
+  private long addr;
+  private int  capacity;
+
+  ARBVBOKey(long addr, int capacity) {
+    this.addr = addr;
+    this.capacity = capacity;
+  }
+
+  public int hashCode() {
+    return (int) addr;
+  }
+
+  public boolean equals(Object o) {
+    if ((o == null) || (!(o instanceof ARBVBOKey))) {
+      return false;
+    }
+
+    ARBVBOKey other = (ARBVBOKey) o;
+    return ((addr == other.addr) && (capacity == other.capacity));
+  }
+}
+
+private Map/*<ARBVBOKey, ByteBuffer>*/ arbVBOCache = new HashMap();
+
+/** Entry point to C language function: <br> <code> LPVOID glMapBuffer(GLenum target, GLenum access); </code>    */
+public java.nio.ByteBuffer glMapBuffer(int target, int access) {
+  final long __addr_ = ((GLES2ProcAddressTable)_context.getGLProcAddressTable())._addressof_glMapBufferOES;
+  if (__addr_ == 0) {
+    throw new GLException("Method \"glMapBuffer\" not available");
+  }
+  int sz = bufferSizeTracker.getBufferSize(bufferStateTracker,
+                                           target,
+                                           this);
+  long addr;
+  addr = dispatch_glMapBuffer(target, access, __addr_);
+  if (addr == 0 || sz == 0) {
+    return null;
+  }
+  ARBVBOKey key = new ARBVBOKey(addr, sz);
+  java.nio.ByteBuffer _res = (java.nio.ByteBuffer) arbVBOCache.get(key);
+  if (_res == null) {
+    _res = newDirectByteBuffer(addr, sz);
+    InternalBufferUtil.nativeOrder(_res);
+    arbVBOCache.put(key, _res);
+  }
+  _res.position(0);
+  return _res;
+}
+
+/** Encapsulates function pointer for OpenGL function <br>: <code> LPVOID glMapBuffer(GLenum target, GLenum access); </code>    */
+native private long dispatch_glMapBuffer(int target, int access, long glProcAddress);
+
+native private ByteBuffer newDirectByteBuffer(long addr, int capacity);
+
+public void glClearDepth(double depth) {
+    glClearDepthf((float)depth); 
+}
+
+public void glDepthRange(double zNear, double zFar) {
+    glDepthRangef((float)zNear, (float)zFar); 
+}
+
diff --git a/make/config/jogl/gl-macosx-nsig.cfg b/make/config/jogl/gl-macosx-nsig.cfg
new file mode 100755
index 000000000..6a4bc0a06
--- /dev/null
+++ b/make/config/jogl/gl-macosx-nsig.cfg
@@ -0,0 +1,2 @@
+Include nsig.cfg
+Include gl-macosx.cfg
diff --git a/make/config/jogl/gl-win32-nsig.cfg b/make/config/jogl/gl-win32-nsig.cfg
new file mode 100755
index 000000000..b7c4973d4
--- /dev/null
+++ b/make/config/jogl/gl-win32-nsig.cfg
@@ -0,0 +1,2 @@
+Include nsig.cfg
+Include gl-win32.cfg
diff --git a/make/config/jogl/gl-x11-nsig.cfg b/make/config/jogl/gl-x11-nsig.cfg
new file mode 100755
index 000000000..bb8a76821
--- /dev/null
+++ b/make/config/jogl/gl-x11-nsig.cfg
@@ -0,0 +1,2 @@
+Include nsig.cfg
+Include gl-x11.cfg
diff --git a/make/config/jogl/gl3-desktop-tracker.cfg b/make/config/jogl/gl3-desktop-tracker.cfg
new file mode 100644
index 000000000..4b9a7edb7
--- /dev/null
+++ b/make/config/jogl/gl3-desktop-tracker.cfg
@@ -0,0 +1,38 @@
+
+# Track server-side object creation and deletion when necessary
+# Note that this is only necessary when the Java 2D / JOGL bridge is active,
+# so will never be needed for the embedded OpenGL variants
+JavaEpilogue glGenBuffers               if (tracker != null) tracker.addBuffers({0}, {1});
+JavaEpilogue glGenFencesAPPLE           if (tracker != null) tracker.addFencesAPPLE({0}, {1});
+JavaEpilogue glGenFencesNV              if (tracker != null) tracker.addFencesNV({0}, {1});
+JavaEpilogue glGenFragmentShadersATI    if (tracker != null) tracker.addFragmentShadersATI(_res, {0});
+JavaEpilogue glGenFramebuffersEXT       if (tracker != null) tracker.addFramebuffersEXT({0}, {1});
+JavaEpilogue glGenLists                 if (tracker != null) tracker.addLists(_res, {0});
+JavaEpilogue glGenOcclusionQueriesNV    if (tracker != null) tracker.addOcclusionQueriesNV({0}, {1});
+JavaEpilogue glCreateProgram            if (tracker != null) tracker.addProgramObject(_res);
+JavaEpilogue glGenPrograms              if (tracker != null) tracker.addPrograms({0}, {1});
+JavaEpilogue glGenQueries               if (tracker != null) tracker.addQueries({0}, {1});
+JavaEpilogue glGenRenderbuffersEXT      if (tracker != null) tracker.addRenderbuffersEXT({0}, {1});
+JavaEpilogue glCreateShader             if (tracker != null) tracker.addShaderObject(_res);
+JavaEpilogue glGenTextures              if (tracker != null) tracker.addTextures({0}, {1});
+JavaEpilogue glGenVertexArraysAPPLE     if (tracker != null) tracker.addVertexArraysAPPLE({0}, {1});
+JavaEpilogue glGenVertexShadersEXT      if (tracker != null) tracker.addVertexShadersEXT(_res, {0});
+
+JavaEpilogue glDeleteBuffers            if (tracker != null) tracker.removeBuffers({0}, {1});
+JavaEpilogue glDeleteFencesAPPLE        if (tracker != null) tracker.removeFencesAPPLE({0}, {1});
+JavaEpilogue glDeleteFencesNV           if (tracker != null) tracker.removeFencesNV({0}, {1});
+JavaEpilogue glDeleteFragmentShaderATI  if (tracker != null) tracker.removeFragmentShaderATI({0});
+JavaEpilogue glDeleteFramebuffersEXT    if (tracker != null) tracker.removeFramebuffersEXT({0}, {1});
+JavaEpilogue glDeleteLists              if (tracker != null) tracker.removeLists({0}, {1});
+JavaEpilogue glDeleteOcclusionQueriesNV if (tracker != null) tracker.removeOcclusionQueriesNV({0}, {1});
+JavaEpilogue glDeleteProgram            if (tracker != null) tracker.removeProgramObject({0});
+JavaEpilogue glDeleteObject             if (tracker != null) tracker.removeProgramOrShaderObject({0});
+JavaEpilogue glDeletePrograms           if (tracker != null) tracker.removePrograms({0}, {1});
+JavaEpilogue glDeleteProgramsNV         if (tracker != null) tracker.removeProgramsNV({0}, {1});
+JavaEpilogue glDeleteQueries            if (tracker != null) tracker.removeQueries({0}, {1});
+JavaEpilogue glDeleteRenderbuffersEXT   if (tracker != null) tracker.removeRenderbuffersEXT({0}, {1});
+JavaEpilogue glDeleteShader             if (tracker != null) tracker.removeShaderObject({0});
+JavaEpilogue glDeleteTextures           if (tracker != null) tracker.removeTextures({0}, {1});
+JavaEpilogue glDeleteVertexArraysAPPLE  if (tracker != null) tracker.removeVertexArraysAPPLE({0}, {1});
+JavaEpilogue glDeleteVertexShaderEXT    if (tracker != null) tracker.removeVertexShaderEXT({0});
+
diff --git a/make/config/jogl/gl3-desktop.cfg b/make/config/jogl/gl3-desktop.cfg
new file mode 100755
index 000000000..2d34ade30
--- /dev/null
+++ b/make/config/jogl/gl3-desktop.cfg
@@ -0,0 +1,67 @@
+# This .cfg file provides common options used by the desktop OpenGL
+# implementation on all platforms.
+
+# Inform the glue code generator of the association between #defines
+# and functions and the extensions in which they are defined
+GLHeader GL3/gl3.h
+GLHeader GL3/gl3ext.h
+
+#Include gl-desktop-tracker.cfg
+
+
+#
+# Directives needed when processing wglext.h on Windows and other platforms
+#
+Opaque boolean BOOL
+ReturnsString wglGetExtensionsStringARB
+ReturnsString wglGetExtensionsStringEXT
+Opaque long HANDLE
+Opaque long HBITMAP
+Opaque long HDC
+Opaque long HGDIOBJ
+Opaque long HGLRC
+Opaque long HPBUFFERARB
+Opaque long HPBUFFEREXT
+Opaque boolean BOOL
+Opaque long PROC
+Opaque long void **
+
+#
+# Directives needed when processing cglext.h on MacOSX and other platforms
+#
+Opaque long CGContextRef
+Opaque long void **
+# Implement the first argument to cglGetProcAddress as String instead
+# of byte[]
+ArgumentIsString cglGetProcAddress 0
+
+#
+# Directives needed when processing glxext.h on X11 and other platforms
+#
+Opaque long __GLXextFuncPtr
+Opaque boolean Bool
+Opaque long Display *
+Opaque long GLXContext
+Opaque long Visual *
+# Ignore the empty Display and Visual data structures (though made
+# opaque, the references from XVisualInfo and elsewhere are still
+# traversed)
+Ignore Display
+Ignore Visual
+# Implement the first argument to glXGetProcAddress as String instead
+# of byte[]
+ArgumentIsString glXGetProcAddress 0
+ArgumentIsString glXGetProcAddressARB 0
+ReturnsString glXQueryExtensionsString
+ReturnsString glXQueryServerString
+ReturnsString glXGetClientString
+TemporaryCVariableDeclaration glXChooseFBConfig     int count;
+TemporaryCVariableAssignment  glXChooseFBConfig     count = _ptr3[0];
+ReturnValueCapacity           glXChooseFBConfig     count * sizeof(GLXFBConfig)
+TemporaryCVariableDeclaration glXChooseFBConfigSGIX int count;
+TemporaryCVariableAssignment  glXChooseFBConfigSGIX count = _ptr3[0];
+ReturnValueCapacity           glXChooseFBConfigSGIX count * sizeof(GLXFBConfig)
+TemporaryCVariableDeclaration glXGetFBConfigs       int count;
+TemporaryCVariableAssignment  glXGetFBConfigs       count = _ptr2[0];
+ReturnValueCapacity           glXGetFBConfigs       count * sizeof(GLXFBConfig)
+
diff --git a/make/config/jogl/gl3-headers.cfg b/make/config/jogl/gl3-headers.cfg
new file mode 100755
index 000000000..282a91ec5
--- /dev/null
+++ b/make/config/jogl/gl3-headers.cfg
@@ -0,0 +1,29 @@
+CustomCCode /* Define GL3_PROTOTYPES so that the OpenGL extension prototypes in
+CustomCCode    "gl3.h" are parsed. */
+CustomCCode #define GL3_PROTOTYPES
+CustomCCode #if defined(_WIN32)
+CustomCCode   #define WIN32_LEAN_AND_MEAN
+CustomCCode   #include <windows.h>
+CustomCCode   #undef WIN32_LEAN_AND_MEAN
+CustomCCode   #include <stdlib.h>
+CustomCCode   #include <stddef.h>
+CustomCCode   #include <malloc.h>
+CustomCCode   #include <GL3/gl3.h>
+CustomCCode #elif defined(macosx)
+CustomCCode   #include <inttypes.h>
+CustomCCode   #include <stdlib.h>
+CustomCCode   #include <GL3/gl3.h>
+CustomCCode   #include </usr/include/machine/types.h>
+CustomCCode   /* Provide Windows typedefs */
+CustomCCode   typedef void* LPVOID;
+CustomCCode   typedef unsigned int* PUINT;
+CustomCCode #elif defined(linux) || defined(__sun) || defined(__FreeBSD__) || defined(_HPUX)
+CustomCCode   #include <inttypes.h>
+CustomCCode   #include <stdlib.h>
+CustomCCode   #include <X11/Xlib.h>
+CustomCCode   #include <GL3/gl3.h>
+CustomCCode #endif
+CustomCCode /* Provide GLES #define for locally generated function pointer typedefs */
+CustomCCode #ifndef GL_APIENTRY
+CustomCCode #define GL_APIENTRY GLAPIENTRY
+CustomCCode #endif
diff --git a/make/config/jogl/glu-CustomJavaCode-base.java b/make/config/jogl/glu-CustomJavaCode-base.java
new file mode 100755
index 000000000..6949cfb68
--- /dev/null
+++ b/make/config/jogl/glu-CustomJavaCode-base.java
@@ -0,0 +1,1469 @@
+/**
+ * Returns true if the specified GLU core- or extension-function can be
+ * successfully used through this GLU instance. By "successfully" we mean
+ * that the function is both <i>callable</i> on the machine running the
+ * program and <i>available</i> on the current display.<P>
+ *
+ * A GLU function is <i>callable</i> if it is a GLU core- or extension-function
+ * that is supported by the underlying GLU implementation. The function is
+ * <i>available</i> if the OpenGL implementation on the display meets the
+ * requirements of the GLU function being called (because GLU functions utilize
+ * OpenGL functions). <P>
+ *
+ * Whether or not a GLU function is <i>callable</i> is determined as follows:
+ * <ul>
+ *   <li>If the function is a GLU core function (i.e., not an
+ *   extension), <code>gluGetString(GLU_VERSION)</code> is used to determine the
+ *   version number of the underlying GLU implementation on the host.
+ *   then the function name is cross-referenced with that specification to
+ *   see if it is part of that version's specification.
+ *
+ *   <li> If the function is a GLU extension, the function name is
+ *   cross-referenced with the list returned by
+ *   <code>gluGetString(GLU_EXTENSIONS)</code> to see if the function is one of
+ *   the extensions that is supported by the underlying GLU implementation.
+ * </ul>
+ *
+ * Whether or not a GLU function is <i>available</i> is determined as follows:
+ * <ul>
+ *   <li>If the function is a GLU core function then the function is first
+ *   cross-referenced with the GLU specifications to find the minimum GLU
+ *   version required to <i>call</i> that GLU function. Then the following table
+ *   is consulted to determine the minimum GL version required for that version
+ *   of GLU:
+ *   <ul>
+ *   <li> GLU 1.0 requires OpenGL 1.0
+ *   <li> GLU 1.1 requires OpenGL 1.0
+ *   <li> GLU 1.2 requires OpenGL 1.1
+ *   <li> GLU 1.3 requires OpenGL 1.2
+ *   </ul>
+ *   Finally, <code>glGetString(GL_VERSION)</code> is used to determine the
+ *   highest OpenGL version that both host and display support, and from that it
+ *   is possible to determine if the GL facilities required by the GLU function
+ *   are <i>available</i> on the display.
+ *
+ *   <li> If the function is a GLU extension, the function name is
+ *   cross-referenced with the list returned by
+ *   <code>gluGetString(GLU_EXTENSIONS)</code> to see if the function is one of
+ *   the extensions that is supported by the underlying GLU implementation.
+ * </ul>
+ *
+ * <b>NOTE:</b>The availability of a function may change at runtime in
+ * response to changes in the display environment. For example, when a window
+ * is dragged from one display to another on a multi-display system, or when
+ * the properties of the display device are modified (e.g., changing the color
+ * depth of the display). Any application that is concerned with handling
+ * these situations correctly should confirm availability after a display
+ * change before calling a questionable OpenGL function. To detect a change in
+ * the display device, please see {@link
+ * GLEventListener#displayChanged(GLAutoDrawable,boolean,boolean)}.
+ *
+ * @param gluFunctionName the name of the OpenGL function (e.g., use
+ * "gluNurbsCallbackDataEXT" to check if the <code>
+ * gluNurbsCallbackDataEXT(GLUnurbs, GLvoid)</code> extension is available).
+ */
+public boolean isFunctionAvailable(String gluFunctionName)
+{
+    //  if (useJavaMipmapCode) {
+    // All GLU functions are available in Java port
+    return true;
+    //  }
+  //  return (gluProcAddressTable.getAddressFor(gluFunctionName) != 0);
+}
+
+
+//----------------------------------------------------------------------
+// Utility routines
+//
+
+private static Class gl2Class;
+private static Class gl2es1Class;
+
+/**
+ * Instantiates a GLU implementation object in respect to the given GL profile
+ * of this thread current GL.
+ */
+public static final GLU createGLU() throws GLException {
+    return createGLU(getCurrentGL());
+}
+
+/**
+ * Instantiates a GLU implementation object in respect to the given GL profile
+ * of the given GL.
+ */
+public static final GLU createGLU(GL gl) throws GLException {
+  try {
+      Class c = null;
+      if(gl.isGL2()) {
+        if (gl2Class == null) {
+          gl2Class = Class.forName("javax.media.opengl.glu.gl2.GLUgl2");
+        }
+        c = gl2Class;
+      } else if (gl.isGL2ES1()) {
+        if (gl2es1Class == null) {
+          gl2es1Class = Class.forName("javax.media.opengl.glu.gl2es1.GLUgl2es1");
+        }
+        c = gl2es1Class;
+      }
+      if (c != null) {
+        return (GLU) c.newInstance();
+      }
+  } catch (Exception e) {
+    throw new GLException(e);
+  }
+  // There is no specialized ES 2 GLU at this time
+  /*
+      try {
+          if(GLProfile.GL2ES12.equals(profile) || GLProfile.GL2.equals(profile) || GLProfile.GLES2.equals(profile)) {
+            return (GLU) NWReflection.createInstance("javax.media.opengl.glu.gl2es2.GLUgl2es2");
+          } 
+      } catch (GLException e) { e.printStackTrace(); }
+  */
+  return new GLU();
+}
+
+public GLU()
+{
+  this.project = new ProjectFloat();
+}
+
+public void destroy() {
+  if(null!=this.project) {
+      this.project.destroy();
+      this.project=null;
+  }
+}
+
+public static final GL getCurrentGL() throws GLException {
+  GLContext curContext = GLContext.getCurrent();
+  if (curContext == null) {
+    throw new GLException("No OpenGL context current on this thread");
+  }
+  return curContext.getGL();
+}
+
+public final String gluErrorString(int errorCode) {
+  return Error.gluErrorString(errorCode);
+}
+
+/* extName is an extension name.
+ * extString is a string of extensions separated by blank(s). There may or 
+ * may not be leading or trailing blank(s) in extString.
+ * This works in cases of extensions being prefixes of another like
+ * GL_EXT_texture and GL_EXT_texture3D.
+ * Returns true if extName is found otherwise it returns false.
+ */
+public final boolean gluCheckExtension(java.lang.String extName, java.lang.String extString) {
+  return Registry.gluCheckExtension(extName, extString);
+}
+
+public final String gluGetString(int name) {
+  return Registry.gluGetString(name);
+}
+
+//----------------------------------------------------------------------
+// Tessellation routines
+//
+
+protected static boolean availableGLUtessellatorImpl = false;
+protected static boolean checkedGLUtessellatorImpl = false;
+
+protected static final void validateGLUtessellatorImpl() {
+    if(!checkedGLUtessellatorImpl) {
+        availableGLUtessellatorImpl = NWReflection.isClassAvailable("com.sun.opengl.impl.glu.tessellator.GLUtessellatorImpl");
+        checkedGLUtessellatorImpl = true;
+    }
+    if(!availableGLUtessellatorImpl) {
+      throw new GLException("GLUtessellator not available (GLUtessellatorImpl)");
+    }
+}
+
+/*****************************************************************************
+ * <b>gluNewTess</b> creates and returns a new tessellation object.  This
+ * object must be referred to when calling tesselation methods.  A return
+ * value of null means that there was not enough memeory to allocate the
+ * object.
+ *
+ * Optional, throws GLException if not available in profile
+ *
+ * @return A new tessellation object.
+ *
+ * @see #gluTessBeginPolygon gluTessBeginPolygon
+ * @see #gluDeleteTess       gluDeleteTess
+ * @see #gluTessCallback     gluTessCallback
+ ****************************************************************************/
+public static final GLUtessellator gluNewTess() {
+    validateGLUtessellatorImpl();
+    return GLUtessellatorImpl.gluNewTess();
+}
+
+/*****************************************************************************
+ * <b>gluDeleteTess</b> destroys the indicated tessellation object (which was
+ * created with {@link #gluNewTess gluNewTess}).
+ *
+ * Optional, throws GLException if not available in profile
+ *
+ * @param tessellator
+ *        Specifies the tessellation object to destroy.
+ *
+ * @see #gluBeginPolygon gluBeginPolygon
+ * @see #gluNewTess      gluNewTess
+ * @see #gluTessCallback gluTessCallback
+ ****************************************************************************/
+public static final void gluDeleteTess(GLUtessellator tessellator) {
+    validateGLUtessellatorImpl();
+    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
+    tess.gluDeleteTess();
+}
+
+/*****************************************************************************
+ * <b>gluTessProperty</b> is used to control properites stored in a
+ * tessellation object.  These properties affect the way that the polygons are
+ * interpreted and rendered.  The legal value for <i>which</i> are as
+ * follows:<P>
+ *
+ * Optional, throws GLException if not available in profile
+ *
+ * <b>GLU_TESS_WINDING_RULE</b>
+ * <UL>
+ *   Determines which parts of the polygon are on the "interior".
+ *   <em>value</em> may be set to one of
+ *   <BR><b>GLU_TESS_WINDING_ODD</b>,
+ *   <BR><b>GLU_TESS_WINDING_NONZERO</b>,
+ *   <BR><b>GLU_TESS_WINDING_POSITIVE</b>, or
+ *   <BR><b>GLU_TESS_WINDING_NEGATIVE</b>, or
+ *   <BR><b>GLU_TESS_WINDING_ABS_GEQ_TWO</b>.<P>
+ *
+ *   To understand how the winding rule works, consider that the input
+ *   contours partition the plane into regions.  The winding rule determines
+ *   which of these regions are inside the polygon.<P>
+ *
+ *   For a single contour C, the winding number of a point x is simply the
+ *   signed number of revolutions we make around x as we travel once around C
+ *   (where CCW is positive).  When there are several contours, the individual
+ *   winding numbers are summed.  This procedure associates a signed integer
+ *   value with each point x in the plane.  Note that the winding number is
+ *   the same for all points in a single region.<P>
+ *
+ *   The winding rule classifies a region as "inside" if its winding number
+ *   belongs to the chosen category (odd, nonzero, positive, negative, or
+ *   absolute value of at least two).  The previous GLU tessellator (prior to
+ *   GLU 1.2) used the "odd" rule.  The "nonzero" rule is another common way
+ *   to define the interior.  The other three rules are useful for polygon CSG
+ *   operations.
+ * </UL>
+ * <BR><b>GLU_TESS_BOUNDARY_ONLY</b>
+ * <UL>
+ *   Is a boolean value ("value" should be set to GL_TRUE or GL_FALSE). When
+ *   set to GL_TRUE, a set of closed contours separating the polygon interior
+ *   and exterior are returned instead of a tessellation.  Exterior contours
+ *   are oriented CCW with respect to the normal; interior contours are
+ *   oriented CW. The <b>GLU_TESS_BEGIN</b> and <b>GLU_TESS_BEGIN_DATA</b>
+ *   callbacks use the type GL_LINE_LOOP for each contour.
+ * </UL>
+ * <BR><b>GLU_TESS_TOLERANCE</b>
+ * <UL>
+ *   Specifies a tolerance for merging features to reduce the size of the
+ *   output. For example, two vertices that are very close to each other
+ *   might be replaced by a single vertex.  The tolerance is multiplied by the
+ *   largest coordinate magnitude of any input vertex; this specifies the
+ *   maximum distance that any feature can move as the result of a single
+ *   merge operation.  If a single feature takes part in several merge
+ *   operations, the toal distance moved could be larger.<P>
+ *
+ *   Feature merging is completely optional; the tolerance is only a hint.
+ *   The implementation is free to merge in some cases and not in others, or
+ *   to never merge features at all.  The initial tolerance is 0.<P>
+ *
+ *   The current implementation merges vertices only if they are exactly
+ *   coincident, regardless of the current tolerance.  A vertex is spliced
+ *   into an edge only if the implementation is unable to distinguish which
+ *   side of the edge the vertex lies on.  Two edges are merged only when both
+ *   endpoints are identical.
+ * </UL>
+ *
+ * @param tessellator
+ *        Specifies the tessellation object created with
+ *        {@link #gluNewTess gluNewTess}
+ * @param which
+ *        Specifies the property to be set.  Valid values are
+ *        <b>GLU_TESS_WINDING_RULE</b>, <b>GLU_TESS_BOUNDARDY_ONLY</b>,
+ *        <b>GLU_TESS_TOLERANCE</b>.
+ * @param value
+ *        Specifices the value of the indicated property.
+ *
+ * @see #gluGetTessProperty gluGetTessProperty
+ * @see #gluNewTess         gluNewTess
+ ****************************************************************************/
+public static final void gluTessProperty(GLUtessellator tessellator, int which, double value) {
+    validateGLUtessellatorImpl();
+    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
+    tess.gluTessProperty(which, value);
+}
+
+/*****************************************************************************
+ * <b>gluGetTessProperty</b> retrieves properties stored in a tessellation
+ * object.  These properties affect the way that tessellation objects are
+ * interpreted and rendered.  See the
+ * {@link #gluTessProperty gluTessProperty} reference
+ * page for information about the properties and what they do.
+ *
+ * Optional, throws GLException if not available in profile
+ *
+ * @param tessellator
+ *        Specifies the tessellation object (created with
+ *        {@link #gluNewTess gluNewTess}).
+ * @param which
+ *        Specifies the property whose value is to be fetched. Valid values
+ *        are <b>GLU_TESS_WINDING_RULE</b>, <b>GLU_TESS_BOUNDARY_ONLY</b>,
+ *        and <b>GLU_TESS_TOLERANCES</b>.
+ * @param value
+ *        Specifices an array into which the value of the named property is
+ *        written.
+ *
+ * @see #gluNewTess      gluNewTess
+ * @see #gluTessProperty gluTessProperty
+ ****************************************************************************/
+public static final void gluGetTessProperty(GLUtessellator tessellator, int which, double[] value, int value_offset) {
+    validateGLUtessellatorImpl();
+    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
+    tess.gluGetTessProperty(which, value, value_offset);
+}
+
+/*****************************************************************************
+ * <b>gluTessNormal</b> describes a normal for a polygon that the program is
+ * defining. All input data will be projected onto a plane perpendicular to
+ * the one of the three coordinate axes before tessellation and all output
+ * triangles will be oriented CCW with repsect to the normal (CW orientation
+ * can be obtained by reversing the sign of the supplied normal).  For
+ * example, if you know that all polygons lie in the x-y plane, call
+ * <b>gluTessNormal</b>(tess, 0.0, 0.0, 0.0) before rendering any polygons.<P>
+ *
+ * If the supplied normal is (0.0, 0.0, 0.0)(the initial value), the normal
+ * is determined as follows.  The direction of the normal, up to its sign, is
+ * found by fitting a plane to the vertices, without regard to how the
+ * vertices are connected.  It is expected that the input data lies
+ * approximately in the plane; otherwise, projection perpendicular to one of
+ * the three coordinate axes may substantially change the geometry.  The sign
+ * of the normal is chosen so that the sum of the signed areas of all input
+ * contours is nonnegative (where a CCW contour has positive area).<P>
+ *
+ * The supplied normal persists until it is changed by another call to
+ * <b>gluTessNormal</b>.
+ *
+ * Optional, throws GLException if not available in profile
+ *
+ * @param tessellator
+ *        Specifies the tessellation object (created by
+ *        {@link #gluNewTess gluNewTess}).
+ * @param x
+ *        Specifies the first component of the normal.
+ * @param y
+ *        Specifies the second component of the normal.
+ * @param z
+ *        Specifies the third component of the normal.
+ *
+ * @see #gluTessBeginPolygon gluTessBeginPolygon
+ * @see #gluTessEndPolygon   gluTessEndPolygon
+ ****************************************************************************/
+public static final void gluTessNormal(GLUtessellator tessellator, double x, double y, double z) {
+    validateGLUtessellatorImpl();
+    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
+    tess.gluTessNormal(x, y, z);
+}
+
+/*****************************************************************************
+ * <b>gluTessCallback</b> is used to indicate a callback to be used by a
+ * tessellation object. If the specified callback is already defined, then it
+ * is replaced. If <i>aCallback</i> is null, then the existing callback
+ * becomes undefined.<P>
+ *
+ * Optional, throws GLException if not available in profile
+ *
+ * These callbacks are used by the tessellation object to describe how a
+ * polygon specified by the user is broken into triangles. Note that there are
+ * two versions of each callback: one with user-specified polygon data and one
+ * without. If both versions of a particular callback are specified, then the
+ * callback with user-specified polygon data will be used. Note that the
+ * polygonData parameter used by some of the methods is a copy of the
+ * reference that was specified when
+ * {@link #gluTessBeginPolygon gluTessBeginPolygon}
+ * was called. The legal callbacks are as follows:<P>
+ *
+ * <b>GLU_TESS_BEGIN</b>
+ * <UL>
+ *   The begin callback is invoked like {@link javax.media.opengl.GL#glBegin
+ *   glBegin} to indicate the start of a (triangle) primitive. The method
+ *   takes a single argument of type int. If the
+ *   <b>GLU_TESS_BOUNDARY_ONLY</b> property is set to <b>GL_FALSE</b>, then
+ *   the argument is set to either <b>GL_TRIANGLE_FAN</b>,
+ *   <b>GL_TRIANGLE_STRIP</b>, or <b>GL_TRIANGLES</b>. If the
+ *   <b>GLU_TESS_BOUNDARY_ONLY</b> property is set to <b>GL_TRUE</b>, then the
+ *   argument will be set to <b>GL_LINE_LOOP</b>. The method prototype for
+ *   this callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void begin(int type);</PRE><P>
+ *
+ * <b>GLU_TESS_BEGIN_DATA</b>
+ * <UL>
+ *   The same as the <b>GLU_TESS_BEGIN</b> callback except
+ *   that it takes an additional reference argument. This reference is
+ *   identical to the opaque reference provided when
+ *   {@link #gluTessBeginPolygon gluTessBeginPolygon}
+ *   was called. The method prototype for this callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void beginData(int type, Object polygonData);</PRE>
+ *
+ * <b>GLU_TESS_EDGE_FLAG</b>
+ * <UL>
+ *   The edge flag callback is similar to
+ *   {@link javax.media.opengl.GL#glEdgeFlag glEdgeFlag}. The method takes
+ *   a single boolean boundaryEdge that indicates which edges lie on the
+ *   polygon boundary. If the boundaryEdge is <b>GL_TRUE</b>, then each vertex
+ *   that follows begins an edge that lies on the polygon boundary, that is,
+ *   an edge that separates an interior region from an exterior one. If the
+ *   boundaryEdge is <b>GL_FALSE</b>, then each vertex that follows begins an
+ *   edge that lies in the polygon interior. The edge flag callback (if
+ *   defined) is invoked before the first vertex callback.<P>
+ *
+ *   Since triangle fans and triangle strips do not support edge flags, the
+ *   begin callback is not called with <b>GL_TRIANGLE_FAN</b> or
+ *   <b>GL_TRIANGLE_STRIP</b> if a non-null edge flag callback is provided.
+ *   (If the callback is initialized to null, there is no impact on
+ *   performance). Instead, the fans and strips are converted to independent
+ *   triangles. The method prototype for this callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void edgeFlag(boolean boundaryEdge);</PRE>
+ *
+ * <b>GLU_TESS_EDGE_FLAG_DATA</b>
+ * <UL>
+ *   The same as the <b>GLU_TESS_EDGE_FLAG</b> callback except that it takes
+ *   an additional reference argument. This reference is identical to the
+ *   opaque reference provided when
+ *   {@link #gluTessBeginPolygon gluTessBeginPolygon}
+ *   was called. The method prototype for this callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void edgeFlagData(boolean boundaryEdge, Object polygonData);</PRE>
+ *
+ * <b>GLU_TESS_VERTEX</b>
+ * <UL>
+ *   The vertex callback is invoked between the begin and end callbacks. It is
+ *   similar to {@link javax.media.opengl.GL#glVertex3f glVertex3f}, and it
+ *   defines the vertices of the triangles created by the tessellation
+ *   process. The method takes a reference as its only argument. This
+ *   reference is identical to the opaque reference provided by the user when
+ *   the vertex was described (see
+ *   {@link #gluTessVertex gluTessVertex}). The method
+ *   prototype for this callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void vertex(Object vertexData);</PRE>
+ *
+ * <b>GLU_TESS_VERTEX_DATA</b>
+ * <UL>
+ *   The same as the <b>GLU_TESS_VERTEX</b> callback except that it takes an
+ *   additional reference argument. This reference is identical to the opaque
+ *   reference provided when
+ *   {@link #gluTessBeginPolygon gluTessBeginPolygon}
+ *   was called. The method prototype for this callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void vertexData(Object vertexData, Object polygonData);</PRE>
+ *
+ * <b>GLU_TESS_END</b>
+ * <UL>
+ *   The end callback serves the same purpose as
+ *   {@link javax.media.opengl.GL#glEnd glEnd}. It indicates the end of a
+ *   primitive and it takes no arguments. The method prototype for this
+ *   callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void end();</PRE>
+ *
+ * <b>GLU_TESS_END_DATA</b>
+ * <UL>
+ *   The same as the <b>GLU_TESS_END</b> callback except that it takes an
+ *   additional reference argument. This reference is identical to the opaque
+ *   reference provided when
+ *   {@link #gluTessBeginPolygon gluTessBeginPolygon}
+ *   was called. The method prototype for this callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void endData(Object polygonData);</PRE>
+ *
+ * <b>GLU_TESS_COMBINE</b>
+ * <UL>
+ *   The combine callback is called to create a new vertex when the
+ *   tessellation detects an intersection, or wishes to merge features. The
+ *   method takes four arguments: an array of three elements each of type
+ *   double, an array of four references, an array of four elements each of
+ *   type float, and a reference to a reference. The prototype is:
+ * </UL>
+ *
+ * <PRE>
+ *         void combine(double[] coords, Object[] data,
+ *                      float[] weight, Object[] outData);</PRE>
+ *
+ * <UL>
+ *   The vertex is defined as a linear combination of up to four existing
+ *   vertices, stored in <i>data</i>. The coefficients of the linear
+ *   combination are given by <i>weight</i>; these weights always add up to 1.
+ *   All vertex pointers are valid even when some of the weights are 0.
+ *   <i>coords</i> gives the location of the new vertex.<P>
+ *
+ *   The user must allocate another vertex, interpolate parameters using
+ *   <i>data</i> and <i>weight</i>, and return the new vertex pointer
+ *   in <i>outData</i>. This handle is supplied during rendering callbacks.
+ *   The user is responsible for freeing the memory some time after
+ *   {@link #gluTessEndPolygon gluTessEndPolygon} is
+ *   called.<P>
+ *
+ *   For example, if the polygon lies in an arbitrary plane in 3-space, and a
+ *   color is associated with each vertex, the <b>GLU_TESS_COMBINE</b>
+ *   callback might look like this:
+ * </UL>
+ * <PRE>
+ *         void myCombine(double[] coords, Object[] data,
+ *                        float[] weight, Object[] outData)
+ *         {
+ *            MyVertex newVertex = new MyVertex();
+ *
+ *            newVertex.x = coords[0];
+ *            newVertex.y = coords[1];
+ *            newVertex.z = coords[2];
+ *            newVertex.r = weight[0]*data[0].r +
+ *                          weight[1]*data[1].r +
+ *                          weight[2]*data[2].r +
+ *                          weight[3]*data[3].r;
+ *            newVertex.g = weight[0]*data[0].g +
+ *                          weight[1]*data[1].g +
+ *                          weight[2]*data[2].g +
+ *                          weight[3]*data[3].g;
+ *            newVertex.b = weight[0]*data[0].b +
+ *                          weight[1]*data[1].b +
+ *                          weight[2]*data[2].b +
+ *                          weight[3]*data[3].b;
+ *            newVertex.a = weight[0]*data[0].a +
+ *                          weight[1]*data[1].a +
+ *                          weight[2]*data[2].a +
+ *                          weight[3]*data[3].a;
+ *            outData = newVertex;
+ *         }</PRE>
+ *
+ * <UL>
+ *   If the tessellation detects an intersection, then the
+ *   <b>GLU_TESS_COMBINE</b> or <b>GLU_TESS_COMBINE_DATA</b> callback (see
+ *   below) must be defined, and it must write a non-null reference into
+ *   <i>outData</i>. Otherwise the <b>GLU_TESS_NEED_COMBINE_CALLBACK</b> error
+ *   occurs, and no output is generated.
+ * </UL>
+ *
+ * <b>GLU_TESS_COMBINE_DATA</b>
+ * <UL>
+ *   The same as the <b>GLU_TESS_COMBINE</b> callback except that it takes an
+ *   additional reference argument. This reference is identical to the opaque
+ *   reference provided when
+ *   {@link #gluTessBeginPolygon gluTessBeginPolygon}
+ *   was called. The method prototype for this callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void combineData(double[] coords, Object[] data,
+                            float[] weight, Object[] outData,
+                            Object polygonData);</PRE>
+ *
+ * <b>GLU_TESS_ERROR</b>
+ * <UL>
+ *   The error callback is called when an error is encountered. The one
+ *   argument is of type int; it indicates the specific error that occurred
+ *   and will be set to one of <b>GLU_TESS_MISSING_BEGIN_POLYGON</b>,
+ *   <b>GLU_TESS_MISSING_END_POLYGON</b>,
+ *   <b>GLU_TESS_MISSING_BEGIN_CONTOUR</b>,
+ *   <b>GLU_TESS_MISSING_END_CONTOUR</b>, <b>GLU_TESS_COORD_TOO_LARGE</b>,
+ *   <b>GLU_TESS_NEED_COMBINE_CALLBACK</b> or <b>GLU_OUT_OF_MEMORY</b>.
+ *   Character strings describing these errors can be retrieved with the
+ *   {@link #gluErrorString gluErrorString} call. The
+ *   method prototype for this callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void error(int errnum);</PRE>
+ *
+ * <UL>
+ *   The GLU library will recover from the first four errors by inserting the
+ *   missing call(s). <b>GLU_TESS_COORD_TOO_LARGE</b> indicates that some
+ *   vertex coordinate exceeded the predefined constant
+ *   <b>GLU_TESS_MAX_COORD</b> in absolute value, and that the value has been
+ *   clamped. (Coordinate values must be small enough so that two can be
+ *   multiplied together without overflow.)
+ *   <b>GLU_TESS_NEED_COMBINE_CALLBACK</b> indicates that the tessellation
+ *   detected an intersection between two edges in the input data, and the
+ *   <b>GLU_TESS_COMBINE</b> or <b>GLU_TESS_COMBINE_DATA</b> callback was not
+ *   provided. No output is generated. <b>GLU_OUT_OF_MEMORY</b> indicates that
+ *   there is not enough memory so no output is generated.
+ * </UL>
+ *
+ * <b>GLU_TESS_ERROR_DATA</b>
+ * <UL>
+ *   The same as the GLU_TESS_ERROR callback except that it takes an
+ *   additional reference argument. This reference is identical to the opaque
+ *   reference provided when
+ *   {@link #gluTessBeginPolygon gluTessBeginPolygon}
+ *   was called. The method prototype for this callback is:
+ * </UL>
+ *
+ * <PRE>
+ *         void errorData(int errnum, Object polygonData);</PRE>
+ *
+ * @param tessellator
+ *        Specifies the tessellation object (created with
+ *        {@link #gluNewTess gluNewTess}).
+ * @param which
+ *        Specifies the callback being defined. The following values are
+ *        valid: <b>GLU_TESS_BEGIN</b>, <b>GLU_TESS_BEGIN_DATA</b>,
+ *        <b>GLU_TESS_EDGE_FLAG</b>, <b>GLU_TESS_EDGE_FLAG_DATA</b>,
+ *        <b>GLU_TESS_VERTEX</b>, <b>GLU_TESS_VERTEX_DATA</b>,
+ *        <b>GLU_TESS_END</b>, <b>GLU_TESS_END_DATA</b>,
+ *        <b>GLU_TESS_COMBINE</b>,  <b>GLU_TESS_COMBINE_DATA</b>,
+ *        <b>GLU_TESS_ERROR</b>, and <b>GLU_TESS_ERROR_DATA</b>.
+ * @param aCallback
+ *        Specifies the callback object to be called.
+ *
+ * @see javax.media.opengl.GL#glBegin              glBegin
+ * @see javax.media.opengl.GL#glEdgeFlag           glEdgeFlag
+ * @see javax.media.opengl.GL#glVertex3f           glVertex3f
+ * @see #gluNewTess          gluNewTess
+ * @see #gluErrorString      gluErrorString
+ * @see #gluTessVertex       gluTessVertex
+ * @see #gluTessBeginPolygon gluTessBeginPolygon
+ * @see #gluTessBeginContour gluTessBeginContour
+ * @see #gluTessProperty     gluTessProperty
+ * @see #gluTessNormal       gluTessNormal
+ ****************************************************************************/
+public static final void gluTessCallback(GLUtessellator tessellator, int which, GLUtessellatorCallback aCallback) {
+    validateGLUtessellatorImpl();
+    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
+    tess.gluTessCallback(which, aCallback);
+}
+
+/*****************************************************************************
+ * <b>gluTessVertex</b> describes a vertex on a polygon that the program
+ * defines. Successive <b>gluTessVertex</b> calls describe a closed contour.
+ * For example, to describe a quadrilateral <b>gluTessVertex</b> should be
+ * called four times. <b>gluTessVertex</b> can only be called between
+ * {@link #gluTessBeginContour gluTessBeginContour} and
+ * {@link #gluTessBeginContour gluTessEndContour}.<P>
+ *
+ * Optional, throws GLException if not available in profile
+ *
+ * <b>data</b> normally references to a structure containing the vertex
+ * location, as well as other per-vertex attributes such as color and normal.
+ * This reference is passed back to the user through the
+ * <b>GLU_TESS_VERTEX</b> or <b>GLU_TESS_VERTEX_DATA</b> callback after
+ * tessellation (see the {@link #gluTessCallback
+ * gluTessCallback} reference page).
+ *
+ * @param tessellator
+ *        Specifies the tessellation object (created with
+ *        {@link #gluNewTess gluNewTess}).
+ * @param coords
+ *        Specifies the coordinates of the vertex.
+ * @param data
+ *        Specifies an opaque reference passed back to the program with the
+ *        vertex callback (as specified by
+ *        {@link #gluTessCallback gluTessCallback}).
+ *
+ * @see #gluTessBeginPolygon gluTessBeginPolygon
+ * @see #gluNewTess          gluNewTess
+ * @see #gluTessBeginContour gluTessBeginContour
+ * @see #gluTessCallback     gluTessCallback
+ * @see #gluTessProperty     gluTessProperty
+ * @see #gluTessNormal       gluTessNormal
+ * @see #gluTessEndPolygon   gluTessEndPolygon
+ ****************************************************************************/
+public static final void gluTessVertex(GLUtessellator tessellator, double[] coords, int coords_offset, Object data) {
+    validateGLUtessellatorImpl();
+    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
+    tess.gluTessVertex(coords, coords_offset, data);
+}
+
+/*****************************************************************************
+ * <b>gluTessBeginPolygon</b> and
+ * {@link #gluTessEndPolygon gluTessEndPolygon} delimit
+ * the definition of a convex, concave or self-intersecting polygon. Within
+ * each <b>gluTessBeginPolygon</b>/
+ * {@link #gluTessEndPolygon gluTessEndPolygon} pair,
+ * there must be one or more calls to
+ * {@link #gluTessBeginContour gluTessBeginContour}/
+ * {@link #gluTessEndContour gluTessEndContour}. Within
+ * each contour, there are zero or more calls to
+ * {@link #gluTessVertex gluTessVertex}. The vertices
+ * specify a closed contour (the last vertex of each contour is automatically
+ * linked to the first). See the {@link #gluTessVertex
+ * gluTessVertex}, {@link #gluTessBeginContour
+ * gluTessBeginContour}, and {@link #gluTessEndContour
+ * gluTessEndContour} reference pages for more details.<P>
+ *
+ * Optional, throws GLException if not available in profile
+ *
+ * <b>data</b> is a reference to a user-defined data structure. If the
+ * appropriate callback(s) are specified (see
+ * {@link #gluTessCallback gluTessCallback}), then this
+ * reference is returned to the callback method(s). Thus, it is a convenient
+ * way to store per-polygon information.<P>
+ *
+ * Once {@link #gluTessEndPolygon gluTessEndPolygon} is
+ * called, the polygon is tessellated, and the resulting triangles are
+ * described through callbacks. See
+ * {@link #gluTessCallback gluTessCallback} for
+ * descriptions of the callback methods.
+ *
+ * @param tessellator
+ *        Specifies the tessellation object (created with
+ *        {@link #gluNewTess gluNewTess}).
+ * @param data
+ *        Specifies a reference to user polygon data.
+ *
+ * @see #gluNewTess          gluNewTess
+ * @see #gluTessBeginContour gluTessBeginContour
+ * @see #gluTessVertex       gluTessVertex
+ * @see #gluTessCallback     gluTessCallback
+ * @see #gluTessProperty     gluTessProperty
+ * @see #gluTessNormal       gluTessNormal
+ * @see #gluTessEndPolygon   gluTessEndPolygon
+ ****************************************************************************/
+public static final void gluTessBeginPolygon(GLUtessellator tessellator, Object data) {
+    validateGLUtessellatorImpl();
+    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
+    tess.gluTessBeginPolygon(data);
+}
+
+/*****************************************************************************
+ * <b>gluTessBeginContour</b> and
+ * {@link #gluTessEndContour gluTessEndContour} delimit
+ * the definition of a polygon contour. Within each
+ * <b>gluTessBeginContour</b>/
+ * {@link #gluTessEndContour gluTessEndContour} pair,
+ * there can be zero or more calls to
+ * {@link #gluTessVertex gluTessVertex}. The vertices
+ * specify a closed contour (the last vertex of each contour is automatically
+ * linked to the first). See the {@link #gluTessVertex
+ * gluTessVertex} reference page for more details. <b>gluTessBeginContour</b>
+ * can only be called between
+ * {@link #gluTessBeginPolygon gluTessBeginPolygon} and
+ * {@link #gluTessEndPolygon gluTessEndPolygon}.
+ *
+ * Optional, throws GLException if not available in profile
+ *
+ * @param tessellator
+ *        Specifies the tessellation object (created with
+ *        {@link #gluNewTess gluNewTess}).
+ *
+ * @see #gluNewTess          gluNewTess
+ * @see #gluTessBeginPolygon gluTessBeginPolygon
+ * @see #gluTessVertex       gluTessVertex
+ * @see #gluTessCallback     gluTessCallback
+ * @see #gluTessProperty     gluTessProperty
+ * @see #gluTessNormal       gluTessNormal
+ * @see #gluTessEndPolygon   gluTessEndPolygon
+ ****************************************************************************/
+public static final void gluTessBeginContour(GLUtessellator tessellator) {
+    validateGLUtessellatorImpl();
+    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
+    tess.gluTessBeginContour();
+}
+
+/*****************************************************************************
+ *  <b>gluTessEndContour</b> and
+ * {@link #gluTessBeginContour gluTessBeginContour}
+ * delimit the definition of a polygon contour. Within each
+ * {@link #gluTessBeginContour gluTessBeginContour}/
+ * <b>gluTessEndContour</b> pair, there can be zero or more calls to
+ * {@link #gluTessVertex gluTessVertex}. The vertices
+ * specify a closed contour (the last vertex of each contour is automatically
+ * linked to the first). See the {@link #gluTessVertex
+ * gluTessVertex} reference page for more details.
+ * {@link #gluTessBeginContour gluTessBeginContour} can
+ * only be called between {@link #gluTessBeginPolygon
+ * gluTessBeginPolygon} and
+ * {@link #gluTessEndPolygon gluTessEndPolygon}.
+ *
+ * Optional, throws GLException if not available in profile
+ *
+ * @param tessellator
+ *        Specifies the tessellation object (created with
+ *        {@link #gluNewTess gluNewTess}).
+ *
+ * @see #gluNewTess          gluNewTess
+ * @see #gluTessBeginPolygon gluTessBeginPolygon
+ * @see #gluTessVertex       gluTessVertex
+ * @see #gluTessCallback     gluTessCallback
+ * @see #gluTessProperty     gluTessProperty
+ * @see #gluTessNormal       gluTessNormal
+ * @see #gluTessEndPolygon   gluTessEndPolygon
+ ****************************************************************************/
+public static final void gluTessEndContour(GLUtessellator tessellator) {
+    validateGLUtessellatorImpl();
+    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
+    tess.gluTessEndContour();
+}
+
+/*****************************************************************************
+ * <b>gluTessEndPolygon</b> and
+ * {@link #gluTessBeginPolygon gluTessBeginPolygon}
+ * delimit the definition of a convex, concave or self-intersecting polygon.
+ * Within each {@link #gluTessBeginPolygon
+ * gluTessBeginPolygon}/<b>gluTessEndPolygon</b> pair, there must be one or
+ * more calls to {@link #gluTessBeginContour
+ * gluTessBeginContour}/{@link #gluTessEndContour
+ * gluTessEndContour}. Within each contour, there are zero or more calls to
+ * {@link #gluTessVertex gluTessVertex}. The vertices
+ * specify a closed contour (the last vertex of each contour is automatically
+ * linked to the first). See the {@link #gluTessVertex
+ * gluTessVertex}, {@link #gluTessBeginContour
+ * gluTessBeginContour} and {@link #gluTessEndContour
+ * gluTessEndContour} reference pages for more details.<P>
+ *
+ * Optional, throws GLException if not available in profile
+ *
+ * Once <b>gluTessEndPolygon</b> is called, the polygon is tessellated, and
+ * the resulting triangles are described through callbacks. See
+ * {@link #gluTessCallback gluTessCallback} for
+ * descriptions of the callback functions.
+ *
+ * @param tessellator
+ *        Specifies the tessellation object (created with
+ *        {@link #gluNewTess gluNewTess}).
+ *
+ * @see #gluNewTess          gluNewTess
+ * @see #gluTessBeginContour gluTessBeginContour
+ * @see #gluTessVertex       gluTessVertex
+ * @see #gluTessCallback     gluTessCallback
+ * @see #gluTessProperty     gluTessProperty
+ * @see #gluTessNormal       gluTessNormal
+ * @see #gluTessBeginPolygon gluTessBeginPolygon
+ ****************************************************************************/
+public static final void gluTessEndPolygon(GLUtessellator tessellator) {
+    validateGLUtessellatorImpl();
+    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
+    tess.gluTessEndPolygon();
+}
+
+/*****************************************************************************
+
+ * <b>gluBeginPolygon</b> and {@link #gluEndPolygon gluEndPolygon}
+ * delimit the definition of a nonconvex polygon. To define such a
+ * polygon, first call <b>gluBeginPolygon</b>. Then define the
+ * contours of the polygon by calling {@link #gluTessVertex
+ * gluTessVertex} for each vertex and {@link #gluNextContour
+ * gluNextContour} to start each new contour. Finally, call {@link
+ * #gluEndPolygon gluEndPolygon} to signal the end of the
+ * definition. See the {@link #gluTessVertex gluTessVertex} and {@link
+ * #gluNextContour gluNextContour} reference pages for more
+ * details.<P>
+ *
+ * Optional, throws GLException if not available in profile
+ *
+ * Once {@link #gluEndPolygon gluEndPolygon} is called,
+ * the polygon is tessellated, and the resulting triangles are described
+ * through callbacks. See {@link #gluTessCallback
+ * gluTessCallback} for descriptions of the callback methods.
+ *
+ * @param tessellator
+ *        Specifies the tessellation object (created with
+ *        {@link #gluNewTess gluNewTess}).
+ *
+ * @see #gluNewTess          gluNewTess
+ * @see #gluNextContour      gluNextContour
+ * @see #gluTessCallback     gluTessCallback
+ * @see #gluTessVertex       gluTessVertex
+ * @see #gluTessBeginPolygon gluTessBeginPolygon
+ * @see #gluTessBeginContour gluTessBeginContour
+ ****************************************************************************/
+public static final void gluBeginPolygon(GLUtessellator tessellator) {
+    validateGLUtessellatorImpl();
+    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
+    tess.gluBeginPolygon();
+}
+
+/*****************************************************************************
+ * <b>gluNextContour</b> is used to describe polygons with multiple
+ * contours. After you describe the first contour through a series of
+ * {@link #gluTessVertex gluTessVertex} calls, a
+ * <b>gluNextContour</b> call indicates that the previous contour is complete
+ * and that the next contour is about to begin. Perform another series of
+ * {@link #gluTessVertex gluTessVertex} calls to
+ * describe the new contour. Repeat this process until all contours have been
+ * described.<P>
+ *
+ * Optional, throws GLException if not available in profile
+ *
+ * The type parameter defines what type of contour follows. The following
+ * values are valid. <P>
+ *
+ * <b>GLU_EXTERIOR</b>
+ * <UL>
+ *   An exterior contour defines an exterior boundary of the polygon.
+ * </UL>
+ * <b>GLU_INTERIOR</b>
+ * <UL>
+ *   An interior contour defines an interior boundary of the polygon (such as
+ *   a hole).
+ * </UL>
+ * <b>GLU_UNKNOWN</b>
+ * <UL>
+ *   An unknown contour is analyzed by the library to determine whether it is
+ *   interior or exterior.
+ * </UL>
+ * <b>GLU_CCW, GLU_CW</b>
+ * <UL>
+ *   The first <b>GLU_CCW</b> or <b>GLU_CW</b> contour defined is considered
+ *   to be exterior. All other contours are considered to be exterior if they
+ *   are oriented in the same direction (clockwise or counterclockwise) as the
+ *   first contour, and interior if they are not. If one contour is of type
+ *   <b>GLU_CCW</b> or <b>GLU_CW</b>, then all contours must be of the same
+ *   type (if they are not, then all <b>GLU_CCW</b> and <b>GLU_CW</b> contours
+ *   will be changed to <b>GLU_UNKNOWN</b>). Note that there is no
+ *   real difference between the <b>GLU_CCW</b> and <b>GLU_CW</b> contour
+ *   types.
+ * </UL><P>
+ *
+ * To define the type of the first contour, you can call <b>gluNextContour</b>
+ * before describing the first contour. If you do not call
+ * <b>gluNextContour</b> before the first contour, the first contour is marked
+ * <b>GLU_EXTERIOR</b>.<P>
+ *
+ * <UL>
+ *   <b>Note:</b>  The <b>gluNextContour</b> function is obsolete and is
+ *   provided for backward compatibility only. The <b>gluNextContour</b>
+ *   function is mapped to {@link #gluTessEndContour
+ *   gluTessEndContour} followed by
+ *   {@link #gluTessBeginContour gluTessBeginContour}.
+ * </UL>
+ *
+ * @param tessellator
+ *        Specifies the tessellation object (created with
+ *        {@link #gluNewTess gluNewTess}).
+ * @param type
+ *        The type of the contour being defined.
+ *
+ * @see #gluNewTess          gluNewTess
+ * @see #gluTessBeginContour gluTessBeginContour
+ * @see #gluTessBeginPolygon gluTessBeginPolygon
+ * @see #gluTessCallback     gluTessCallback
+ * @see #gluTessEndContour   gluTessEndContour
+ * @see #gluTessVertex       gluTessVertex
+ ****************************************************************************/
+public static final void gluNextContour(GLUtessellator tessellator, int type) {
+    validateGLUtessellatorImpl();
+    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
+    tess.gluNextContour(type);
+}
+
+/*****************************************************************************
+ * <b>gluEndPolygon</b> and {@link #gluBeginPolygon
+ * gluBeginPolygon} delimit the definition of a nonconvex polygon. To define
+ * such a polygon, first call {@link #gluBeginPolygon
+ * gluBeginPolygon}. Then define the contours of the polygon by calling
+ * {@link #gluTessVertex gluTessVertex} for each vertex
+ * and {@link #gluNextContour gluNextContour} to start
+ * each new contour. Finally, call <b>gluEndPolygon</b> to signal the end of
+ * the definition. See the {@link #gluTessVertex
+ * gluTessVertex} and {@link #gluNextContour
+ * gluNextContour} reference pages for more details.<P>
+ *
+ * Optional, throws GLException if not available in profile
+ *
+ * Once <b>gluEndPolygon</b> is called, the polygon is tessellated, and the
+ * resulting triangles are described through callbacks. See
+ * {@link #gluTessCallback gluTessCallback} for
+ * descriptions of the callback methods.
+ *
+ * @param tessellator
+ *        Specifies the tessellation object (created with
+ *        {@link #gluNewTess gluNewTess}).
+ *
+ * @see #gluNewTess          gluNewTess
+ * @see #gluNextContour      gluNextContour
+ * @see #gluTessCallback     gluTessCallback
+ * @see #gluTessVertex       gluTessVertex
+ * @see #gluTessBeginPolygon gluTessBeginPolygon
+ * @see #gluTessBeginContour gluTessBeginContour
+ ****************************************************************************/
+public static final void gluEndPolygon(GLUtessellator tessellator) {
+    validateGLUtessellatorImpl();
+    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
+    tess.gluEndPolygon();
+}
+
+// Boolean
+public static final int GLU_FALSE = 0;
+public static final int GLU_TRUE = 1;
+
+// String Name
+public static final int GLU_VERSION = 100800;
+public static final int GLU_EXTENSIONS = 100801;
+
+// Extensions
+public static final String versionString = "1.3";
+public static final String extensionString = "GLU_EXT_nurbs_tessellator " +
+                                             "GLU_EXT_object_space_tess ";
+
+// ErrorCode
+public static final int GLU_INVALID_ENUM = 100900;
+public static final int GLU_INVALID_VALUE = 100901;
+public static final int GLU_OUT_OF_MEMORY = 100902;
+public static final int GLU_INVALID_OPERATION = 100904;
+
+
+// QuadricDrawStyle
+public static final int GLU_POINT = 100010;
+public static final int GLU_LINE = 100011;
+public static final int GLU_FILL = 100012;
+public static final int GLU_SILHOUETTE = 100013;
+
+// QuadricCallback
+// GLU_ERROR
+
+// QuadricNormal
+public static final int GLU_SMOOTH = 100000;
+public static final int GLU_FLAT = 100001;
+public static final int GLU_NONE = 100002;
+
+// QuadricOrientation
+public static final int GLU_OUTSIDE = 100020;
+public static final int GLU_INSIDE = 100021;
+
+// NurbsDisplay
+// GLU_FILL
+//public static final int GLU_OUTLINE_POLYGON = 100240;
+//public static final int GLU_OUTLINE_PATCH = 100241;
+
+// NurbsCallback
+//public static final int GLU_NURBS_ERROR = 100103;
+public static final int GLU_ERROR = 100103;
+//public static final int GLU_NURBS_BEGIN = 100164;
+//public static final int GLU_NURBS_BEGIN_EXT = 100164;
+//public static final int GLU_NURBS_VERTEX = 100165;
+//public static final int GLU_NURBS_VERTEX_EXT = 100165;
+//public static final int GLU_NURBS_NORMAL = 100166;
+//public static final int GLU_NURBS_NORMAL_EXT = 100166;
+//public static final int GLU_NURBS_COLOR = 100167;
+//public static final int GLU_NURBS_COLOR_EXT = 100167;
+//public static final int GLU_NURBS_TEXTURE_COORD = 100168;
+//public static final int GLU_NURBS_TEX_COORD_EXT = 100168;
+//public static final int GLU_NURBS_END = 100169;
+//public static final int GLU_NURBS_END_EXT = 100169;
+//public static final int GLU_NURBS_BEGIN_DATA = 100170;
+//public static final int GLU_NURBS_BEGIN_DATA_EXT = 100170;
+//public static final int GLU_NURBS_VERTEX_DATA = 100171;
+//public static final int GLU_NURBS_VERTEX_DATA_EXT = 100171;
+//public static final int GLU_NURBS_NORMAL_DATA = 100172;
+//public static final int GLU_NURBS_NORMAL_DATA_EXT = 100172;
+//public static final int GLU_NURBS_COLOR_DATA = 100173;
+//public static final int GLU_NURBS_COLOR_DATA_EXT = 100173;
+//public static final int GLU_NURBS_TEXTURE_COORD_DATA = 100174;
+//public static final int GLU_NURBS_TEX_COORD_DATA_EXT = 100174;
+//public static final int GLU_NURBS_END_DATA = 100175;
+//public static final int GLU_NURBS_END_DATA_EXT = 100175;
+
+// NurbsError
+//public static final int GLU_NURBS_ERROR1 = 100251;
+//public static final int GLU_NURBS_ERROR2 = 100252;
+//public static final int GLU_NURBS_ERROR3 = 100253;
+//public static final int GLU_NURBS_ERROR4 = 100254;
+//public static final int GLU_NURBS_ERROR5 = 100255;
+//public static final int GLU_NURBS_ERROR6 = 100256;
+//public static final int GLU_NURBS_ERROR7 = 100257;
+//public static final int GLU_NURBS_ERROR8 = 100258;
+//public static final int GLU_NURBS_ERROR9 = 100259;
+//public static final int GLU_NURBS_ERROR10 = 100260;
+//public static final int GLU_NURBS_ERROR11 = 100261;
+//public static final int GLU_NURBS_ERROR12 = 100262;
+//public static final int GLU_NURBS_ERROR13 = 100263;
+//public static final int GLU_NURBS_ERROR14 = 100264;
+//public static final int GLU_NURBS_ERROR15 = 100265;
+//public static final int GLU_NURBS_ERROR16 = 100266;
+//public static final int GLU_NURBS_ERROR17 = 100267;
+//public static final int GLU_NURBS_ERROR18 = 100268;
+//public static final int GLU_NURBS_ERROR19 = 100269;
+//public static final int GLU_NURBS_ERROR20 = 100270;
+//public static final int GLU_NURBS_ERROR21 = 100271;
+//public static final int GLU_NURBS_ERROR22 = 100272;
+//public static final int GLU_NURBS_ERROR23 = 100273;
+//public static final int GLU_NURBS_ERROR24 = 100274;
+//public static final int GLU_NURBS_ERROR25 = 100275;
+//public static final int GLU_NURBS_ERROR26 = 100276;
+//public static final int GLU_NURBS_ERROR27 = 100277;
+//public static final int GLU_NURBS_ERROR28 = 100278;
+//public static final int GLU_NURBS_ERROR29 = 100279;
+//public static final int GLU_NURBS_ERROR30 = 100280;
+//public static final int GLU_NURBS_ERROR31 = 100281;
+//public static final int GLU_NURBS_ERROR32 = 100282;
+//public static final int GLU_NURBS_ERROR33 = 100283;
+//public static final int GLU_NURBS_ERROR34 = 100284;
+//public static final int GLU_NURBS_ERROR35 = 100285;
+//public static final int GLU_NURBS_ERROR36 = 100286;
+//public static final int GLU_NURBS_ERROR37 = 100287;
+
+// NurbsProperty
+//public static final int GLU_AUTO_LOAD_MATRIX = 100200;
+//public static final int GLU_CULLING = 100201;
+//public static final int GLU_SAMPLING_TOLERANCE = 100203;
+//public static final int GLU_DISPLAY_MODE = 100204;
+//public static final int GLU_PARAMETRIC_TOLERANCE = 100202;
+//public static final int GLU_SAMPLING_METHOD = 100205;
+//public static final int GLU_U_STEP = 100206;
+//public static final int GLU_V_STEP = 100207;
+//public static final int GLU_NURBS_MODE = 100160;
+//public static final int GLU_NURBS_MODE_EXT = 100160;
+//public static final int GLU_NURBS_TESSELLATOR = 100161;
+//public static final int GLU_NURBS_TESSELLATOR_EXT = 100161;
+//public static final int GLU_NURBS_RENDERER = 100162;
+//public static final int GLU_NURBS_RENDERER_EXT = 100162;
+
+// NurbsSampling
+//public static final int GLU_OBJECT_PARAMETRIC_ERROR = 100208;
+//public static final int GLU_OBJECT_PARAMETRIC_ERROR_EXT = 100208;
+//public static final int GLU_OBJECT_PATH_LENGTH = 100209;
+//public static final int GLU_OBJECT_PATH_LENGTH_EXT = 100209;
+//public static final int GLU_PATH_LENGTH = 100215;
+//public static final int GLU_PARAMETRIC_ERROR = 100216;
+//public static final int GLU_DOMAIN_DISTANCE = 100217;
+
+// NurbsTrim
+//public static final int GLU_MAP1_TRIM_2 = 100210;
+//public static final int GLU_MAP1_TRIM_3 = 100211;
+
+// QuadricCallback
+// GLU_ERROR
+
+// TessCallback
+public static final int GLU_TESS_BEGIN = 100100;
+public static final int GLU_BEGIN = 100100;
+public static final int GLU_TESS_VERTEX = 100101;
+public static final int GLU_VERTEX = 100101;
+public static final int GLU_TESS_END = 100102;
+public static final int GLU_END = 100102;
+public static final int GLU_TESS_ERROR = 100103;
+public static final int GLU_TESS_EDGE_FLAG = 100104;
+public static final int GLU_EDGE_FLAG = 100104;
+public static final int GLU_TESS_COMBINE = 100105;
+public static final int GLU_TESS_BEGIN_DATA = 100106;
+public static final int GLU_TESS_VERTEX_DATA = 100107;
+public static final int GLU_TESS_END_DATA = 100108;
+public static final int GLU_TESS_ERROR_DATA = 100109;
+public static final int GLU_TESS_EDGE_FLAG_DATA = 100110;
+public static final int GLU_TESS_COMBINE_DATA = 100111;
+
+// TessContour
+public static final int GLU_CW = 100120;
+public static final int GLU_CCW = 100121;
+public static final int GLU_INTERIOR = 100122;
+public static final int GLU_EXTERIOR = 100123;
+public static final int GLU_UNKNOWN = 100124;
+
+// TessProperty
+public static final int GLU_TESS_WINDING_RULE = 100140;
+public static final int GLU_TESS_BOUNDARY_ONLY = 100141;
+public static final int GLU_TESS_TOLERANCE = 100142;
+// JOGL-specific boolean property, false by default, that may improve the tessellation
+public static final int GLU_TESS_AVOID_DEGENERATE_TRIANGLES = 100149;
+
+// TessError
+public static final int GLU_TESS_ERROR1 = 100151;
+public static final int GLU_TESS_ERROR2 = 100152;
+public static final int GLU_TESS_ERROR3 = 100153;
+public static final int GLU_TESS_ERROR4 = 100154;
+public static final int GLU_TESS_ERROR5 = 100155;
+public static final int GLU_TESS_ERROR6 = 100156;
+public static final int GLU_TESS_ERROR7 = 100157;
+public static final int GLU_TESS_ERROR8 = 100158;
+public static final int GLU_TESS_MISSING_BEGIN_POLYGON = 100151;
+public static final int GLU_TESS_MISSING_BEGIN_CONTOUR = 100152;
+public static final int GLU_TESS_MISSING_END_POLYGON = 100153;
+public static final int GLU_TESS_MISSING_END_CONTOUR = 100154;
+public static final int GLU_TESS_COORD_TOO_LARGE = 100155;
+public static final int GLU_TESS_NEED_COMBINE_CALLBACK = 100156;
+
+// TessWinding
+public static final int GLU_TESS_WINDING_ODD = 100130;
+public static final int GLU_TESS_WINDING_NONZERO = 100131;
+public static final int GLU_TESS_WINDING_POSITIVE = 100132;
+public static final int GLU_TESS_WINDING_NEGATIVE = 100133;
+public static final int GLU_TESS_WINDING_ABS_GEQ_TWO = 100134;
+public static final double GLU_TESS_MAX_COORD = 1.0e150;
+
+//----------------------------------------------------------------------
+// Quadric functionality
+//
+
+protected static boolean availableGLUquadricImpl = false;
+protected static boolean checkedGLUquadricImpl = false;
+protected static volatile Object syncObject = new Object();
+
+/**
+ * Optional, throws GLException if not available in profile
+ */
+protected static final void validateGLUquadricImpl() {
+    if(!checkedGLUquadricImpl) {
+        synchronized (syncObject) {
+            if(!checkedGLUquadricImpl) {
+                availableGLUquadricImpl = NWReflection.isClassAvailable("com.sun.opengl.impl.glu.GLUquadricImpl");
+                checkedGLUquadricImpl = true;
+            }
+        }
+    }
+    if(!availableGLUquadricImpl) {
+      throw new GLException("GLUquadric not available (GLUquadricImpl)");
+    }
+}
+
+
+/** Option (throws GLException if not available in profile). <br> Interface to C language function: <br> <code> void gluCylinder(GLUquadric *  quad, GLdouble base, GLdouble top, GLdouble height, GLint slices, GLint stacks); </code>    */
+public final void gluCylinder(GLUquadric quad, double base, double top, double height, int slices, int stacks) {
+  validateGLUquadricImpl();
+  ((GLUquadricImpl) quad).drawCylinder(getCurrentGL(), (float) base, (float) top, (float) height, slices, stacks);
+}
+
+/** Option (throws GLException if not available in profile). <br> Interface to C language function: <br> <code> void gluDeleteQuadric(GLUquadric *  quad); </code>    */
+public final void gluDeleteQuadric(GLUquadric quad) {
+  validateGLUquadricImpl();
+}
+
+/** Option (throws GLException if not available in profile). <br> Interface to C language function: <br> <code> void gluDisk(GLUquadric *  quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops); </code>    */
+public final void gluDisk(GLUquadric quad, double inner, double outer, int slices, int loops) {
+  validateGLUquadricImpl();
+  ((GLUquadricImpl) quad).drawDisk(getCurrentGL(), (float) inner, (float) outer, slices, loops);
+}
+
+/** Option (throws GLException if not available in profile). <br> Interface to C language function: <br> <code> GLUquadric *  gluNewQuadric(void); </code>    */
+public final GLUquadric gluNewQuadric() {
+  return gluNewQuadric(false);
+}
+
+public final GLUquadric gluNewQuadric(boolean useGLSL) {
+  GL gl = getCurrentGL();
+  if(useGLSL && !gl.isGL2ES2()) {
+    throw new GLException("GLUquadric GLSL implementation not supported for profile: "+gl);
+  }
+  validateGLUquadricImpl();
+  return new GLUquadricImpl(gl, useGLSL);
+}
+
+/** Option (throws GLException if not available in profile). <br> Interface to C language function: <br> <code> void gluPartialDisk(GLUquadric *  quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops, GLdouble start, GLdouble sweep); </code>    */
+public final void gluPartialDisk(GLUquadric quad, double inner, double outer, int slices, int loops, double start, double sweep) {
+  validateGLUquadricImpl();
+  ((GLUquadricImpl) quad).drawPartialDisk(getCurrentGL(), (float) inner, (float) outer, slices, loops, (float) start, (float) sweep);
+}
+
+/** Option (throws GLException if not available in profile). <br> Interface to C language function: <br> <code> void gluQuadricDrawStyle(GLUquadric *  quad, GLenum draw); </code>    */
+public final void gluQuadricDrawStyle(GLUquadric quad, int draw) {
+  validateGLUquadricImpl();
+  ((GLUquadricImpl) quad).setDrawStyle(draw);
+}
+
+/** Option (throws GLException if not available in profile). <br> Interface to C language function: <br> <code> void gluQuadricNormals(GLUquadric *  quad, GLenum normal); </code>    */
+public final void gluQuadricNormals(GLUquadric quad, int normal) {
+  validateGLUquadricImpl();
+  ((GLUquadricImpl) quad).setNormals(normal);
+}
+
+/** Option (throws GLException if not available in profile). <br> Interface to C language function: <br> <code> void gluQuadricOrientation(GLUquadric *  quad, GLenum orientation); </code>    */
+public final void gluQuadricOrientation(GLUquadric quad, int orientation) {
+  validateGLUquadricImpl();
+  ((GLUquadricImpl) quad).setOrientation(orientation);
+}
+
+/** Option (throws GLException if not available in profile). <br> Interface to C language function: <br> <code> void gluQuadricTexture(GLUquadric *  quad, GLboolean texture); </code>    */
+public final void gluQuadricTexture(GLUquadric quad, boolean texture) {
+  validateGLUquadricImpl();
+  ((GLUquadricImpl) quad).setTextureFlag(texture);
+}
+
+/** Option (throws GLException if not available in profile). <br> Interface to C language function: <br> <code> void gluSphere(GLUquadric *  quad, GLdouble radius, GLint slices, GLint stacks); </code>    */
+public final void gluSphere(GLUquadric quad, double radius, int slices, int stacks) {
+  validateGLUquadricImpl();
+  ((GLUquadricImpl) quad).drawSphere(getCurrentGL(), (float) radius, slices, stacks);
+}
+
+//----------------------------------------------------------------------
+// Projection routines
+//
+
+private ProjectFloat project;
+
+public void gluOrtho2D(float left, float right, float bottom, float top) {
+  project.gluOrtho2D(getCurrentGL().getGL2ES1(), left, right, bottom, top);
+}
+
+public void gluPerspective(float fovy, float aspect, float zNear, float zFar) {
+  project.gluPerspective(getCurrentGL().getGL2ES1(), fovy, aspect, zNear, zFar);
+}
+
+public void gluLookAt(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ) {
+  project.gluLookAt(getCurrentGL().getGL2ES1(), eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ);
+}
+
+/** Interface to C language function: <br> <code> GLint gluProject(GLdouble objX, GLdouble objY, GLdouble objZ, const GLdouble *  model, const GLdouble *  proj, const GLint *  view, GLdouble *  winX, GLdouble *  winY, GLdouble *  winZ); </code>
+ * <P> Accepts the outgoing window coordinates as a single array.
+ */
+public boolean gluProject(float objX, float objY, float objZ, float[] model, int model_offset, float[] proj, int proj_offset, int[] view, int view_offset, float[] winPos, int winPos_offset) {
+  return project.gluProject(objX, objY, objZ, model, model_offset, proj, proj_offset, view, view_offset, winPos, winPos_offset);
+}
+
+/** Interface to C language function: <br> <code> GLint gluProject(GLdouble objX, GLdouble objY, GLdouble objZ, const GLdouble *  model, const GLdouble *  proj, const GLint *  view, GLdouble *  winX, GLdouble *  winY, GLdouble *  winZ); </code>
+ * <P> Accepts the outgoing window coordinates as a single buffer.
+ */
+public boolean gluProject(float objX, float objY, float objZ, java.nio.FloatBuffer model, java.nio.FloatBuffer proj, java.nio.IntBuffer view, java.nio.FloatBuffer winPos) {
+  return project.gluProject(objX, objY, objZ, model, proj, view, winPos);
+}
+
+/** Interface to C language function: <br> <code> GLint gluUnProject(GLdouble winX, GLdouble winY, GLdouble winZ, const GLdouble *  model, const GLdouble *  proj, const GLint *  view, GLdouble *  objX, GLdouble *  objY, GLdouble *  objZ); </code>
+ * <P> Accepts the outgoing object coordinates (a 3-vector) as a single array.
+ */
+public boolean gluUnProject(float winX, float winY, float winZ, float[] model, int model_offset, float[] proj, int proj_offset, int[] view, int view_offset, float[] objPos, int objPos_offset) {
+  return project.gluUnProject(winX, winY, winZ, model, model_offset, proj, proj_offset, view, view_offset, objPos, objPos_offset);
+}
+
+/** Interface to C language function: <br> <code> GLint gluUnProject(GLdouble winX, GLdouble winY, GLdouble winZ, const GLdouble *  model, const GLdouble *  proj, const GLint *  view, GLdouble *  objX, GLdouble *  objY, GLdouble *  objZ); </code>
+ * <P> Accepts the outgoing object coordinates (a 3-vector) as a single buffer.
+ */
+public boolean gluUnProject(float winX, float winY, float winZ, java.nio.FloatBuffer model, java.nio.FloatBuffer proj, java.nio.IntBuffer view, java.nio.FloatBuffer objPos) {
+  return project.gluUnProject(winX, winY, winZ, model, proj, view, objPos);
+}
+
+/** Interface to C language function: <br> <code> GLint gluUnProject4(GLdouble winX, GLdouble winY, GLdouble winZ, GLdouble clipW, const GLdouble *  model, const GLdouble *  proj, const GLint *  view, GLdouble nearVal, GLdouble farVal, GLdouble *  objX, GLdouble *  objY, GLdouble *  objZ, GLdouble *  objW); </code>
+ * <P> Accepts the outgoing object coordinates (a 4-vector) as a single array.
+ */
+public boolean gluUnProject4(float winX, float winY, float winZ, float clipW, float[] model, int model_offset, float[] proj, int proj_offset, int[] view, int view_offset, float nearVal, float farVal, float[] objPos, int objPos_offset) {
+  return project.gluUnProject4(winX, winY, winZ, clipW, model, model_offset, proj, proj_offset, view, view_offset, nearVal, farVal, objPos, objPos_offset);
+}
+
+/** Interface to C language function: <br> <code> GLint gluUnProject4(GLdouble winX, GLdouble winY, GLdouble winZ, GLdouble clipW, const GLdouble *  model, const GLdouble *  proj, const GLint *  view, GLdouble nearVal, GLdouble farVal, GLdouble *  objX, GLdouble *  objY, GLdouble *  objZ, GLdouble *  objW); </code>
+ * <P> Accepts the outgoing object coordinates (a 4-vector) as a single buffer.
+ */
+public boolean gluUnProject4(float winX, float winY, float winZ, float clipW, java.nio.FloatBuffer model, java.nio.FloatBuffer proj, java.nio.IntBuffer view, float nearVal, float farVal, java.nio.FloatBuffer objPos) {
+  return project.gluUnProject4(winX, winY, winZ, clipW, model, proj, view, nearVal, farVal, objPos);
+}
+
+public void gluPickMatrix(float x, float y, float delX, float delY, int[] viewport, int viewport_offset) {
+  project.gluPickMatrix(getCurrentGL().getGL2ES1(), x, y, delX, delY, viewport, viewport_offset);
+}
+
+public void gluPickMatrix(float x, float y, float delX, float delY, java.nio.IntBuffer viewport) {
+  project.gluPickMatrix(getCurrentGL().getGL2ES1(), x, y, delX, delY, viewport);
+}
+
+public void gluOrtho2D(double left, double right, double bottom, double top) {
+  project.gluOrtho2D(getCurrentGL().getGL2ES1(), (float)left, (float)right, (float)bottom, (float)top);
+}
+
+public void gluPerspective(double fovy, double aspect, double zNear, double zFar) {
+  project.gluPerspective(getCurrentGL().getGL2ES1(), (float)fovy, (float)aspect, (float)zNear, (float)zFar);
+}
+
+public void gluLookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ) {
+  project.gluLookAt(getCurrentGL().getGL2ES1(), (float)eyeX, (float)eyeY, (float)eyeZ, (float)centerX, (float)centerY, (float)centerZ, (float)upX, (float)upY, (float)upZ);
+}
+
+/** Interface to C language function: <br> <code> GLint gluProject(GLdouble objX, GLdouble objY, GLdouble objZ, const GLdouble *  model, const GLdouble *  proj, const GLint *  view, GLdouble *  winX, GLdouble *  winY, GLdouble *  winZ); </code>
+ * <P> Accepts the outgoing window coordinates as a single array.
+ */
+public boolean gluProject(double objX, double objY, double objZ, double[] model, int model_offset, double[] proj, int proj_offset, int[] view, int view_offset, double[] winPos, int winPos_offset) {
+  return project.gluProject((float)objX, (float)objY, (float)objZ, InternalBufferUtil.getFloatArray(model), model_offset, InternalBufferUtil.getFloatArray(proj), proj_offset, view, view_offset, InternalBufferUtil.getFloatArray(winPos), winPos_offset);
+}
+
+/** Interface to C language function: <br> <code> GLint gluUnProject(GLdouble winX, GLdouble winY, GLdouble winZ, const GLdouble *  model, const GLdouble *  proj, const GLint *  view, GLdouble *  objX, GLdouble *  objY, GLdouble *  objZ); </code>
+ * <P> Accepts the outgoing object coordinates (a 3-vector) as a single array.
+ */
+public boolean gluUnProject(double winX, double winY, double winZ, double[] model, int model_offset, double[] proj, int proj_offset, int[] view, int view_offset, double[] objPos, int objPos_offset) {
+  return project.gluUnProject((float)winX, (float)winY, (float)winZ, InternalBufferUtil.getFloatArray(model), model_offset, InternalBufferUtil.getFloatArray(proj), proj_offset, view, view_offset, InternalBufferUtil.getFloatArray(objPos), objPos_offset);
+}
+
+/** Interface to C language function: <br> <code> GLint gluUnProject4(GLdouble winX, GLdouble winY, GLdouble winZ, GLdouble clipW, const GLdouble *  model, const GLdouble *  proj, const GLint *  view, GLdouble nearVal, GLdouble farVal, GLdouble *  objX, GLdouble *  objY, GLdouble *  objZ, GLdouble *  objW); </code>
+ * <P> Accepts the outgoing object coordinates (a 4-vector) as a single array.
+ */
+public boolean gluUnProject4(double winX, double winY, double winZ, double clipW, double[] model, int model_offset, double[] proj, int proj_offset, int[] view, int view_offset, double nearVal, double farVal, double[] objPos, int objPos_offset) {
+  return project.gluUnProject4((float)winX, (float)winY, (float)winZ, (float)clipW, InternalBufferUtil.getFloatArray(model), model_offset, InternalBufferUtil.getFloatArray(proj), proj_offset, view, view_offset, (float)nearVal, (float)farVal, InternalBufferUtil.getFloatArray(objPos), objPos_offset);
+}
+
+public void gluPickMatrix(double x, double y, double delX, double delY, int[] viewport, int viewport_offset) {
+  project.gluPickMatrix(getCurrentGL().getGL2ES1(), (float)x, (float)y, (float)delX, (float)delY, viewport, viewport_offset);
+}
+
+public void gluPickMatrix(double x, double y, double delX, double delY, IntBuffer viewport) {
+  project.gluPickMatrix(getCurrentGL().getGL2ES1(), (float)x, (float)y, (float)delX, (float)delY, viewport);
+}
+
+/**
+ * Optional, throws GLException if not available in profile
+ */
+public int gluScaleImage( int format, int widthin, int heightin,
+                               int typein, java.nio.Buffer datain, int widthout, int heightout,
+                               int typeout, java.nio.Buffer dataout ) {
+    throw new GLException("not implemented");
+}
+
+/**
+ * Optional, throws GLException if not available in profile
+ */
+public int gluBuild1DMipmapLevels( int target, int internalFormat, int width,
+                                        int format, int type, int userLevel, int baseLevel, int maxLevel,
+                                        java.nio.Buffer data ) {
+    throw new GLException("not implemented");
+}
+/**
+ * Optional, throws GLException if not available in profile
+ */
+public int gluBuild1DMipmaps( int target, int internalFormat, int width,
+                                   int format, int type, java.nio.Buffer data ) {
+    throw new GLException("not implemented");
+}
+
+/**
+ * Optional, throws GLException if not available in profile
+ */
+public int gluBuild2DMipmapLevels( int target, int internalFormat, int width,
+                                        int height, int format, int type, int userLevel, int baseLevel,
+                                        int maxLevel, java.nio.Buffer data ) {
+    throw new GLException("not implemented");
+}
+
+/**
+ * Optional, throws GLException if not available in profile
+ */
+public int gluBuild2DMipmaps( int target, int internalFormat, int width,
+                                   int height, int format, int type, java.nio.Buffer data ) {
+    throw new GLException("not implemented");
+}
+
+/**
+ * Optional, throws GLException if not available in profile
+ */
+public int gluBuild3DMipmapLevels( int target, int internalFormat, int width,
+                                        int height, int depth, int format, int type, int userLevel, int baseLevel,
+                                        int maxLevel, java.nio.Buffer data) {
+    throw new GLException("not implemented");
+}
+
+/**
+ * Optional, throws GLException if not available in profile
+ */
+public int gluBuild3DMipmaps( int target, int internalFormat, int width,
+                                   int height, int depth, int format, int type, java.nio.Buffer data ) {
+    throw new GLException("not implemented");
+}
+
diff --git a/make/config/jogl/glu-CustomJavaCode-gl2.java b/make/config/jogl/glu-CustomJavaCode-gl2.java
new file mode 100644
index 000000000..5b2a3ed89
--- /dev/null
+++ b/make/config/jogl/glu-CustomJavaCode-gl2.java
@@ -0,0 +1,562 @@
+private static boolean useJavaMipmapCode = true;
+
+static {
+  AccessController.doPrivileged(new PrivilegedAction() {
+      public Object run() {
+        String val = System.getProperty("jogl.glu.nojava");
+        if (val != null && !val.toLowerCase().equals("false")) {
+          useJavaMipmapCode = false;
+        }
+        return null;
+      }
+    });
+}
+
+/**
+ * Instantiates a new OpenGL Utility Library object. A GLU object may
+ * be instantiated at any point in the application and is not
+ * inherently tied to any particular OpenGL context; however, the GLU
+ * object may only be used when an OpenGL context is current on the
+ * current thread. Attempts to call most of the methods in the GLU
+ * library when no OpenGL context is current will cause an exception
+ * to be thrown.
+ *
+ * <P>
+ *
+ * The returned GLU object is not guaranteed to be thread-safe and
+ * should only be used from one thread at a time. Multiple GLU objects
+ * may be instantiated to be used from different threads
+ * simultaneously.
+ */
+
+public GLUgl2()
+{
+  this.project = new ProjectDouble();
+}
+
+public void destroy() {
+  if(null!=this.project) {
+      this.project.destroy();
+      this.project=null;
+  }
+  super.destroy();
+}
+
+
+//----------------------------------------------------------------------
+// Utility routines
+//
+
+public static final GL2 getCurrentGL2() throws GLException {
+  GLContext curContext = GLContext.getCurrent();
+  if (curContext == null) {
+    throw new GLException("No OpenGL context current on this thread");
+  }
+  return curContext.getGL().getGL2();
+}
+
+/**
+ * Returns true if the specified GLU core- or extension-function can be
+ * successfully used through this GLU instance. By "successfully" we mean
+ * that the function is both <i>callable</i> on the machine running the
+ * program and <i>available</i> on the current display.<P>
+ *
+ * A GLU function is <i>callable</i> if it is a GLU core- or extension-function
+ * that is supported by the underlying GLU implementation. The function is
+ * <i>available</i> if the OpenGL implementation on the display meets the
+ * requirements of the GLU function being called (because GLU functions utilize
+ * OpenGL functions). <P>
+ *
+ * Whether or not a GLU function is <i>callable</i> is determined as follows:
+ * <ul>
+ *   <li>If the function is a GLU core function (i.e., not an
+ *   extension), <code>gluGetString(GLU_VERSION)</code> is used to determine the
+ *   version number of the underlying GLU implementation on the host.
+ *   then the function name is cross-referenced with that specification to
+ *   see if it is part of that version's specification.
+ *
+ *   <li> If the function is a GLU extension, the function name is
+ *   cross-referenced with the list returned by
+ *   <code>gluGetString(GLU_EXTENSIONS)</code> to see if the function is one of
+ *   the extensions that is supported by the underlying GLU implementation.
+ * </ul>
+ *
+ * Whether or not a GLU function is <i>available</i> is determined as follows:
+ * <ul>
+ *   <li>If the function is a GLU core function then the function is first
+ *   cross-referenced with the GLU specifications to find the minimum GLU
+ *   version required to <i>call</i> that GLU function. Then the following table
+ *   is consulted to determine the minimum GL version required for that version
+ *   of GLU:
+ *   <ul>
+ *   <li> GLU 1.0 requires OpenGL 1.0
+ *   <li> GLU 1.1 requires OpenGL 1.0
+ *   <li> GLU 1.2 requires OpenGL 1.1
+ *   <li> GLU 1.3 requires OpenGL 1.2
+ *   </ul>
+ *   Finally, <code>glGetString(GL_VERSION)</code> is used to determine the
+ *   highest OpenGL version that both host and display support, and from that it
+ *   is possible to determine if the GL facilities required by the GLU function
+ *   are <i>available</i> on the display.
+ *
+ *   <li> If the function is a GLU extension, the function name is
+ *   cross-referenced with the list returned by
+ *   <code>gluGetString(GLU_EXTENSIONS)</code> to see if the function is one of
+ *   the extensions that is supported by the underlying GLU implementation.
+ * </ul>
+ *
+ * <b>NOTE:</b>The availability of a function may change at runtime in
+ * response to changes in the display environment. For example, when a window
+ * is dragged from one display to another on a multi-display system, or when
+ * the properties of the display device are modified (e.g., changing the color
+ * depth of the display). Any application that is concerned with handling
+ * these situations correctly should confirm availability after a display
+ * change before calling a questionable OpenGL function. To detect a change in
+ * the display device, please see {@link
+ * GLEventListener#displayChanged(GLAutoDrawable,boolean,boolean)}.
+ *
+ * @param gluFunctionName the name of the OpenGL function (e.g., use
+ * "gluNurbsCallbackDataEXT" to check if the <code>
+ * gluNurbsCallbackDataEXT(GLUnurbs, GLvoid)</code> extension is available).
+ */
+public final boolean isFunctionAvailable(String gluFunctionName)
+{
+  if (useJavaMipmapCode) {
+    // All GLU functions are available in Java port
+    return true;
+  }
+  return (gluProcAddressTable.getAddressFor(gluFunctionName) != 0);
+}
+
+//----------------------------------------------------------------------
+// Projection routines
+//
+
+private ProjectDouble project;
+
+public final void gluOrtho2D(float left, float right, float bottom, float top) {
+  project.gluOrtho2D(getCurrentGL2(), (double)left, (double)right, (double)bottom, (double)top);
+
+}
+
+public final void gluOrtho2D(double left, double right, double bottom, double top) {
+  project.gluOrtho2D(getCurrentGL2(), left, right, bottom, top);
+}
+
+public final void gluPerspective(float fovy, float aspect, float zNear, float zFar) {
+  project.gluPerspective(getCurrentGL2(), (double)fovy, (double)aspect, (double)zNear, (double)zFar);
+}
+
+public final void gluPerspective(double fovy, double aspect, double zNear, double zFar) {
+  project.gluPerspective(getCurrentGL2(), fovy, aspect, zNear, zFar);
+}
+
+public final void gluLookAt(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ) {
+  project.gluLookAt(getCurrentGL2(), (double)eyeX, (double)eyeY, (double)eyeZ, (double)centerX, (double)centerY, (double)centerZ, (double)upX, (double)upY, (double)upZ);
+}
+
+public final void gluLookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ) {
+  project.gluLookAt(getCurrentGL2(), eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ);
+}
+
+/** Interface to C language function: <br> <code> GLint gluProject(GLdouble objX, GLdouble objY, GLdouble objZ, const GLdouble *  model, const GLdouble *  proj, const GLint *  view, GLdouble *  winX, GLdouble *  winY, GLdouble *  winZ); </code>
+ * <P> Accepts the outgoing window coordinates as a single array.
+ */
+public final boolean gluProject(double objX, double objY, double objZ, double[] model, int model_offset, double[] proj, int proj_offset, int[] view, int view_offset, double[] winPos, int winPos_offset) {
+  return project.gluProject(objX, objY, objZ, model, model_offset, proj, proj_offset, view, view_offset, winPos, winPos_offset);
+}
+
+/** Interface to C language function: <br> <code> GLint gluProject(GLdouble objX, GLdouble objY, GLdouble objZ, const GLdouble *  model, const GLdouble *  proj, const GLint *  view, GLdouble *  winX, GLdouble *  winY, GLdouble *  winZ); </code>
+ * <P> Accepts the outgoing window coordinates as a single buffer.
+ */
+public final boolean gluProject(double objX, double objY, double objZ, DoubleBuffer model, DoubleBuffer proj, IntBuffer view, DoubleBuffer winPos) {
+  return project.gluProject(objX, objY, objZ, model, proj, view, winPos);
+}
+
+/** Interface to C language function: <br> <code> GLint gluUnProject(GLdouble winX, GLdouble winY, GLdouble winZ, const GLdouble *  model, const GLdouble *  proj, const GLint *  view, GLdouble *  objX, GLdouble *  objY, GLdouble *  objZ); </code>
+ * <P> Accepts the outgoing object coordinates (a 3-vector) as a single array.
+ */
+public final boolean gluUnProject(double winX, double winY, double winZ, double[] model, int model_offset, double[] proj, int proj_offset, int[] view, int view_offset, double[] objPos, int objPos_offset) {
+  return project.gluUnProject(winX, winY, winZ, model, model_offset, proj, proj_offset, view, view_offset, objPos, objPos_offset);
+}
+
+/** Interface to C language function: <br> <code> GLint gluUnProject(GLdouble winX, GLdouble winY, GLdouble winZ, const GLdouble *  model, const GLdouble *  proj, const GLint *  view, GLdouble *  objX, GLdouble *  objY, GLdouble *  objZ); </code>
+ * <P> Accepts the outgoing object coordinates (a 3-vector) as a single buffer.
+ */
+public final boolean gluUnProject(double winX, double winY, double winZ, DoubleBuffer model, DoubleBuffer proj, IntBuffer view, DoubleBuffer objPos) {
+  return project.gluUnProject(winX, winY, winZ, model, proj, view, objPos);
+}
+
+/** Interface to C language function: <br> <code> GLint gluUnProject4(GLdouble winX, GLdouble winY, GLdouble winZ, GLdouble clipW, const GLdouble *  model, const GLdouble *  proj, const GLint *  view, GLdouble nearVal, GLdouble farVal, GLdouble *  objX, GLdouble *  objY, GLdouble *  objZ, GLdouble *  objW); </code>
+ * <P> Accepts the outgoing object coordinates (a 4-vector) as a single array.
+ */
+public final boolean gluUnProject4(double winX, double winY, double winZ, double clipW, double[] model, int model_offset, double[] proj, int proj_offset, int[] view, int view_offset, double nearVal, double farVal, double[] objPos, int objPos_offset) {
+  return project.gluUnProject4(winX, winY, winZ, clipW, model, model_offset, proj, proj_offset, view, view_offset, nearVal, farVal, objPos, objPos_offset);
+}
+
+/** Interface to C language function: <br> <code> GLint gluUnProject4(GLdouble winX, GLdouble winY, GLdouble winZ, GLdouble clipW, const GLdouble *  model, const GLdouble *  proj, const GLint *  view, GLdouble nearVal, GLdouble farVal, GLdouble *  objX, GLdouble *  objY, GLdouble *  objZ, GLdouble *  objW); </code>
+ * <P> Accepts the outgoing object coordinates (a 4-vector) as a single buffer.
+ */
+public final boolean gluUnProject4(double winX, double winY, double winZ, double clipW, DoubleBuffer model, DoubleBuffer proj, IntBuffer view, double nearVal, double farVal, DoubleBuffer objPos) {
+  return project.gluUnProject4(winX, winY, winZ, clipW, model, proj, view, nearVal, farVal, objPos);
+}
+
+public final void gluPickMatrix(double x, double y, double delX, double delY, int[] viewport, int viewport_offset) {
+  project.gluPickMatrix(getCurrentGL2(), x, y, delX, delY, viewport, viewport_offset);
+}
+
+public final void gluPickMatrix(double x, double y, double delX, double delY, IntBuffer viewport) {
+  project.gluPickMatrix(getCurrentGL2(), x, y, delX, delY, viewport);
+}
+
+//----------------------------------------------------------------------
+// Mipmap and image scaling functionality
+
+
+private final ByteBuffer copyToByteBuffer(Buffer buf) {
+  if (buf instanceof ByteBuffer) {
+    if (buf.position() == 0) {
+      return (ByteBuffer) buf;
+    }
+    return InternalBufferUtil.copyByteBuffer((ByteBuffer) buf);
+  } else if (buf instanceof ShortBuffer) {
+    return InternalBufferUtil.copyShortBufferAsByteBuffer((ShortBuffer) buf);
+  } else if (buf instanceof IntBuffer) {
+    return InternalBufferUtil.copyIntBufferAsByteBuffer((IntBuffer) buf);
+  } else if (buf instanceof FloatBuffer) {
+    return InternalBufferUtil.copyFloatBufferAsByteBuffer((FloatBuffer) buf);
+  } else {
+    throw new IllegalArgumentException("Unsupported buffer type (must be one of byte, short, int, or float)");
+  }
+}
+
+private final int gluScaleImageJava( int format, int widthin, int heightin,
+                               int typein, Buffer datain, int widthout, int heightout,
+                               int typeout, Buffer dataout ) {
+  ByteBuffer in = null;
+  ByteBuffer out = null;
+  in = copyToByteBuffer(datain);
+  if( dataout instanceof ByteBuffer ) {
+    out = (ByteBuffer)dataout;
+  } else if( dataout instanceof ShortBuffer ) {
+    out = InternalBufferUtil.newByteBuffer(dataout.remaining() * InternalBufferUtil.SIZEOF_SHORT);
+  } else if ( dataout instanceof IntBuffer ) {
+    out = InternalBufferUtil.newByteBuffer(dataout.remaining() * InternalBufferUtil.SIZEOF_INT);
+  } else if ( dataout instanceof FloatBuffer ) {
+    out = InternalBufferUtil.newByteBuffer(dataout.remaining() * InternalBufferUtil.SIZEOF_FLOAT);
+  } else {
+    throw new IllegalArgumentException("Unsupported destination buffer type (must be byte, short, int, or float)");
+  }
+  int errno = Mipmap.gluScaleImage( getCurrentGL2(), format, widthin, heightin, typein, in, 
+            widthout, heightout, typeout, out );
+  if( errno == 0 ) {
+    out.rewind();
+    if (out != dataout) {
+      if( dataout instanceof ShortBuffer ) {
+        ((ShortBuffer) dataout).put(out.asShortBuffer());
+      } else if( dataout instanceof IntBuffer ) {
+        ((IntBuffer) dataout).put(out.asIntBuffer());
+      } else if( dataout instanceof FloatBuffer ) {
+        ((FloatBuffer) dataout).put(out.asFloatBuffer());
+      } else {
+        throw new RuntimeException("Should not reach here");
+      }
+    }
+  }
+  return( errno );
+}
+
+
+private final int gluBuild1DMipmapLevelsJava( int target, int internalFormat, int width,
+                                        int format, int type, int userLevel, int baseLevel, int maxLevel,
+                                        Buffer data ) {
+  ByteBuffer buffer = copyToByteBuffer(data);
+  return( Mipmap.gluBuild1DMipmapLevels( getCurrentGL2(), target, internalFormat, width,
+          format, type, userLevel, baseLevel, maxLevel, buffer ) );
+}
+
+
+private final int gluBuild1DMipmapsJava( int target, int internalFormat, int width,
+                                   int format, int type, Buffer data ) {
+  ByteBuffer buffer = copyToByteBuffer(data);
+  return( Mipmap.gluBuild1DMipmaps( getCurrentGL2(), target, internalFormat, width, format,
+          type, buffer ) );
+}
+
+
+private final int gluBuild2DMipmapLevelsJava( int target, int internalFormat, int width,
+                                        int height, int format, int type, int userLevel, int baseLevel,
+                                        int maxLevel, Buffer data ) {
+  // While the code below handles other data types, it doesn't handle non-ByteBuffers
+  data = copyToByteBuffer(data);
+  return( Mipmap.gluBuild2DMipmapLevels( getCurrentGL2(), target, internalFormat, width,
+          height, format, type, userLevel, baseLevel, maxLevel, data ) );
+}
+
+private final int gluBuild2DMipmapsJava( int target, int internalFormat, int width,
+                                   int height, int format, int type, Buffer data ) {
+  // While the code below handles other data types, it doesn't handle non-ByteBuffers
+  data = copyToByteBuffer(data);
+  return( Mipmap.gluBuild2DMipmaps( getCurrentGL2(), target, internalFormat, width, height,
+          format, type, data) );
+}
+
+private final int gluBuild3DMipmapLevelsJava( int target, int internalFormat, int width,
+                                        int height, int depth, int format, int type, int userLevel, int baseLevel,
+                                        int maxLevel, Buffer data) {
+  ByteBuffer buffer = copyToByteBuffer(data);
+  return( Mipmap.gluBuild3DMipmapLevels( getCurrentGL2(), target, internalFormat, width,
+          height, depth, format, type, userLevel, baseLevel, maxLevel, buffer) );
+}
+
+private final int gluBuild3DMipmapsJava( int target, int internalFormat, int width,
+                                   int height, int depth, int format, int type, Buffer data ) {
+  ByteBuffer buffer = copyToByteBuffer(data);
+  return( Mipmap.gluBuild3DMipmaps( getCurrentGL2(), target, internalFormat, width, height,
+          depth, format, type, buffer ) );
+}
+
+
+//----------------------------------------------------------------------
+// Wrappers for mipmap and image scaling entry points which dispatch either
+// to the Java or C versions.
+//
+
+/** Interface to C language function: <br> <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void *  data); </code>    */
+public final int gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, java.nio.Buffer data) {
+  if (useJavaMipmapCode) {
+    return gluBuild1DMipmapLevelsJava(target, internalFormat, width, format, type, level, base, max, data);
+  } else {
+    return gluBuild1DMipmapLevelsC(target, internalFormat, width, format, type, level, base, max, data);
+  }
+}
+
+/** Interface to C language function: <br> <code> GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void *  data); </code>    */
+public final int gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, java.nio.Buffer data) {
+  if (useJavaMipmapCode) {
+    return gluBuild1DMipmapsJava(target, internalFormat, width, format, type, data);
+  } else {
+    return gluBuild1DMipmapsC(target, internalFormat, width, format, type, data);
+  }
+}
+
+/** Interface to C language function: <br> <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void *  data); </code>    */
+public final int gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, java.nio.Buffer data) {
+  if (useJavaMipmapCode) {
+    return gluBuild2DMipmapLevelsJava(target, internalFormat, width, height, format, type, level, base, max, data);
+  } else {
+    return gluBuild2DMipmapLevelsC(target, internalFormat, width, height, format, type, level, base, max, data);
+  }
+}
+
+
+/** Interface to C language function: <br> <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *  data); </code>    */
+public final int gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, java.nio.Buffer data) {
+  if (useJavaMipmapCode) {
+    return gluBuild2DMipmapsJava(target, internalFormat, width, height, format, type, data);
+  } else {
+    return gluBuild2DMipmapsC(target, internalFormat, width, height, format, type, data);
+  }
+}
+
+
+/** Interface to C language function: <br> <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void *  data); </code>    */
+public final int gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, java.nio.Buffer data) {
+  if (useJavaMipmapCode) {
+    return gluBuild3DMipmapLevelsJava(target, internalFormat, width, height, depth, format, type, level, base, max, data);
+  } else {
+    return gluBuild3DMipmapLevelsC(target, internalFormat, width, height, depth, format, type, level, base, max, data);
+  }
+}
+
+/** Interface to C language function: <br> <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *  data); </code>    */
+public final int gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, java.nio.Buffer data) {
+  if (useJavaMipmapCode) {
+    return gluBuild3DMipmapsJava(target, internalFormat, width, height, depth, format, type, data);
+  } else {
+    return gluBuild3DMipmapsC(target, internalFormat, width, height, depth, format, type, data);
+  }
+}
+
+
+/** Interface to C language function: <br> <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void *  dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid *  dataOut); </code>    */
+public final int gluScaleImage(int format, int wIn, int hIn, int typeIn, java.nio.Buffer dataIn, int wOut, int hOut, int typeOut, java.nio.Buffer dataOut) {
+  if (useJavaMipmapCode) {
+    return gluScaleImageJava(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut);
+  } else {
+    return gluScaleImageC(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut);
+  }
+}
+
+//----------------------------------------------------------------------
+// NURBS functionality
+//
+
+/**
+ * Sets a property on a NURBS object. (NOTE: this function is not currently implemented.)
+ * 
+ * @param r
+ *            GLUnurbs object holding NURBS to which a property should be
+ *            set
+ * @param property
+ *            property id
+ * @param value
+ *            property value
+ */
+public final void gluNurbsProperty(GLUnurbs r, int property, float value) {
+  // TODO glunurbsproperty
+  float nurbsValue;
+  switch (property) {
+  default:
+    //				System.out.println("TODO gluwnurbs.glunurbsproperty");
+    break;
+  }
+}
+
+/**
+ * Creates a new GLUnurbs object.
+ * 
+ * @return GLUnurbs object
+ */
+public final GLUnurbs gluNewNurbsRenderer() {
+  // DONE
+  return new GLUgl2nurbsImpl();
+}
+
+/**
+ * Begins a curve definition.
+ * 
+ * @param r
+ *            GLUnurbs object to specify curve to
+ */
+public final void gluBeginCurve(GLUnurbs r) {
+  // DONE
+  ((GLUgl2nurbsImpl) r).bgncurve();
+}
+
+/**
+ * Begins a surface definition.
+ * 
+ * @param r
+ *            GLUnurbs object to specify surface to
+ */
+public final void gluBeginSurface(GLUnurbs r) {
+  // DONE
+  ((GLUgl2nurbsImpl) r).bgnsurface();
+}
+
+/**
+ * Ends a surface.
+ * 
+ * @param r
+ *            GLUnurbs object holding surface
+ */
+public final void gluEndSurface(GLUnurbs r) {
+  // DONE
+  ((GLUgl2nurbsImpl) r).endsurface();
+}
+
+/**
+ * Makes a NURBS surface.
+ * 
+ * @param r
+ *            GLUnurbs object holding the surface
+ * @param sknot_count
+ *            number of knots in s direction
+ * @param sknot
+ *            knots in s direction
+ * @param tknot_count
+ *            number of knots in t direction
+ * @param tknot
+ *            knots in t direction
+ * @param s_stride
+ *            number of control points coordinates in s direction
+ * @param t_stride
+ *            number of control points coordinates in t direction
+ * @param ctlarray
+ *            control points
+ * @param sorder
+ *            order of surface in s direction
+ * @param torder
+ *            order of surface in t direction
+ * @param type
+ *            surface type
+ */
+public final void gluNurbsSurface(GLUnurbs r, 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
+  ((GLUgl2nurbsImpl) r).nurbssurface(sknot_count, sknot, tknot_count, tknot, s_stride,
+                                  t_stride, ctlarray, sorder, torder, type);
+}
+
+/**
+ * Make a NURBS curve.
+ * 
+ * @param r
+ *            GLUnurbs object holding the curve
+ * @param nknots
+ *            number of knots
+ * @param knot
+ *            knot vector
+ * @param stride
+ *            number of control point coordinates
+ * @param ctlarray
+ *            control points
+ * @param order
+ *            order of the curve
+ * @param type
+ *            curve type
+ */
+public final void gluNurbsCurve(GLUnurbs r, int nknots, float[] knot, int stride,
+                          float[] ctlarray, int order, int type) {
+  int realType;
+  switch (type) {
+    // TODO GLU_MAP1_TRIM_2 etc.
+  default:
+    realType = type;
+    break;
+  }
+  ((GLUgl2nurbsImpl) r).nurbscurve(nknots, knot, stride, ctlarray, order, realType);
+}
+
+/**
+ * Ends a curve definition.
+ * 
+ * @param r
+ *            GLUnurbs object holding the curve
+ */
+public final void gluEndCurve(GLUnurbs r) {
+  //DONE
+  ((GLUgl2nurbsImpl) r).endcurve();
+}
+
+//----------------------------------------------------------------------
+// GLUProcAddressTable handling
+//
+
+private static GLUgl2ProcAddressTable gluProcAddressTable;
+private static volatile boolean gluLibraryLoaded;
+
+private static final GLUgl2ProcAddressTable getGLUProcAddressTable() {
+  if (!gluLibraryLoaded) {
+    loadGLULibrary();
+  }
+  if (gluProcAddressTable == null) {
+    GLContext curContext = GLContext.getCurrent();
+    if (curContext == null) {
+        throw new GLException("No OpenGL context current on this thread");
+    }
+    GLUgl2ProcAddressTable tmp = new GLUgl2ProcAddressTable();
+    GLProcAddressHelper.resetProcAddressTable(tmp, ((GLDrawableImpl)curContext.getGLDrawable()).getDynamicLookupHelper());
+    gluProcAddressTable = tmp;
+  }
+  return gluProcAddressTable;
+}
+
+private static final synchronized void loadGLULibrary() {
+  if (!gluLibraryLoaded) {
+    GLDrawableFactoryImpl.getFactoryImpl(null).loadGLULibrary();
+    gluLibraryLoaded = true;
+  }
+}
diff --git a/make/config/jogl/glu-CustomJavaCode-gl2es1.java b/make/config/jogl/glu-CustomJavaCode-gl2es1.java
new file mode 100755
index 000000000..8afc28c15
--- /dev/null
+++ b/make/config/jogl/glu-CustomJavaCode-gl2es1.java
@@ -0,0 +1,254 @@
+/*
+private static boolean useJavaMipmapCode = true;
+
+static {
+  AccessController.doPrivileged(new PrivilegedAction() {
+      public Object run() {
+        String val = System.getProperty("jogl.glu.nojava");
+        if (val != null && !val.toLowerCase().equals("false")) {
+          useJavaMipmapCode = false;
+        }
+        return null;
+      }
+    });
+}
+*/
+
+/**
+ * Instantiates a new OpenGL Utility Library object. A GLU object may
+ * be instantiated at any point in the application and is not
+ * inherently tied to any particular OpenGL context; however, the GLU
+ * object may only be used when an OpenGL context is current on the
+ * current thread. Attempts to call most of the methods in the GLU
+ * library when no OpenGL context is current will cause an exception
+ * to be thrown.
+ *
+ * <P>
+ *
+ * The returned GLU object is not guaranteed to be thread-safe and
+ * should only be used from one thread at a time. Multiple GLU objects
+ * may be instantiated to be used from different threads
+ * simultaneously.
+ */
+
+public GLUgl2es1()
+{
+  super();
+}
+
+public void destroy() {
+  super.destroy();
+}
+
+//----------------------------------------------------------------------
+// Utility routines
+//
+
+public static final GL2ES1 getCurrentGL2ES1() throws GLException {
+  GLContext curContext = GLContext.getCurrent();
+  if (curContext == null) {
+    throw new GLException("No OpenGL context current on this thread");
+  }
+  return curContext.getGL().getGL2ES1();
+}
+
+
+/*
+public String gluErrorString(int errorCode) {
+  return Error.gluErrorString(errorCode);
+}
+*/
+
+/* extName is an extension name.
+ * extString is a string of extensions separated by blank(s). There may or 
+ * may not be leading or trailing blank(s) in extString.
+ * This works in cases of extensions being prefixes of another like
+ * GL_EXT_texture and GL_EXT_texture3D.
+ * Returns true if extName is found otherwise it returns false.
+ */
+/*
+public boolean gluCheckExtension(java.lang.String extName, java.lang.String extString) {
+  return Registry.gluCheckExtension(extName, extString);
+}
+*/
+
+/*
+public String gluGetString(int name) {
+  return Registry.gluGetString(name);
+}
+*/
+
+//----------------------------------------------------------------------
+// Mipmap and image scaling functionality
+
+protected static boolean availableMipmap = false;
+protected static boolean checkedMipmap = false;
+
+protected static final void validateMipmap() {
+    if(!checkedMipmap) {
+        availableMipmap = NWReflection.isClassAvailable("com.sun.opengl.impl.glu.mipmap.Mipmap");
+        checkedMipmap = true;
+    }
+    if(!availableMipmap) {
+      throw new GLException("Mipmap not available");
+    }
+}
+
+private final java.nio.ByteBuffer copyToByteBuffer(java.nio.Buffer buf) {
+  if (buf instanceof java.nio.ByteBuffer) {
+    if (buf.position() == 0) {
+      return (java.nio.ByteBuffer) buf;
+    }
+    return InternalBufferUtil.copyByteBuffer((java.nio.ByteBuffer) buf);
+  } else if (buf instanceof java.nio.ShortBuffer) {
+    return InternalBufferUtil.copyShortBufferAsByteBuffer((java.nio.ShortBuffer) buf);
+  } else if (buf instanceof java.nio.IntBuffer) {
+    return InternalBufferUtil.copyIntBufferAsByteBuffer((java.nio.IntBuffer) buf);
+  } else if (buf instanceof java.nio.FloatBuffer) {
+    return InternalBufferUtil.copyFloatBufferAsByteBuffer((java.nio.FloatBuffer) buf);
+  } else {
+    throw new IllegalArgumentException("Unsupported buffer type (must be one of byte, short, int, or float)");
+  }
+}
+
+/**
+ * Optional, throws GLException if not available in profile
+ */
+public final int gluScaleImage( int format, int widthin, int heightin,
+                               int typein, java.nio.Buffer datain, int widthout, int heightout,
+                               int typeout, java.nio.Buffer dataout ) {
+  validateMipmap();
+  java.nio.ByteBuffer in = null;
+  java.nio.ByteBuffer out = null;
+  in = copyToByteBuffer(datain);
+  if( dataout instanceof java.nio.ByteBuffer ) {
+    out = (java.nio.ByteBuffer)dataout;
+  } else if( dataout instanceof java.nio.ShortBuffer ) {
+    out = InternalBufferUtil.newByteBuffer(dataout.remaining() * InternalBufferUtil.SIZEOF_SHORT);
+  } else if ( dataout instanceof java.nio.IntBuffer ) {
+    out = InternalBufferUtil.newByteBuffer(dataout.remaining() * InternalBufferUtil.SIZEOF_INT);
+  } else if ( dataout instanceof java.nio.FloatBuffer ) {
+    out = InternalBufferUtil.newByteBuffer(dataout.remaining() * InternalBufferUtil.SIZEOF_FLOAT);
+  } else {
+    throw new IllegalArgumentException("Unsupported destination buffer type (must be byte, short, int, or float)");
+  }
+  int errno = Mipmap.gluScaleImage( getCurrentGL2ES1(), format, widthin, heightin, typein, in, 
+            widthout, heightout, typeout, out );
+  if( errno == 0 ) {
+    out.rewind();
+    if (out != dataout) {
+      if( dataout instanceof java.nio.ShortBuffer ) {
+        ((java.nio.ShortBuffer) dataout).put(out.asShortBuffer());
+      } else if( dataout instanceof java.nio.IntBuffer ) {
+        ((java.nio.IntBuffer) dataout).put(out.asIntBuffer());
+      } else if( dataout instanceof java.nio.FloatBuffer ) {
+        ((java.nio.FloatBuffer) dataout).put(out.asFloatBuffer());
+      } else {
+        throw new RuntimeException("Should not reach here");
+      }
+    }
+  }
+  return( errno );
+}
+
+
+/**
+ * Optional, throws GLException if not available in profile
+ */
+public final int gluBuild1DMipmapLevels( int target, int internalFormat, int width,
+                                        int format, int type, int userLevel, int baseLevel, int maxLevel,
+                                        java.nio.Buffer data ) {
+  validateMipmap();
+  java.nio.ByteBuffer buffer = copyToByteBuffer(data);
+  return( Mipmap.gluBuild1DMipmapLevels( getCurrentGL2ES1(), target, internalFormat, width,
+          format, type, userLevel, baseLevel, maxLevel, buffer ) );
+}
+
+
+/**
+ * Optional, throws GLException if not available in profile
+ */
+public final int gluBuild1DMipmaps( int target, int internalFormat, int width,
+                                   int format, int type, java.nio.Buffer data ) {
+  validateMipmap();
+  java.nio.ByteBuffer buffer = copyToByteBuffer(data);
+  return( Mipmap.gluBuild1DMipmaps( getCurrentGL2ES1(), target, internalFormat, width, format,
+          type, buffer ) );
+}
+
+
+/**
+ * Optional, throws GLException if not available in profile
+ */
+public final int gluBuild2DMipmapLevels( int target, int internalFormat, int width,
+                                        int height, int format, int type, int userLevel, int baseLevel,
+                                        int maxLevel, java.nio.Buffer data ) {
+  validateMipmap();
+  // While the code below handles other data types, it doesn't handle non-ByteBuffers
+  data = copyToByteBuffer(data);
+  return( Mipmap.gluBuild2DMipmapLevels( getCurrentGL2ES1(), target, internalFormat, width,
+          height, format, type, userLevel, baseLevel, maxLevel, data ) );
+}
+
+/**
+ * Optional, throws GLException if not available in profile
+ */
+public final int gluBuild2DMipmaps( int target, int internalFormat, int width,
+                                   int height, int format, int type, java.nio.Buffer data ) {
+  validateMipmap();
+  // While the code below handles other data types, it doesn't handle non-ByteBuffers
+  data = copyToByteBuffer(data);
+  return( Mipmap.gluBuild2DMipmaps( getCurrentGL2ES1(), target, internalFormat, width, height,
+          format, type, data) );
+}
+
+/**
+ * Optional, throws GLException if not available in profile
+ */
+public final int gluBuild3DMipmapLevels( int target, int internalFormat, int width,
+                                        int height, int depth, int format, int type, int userLevel, int baseLevel,
+                                        int maxLevel, java.nio.Buffer data) {
+  validateMipmap();
+  java.nio.ByteBuffer buffer = copyToByteBuffer(data);
+  return( Mipmap.gluBuild3DMipmapLevels( getCurrentGL2ES1(), target, internalFormat, width,
+          height, depth, format, type, userLevel, baseLevel, maxLevel, buffer) );
+}
+
+/**
+ * Optional, throws GLException if not available in profile
+ */
+public final int gluBuild3DMipmaps( int target, int internalFormat, int width,
+                                   int height, int depth, int format, int type, java.nio.Buffer data ) {
+  validateMipmap();
+  java.nio.ByteBuffer buffer = copyToByteBuffer(data);
+  return( Mipmap.gluBuild3DMipmaps( getCurrentGL2ES1(), target, internalFormat, width, height,
+          depth, format, type, buffer ) );
+}
+
+//----------------------------------------------------------------------
+// GLUProcAddressTable handling
+//
+
+/*
+private static GLUProcAddressTable gluProcAddressTable;
+private static volatile boolean gluLibraryLoaded;
+
+private static GLUProcAddressTable getGLUProcAddressTable() {
+  if (!gluLibraryLoaded) {
+    loadGLULibrary();
+  }
+  if (gluProcAddressTable == null) {
+    GLUProcAddressTable tmp = new GLUProcAddressTable();
+    GLProcAddressHelper.resetProcAddressTable(tmp, GLDrawableFactoryImpl.getFactoryImpl());
+    gluProcAddressTable = tmp;
+  }
+  return gluProcAddressTable;
+}
+
+private static synchronized void loadGLULibrary() {
+  if (!gluLibraryLoaded) {
+    GLDrawableFactoryImpl.getFactoryImpl().loadGLULibrary();
+    gluLibraryLoaded = true;
+  }
+}
+*/
diff --git a/make/config/jogl/glu-base.cfg b/make/config/jogl/glu-base.cfg
new file mode 100755
index 000000000..f67673a78
--- /dev/null
+++ b/make/config/jogl/glu-base.cfg
@@ -0,0 +1,28 @@
+# This .cfg file is used to generate the GLU implementation for OpenGL ES 1.0,
+# where it is pure Java.
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/jogl
+
+Style ImplOnly
+ImplPackage javax.media.opengl.glu
+ImplJavaClass GLU
+AccessControl GLU PUBLIC
+
+Ignore gluBuild1DMipmapLevels
+Ignore gluBuild1DMipmaps
+Ignore gluBuild2DMipmapLevels
+Ignore gluBuild2DMipmaps
+Ignore gluBuild3DMipmapLevels
+Ignore gluBuild3DMipmaps
+Ignore gluScaleImage
+
+# Custom Java code for GLU class
+IncludeAs CustomJavaCode GLU glu-CustomJavaCode-base.java
+
+# Imports for the Error and Registry classes
+Import com.sun.opengl.impl.glu.error.Error
+Import com.sun.opengl.impl.glu.registry.Registry
+
+Include glu-common.cfg
+
+Import java.lang.reflect.*
diff --git a/make/config/jogl/glu-common.cfg b/make/config/jogl/glu-common.cfg
new file mode 100644
index 000000000..3b5a1160a
--- /dev/null
+++ b/make/config/jogl/glu-common.cfg
@@ -0,0 +1,177 @@
+# This .cfg file provides common options used among all GLU glue code
+HierarchicalNativeOutput false
+
+# Pick up on-line OpenGL javadoc thanks to user cylab on javagaming.org forums
+TagNativeBinding true
+
+#
+# Imports needed by all glue code
+#
+Import java.nio.*
+Import javax.media.opengl.*
+Import javax.media.opengl.glu.*
+Import com.sun.opengl.impl.*
+Import com.sun.opengl.impl.glu.*
+Import com.sun.opengl.impl.glu.tessellator.GLUtessellatorImpl
+Import com.sun.nativewindow.impl.NWReflection
+
+# Raise GLException instead of RuntimeException in glue code
+RuntimeExceptionType GLException
+UnsupportedExceptionType GLException
+
+#
+# Opaques and other directives for platform-independent routines
+#
+
+Opaque boolean GLboolean
+Opaque boolean BOOL
+
+#
+# Don't output #defines of GLU version identifier strings as constants, 
+# because we don't need them java-side. 
+#
+Ignore GLU_VERSION_.+
+
+#
+# Ignore the non-GLU functions 
+#
+Ignore gl[^u].+
+
+#
+# Ignore the non-GLU constants
+#
+Ignore GL[^U]?_.+
+
+#
+# Ignore the GLU extension constants, since we don't need them java-side
+#
+Ignore GLU_EXT_.+
+
+# Javadoc for the GLU class
+ClassJavadoc GLU /**
+ClassJavadoc GLU  * Provides access to the OpenGL Utility Library (GLU). This library
+ClassJavadoc GLU  * provides standard methods for setting up view volumes, building
+ClassJavadoc GLU  * mipmaps and performing other common operations.  The GLU NURBS
+ClassJavadoc GLU  * routines are not currently exposed.
+ClassJavadoc GLU  * 
+ClassJavadoc GLU  * <P>
+ClassJavadoc GLU  *
+ClassJavadoc GLU  * Notes from the Reference Implementation for this class:
+ClassJavadoc GLU  * Thanks to the contributions of many individuals, this class is a
+ClassJavadoc GLU  * pure Java port of SGI's original C sources. All of the projection,
+ClassJavadoc GLU  * mipmap, scaling, and tessellation routines that are exposed are
+ClassJavadoc GLU  * compatible with the GLU 1.3 specification. The GLU NURBS routines
+ClassJavadoc GLU  * are not currently exposed.
+ClassJavadoc GLU  */
+
+#
+# We ignore most of the function declarations in glu.h because we
+# provide a pure Java implementation of most of GLU. Currently the
+# only reason we generate glue code for this class is to provide a
+# fallback path to the C code for the mipmap routines in case of bugs
+# with the Java port (although it has been pretty thoroughly debugged
+# at this point).
+# 
+
+#
+# ------------------------
+#    Utility routines
+# ------------------------
+#
+
+# These are implemented by pure Java
+Ignore gluCheckExtension
+Ignore gluErrorString
+Ignore gluGetString
+
+#
+# ------------------------
+#         NURBS
+# ------------------------
+#
+
+#
+# !!!!!!!!!!!!! FIXME:
+# Ignore these Nurbs things until we get other stuff working
+#
+Ignore gluBeginCurve
+Ignore gluBeginSurface
+Ignore gluBeginTrim
+Ignore gluEndCurve
+Ignore gluEndSurface
+Ignore gluEndTrim
+Ignore gluLoadSamplingMatrices
+Ignore gluPwlCurve
+Ignore gluNewNurbsRenderer
+Ignore gluDeleteNurbsRenderer
+Ignore gluNurbsProperty
+Ignore gluGetNurbsProperty
+Ignore gluNurbsCallback.*
+Ignore gluNurbsCurve
+Ignore gluNurbsSurface
+Ignore GLU_NURB.+
+Ignore GLU_.*PARAMETRIC.+
+Ignore GLUnurbs
+
+#
+# ------------------------
+#     Tesselators
+# ------------------------
+#
+
+#
+# Ignore these methods; we must manually implement their C and Java code
+#
+Ignore gluBeginPolygon
+Ignore gluTessCallback
+Ignore gluDeleteTess
+Ignore gluEndPolygon
+Ignore gluGetTessProperty
+Ignore gluNewTess
+Ignore gluNextContour
+Ignore gluTessBeginContour
+Ignore gluTessBeginPolygon
+Ignore gluTessEndContour
+Ignore gluTessEndPolygon
+Ignore gluTessNormal
+Ignore gluTessProperty
+Ignore gluTessVertex
+Ignore gluTessCallback.*
+Ignore GLUtesselator
+
+#
+# ------------------------
+#     Quadrics
+# ------------------------
+#
+#
+# !!!!!!!!!!!!! FIXME:
+# Ignore these Quadric things until we get other stuff working
+#
+Ignore gluQuadricCallback.*
+
+# Manually implement the GLU quadric functionality to mostly conform
+# to the C APIs
+Ignore GLUquadric
+Ignore gluCylinder
+Ignore gluDeleteQuadric
+Ignore gluDisk
+Ignore gluNewQuadric
+Ignore gluPartialDisk
+Ignore gluQuadricDrawStyle
+Ignore gluQuadricNormals
+Ignore gluQuadricOrientation
+Ignore gluQuadricTexture
+Ignore gluSphere
+
+# Ignore a few of the projection/unprojection APIs altogether because
+# their signatures aren't specified correctly in the header file
+Ignore gluProject
+Ignore gluUnProject
+Ignore gluUnProject4
+
+# Manually implement the rest of the projection / unprojection APIs
+Ignore gluOrtho2D
+Ignore gluPerspective
+Ignore gluLookAt
+Ignore gluPickMatrix
diff --git a/make/config/jogl/glu-gl2.cfg b/make/config/jogl/glu-gl2.cfg
new file mode 100755
index 000000000..712f9a305
--- /dev/null
+++ b/make/config/jogl/glu-gl2.cfg
@@ -0,0 +1,80 @@
+# This .cfg file provides common options used among gl2 GLU glue code
+# generated for Jogl on all platforms.
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/jogl/gl2
+
+Style ImplOnly
+ImplPackage javax.media.opengl.glu.gl2
+ImplJavaClass GLUgl2
+ParentClass GLUgl2 GLU
+
+CustomCCode #if defined(WIN32)
+CustomCCode   #define WIN32_LEAN_AND_MEAN
+CustomCCode   #include <windows.h>
+CustomCCode   #undef WIN32_LEAN_AND_MEAN
+CustomCCode 
+CustomCCode   #include <stddef.h>
+CustomCCode #elif defined(macosx)
+CustomCCode   #include <inttypes.h>
+CustomCCode   #include <jni.h>
+CustomCCode   #include </usr/include/machine/types.h>
+CustomCCode #elif defined(linux) || defined(__sun) || defined(__FreeBSD__) || defined(_HPUX)
+CustomCCode   #include <inttypes.h>
+CustomCCode #endif
+
+Include ../intptr.cfg
+
+EmitProcAddressTable true
+ProcAddressTablePackage   com.sun.opengl.impl.glu.gl2
+ProcAddressTableClassName GLUgl2ProcAddressTable
+GetProcAddressTableExpr   getGLUProcAddressTable()
+
+CustomCCode /* Include the OpenGL GLU header */
+CustomCCode #include <GL/glu.h>
+
+# Custom Java code for GLU class
+IncludeAs CustomJavaCode GLUgl2 glu-CustomJavaCode-gl2.java
+
+# GLU needs access to the GLUtesselatorImpl class for GLUtesselator,
+# to the Mipmap class for scaling and mipmap generation,
+# and to the nurbs.* package for the NURBS functionality
+Import com.sun.opengl.impl.glu.nurbs.*
+Import java.security.*
+Import com.sun.gluegen.runtime.opengl.GLProcAddressHelper
+Import com.sun.opengl.impl.glu.gl2.nurbs.*
+Import com.sun.opengl.impl.glu.mipmap.Mipmap
+Import com.sun.opengl.impl.glu.gl2.*
+Import javax.media.opengl.GL2
+Import com.sun.opengl.impl.gl2.ProjectDouble
+
+#
+# ------------------------
+#        Mipmape
+# ------------------------
+#
+# Ignore the C versions of the mipmap code in the public interface and
+# use GKW's Java port instead. The bindings to the C entry points are
+# still being left in for now, but only for debugging purposes and the
+# intent is to remove them in a future release.
+
+# Emit these entry points as private
+
+AccessControl gluBuild1DMipmapLevels PRIVATE
+AccessControl gluBuild1DMipmaps      PRIVATE
+AccessControl gluBuild2DMipmapLevels PRIVATE
+AccessControl gluBuild2DMipmaps      PRIVATE
+AccessControl gluBuild3DMipmapLevels PRIVATE
+AccessControl gluBuild3DMipmaps      PRIVATE
+AccessControl gluScaleImage          PRIVATE
+
+# Rename these methods in the implementing class
+
+RenameJavaMethod gluBuild1DMipmapLevels gluBuild1DMipmapLevelsC
+RenameJavaMethod gluBuild1DMipmaps      gluBuild1DMipmapsC
+RenameJavaMethod gluBuild2DMipmapLevels gluBuild2DMipmapLevelsC
+RenameJavaMethod gluBuild2DMipmaps      gluBuild2DMipmapsC
+RenameJavaMethod gluBuild3DMipmapLevels gluBuild3DMipmapLevelsC
+RenameJavaMethod gluBuild3DMipmaps      gluBuild3DMipmapsC
+RenameJavaMethod gluScaleImage          gluScaleImageC
+
+Include glu-common.cfg
diff --git a/make/config/jogl/glu-gl2es1.cfg b/make/config/jogl/glu-gl2es1.cfg
new file mode 100755
index 000000000..8927f96b9
--- /dev/null
+++ b/make/config/jogl/glu-gl2es1.cfg
@@ -0,0 +1,26 @@
+# This .cfg file is used to generate the GLU implementation for OpenGL ES 1.0,
+# where it is pure Java.
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/jogl/gl2es1
+
+Style ImplOnly
+ImplPackage javax.media.opengl.glu.gl2es1
+ImplJavaClass GLUgl2es1
+ParentClass GLUgl2es1 GLU
+
+Ignore gluBuild1DMipmapLevels
+Ignore gluBuild1DMipmaps
+Ignore gluBuild2DMipmapLevels
+Ignore gluBuild2DMipmaps
+Ignore gluBuild3DMipmapLevels
+Ignore gluBuild3DMipmaps
+Ignore gluScaleImage
+
+# Custom Java code for GLU class
+IncludeAs CustomJavaCode GLUgl2es1 glu-CustomJavaCode-gl2es1.java
+
+Import javax.media.opengl.GLES1
+Import com.sun.opengl.impl.glu.mipmap.Mipmap
+
+
+Include glu-common.cfg
diff --git a/make/config/jogl/glx-CustomCCode.c b/make/config/jogl/glx-CustomCCode.c
new file mode 100755
index 000000000..93347a174
--- /dev/null
+++ b/make/config/jogl/glx-CustomCCode.c
@@ -0,0 +1,151 @@
+#include <inttypes.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <GL/glx.h>
+/* Linux headers don't work properly */
+#define __USE_GNU
+#include <dlfcn.h>
+#undef __USE_GNU
+
+/* HP-UX doesn't define RTLD_DEFAULT. */
+#if defined(_HPUX) && !defined(RTLD_DEFAULT)
+#define RTLD_DEFAULT NULL
+#endif
+
+/* We expect glXGetProcAddressARB to be defined */
+extern void (*glXGetProcAddressARB(const GLubyte *procname))();
+
+static const char * clazzNameInternalBufferUtil = "com/sun/opengl/impl/InternalBufferUtil";
+static const char * clazzNameInternalBufferUtilStaticCstrName = "copyByteBuffer";
+static const char * clazzNameInternalBufferUtilStaticCstrSignature = "(Ljava/nio/ByteBuffer;)Ljava/nio/ByteBuffer;";
+static const char * clazzNameByteBuffer = "java/nio/ByteBuffer";
+static jclass clazzInternalBufferUtil = NULL;
+static jmethodID cstrInternalBufferUtil = NULL;
+static jclass clazzByteBuffer = NULL;
+
+static void _initClazzAccess(JNIEnv *env) {
+    if(NULL!=cstrInternalBufferUtil) return ;
+
+    jclass c = (*env)->FindClass(env, clazzNameInternalBufferUtil);
+    if(NULL==c) {
+        fprintf(stderr, "FatalError: Java_com_sun_opengl_impl_x11_glx_GLX: can't find %s\n", clazzNameInternalBufferUtil);
+        (*env)->FatalError(env, clazzNameInternalBufferUtil);
+    }
+    clazzInternalBufferUtil = (jclass)(*env)->NewGlobalRef(env, c);
+    if(NULL==clazzInternalBufferUtil) {
+        fprintf(stderr, "FatalError: Java_com_sun_opengl_impl_x11_glx_GLX: can't use %s\n", clazzNameInternalBufferUtil);
+        (*env)->FatalError(env, clazzNameInternalBufferUtil);
+    }
+    c = (*env)->FindClass(env, clazzNameByteBuffer);
+    if(NULL==c) {
+        fprintf(stderr, "FatalError: Java_com_sun_opengl_impl_x11_glx_GLX: can't find %s\n", clazzNameByteBuffer);
+        (*env)->FatalError(env, clazzNameByteBuffer);
+    }
+    clazzByteBuffer = (jclass)(*env)->NewGlobalRef(env, c);
+    if(NULL==c) {
+        fprintf(stderr, "FatalError: Java_com_sun_opengl_impl_x11_glx_GLX: can't use %s\n", clazzNameByteBuffer);
+        (*env)->FatalError(env, clazzNameByteBuffer);
+    }
+
+    cstrInternalBufferUtil = (*env)->GetStaticMethodID(env, clazzInternalBufferUtil, 
+                            clazzNameInternalBufferUtilStaticCstrName, clazzNameInternalBufferUtilStaticCstrSignature);
+    if(NULL==cstrInternalBufferUtil) {
+        fprintf(stderr, "FatalError: Java_com_sun_opengl_impl_x11_glx_GLX:: can't create %s.%s %s\n",
+            clazzNameInternalBufferUtil,
+            clazzNameInternalBufferUtilStaticCstrName, clazzNameInternalBufferUtilStaticCstrSignature);
+        (*env)->FatalError(env, clazzNameInternalBufferUtilStaticCstrName);
+    }
+}
+
+/*   Java->C glue code:
+ *   Java package: com.sun.opengl.impl.x11.glx.GLX
+ *    Java method: XVisualInfo glXGetVisualFromFBConfig(long dpy, long config)
+ *     C function: XVisualInfo *  glXGetVisualFromFBConfig(Display *  dpy, GLXFBConfig config);
+ */
+JNIEXPORT jobject JNICALL 
+Java_com_sun_opengl_impl_x11_glx_GLX_glXGetVisualFromFBConfigCopied0__JJ(JNIEnv *env, jclass _unused, jlong dpy, jlong config) {
+  XVisualInfo *  _res;
+  _res = glXGetVisualFromFBConfig((Display *) (intptr_t) dpy, (GLXFBConfig) (intptr_t) config);
+  if (_res == NULL) return NULL;
+
+  _initClazzAccess(env);
+
+  jobject jbyteSource = (*env)->NewDirectByteBuffer(env, _res, sizeof(XVisualInfo));
+  jobject jbyteCopy   = (*env)->CallStaticObjectMethod(env,
+                            clazzInternalBufferUtil, cstrInternalBufferUtil, jbyteSource);
+
+  // FIXME: remove reference/gc jbyteSource ?? 
+  XFree(_res);
+
+  return jbyteCopy;
+}
+
+/*   Java->C glue code:
+ *   Java package: com.sun.opengl.impl.x11.glx.GLX
+ *    Java method: java.nio.LongBuffer glXChooseFBConfig(long dpy, int screen, java.nio.IntBuffer attribList, java.nio.IntBuffer nitems)
+ *     C function: GLXFBConfig *  glXChooseFBConfig(Display *  dpy, int screen, const int *  attribList, int *  nitems);
+ */
+JNIEXPORT jobject JNICALL 
+Java_com_sun_opengl_impl_x11_glx_GLX_glXChooseFBConfigCopied1__JILjava_lang_Object_2ILjava_lang_Object_2I(JNIEnv *env, jclass _unused, jlong dpy, jint screen, jobject attribList, jint attribList_byte_offset, jobject nitems, jint nitems_byte_offset) {
+  int * _ptr2 = NULL;
+  int * _ptr3 = NULL;
+  GLXFBConfig *  _res;
+  int count;
+  if (attribList != NULL) {
+    _ptr2 = (int *) (((char*) (*env)->GetPrimitiveArrayCritical(env, attribList, NULL)) + attribList_byte_offset);
+  }
+  if (nitems != NULL) {
+    _ptr3 = (int *) (((char*) (*env)->GetPrimitiveArrayCritical(env, nitems, NULL)) + nitems_byte_offset);
+  }
+  _res = glXChooseFBConfig((Display *) (intptr_t) dpy, (int) screen, (int *) _ptr2, (int *) _ptr3);
+  count = _ptr3[0];
+  if (attribList != NULL) {
+    (*env)->ReleasePrimitiveArrayCritical(env, attribList, _ptr2, 0);
+  }
+  if (nitems != NULL) {
+    (*env)->ReleasePrimitiveArrayCritical(env, nitems, _ptr3, 0);
+  }
+  if (_res == NULL) return NULL;
+
+  _initClazzAccess(env);
+
+  jobject jbyteSource = (*env)->NewDirectByteBuffer(env, _res, count * sizeof(GLXFBConfig));
+  jobject jbyteCopy   = (*env)->CallStaticObjectMethod(env,
+                            clazzInternalBufferUtil, cstrInternalBufferUtil, jbyteSource);
+
+  // FIXME: remove reference/gc jbyteSource ?? 
+  XFree(_res);
+
+  return jbyteCopy;
+}
+
+/*   Java->C glue code:
+ *   Java package: com.sun.opengl.impl.x11.glx.GLX
+ *    Java method: XVisualInfo glXChooseVisual(long dpy, int screen, java.nio.IntBuffer attribList)
+ *     C function: XVisualInfo *  glXChooseVisual(Display *  dpy, int screen, int *  attribList);
+ */
+JNIEXPORT jobject JNICALL 
+Java_com_sun_opengl_impl_x11_glx_GLX_glXChooseVisualCopied1__JILjava_lang_Object_2I(JNIEnv *env, jclass _unused, jlong dpy, jint screen, jobject attribList, jint attribList_byte_offset) {
+  int * _ptr2 = NULL;
+  XVisualInfo *  _res;
+  if (attribList != NULL) {
+    _ptr2 = (int *) (((char*) (*env)->GetPrimitiveArrayCritical(env, attribList, NULL)) + attribList_byte_offset);
+  }
+  _res = glXChooseVisual((Display *) (intptr_t) dpy, (int) screen, (int *) _ptr2);
+  if (attribList != NULL) {
+    (*env)->ReleasePrimitiveArrayCritical(env, attribList, _ptr2, 0);
+  }
+  if (_res == NULL) return NULL;
+
+  _initClazzAccess(env);
+
+  jobject jbyteSource = (*env)->NewDirectByteBuffer(env, _res, sizeof(XVisualInfo));
+  jobject jbyteCopy   = (*env)->CallStaticObjectMethod(env,
+                            clazzInternalBufferUtil, cstrInternalBufferUtil, jbyteSource);
+
+  // FIXME: remove reference/gc jbyteSource ?? 
+  XFree(_res);
+
+  return jbyteCopy;
+}
+
diff --git a/make/config/jogl/glx-CustomJavaCode.java b/make/config/jogl/glx-CustomJavaCode.java
new file mode 100644
index 000000000..f59e71e41
--- /dev/null
+++ b/make/config/jogl/glx-CustomJavaCode.java
@@ -0,0 +1,46 @@
+
+  /** Interface to C language function: <br> - Alias for: <br> <code> XVisualInfo *  glXGetVisualFromFBConfigSGIX, glXGetVisualFromFBConfig(Display *  dpy, GLXFBConfig config); </code>    */
+  public static XVisualInfo glXGetVisualFromFBConfigCopied(long dpy, long config)
+  {
+    java.nio.ByteBuffer _res;
+    _res = glXGetVisualFromFBConfigCopied0(dpy, config);
+    if (_res == null) return null;
+    return XVisualInfo.create(_res);
+  }
+
+  /** Entry point to C language function: - Alias for: <br> <code> XVisualInfo *  glXGetVisualFromFBConfigSGIX, glXGetVisualFromFBConfig(Display *  dpy, GLXFBConfig config); </code>    */
+  private static native java.nio.ByteBuffer glXGetVisualFromFBConfigCopied0(long dpy, long config);
+
+
+  /** Interface to C language function: <br> - Alias for: <br> <code> GLXFBConfig *  glXChooseFBConfigSGIX, glXChooseFBConfig(Display *  dpy, int screen, const int *  attribList, int *  nitems); </code>    */
+  public static java.nio.LongBuffer glXChooseFBConfigCopied(long dpy, int screen, int[] attribList, int attribList_offset, int[] nitems, int nitems_offset)
+  {
+    if(attribList != null && attribList.length <= attribList_offset)
+      throw new GLException("array offset argument \"attribList_offset\" (" + attribList_offset + ") equals or exceeds array length (" + attribList.length + ")");
+    if(nitems != null && nitems.length <= nitems_offset)
+      throw new GLException("array offset argument \"nitems_offset\" (" + nitems_offset + ") equals or exceeds array length (" + nitems.length + ")");
+    java.nio.ByteBuffer _res;
+    _res = glXChooseFBConfigCopied1(dpy, screen, attribList, BufferFactory.SIZEOF_INT * attribList_offset, nitems, BufferFactory.SIZEOF_INT * nitems_offset);
+
+    if (_res == null) return null;
+    return BufferFactory.asPointerBuffer(_res);
+  }
+
+  /** Entry point to C language function: - Alias for: <br> <code> GLXFBConfig *  glXChooseFBConfigSGIX, glXChooseFBConfig(Display *  dpy, int screen, const int *  attribList, int *  nitems); </code>    */
+  private static native java.nio.ByteBuffer glXChooseFBConfigCopied1(long dpy, int screen, Object attribList, int attribList_byte_offset, Object nitems, int nitems_byte_offset);
+
+  /** Interface to C language function: <br> - Alias for: <br> <code> XVisualInfo *  glXChooseVisual(Display *  dpy, int screen, int *  attribList); </code>    */
+  public static XVisualInfo glXChooseVisualCopied(long dpy, int screen, int[] attribList, int attribList_offset)
+  {
+    if(attribList != null && attribList.length <= attribList_offset)
+      throw new GLException("array offset argument \"attribList_offset\" (" + attribList_offset + ") equals or exceeds array length (" + attribList.length + ")");
+    java.nio.ByteBuffer _res;
+    _res = glXChooseVisualCopied1(dpy, screen, attribList, BufferFactory.SIZEOF_INT * attribList_offset);
+
+    if (_res == null) return null;
+    return XVisualInfo.create(_res);
+  }
+
+  /** Entry point to C language function: - Alias for: <br> <code> XVisualInfo *  glXChooseVisual(Display *  dpy, int screen, int *  attribList); </code>    */
+  private static native java.nio.ByteBuffer glXChooseVisualCopied1(long dpy, int screen, Object attribList, int attribList_byte_offset);
+
diff --git a/make/config/jogl/glx-x11.cfg b/make/config/jogl/glx-x11.cfg
new file mode 100644
index 000000000..5511b339e
--- /dev/null
+++ b/make/config/jogl/glx-x11.cfg
@@ -0,0 +1,83 @@
+# This .cfg file is used to generate the interface to the GLX routines
+# used internally by the X11GLContext implementation.
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/jogl/X11
+
+Package com.sun.opengl.impl.x11.glx
+JavaClass GLX
+Style allstatic
+Include gl-common-gl2.cfg
+Include gl-common-extensions.cfg
+Include gl-desktop.cfg
+
+EmitProcAddressTable true
+ProcAddressTableClassName GLXProcAddressTable
+GetProcAddressTableExpr glxProcAddressTable
+# This must be present for bootstrapping
+SkipProcAddressGen glXGetProcAddressARB
+
+Import com.sun.nativewindow.impl.x11.*
+
+
+CustomJavaCode GLX private static GLXProcAddressTable glxProcAddressTable = new GLXProcAddressTable();
+CustomJavaCode GLX public  static GLXProcAddressTable getGLXProcAddressTable() { return glxProcAddressTable; }
+
+IncludeAs CustomJavaCode GLX glx-CustomJavaCode.java
+IncludeAs CustomCCode        glx-CustomCCode.c
+
+ArgumentIsString XOpenDisplay 0
+
+Opaque long GLXFBConfig
+
+Ignore glXCreateContextAttribsARB
+
+#
+# We have Custom code for the following
+Ignore glXGetVisualFromFBConfig
+Ignore glXGetVisualFromFBConfigSGIX
+Ignore glXChooseFBConfig
+Ignore glXChooseVisual
+
+# Ignore everything not in the GLX core (up through GLX 1.4) aside from glXGetProcAddress
+# FIXME: this needs to be kept in sync with the stub headers more than usual
+Ignore glXFreeContextEXT
+Ignore glXGetContextIDEXT
+Ignore glXGetCurrentDisplayEXT
+Ignore glXImportContextEXT
+Ignore glXQueryContextInfoEXT
+
+Ignore glXGetSyncValues
+Ignore glXGetMscRate
+Ignore glXSwapBuffersMsc
+Ignore glXWaitForMsc
+Ignore glXWaitForSbc
+
+# Ignore non-GLX GL routines and constants
+Ignore ^GL_.+
+Ignore TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB
+Ignore CLAMP_TO_EDGE_EXT
+Ignore ^gl[^X].+
+Ignore ^X.+
+Ignore ^Visual.+
+
+DropUniqVendorExtensions AMD
+# We need GL_APPLE_float_pixels for our pbuffer implementation
+# DropUniqVendorExtensions APPLE
+DropUniqVendorExtensions ATI
+DropUniqVendorExtensions HP
+DropUniqVendorExtensions IBM
+DropUniqVendorExtensions MESA
+DropUniqVendorExtensions MESAX
+DropUniqVendorExtensions NV
+DropUniqVendorExtensions SGI
+DropUniqVendorExtensions SGIS
+DropUniqVendorExtensions SGIX
+DropUniqVendorExtensions SUN
+DropUniqVendorExtensions WIN
+
+# Ignore the SGI hyperpipe extension, which will require more GlueGen
+# work to expose the pipeName fields in the various structs
+Ignore GLXHyperpipeNetworkSGIX
+Ignore GLXHyperpipeConfigSGIX
+Ignore GLXPipeRect
+Ignore GLXPipeRectLimits
diff --git a/make/config/jogl/glxext.cfg b/make/config/jogl/glxext.cfg
new file mode 100755
index 000000000..b1b8fe65a
--- /dev/null
+++ b/make/config/jogl/glxext.cfg
@@ -0,0 +1,132 @@
+# This .cfg file is used to generate the interface and implementing
+# class for the GLX extensions.
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/jogl/X11
+
+Package com.sun.opengl.impl.x11.glx
+Style InterfaceAndImpl
+JavaClass GLXExt
+ImplPackage com.sun.opengl.impl.x11.glx
+ImplJavaClass GLXExtImpl
+
+ExtendedInterfaceSymbols ../build-temp/gensrc/classes/com/sun/opengl/impl/x11/glx/GLX.java
+Include gl-common-gl2.cfg
+Include gl-desktop.cfg
+
+EmitProcAddressTable true
+ProcAddressTableClassName GLXExtProcAddressTable
+GetProcAddressTableExpr _context.getGLXExtProcAddressTable()
+
+Import com.sun.nativewindow.impl.x11.*
+
+# Ignore everything that doesn't start with glX or GLX
+IgnoreNot ^(glX|GLX).+
+
+Include gl-headers.cfg
+Include ../intptr.cfg
+
+CustomCCode /* Provide Windows typedefs */
+CustomCCode typedef void* LPVOID;
+CustomCCode typedef unsigned int* PUINT;
+
+CustomJavaCode GLXExt      public boolean isFunctionAvailable(String glFunctionName);
+CustomJavaCode GLXExt      public boolean isExtensionAvailable(String glExtensionName);
+
+CustomJavaCode GLXExtImpl  public GLXExtImpl(X11GLXContext context) {
+CustomJavaCode GLXExtImpl    this._context = context; 
+CustomJavaCode GLXExtImpl  }
+
+CustomJavaCode GLXExtImpl  public boolean isFunctionAvailable(String glFunctionName)
+CustomJavaCode GLXExtImpl  {
+CustomJavaCode GLXExtImpl    return _context.isFunctionAvailable(glFunctionName);
+CustomJavaCode GLXExtImpl  }
+
+CustomJavaCode GLXExtImpl  public boolean isExtensionAvailable(String glExtensionName)
+CustomJavaCode GLXExtImpl  {
+CustomJavaCode GLXExtImpl    return _context.isExtensionAvailable(glExtensionName);
+CustomJavaCode GLXExtImpl  }
+
+CustomJavaCode GLXExtImpl  private X11GLXContext _context;
+
+
+# These Ignores cause the core GLX routines to be ignored from the
+# GLXExt interface and GLXExtImpl implementing class.
+Ignore glXGetVisualFromFBConfig
+Ignore glXGetVisualFromFBConfigSGIX
+Ignore glXChooseFBConfig
+Ignore glXChooseVisual
+Ignore glXCreateContext
+Ignore glXDestroyContext
+Ignore glXMakeCurrent
+Ignore glXCopyContext
+Ignore glXSwapBuffers
+Ignore glXCreateGLXPixmap
+Ignore glXDestroyGLXPixmap
+Ignore glXQueryExtension
+Ignore glXQueryVersion
+Ignore glXIsDirect
+Ignore glXGetConfig
+Ignore glXGetCurrentContext
+Ignore glXGetCurrentDrawable
+Ignore glXWaitGL
+Ignore glXWaitX
+Ignore glXUseXFont
+Ignore glXQueryExtensionsString
+Ignore glXQueryServerString
+Ignore glXGetClientString
+Ignore glXGetCurrentDisplay
+Ignore glXChooseFBConfig
+Ignore glXGetFBConfigAttrib
+Ignore glXGetFBConfigs
+Ignore glXGetVisualFromFBConfig
+Ignore glXCreateWindow
+Ignore glXDestroyWindow
+Ignore glXCreatePixmap
+Ignore glXDestroyPixmap
+Ignore glXCreatePbuffer
+Ignore glXDestroyPbuffer
+Ignore glXQueryDrawable
+Ignore glXCreateNewContext
+Ignore glXMakeContextCurrent
+Ignore glXGetCurrentReadDrawable
+Ignore glXQueryContext
+Ignore glXSelectEvent
+Ignore glXGetSelectedEvent
+Ignore glXGetProcAddress
+
+# Ignore a few extensions that bring in data types we don't want to
+# expose in the public API (and that are useless anyway without
+# exposing more of the implementation)
+Ignore glXGetFBConfigAttribSGIX
+Ignore glXChooseFBConfigSGIX
+Ignore glXCreateGLXPixmapWithConfigSGIX
+Ignore glXCreateContextWithConfigSGIX
+Ignore glXGetVisualFromFBConfigSGIX
+Ignore glXGetFBConfigFromVisualSGIX
+Ignore glXCreateGLXPbufferSGIX
+Ignore glXDestroyGLXPbufferSGIX
+Ignore glXQueryGLXPbufferSGIX
+Ignore glXSelectEventSGIX
+Ignore glXGetSelectedEventSGIX
+Ignore glXCreateGLXPixmapMESA
+
+Opaque long GLXFBConfig
+
+# Now we can ignore the GLXFBConfig and XVisualInfo data types
+# Ignore GLXFBConfig
+Ignore XVisualInfo
+
+# Ignore the SGI hyperpipe extension, which will require more GlueGen
+# work to expose the pipeName fields in the various structs
+Ignore glXQueryHyperpipeNetworkSGIX
+Ignore glXHyperpipeConfigSGIX
+Ignore glXQueryHyperpipeConfigSGIX
+Ignore glXDestroyHyperpipeConfigSGIX
+Ignore glXBindHyperpipeSGIX
+Ignore glXQueryHyperpipeBestAttribSGIX
+Ignore glXHyperpipeAttribSGIX
+Ignore glXQueryHyperpipeAttribSGIX
+Ignore GLXHyperpipeNetworkSGIX
+Ignore GLXHyperpipeConfigSGIX
+Ignore GLXPipeRect
+Ignore GLXPipeRectLimits
diff --git a/make/config/jogl/nsig.cfg b/make/config/jogl/nsig.cfg
new file mode 100755
index 000000000..404746cc3
--- /dev/null
+++ b/make/config/jogl/nsig.cfg
@@ -0,0 +1,22 @@
+# The NativeSignatureEmitter can not yet handle some constructs
+Ignore glColorPointerListIBM
+Ignore glColorPointervINTEL
+Ignore glEdgeFlagPointerListIBM
+Ignore glFogCoordPointerListIBM
+Ignore glIndexPointerListIBM
+Ignore glMultiDrawElements
+Ignore glMultiDrawElementsEXT
+Ignore glMultiModeDrawElementsIBM
+Ignore glNormalPointerListIBM
+Ignore glNormalPointervINTEL
+Ignore glReplacementCodePointerSUN
+Ignore glSecondaryColorPointerListIBM
+Ignore glTexCoordPointerListIBM
+Ignore glTexCoordPointervINTEL
+Ignore glVertexPointerListIBM
+Ignore glVertexPointervINTEL
+Ignore glShaderSource
+Ignore glShaderSourceARB
+Ignore glGetSeparableFilter
+Ignore glGetSeparableFilterEXT
+Ignore glGetShaderSourceARB
diff --git a/make/config/jogl/wgl-CustomCCode.c b/make/config/jogl/wgl-CustomCCode.c
new file mode 100755
index 000000000..0fe9ee628
--- /dev/null
+++ b/make/config/jogl/wgl-CustomCCode.c
@@ -0,0 +1,48 @@
+#include <stdio.h>
+
+#define JOGL_DUMMY_WINDOW_NAME "__jogl_dummy_window"
+
+LRESULT CALLBACK DummyWndProc( HWND   hWnd, UINT   uMsg, WPARAM wParam, LPARAM lParam) {
+  return DefWindowProc(hWnd,uMsg,wParam,lParam);
+}
+
+ATOM oglClass = 0;
+
+HWND CreateDummyWindow( int x, int y, int width, int height ) {
+  HINSTANCE hInstance;
+  DWORD     dwExStyle;
+  DWORD     dwStyle;
+  HWND      hWnd;
+
+  hInstance = GetModuleHandle(NULL);
+  if( !oglClass ) {
+    WNDCLASS  wc;
+    ZeroMemory( &wc, sizeof( wc ) );
+    wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
+    wc.lpfnWndProc = (WNDPROC) DummyWndProc;
+    wc.cbClsExtra = 0;
+    wc.cbWndExtra = 0;
+    wc.hInstance = hInstance;
+    wc.hIcon = NULL;
+    wc.hCursor = NULL;
+    wc.hbrBackground = NULL;
+    wc.lpszMenuName = NULL;
+    wc.lpszClassName = JOGL_DUMMY_WINDOW_NAME;
+    if( !(oglClass = RegisterClass( &wc )) ) {
+      printf( "RegisterClass Failed: %d\n", GetLastError() );
+      return( 0 );
+    }
+  }
+  
+  dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
+  dwStyle = WS_OVERLAPPEDWINDOW;
+  if( !(hWnd=CreateWindowEx( dwExStyle,
+                             JOGL_DUMMY_WINDOW_NAME,
+                             JOGL_DUMMY_WINDOW_NAME,
+                             dwStyle | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
+                             x, y, width, height,
+                             NULL, NULL, hInstance, NULL ) ) ) {
+    return( 0 );
+  }
+  return( hWnd );
+}
diff --git a/make/config/jogl/wgl-win32.cfg b/make/config/jogl/wgl-win32.cfg
new file mode 100644
index 000000000..f86f1adcc
--- /dev/null
+++ b/make/config/jogl/wgl-win32.cfg
@@ -0,0 +1,44 @@
+# This .cfg file is used to generate the interface to the wgl routines
+# used internally by the WindowsGLContext implementation.
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/jogl/Windows
+
+Package com.sun.opengl.impl.windows.wgl
+JavaClass WGL
+Style allstatic
+Include gl-common-gl2.cfg
+Include gl-common-extensions.cfg
+Include gl-desktop.cfg
+
+# Implement the first argument to wglGetProcAddress as String instead
+# of byte[]
+ArgumentIsString wglGetProcAddress 0
+ArgumentIsString LoadLibraryA 0
+ArgumentIsString GetProcAddress 1
+
+CustomCCode #define WIN32_LEAN_AND_MEAN
+CustomCCode #include <windows.h>
+CustomCCode #undef WIN32_LEAN_AND_MEAN
+
+CustomCCode #include <wingdi.h>
+CustomCCode #include <stddef.h>
+
+Include ../intptr.cfg
+
+IncludeAs CustomCCode wgl-CustomCCode.c
+
+DropUniqVendorExtensions AMD
+# We need GL_APPLE_float_pixels for our pbuffer implementation
+# DropUniqVendorExtensions APPLE
+DropUniqVendorExtensions ATI
+DropUniqVendorExtensions HP
+DropUniqVendorExtensions IBM
+DropUniqVendorExtensions MESA
+DropUniqVendorExtensions MESAX
+DropUniqVendorExtensions NV
+DropUniqVendorExtensions SGI
+DropUniqVendorExtensions SGIS
+DropUniqVendorExtensions SGIX
+DropUniqVendorExtensions SUN
+DropUniqVendorExtensions WIN
+
diff --git a/make/config/jogl/wglext.cfg b/make/config/jogl/wglext.cfg
new file mode 100644
index 000000000..af4430bbe
--- /dev/null
+++ b/make/config/jogl/wglext.cfg
@@ -0,0 +1,51 @@
+# This .cfg file is used to generate the interface and implementing
+# class for the WGL extensions.
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/jogl/Windows
+
+Package com.sun.opengl.impl.windows.wgl
+Style InterfaceAndImpl
+JavaClass WGLExt
+ImplPackage com.sun.opengl.impl.windows.wgl
+ImplJavaClass WGLExtImpl
+Include gl-common-gl2.cfg
+Include gl-desktop.cfg
+
+EmitProcAddressTable true
+ProcAddressTableClassName WGLExtProcAddressTable
+GetProcAddressTableExpr _context.getWGLExtProcAddressTable()
+
+# Ignore everything that doesn't start with wgl or WGL
+Ignore GL_.+
+Ignore gl.+
+
+Include gl-headers.cfg
+Include ../intptr.cfg
+
+# FIXME: for the time being, ignore all extensions requiring the
+# presence of java.nio.LongBuffer because it doesn't exist on CDC/FP +
+# JSR-239 NIO subset (remove once we have Java SE classes running on CVM)
+# Inform the glue code generator of the association between #defines
+# and functions and the extensions in which they are defined
+GLHeader GL/wglext.h
+IgnoreExtension WGL_OML_sync_control
+IgnoreExtension WGL_NV_gpu_affinity
+
+CustomJavaCode WGLExt      public boolean isFunctionAvailable(String glFunctionName);
+CustomJavaCode WGLExt      public boolean isExtensionAvailable(String glExtensionName);
+
+CustomJavaCode WGLExtImpl  public WGLExtImpl(WindowsWGLContext context) {
+CustomJavaCode WGLExtImpl    this._context = context; 
+CustomJavaCode WGLExtImpl  }
+
+CustomJavaCode WGLExtImpl  public boolean isFunctionAvailable(String glFunctionName)
+CustomJavaCode WGLExtImpl  {
+CustomJavaCode WGLExtImpl    return _context.isFunctionAvailable(glFunctionName);
+CustomJavaCode WGLExtImpl  }
+
+CustomJavaCode WGLExtImpl  public boolean isExtensionAvailable(String glExtensionName)
+CustomJavaCode WGLExtImpl  {
+CustomJavaCode WGLExtImpl    return _context.isExtensionAvailable(glExtensionName);
+CustomJavaCode WGLExtImpl  }
+
+CustomJavaCode WGLExtImpl  private WindowsWGLContext _context;
diff --git a/make/config/nativewindow/jawt-CustomJavaCode.java b/make/config/nativewindow/jawt-CustomJavaCode.java
new file mode 100755
index 000000000..f1ef91075
--- /dev/null
+++ b/make/config/nativewindow/jawt-CustomJavaCode.java
@@ -0,0 +1,27 @@
+private static volatile JAWT jawt;
+
+/** Helper routine for all users to call to access the JAWT. */
+public static JAWT getJAWT() {
+  if (jawt == null) {
+    synchronized (JAWT.class) {
+      if (jawt == null) {
+        JAWTNativeLibLoader.loadAWTImpl();
+        // Workaround for 4845371.
+        // Make sure the first reference to the JNI GetDirectBufferAddress is done
+        // from a privileged context so the VM's internal class lookups will succeed.
+        AccessController.doPrivileged(new PrivilegedAction() {
+            public Object run() {
+              JAWT j = JAWT.create();
+              j.version(JAWTFactory.JAWT_VERSION_1_4);
+              if (!JAWTFactory.JAWT_GetAWT(j)) {
+                throw new RuntimeException("Unable to initialize JAWT");
+              }
+              jawt = j;
+              return null;
+            }
+          });
+      }
+    }
+  }
+  return jawt;
+}
diff --git a/make/config/nativewindow/jawt-DrawingSurfaceInfo-CustomJavaCode.java b/make/config/nativewindow/jawt-DrawingSurfaceInfo-CustomJavaCode.java
new file mode 100755
index 000000000..dab377ad4
--- /dev/null
+++ b/make/config/nativewindow/jawt-DrawingSurfaceInfo-CustomJavaCode.java
@@ -0,0 +1,38 @@
+public JAWT_PlatformInfo platformInfo() {
+  return newPlatformInfo(platformInfo0(getBuffer()));
+}
+
+private native ByteBuffer platformInfo0(Buffer jthis0);
+
+private static java.lang.reflect.Method platformInfoFactoryMethod;
+
+private static JAWT_PlatformInfo newPlatformInfo(ByteBuffer buf) {
+  if (platformInfoFactoryMethod == null) {
+    String osName = (String) AccessController.doPrivileged(new PrivilegedAction() {
+        public Object run() {
+          return System.getProperty("os.name").toLowerCase();
+        }
+      });
+    try {
+      Class factoryClass;
+      if (osName.startsWith("wind")) {
+        factoryClass = Class.forName("com.sun.nativewindow.impl.jawt.windows.JAWT_Win32DrawingSurfaceInfo");
+      } else if (osName.startsWith("mac os x")) {
+        factoryClass = Class.forName("com.sun.nativewindow.impl.jawt.macosx.JAWT_MacOSXDrawingSurfaceInfo");
+      } else {
+        // Assume Linux, Solaris, etc. Should probably test for these explicitly.
+        factoryClass = Class.forName("com.sun.nativewindow.impl.jawt.x11.JAWT_X11DrawingSurfaceInfo");
+      }
+      platformInfoFactoryMethod = factoryClass.getMethod("create",
+                                                         new Class[] { ByteBuffer.class });
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+  }
+  try {
+    return (JAWT_PlatformInfo)
+      platformInfoFactoryMethod.invoke(null, new Object[] { buf });
+  } catch (Exception e) {
+    throw new RuntimeException(e);
+  }
+}
diff --git a/make/config/nativewindow/jawt-macosx.cfg b/make/config/nativewindow/jawt-macosx.cfg
new file mode 100644
index 000000000..b047ecdff
--- /dev/null
+++ b/make/config/nativewindow/jawt-macosx.cfg
@@ -0,0 +1,30 @@
+# This .cfg file is used to generate the interface to the JAWT, which
+# is used by the MacOSXOnscreenGLContext.
+Style AllStatic
+Package com.sun.nativewindow.impl.jawt
+JavaClass JAWTFactory
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/MacOSX
+
+HierarchicalNativeOutput false
+
+Opaque boolean jboolean
+Opaque long void *
+Opaque long NSView *
+
+IgnoreField JAWT GetComponent
+IgnoreField JAWT_DrawingSurfaceInfo      platformInfo
+
+IncludeAs CustomJavaCode JAWT jawt-CustomJavaCode.java
+
+CustomCCode #include <inttypes.h>
+CustomCCode #include <jawt.h>
+CustomCCode #include </usr/include/machine/types.h>
+
+import java.security.*
+import com.sun.nativewindow.impl.jawt.*
+StructPackage JAWT_MacOSXDrawingSurfaceInfo com.sun.nativewindow.impl.jawt.macosx
+EmitStruct JAWT_MacOSXDrawingSurfaceInfo
+Implements JAWT_MacOSXDrawingSurfaceInfo JAWT_PlatformInfo
+
+IncludeAs CustomJavaCode JAWT_DrawingSurfaceInfo jawt-DrawingSurfaceInfo-CustomJavaCode.java
diff --git a/make/config/nativewindow/jawt-win32.cfg b/make/config/nativewindow/jawt-win32.cfg
new file mode 100644
index 000000000..e7754843e
--- /dev/null
+++ b/make/config/nativewindow/jawt-win32.cfg
@@ -0,0 +1,30 @@
+# This .cfg file is used to generate the interface to the JAWT, which
+# is used by the WindowsOnscreenGLContext.
+Style AllStatic
+Package com.sun.nativewindow.impl.jawt
+JavaClass JAWTFactory
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/Windows
+
+HierarchicalNativeOutput false
+
+Opaque boolean jboolean
+Opaque long HDC
+
+IgnoreField JAWT GetComponent
+IgnoreField JAWT_DrawingSurfaceInfo      platformInfo
+IgnoreField JAWT_Win32DrawingSurfaceInfo null
+IgnoreField JAWT_Win32DrawingSurfaceInfo hpalette
+
+IncludeAs CustomJavaCode JAWT jawt-CustomJavaCode.java
+
+CustomCCode #include <jawt.h>
+Include ../intptr.cfg
+
+import java.security.*
+import com.sun.nativewindow.impl.jawt.*
+StructPackage JAWT_Win32DrawingSurfaceInfo com.sun.nativewindow.impl.jawt.windows
+EmitStruct JAWT_Win32DrawingSurfaceInfo
+Implements JAWT_Win32DrawingSurfaceInfo JAWT_PlatformInfo
+
+IncludeAs CustomJavaCode JAWT_DrawingSurfaceInfo jawt-DrawingSurfaceInfo-CustomJavaCode.java
diff --git a/make/config/nativewindow/jawt-x11.cfg b/make/config/nativewindow/jawt-x11.cfg
new file mode 100644
index 000000000..25df57a1f
--- /dev/null
+++ b/make/config/nativewindow/jawt-x11.cfg
@@ -0,0 +1,30 @@
+# This .cfg file is used to generate the interface to the JAWT, which
+# is used by the X11OnscreenGLContext.
+Style AllStatic
+Package com.sun.nativewindow.impl.jawt
+JavaClass JAWTFactory
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/X11
+
+HierarchicalNativeOutput false
+
+Opaque boolean jboolean
+Opaque long Drawable
+Opaque long Display *
+
+IgnoreField JAWT GetComponent
+IgnoreField JAWT_DrawingSurfaceInfo platformInfo
+IgnoreField JAWT_X11DrawingSurfaceInfo GetAWTColor
+
+IncludeAs CustomJavaCode JAWT jawt-CustomJavaCode.java
+
+CustomCCode #include <inttypes.h>
+CustomCCode #include <jawt.h>
+
+import java.security.*
+import com.sun.nativewindow.impl.jawt.*
+StructPackage JAWT_X11DrawingSurfaceInfo com.sun.nativewindow.impl.jawt.x11
+EmitStruct JAWT_X11DrawingSurfaceInfo
+Implements JAWT_X11DrawingSurfaceInfo JAWT_PlatformInfo
+
+IncludeAs CustomJavaCode JAWT_DrawingSurfaceInfo jawt-DrawingSurfaceInfo-CustomJavaCode.java
diff --git a/make/config/nativewindow/x11-CustomCCode.c b/make/config/nativewindow/x11-CustomCCode.c
new file mode 100755
index 000000000..e24e0cd1c
--- /dev/null
+++ b/make/config/nativewindow/x11-CustomCCode.c
@@ -0,0 +1,165 @@
+#include <inttypes.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+/* Linux headers don't work properly */
+#define __USE_GNU
+#include <dlfcn.h>
+#undef __USE_GNU
+
+/* Current versions of Solaris don't expose the XF86 extensions,
+   although with the recent transition to Xorg this will probably
+   happen in an upcoming release */
+#if !defined(__sun) && !defined(_HPUX)
+#include <X11/extensions/xf86vmode.h>
+#else
+/* Need to provide stubs for these */
+Bool XF86VidModeGetGammaRampSize(
+    Display *display,
+    int screen,
+    int* size)
+{
+  return False;
+}
+
+Bool XF86VidModeGetGammaRamp(
+    Display *display,
+    int screen,
+    int size,
+    unsigned short *red_array,
+    unsigned short *green_array,
+    unsigned short *blue_array) {
+  return False;
+}
+Bool XF86VidModeSetGammaRamp(
+    Display *display,
+    int screen,
+    int size,
+    unsigned short *red_array,
+    unsigned short *green_array,
+    unsigned short *blue_array) {
+  return False;
+}
+#endif
+
+/* HP-UX doesn't define RTLD_DEFAULT. */
+#if defined(_HPUX) && !defined(RTLD_DEFAULT)
+#define RTLD_DEFAULT NULL
+#endif
+
+/* Need to expose DefaultScreen and RootWindow macros to Java */
+JNIEXPORT jlong JNICALL 
+Java_com_sun_nativewindow_impl_x11_X11Lib_DefaultScreen(JNIEnv *env, jclass _unused, jlong display) {
+  return DefaultScreen((Display*) (intptr_t) display);
+}
+
+JNIEXPORT jlong JNICALL 
+Java_com_sun_nativewindow_impl_x11_X11Lib_DefaultVisualID(JNIEnv *env, jclass _unused, jlong display, jint screen) {
+  return (jlong) XVisualIDFromVisual( DefaultVisual( (Display*) (intptr_t) display, screen ) );
+}
+
+JNIEXPORT jlong JNICALL 
+Java_com_sun_nativewindow_impl_x11_X11Lib_RootWindow(JNIEnv *env, jclass _unused, jlong display, jint screen) {
+  return RootWindow((Display*) (intptr_t) display, screen);
+}
+
+JNIEXPORT jlong JNICALL 
+Java_com_sun_nativewindow_impl_x11_X11Lib_dlopen(JNIEnv *env, jclass _unused, jstring name) {
+  const jbyte* chars;
+  void* res;
+  chars = (*env)->GetStringUTFChars(env, name, NULL);
+  res = dlopen(chars, RTLD_LAZY | RTLD_GLOBAL);
+  (*env)->ReleaseStringUTFChars(env, name, chars);
+  return (jlong) ((intptr_t) res);
+}
+
+JNIEXPORT jlong JNICALL 
+Java_com_sun_nativewindow_impl_x11_X11Lib_dlsym(JNIEnv *env, jclass _unused, jstring name) {
+  const jbyte* chars;
+  void* res;
+  chars = (*env)->GetStringUTFChars(env, name, NULL);
+  res = dlsym(RTLD_DEFAULT, chars);
+  (*env)->ReleaseStringUTFChars(env, name, chars);
+  return (jlong) ((intptr_t) res);
+}
+
+/* Need to pull this in as we don't have a stub header for it */
+extern Bool XineramaEnabled(Display* display);
+
+static const char * clazzNameInternalBufferUtil = "com/sun/nativewindow/impl/InternalBufferUtil";
+static const char * clazzNameInternalBufferUtilStaticCstrName = "copyByteBuffer";
+static const char * clazzNameInternalBufferUtilStaticCstrSignature = "(Ljava/nio/ByteBuffer;)Ljava/nio/ByteBuffer;";
+static const char * clazzNameByteBuffer = "java/nio/ByteBuffer";
+static jclass clazzInternalBufferUtil = NULL;
+static jmethodID cstrInternalBufferUtil = NULL;
+static jclass clazzByteBuffer = NULL;
+
+static void _initClazzAccess(JNIEnv *env) {
+    if(NULL!=cstrInternalBufferUtil) return ;
+
+    jclass c = (*env)->FindClass(env, clazzNameInternalBufferUtil);
+    if(NULL==c) {
+        fprintf(stderr, "FatalError: Java_com_sun_nativewindow_impl_x11_X11Lib: can't find %s\n", clazzNameInternalBufferUtil);
+        (*env)->FatalError(env, clazzNameInternalBufferUtil);
+    }
+    clazzInternalBufferUtil = (jclass)(*env)->NewGlobalRef(env, c);
+    if(NULL==clazzInternalBufferUtil) {
+        fprintf(stderr, "FatalError: Java_com_sun_nativewindow_impl_x11_X11Lib: can't use %s\n", clazzNameInternalBufferUtil);
+        (*env)->FatalError(env, clazzNameInternalBufferUtil);
+    }
+    c = (*env)->FindClass(env, clazzNameByteBuffer);
+    if(NULL==c) {
+        fprintf(stderr, "FatalError: Java_com_sun_nativewindow_impl_x11_X11Lib: can't find %s\n", clazzNameByteBuffer);
+        (*env)->FatalError(env, clazzNameByteBuffer);
+    }
+    clazzByteBuffer = (jclass)(*env)->NewGlobalRef(env, c);
+    if(NULL==c) {
+        fprintf(stderr, "FatalError: Java_com_sun_nativewindow_impl_x11_X11Lib: can't use %s\n", clazzNameByteBuffer);
+        (*env)->FatalError(env, clazzNameByteBuffer);
+    }
+
+    cstrInternalBufferUtil = (*env)->GetStaticMethodID(env, clazzInternalBufferUtil, 
+                            clazzNameInternalBufferUtilStaticCstrName, clazzNameInternalBufferUtilStaticCstrSignature);
+    if(NULL==cstrInternalBufferUtil) {
+        fprintf(stderr, "FatalError: Java_com_sun_nativewindow_impl_x11_X11Lib:: can't create %s.%s %s\n",
+            clazzNameInternalBufferUtil,
+            clazzNameInternalBufferUtilStaticCstrName, clazzNameInternalBufferUtilStaticCstrSignature);
+        (*env)->FatalError(env, clazzNameInternalBufferUtilStaticCstrName);
+    }
+}
+
+/*   Java->C glue code:
+ *   Java package: com.sun.nativewindow.impl.x11.X11Lib
+ *    Java method: XVisualInfo XGetVisualInfo(long arg0, long arg1, XVisualInfo arg2, java.nio.IntBuffer arg3)
+ *     C function: XVisualInfo *  XGetVisualInfo(Display * , long, XVisualInfo * , int * );
+ */
+JNIEXPORT jobject JNICALL
+Java_com_sun_nativewindow_impl_x11_X11Lib_XGetVisualInfoCopied1__JJLjava_nio_ByteBuffer_2Ljava_lang_Object_2I(JNIEnv *env, jclass _unused, jlong arg0, jlong arg1, jobject arg2, jobject arg3, jint arg3_byte_offset) {
+  XVisualInfo * _ptr2 = NULL;
+  int * _ptr3 = NULL;
+  XVisualInfo *  _res;
+  int count;
+    if (arg2 != NULL) {
+        _ptr2 = (XVisualInfo *) (((char*) (*env)->GetDirectBufferAddress(env, arg2)) + 0);
+    }
+  if (arg3 != NULL) {
+    _ptr3 = (int *) (((char*) (*env)->GetPrimitiveArrayCritical(env, arg3, NULL)) + arg3_byte_offset);
+  }
+  _res = XGetVisualInfo((Display *) (intptr_t) arg0, (long) arg1, (XVisualInfo *) _ptr2, (int *) _ptr3);
+  count = _ptr3[0];
+  if (arg3 != NULL) {
+    (*env)->ReleasePrimitiveArrayCritical(env, arg3, _ptr3, 0);
+  }
+  if (_res == NULL) return NULL;
+
+  _initClazzAccess(env);
+
+  jobject jbyteSource = (*env)->NewDirectByteBuffer(env, _res, count * sizeof(XVisualInfo));
+  jobject jbyteCopy   = (*env)->CallStaticObjectMethod(env,
+                            clazzInternalBufferUtil, cstrInternalBufferUtil, jbyteSource);
+
+  // FIXME: remove reference/gc jbyteSource ?? 
+  XFree(_res);
+
+  return jbyteCopy;
+}
+
diff --git a/make/config/nativewindow/x11-CustomJavaCode.java b/make/config/nativewindow/x11-CustomJavaCode.java
new file mode 100644
index 000000000..b1ee3a6c3
--- /dev/null
+++ b/make/config/nativewindow/x11-CustomJavaCode.java
@@ -0,0 +1,26 @@
+
+  /** Interface to C language function: <br> <code> XVisualInfo *  XGetVisualInfo(Display * , long, XVisualInfo * , int * ); </code>    */
+  public static XVisualInfo[] XGetVisualInfoCopied(long arg0, long arg1, XVisualInfo arg2, int[] arg3, int arg3_offset)
+  {
+    if(arg3 != null && arg3.length <= arg3_offset)
+      throw new RuntimeException("array offset argument \"arg3_offset\" (" + arg3_offset + ") equals or exceeds array length (" + arg3.length + ")");
+    java.nio.ByteBuffer _res;
+    _res = XGetVisualInfoCopied1(arg0, arg1, ((arg2 == null) ? null : arg2.getBuffer()), arg3, BufferFactory.SIZEOF_INT * arg3_offset);
+
+    if (_res == null) return null;
+    BufferFactory.nativeOrder(_res);
+    XVisualInfo[] _retarray = new XVisualInfo[getFirstElement(arg3, arg3_offset)];
+    for (int _count = 0; _count < getFirstElement(arg3, arg3_offset); _count++) {
+      _res.position(_count * XVisualInfo.size());
+      _res.limit   ((1 + _count) * XVisualInfo.size());
+      java.nio.ByteBuffer _tmp = _res.slice();
+      _res.position(0);
+      _res.limit(_res.capacity());
+      _retarray[_count] = XVisualInfo.create(_tmp);
+    }
+    return _retarray;
+  }
+
+  /** Entry point to C language function: <code> XVisualInfo *  XGetVisualInfo(Display * , long, XVisualInfo * , int * ); </code>    */
+  private static native java.nio.ByteBuffer XGetVisualInfoCopied1(long arg0, long arg1, java.nio.ByteBuffer arg2, Object arg3, int arg3_byte_offset);
+
diff --git a/make/config/nativewindow/x11-lib.cfg b/make/config/nativewindow/x11-lib.cfg
new file mode 100644
index 000000000..321444725
--- /dev/null
+++ b/make/config/nativewindow/x11-lib.cfg
@@ -0,0 +1,43 @@
+# This .cfg file is used to generate the interface to the GLX routines
+# used internally by the X11GLContext implementation.
+Package com.sun.nativewindow.impl.x11
+JavaClass X11Lib
+Style allstatic
+
+HierarchicalNativeOutput false
+
+JavaOutputDir gensrc/classes
+NativeOutputDir gensrc/native/X11
+
+# Imports needed by all glue code
+Import java.nio.*
+Import java.util.*
+
+# XID needs to be treated as a long for 32/64 bit compatibility
+Opaque long XID
+
+Opaque long Display *
+Opaque boolean Bool
+Opaque long GLXFBConfig
+
+CustomJavaCode X11Lib public static native long dlopen(String name);
+CustomJavaCode X11Lib public static native long dlsym(String name);
+
+IncludeAs CustomJavaCode X11Lib x11-CustomJavaCode.java
+IncludeAs CustomCCode           x11-CustomCCode.c
+
+ArgumentIsString XOpenDisplay 0
+
+# Need to expose DefaultScreen and RootWindow macros to Java
+CustomJavaCode X11Lib public static native int  DefaultScreen(long display);
+CustomJavaCode X11Lib public static native long DefaultVisualID(long display, int screen);
+CustomJavaCode X11Lib public static native long RootWindow(long display, int screen);
+
+# We have Custom code for the following
+Ignore XGetVisualInfo
+
+# Helper routine to make the ReturnedArrayLength expression below work correctly
+CustomJavaCode X11Lib private static int getFirstElement(IntBuffer buf)         { return buf.get(buf.position()); }
+CustomJavaCode X11Lib private static int getFirstElement(int[] arr, int offset) { return arr[offset]; }
+
+CustomJavaCode XVisualInfo public static XVisualInfo create(XVisualInfo s) { XVisualInfo d = XVisualInfo.create(); d.getBuffer().put(s.getBuffer()); d.getBuffer().rewind(); s.getBuffer().rewind(); return d; }