All supported extensions have a corresponding definition in 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.

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() command, 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 IRIX 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.

When an extension is incomplete, it is not advertised in the extensions string. Some of the RealityEngine extensions that were supported in IRIX 5.3 (for example, the subtexture, sharpen texture, convolution, and histogram extensions) fall in that category.

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:

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

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

Note that individual OpenGL reference pages have a MACHINE DEPENDENCIES section that lists the systems on which certain extension functions or options are implemented. Here is an example from the glSampleMaskSGIS reference page:

MACHINE DEPENDENCIES

Multisampling is supported only on RealityEngine, RealityEngine2, VTX and InfiniteReality systems. Currently it can be used with windows 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 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://www.sgi.com/Technology/toolbox.html.

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 detail on any of the extensions, search for its specification in the developer toolbox.