X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=simgear%2Fscreen%2Fextensions.cxx;h=130673c51f92c7654a1ba47c36b865a4ce14c3e5;hb=bbd61977f14c30ce93a2bcf5a3551708d36a29c8;hp=aeab8998520201aa546ff1bf3a33a66a46270289;hpb=9ca1c6666e6f5fcd071d36c590b768ec880a58c6;p=simgear.git

diff --git a/simgear/screen/extensions.cxx b/simgear/screen/extensions.cxx
index aeab8998..130673c5 100644
--- a/simgear/screen/extensions.cxx
+++ b/simgear/screen/extensions.cxx
@@ -24,19 +24,22 @@
 
 #include <string.h>
 
-#ifndef WIN32
-#include <dlfcn.h>
+#include "extensions.hxx"
+#include <simgear/debug/logstream.hxx>
+#if !defined(WIN32)
+#  include <dlfcn.h>
 #endif
 
-#include <extensions.hxx>
-
-bool SGSearchExtensionsString(char *extString, char *extName) {
+bool SGSearchExtensionsString(const char *extString, const char *extName) {
     // Returns GL_TRUE if the *extName string appears in the *extString string,
     // surrounded by white spaces, or GL_FALSE otherwise.
 
-    char *p, *end;
+    const char *p, *end;
     int n, extNameLen;
 
+    if ((extString == NULL) || (extName == NULL))
+        return false;
+
     extNameLen = strlen(extName);
 
     p=extString;
@@ -53,14 +56,98 @@ bool SGSearchExtensionsString(char *extString, char *extName) {
     return GL_FALSE;
 }
 
-bool SGIsOpenGLExtensionSupported(char *extName) {
+bool SGIsOpenGLExtensionSupported(const char *extName) {
    // Returns GL_TRUE if the OpenGL Extension whose name is *extName
    // is supported by the system, or GL_FALSE otherwise.
    //
    // The *extName string must follow the OpenGL extensions naming scheme
    // (ie: "GL_type_extension", like GL_EXT_convolution)
 
-    return SGSearchExtensionsString((char *)glGetString(GL_EXTENSIONS),
-extName);
+    return SGSearchExtensionsString((const char *)glGetString(GL_EXTENSIONS),extName);
 }
 
+#ifdef __APPLE__
+
+#include <CoreFoundation/CoreFoundation.h>
+
+void* macosxGetGLProcAddress(const char *func) {
+
+  /* We may want to cache the bundleRef at some point */
+  static CFBundleRef bundle = 0;
+
+  if (!bundle) {
+
+    CFURLRef bundleURL = CFURLCreateWithFileSystemPath (kCFAllocatorDefault,
+							CFSTR("/System/Library/Frameworks/OpenGL.framework"), kCFURLPOSIXPathStyle, true);
+
+    bundle = CFBundleCreate (kCFAllocatorDefault, bundleURL);
+    CFRelease (bundleURL);
+  }
+
+  if (!bundle)
+    return 0;
+
+  CFStringRef functionName = CFStringCreateWithCString
+    (kCFAllocatorDefault, func, kCFStringEncodingASCII);
+  
+  void *function;
+  
+  function = CFBundleGetFunctionPointerForName (bundle, functionName);
+
+  CFRelease (functionName);
+
+  return function;
+}
+
+#elif !defined( WIN32 )
+
+void *SGGetGLProcAddress(const char *func) {
+    static void *libHandle = NULL;
+    static void *(*glXGetProcAddressPtr)(const GLubyte*) = 0;
+    void *fptr = NULL;
+
+    /*
+     * Clear the error buffer
+     */
+    dlerror();
+
+    /*
+     * Since libGL must be linked to the binary we run on, this is the
+     * right handle. That 'current binary' handle also avoids conflicts which
+     * arise from linking with a different libGL at link time an than later
+     * use the standard libGL at runtime ...
+     */
+    if (libHandle == NULL) {
+        libHandle = dlopen(NULL, RTLD_LAZY);
+
+        if (!libHandle) {
+            const char *error = dlerror();
+            if (error) {
+                SG_LOG(SG_GENERAL, SG_INFO, error);
+                return 0;
+            }
+        }
+
+        void* symbol = dlsym(libHandle, "glXGetProcAddress");
+        if (!symbol)
+            symbol = dlsym(libHandle, "glXGetProcAddressARB");
+        glXGetProcAddressPtr = (void *(*)(const GLubyte*)) symbol;
+    }
+
+    // First try the glx api function for that
+    if (glXGetProcAddressPtr) {
+        fptr = glXGetProcAddressPtr((const GLubyte*)func);
+
+    } else if (libHandle != NULL) {
+        fptr = dlsym(libHandle, func);
+
+        const char *error = dlerror();
+        if (error)
+            SG_LOG(SG_GENERAL, SG_INFO, error);
+    }
+
+    return fptr;
+}
+
+#endif
+