An OpenGL rendering context is created with glXCreateContext(). One of the arguments to this routine allows you to request a direct rendering context that bypasses the X server as described previously. (Note that to do direct rendering, the X server connection must be local, and the OpenGL implementation needs to support direct rendering.) glXCreateContext() also allows display-list and texture-object indices and definitions to be shared by multiple rendering contexts. You can determine whether a GLX context is direct with glXIsDirect().

To make a rendering context current, use glXMakeCurrent(); glXGetCurrentContext() returns the current context. You can also obtain the current drawable with glXGetCurrentDrawable() and the current X Display with glXGetCurrentDisplay(). Remember that only one context can be current for any thread at any one time. If you have multiple contexts, you can copy selected groups of OpenGL state variables from one context to another with glXCopyContext(). When you're finished with a particular context, destroy it with glXDestroyContext().

To render off-screen, first create an X Pixmap and then pass this as an argument to glXCreateGLXPixmap(). Once rendering is completed,
you can destroy the association between the X and GLX Pixmaps with glXDestroyGLXPixmap(). (Off-screen rendering isn't guaranteed to be supported for direct renderers.)

To prevent X requests from executing until any outstanding OpenGL rendering is completed, call glXWaitGL(). Then, any previously issued OpenGL commands are guaranteed to be executed before any X rendering calls made after glXWaitGL(). Although the same result can be achieved with glFinish(), glXWaitGL() doesn't require a round trip to the server and thus is more efficient in cases where the client and server are on separate machines.

To prevent an OpenGL command sequence from executing until any outstanding X requests are completed, use glXWaitX(). This routine guarantees that previously issued X rendering calls are executed before any OpenGL calls made after glXWaitX().

For drawables that are double-buffered, the front and back buffers can be exchanged by calling glXSwapBuffers(). An implicit glFlush() is done as part of this routine.

A shortcut for using X fonts in OpenGL is provided with the command glXUseXFont(). This routine builds display lists, each of which calls glBitmap(), for each requested character from the specified font and font size.

Determine whether the GLX extension is defined on the X server:

Bool glXQueryExtension ( Display *dpy, int *errorBase, int *eventBase );

Query version and extension information for client and server:

Bool glXQueryVersion ( Display *dpy, int *major, int *minor );

const char* glXGetClientString ( Display *dpy, int name );

const char* glXQueryServerString ( Display *dpy, int screen, int name );

const char* glXQueryExtensionsString ( Display *dpy, int screen );

Obtain the desired visual:

XVisualInfo* glXChooseVisual ( Display *dpy, int screen,
int *attribList );

int glXGetConfig ( Display *dpy, XVisualInfo *visual, int attrib,
int *value );

Manage or query an OpenGL rendering context:

GLXContext glXCreateContext ( Display *dpy, XVisualInfo *visual,
GLXContext shareList, Bool direct );

void glXDestroyContext ( Display *dpy, GLXContext context );

void glXCopyContext ( Display *dpy, GLXContext source,
GLXContext dest, unsigned long mask );

Bool glXIsDirect ( Display *dpy, GLXContext context );

Bool glXMakeCurrent ( Display *dpy, GLXDrawable draw,
GLXContext context );

GLXContext glXGetCurrentContext (void);

Display* glXGetCurrentDisplay (void);

GLXDrawable glXGetCurrentDrawable (void);

Perform off-screen rendering:

GLXPixmap glXCreateGLXPixmap ( Display *dpy, XVisualInfo *visual,
Pixmap pixmap );

void glXDestroyGLXPixmap ( Display *dpy, GLXPixmap pix );

Synchronize execution:

void glXWaitGL (void);

void glXWaitX (void);

Exchange front and back buffers:

void glXSwapBuffers ( Display *dpy, GLXDrawable drawable );

Use an X font:

void glXUseXFont ( Font font, int first, int count, int listBase );

An OpenGL rendering context is created (at least one context per window being rendered into) with aglCreateContext(). This takes the pixel format you selected as a parameter and uses it to initialize the context.

Use aglMakeCurrent() to make a rendering context current. Only one context can be current for a thread of control at any time. This indicates which drawable is to be rendered into and which context to use with it. It's possible for more than one context to be used (not simultaneously) with a particular drawable. Two routines allow you to determine which is the current rendering context and drawable being rendered into: aglGetCurrentContext() and aglGetCurrentDrawable().

If you have multiple contexts, you can copy selected groups of OpenGL state variables from one context to another with aglCopyContext(). When a particular context is finished with, it should be destroyed by calling aglDestroyContext().

With the OpenGL extensions for the Apple Macintosh you can choose whether window clipping is performed when writing to the screen and whether the cursor is hidden during screen writing operations. This is important since these two items may affect how fast rendering can be performed. Call aglSetOptions() to select these options.

To render off-screen, first create an off-screen graphics world in the usual way, and pass the handle into aglCreateAGLPixmap(). This routine returns a drawable that can be used with aglMakeCurrent(). Once rendering is completed, you can destroy the association with aglDestroyAGLPixmap().

For drawables that are double-buffered (as per the pixel format of the current rendering context), call aglSwapBuffers() to exchange the front and back buffers. An implicit glFlush() is performed as part of this routine.

The Apple Macintosh toolbox requires you to perform your own event handling and does not provide a way for libraries to automatically hook in to the event stream. So that the drawables maintained by OpenGL can adjust to changes in drawable size, position and pixel depth, aglUpdateCurrent() is provided.

This routine must be called by your event processing code whenever one of these events occurs in the current drawable. Ideally the scene should be rerendered after a update call to take into account the changes made to the rendering buffers.

A shortcut for using Macintosh fonts is provided with aglUseFont(). This routine builds display lists, each of which calls glBitmap(), for each requested character from the specified font and font size.

Determine AGL version:

GLboolean aglQueryVersion ( int *major, int *minor );

Pixel format selection, availability, and capability:

AGLPixelFmtID aglChoosePixelFmt ( GDHandle *dev, int ndev,
int *attribs );

int aglListPixelFmts ( GDHandle dev, AGLPixelFmtID **fmts );

GLboolean aglGetConfig ( AGLPixelFmtID pix, int attrib, int *value );

Manage an OpenGL rendering context:

AGLContext aglCreateContext ( AGLPixelFmtID pix,
AGLContext shareList );

GLboolean aglDestroyContext ( AGLContext context );

GLboolean aglCopyContext ( AGLContext source, AGLContext dest,
GLuint mask );

GLboolean aglMakeCurrent ( AGLDrawable drawable,
AGLContext context );

GLboolean aglSetOptions ( int opts );

AGLContext aglGetCurrentContext (void);

AGLDrawable aglGetCurrentDrawable (void);

Perform off-screen rendering:

AGLPixmap aglCreateAGLPixmap ( AGLPixelFmtID pix,
GWorldPtr pixmap );

GLboolean aglDestroyAGLPixmap ( AGLPixmap pix );

Exchange front and back buffers:

GLboolean aglSwapBuffers ( AGLDrawable drawable );

Update the current rendering buffers:

GLboolean aglUpdateCurrent (void);

Use a Macintosh font:

GLboolean aglUseFont ( int familyID, int size, int first, int count,
int listBase );

Find the cause of an error:

GLenum aglGetError (void);

An OpenGL rendering context is created with pglCreateContext(). One of the arguments to this routine allows you to request a direct rendering context that bypasses the Gpi and render to a PM window, which is generally faster. You can determine whether a OpenGL context is direct with pglIsIndirect().

To make a rendering context current, use pglMakeCurrent(); pglGetCurrentContext() returns the current context. You can also obtain the current window with pglGetCurrentWindow(). You can copy some OpenGL state variables from one context to another with pglCopyContext(). When you're finished with a particular context, destroy it with pglDestroyContext().

To lock access to the bitmap representation of the contents of the front buffer, use pglGrabFrontBitmap(). An implicit glFlush() is performed, and you can read the bitmap, but its contents are effectively read-only. Immediately after access is completed, you should call pglReleaseFrontBitmap() to restore write access to the front buffer.

To prevent Gpi rendering requests from executing until any outstanding OpenGL rendering is completed, call pglWaitGL(). Then, any previously issued OpenGL commands are guaranteed to be executed before any Gpi rendering calls made after pglWaitGL().

To prevent an OpenGL command sequence from executing until any outstanding Gpi requests are completed, use pglWaitPM(). This routine guarantees that previously issued Gpi rendering calls are executed before any OpenGL calls made after pglWaitPM().

For windows that are double-buffered, the front and back buffers can be exchanged by calling pglSwapBuffers(). An implicit glFlush() is done as part of this routine.

A shortcut for using OS/2 logical fonts in OpenGL is provided with the command pglUseFont(). This routine builds display lists, each of which calls glBitmap(), for each requested character from the specified font and font size.

Determine whether OpenGL is supported and, if so, its version number:

long pglQueryCapability (HAB hab);

void pglQueryVersion (HAB hab, int *major, int *minor);

Visual configuration selection, availability and capability:

PVISUALCONFIG pglChooseConfig (HAB hab, int *attribList);

PVISUALCONFIG * pglQueryConfigs (HAB hab);

Manage or query an OpenGL rendering context:

HGC pglCreateContext (HAB hab, PVISUALCONFIG pVisualConfig,
HGC shareList, Bool isDirect);

Bool pglDestroyContext (HAB hab, HGC hgc);

Bool pglCopyContext (HAB hab, HGC source, HGC dest, GLuint mask);

Bool pglMakeCurrent (HAB hab, HGC hgc, HWND hwnd);

long pglIsIndirect (HAB hab, HGC hgc);

HGC pglGetCurrentContext (HAB hab);

HWND pglGetCurrentWindow (HAB hab);

Access and release the bitmap of the front buffer:

Bool pglGrabFrontBitmap (HAB hab, HPS *hps, HBITMAP *phbitmap);

Bool pglReleaseFrontBitmap (HAB hab);

Synchronize execution:

HPS pglWaitGL (HAB hab);

void pglWaitPM (HAB hab);

Exchange front and back buffers:

void pglSwapBuffers (HAB hab, HWND hwnd);

Finding a color-index palette:

void pglSelectColorIndexPalette (HAB hab, HPAL, hpal, HGC hgc);

Use an OS/2 logical font:

Bool pglUseFont (HAB hab, HPS hps, FATTRS *fontAttribs,
long logicalId, int first, int count, int listBase);

wglCreateContext() creates an OpenGL rendering context for drawing on the device in the selected pixel format of the device context. (To create an OpenGL rendering context for overlay or underlay windows, use wglCreateLayerContext() instead.) To make a rendering context current, use wglMakeCurrent(); wglGetCurrentContext() returns the current context. You can also obtain the current device context with wglGetCurrentDC(). You can copy some OpenGL state variables from one context to another with wglCopyContext() or make two contexts share the same display lists and texture objects with wglShareLists(). When you're finished with a particular context, destroy it with wglDestroyContext().

Win32 has a few routines to allocate (and deallocate) bitmaps, to which you can render OpenGL directly. CreateDIBitmap() creates a device-dependent bitmap (DDB) from a device-independent bitmap (DIB). CreateDIBSection() creates a device-independent bitmap (DIB) that applications can write to directly. When finished with your bitmap, you can use DeleteObject() to free it up.

If you want to combine GDI and OpenGL rendering, be aware there are no equivalents to functions like glXWaitGL(), glXWaitX(), or pglWaitGL() in Win32. Although glXWaitGL() has no equivalent in Win32, you can achieve the same effect by calling glFinish(), which waits until all pending OpenGL commands are executed, or by calling GdiFlush(), which waits until all GDI drawing has completed.

For windows that are double-buffered, the front and back buffers can be exchanged by calling SwapBuffers() or wglSwapLayerBuffers(); the latter for overlays and underlays.

To access the color palette for the standard (non-layer) bitplanes, use the standard GDI functions to set the palette entries. For overlay or underlay layers, use wglRealizeLayerPalette(), which maps palette entries from a given color-index layer plane into the physical palette or initializes the palette of an RGBA layer plane. wglGetLayerPaletteEntries() is used to query the entries in palettes of layer planes.

WGL has two routines, wglUseFontBitmaps() and wglUseFontOutlines(), for converting system fonts to use with OpenGL. Both routines build a display list for each requested character from the specified font and font size.

Determine version information:

BOOL GetVersion ( LPOSVERSIONINFO lpVersionInformation );

BOOL GetVersionEx ( LPOSVERSIONINFO lpVersionInformation );

Pixel format availability, selection, and capability:

int ChoosePixelFormat ( HDC hdc,
CONST PIXELFORMATDESCRIPTOR * ppfd );

BOOL SetPixelFormat ( HDC hdc, int iPixelFormat,
CONST PIXELFORMATDESCRIPTOR * ppfd );

int DescribePixelFormat ( HDC hdc, int iPixelFormat, UINT nBytes,
LPPIXELFORMATDESCRIPTOR ppfd );

BOOL wglDescribeLayerPlane ( HDC hdc, int iPixelFormat,
int iLayerPlane, UINT nBytes, LPLAYERPLANEDESCRIPTOR plpd );

Manage or query an OpenGL rendering context:

HGLRC wglCreateContext ( HDC hdc );

HGLRC wglCreateLayerContext ( HDC hdc, int iLayerPlane );

BOOL wglShareLists ( HGLRC hglrc1, HGLRC hglrc2 );

BOOL wglDeleteContext ( HGLRC hglrc );

BOOL wglCopyContext ( HGLRC hglrcSource, HGLRC hlglrcDest,
UINT mask );

BOOL wglMakeCurrent ( HDC hdc, HGLRC hglrc );

HGLRC wglGetCurrentContext (VOID) ;

HDC wglGetCurrentDC (VOID);

Access and release the bitmap of the front buffer:

HBITMAP CreateDIBitmap ( HDC hdc,
CONST BITMAPINFOHEADER *lpbmih, DWORD fdwInit,
CONST VOID *lpbInit, CONST BITMAPINFO *lpbmi, UINT fuUsage );

HBITMAP CreateDIBSection ( HDC hdc, CONST BITMAPINFO *pbmi,
UINT iUsage, VOID *ppvBits, HANDLE hSection, DWORD dwOffset );

BOOL DeleteObject ( HGDIOBJ hObject );

Exchange front and back buffers:

BOOL SwapBuffers ( HDC hdc );

BOOL wglSwapLayerBuffers ( HDC hdc, UINT fuPlanes );

Finding a color palette for overlay or underlay layers:

int wglGetLayerPaletteEntries ( HDC hdc, int iLayerPlane, int iStart,
int cEntries, CONST COLORREF *pcr );

BOOL wglRealizeLayerPalette ( HDC hdc, int iLayerPlane,
BOOL bRealize );

Use a bitmap or an outline font:

BOOL wglUseFontBitmaps ( HDC hdc, DWORD first, DWORD count,
DWORD listBase );

BOOL wglUseFontOutlines ( HDC hdc, DWORD first, DWORD count,
DWORD listBase, FLOAT deviation, FLOAT extrusion, int format,
LPGLYPHMETRICSFLOAT lpgmf );