Package org.lwjgl.opengl

Class CGL

java.lang.Object
org.lwjgl.opengl.CGL
public class CGL extends Object
Native bindings to CGL.

  • Field Details

  • Method Details

    • 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

    • CGLChoosePixelFormat

      public static int CGLChoosePixelFormat(IntBuffer attribs, org.lwjgl.PointerBuffer pix, IntBuffer npix)
      Creates a pixel format object that satisfies the constraints of the specified buffer and renderer attributes.
      Parameters:
      attribs - a 0 terminated array that contains a list of buffer and renderer attributes. Attributes can be Boolean or integer. If an attribute is integer, you must supply the desired value immediately following the attribute. If the attribute is Boolean, do not supply a value because its presence in the attributes array implies a true value. One of:
      PFAAllRenderersPFATripleBufferPFADoubleBufferPFAStereoPFAColorSize
      PFAAlphaSizePFADepthSizePFAStencilSizePFAMinimumPolicyPFAMaximumPolicy
      PFASampleBuffersPFASamplesPFAColorFloatPFAMultisamplePFASupersample
      PFASampleAlphaPFARendererIDPFASingleRendererPFANoRecoveryPFAAccelerated
      PFAClosestPolicyPFABackingStorePFABackingVolatilePFADisplayMaskPFAAllowOfflineRenderers
      PFAAcceleratedComputePFAOpenGLProfilePFASupportsAutomaticGraphicsSwitchingPFAVirtualScreenCountPFAAuxBuffers
      PFAAccumSizePFAOffScreenPFAAuxDepthStencilPFAWindowPFACompliant
      PFAPBufferPFARemotePBufferPFARobustPFAMPSafePFAMultiScreen
      PFAFullScreen
      pix - the memory address of a pixel format object. On return, points to a new pixel format object that contains pixel format information and a list of virtual screens. If there are no pixel formats or virtual screens that satisfy the constraints of the buffer and renderer attributes, the value of pix is set to NULL.
      npix - on return, points to the number of virtual screens referenced by pix. If pix is NULL, the value of npix is set to 0.

    • 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

    • CGLDescribePixelFormat

      public static int CGLDescribePixelFormat(long pix, int pix_num, int attrib, IntBuffer value)
      Retrieves the values of an attribute associated with a pixel format object.
      Parameters:
      pix - the pixel format object to query
      pix_num - the virtual screen number whose attribute value you want to retrieve. This value must be between 0 and the number of virtual screens minus one.
      attrib - the attribute whose value you want to obtain. One of:
      PFAAllRenderersPFATripleBufferPFADoubleBufferPFAStereoPFAColorSize
      PFAAlphaSizePFADepthSizePFAStencilSizePFAMinimumPolicyPFAMaximumPolicy
      PFASampleBuffersPFASamplesPFAColorFloatPFAMultisamplePFASupersample
      PFASampleAlphaPFARendererIDPFASingleRendererPFANoRecoveryPFAAccelerated
      PFAClosestPolicyPFABackingStorePFABackingVolatilePFADisplayMaskPFAAllowOfflineRenderers
      PFAAcceleratedComputePFAOpenGLProfilePFASupportsAutomaticGraphicsSwitchingPFAVirtualScreenCountPFAAuxBuffers
      PFAAccumSizePFAOffScreenPFAAuxDepthStencilPFAWindowPFACompliant
      PFAPBufferPFARemotePBufferPFARobustPFAMPSafePFAMultiScreen
      PFAFullScreen
      value - on return, points to the value of the attribute

    • 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, org.lwjgl.PointerBuffer rend, 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

    • CGLDescribeRenderer

      public static int CGLDescribeRenderer(long rend, int rend_num, int prop, IntBuffer value)
      Obtains the value associated with a renderer property.
      Parameters:
      rend - an opaque renderer information object that contains a description of the renderer capabilities you want to inspect. You can obtain a renderer information object by calling the function QueryRendererInfo. You must call DestroyRendererInfo when you no longer need this object.
      rend_num - the index of the renderer inside the renderer information object — a value between 0 and the number of renderers minus one. The number of renderers can be obtained by calling DescribeRenderer, passing in rend, renderer number 0, and the renderer property RPRendererCount.
      prop - the renderer property whose value you want to obtain. One of:
      RPOffScreenRPRendererIDRPAcceleratedRPBackingStoreRPWindow
      RPCompliantRPDisplayMaskRPBufferModesRPColorModesRPAccumModes
      RPDepthModesRPStencilModesRPMaxAuxBuffersRPMaxSampleBuffersRPMaxSamples
      RPSampleModesRPSampleAlphaRPVideoMemoryRPTextureMemoryRPGPUVertProcCapable
      RPGPUFragProcCapableRPRendererCountRPOnlineRPAcceleratedComputeRPVideoMemoryMegabytes
      RPTextureMemoryMegabytesRPRobustRPMPSafeRPMultiScreenRPFullScreen
      value - on return, points to the value of the requested property

    • nCGLCreateContext

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

    • CGLCreateContext

      public static int CGLCreateContext(long pix, long share, org.lwjgl.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, org.lwjgl.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, IntBuffer width, IntBuffer height, IntBuffer target, IntBuffer internalFormat, 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, 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, IntBuffer width, IntBuffer height, IntBuffer rowbytes, org.lwjgl.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, org.lwjgl.PointerBuffer pbuffer, IntBuffer face, IntBuffer level, 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

    • CGLEnable

      public static int CGLEnable(long ctx, int pname)
      Enables an option for a rendering context.
      Parameters:
      ctx - a rendering context
      pname - the option to enable. One of:
      CESwapRectangleCESwapLimitCERasterizationCEStateValidationCESurfaceBackingSize
      CEDisplayListOptimizationCEMPEngine

    • CGLDisable

      public static int CGLDisable(long ctx, int pname)
      Disables an option for a rendering context.
      Parameters:
      ctx - a rendering context
      pname - the option to disable. One of:
      CESwapRectangleCESwapLimitCERasterizationCEStateValidationCESurfaceBackingSize
      CEDisplayListOptimizationCEMPEngine

    • nCGLIsEnabled

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

    • CGLIsEnabled

      public static int CGLIsEnabled(long ctx, int pname, IntBuffer enable)
      Reports whether an option is enabled for a rendering context.
      Parameters:
      ctx - a rendering context
      pname - the option to query. One of:
      CESwapRectangleCESwapLimitCERasterizationCEStateValidationCESurfaceBackingSize
      CEDisplayListOptimizationCEMPEngine
      enable - on return, enable is set to true if the option is enabled

    • nCGLSetParameter

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

    • CGLSetParameter

      public static int CGLSetParameter(long ctx, int pname, IntBuffer params)
      Sets the value of a rendering context parameter.
      Parameters:
      ctx - a rendering context
      pname - the parameter whose value you want to set. One of:
      CPSwapRectangleCPSwapIntervalCPDispatchTableSizeCPClientStorage
      CPSurfaceTextureCPSurfaceOrderCPSurfaceOpacityCPSurfaceBackingSize
      CPSurfaceSurfaceVolatileCPReclaimResourcesCPCurrentRendererIDCPGPUVertexProcessing
      CPGPUFragmentProcessingCPHasDrawableCPMPSwapsInFlight
      params - a pointer to the value to set the parameter to

    • CGLSetParameter

      public static int CGLSetParameter(long ctx, int pname, int param)
      Sets the value of a rendering context parameter.
      Parameters:
      ctx - a rendering context
      pname - the parameter whose value you want to set. One of:
      CPSwapRectangleCPSwapIntervalCPDispatchTableSizeCPClientStorage
      CPSurfaceTextureCPSurfaceOrderCPSurfaceOpacityCPSurfaceBackingSize
      CPSurfaceSurfaceVolatileCPReclaimResourcesCPCurrentRendererIDCPGPUVertexProcessing
      CPGPUFragmentProcessingCPHasDrawableCPMPSwapsInFlight

    • nCGLGetParameter

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

    • CGLGetParameter

      public static int CGLGetParameter(long ctx, int pname, IntBuffer params)
      Retrieves the value of a rendering context parameter.
      Parameters:
      ctx - a rendering context
      pname - the parameter whose value you want to retrieve. One of:
      CPSwapRectangleCPSwapIntervalCPDispatchTableSizeCPClientStorage
      CPSurfaceTextureCPSurfaceOrderCPSurfaceOpacityCPSurfaceBackingSize
      CPSurfaceSurfaceVolatileCPReclaimResourcesCPCurrentRendererIDCPGPUVertexProcessing
      CPGPUFragmentProcessingCPHasDrawableCPMPSwapsInFlight
      params - on return, points to the value of the parameter

    • 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, 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

    • CGLSetGlobalOption

      public static int CGLSetGlobalOption(int pname, IntBuffer params)
      Sets the value of a global option.
      Parameters:
      pname - the name of the option whose value you want to set. One of:
      GOFormatCacheSizeGOClearFormatCacheGORetainRenderersGOResetLibraryGOUseErrorHandler
      GOUseBuildCache
      params - the value to set the option to

    • CGLSetGlobalOption

      public static int CGLSetGlobalOption(int pname, int param)
      Sets the value of a global option.
      Parameters:
      pname - the name of the option whose value you want to set. One of:
      GOFormatCacheSizeGOClearFormatCacheGORetainRenderersGOResetLibraryGOUseErrorHandler
      GOUseBuildCache

    • nCGLGetGlobalOption

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

    • CGLGetGlobalOption

      public static int CGLGetGlobalOption(int pname, IntBuffer params)
      Retrieves the value of a global option.
      Parameters:
      pname - the name of the option whose value you want to get. One of:
      GOFormatCacheSizeGOClearFormatCacheGORetainRenderersGOResetLibraryGOUseErrorHandler
      GOUseBuildCache
      params - on return, a pointer to the value of the option

    • 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(IntBuffer majorvers, 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

    • CGLErrorString

      @Nullable public static String CGLErrorString(int error)
      Returns a string that describes the specified result code.
      Parameters:
      error - the CGL result code constant returned from a CGL function. One of:
      NoErrorBadAttributeBadPropertyBadPixelFormatBadRendererInfoBadContextBadDrawable
      BadDisplayBadStateBadValueBadMatchBadEnumerationBadOffScreenBadFullScreen
      BadWindowBadAddressBadCodeModuleBadAllocBadConnection

    • CGLChoosePixelFormat

      public static int CGLChoosePixelFormat(int[] attribs, org.lwjgl.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, org.lwjgl.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, org.lwjgl.PointerBuffer baseaddr)
      Array version of: GetOffScreen

    • CGLGetPBuffer

      public static int CGLGetPBuffer(long ctx, org.lwjgl.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