On X11, function pointers returned by this function are valid for any context, and can even be looked up before a context is created at all. This means that, for at least some common OpenGL implementations, if you look up a function that doesn't exist, you'll get a non-NULL result that is _NOT_ safe to call. You must always make sure the function is actually available for a given GL context before calling it, by checking for the existence of the appropriate extension with SDL_GL_ExtensionSupported(), or verifying that the version of OpenGL you're using offers the function as core functionality.

Thanks to all for the responses.

So basically this is what I'm planning on doing:

1) When compiling I'll use #ifdef GL_VERSION_X_Y to make sure the compilation works properly.

2) When running it, let's say that glGetString(GL_VERSION) is supported. I understand that GLEW may have a bug in this function; but if I have a reliable way of parsing this string to get the major and minor version numbers, then these will be the ones available at runtime. Let's say I define an integer iversion = 10*major + minor. Then I can use

#ifdef GL_VERSION_3_1
if(iversion >= 31) {
   /* my happy OpenGL 3.1 code here */
}
#endif

Of course, this is all predicated on two facts: (1) I can construct iversion reliably; and (2) iversion created at runtime by extracting the version through gl calls will give me the supported runtime version of gl - regardless of how it was compiled.

Am I correct?

Android, sadly.

Qualcomm's Adreno drivers always return a non-null function pointer, regardless of whether the function is actually supported.

Well on EGL platform if

Hi cgrant,

I think my confusion right now is just one question: regardless how the code was compiled and on what platform, and with what version of OpenGL, is GL_VERSION (major and minor) obtained at runtime reliable ways (at runtime!) do bracket the source with "if" statements to skip over code that compiled properly but should not be called because the runtime version of opengl does not support it?

In other words, if my running machine only supports GL 1.1, can I reliably count on the fact that glGetString(GL_VERSION) will tell me that the runtime version is 1.1 and that I should skip some code that uses functionality in GL > 1.1?

I'm just hoping that glGetString(GL_VERSION) has no relation to the version used for compiling the code.

Thanks.