Initial revision

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

1 files changed, 364 insertions, 0 deletions

diff --git a/make/gl-common.cfg b/make/gl-common.cfg
new file mode 100644
index 000000000..c49f64478
--- /dev/null
+++ b/make/gl-common.cfg
@@ -0,0 +1,364 @@
+# 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
+
+# Imports needed by all glue code
+Import java.nio.*
+Import net.java.games.jogl.*
+
+# Don't output #defines of GL version identifier strings as constants, 
+# because we don't need them java-side. 
+Ignore GL_VERSION_.+
+
+# 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)_EXT_.+
+Ignore (GL|GLU|GLX|WGL|AGL)_ARB_.+
+Ignore (GL|GLU|GLX|WGL|AGL)_PGI_.+
+Ignore (GL|GLU|GLX|WGL|AGL)_SGI_.+
+Ignore (GL|GLU|GLX|WGL|AGL)_SGIS_.+
+Ignore (GL|GLU|GLX|WGL|AGL)_SGIX_.+
+Ignore (GL|GLU|GLX|WGL|AGL)_MESA_.+
+Ignore (GL|GLU|GLX|WGL|AGL)_HP_.+
+Ignore (GL|GLU|GLX|WGL|AGL)_ATI_.+
+Ignore (GL|GLU|GLX|WGL|AGL)_NV_.+
+Ignore (GL|GLU|GLX|WGL|AGL)_IBM_.+
+Ignore (GL|GLU|GLX|WGL|AGL)_WIN_.+
+Ignore (GL|GLU|GLX|WGL|AGL)_REND_.+
+Ignore (GL|GLU|GLX|WGL|AGL)_APPLE_.+
+Ignore (GL|GLU|GLX|WGL|AGL)_INTEL_.+
+Ignore (GL|GLU|GLX|WGL|AGL)_INGR_.+
+Ignore (GL|GLU|GLX|WGL|AGL)_SUN_.+
+Ignore (GL|GLU|GLX|WGL|AGL)_SUNX_.+
+Ignore (GL|GLU|GLX|WGL|AGL)_3DFX_.+
+Ignore (GL|GLU|GLX|WGL|AGL)_OML_.+
+Ignore (GL|GLU|GLX|WGL|AGL)_I3D_.+
+
+# Ignore GL functions that deal with explicit pointer values in such a
+# way that we cannot implement the functionality in Java
+Ignore glGetBufferPointervARB
+Ignore glGetPointerv
+Ignore glGetPointervEXT
+Ignore glGetVertexAttribPointervARB
+Ignore glGetVertexAttribPointervNV
+Ignore glTracePointerRangeMESA 
+
+# FIXME: Temporarily ignore glMapBufferARB as it returns a void* that
+# we don't know the size of, and it's so new that there's no
+# documentation on its semantics
+Ignore glMapBufferARB
+
+# Ignore GL functions that have void** parameters; we cannot yet deal with them
+Ignore glMultiDrawElements
+Ignore glMultiDrawElements
+Ignore glVertexPointervINTEL
+Ignore glNormalPointervINTEL
+Ignore glColorPointervINTEL
+Ignore glTexCoordPointervINTEL
+Ignore glMultiDrawElementsEXT
+Ignore glReplacementCodePointerSUN
+Ignore glMultiModeDrawElementsIBM
+Ignore glColorPointerListIBM
+Ignore glSecondaryColorPointerListIBM
+Ignore glEdgeFlagPointerListIBM
+Ignore glFogCoordPointerListIBM
+Ignore glIndexPointerListIBM
+Ignore glNormalPointerListIBM
+Ignore glTexCoordPointerListIBM
+Ignore glVertexPointerListIBM
+Ignore glGetVariantPointervEXT
+
+# Some GL functions have multiple void* arguments but require them to
+# contain data of the same type; make sure that when bindings are
+# expanded those arguments have the same type.
+MirrorExpandedBindingArgs glSeparableFilter2D 6 7
+MirrorExpandedBindingArgs glSeparableFilter2DEXT 6 7
+MirrorExpandedBindingArgs glGetSeparableFilter 3 4
+MirrorExpandedBindingArgs glGetSeparableFilterEXT 3 4
+
+# 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 wglCreateBufferRegionARB
+Ignore wglDeleteBufferRegionARB
+Ignore wglSaveBufferRegionARB
+Ignore wglRestoreBufferRegionARB
+# WGL_ARB_extensions_string
+Ignore wglGetExtensionsStringARB
+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
+
+#
+# Opaques and other directives for platform-independent routines
+#
+
+Opaque boolean GLboolean
+ReturnsString glGetString
+
+#
+# NIOOnly directives for vertex arrays
+#
+NIOOnly glColorPointer
+NIOOnly glEdgeFlagPointer
+NIOOnly glIndexPointer
+NIOOnly glNormalPointer
+NIOOnly glTexCoordPointer
+NIOOnly glVertexPointer
+#
+# FIXME: we should probably be ignoring the "EXT" variants of these
+#
+NIOOnly glColorPointerEXT
+NIOOnly glEdgeFlagPointerEXT
+NIOOnly glIndexPointerEXT
+NIOOnly glNormalPointerEXT
+NIOOnly glTexCoordPointerEXT
+NIOOnly glVertexPointerEXT
+#
+# NIOOnly directives for other extensions
+#
+NIOOnly glBinormalPointerEXT
+NIOOnly glBufferDataARB
+NIOOnly glBufferSubDataARB
+NIOOnly glGetBufferSubDataARB
+# FIXME: should add way to restrict argument to be a direct ByteBuffer
+NIOOnly glGetProgramStringARB
+NIOOnly glElementPointerATI
+NIOOnly glElementPointerNV
+NIOOnly glFogCoordPointer
+NIOOnly glFogCoordPointerEXT
+NIOOnly glMatrixIndexPointerARB
+# NIOOnly glNewObjectBufferATI # FIXME: look up semantics of this routine
+NIOOnly glPixelDataRangeNV
+NIOOnly glSecondaryColorPointer
+NIOOnly glSecondaryColorPointerEXT
+NIOOnly glTangentPointerEXT
+# NIOOnly glUpdateObjectBufferATI # FIXME: look up semantics of this routine
+# NIOOnly glVariantPointerEXT # FIXME: look up semantics of this routine
+NIOOnly glVertexArrayRangeNV
+NIOOnly glVertexAttribPointerARB
+NIOOnly glVertexAttribPointerNV
+NIOOnly glVertexWeightPointerEXT
+NIOOnly glWeightPointerARB
+NIOOnly wglFreeMemoryNV
+NIOOnly 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,
+# NV_vertex_program, and NV_fragment_program as Strings
+ArgumentIsString glLoadProgramNV 3
+ArgumentIsString glProgramStringARB 3
+ArgumentIsString glProgramNamedParameter4fNV 2
+ArgumentIsString glProgramNamedParameter4dNV 2
+ArgumentIsString glProgramNamedParameter4fvNV 2
+ArgumentIsString glProgramNamedParameter4dvNV 2
+ArgumentIsString glGetProgramNamedParameterfvNV 2
+ArgumentIsString glGetProgramNamedParameterdvNV 2
+
+# 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 1.4 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. On certain platforms (Windows in particular), the most
+ClassJavadoc GL  * "core" functionality is only OpenGL 1.1, so in theory any routines
+ClassJavadoc GL  * first exposed in OpenGL 1.2, 1.3, and 1.4 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  * <P> Access to window system-specific extensions is provided through
+ClassJavadoc GL  * the {@link WGL} and {@link GLX} interfaces. However, most of these
+ClassJavadoc GL  * extensions require access to low-level window system data
+ClassJavadoc GL  * structures which are not exposed by this binding, and are therefore
+ClassJavadoc GL  * not useful. Calling one particular window system's extension on
+ClassJavadoc GL  * another platform will cause a {@link GLException} to be raised
+ClassJavadoc GL  * indicating the routine is unimplemented on the current platform.
+ClassJavadoc GL  * </P>
+ClassJavadoc GL  *
+ClassJavadoc GL  * <P> Exceptions to the window system extension naming rules:
+ClassJavadoc GL  *
+ClassJavadoc GL  * <UL>
+ClassJavadoc GL  *
+ClassJavadoc GL  * <LI> The NVidia vertex_array_range (VAR) extension, in particular {@link
+ClassJavadoc GL  * WGL#wglAllocateMemoryNV} / {@link GLX#glXAllocateMemoryNV} and
+ClassJavadoc GL  * associated routines. {@link #glAllocateMemoryNV} has been provided
+ClassJavadoc GL  * for window system-independent access to VAR. {@link
+ClassJavadoc GL  * #isFunctionAvailable} will translate an argument of
+ClassJavadoc GL  * "glAllocateMemoryNV" or "glFreeMemoryNV" into the appropriate
+ClassJavadoc GL  * window system-specific name. </P>
+ClassJavadoc GL  *
+ClassJavadoc GL  * <LI> WGL_ARB_pbuffer and WGL_ARB_pixel_format; these extensions have been
+ClassJavadoc GL  * exposed with the names "GL_ARB_pbuffer" and "GL_ARB_pixel_format" for
+ClassJavadoc GL  * platform independence. When pbuffer support is added to the X11 port of
+ClassJavadoc GL  * Jogl, the semantics of querying for these platform-independent extension
+ClassJavadoc GL  * names will be preserved.
+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 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 statically linked, or can be 
+CustomJavaCode GL    * dynamically linked at runtime. 
+CustomJavaCode GL    * 
+CustomJavaCode GL    * Whether or not a GL function is <i>available</i> is determined as follows: 
+CustomJavaCode GL    * <ul>
+CustomJavaCode GL    *   <li>If the function is an OpenGL core function (i.e., not an
+CustomJavaCode GL    *   extension), <code>glGetString(GL_VERSION)</code> is used to determine the
+CustomJavaCode GL    *   version number of the highest OpenGL specification version that both host
+CustomJavaCode GL    *   and display support, and then the function name is cross-referenced
+CustomJavaCode GL    *   with that specification version to see if it is part of that version.
+
+CustomJavaCode GL    *   <li> If the function is an OpenGL extension, the function name is
+CustomJavaCode GL    *   cross-referenced with the list returned by
+CustomJavaCode GL    *   <code>glGetString(GL_EXTENSIONS)</code> to see if the function is one of
+CustomJavaCode GL    *   the extensions that is supported on both host and display.
+CustomJavaCode GL    * </ul>
+CustomJavaCode GL    *
+CustomJavaCode GL    * <b>NOTE:</b>The availability of a function may change at runtime in
+CustomJavaCode GL    * response to changes in the display environment. For example, when a window
+CustomJavaCode GL    * is dragged from one display to another on a multi-display system, or when
+CustomJavaCode GL    * the properties of the display device are modified (e.g., changing the color
+CustomJavaCode GL    * depth of the display). Any application that is concerned with handling
+CustomJavaCode GL    * these situations correctly should confirm availability after a display
+CustomJavaCode GL    * change before calling a questionable OpenGL function. To detect a change in
+CustomJavaCode GL    * the display device, please see {@link
+CustomJavaCode GL    * GLEventListener#displayChanged(GLDrawable,boolean,boolean)}.
+CustomJavaCode GL    *
+CustomJavaCode GL    * @param glFunctionName the name of the OpenGL function (e.g., use
+CustomJavaCode GL    * "glPolygonOffsetEXT" to check if the {@link
+CustomJavaCode GL    * #glPolygonOffsetEXT(float,float)} 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_VERTEX_PROGRAM_ARB").
+CustomJavaCode GL    */
+CustomJavaCode GL   public boolean isExtensionAvailable(String glExtensionName);
+
+CustomJavaCode GL   /**
+CustomJavaCode GL    * Provides platform-independent access to the {@link WGL#wglAllocateMemoryNV} /
+CustomJavaCode GL    * {@link GLX#glXAllocateMemoryNV} extension.
+CustomJavaCode GL    */
+CustomJavaCode GL   public java.nio.ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3);
+
+#
+# Directives needed when processing wglext.h on Windows and other platforms
+#
+Opaque boolean BOOL
+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 glxext.h on X11 and other platforms
+#
+Opaque long __GLXextFuncPtr
+Opaque boolean Bool
+Opaque long Display *
+Opaque long GLXContext
+Opaque long GLXFBConfig
+Opaque long GLXFBConfig *
+Opaque long GLXFBConfigSGIX
+Opaque long GLXFBConfigSGIX *
+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