All supported extensions have a corresponding definition in gl.h or glext.h (a companion header included by gl.h) and a token in the extensions string returned by glGetString(). For example, if the ABGR extension (EXT_abgr) is supported, it is defined in gl.h as follows:

#define GL_EXT_abgr 1

GL_EXT_abgr appears in the extensions string returned by glGetString(). Use the definitions in gl.h at compile time to determine if procedure calls corresponding to an extension exist in the library.

---

Note: In this document, OpenGL extensions are listed by name without the GL_ prefix. For example, the ABGR extension is listed under a section heading of “EXT_abgr”. However, when testing for the presence of an OpenGL extension in the extensions string or in the OpenGL header files, you must use the GL_ prefix. Note that extensions for the GLX and GLU APIs have names similarly prefixed by GLX_ and GL_, and you must use these prefixes when testing for run-time or compile-time support of those extensions.

---

Applications should do compile-time checking—for example, making sure GL_EXT_abgr is defined; and run-time checking—for example, making sure GL_EXT_abgr is in the extension string returned by glGetString().

Note that libdl interface allows users to dynamically load their own shared objects as needed. Applications can use this interface, particularly the dlsym() function, to compile their application on any system, even if some of the extensions used are not supported.

In Example 5-1, the function QueryExtension() checks whether an extension is available.

main(int argc, char* argv[]) {
...
    if (!QueryExtension("GL_EXT_texture_object")) {
        fprintf(stderr, "texture_object extension not supported.\n");
        	exit(1);
    }
...
}

static GLboolean QueryExtension(char *extName)
{
    /*
    ** Search for extName in the extensions string. Use of strstr()
    ** is not sufficient because extension names can be prefixes of
    ** other extension names. Could use strtok() but the constant
    ** string returned by glGetString might be in read-only memory.
    */
    char *p;
    char *end;
    int extNameLen;   

    extNameLen = strlen(extName);
        
    p = (char *)glGetString(GL_EXTENSIONS);
    if (NULL == p) {
        return GL_FALSE;
    }

    end = p + strlen(p);   

    while (p < end) {
        int n = strcspn(p, " ");
        if ((extNameLen == n) && (strncmp(extName, p, n) == 0)) {
            return GL_TRUE;
        }
        p += (n + 1);
    }
    return GL_FALSE;
}

As an alternative to checking for each extension explicitly, you can make the following calls to determine the system and graphics driver release on which your program is running:

glGetString(
GL_RENDERER)
...
glGetString(
GL_VERSION) 

Given a list of extensions supported on that system for that release, you can usually determine whether the particular extension you need is available. For this to work on all systems, a table of different systems and the extensions supported has to be available. Some extensions have been included in patch releases; so, be careful when using this approach.

If you use any of the extensions to GLX, described in Chapter 6, “Resource Control Extensions”, you also need to check for GLX extension availability.

Querying for GLX extension support is similar to querying for OpenGL extension support with the following exceptions:

Taking these exceptions into account, adapt the process described in “How to Check for OpenGL Extension Availability”.

Function glXGetProcAddressARB() is called with the name of another OpenGL or GLX extension function or a newer core function and has the following format:

void (*glXGetProcAddress(const GLubyte *procname))(void)

The value procname is a string such as “glIsObjectBufferATI” or “glCompressedTexImage2DARB”. If the OpenGL or GLX function corresponding to procname exists, glXGetProcAddressARB() returns a function pointer to the corresponding function. Because the signatures of extension functions differ, the type of the pointer returned by glXGetProcAddressARB() is the generic (void (*)(void)). The pointer must be mapped to an appropriate function pointer type corresponding to the extension and then used to call the extension function when required.

The standard headers GL/glext.h and GL/glxext.h define, respectively, OpenGL and GLX interfaces (formats and token values) for extensions and newer core functions. In addition to defining formats, the headers also define C typedefs for these functions to ease the process of storing return values from glXGetProcAddressARB(). The following is a consistent convention for deriving a typedef for such a function:

For example, consider the following extension function:

GLboolean glIsObjectBufferATI(GLuint buffer);

Its corresponding typedef in glext.h would be the following:

typedef GLboolean (*PFNGLISOBJECTBUFFERATIPROC)(GLuint buffer);

The typedef names for GLX extension functions are defined similarly, but using the prefix “PFNGLX” instead of “PFNGL”.

Example 5-2 shows how to query and use an extension function pointer. The example uses the glIsObjectBufferATI function(), which is part of the GL_ATI_vertex_array_object extension, supported on Onyx4 and Silicon Graphics Prism systems. The example assumes that the application has already checked the GL_EXTENSIONS string to confirm that the extension is supported and that all references to functions, typedefs, or tokens used by the extension are wrapped in a #ifdef GL_ATI_vertex_array_object/#endif block so that the application using this code compiles correctly on platforms not supporting the extension. For clarity, these compile- and run-time checks are not included in the example.

Example 5-2. Querying Extension Function Pointers

/* Declare global variable containing the extension function pointer */ PFNGLISOBJECTBUFFERATIPROC IsObjectBufferATI = NULL; /* Query the function pointer */ IsObjectBufferATI = (PFNGLISOBJECTBUFFERATIPROC) glXGetProcAddressARB(“glIsObjectBufferATI”); /* This should never happen if the extension is supported; * but sanity check anyway, for robustness. */ if (IsObjectBufferATI == NULL) { error(“Cannot obtain extension function pointer.”); } ... /* Later in the program, call the extension function as needed */ GLuint buffer = bufferID; /* A buffer ID to be queried */ /* Equivalent to calling * if (glIsObjectBufferATI(buffer) == GL_TRUE) { ... */ if ((*IsObjectBufferATI)(buffer) == GL_TRUE) { /* buffer is indeed a vertex array buffer ID */ }

---

Note: Calling glXGetProcAddressARB() is an expensive operation. Do not call it every time an extension is to be called. Instead, query function pointers once after creating a context and cache the resulting pointers for future use.

---

Using the GLX_ARB_get_proc_address extension directly, as described in Example 5-2, can be tedious and intrusive on application code by causing many GL function calls to be performed indirectly through function pointers. Instead, use one of the many available open source extension wrapper libraries, which hide most of the details.

SGI does not currently recommend or support a specific wrapper library, because there are many popular libraries and they are frequently updated to keep track of new vendor and ARB-approved OpenGL extensions. Consult the the developer and support forums area of the OpenGL website, http://www.opengl.org/ (which is also a good place to look for information about many other OpenGL programming topics).

As a starting point, consider the following extension wrapper libraries:

Note that most of these libraries run on Microsoft Windows as well as Linux (and sometimes other operating systems with OpenGL support as well).

For the most up-to-date information on extensions, see the following man pages:

Note that individual OpenGL man pages have a MACHINE DEPENDENCIES section that lists the systems on which certain extension functions or options are implemented.

Multisampling is supported on all current Silicon Graphics systems with the exception of Fuel, Tezro, and InfinitePerformance systems. Currently, it can be used with windows or pixel buffers of multisampling-capable visual types, but not with pixmaps.

All complete example programs included in this guide (though not the short code fragments) are available on IRIX systems in /usr/share/src/OpenGL if you have the ogl_dev.sw.samples subsystem installed. You can also find example programs through the Silicon Graphics Developer Toolbox, http://toolbox.sgi.com/.

Extension specifications describe extension functionality from the implementor's point of view. They are prepared to fit in with the OpenGL specification. Specification contain detailed information that goes beyond what developers usually need to know. If you need more details on any of the extensions, search for its specification in the OpenGL Extenstion Registry, http://oss.sgi.com/projects/ogl-sample/registry/.