Fixed GL* documentation. Moved common GL functions to GLBase. Moved glAllocateMemoryNV to GL2GL3 only. Add GL2GL3 interface. Fix some GL2 signatures. BroadcomEGL disable custom setSize().

1 files changed, 72 insertions, 132 deletions

diff --git a/make/config/jogl/gl-common.cfg b/make/config/jogl/gl-common.cfg
index 50c2ff004..19e0eb8e4 100644
--- a/make/config/jogl/gl-common.cfg
+++ b/make/config/jogl/gl-common.cfg
@@ -481,70 +481,87 @@ 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  * <P> Common interface containing the subset of all profiles, GL3, GL2, GLES1 and GLES2.<br>
+ClassJavadoc GL  * This interface reflects common data types, texture and framebuffer functionality.</P>
 ClassJavadoc GL  */
 
+ClassJavadoc GL2ES1 /**
+ClassJavadoc GL2ES1  * <P> 
+ClassJavadoc GL2ES1  * Interface containing the common subset of GL2 and GLES1.<br>
+ClassJavadoc GL2ES1  * This interface reflects only the fixed functionality of OpenGL<br>
+ClassJavadoc GL2ES1  * </P>
+ClassJavadoc GL2ES1  */
+
+ClassJavadoc GL2ES2 /**
+ClassJavadoc GL2ES2  * <P> 
+ClassJavadoc GL2ES2  * Interface containing the common subset of GL3, GL2 and GLES2.<br>
+ClassJavadoc GL2ES2  * This interface reflects only the programmable shader functionality of desktop and embedded OpenGL<br>
+ClassJavadoc GL2ES2  * </P>
+ClassJavadoc GL2ES2  */
+
+ClassJavadoc GL2GL3 /**
+ClassJavadoc GL2GL3  * <P> 
+ClassJavadoc GL2GL3  * Interface containing the common subset of GL3 and GL2.<br>
+ClassJavadoc GL2GL3  * This interface reflects only the programmable shader functionality of desktop OpenGL<br>
+ClassJavadoc GL2GL3  * </P>
+ClassJavadoc GL2GL3  */
+
+ClassJavadoc GL2 /**
+ClassJavadoc GL2  * <P> 
+ClassJavadoc GL2  * This interface contains all core desktop OpenGL methods through
+ClassJavadoc GL2  * version 3.0, inclusive, as well as most of it's extensions defined at the
+ClassJavadoc GL2  * time of this specification.  Early OpenGL extensions whose functionality
+ClassJavadoc GL2  * was incorporated into core OpenGL by version 2.0, inclusive, are specifically
+ClassJavadoc GL2  * excluded.
+ClassJavadoc GL2  * </P>
+ClassJavadoc GL2  */
+
+ClassJavadoc GL3 /**
+ClassJavadoc GL3  * <P> 
+ClassJavadoc GL3  * This interface contains all core desktop OpenGL methods starting from 3.1,
+ClassJavadoc GL3  * inclusive - forward compatible only, as well as most of it's extensions defined at the
+ClassJavadoc GL3  * time of this specification.<br>
+ClassJavadoc GL3  * </P>
+ClassJavadoc GL3  */
+
+ClassJavadoc GLES1 /**
+ClassJavadoc GLES1  * <P> 
+ClassJavadoc GLES1  * This interface contains all core embedded OpenGL methods of ES 1.x, with x >= 0,
+ClassJavadoc GLES1  * inclusive, as well as most of it's extensions defined at the
+ClassJavadoc GLES1  * time of this specification.
+ClassJavadoc GLES1  * </P>
+ClassJavadoc GLES1  */
+
+ClassJavadoc GLES2 /**
+ClassJavadoc GLES2  * <P> 
+ClassJavadoc GLES2  * This interface contains all core embedded OpenGL methods of ES 2.x, with x >= 0,
+ClassJavadoc GLES2  * inclusive, as well as most of it's extensions defined at the
+ClassJavadoc GLES2  * time of this specification.
+ClassJavadoc GLES2  * </P>
+ClassJavadoc GLES2  */
+
+# Javadoc for the EGL class
+ClassJavadoc EGL /**
+ClassJavadoc EGL  * Provides access to the embedded-specific OpenGL vendor extensions.
+ClassJavadoc EGL  * See {@link GLBase} for more information.
+ClassJavadoc EGL  */
+
 # 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  * See {@link GLBase} 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  * See {@link GLBase} 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  * See {@link GLBase} for more information.
 ClassJavadoc CGL  */
 
 # Javadoc for the XVisualInfo class
@@ -556,86 +573,9 @@ 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);
+CustomJavaCode GL2GL3   /**
+CustomJavaCode GL2GL3    * Provides platform-independent access to the <code>wglAllocateMemoryNV</code> /
+CustomJavaCode GL2GL3    * <code>glXAllocateMemoryNV</code> extension.
+CustomJavaCode GL2GL3    */
+CustomJavaCode GL2GL3   public java.nio.ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3);
+