Package org.lwjgl.opengl

Class CGL

  • public class CGL
extends java.lang.Object
    Native bindings to CGL.

    • Method Detail

      • CGLGetCurrentContext

        public static long CGLGetCurrentContext()
        Returns the current rendering context. If there is none, returns NULL.

      • CGLSetCurrentContext

        public static int CGLSetCurrentContext​(long context)
        Sets the specified rendering context as the current rendering context.

        There can be only one current rendering context. Subsequent OpenGL rendering calls operate on the current rendering context to modify the drawable object associated with it.

        You can use AGL macros to bypass the current rendering context mechanism and maintain your own current rendering context.

        A context is current on a per-thread basis. Multiple threads must serialize calls into the same context.

        Parameters:
        context - the rendering context to set as the current rendering context. Pass NULL to release the current rendering context without assigning a new one.

      • CGLGetShareGroup

        public static long CGLGetShareGroup​(long ctx)
        Returns the sharegroup of the specified rendering context.
        Parameters:
        ctx - a rendering context

      • nCGLChoosePixelFormat

        public static int nCGLChoosePixelFormat​(long attribs,
                                        long pix,
                                        long npix)
        Unsafe version of: ChoosePixelFormat

      • CGLDestroyPixelFormat

        public static int CGLDestroyPixelFormat​(long pix)
        Frees the memory associated with a pixel format object. Calling this function is equivalent to calling ReleasePixelFormat.
        Parameters:
        pix - the pixel format object to destroy

      • nCGLDescribePixelFormat

        public static int nCGLDescribePixelFormat​(long pix,
                                          int pix_num,
                                          int attrib,
                                          long value)
        Unsafe version of: DescribePixelFormat

      • CGLReleasePixelFormat

        public static void CGLReleasePixelFormat​(long pix)
        Decrements the reference count of a pixel format object.

        The system retains the pixel format object when you call the function CreateContext, so you can release a pixel format object immediately after passing it to the context creation function.

        Each call to CGLReleasePixelFormat decreases the reference count by 1. If the reference count reaches 0, the pixel format object is destroyed.

        Parameters:
        pix - the pixel format object whose reference count should be decremented

      • CGLRetainPixelFormat

        public static long CGLRetainPixelFormat​(long pix)
        Increments the receiver's reference count.

        Each call to CGLRetainPixelFormat increases the reference count by 1. Each call to CGLRetainPixelFormat must be matched with a call to ReleasePixelFormat.

        Parameters:
        pix - the pixel format object whose reference count should be incremented

      • CGLGetPixelFormatRetainCount

        public static int CGLGetPixelFormatRetainCount​(long pix)
        Returns the retain count of a pixel format object.
        Parameters:
        pix - a pixel format object

      • nCGLQueryRendererInfo

        public static int nCGLQueryRendererInfo​(int display_mask,
                                        long rend,
                                        long nrend)
        Unsafe version of: QueryRendererInfo

      • CGLQueryRendererInfo

        public static int CGLQueryRendererInfo​(int display_mask,
                                       PointerBuffer rend,
                                       java.nio.IntBuffer nrend)
        Creates a renderer information object that contains properties and values for renderers able to drive all the specified displays in a given display mask.
        Parameters:
        display_mask - a bit field that contains the bitwise OR of OpenGL display masks returned by the CGDisplayIDToOpenGLDisplayMask function. If you want to obtain information for all renderers in the system you must call CGLQueryRendererInfo once for each display bit.
        rend - the memory address of a renderer information object. On return, points to a renderer information object that describes all renderers that are able to drive the displays specified by the display_mask parameter. If display_mask does not specify any displays, the value of rend is set to NULL. You must call DestroyRendererInfo when you no longer need this object.
        nrend - on return, points to the number of renderers described in the renderer information object. If display_mask does not specify any displays, the value of nrend is set to 0.

      • CGLDestroyRendererInfo

        public static int CGLDestroyRendererInfo​(long rend)
        Frees resources associated with a renderer information object.
        Parameters:
        rend - the renderer information object to destroy

      • nCGLDescribeRenderer

        public static int nCGLDescribeRenderer​(long rend,
                                       int rend_num,
                                       int prop,
                                       long value)
        Unsafe version of: DescribeRenderer

      • nCGLCreateContext

        public static int nCGLCreateContext​(long pix,
                                    long share,
                                    long ctx)
        Unsafe version of: CreateContext

      • CGLCreateContext

        public static int CGLCreateContext​(long pix,
                                   long share,
                                   PointerBuffer ctx)
        Creates a CGL rendering context.
        Parameters:
        pix - a pixel format object created by calling the function ChoosePixelFormat
        share - the rendering context with which to share the OpenGL object state — including texture objects, programs and shader display lists, vertex array objects, vertex buffer objects, pixel buffer objects, and frame buffer objects — and the object state associated which each of these object types. Pass NULL to indicate that no sharing is to take place.
        ctx - the memory address of a context object. On return, points to a new context object with the buffers and attributes specified by the pix parameter. If the context can not be created as specified, the value of ctx is set to NULL.

      • CGLDestroyContext

        public static int CGLDestroyContext​(long ctx)
        Frees the resources associated with a rendering context.

        Starting in Mac OS 10.5, CGL rendering contexts are reference counted. For compatibility reasons, calling CGLDestroyContext clears the drawable associated with the rendering context. Calling CGLDestroyContext is the equivalent of calling both ClearDrawable and ReleaseContext.

        Parameters:
        ctx - the rendering context to destroy

      • CGLCopyContext

        public static int CGLCopyContext​(long src,
                                 long dst,
                                 int mask)
        Copies the specified state variables from one rendering context to another.
        Parameters:
        src - the source rendering context
        dst - the destination rendering context
        mask - a mask that specifies the state variables to copy. Pass a bit field that contains the bitwise OR of the state variable names that you want to copy. Use the symbolic mask constants that are passed to the OpenGL function PushAttrib. To copy as many state variables as possible, supply the constant ALL_ATTRIB_BITS.

      • CGLRetainContext

        public static long CGLRetainContext​(long ctx)
        Increments the retain count on a CGL rendering context.

        Each call to CGLRetainContext increases the retain count by 1. To prevent memory leaks, each retain call must be balanced with a call to ReleaseContext.

        Parameters:
        ctx - the rendering context to be retained
        Returns:
        the same context that was passed into the function.

      • CGLReleaseContext

        public static void CGLReleaseContext​(long ctx)
        Decrements the retain count on a CGL rendering context.

        Each call to CGLReleaseContext decreases the retain count by 1.

        When the retain count reaches 0, all resources associated with the rendering context are freed. If the rendering context that you pass is the current rendering context and it is freed, the current context is set to NULL and there is no current rendering context after the function executes. After the context is freed, you must make sure you do not use the destroyed rendering context. This includes using CGL macros in which the rendering context is explicitly passed to OpenGL.

        Parameters:
        ctx - the rendering context to be released

      • CGLGetContextRetainCount

        public static int CGLGetContextRetainCount​(long ctx)
        Returns the current retain count of a CGL rendering context.
        Parameters:
        ctx - the CGL rendering context whose retain count you wish to discover

      • CGLGetPixelFormat

        public static long CGLGetPixelFormat​(long ctx)
        Retrieves the current pixel format associated with a CGL rendering context.

        The pixel format object is not retained before being returned to your application. If your application needs to maintain this object, it should call RetainPixelFormat.

        Parameters:
        ctx - the CGL rendering context whose format you want to receive

      • nCGLCreatePBuffer

        public static int nCGLCreatePBuffer​(int width,
                                    int height,
                                    int target,
                                    int internalFormat,
                                    int max_level,
                                    long pbuffer)
        Unsafe version of: CreatePBuffer

      • CGLCreatePBuffer

        public static int CGLCreatePBuffer​(int width,
                                   int height,
                                   int target,
                                   int internalFormat,
                                   int max_level,
                                   PointerBuffer pbuffer)
        Creates a pixel buffer of the specified size, compatible with the specified texture target.

        This function does not have any knowledge of OpenGL contexts or pixel format objects and does not specifically allocate the storage needed for the actual pixel buffer. These operations occur when you call the function SetPBuffer.

        You can determine the dimensional limits of a pixel buffer by calling the OpenGL function glGetInteger. You can find the maximum size supported by querying GL_MAX_VIEWPORT_DIMS and the minimum size by querying GL_MIN_PBUFFER_VIEWPORT_DIMS_APPLE, which returns two integer values (similar to GL_MAX_VIEWPORT_DIMS). All pixel buffer dimensions that you request with the function aglCreatePBuffer should fall within these limits (inclusively) and should comply with any limitations imposed by the texture target you select.

        The maximum viewport size supported in OS X is quite large. You should take into consideration the amount of video or system memory required to support the requested pixel buffer size, including additional memory needed for multiple buffers and options such as multisampling.

        Starting in OS X v10.5, pixel buffer objects are reference counted. Pixel buffer objects are created with a reference count of 1 and are destroyed when the last reference to the object is released.

        Deprecated in OS X v10.7.

        Parameters:
        width - the width, in pixels, of the pixel buffer
        height - the height, in pixels, of the pixel buffer
        target - a constant that specifies the type of the pixel buffer target texture. One of:
        TEXTURE_2DTEXTURE_CUBE_MAPTEXTURE_RECTANGLE
        internalFormat - a constant that specifies the internal color format of the pixel buffer. The format controls whether the alpha channel of the pixel buffer is used for texturing operations. One of:
        RGBGL11.GL_RGBA
        max_level - the maximum level of mipmap detail allowable. Pass 0 for a pixel buffer that is not using mipmaps. The value passed should never exceed the actual maximum number of mipmap levels that can be represented with the given width and height.
        pbuffer - on return, points to a new pixel buffer object

      • CGLDestroyPBuffer

        public static int CGLDestroyPBuffer​(long pbuffer)
        Releases the resources associated with a pixel buffer object.

        Starting in OS X v10.5, pixel buffer objects are reference counted. Calling this function is equivalent to calling ReleasePBuffer.

        Deprecated in OS X v10.7.

        Parameters:
        pbuffer - the pixel buffer object whose resources you want to release

      • nCGLDescribePBuffer

        public static int nCGLDescribePBuffer​(long obj,
                                      long width,
                                      long height,
                                      long target,
                                      long internalFormat,
                                      long mipmap)
        Unsafe version of: DescribePBuffer

      • CGLDescribePBuffer

        public static int CGLDescribePBuffer​(long obj,
                                     java.nio.IntBuffer width,
                                     java.nio.IntBuffer height,
                                     java.nio.IntBuffer target,
                                     java.nio.IntBuffer internalFormat,
                                     java.nio.IntBuffer mipmap)
        Retrieves information that describes the specified pixel buffer object.

        The width, height, texture target, and internal texture color format of a pixel buffer object are set at its creation and cannot be changed without destroying and recreating the object. The level is set when the pixel buffer object is attached to a rendering context by calling the function SetPBuffer.

        Deprecated in OS X v10.7.

        Parameters:
        obj - a pointer to the pixel buffer object
        width - on return, points to the width, in pixels, of the pixel buffer
        height - on return, points to the height, in pixels, of the pixel buffer
        target - on return, points to a constant that specifies the pixel buffer texture target
        internalFormat - on return, points to a constant that specifies the internal color format of the pixel buffer
        mipmap - on return, points to the mipmap level of the pixel buffer or 0 if it doesn't use mipmaps

      • CGLTexImagePBuffer

        public static int CGLTexImagePBuffer​(long ctx,
                                     long pbuffer,
                                     int source)
        Binds the contents of a pixel buffer to a data source for a texture object.

        You must generate and bind a texture name (using standard OpenGL texturing calls) that is compatible with the pixel buffer texture target. Don't supply a texture object that was used previously for nonpixel buffer texturing operations unless you first call glDeleteTextures to regenerate the texture name.

        If you modify the content of a pixel buffer that uses mipmap levels, you must call this function again before drawing with the pixel buffer, to ensure that the content is synchronized with OpenGL. For pixel buffers without mipmaps, simply rebind to the texture object to synchronize content.

        No OpenGL texturing calls that modify a pixel buffer texture content are permitted (such as glTexSubImage2D or glCopyTexImage2D) with the pixel buffer texture as the destination. It is permitted to use texturing commands to read data from a pixel buffer texture, such as glCopyTexImage2D, with the pixel buffer texture as the source. It is also legal to use OpenGL functions such as glReadPixels to read the contents of a pixel buffer directly through the pixel buffer context.

        Note that texturing with the CGLTexImagePBuffer function can fail to produce the intended results without error in the same way other OpenGL texturing commands can normally fail. The function fails if you set an incompatible filter mode, do not enable the proper texture target, or other conditions described in the OpenGL specification.

        You don't need to share a context to use a pixel buffer object as a texture source. You can use independent pixel format objects and OpenGL contexts for both the pixel buffer and the target drawable object without sharing resources, and still texture using a pixel buffer in the target context.

        Deprecated in OS X v10.7.

        Parameters:
        ctx - a rendering context, which is the target context for the texture operation. This is the context that you plan to render content to. This is not the context attached to the pixel buffer.
        pbuffer - a pixel buffer object
        source - the source buffer to get the texture from, which should be a valid OpenGL buffer such as GL_FRONT or GL_BACK and should be compatible with the buffer and renderer attributes that you used to create the rendering context attached to the pixel buffer. This means that the pixel buffer must possess the buffer in question for the texturing operation to succeed.

      • CGLRetainPBuffer

        public static long CGLRetainPBuffer​(long pbuffer)
        Increments the retain count on a pixel buffer object.

        Each call to CGLRetainPBuffer increases the retain count by 1. To prevent the pixel buffer object from being leaked, each retain call must be matched with a call to ReleasePBuffer.

        Deprecated in OS X v10.7.

        Parameters:
        pbuffer - the pixel buffer object whose retain count you wish to increment

      • CGLReleasePBuffer

        public static void CGLReleasePBuffer​(long pbuffer)
        Releases the resources associated with a pixel buffer object.

        Starting in OS X v10.5, pixel buffer objects are reference counted. Calling this function is equivalent to calling CGLReleasePBuffer.

        Deprecated in OS X v10.7.

        Parameters:
        pbuffer - the pixel buffer object whose resources you want to release

      • CGLGetPBufferRetainCount

        public static int CGLGetPBufferRetainCount​(long pbuffer)
        Returns the retain count of a pixel buffer object.

        Deprecated in OS X v10.7.

        Parameters:
        pbuffer - the pixel buffer object whose retain count you wish to retrieve

      • nCGLSetOffScreen

        public static int nCGLSetOffScreen​(long ctx,
                                   int width,
                                   int height,
                                   int rowbytes,
                                   long baseaddr)
        Unsafe version of: SetOffScreen

      • CGLSetOffScreen

        public static int CGLSetOffScreen​(long ctx,
                                  int width,
                                  int height,
                                  int rowbytes,
                                  java.nio.ByteBuffer baseaddr)
        Attaches a rendering context to an offscreen buffer.

        Before calling this function, you must set up the rendering context using a pixel format object created with the kCGLPFAOffScreen attribute. For more information about kCGLPFAOffScreen, see Buffer and Renderer Attributes.

        After calling this function, subsequent OpenGL drawing is rendered into the offscreen buffer and the viewport of the rendering context is set to the full size of the offscreen area.

        To exit offscreen mode, call ClearDrawable.

        To obtain functionality similar to offscreen mode on renderers that do not support it, attach the context to a hidden window and use the OpenGL function glReadPixels.

        Deprecated in OS X v10.7.

        Parameters:
        ctx - a rendering context
        width - the width, in pixels, of the offscreen buffer
        height - the height, in pixels, of the offscreen buffer
        rowbytes - the number of bytes per row of the offscreen buffer, which must be greater than or equal to width times bytes per pixel
        baseaddr - a pointer to a block of memory to use as the offscreen buffer. The size of the memory must be at least rowbytes*height bytes.

      • nCGLGetOffScreen

        public static int nCGLGetOffScreen​(long ctx,
                                   long width,
                                   long height,
                                   long rowbytes,
                                   long baseaddr)
        Unsafe version of: GetOffScreen

      • CGLGetOffScreen

        public static int CGLGetOffScreen​(long ctx,
                                  java.nio.IntBuffer width,
                                  java.nio.IntBuffer height,
                                  java.nio.IntBuffer rowbytes,
                                  PointerBuffer baseaddr)
        Retrieves an offscreen buffer and its parameters for a specified rendering context.

        Deprecated in OS X v10.7.

        Parameters:
        ctx - a rendering context
        width - on return, points to the width, in pixels, of the offscreen buffer. If the rendering context is not attached to an offscreen drawable object, the value of width is set to 0.
        height - on return, points to the height, in pixels, of the offscreen buffer. If the rendering context is not attached to an offscreen drawable object, the value of height is set to 0.
        rowbytes - on return, points to the number of bytes per row of the offscreen buffer. If the context is not attached to an offscreen drawable object, the value of rowbytes is set to 0.
        baseaddr - on return, points to the base address of the offscreen buffer. If the context is not attached to an offscreen drawable object, the value of baseaddr is set to NULL.

      • CGLSetFullScreen

        public static int CGLSetFullScreen​(long ctx)
        Attaches a rendering context to its full-screen drawable object.

        Before calling this function, you must set up the rendering context using a pixel format object created with the kCGLPFAFullScreen attribute (see Buffer and Renderer Attributes). Some OpenGL renderers, such as the software renderer, do not support full-screen mode. After you call the function ChoosePixelFormat with the full-screen attribute, you need to check whether the pixel format object is created successfully.

        You must capture the display prior to entering full-screen mode and release it after exiting. After calling this function, subsequent OpenGL drawing is rendered into the entire screen. For more information, see OpenGL Programming Guide for Mac.

        To exit full-screen mode, call ClearDrawable.

        Deprecated in OS X v10.7. Use SetFullScreenOnDisplay instead.

        Parameters:
        ctx - a rendering context

      • CGLSetFullScreenOnDisplay

        public static int CGLSetFullScreenOnDisplay​(long ctx,
                                            int display_mask)
        Attaches a rendering context to a full-screen drawable object." +

        This function obtains a drawable object that covers an entire screen and attaches it to the rendering context. A full-screen rendering context may allow the underlying renderer to provide better performance compared to a context associated with a window that partially covers the screen.

        Prior to calling this function, your application should ensure that the context is capable of rendering to this display by querying the appropriate renderer properties. For more information, see QueryRendererInfo. Note that some renderers, including the software renderer, do not support full-screen mode.

        You must capture the screen prior to entering full-screen mode and release it after exiting. After calling this function, subsequent OpenGL drawing is rendered into the entire screen. For more information, see OpenGL Programming Guide for Mac.

        To exit full-screen mode, call ClearDrawable.

        In OS X v10.6 or later, this function is not deprecated, but is usually not necessary. If your application creates a window that completely covers the screen, the system implicitly creates a full-screen instance, for the same potential performance benefit.

        Deprecated in OS X v10.7.

        Parameters:
        ctx - a rendering context
        display_mask - a bit field that contains the OpenGL display mask for the screen you wish the context to cover

      • CGLSetPBuffer

        public static int CGLSetPBuffer​(long ctx,
                                long pbuffer,
                                int face,
                                int level,
                                int screen)
        Attaches a pixel buffer object to a rendering context.

        The first time you call this function for a specific pixel buffer object, the system creates the necessary buffers. The buffers are created to support the attributes dictated by the pixel format object used to create the rendering context and by the parameters used to create the pixel buffer object. The storage requirements for pixel buffer objects, which can be quite large, are very similar to the requirements for windows or views with OpenGL contexts attached. All drawable objects compete for the same scarce resources. This function can fail is there is not enough contiguous VRAM for each buffer. It's best to code defensively with a scheme that reduces resource consumption without causing the application to resort to failure. Unless, of course, failure is the only viable alternative.

        The ability to attach a pixel buffer to a context is supported only on renderers that export GL_APPLE_pixel_buffer in the GL_EXTENSIONS string. Before calling this function, you should programmatically determine if it’s possible to attach a pixel buffer to a context by querying GL_EXTENSIONS in the context and looking for GL_APPLE_pixel_buffer. If that extension is not present, the renderer won’t allow setting the pixel buffer.

        In order of performance, these are the renderers you should consider using when setting up a rendering context to attach to a pixel buffer:

        • A hardware renderer.
        • The generic render, but only with an offscreen pixel format and glTexSubImage.
        • The Apple software renderer, which supports pixel buffers in OS X v10.4.8 and later.

        Deprecated in OS X v10.7.

        Parameters:
        ctx - the rendering context to attach the pixel buffer to
        pbuffer - a pixel buffer object
        face - the cube map face to draw if the pixel buffer texture target type is TEXTURE_CUBE_MAP; otherwise pass 0.
        level - the mipmap level to draw. This must not exceed the maximum mipmap level set when the pixel buffer object was created. Pass 0 for a texture target that does not support mipmaps.
        screen - a virtual screen value. The virtual screen determines the renderer OpenGL uses to draw to the pixel buffer object. For best performance, for a pixel buffer used as a texture source, you should supply the virtual screen value that results in using the same renderer used by the context that's the texturing target.

      • nCGLGetPBuffer

        public static int nCGLGetPBuffer​(long ctx,
                                 long pbuffer,
                                 long face,
                                 long level,
                                 long screen)
        Unsafe version of: GetPBuffer

      • CGLGetPBuffer

        public static int CGLGetPBuffer​(long ctx,
                                PointerBuffer pbuffer,
                                java.nio.IntBuffer face,
                                java.nio.IntBuffer level,
                                java.nio.IntBuffer screen)
        Retrieves a pixel buffer and its parameters for a specified rendering context.

        Deprecated in OS X v10.7.

        Parameters:
        ctx - a rendering context
        pbuffer - on return, points to the pixel buffer object attached to the rendering context
        face - on return, points to the cube map face that is set if the pixel buffer texture target type is TEXTURE_CUBE_MAP; otherwise 0 for all other texture target types.
        level - on return, points to the current mipmap level for drawing
        screen - on return, points to the current virtual screen number, as set by the last valid call to SetPBuffer

      • CGLClearDrawable

        public static int CGLClearDrawable​(long ctx)
        Disassociates a rendering context from any drawable objects attached to it.
        Parameters:
        ctx - a rendering context

      • CGLFlushDrawable

        public static int CGLFlushDrawable​(long ctx)
        Copies the back buffer of a double-buffered context to the front buffer.

        To create a double-buffered context, specify the PFADoubleBuffer attribute when you create the pixel format object for the rendering context. If the backing store attribute is set to false, the buffers can be exchanged rather than copied. This is often the case in full-screen mode. If the receiver is not a double-buffered context, this call does nothing.

        If you set the swap interval attribute (CPSwapInterval) appropriately, the copy takes place during the vertical retrace of the display, rather than immediately after CGLFlushDrawable is called. An implicit Flush operation is performed by CGLFlushDrawable before it returns. For optimal performance, an application should not call glFlush immediately before calling CGLFlushDrawable. Subsequent OpenGL commands can be issued immediately after calling CGLFlushDrawable, but are not executed until the buffer copy is completed.

        Parameters:
        ctx - the context object

      • nCGLIsEnabled

        public static int nCGLIsEnabled​(long ctx,
                                int pname,
                                long enable)
        Unsafe version of: IsEnabled

      • nCGLSetParameter

        public static int nCGLSetParameter​(long ctx,
                                   int pname,
                                   long params)
        Unsafe version of: SetParameter

      • nCGLGetParameter

        public static int nCGLGetParameter​(long ctx,
                                   int pname,
                                   long params)
        Unsafe version of: GetParameter

      • CGLSetVirtualScreen

        public static int CGLSetVirtualScreen​(long ctx,
                                      int screen)
        Forces subsequent OpenGL commands to the specified virtual screen.

        Setting the virtual screen forces the renderer associated with the virtual screen to process OpenGL commands issued to the specified context. Changing the virtual screen changes the current renderer. You should use this function only when it is necessary to override the default behavior. The current virtual screen is normally set automatically. Because the current virtual screen determines which OpenGL renderer is processing commands, the return values of all glGetXXX functions can be affected by the current virtual screen.

        Parameters:
        ctx - a rendering context
        screen - a virtual screen number, which must be a value between 0 and the number of virtual screens minus one. The number of virtual screens available in a context can be obtained by calling the function DescribePixelFormat, passing in the pixel format object used to create the rendering context, 0 for the virtual screen number (pix_num parameter), and the attribute constant PFAVirtualScreenCount.

      • nCGLGetVirtualScreen

        public static int nCGLGetVirtualScreen​(long ctx,
                                       long screen)
        Unsafe version of: GetVirtualScreen

      • CGLGetVirtualScreen

        public static int CGLGetVirtualScreen​(long ctx,
                                      java.nio.IntBuffer screen)
        Gets the current virtual screen number associated with a rendering context.

        The current virtual screen can change when a drawable object is moved or resized across graphics device boundaries. A change in the current virtual screen can affect the return values of some OpenGL functions and in most cases also means that the renderer has changed.

        Parameters:
        ctx - a rendering context
        screen - on return, points to the virtual screen associated with the context. The value is always 0 on a single-display system and –1 if the function fails for any reason.

      • CGLUpdateContext

        public static int CGLUpdateContext​(long ctx)
        Synchronizes new renderer state to that of the application context
        Parameters:
        ctx - a rendering context

      • nCGLSetGlobalOption

        public static int nCGLSetGlobalOption​(int pname,
                                      long params)
        Unsafe version of: SetGlobalOption

      • nCGLGetGlobalOption

        public static int nCGLGetGlobalOption​(int pname,
                                      long params)
        Unsafe version of: GetGlobalOption

      • CGLLockContext

        public static int CGLLockContext​(long context)
        Locks a CGL rendering context.

        The function CGLLockContext blocks the thread it is on until all other threads have unlocked the same context using the function UnlockContext. You can use CGLLockContext recursively. Context-specific CGL calls by themselves do not require locking, but you can guarantee serial processing for a group of calls by surrounding them with CGLLockContext and CGLUnlockContext. Keep in mind that calls from the OpenGL API (the API provided by the Architecture Review Board) require locking.

        Applications that use NSOpenGL classes with multithreading can lock contexts using the functions CGLLockContext and CGLUnlockContext. To perform rendering in a thread other than the main one, you can lock the context that you want to access and safely execute OpenGL commands. The locking calls must be placed around all OpenGL calls in all threads.

        Parameters:
        context - a rendering context

      • CGLUnlockContext

        public static int CGLUnlockContext​(long context)
        Unlocks a CGL rendering context.
        Parameters:
        context - the CGL context to unlock

      • nCGLGetVersion

        public static void nCGLGetVersion​(long majorvers,
                                  long minorvers)
        Unsafe version of: GetVersion

      • CGLGetVersion

        public static void CGLGetVersion​(java.nio.IntBuffer majorvers,
                                 java.nio.IntBuffer minorvers)
        Gets the major and minor version numbers of the CGL library.
        Parameters:
        majorvers - on return, points to the major version number of the CGL library
        minorvers - on return, points to the minor version number of the CGL library

      • nCGLErrorString

        public static long nCGLErrorString​(int error)
        Unsafe version of: ErrorString

      • CGLChoosePixelFormat

        public static int CGLChoosePixelFormat​(int[] attribs,
                                       PointerBuffer pix,
                                       int[] npix)
        Array version of: ChoosePixelFormat

      • CGLDescribePixelFormat

        public static int CGLDescribePixelFormat​(long pix,
                                         int pix_num,
                                         int attrib,
                                         int[] value)
        Array version of: DescribePixelFormat

      • CGLQueryRendererInfo

        public static int CGLQueryRendererInfo​(int display_mask,
                                       PointerBuffer rend,
                                       int[] nrend)
        Array version of: QueryRendererInfo

      • CGLDescribeRenderer

        public static int CGLDescribeRenderer​(long rend,
                                      int rend_num,
                                      int prop,
                                      int[] value)
        Array version of: DescribeRenderer

      • CGLDescribePBuffer

        public static int CGLDescribePBuffer​(long obj,
                                     int[] width,
                                     int[] height,
                                     int[] target,
                                     int[] internalFormat,
                                     int[] mipmap)
        Array version of: DescribePBuffer

      • CGLGetOffScreen

        public static int CGLGetOffScreen​(long ctx,
                                  int[] width,
                                  int[] height,
                                  int[] rowbytes,
                                  PointerBuffer baseaddr)
        Array version of: GetOffScreen

      • CGLGetPBuffer

        public static int CGLGetPBuffer​(long ctx,
                                PointerBuffer pbuffer,
                                int[] face,
                                int[] level,
                                int[] screen)
        Array version of: GetPBuffer

      • CGLIsEnabled

        public static int CGLIsEnabled​(long ctx,
                               int pname,
                               int[] enable)
        Array version of: IsEnabled

      • CGLSetParameter

        public static int CGLSetParameter​(long ctx,
                                  int pname,
                                  int[] params)
        Array version of: SetParameter

      • CGLGetParameter

        public static int CGLGetParameter​(long ctx,
                                  int pname,
                                  int[] params)
        Array version of: GetParameter

      • CGLGetVirtualScreen

        public static int CGLGetVirtualScreen​(long ctx,
                                      int[] screen)
        Array version of: GetVirtualScreen

      • CGLSetGlobalOption

        public static int CGLSetGlobalOption​(int pname,
                                     int[] params)
        Array version of: SetGlobalOption

      • CGLGetGlobalOption

        public static int CGLGetGlobalOption​(int pname,
                                     int[] params)
        Array version of: GetGlobalOption

      • CGLGetVersion

        public static void CGLGetVersion​(int[] majorvers,
                                 int[] minorvers)
        Array version of: GetVersion