Add function for app to explicitly make libktx load its GL function pointers. (#894)

Fixes #708.

Author: MarkCallow

CMakeLists.txt

@@ -454,6 +454,7 @@ set(BASISU_ENCODER_CXX_SRC
 
 if(KTX_FEATURE_GL_UPLOAD)
     list(APPEND KTX_MAIN_SRC
+        lib/gl_funclist.inl
         lib/gl_funcs.c
         lib/gl_funcs.h
         lib/glloader.c

cmake/docs.cmake

@@ -122,6 +122,7 @@ function( CreateDocLibKTX )
         lib/basis_transcode.cpp
         lib/miniz_wrapper.cpp
         lib/strings.c
+        lib/gl_funcs.c
         lib/glloader.c
         lib/hashlist.c
         lib/filestream.c

include/ktx.h

@@ -905,6 +905,22 @@ struct ktxStream
  * functions.
  */
 
+/**
+ * @~English
+ * @brief typedef of function pointer returned by GLGetProcAddress functions.
+ */
+typedef void (KTX_APIENTRY* PFNVOIDFUNCTION)(void);
+/**
+ * @~English
+ * @brief typedef of pointer to function for retrieving OpenGL function pointers.
+ */
+typedef PFNVOIDFUNCTION (KTX_APIENTRY* PFNGLGETPROCADDRESS) (const char *proc);
+/*
+ * Load pointers for the OpenGL functions needed by ktxTexture_GLUpload.
+ */
+KTX_API KTX_error_code KTX_APIENTRY
+ktxLoadOpenGL(PFNGLGETPROCADDRESS pfnGLGetProcAddress);
+
 /*
  * These four create a ktxTexture1 or ktxTexture2 according to the data
  * header, and return a pointer to the base ktxTexture class.

lib/gl_funcs.c

@@ -52,69 +52,63 @@
 #else
 #include <dlfcn.h>
 #include <stdlib.h>
-#define WINAPI
 #endif
 #define NO_SHORTCUTS
 #include "gl_funcs.h"
 
 #if WINDOWS
 #define GetOpenGLModuleHandle(flags) ktxFindOpenGL()
-#define LoadProcAddr GetProcAddress
-HMODULE ktxOpenGLModuleHandle;
+static HMODULE ktxOpenGLModuleHandle;
+static PFNGLGETPROCADDRESS pfnWglGetProcAddress;
+
+PFNVOIDFUNCTION
+defaultGLGetProcAddress(const char* proc)
+{
+    PFNVOIDFUNCTION pfnGLProc = NULL;
+
+    if (pfnWglGetProcAddress)
+        pfnGLProc = pfnWglGetProcAddress(proc);
+    if (!pfnGLProc) {
+        pfnGLProc = (PFNVOIDFUNCTION)GetProcAddress(ktxOpenGLModuleHandle,
+                                                    proc);
+    }
+    return pfnGLProc;
+}
 #elif MACOS || UNIX || IOS
 // Using NULL returns a handle that can be used to search the process that
 // loaded us and any other libraries it has loaded. That's all we need to
 // search as the app is responsible for creating the GL context so it must
 // be there.
 #define GetOpenGLModuleHandle(flags) dlopen(NULL, flags)
-#define LoadProcAddr dlsym
-#define LIBRARY_NAME NULL
-void* ktxOpenGLModuleHandle;
+static void* ktxOpenGLModuleHandle;
+
+PFNVOIDFUNCTION
+defaultGLGetProcAddress(const char* proc)
+{
+    return dlsym(ktxOpenGLModuleHandle, proc);
+}
 #elif WEB
 extern void* emscripten_GetProcAddress(const char *name_);
 #define GetOpenGLModuleHandle(flag) (void*)0x0000ffff // Value doesn't matter.
-#define LoadProcAddr(lib, proc) emscripten_GetProcAddress(proc)
-#define LIBRARY_NAME "unused"
 void* ktxOpenGLModuleHandle;
+
+#define defaultGLGetProcAddress ((PFNGLGETPROCADDRESS)emscripten_GetProcAddress)
 #else
 #error "Don\'t know how to load symbols on this OS."
 #endif
 
-typedef void (WINAPI *PFNVOIDFUNCTION)(void);
-typedef  PFNVOIDFUNCTION *(WINAPI * PFNWGLGETPROCADDRESS) (const char *proc);
-static  PFNWGLGETPROCADDRESS wglGetProcAddressPtr;
+static bool openGLLoaded = false;
 static const char* noloadmsg = "Could not load OpenGL command: %s!\n";
 
 /* Define pointers for functions libktx is using. */
 struct glFuncPtrs gl;
 
-#if defined(__GNUC__)
-// This strange casting is because dlsym returns a void* thus is not
-// compatible with ISO C which forbids conversion of object pointers
-// to function pointers. The cast masks the conversion from the
-// compiler thus no warning even though -pedantic is set. Since the
-// platform supports dlsym, conversion to function pointers must
-// work, despite the mandated ISO C warning.
 #define GL_FUNCTION(type, func, required)                                  \
-  if ( wglGetProcAddressPtr )                                              \
-  *(void **)(&gl.func) = wglGetProcAddressPtr(#func);                      \
-  if ( !gl.func )                                                          \
-    *(void **)(&gl.func) = LoadProcAddr(ktxOpenGLModuleHandle, #func);     \
-  if ( !gl.func && required ) {                                            \
-        fprintf(stderr, noloadmsg, #func);                                 \
-        return KTX_NOT_FOUND;                                              \
-  }
-#else
-#define GL_FUNCTION(type, func, required)                                  \
-  if ( wglGetProcAddressPtr )                                              \
-    gl.func = (type)wglGetProcAddressPtr(#func);                           \
-  if ( !gl.func)                                                           \
-    gl.func = (type)LoadProcAddr(ktxOpenGLModuleHandle, #func);            \
+  gl.func = (type)pfnGLGetProcAddress(#func);                              \
   if ( !gl.func && required) {                                             \
     fprintf(stderr, noloadmsg, #func);                                     \
     return KTX_NOT_FOUND;                                                  \
   }
-#endif
 
 #if WINDOWS
 static HMODULE
@@ -130,7 +124,7 @@ ktxFindOpenGL() {
         &module
     );
     if (found) {
-        if (LoadProcAddr(module, "glGetError") != NULL)
+        if (GetProcAddress(module, "glGetError") != NULL)
             return module;
     }
     // Not statically linked. See what dll the process has loaded.
@@ -154,22 +148,23 @@ ktxFindOpenGL() {
     );
     if (found) {
         // Need wglGetProcAddr for non-OpenGL-2 functions.
-        wglGetProcAddressPtr =
-            (PFNWGLGETPROCADDRESS)LoadProcAddr(module,
-                                               "wglGetProcAddress");
-        if (wglGetProcAddressPtr != NULL)
+        pfnWglGetProcAddress =
+            (PFNGLGETPROCADDRESS)GetProcAddress(module,
+                                                 "wglGetProcAddress");
+        if (pfnWglGetProcAddress != NULL)
             return module;
     }
-    return module; // Keep the compiler happy!
+    return 0;
 }
 #endif
 
 ktx_error_code_e
 ktxLoadOpenGLLibrary(void)
 {
-    if (ktxOpenGLModuleHandle)
+    if (openGLLoaded)
         return KTX_SUCCESS;
 
+    // Look for OpenGL module and set up default GetProcAddress.
     ktxOpenGLModuleHandle = GetOpenGLModuleHandle(RTLD_LAZY);
     if (ktxOpenGLModuleHandle == NULL) {
         fprintf(stderr, "OpenGL lib not linked or loaded by application.\n");
@@ -184,9 +179,48 @@ ktxLoadOpenGLLibrary(void)
         return KTX_LIBRARY_NOT_LINKED; // So release version doesn't crash.
 #endif
     }
+    return KTX_SUCCESS;
+}
+
+/**
+ * @~English
+ * @brief Load pointers for the GL functions used by ktxTexture_GLUpload.
+ *
+ * Should be called by an application before its first call to
+ * ktxTexture\_GLUpload, passing a pointer to the GLGetProcAddress function
+ * provided by whatever OpenGL framework it is using. For backward
+ * compatibility, ktxTexture\_GLUpload calls this with a NULL pointer causing an
+ * attempt to load the pointers from the program module using
+ * @c dlsym (GNU/Linux, macOS), @c wglGetProcAddr and @c GetProcAddr (Windows)
+ * or @c emscripten_GetProcAddress (Web). This works with the vast majority of
+ * OpenGL implementations but issues have been seen on Fedora systems
+ * particularly with NVIDIA hardware. For full robustness, applications should
+ * call this function.
+ *
+ * @param [in] pfnGLGetProcAddress pointer to function for retrieving pointers
+ *                                 to GL functions. If NULL, retrieval is
+ *                                 attempted using system dependent generic
+ *                                 functions.
+ */
+KTX_API ktx_error_code_e KTX_APIENTRY
+ktxLoadOpenGL(PFNGLGETPROCADDRESS pfnGLGetProcAddress)
+{
+    if (openGLLoaded)
+        return KTX_SUCCESS;
+
+    if (!pfnGLGetProcAddress) {
+        ktx_error_code_e result = ktxLoadOpenGLLibrary();
+        if (result != KTX_SUCCESS) {
+            return result;
+        }
+        pfnGLGetProcAddress = defaultGLGetProcAddress;
+    }
+
+    // Load function pointers
 
 #include "gl_funclist.inl"
 
+    openGLLoaded = true;
     return KTX_SUCCESS;
 }
 

lib/gl_funcs.h

@@ -24,14 +24,6 @@
 #include "GL/glcorearb.h"
 #include "ktx.h"
 
-#if WINDOWS
-#define WINDOWS_LEAN_AND_MEAN
-#include <windows.h>
-extern HMODULE ktxOpenGLModuleHandle;
-#else
-extern void* ktxOpenGLModuleHandle;
-#endif
-
 extern ktx_error_code_e ktxLoadOpenGLLibrary(void);
 
 #define GL_FUNCTION(type, fun, required) type fun;

lib/glloader.c

@@ -924,11 +924,9 @@ ktxTexture1_GLUpload(ktxTexture1* This, GLuint* pTexture, GLenum* pTarget,
         return KTX_INVALID_VALUE;
     }
 
-    if (!ktxOpenGLModuleHandle) {
-        result = ktxLoadOpenGLLibrary();
-        if (result != KTX_SUCCESS) {
-            return result;
-        }
+    result = ktxLoadOpenGL(NULL);
+    if (result != KTX_SUCCESS) {
+        return result;
     }
     /* KTX 1 files require an unpack alignment of 4 */
     glGetIntegerv(GL_UNPACK_ALIGNMENT, &previousUnpackAlignment);
@@ -1010,11 +1008,9 @@ ktxTexture2_GLUpload(ktxTexture2* This, GLuint* pTexture, GLenum* pTarget,
         return KTX_INVALID_VALUE;
     }
 
-    if (!ktxOpenGLModuleHandle) {
-        result = ktxLoadOpenGLLibrary();
-        if (result != KTX_SUCCESS) {
-            return result;
-        }
+    result = ktxLoadOpenGL(NULL);
+    if (result != KTX_SUCCESS) {
+        return result;
     }
 
     if (This->vkFormat != VK_FORMAT_UNDEFINED) {

lib/libktx_mainpage.md

@@ -84,6 +84,19 @@ GLenum target, glerror;
 result = ktxTexture_CreateFromNamedFile("mytex3d.ktx",
                                         KTX_TEXTURE_CREATE_NO_FLAGS,
                                         &kTexture);
+
+// Before the first call to  ktxTexture_GLUpload make libktx load its
+// function pointers for the GL functions it uses. The parameter is a
+// pointer to the GLGetProcAddress function provided by whatever OpenGL
+// framework the application is using. The example shown is for SDL.
+//
+// Note 1: This is unrelated to any GL function pointers the app may be
+//         using.
+// Note 2: When this is not called, libktx has fallback mechanisms to
+//         find the pointers which work on the vast majority of
+//         platforms. The only known failures have occurred on Fedora.
+result = ktxLoadOpenGL((PFNGLGETPROCADDRESS)SDL_GL_GetProcAddress);
+
 glGenTextures(1, &texture); // Optional. GLUpload can generate a texture.
 result = ktxTexture_GLUpload(kTexture, &texture, &target, &glerror);
 ktxTexture_Destroy(kTexture);

tests/loadtests/glloadtests/GLLoadTests.cpp

@@ -41,9 +41,23 @@ GLLoadTests::~GLLoadTests()
 bool
 GLLoadTests::initialize(Args& args)
 {
+    bool explicitlyLoadOpenGL = false;
+    for (uint32_t i = 1; i < args.size(); i++) {
+        if (args[i].compare("--load-gl") == 0) {
+            explicitlyLoadOpenGL = true;
+            args.erase(args.begin() + i);
+            break;
+        }
+    }
+
     if (!GLAppSDL::initialize(args))
         return false;
 
+    // --load-gl allows testing of explicitly loading the OpenGL pointers.
+    // Default is for ktxTexture_GLUpload to implicitly load them.
+    if (explicitlyLoadOpenGL)
+        ktxLoadOpenGL(reinterpret_cast<PFNGLGETPROCADDRESS>(SDL_GL_GetProcAddress));
+
     for (auto it = args.begin() + 1; it != args.end(); it++) {
         infiles.push_back(*it);
     }