Using OpenGL core functions along with extension - opengl

Question

I want to use DXT compressed textures in my program, so i am loading the core function pointer like this:
/* GL 1.3 core */
PFNGLCOMPRESSEDTEXIMAGE2DPROC glCompressedTexImage2D = NULL;
/* ... */
/* check GL version using glGetString(GL_VERSION) */
/* ... */
glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)wglGetProcAddress(
"glCompressedTexImage2D");
if (!glCompressedTexImage2D)
return 0;
/* check if GL_EXT_texture_compression_s3tc is available */
And after that, i use the function like this:
glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, width,
height, 0, size, ptr);
It works well, but the reason i am doubting this is i have been told that i cannot mix OpenGL core functions with extensions functions like this:
glGenBuffersARB(1, &id);
glBindBuffer(GL_ARRAY_BUFFER, id);
Or, core functions with tokens added by some extension like this:
glActiveTexture(GL_TEXTURE0_ARB);
But i am using glCompressedTexImage2D(core function) with GL_COMPRESSED_RGB_S3TC_DXT1_EXT(a token added by GL_EXT_texture_compression_s3tc).
So, is it okay to use extensions that wasn't added to the core (extensions such as GL_EXT_texture_compression_s3tc or WGL_EXT_swap_control) functions/tokens along with core functions?

Answer 1

Generally, it's good advice not to mix core and extension definitions for the same functionality. Often times extensions are promoted to core functionality, with identical definitions, and it's not a problem. But there are cases where the core functionality is not quite the same as earlier versions of he same functionality defined in extensions.
A common example for this are FBOs (Framebuffer Objects). There were a number of different extensions related to FBO functionality before FBOs were introduced as core functionality in OpenGL 3.0, and some of those extensions are not quite the same as what ended up as core functionality. Therefore, mixing older extensions and core definitions for FBOs would be a bad idea.
In this specific case however, it's perfectly fine. It's expected that many/most compressed texture formats are extensions. Many of them are vendor specific, and involve patents, so they will most likely never become core functionality. The spec accommodates for that. Some spec quotes for glCompressedTexImage2D() make this clear:
internalformat must be a supported specific compressed internal format.
For all other compressed internal formats, the compressed image will be decoded according to the specification defining the internalformat token.
Specific compressed internal formats may impose format-specific restrictions on the use of the compressed image specification calls or parameters.
The extension definition for EXT_texture_compression_s3tc also confirms that COMPRESSED_RGB_S3TC_DXT1_EXT can be used as argument for glCompressedTExImage2D():
This extension introduces new tokens:
COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0
COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1
COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2
COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3
In OpenGL 1.2.1 these tokens are accepted by the <internalformat> parameter
of TexImage2D, CopyTexImage2D, and CompressedTexImage2D and the <format>
parameter of CompressedTexSubImage2D.
The list of supported compressed texture formats can also be obtained without querying extensions. You can use glGetIntegerv() to enumerate them:
GLint numFormats = 0;
glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &numFormats);
GLint* formats = new GLint[numFormats];
glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, formats);
This directly gives you the list of formats accepted by glCompressedTexImage2D().

Answer 2

It's perfectly possible to use extensions in core. Core profile just means, that certain cruft from the past has been removed from, well the core. But everything that is reported by your OpenGL context as being available in the extension strings as reported by glGetStringi may be legally used from that context. Any extension that is not "core-compliant" would not appear in a pure core context.
Also texture compression is one of those extensions of high interest in core profiles. See https://www.opengl.org/wiki/OpenGL_Extension#Targeting_OpenGL_3.3