javax.media.opengl

## Class GLContext

- java.lang.Object
- - javax.media.opengl.GLContext

-     public abstract class GLContext
      extends Object

  Abstraction for an OpenGL rendering context. In order to perform OpenGL rendering, a context must be "made current" on the current thread. OpenGL rendering semantics specify that only one context may be current on the current thread at any given time, and also that a given context may be current on only one thread at any given time. Because components can be added to and removed from the component hierarchy at any time, it is possible that the underlying OpenGL context may need to be destroyed and recreated multiple times over the lifetime of a given component. This process is handled by the implementation, and the GLContext abstraction provides a stable object which clients can use to refer to a given context.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static int` | `CONTEXT_CURRENT` Indicates that the context was made current during the last call to `makeCurrent`, value 1.
    `static int` | `CONTEXT_CURRENT_NEW` Indicates that a newly-created context was made current during the last call to `makeCurrent`, value 2.
    `static int` | `CONTEXT_NOT_CURRENT` Indicates that the context was not made current during the last call to `makeCurrent`, value 0.
    `static int` | `CTX_OPTION_DEBUG` `ARB_create_context` related: flag debug.
    `static boolean` | `DEBUG`
    `static boolean` | `DEBUG_GL` Reflects property jogl.debug.DebugGL.
    `static boolean` | `DEBUG_TRACE_SWITCH`
    `static int[][]` | `ES_VERSIONS`
    `static int[][]` | `GL_VERSIONS`
    `static boolean` | `PROFILE_ALIASING` If `true` (default), bootstrapping the available GL profiles will use the highest compatible GL context for each profile, hence skipping querying lower profiles if a compatible higher one is found: 4.2-core -> 4.2-core, 3.3-core 4.2-comp -> 4.2-comp, 3.3-comp, 2 Otherwise the dedicated GL context would be queried and used: 4.2-core -> 4.2-core 3.3-core -> 3.3-core 4.2-comp -> 4.2-comp 3.3-comp -> 3.3-comp 3.0-comp -> 2 Using aliasing speeds up initialization about: Linux x86_64 - Nvidia: 28%, 700ms down to 500ms Linux x86_64 - AMD : 40%, 1500ms down to 900ms
    `static boolean` | `TRACE_GL` Reflects property jogl.debug.TraceGL.
    `static boolean` | `TRACE_SWITCH`
    `static VersionNumber` | `Version100` Version 1.00, i.e.
    `static VersionNumber` | `Version110` Version 1.10, i.e.
    `static VersionNumber` | `Version120` Version 1.20, i.e.
    `static VersionNumber` | `Version130` Version 1.30, i.e.
    `static VersionNumber` | `Version140` Version 1.40, i.e.
    `static VersionNumber` | `Version150` Version 1.50, i.e.
    `static VersionNumber` | `Version300` Version 3.0.
    `static VersionNumber` | `Version310` Version 3.1.
    `static VersionNumber` | `Version320` Version 3.2.
    `static VersionNumber` | `Version430` Version 4.3.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `abstract void` | `addGLDebugListener(GLDebugListener listener)` Add `GLDebugListener`.
    `StringBuilder` | `append(StringBuilder sb)`
    `Object` | `attachObject(String name, Object obj)` Sets the attached user object for the given name to this GLContext.
    `boolean` | `bindSwapBarrier(int group, int barrier)`
    `static boolean` | `clipGLVersion(int ctxProfile, int[] major, int[] minor)` Clip the given GL version to the maximum known valid version if exceeding.
    `abstract void` | `copy(GLContext source, int mask)` Copies selected groups of OpenGL state variables from the supplied source context into this one.
    `static boolean` | `decrementGLVersion(int ctxProfile, int[] major, int[] minor)` Decrement the given GL version by one and return true if still valid, otherwise false.
    `abstract void` | `destroy()` Destroys this OpenGL context and frees its associated resources.
    `Object` | `detachObject(String name)`
    `abstract void` | `enableGLDebugMessage(boolean enable)` Enables or disables the GLDebugOutput feature of extension `GLExtensions.ARB_debug_output` or `GLExtensions.AMD_debug_output`, if available.
    `Object` | `getAttachedObject(String name)` Returns the attached user object for the given name to this GLContext.
    `abstract int` | `getBoundFramebuffer(int target)` Return the framebuffer name bound to this context, see `GL.glBindFramebuffer(int, int)`.
    `abstract int` | `getContextCreationFlags()`
    `List<GLContext>` | `getCreatedShares()` Returns a new list of created GLContext shared with this GLContext.
    `static GLContext` | `getCurrent()` Returns this thread current context.
    `static GL` | `getCurrentGL()` Returns the GL object bound to this thread current context.
    `abstract int` | `getDefaultDrawFramebuffer()` Return the default draw framebuffer name.
    `abstract int` | `getDefaultPixelDataFormat()` Get the default pixel data format, as required by e.g.
    `abstract int` | `getDefaultPixelDataType()` Get the default pixel data type, as required by e.g.
    `abstract int` | `getDefaultReadBuffer()` Returns the default color buffer within the current bound `getDefaultReadFramebuffer()`, i.e.
    `abstract int` | `getDefaultReadFramebuffer()` Return the default read framebuffer name.
    `abstract int` | `getDefaultVAO()` If this GLContext does not implement a default VAO, see `hasNoDefaultVAO()`, an own default VAO will be created and bound at context creation.
    `List<GLContext>` | `getDestroyedShares()` Returns a new list of destroyed GLContext shared with this GLContext.
    `abstract GL` | `getGL()` Returns the GL pipeline object for this GLContext.
    `abstract String` | `getGLDebugMessageExtension()`
    `abstract GLDrawable` | `getGLDrawable()` Returns the write-drawable this context uses for framebuffer operations.
    `abstract int` | `getGLExtensionCount()` Returns the number of OpenGL extensions
    `abstract String` | `getGLExtensionsString()` Returns a non-null (but possibly empty) string containing the space-separated list of available extensions.
    `abstract GLDrawable` | `getGLReadDrawable()` Returns the read-Drawable this context uses for read framebuffer operations.
    `VersionNumber` | `getGLSLVersionNumber()` Returns the matching GLSL version number, queried by this context GL via `GL2ES2.GL_SHADING_LANGUAGE_VERSION` if ≥ ES2.0 or GL2.0, otherwise a static match is being utilized.
    `String` | `getGLSLVersionString()` Returns the GLSL version string as to be used in a shader program, including a terminating newline '\n', i.e.
    `VersionNumberString` | `getGLVendorVersionNumber()` Returns the vendor's version, i.e.
    `String` | `getGLVersion()` Returns a valid OpenGL version string, ie
    `VersionNumber` | `getGLVersionNumber()` Returns this context OpenGL version.
    `long` | `getHandle()` Returns the underlying native OpenGL context handle
    `static int` | `getMaxMajor(int ctxProfile)`
    `static int` | `getMaxMinor(int ctxProfile, int major)`
    `int` | `getMaxRenderbufferSamples()` Returns the maximum number of FBO RENDERBUFFER samples if `full FBO is supported`, otherwise false.
    `abstract int` | `getPlatformExtensionCount()` Returns the number of platform extensions
    `abstract String` | `getPlatformExtensionsString()` Returns a non-null (but possibly empty) string containing the space-separated list of available platform-dependent (e.g., WGL, GLX) extensions.
    `GLRendererQuirks` | `getRendererQuirks()` Returns the instance of `GLRendererQuirks`, allowing one to determine workarounds.
    `abstract GL` | `getRootGL()` Returns the implementing root GL instance of this GLContext's GL object, considering a wrapped pipelined hierarchy, see `GLBase.getDownstreamGL()`.
    `GLContext` | `getSharedMaster()` Returns the shared master GLContext of this GLContext if shared, otherwise return `null`.
    `int` | `getSwapGroup()`
    `int` | `getSwapInterval()` Return the current swap interval.
    `abstract void` | `glDebugMessageControl(int source, int type, int severity, int count, int[] ids, int ids_offset, boolean enabled)` Generic entry for `GL2ES2.glDebugMessageControl(int, int, int, int, int[], int, boolean)` and `GL2GL3.glDebugMessageEnableAMD(int, int, int, int[], int, boolean)` of the GLDebugOutput feature.
    `abstract void` | `glDebugMessageControl(int source, int type, int severity, int count, IntBuffer ids, boolean enabled)` Generic entry for `GL2ES2.glDebugMessageControl(int, int, int, int, IntBuffer, boolean)` and `GL2GL3.glDebugMessageEnableAMD(int, int, int, IntBuffer, boolean)` of the GLDebugOutput feature.
    `abstract void` | `glDebugMessageInsert(int source, int type, int id, int severity, String buf)` Generic entry for `GL2ES2.glDebugMessageInsert(int, int, int, int, int, String)` and `GL2GL3.glDebugMessageInsertAMD(int, int, int, int, String)` of the GLDebugOutput feature.
    `boolean` | `hasBasicFBOSupport()` Returns `true` if basic FBO support is available, otherwise `false`.
    `boolean` | `hasFP32CompatAPI()` Returns `true` if `OES_single_precision`, fp32, fixed function point (FFP) compatibility entry points available, otherwise `false`.
    `boolean` | `hasFullFBOSupport()` Returns `true` if full FBO support is available, otherwise `false`.
    `boolean` | `hasGLSL()`
    `boolean` | `hasNoDefaultVAO()` Indicates whether this GLContext's native profile does not implement a default vertex array object (VAO), starting w/ OpenGL 3.1 core.
    `boolean` | `hasRendererQuirk(int quirk)` Returns true if the `quirk` exist in `getRendererQuirks()`, otherwise false.
    `boolean` | `isCPUDataSourcingAvail()` Indicates whether this GLContext allows CPU data sourcing (indices, vertices ..) as opposed to using a GPU buffer source (VBO), e.g.
    `boolean` | `isCreated()` Indicates whether the underlying native OpenGL context has been created.
    `boolean` | `isCreatedWithARBMethod()`
    `boolean` | `isCurrent()`
    `abstract boolean` | `isExtensionAvailable(String glExtensionName)` Returns true if the specified OpenGL extension can be successfully called using this GL context given the current host (OpenGL client) and display (OpenGL server) configuration.
    `static boolean` | `isFBOAvailable(AbstractGraphicsDevice device, GLProfile glp)` Returns true if it is possible to create an framebuffer object (FBO).
    `abstract boolean` | `isFunctionAvailable(String glFunctionName)` Returns true if the specified OpenGL core- or extension-function can be successfully called using this GL context given the current host (OpenGL client) and display (OpenGL server) configuration.
    `boolean` | `isGL2()` Indicates whether this GLContext is capable of GL2.
    `static boolean` | `isGL2Available(AbstractGraphicsDevice device, boolean[] isHardware)`
    `boolean` | `isGL2ES1()` Indicates whether this GLContext is capable of GL2ES1.
    `boolean` | `isGL2ES2()` Indicates whether this GLContext is capable of GL2ES2.
    `boolean` | `isGL2ES3()` Indicates whether this GLContext is capable of GL2ES3.
    `boolean` | `isGL2GL3()` Indicates whether this GLContext is capable of GL2GL3.
    `boolean` | `isGL3()` Indicates whether this GLContext is capable of GL3.
    `static boolean` | `isGL3Available(AbstractGraphicsDevice device, boolean[] isHardware)`
    `boolean` | `isGL3bc()` Indicates whether this GLContext is capable of GL3bc.
    `static boolean` | `isGL3bcAvailable(AbstractGraphicsDevice device, boolean[] isHardware)`
    `boolean` | `isGL3core()` Indicates whether this GLContext uses a GL3 core profile.
    `boolean` | `isGL3ES3()` Indicates whether this GLContext is capable of GL3ES3.
    `boolean` | `isGL4()` Indicates whether this GLContext is capable of GL4.
    `static boolean` | `isGL4Available(AbstractGraphicsDevice device, boolean[] isHardware)`
    `boolean` | `isGL4bc()` Indicates whether this GLContext is capable of GL4bc.
    `static boolean` | `isGL4bcAvailable(AbstractGraphicsDevice device, boolean[] isHardware)`
    `boolean` | `isGL4core()` Indicates whether this GLContext uses a GL4 core profile.
    `boolean` | `isGL4ES3()` Returns true if this profile is capable of GL4ES3, i.e.
    `boolean` | `isGLCompatibilityProfile()`
    `boolean` | `isGLcore()` Indicates whether this GLContext uses a GL core profile.
    `boolean` | `isGLCoreProfile()`
    `boolean` | `isGLDebugEnabled()`
    `abstract boolean` | `isGLDebugMessageEnabled()`
    `abstract boolean` | `isGLDebugSynchronous()`
    `boolean` | `isGLES()` Indicates whether this GLContext is capable of GLES.
    `boolean` | `isGLES1()` Indicates whether this GLContext is capable of GLES1.
    `static boolean` | `isGLES1Available(AbstractGraphicsDevice device, boolean[] isHardware)`
    `boolean` | `isGLES2()` Indicates whether this GLContext is capable of GLES2.
    `static boolean` | `isGLES2Available(AbstractGraphicsDevice device, boolean[] isHardware)`
    `boolean` | `isGLES2Compatible()`
    `boolean` | `isGLES3()` Indicates whether this GLContext is capable of GLES3.
    `static boolean` | `isGLES3Available(AbstractGraphicsDevice device, boolean[] isHardware)`
    `boolean` | `isGLES3Compatible()` Return true if this context is an ES3 context or implements the extension `GL_ARB_ES3_compatibility`, otherwise false.
    `static boolean` | `isGLES3CompatibleAvailable(AbstractGraphicsDevice device)` Returns true if a ES3 compatible profile is available, i.e.
    `boolean` | `isGLESProfile()`
    `boolean` | `isGLForwardCompatible()`
    `abstract boolean` | `isGLReadDrawableAvailable()` Query whether using a distinguished read-drawable is supported.
    `boolean` | `isHardwareRasterizer()`
    `static int` | `isHardwareRasterizer(AbstractGraphicsDevice device, GLProfile glp)`
    `boolean` | `isNPOTTextureAvailable()` Note: The GL impl.
    `boolean` | `isShared()` Returns true if this GLContext is shared, otherwise false.
    `boolean` | `isTextureFormatBGRA8888Available()`
    `static boolean` | `isValidGLVersion(int ctxProfile, int major, int minor)` Returns true, if the major.minor is not inferior to the lowest valid version and does not exceed the highest known major number by more than one.
    `boolean` | `joinSwapGroup(int group)`
    `abstract int` | `makeCurrent()` Makes this GLContext current on the calling thread.
    `static String` | `makeCurrentResultToString(int res)` Returns a String representation of the `makeCurrent()` result.
    `boolean` | `queryMaxSwapGroups(int[] maxGroups, int maxGroups_offset, int[] maxBarriers, int maxBarriers_offset)`
    `abstract void` | `release()` Releases control of this GLContext from the current thread.
    `abstract void` | `removeGLDebugListener(GLDebugListener listener)` Remove `GLDebugListener`.
    `abstract void` | `setContextCreationFlags(int flags)`
    `abstract GL` | `setGL(GL gl)` Sets the GL pipeline object for this GLContext.
    `abstract void` | `setGLDebugSynchronous(boolean synchronous)` Enables or disables the synchronous debug behavior via `glEnable/glDisable(GL_DEBUG_OUTPUT_SYNCHRONOUS)`, if extension is `GLExtensions.ARB_debug_output`.
    `abstract GLDrawable` | `setGLDrawable(GLDrawable readWrite, boolean setWriteOnly)` Sets the read/write drawable for framebuffer operations, i.e.
    `abstract GLDrawable` | `setGLReadDrawable(GLDrawable read)` Set the read-Drawable for read framebuffer operations. The caller should query if this feature is supported via `isGLReadDrawableAvailable()`.
    `boolean` | `setSwapInterval(int interval)` Set the swap interval of the current context and attached drawable.
    `String` | `toString()` Classname, GL, GLDrawable
    `void` | `validateCurrent()`

    - ### Methods inherited from class java.lang.Object

      `equals, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### DEBUG

          public static final boolean DEBUG

    - #### TRACE_SWITCH

          public static final boolean TRACE_SWITCH

    - #### DEBUG_TRACE_SWITCH

          public static final boolean DEBUG_TRACE_SWITCH

    - #### PROFILE_ALIASING

          public static final boolean PROFILE_ALIASING

      If `true` (default), bootstrapping the available GL profiles will use the highest compatible GL context for each profile, hence skipping querying lower profiles if a compatible higher one is found:
      - 4.2-core -> 4.2-core, 3.3-core
      - 4.2-comp -> 4.2-comp, 3.3-comp, 2
      Otherwise the dedicated GL context would be queried and used:
      - 4.2-core -> 4.2-core
      - 3.3-core -> 3.3-core
      - 4.2-comp -> 4.2-comp
      - 3.3-comp -> 3.3-comp
      - 3.0-comp -> 2
      Using aliasing speeds up initialization about:
      - Linux x86_64 - Nvidia: 28%, 700ms down to 500ms
      - Linux x86_64 - AMD : 40%, 1500ms down to 900ms

      Can be turned off with property `jogl.debug.GLContext.NoProfileAliasing`.

    - #### DEBUG_GL

          public static final boolean DEBUG_GL

      Reflects property jogl.debug.DebugGL. If true, the debug pipeline is enabled at context creation.

    - #### TRACE_GL

          public static final boolean TRACE_GL

      Reflects property jogl.debug.TraceGL. If true, the trace pipeline is enabled at context creation.

    - #### CONTEXT_NOT_CURRENT

          public static final int CONTEXT_NOT_CURRENT

      Indicates that the context was not made current during the last call to `makeCurrent`, value 0.
      See Also:
        Constant Field Values

    - #### CONTEXT_CURRENT

          public static final int CONTEXT_CURRENT

      Indicates that the context was made current during the last call to `makeCurrent`, value 1.
      See Also:
        Constant Field Values

    - #### CONTEXT_CURRENT_NEW

          public static final int CONTEXT_CURRENT_NEW

      Indicates that a newly-created context was made current during the last call to `makeCurrent`, value 2.
      See Also:
        Constant Field Values

    - #### Version100

          public static final VersionNumber Version100

      Version 1.00, i.e. GLSL 1.00 for ES 2.0.

    - #### Version110

          public static final VersionNumber Version110

      Version 1.10, i.e. GLSL 1.10 for GL 2.0.

    - #### Version120

          public static final VersionNumber Version120

      Version 1.20, i.e. GLSL 1.20 for GL 2.1.

    - #### Version130

          public static final VersionNumber Version130

      Version 1.30, i.e. GLSL 1.30 for GL 3.0.

    - #### Version140

          public static final VersionNumber Version140

      Version 1.40, i.e. GLSL 1.40 for GL 3.1.

    - #### Version150

          public static final VersionNumber Version150

      Version 1.50, i.e. GLSL 1.50 for GL 3.2.

    - #### Version300

          public static final VersionNumber Version300

      Version 3.0. As an OpenGL version, it qualifies for desktop `isGL2()` only, or ES 3.0. Or GLSL 3.00 for ES 3.0.

    - #### Version310

          public static final VersionNumber Version310

      Version 3.1. As an OpenGL version, it qualifies for `isGL3core()`, `isGL3bc()` and `isGL3()`

    - #### Version320

          public static final VersionNumber Version320

      Version 3.2. As an OpenGL version, it qualifies for geometry shader

    - #### Version430

          public static final VersionNumber Version430

      Version 4.3. As an OpenGL version, it qualifies for `GL_ARB_ES3_compatibility`

    - #### CTX_OPTION_DEBUG

          public static final int CTX_OPTION_DEBUG

      `ARB_create_context` related: flag debug. Cache key value. See `setContextCreationFlags(int)`, `GLAutoDrawable.setContextCreationFlags(int)`, `getAvailableContextProperties(AbstractGraphicsDevice, GLProfile)`.
      See Also:
        Constant Field Values

    - #### GL_VERSIONS

          public static final int[][] GL_VERSIONS

    - #### ES_VERSIONS

          public static final int[][] ES_VERSIONS

  - ### Method Detail

    - #### isShared

          public final boolean isShared()

      Returns true if this GLContext is shared, otherwise false.

    - #### getSharedMaster

          public final GLContext getSharedMaster()

      Returns the shared master GLContext of this GLContext if shared, otherwise return `null`.

      Returns this GLContext, if it is a shared master.

      Since:
        2.2.1

    - #### getCreatedShares

          public final List<GLContext> getCreatedShares()

      Returns a new list of created GLContext shared with this GLContext.

    - #### getDestroyedShares

          public final List<GLContext> getDestroyedShares()

      Returns a new list of destroyed GLContext shared with this GLContext.

    - #### getRendererQuirks

          public final GLRendererQuirks getRendererQuirks()

      Returns the instance of `GLRendererQuirks`, allowing one to determine workarounds.
      Returns:
        instance of `GLRendererQuirks` if context was made current once, otherwise `null`.

    - #### hasRendererQuirk

          public final boolean hasRendererQuirk(int quirk)
                                         throws IllegalArgumentException

      Returns true if the `quirk` exist in `getRendererQuirks()`, otherwise false.

      Convenience method for:

              final GLRendererQuirks glrq = ctx.getRendererQuirks();
              boolean hasQuirk = null != glrq ? glrq.exist(quirk) : false ;

      Parameters:
        `quirk` - the quirk to be tested, e.g. `GLRendererQuirks.NoDoubleBufferedPBuffer`.
      Throws:
        `IllegalArgumentException` - if the quirk is out of range

    - #### setGLDrawable

          public abstract GLDrawable setGLDrawable(GLDrawable readWrite,
                                 boolean setWriteOnly)

      Sets the read/write drawable for framebuffer operations, i.e. reassociation of the context's drawable.

      If the arguments reflect the current state of this context this method is a no-operation and returns the old and current `GLDrawable`.

      Remarks:

      - `glFinish()` is issued if context `isCreated()` and a `previous drawable` was bound before disassociation.
      - If the context was current on this thread, it is being released before drawable reassociation and made current afterwards.
      - Implementation may issue `makeCurrent()` and `release()` while drawable reassociation.
      - The user shall take extra care of thread synchronization, i.e. lock the involved `drawable's` `NativeSurface`s to avoid a race condition. In case `auto-drawable's` are used, their `upstream-lock` must be locked beforehand see GLAutoDrawable Locking.
      Parameters:
        `readWrite` - The read/write drawable for framebuffer operations, maybe `null` to remove association.
        `setWriteOnly` - Only change the write-drawable, if `setWriteOnly` is `true` and if the `read-drawable` differs from the `write-drawable`. Otherwise set both drawables, read and write.
      Returns:
        The previous read/write drawable
      Throws:
        `GLException` - in case `null` is being passed or this context is made current on another thread.
      See Also:
        `isGLReadDrawableAvailable()`, `setGLReadDrawable(GLDrawable)`, `getGLReadDrawable()`, `setGLDrawable(GLDrawable, boolean)`, `getGLDrawable()`

    - #### getGLDrawable

          public abstract GLDrawable getGLDrawable()

      Returns the write-drawable this context uses for framebuffer operations.

      If the read-drawable has not been changed manually via `setGLReadDrawable(GLDrawable)`, it equals to the write-drawable (default).

      Method is only thread-safe while context is `made current`.

      See Also:
        `setGLDrawable(GLDrawable, boolean)`, `setGLReadDrawable(GLDrawable)`

    - #### isGLReadDrawableAvailable

          public abstract boolean isGLReadDrawableAvailable()

      Query whether using a distinguished read-drawable is supported.
      Returns:
        true if using a read-drawable is supported with your driver/OS, otherwise false.

    - #### setGLReadDrawable

          public abstract GLDrawable setGLReadDrawable(GLDrawable read)

      Set the read-Drawable for read framebuffer operations.
      The caller should query if this feature is supported via `isGLReadDrawableAvailable()`.

      If the context was current on this thread, it is being released before switching the drawable and made current afterwards. However the user shall take extra care that not other thread attempts to make this context current. Otherwise a race condition may happen.

      Parameters:
        `read` - the read-drawable for read framebuffer operations. If null is passed, the default write drawable will be set.
      Returns:
        the previous read-drawable
      Throws:
        `GLException` - in case a read drawable is not supported or this context is made current on another thread.
      See Also:
        `isGLReadDrawableAvailable()`, `getGLReadDrawable()`

    - #### getGLReadDrawable

          public abstract GLDrawable getGLReadDrawable()

      Returns the read-Drawable this context uses for read framebuffer operations.

      If the read-drawable has not been changed manually via `setGLReadDrawable(GLDrawable)`, it equals to the write-drawable (default).

      Method is only thread-safe while context is `made current`.

      See Also:
        `isGLReadDrawableAvailable()`, `setGLReadDrawable(GLDrawable)`, `getGLReadDrawable()`

    - #### makeCurrent

          public abstract int makeCurrent()
                                   throws GLException

      Makes this GLContext current on the calling thread.

      Recursive call to `makeCurrent()` and hence `release()` are supported.

      There are two return values that indicate success and one that indicates failure.

      A return value of `CONTEXT_CURRENT_NEW` indicates that that context has been made current for the 1st time, or that the state of the underlying context or drawable has changed since the last time this context was current. In this case, the application may wish to initialize the render state.

      A return value of `CONTEXT_CURRENT` indicates that the context has been made current, with its previous state restored.

      If the context could not be made current (for example, because the underlying drawable has not ben realized on the display) , a value of `CONTEXT_NOT_CURRENT` is returned.

      This method is blocking, i.e. waits until another thread has released the context.

      The drawable's surface is being locked at entry and unlocked at `release()`

      Returns:
        - `CONTEXT_CURRENT_NEW` if the context was successfully made current the 1st time,
        - `CONTEXT_CURRENT` if the context was successfully made current,
        - `CONTEXT_NOT_CURRENT` if the context could not be made current.
      Throws:
        `GLException` - if synchronization is disabled and the context is current on another thread, or because the context could not be created or made current due to non-recoverable, window system-specific errors.

    - #### release

          public abstract void release()
                                throws GLException

      Releases control of this GLContext from the current thread.

      Recursive call to `release()` and hence `makeCurrent()` are supported.

      The drawable's surface is being unlocked at exit, assumed to be locked by `makeCurrent()`.

      Throws:
        `GLException` - if the context had not previously been made current on the current thread

    - #### copy

          public abstract void copy(GLContext source,
                  int mask)
                             throws GLException

      Copies selected groups of OpenGL state variables from the supplied source context into this one. The `mask` parameter indicates which groups of state variables are to be copied. `mask` contains the bitwise OR of the same symbolic names that are passed to the GL command `glPushAttrib`. The single symbolic constant `GL_ALL_ATTRIB_BITS` can be used to copy the maximum possible portion of rendering state.

      Not all values for GL state can be copied. For example, pixel pack and unpack state, render mode state, and select and feedback state are not copied. The state that can be copied is exactly the state that is manipulated by the GL command `glPushAttrib`.

      On most platforms, this context may not be current to any thread, including the calling thread, when this method is called. Some platforms have additional requirements such as whether this context or the source context must occasionally be made current in order for the results of the copy to be seen; these requirements are beyond the scope of this specification.

      Parameters:
        `source` - the source OpenGL context from which to copy state
        `mask` - a mask of symbolic names indicating which groups of state to copy
      Throws:
        `GLException` - if an OpenGL-related error occurred

    - #### getCurrentGL

          public static GL getCurrentGL()
                                 throws GLException

      Returns the GL object bound to this thread current context. If no context is current, throw an GLException
      Returns:
        the current context's GL object on this thread
      Throws:
        `GLException` - if no context is current

    - #### getCurrent

          public static GLContext getCurrent()

      Returns this thread current context. If no context is current, returns null.
      Returns:
        the context current on this thread, or null if no context is current.

    - #### isCurrent

          public final boolean isCurrent()

      Returns:
        true if this GLContext is current on this thread

    - #### validateCurrent

          public final void validateCurrent()
                                     throws GLException

      Throws:
        `GLException` - if this GLContext is not current on this thread

    - #### makeCurrentResultToString

          public static final String makeCurrentResultToString(int res)

      Returns a String representation of the `makeCurrent()` result.

    - #### destroy

          public abstract void destroy()

      Destroys this OpenGL context and frees its associated resources.

      The context may be current w/o recursion when calling `destroy()`, in which case this method destroys the context and releases the lock.

    - #### getRootGL

          public abstract GL getRootGL()

      Returns the implementing root GL instance of this GLContext's GL object, considering a wrapped pipelined hierarchy, see `GLBase.getDownstreamGL()`.
      Throws:
        `GLException` - if the root instance is not a GL implementation
      See Also:
        `GLBase.getRootGL()`, `GLBase.getDownstreamGL()`, `getGL()`, `setGL(GL)`

    - #### getGL

          public abstract GL getGL()

      Returns the GL pipeline object for this GLContext.
      Returns:
        the aggregated GL instance, or null if this context was not yet made current.

    - #### setGL

          public abstract GL setGL(GL gl)

      Sets the GL pipeline object for this GLContext.
      Returns:
        the set GL pipeline or null if not successful

    - #### getHandle

          public final long getHandle()

      Returns the underlying native OpenGL context handle

    - #### isCreated

          public final boolean isCreated()

      Indicates whether the underlying native OpenGL context has been created.

    - #### getAttachedObject

          public final Object getAttachedObject(String name)

      Returns the attached user object for the given name to this GLContext.

    - #### attachObject

          public final Object attachObject(String name,
                            Object obj)

      Sets the attached user object for the given name to this GLContext. Returns the previously set object or null.

    - #### detachObject

          public final Object detachObject(String name)

    - #### toString

          public String toString()

      Classname, GL, GLDrawable
      Overrides:
        `toString` in class `Object`

    - #### append

          public final StringBuilder append(StringBuilder sb)

    - #### isFunctionAvailable

          public abstract boolean isFunctionAvailable(String glFunctionName)

      Returns true if the specified OpenGL core- or extension-function can be successfully called using this GL context given the current host (OpenGL client) and display (OpenGL server) configuration. See `GLBase.isFunctionAvailable(String)` for more details.
      Parameters:
        `glFunctionName` - the name of the OpenGL function (e.g., use "glPolygonOffsetEXT" or "glPolygonOffset" to check if the `GL.glPolygonOffset(float,float)` is available).

    - #### isExtensionAvailable

          public abstract boolean isExtensionAvailable(String glExtensionName)

      Returns true if the specified OpenGL extension can be successfully called using this GL context given the current host (OpenGL client) and display (OpenGL server) configuration. See `GLBase.isExtensionAvailable(String)` for more details.
      Parameters:
        `glExtensionName` - the name of the OpenGL extension (e.g., "GL_VERTEX_PROGRAM_ARB").

    - #### getPlatformExtensionCount

          public abstract int getPlatformExtensionCount()

      Returns the number of platform extensions

    - #### getPlatformExtensionsString

          public abstract String getPlatformExtensionsString()

      Returns a non-null (but possibly empty) string containing the space-separated list of available platform-dependent (e.g., WGL, GLX) extensions. Can only be called while this context is current.

    - #### getGLExtensionCount

          public abstract int getGLExtensionCount()

      Returns the number of OpenGL extensions

    - #### getGLExtensionsString

          public abstract String getGLExtensionsString()

      Returns a non-null (but possibly empty) string containing the space-separated list of available extensions. Can only be called while this context is current. This is equivalent to `glGetString`(`GL_EXTENSIONS`)

    - #### getContextCreationFlags

          public abstract int getContextCreationFlags()

      Returns:
        Additional context creation flags, supported: `CTX_OPTION_DEBUG`.

    - #### setContextCreationFlags

          public abstract void setContextCreationFlags(int flags)

      Parameters:
        `flags` - Additional context creation flags, supported: `CTX_OPTION_DEBUG`. Unsupported flags are masked out. Only affects this context state if not created yet via `makeCurrent()`.
      See Also:
        `enableGLDebugMessage(boolean)`, `GLAutoDrawable.setContextCreationFlags(int)`

    - #### getGLVersion

          public final String getGLVersion()

      Returns a valid OpenGL version string, ie

               major.minor ([option]?[options,]*) - gl-version

      - options
        - `ES profile` ES profile
        - `Compatibility profile` Compatibility profile including fixed function pipeline and deprecated functionality
        - `Core profile` Core profile
        - `forward` Forward profile excluding deprecated functionality
        - `arb` refers to an ARB_create_context created context
        - `debug` refers to a debug context
        - `ES2 compatible` refers to an ES2 compatible implementation
        - `software` refers to a software implementation of the rasterizer
        - `hardware` refers to a hardware implementation of the rasterizer
      - gl-version the GL_VERSION string
      e.g.:

      row 2, cell 1 | row 2, cell 2

      | ES2 | `2.0 (ES profile, ES2 compatible, hardware) - 2.0 ES Profile`
      ATI | GL2 | `3.0 (Compatibility profile, arb, hardware) - 3.2.9704 Compatibility Profile Context`
      ATI | GL3 | `3.3 (Core profile, any, new, hardware) - 1.4 (3.2.9704 Compatibility Profile Context)`
      ATI | GL3bc | `3.3 (Compatibility profile, arb, hardware) - 1.4 (3.2.9704 Compatibility Profile Context)`
      NV | GL2 | `3.0 (Compatibility profile, arb, hardware) - 3.0.0 NVIDIA 195.36.07.03`
      NV | GL3 | `3.3 (Core profile, arb, hardware) - 3.3.0 NVIDIA 195.36.07.03`
      NV | GL3bc | `3.3 (Compatibility profile, arb, hardware) - 3.3.0 NVIDIA 195.36.07.03`
      NV | GL2 | `3.0 (Compatibility profile, arb, ES2 compatible, hardware) - 3.0.0 NVIDIA 290.10`

    - #### getGLVersionNumber

          public final VersionNumber getGLVersionNumber()

      Returns this context OpenGL version.
      See Also:
        `getGLSLVersionNumber()`

    - #### getGLVendorVersionNumber

          public final VersionNumberString getGLVendorVersionNumber()

      Returns the vendor's version, i.e. version number at the end of `GL_VERSION` not being the GL version.

      In case no such version exists within `GL_VERSION`, the `zero version` instance is returned.

      The vendor's version is usually the vendor's OpenGL driver version.

    - #### isGLCompatibilityProfile

          public final boolean isGLCompatibilityProfile()

    - #### isGLCoreProfile

          public final boolean isGLCoreProfile()

    - #### isGLESProfile

          public final boolean isGLESProfile()

    - #### isGLForwardCompatible

          public final boolean isGLForwardCompatible()

    - #### isGLDebugEnabled

          public final boolean isGLDebugEnabled()

    - #### isCreatedWithARBMethod

          public final boolean isCreatedWithARBMethod()

    - #### getGLSLVersionNumber

          public final VersionNumber getGLSLVersionNumber()

      Returns the matching GLSL version number, queried by this context GL via `GL2ES2.GL_SHADING_LANGUAGE_VERSION` if ≥ ES2.0 or GL2.0, otherwise a static match is being utilized.

      The context must have been current once, otherwise the `zero version` instance is returned.

      Examples w/ `major.minor`:

              1.00 (ES 2.0), 3.00 (ES 3.0)
              1.10 (GL 2.0), 1.20 (GL 2.1), 1.50 (GL 3.2),
              3.30 (GL 3.3), 4.00 (GL 4.0), 4.10 (GL 4.1), 4.20 (GL 4.2)

      Matching could also refer to the maximum GLSL version usable by this context since normal GL implementations are capable of using a lower GLSL version as well. The latter is not true on OSX w/ a GL3 context.

      Returns:
        GLSL version number if context has been made current at least once, otherwise the `zero version` instance is returned.
      See Also:
        `getGLVersionNumber()`

    - #### getGLSLVersionString

          public final String getGLSLVersionString()

      Returns the GLSL version string as to be used in a shader program, including a terminating newline '\n', i.e. for desktop

              #version 110
              ..
              #version 150 core
              #version 330 compatibility
              ...

      And for ES:

              #version 100
              #version 300 es
              ..

      If context has not been made current yet, a string of zero length is returned.

      See Also:
        `getGLSLVersionNumber()`

    - #### isGLES2Compatible

          public final boolean isGLES2Compatible()

      Returns:
        true if this context is an ES2 context or implements the extension `GL_ARB_ES3_compatibility` or `GL_ARB_ES2_compatibility`, otherwise false

    - #### isGLES3Compatible

          public final boolean isGLES3Compatible()

      Return true if this context is an ES3 context or implements the extension `GL_ARB_ES3_compatibility`, otherwise false.

      Includes [ GL ≥ 4.3, GL ≥ 3.1 w/ GL_ARB_ES3_compatibility and GLES3 ]

    - #### isHardwareRasterizer

          public final boolean isHardwareRasterizer()

      Returns:
        true if impl. is a hardware rasterizer, otherwise false.
      See Also:
        `isHardwareRasterizer(AbstractGraphicsDevice, GLProfile)`, `GLProfile.isHardwareRasterizer()`

    - #### hasGLSL

          public final boolean hasGLSL()

      Returns:
        true if context supports GLSL, i.e. is either `isGLES3()`, `isGLES2()`, `isGL3()` or `isGL2()` and major-version > 1.
      See Also:
        `GLProfile.hasGLSL()`

    - #### hasBasicFBOSupport

          public final boolean hasBasicFBOSupport()

      Returns `true` if basic FBO support is available, otherwise `false`.

      Basic FBO is supported if the context is either GL-ES >= 2.0, GL >= 3.0 [core, compat] or implements the extensions `GL_ARB_ES2_compatibility`, `GL_ARB_framebuffer_object`, `GL_EXT_framebuffer_object` or `GL_OES_framebuffer_object`.

      Basic FBO support may only include one color attachment and no multisampling, as well as limited internal formats for renderbuffer.

      See Also:
        `CTX_IMPL_FBO`

    - #### hasFullFBOSupport

          public final boolean hasFullFBOSupport()

      Returns `true` if full FBO support is available, otherwise `false`.

      Full FBO is supported if the context is either GL >= 3.0 [ES, core, compat] or implements the extensions `ARB_framebuffer_object`, or all of `EXT_framebuffer_object`, `EXT_framebuffer_multisample`, `EXT_framebuffer_blit`, `GL_EXT_packed_depth_stencil`.

      Full FBO support includes multiple color attachments and multisampling.

    - #### hasFP32CompatAPI

          public final boolean hasFP32CompatAPI()

      Returns `true` if `OES_single_precision`, fp32, fixed function point (FFP) compatibility entry points available, otherwise `false`.
      See Also:
        `CTX_IMPL_FP32_COMPAT_API`

    - #### getMaxRenderbufferSamples

          public final int getMaxRenderbufferSamples()

      Returns the maximum number of FBO RENDERBUFFER samples if `full FBO is supported`, otherwise false.

    - #### isNPOTTextureAvailable

          public boolean isNPOTTextureAvailable()

      Note: The GL impl. may return a const value, ie `GLBase.isNPOTTextureAvailable()` always returns `true`.

    - #### isTextureFormatBGRA8888Available

          public boolean isTextureFormatBGRA8888Available()

    - #### isGL4bc

          public final boolean isGL4bc()

      Indicates whether this GLContext is capable of GL4bc.

      Includes [ GL4bc ].

      See Also:
        `GLProfile.isGL4bc()`

    - #### isGL4

          public final boolean isGL4()

      Indicates whether this GLContext is capable of GL4.

      Includes [ GL4bc, GL4 ].

      See Also:
        `GLProfile.isGL4()`

    - #### isGL4core

          public final boolean isGL4core()

      Indicates whether this GLContext uses a GL4 core profile.

      Includes [ GL4 ].

    - #### isGL3bc

          public final boolean isGL3bc()

      Indicates whether this GLContext is capable of GL3bc.

      Includes [ GL4bc, GL3bc ].

      See Also:
        `GLProfile.isGL3bc()`

    - #### isGL3

          public final boolean isGL3()

      Indicates whether this GLContext is capable of GL3.

      Includes [ GL4bc, GL4, GL3bc, GL3 ].

      See Also:
        `GLProfile.isGL3()`

    - #### isGL3core

          public final boolean isGL3core()

      Indicates whether this GLContext uses a GL3 core profile.

      Includes [ GL4, GL3 ].

    - #### isGLcore

          public final boolean isGLcore()

      Indicates whether this GLContext uses a GL core profile.

      Includes [ GL4, GL3, GLES3, GLES2 ].

    - #### isCPUDataSourcingAvail

          public final boolean isCPUDataSourcingAvail()

      Indicates whether this GLContext allows CPU data sourcing (indices, vertices ..) as opposed to using a GPU buffer source (VBO), e.g. `GL2ES1.glDrawElements(int, int, int, java.nio.Buffer)`.

      Includes [GL2ES1, GLES2] == [ GL4bc, GL3bc, GL2, GLES1, GL2ES1, GLES2 ].

      See Bug 852 - https://jogamp.org/bugzilla/show_bug.cgi?id=852

    - #### hasNoDefaultVAO

          public final boolean hasNoDefaultVAO()

      Indicates whether this GLContext's native profile does not implement a default vertex array object (VAO), starting w/ OpenGL 3.1 core.

      Includes [ GL4, GL3 ].

               Due to GL 3.1 core spec: E.1. DEPRECATED AND REMOVED FEATURES (p 296),
                      GL 3.2 core spec: E.2. DEPRECATED AND REMOVED FEATURES (p 331)
               there is no more default VAO buffer 0 bound, hence generating and binding one
               to avoid INVALID_OPERATION at VertexAttribPointer.
               More clear is GL 4.3 core spec: 10.4 (p 307).

               ES 3.x is not included here.
               Due to it's ES 2.0 backward compatibility it still supports the following features:
                      client side vertex arrays
                      default vertex array object

               Binding a custom VAO with ES 3.0 would cause client side vertex arrays via glVertexPointer
               to produce GL_INVALID_OPERATION.

               However, they are marked deprecated:
                      GL ES 3.0 spec F.1. Legacy Features (p 322).
                      GL ES 3.1 spec F.1. Legacy Features (p 454).

      If no default VAO is implemented in the native OpenGL profile, an own default VAO is being used, see `getDefaultVAO()`.

      See Also:
        `getDefaultVAO()`

    - #### getDefaultVAO

          public abstract int getDefaultVAO()

      If this GLContext does not implement a default VAO, see `hasNoDefaultVAO()`, an own default VAO will be created and bound at context creation.

      If this GLContext does implement a default VAO, i.e. `hasNoDefaultVAO()` returns `false`, this method returns `0`.

      Otherwise this method returns the VAO object name representing this GLContext's own default VAO.

      See Also:
        `hasNoDefaultVAO()`

    - #### isGL2

          public final boolean isGL2()

      Indicates whether this GLContext is capable of GL2.

      Includes [ GL4bc, GL3bc, GL2 ].

      See Also:
        `GLProfile.isGL2()`

    - #### isGL2GL3

          public final boolean isGL2GL3()

      Indicates whether this GLContext is capable of GL2GL3.

      Includes [ GL4bc, GL4, GL3bc, GL3, GL2, GL2GL3 ].

      See Also:
        `GLProfile.isGL2GL3()`

    - #### isGLES1

          public final boolean isGLES1()

      Indicates whether this GLContext is capable of GLES1.

      Includes [ GLES1 ].

      See Also:
        `GLProfile.isGLES1()`

    - #### isGLES2

          public final boolean isGLES2()

      Indicates whether this GLContext is capable of GLES2.

      Includes [ GLES2, GLES3 ].

      See Also:
        `GLProfile.isGLES2()`

    - #### isGLES3

          public final boolean isGLES3()

      Indicates whether this GLContext is capable of GLES3.

      Includes [ GLES3 ].

      See Also:
        `GLProfile.isGLES3()`

    - #### isGLES

          public final boolean isGLES()

      Indicates whether this GLContext is capable of GLES.

      Includes [ GLES3, GLES1, GLES2 ].

      See Also:
        `GLProfile.isGLES()`

    - #### isGL2ES1

          public final boolean isGL2ES1()

      Indicates whether this GLContext is capable of GL2ES1.

      Includes [ GL4bc, GL3bc, GL2, GLES1, GL2ES1 ].

      See Also:
        `GLProfile.isGL2ES1()`

    - #### isGL2ES2

          public final boolean isGL2ES2()

      Indicates whether this GLContext is capable of GL2ES2.

      Includes [ GL4bc, GL4, GL3bc, GL3, GLES3, GL2, GL2GL3, GL2ES2, GLES2 ].

      See Also:
        `GLProfile.isGL2ES2()`

    - #### isGL2ES3

          public final boolean isGL2ES3()

      Indicates whether this GLContext is capable of GL2ES3.

      Includes [ GL4bc, GL4, GL3bc, GL3, GLES3, GL3ES3, GL2, GL2GL3 ].

      See Also:
        `GLProfile.isGL2ES3()`, `isGL3ES3()`, `isGL2GL3()`

    - #### isGL3ES3

          public final boolean isGL3ES3()

      Indicates whether this GLContext is capable of GL3ES3.

      Includes [ GL4bc, GL4, GL3bc, GL3, GLES3 ].

      See Also:
        `GLProfile.isGL3ES3()`

    - #### isGL4ES3

          public final boolean isGL4ES3()

      Returns true if this profile is capable of GL4ES3, i.e. if `isGLES3Compatible()` returns true.

      Includes [ GL ≥ 4.3, GL ≥ 3.1 w/ GL_ARB_ES3_compatibility and GLES3 ]

      See Also:
        `GLProfile.isGL4ES3()`

    - #### setSwapInterval

          public final boolean setSwapInterval(int interval)
                                        throws GLException

      Set the swap interval of the current context and attached drawable.
      Parameters:
        `interval` - Should be ≥ 0. 0 disables the vertical synchronization, where ≥ 1 is the number of vertical refreshes before a swap buffer occurs. A value < 0 is ignored.
      Returns:
        true if the operation was successful, otherwise false
      Throws:
        `GLException` - if the context is not current.

    - #### getSwapInterval

          public final int getSwapInterval()

      Return the current swap interval.

      If the context has not been made current at all, the default value `-1` is returned.

      For a valid context the default value is `1` in case of an EGL based profile (ES1 or ES2) and `-1` (undefined) for desktop.

    - #### queryMaxSwapGroups

          public final boolean queryMaxSwapGroups(int[] maxGroups,
                                   int maxGroups_offset,
                                   int[] maxBarriers,
                                   int maxBarriers_offset)

    - #### joinSwapGroup

          public final boolean joinSwapGroup(int group)

    - #### getSwapGroup

          public int getSwapGroup()

    - #### bindSwapBarrier

          public final boolean bindSwapBarrier(int group,
                                int barrier)

    - #### getBoundFramebuffer

          public abstract int getBoundFramebuffer(int target)

      Return the framebuffer name bound to this context, see `GL.glBindFramebuffer(int, int)`.

      Method is only thread-safe while context is `made current`.

    - #### getDefaultDrawFramebuffer

          public abstract int getDefaultDrawFramebuffer()

      Return the default draw framebuffer name.

      May differ from it's default `zero` in case an framebuffer object (`FBObject`) based drawable is being used.

      Method is only thread-safe while context is `made current`.

    - #### getDefaultReadFramebuffer

          public abstract int getDefaultReadFramebuffer()

      Return the default read framebuffer name.

      May differ from it's default `zero` in case an framebuffer object (`FBObject`) based drawable is being used.

      Method is only thread-safe while context is `made current`.

    - #### getDefaultReadBuffer

          public abstract int getDefaultReadBuffer()

      Returns the default color buffer within the current bound `getDefaultReadFramebuffer()`, i.e. GL_READ_FRAMEBUFFER​, which will be used as the source for pixel reading commands, like `glReadPixels` etc.

      For offscreen framebuffer objects this is `GL.GL_COLOR_ATTACHMENT0`, otherwise this is `GL.GL_FRONT` for single buffer configurations and `GL.GL_BACK` for double buffer configurations.

      Note-1: Neither ES1 nor ES2 supports selecting the read buffer via glReadBuffer and `GL.GL_BACK` is the default.

      Note-2: ES3 only supports `GL.GL_BACK`, `GL.GL_NONE` or `GL.GL_COLOR_ATTACHMENT0`+i

      Note-3: See `swapBuffersBeforeRead` for read-pixels and swap-buffers implications.

      Method is only thread-safe while context is `made current`.

    - #### getDefaultPixelDataType

          public abstract int getDefaultPixelDataType()

      Get the default pixel data type, as required by e.g. `GL.glReadPixels(int, int, int, int, int, int, java.nio.Buffer)`.

      Method is only thread-safe while context is `made current`.

    - #### getDefaultPixelDataFormat

          public abstract int getDefaultPixelDataFormat()

      Get the default pixel data format, as required by e.g. `GL.glReadPixels(int, int, int, int, int, int, java.nio.Buffer)`.

      Method is only thread-safe while context is `made current`.

    - #### getGLDebugMessageExtension

          public abstract String getGLDebugMessageExtension()

      Returns:
        The extension implementing the GLDebugOutput feature, either `GLExtensions.ARB_debug_output` or `GLExtensions.AMD_debug_output`. If unavailable or called before initialized via `makeCurrent()`, null is returned.

    - #### isGLDebugSynchronous

          public abstract boolean isGLDebugSynchronous()

      Returns:
        the current synchronous debug behavior, set via `setGLDebugSynchronous(boolean)`.

    - #### setGLDebugSynchronous

          public abstract void setGLDebugSynchronous(boolean synchronous)

      Enables or disables the synchronous debug behavior via `glEnable/glDisable(GL_DEBUG_OUTPUT_SYNCHRONOUS)`, if extension is `GLExtensions.ARB_debug_output`. There is no equivalent for `GLExtensions.AMD_debug_output`.

      The default is `true`, ie `GL2ES2.GL_DEBUG_OUTPUT_SYNCHRONOUS`.

    - #### isGLDebugMessageEnabled

          public abstract boolean isGLDebugMessageEnabled()

      Returns:
        true if the GLDebugOutput feature is enabled or not.

    - #### enableGLDebugMessage

          public abstract void enableGLDebugMessage(boolean enable)
                                             throws GLException

      Enables or disables the GLDebugOutput feature of extension `GLExtensions.ARB_debug_output` or `GLExtensions.AMD_debug_output`, if available.

      To enable the GLDebugOutput feature `enableGLDebugMessage(true)` or `setContextCreationFlags`(`CTX_OPTION_DEBUG`) shall be called before context creation via `makeCurrent()`!

      In case `GLAutoDrawable` are being used, `glAutoDrawable.setContextCreationFlags`(`CTX_OPTION_DEBUG`) shall be issued before context creation via `makeCurrent()`!

      After context creation, the GLDebugOutput feature may be enabled or disabled at any time using this method.

      Parameters:
        `enable` - If true enables, otherwise disables the GLDebugOutput feature.
      Throws:
        `GLException` - if this context is not current or GLDebugOutput registration failed (enable)
      See Also:
        `setContextCreationFlags(int)`, `addGLDebugListener(GLDebugListener)`, `GLAutoDrawable.setContextCreationFlags(int)`

    - #### addGLDebugListener

          public abstract void addGLDebugListener(GLDebugListener listener)

      Add `GLDebugListener`.
      Parameters:
        `listener` - `GLDebugListener` handling `GLDebugMessage`s
      See Also:
        `enableGLDebugMessage(boolean)`, `removeGLDebugListener(GLDebugListener)`

    - #### removeGLDebugListener

          public abstract void removeGLDebugListener(GLDebugListener listener)

      Remove `GLDebugListener`.
      Parameters:
        `listener` - `GLDebugListener` handling `GLDebugMessage`s
      See Also:
        `enableGLDebugMessage(boolean)`, `addGLDebugListener(GLDebugListener)`

    - #### glDebugMessageControl

          public abstract void glDebugMessageControl(int source,
                                   int type,
                                   int severity,
                                   int count,
                                   IntBuffer ids,
                                   boolean enabled)

      Generic entry for `GL2ES2.glDebugMessageControl(int, int, int, int, IntBuffer, boolean)` and `GL2GL3.glDebugMessageEnableAMD(int, int, int, IntBuffer, boolean)` of the GLDebugOutput feature.
      See Also:
        `enableGLDebugMessage(boolean)`

    - #### glDebugMessageControl

          public abstract void glDebugMessageControl(int source,
                                   int type,
                                   int severity,
                                   int count,
                                   int[] ids,
                                   int ids_offset,
                                   boolean enabled)

      Generic entry for `GL2ES2.glDebugMessageControl(int, int, int, int, int[], int, boolean)` and `GL2GL3.glDebugMessageEnableAMD(int, int, int, int[], int, boolean)` of the GLDebugOutput feature.
      See Also:
        `enableGLDebugMessage(boolean)`

    - #### glDebugMessageInsert

          public abstract void glDebugMessageInsert(int source,
                                  int type,
                                  int id,
                                  int severity,
                                  String buf)

      Generic entry for `GL2ES2.glDebugMessageInsert(int, int, int, int, int, String)` and `GL2GL3.glDebugMessageInsertAMD(int, int, int, int, String)` of the GLDebugOutput feature.
      See Also:
        `enableGLDebugMessage(boolean)`

    - #### getMaxMajor

          public static final int getMaxMajor(int ctxProfile)

    - #### getMaxMinor

          public static final int getMaxMinor(int ctxProfile,
                        int major)

    - #### isValidGLVersion

          public static final boolean isValidGLVersion(int ctxProfile,
                                 int major,
                                 int minor)

      Returns true, if the major.minor is not inferior to the lowest valid version and does not exceed the highest known major number by more than one.

      The minor version number is ignored by the upper limit validation and the major version number may exceed by one.

      The upper limit check is relaxed since we don't want to cut-off unforseen new GL version since the release of JOGL.

      Hence it is important to iterate through GL version from the upper limit and `decrementGLVersion(int, int[], int[])` until invalid.

    - #### clipGLVersion

          public static final boolean clipGLVersion(int ctxProfile,
                              int[] major,
                              int[] minor)

      Clip the given GL version to the maximum known valid version if exceeding.
      Returns:
        true if clipped, i.e. given value exceeds maximum, otherwise false.

    - #### decrementGLVersion

          public static final boolean decrementGLVersion(int ctxProfile,
                                   int[] major,
                                   int[] minor)

      Decrement the given GL version by one and return true if still valid, otherwise false.

      If the given version exceeds the maximum known valid version, it is `clipped` and true is returned.

      Parameters:
        `ctxProfile` -
        `major` -
        `minor` -
      Returns:

    - #### isFBOAvailable

          public static final boolean isFBOAvailable(AbstractGraphicsDevice device,
                               GLProfile glp)

      Returns true if it is possible to create an framebuffer object (FBO).

      FBO feature is implemented in OpenGL, hence it is `GLProfile` dependent.

      FBO support is queried as described in `hasBasicFBOSupport()`.

      Parameters:
        `device` - the device to request whether FBO is available for
        `glp` - `GLProfile` to check for FBO capabilities
      See Also:
        `hasBasicFBOSupport()`

    - #### isHardwareRasterizer

          public static final int isHardwareRasterizer(AbstractGraphicsDevice device,
                                 GLProfile glp)

      Returns:
        `1` if using a hardware rasterizer, `0` if using a software rasterizer and `-1` if not determined yet.
      See Also:
        `isHardwareRasterizer()`, `GLProfile.isHardwareRasterizer()`

    - #### isGLES1Available

          public static boolean isGLES1Available(AbstractGraphicsDevice device,
                                 boolean[] isHardware)

    - #### isGLES2Available

          public static boolean isGLES2Available(AbstractGraphicsDevice device,
                                 boolean[] isHardware)

    - #### isGLES3Available

          public static boolean isGLES3Available(AbstractGraphicsDevice device,
                                 boolean[] isHardware)

    - #### isGLES3CompatibleAvailable

          public static final boolean isGLES3CompatibleAvailable(AbstractGraphicsDevice device)

      Returns true if a ES3 compatible profile is available, i.e. either a ≥ 4.3 context or a ≥ 3.1 context supporting `GL_ARB_ES3_compatibility`, otherwise false.

      Includes [ GL ≥ 4.3, GL ≥ 3.1 w/ GL_ARB_ES3_compatibility and GLES3 ]

    - #### isGL4bcAvailable

          public static boolean isGL4bcAvailable(AbstractGraphicsDevice device,
                                 boolean[] isHardware)

    - #### isGL4Available

          public static boolean isGL4Available(AbstractGraphicsDevice device,
                               boolean[] isHardware)

    - #### isGL3bcAvailable

          public static boolean isGL3bcAvailable(AbstractGraphicsDevice device,
                                 boolean[] isHardware)

    - #### isGL3Available

          public static boolean isGL3Available(AbstractGraphicsDevice device,
                               boolean[] isHardware)

    - #### isGL2Available

          public static boolean isGL2Available(AbstractGraphicsDevice device,
                               boolean[] isHardware)

Copyright 2010 JogAmp Community.