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

1 files changed, 641 insertions, 0 deletions

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);