Commits

yotis  committed d592326

made glxx dynamic library

  • Participants
  • Parent commits 5193355

Comments (0)

Files changed (568)

 glob:*.pkl
 glob:*~
 glob:*.pro.user*
-glob:*.directory
+glob:*.directory
+glob:x86_64/*

File generator/glXxx.py

 #ifndef GLXXX
 #define GLXXX
 
+#include <glxx/private/glxx_config.h>
+
 #ifdef __linux__
 
 #include <X11/Xlib.h>
         cpp.write(' */\n')
         
         cpp.write('''
-#include "config.h"
 
 
 #ifdef __linux__

File generator/glxx.py

 #ifndef GL_XX
 #define GL_XX
 
+#include <glxx/private/glxx_config.h>
+
 #include <stddef.h>
 
 typedef unsigned int GLenum;
         cpp_out.write(' */\n')
         
         cpp_out.write('''
-#include "config.h"
 
 
 #if defined(_WIN32) || defined(WIN32)
         
         cpp_out.write('''        
 
-bool has_gl_1_1() { return glxxIsVersionSupported(1, 1); }
-bool has_gl_1_2() { return glxxIsVersionSupported(1, 2); }
-bool has_gl_1_3() { return glxxIsVersionSupported(1, 3); }
-bool has_gl_1_4() { return glxxIsVersionSupported(1, 4); }
-bool has_gl_1_5() { return glxxIsVersionSupported(1, 5); }
-bool has_gl_2_0() { return glxxIsVersionSupported(2, 0); }
-bool has_gl_2_1() { return glxxIsVersionSupported(2, 1); }
-bool has_gl_3_0() { return glxxIsVersionSupported(3, 0); }
-bool has_gl_3_1_compatibility() { return glxxIsVersionSupported(3, 1); }
-bool has_gl_3_2_compatibility() { return glxxIsVersionSupported(3, 2); }
-bool has_gl_3_3_compatibility() { return glxxIsVersionSupported(3, 3); }
-bool has_gl_4_0_compatibility() { return glxxIsVersionSupported(4, 0); }
-bool has_gl_4_1_compatibility() { return glxxIsVersionSupported(4, 1); }
-bool has_gl_4_2_compatibility() { return glxxIsVersionSupported(4, 2); }
-bool has_gl_3_1_core() { return glxxIsVersionSupported(3, 1); }
-bool has_gl_3_2_core() { return glxxIsVersionSupported(3, 2); }
-bool has_gl_3_3_core() { return glxxIsVersionSupported(3, 3); }
-bool has_gl_4_0_core() { return glxxIsVersionSupported(4, 0); }
-bool has_gl_4_1_core() { return glxxIsVersionSupported(4, 1); }
-bool has_gl_4_2_core() { return glxxIsVersionSupported(4, 2); }
+GLXX_EXPORT bool has_gl_1_1() { return glxxIsVersionSupported(1, 1); }
+GLXX_EXPORT bool has_gl_1_2() { return glxxIsVersionSupported(1, 2); }
+GLXX_EXPORT bool has_gl_1_3() { return glxxIsVersionSupported(1, 3); }
+GLXX_EXPORT bool has_gl_1_4() { return glxxIsVersionSupported(1, 4); }
+GLXX_EXPORT bool has_gl_1_5() { return glxxIsVersionSupported(1, 5); }
+GLXX_EXPORT bool has_gl_2_0() { return glxxIsVersionSupported(2, 0); }
+GLXX_EXPORT bool has_gl_2_1() { return glxxIsVersionSupported(2, 1); }
+GLXX_EXPORT bool has_gl_3_0() { return glxxIsVersionSupported(3, 0); }
+GLXX_EXPORT bool has_gl_3_1_compatibility() { return glxxIsVersionSupported(3, 1); }
+GLXX_EXPORT bool has_gl_3_2_compatibility() { return glxxIsVersionSupported(3, 2); }
+GLXX_EXPORT bool has_gl_3_3_compatibility() { return glxxIsVersionSupported(3, 3); }
+GLXX_EXPORT bool has_gl_4_0_compatibility() { return glxxIsVersionSupported(4, 0); }
+GLXX_EXPORT bool has_gl_4_1_compatibility() { return glxxIsVersionSupported(4, 1); }
+GLXX_EXPORT bool has_gl_4_2_compatibility() { return glxxIsVersionSupported(4, 2); }
+GLXX_EXPORT bool has_gl_3_1_core() { return glxxIsVersionSupported(3, 1); }
+GLXX_EXPORT bool has_gl_3_2_core() { return glxxIsVersionSupported(3, 2); }
+GLXX_EXPORT bool has_gl_3_3_core() { return glxxIsVersionSupported(3, 3); }
+GLXX_EXPORT bool has_gl_4_0_core() { return glxxIsVersionSupported(4, 0); }
+GLXX_EXPORT bool has_gl_4_1_core() { return glxxIsVersionSupported(4, 1); }
+GLXX_EXPORT bool has_gl_4_2_core() { return glxxIsVersionSupported(4, 2); }
 
-bool load_gl_1_1() { return load_gl_version_1_1() && load_gl_version_1_1_deprecated(); }
-bool load_gl_1_2() { return load_gl_1_1() && load_gl_version_1_2() && load_gl_version_1_2_deprecated(); }
-bool load_gl_1_3() { return load_gl_1_2() && load_gl_version_1_3() && load_gl_version_1_3_deprecated(); }
-bool load_gl_1_4() { return load_gl_1_3() && load_gl_version_1_4() && load_gl_version_1_4_deprecated(); }
-bool load_gl_1_5() { return load_gl_1_4() && load_gl_version_1_5(); }
-bool load_gl_2_0() { return load_gl_1_5() && load_gl_version_2_0(); }
-bool load_gl_2_1() { return load_gl_2_0() && load_gl_version_2_1(); }
-bool load_gl_3_0() { return load_gl_2_1() && load_gl_version_3_0(); }
-bool load_gl_3_1_compatibility() { return load_gl_3_0() && load_gl_version_3_1(); }
-bool load_gl_3_2_compatibility() { return load_gl_3_1_compatibility() && load_gl_version_3_2(); }
-bool load_gl_3_3_compatibility() { return load_gl_3_2_compatibility() && load_gl_version_3_3(); }
-bool load_gl_4_0_compatibility() { return load_gl_3_3_compatibility() && load_gl_version_4_0(); }
-bool load_gl_4_1_compatibility() { return load_gl_4_0_compatibility() && load_gl_version_4_1(); }
-bool load_gl_4_2_compatibility() { return load_gl_4_1_compatibility() && load_gl_version_4_2(); }
-bool load_gl_3_1_core() { return load_gl_version_1_1() && load_gl_version_1_2() && load_gl_version_1_3() &&
+GLXX_EXPORT bool load_gl_1_1() { return load_gl_version_1_1() && load_gl_version_1_1_deprecated(); }
+GLXX_EXPORT bool load_gl_1_2() { return load_gl_1_1() && load_gl_version_1_2() && load_gl_version_1_2_deprecated(); }
+GLXX_EXPORT bool load_gl_1_3() { return load_gl_1_2() && load_gl_version_1_3() && load_gl_version_1_3_deprecated(); }
+GLXX_EXPORT bool load_gl_1_4() { return load_gl_1_3() && load_gl_version_1_4() && load_gl_version_1_4_deprecated(); }
+GLXX_EXPORT bool load_gl_1_5() { return load_gl_1_4() && load_gl_version_1_5(); }
+GLXX_EXPORT bool load_gl_2_0() { return load_gl_1_5() && load_gl_version_2_0(); }
+GLXX_EXPORT bool load_gl_2_1() { return load_gl_2_0() && load_gl_version_2_1(); }
+GLXX_EXPORT bool load_gl_3_0() { return load_gl_2_1() && load_gl_version_3_0(); }
+GLXX_EXPORT bool load_gl_3_1_compatibility() { return load_gl_3_0() && load_gl_version_3_1(); }
+GLXX_EXPORT bool load_gl_3_2_compatibility() { return load_gl_3_1_compatibility() && load_gl_version_3_2(); }
+GLXX_EXPORT bool load_gl_3_3_compatibility() { return load_gl_3_2_compatibility() && load_gl_version_3_3(); }
+GLXX_EXPORT bool load_gl_4_0_compatibility() { return load_gl_3_3_compatibility() && load_gl_version_4_0(); }
+GLXX_EXPORT bool load_gl_4_1_compatibility() { return load_gl_4_0_compatibility() && load_gl_version_4_1(); }
+GLXX_EXPORT bool load_gl_4_2_compatibility() { return load_gl_4_1_compatibility() && load_gl_version_4_2(); }
+GLXX_EXPORT bool load_gl_3_1_core() { return load_gl_version_1_1() && load_gl_version_1_2() && load_gl_version_1_3() &&
                                  load_gl_version_1_4() && load_gl_version_1_5() && load_gl_version_2_0() &&
                                  load_gl_version_2_1() && load_gl_version_3_0() && load_gl_version_3_1(); }
-bool load_gl_3_2_core() { return load_gl_3_1_core() && load_gl_version_3_2(); }
-bool load_gl_3_3_core() { return load_gl_3_2_core() && load_gl_version_3_3(); }
-bool load_gl_4_0_core() { return load_gl_3_3_core() && load_gl_version_4_0(); }
-bool load_gl_4_1_core() { return load_gl_4_0_core() && load_gl_version_4_1(); }
-bool load_gl_4_2_core() { return load_gl_4_1_core() && load_gl_version_4_2(); }
+GLXX_EXPORT bool load_gl_3_2_core() { return load_gl_3_1_core() && load_gl_version_3_2(); }
+GLXX_EXPORT bool load_gl_3_3_core() { return load_gl_3_2_core() && load_gl_version_3_3(); }
+GLXX_EXPORT bool load_gl_4_0_core() { return load_gl_3_3_core() && load_gl_version_4_0(); }
+GLXX_EXPORT bool load_gl_4_1_core() { return load_gl_4_0_core() && load_gl_version_4_1(); }
+GLXX_EXPORT bool load_gl_4_2_core() { return load_gl_4_1_core() && load_gl_version_4_2(); }
 
-bool has_gl_arb_framebuffer_object_compatibility() { return has_gl_arb_framebuffer_object(); }
-bool has_gl_arb_framebuffer_object_core() { return has_gl_arb_framebuffer_object(); }
-bool load_gl_arb_framebuffer_object_compatibility() { return load_gl_arb_framebuffer_object(); }
-bool load_gl_arb_framebuffer_object_core() { return load_gl_arb_framebuffer_object(); }
+GLXX_EXPORT bool has_gl_arb_framebuffer_object_compatibility() { return has_gl_arb_framebuffer_object(); }
+GLXX_EXPORT bool has_gl_arb_framebuffer_object_core() { return has_gl_arb_framebuffer_object(); }
+GLXX_EXPORT bool load_gl_arb_framebuffer_object_compatibility() { return load_gl_arb_framebuffer_object(); }
+GLXX_EXPORT bool load_gl_arb_framebuffer_object_core() { return load_gl_arb_framebuffer_object(); }
 
-bool has_gl_arb_imaging_compatibility() { return glxxIsExtensionSupported("GL_ARB_imaging"); }
-bool has_gl_arb_imaging_core() { return glxxIsExtensionSupported("GL_ARB_imaging"); }
+GLXX_EXPORT bool has_gl_arb_imaging_compatibility() { return glxxIsExtensionSupported("GL_ARB_imaging"); }
+GLXX_EXPORT bool has_gl_arb_imaging_core() { return glxxIsExtensionSupported("GL_ARB_imaging"); }
 
 #if defined(_WIN32) || defined(WIN32)
 #pragma pop_macro("MemoryBarrier")

File generator/include_proto/glxx/gl_1_1.h

     using namespace gl_version_1_1_deprecated;
 }
 
-bool has_gl_1_1();
-bool load_gl_1_1();
+GLXX_EXPORT bool has_gl_1_1();
+GLXX_EXPORT bool load_gl_1_1();
 
 #endif

File generator/include_proto/glxx/gl_1_2.h

     using namespace gl_version_1_2_deprecated;
 }
 
-bool has_gl_1_2();
-bool load_gl_1_2();
+GLXX_EXPORT bool has_gl_1_2();
+GLXX_EXPORT bool load_gl_1_2();
 
 #endif

File generator/include_proto/glxx/gl_1_3.h

     using namespace gl_version_1_3_deprecated;
 }
 
-bool has_gl_1_3();
-bool load_gl_1_3();
+GLXX_EXPORT bool has_gl_1_3();
+GLXX_EXPORT bool load_gl_1_3();
 
 #endif

File generator/include_proto/glxx/gl_1_4.h

     using namespace gl_version_1_4_deprecated;
 }
 
-bool has_gl_1_4();
-bool load_gl_1_4();
+GLXX_EXPORT bool has_gl_1_4();
+GLXX_EXPORT bool load_gl_1_4();
 
 #endif

File generator/include_proto/glxx/gl_1_5.h

     using namespace gl_version_1_5;
 }
 
-bool has_gl_1_5();
-bool load_gl_1_5();
+GLXX_EXPORT bool has_gl_1_5();
+GLXX_EXPORT bool load_gl_1_5();
 
 #endif

File generator/include_proto/glxx/gl_2_0.h

     using namespace gl_version_2_0;
 }
 
-bool has_gl_2_0();
-bool load_gl_2_0();
+GLXX_EXPORT bool has_gl_2_0();
+GLXX_EXPORT bool load_gl_2_0();
 
 #endif

File generator/include_proto/glxx/gl_2_1.h

     using namespace gl_version_2_1;
 }
 
-bool has_gl_2_1();
-bool load_gl_2_1();
+GLXX_EXPORT bool has_gl_2_1();
+GLXX_EXPORT bool load_gl_2_1();
 
 #endif

File generator/include_proto/glxx/gl_3_0.h

     using namespace gl_version_3_0;
 }
 
-bool has_gl_3_0();
-bool load_gl_3_0();
+GLXX_EXPORT bool has_gl_3_0();
+GLXX_EXPORT bool load_gl_3_0();
 
 #endif

File generator/include_proto/glxx/gl_3_1_compatibility.h

     using namespace gl_version_3_1;
 }
 
-bool has_gl_3_1_compatibility();
-bool load_gl_3_1_compatibility();
+GLXX_EXPORT bool has_gl_3_1_compatibility();
+GLXX_EXPORT bool load_gl_3_1_compatibility();
 
 #endif

File generator/include_proto/glxx/gl_3_1_core.h

     using namespace gl_version_3_1;
 }
 
-bool has_gl_3_1_core();
-bool load_gl_3_1_core();
+GLXX_EXPORT bool has_gl_3_1_core();
+GLXX_EXPORT bool load_gl_3_1_core();
 
 #endif

File generator/include_proto/glxx/gl_3_2_compatibility.h

     using namespace gl_version_3_2;
 }
 
-bool has_gl_3_2_compatibility();
-bool load_gl_3_2_compatibility();
+GLXX_EXPORT bool has_gl_3_2_compatibility();
+GLXX_EXPORT bool load_gl_3_2_compatibility();
 
 #endif

File generator/include_proto/glxx/gl_3_2_core.h

     using namespace gl_version_3_2;
 }
 
-bool has_gl_3_2_core();
-bool load_gl_3_2_core();
+GLXX_EXPORT bool has_gl_3_2_core();
+GLXX_EXPORT bool load_gl_3_2_core();
 
 #endif

File generator/include_proto/glxx/gl_3_3_compatibility.h

     using namespace gl_version_3_3;
 }
 
-bool has_gl_3_3_compatibility();
-bool load_gl_3_3_compatibility();
+GLXX_EXPORT bool has_gl_3_3_compatibility();
+GLXX_EXPORT bool load_gl_3_3_compatibility();
 
 
 #endif

File generator/include_proto/glxx/gl_3_3_core.h

     using namespace gl_version_3_3;
 }
 
-bool has_gl_3_3_core();
-bool load_gl_3_3_core();
+GLXX_EXPORT bool has_gl_3_3_core();
+GLXX_EXPORT bool load_gl_3_3_core();
 
 #endif

File generator/include_proto/glxx/gl_4_0_compatibility.h

     using namespace gl_version_4_0;
 }
 
-bool has_gl_4_0_compatibility();
-bool load_gl_4_0_compatibility();
+GLXX_EXPORT bool has_gl_4_0_compatibility();
+GLXX_EXPORT bool load_gl_4_0_compatibility();
 
 #endif

File generator/include_proto/glxx/gl_4_0_core.h

     using namespace gl_version_4_0;
 }
 
-bool has_gl_4_0_core();
-bool load_gl_4_0_core();
+GLXX_EXPORT bool has_gl_4_0_core();
+GLXX_EXPORT bool load_gl_4_0_core();
 
 #endif

File generator/include_proto/glxx/gl_4_1_compatibility.h

     using namespace gl_version_4_1;
 }
 
-bool has_gl_4_1_compatibility();
-bool load_gl_4_1_compatibility();
+GLXX_EXPORT bool has_gl_4_1_compatibility();
+GLXX_EXPORT bool load_gl_4_1_compatibility();
 
 #endif

File generator/include_proto/glxx/gl_4_1_core.h

     using namespace gl_version_4_1;
 }
 
-bool has_gl_4_1_core();
-bool load_gl_4_1_core();
+GLXX_EXPORT bool has_gl_4_1_core();
+GLXX_EXPORT bool load_gl_4_1_core();
 
 #endif

File generator/include_proto/glxx/gl_4_2_compatibility.h

     using namespace gl_version_4_2;
 }
 
-bool has_gl_4_2_compatibility();
-bool load_gl_4_2_compatibility();
+GLXX_EXPORT bool has_gl_4_2_compatibility();
+GLXX_EXPORT bool load_gl_4_2_compatibility();
 
 #endif

File generator/include_proto/glxx/gl_4_2_core.h

     using namespace gl_version_4_2;
 }
 
-bool has_gl_4_2_core();
-bool load_gl_4_2_core();
+GLXX_EXPORT bool has_gl_4_2_core();
+GLXX_EXPORT bool load_gl_4_2_core();
 
 #endif

File generator/include_proto/glxx/gl_arb_framebuffer_object_combatibility.h

     using namespace gl_arb_framebuffer_object_deprecated;
 }
 
-bool has_gl_arb_framebuffer_object_combatibility();
-bool load_gl_arb_framebuffer_object_combatibility();
+GLXX_EXPORT bool has_gl_arb_framebuffer_object_combatibility();
+GLXX_EXPORT bool load_gl_arb_framebuffer_object_combatibility();
 
 #endif

File generator/include_proto/glxx/gl_arb_framebuffer_object_core.h

     using namespace gl_arb_framebuffer_object;
 }
 
-bool has_gl_arb_framebuffer_object_core();
-bool load_gl_arb_framebuffer_object_core();
+GLXX_EXPORT bool has_gl_arb_framebuffer_object_core();
+GLXX_EXPORT bool load_gl_arb_framebuffer_object_core();
 
 #endif

File generator/include_proto/glxx/gl_arb_imaging_combatibility.h

 #include "private/gl_arb_imaging"
 #include "private/gl_arb_imaging_deprecated"
 
-bool has_gl_arb_imaging_compatibility();
+GLXX_EXPORT bool has_gl_arb_imaging_compatibility();
 
 #endif

File generator/include_proto/glxx/gl_arb_imaging_core.h

 
 #include "private/gl_arb_imaging"
 
-bool has_gl_arb_imaging_core();
+GLXX_EXPORT bool has_gl_arb_imaging_core();
 
 #endif

File generator/include_proto/glxx/private/glxx_config.h

+#ifndef GLXX_CONFIG_H
+#define GLXX_CONFIG_H
+
+// GLXX_EXPORT macro
+#if defined(_WIN32) || defined(WIN32)
+#  if defined(GLXX_LIBRARY_BUILD)
+#    define GLXX_EXPORT __declspec(dllexport)
+#  else
+#    define GLXX_EXPORT __declspec(dllimport)
+#  endif
+#endif
+
+#if defined(__linux__)
+#  define GLXX_EXPORT
+#endif
+
+
+#ifdef GLXX_LIBRARY_BUILD
+// thread local storage control
+#  define GLXX_TLS
+// namespace injection control
+#  define GLXX_NO_NAMESPACE_INJECTION
+#endif
+
+#endif

File generator/parse.py

             if category_functions:
                 cf.write('\nnamespace %s_%s\n{\n' % (prefix.lower(), category.lower()))
                 for f in category_functions:
-                    cf.write('    %s %s%s(%s);\n' % (tm[f.returns], prefix, f.name, ', '.join(f.make_param_list(tm))))
+                    cf.write('    GLXX_EXPORT %s %s%s(%s);\n' % (tm[f.returns], prefix, f.name, ', '.join(f.make_param_list(tm))))
                 cf.write('}\n')
                 cf.write('\n#ifndef GLXX_NO_NAMESPACE_INJECTION')
                 cf.write('\nusing namespace %s_%s;' % (prefix.lower(), category.lower()))
                 cf.write('\n#endif\n')
             if '/private/' not in category_filename:
-                cf.write('\nbool has_%s_%s();\n' % (prefix.lower(), category.lower()))
+                cf.write('\nGLXX_EXPORT bool  has_%s_%s();\n' % (prefix.lower(), category.lower()))
                 if category_functions:
-                    cf.write('bool load_%s_%s();\n' % (prefix.lower(), category.lower()))
+                    cf.write('GLXX_EXPORT bool  load_%s_%s();\n' % (prefix.lower(), category.lower()))
             if passes_end:
                 cf.write('\n'.join(passes_end))
             cf.write('\n#endif\n')
 
         ### load_... functions
         out_cpp.append('''
-bool load_%s_%s()
+GLXX_EXPORT bool load_%s_%s()
 {
     assert(%sxxGetCurrentCtx() && "load_%s_%s() called without a current context");
 
         m = re_parse_version.match(category)
         if not m:
             out_cpp.append('''
-bool has_%s_%s()
+GLXX_EXPORT bool has_%s_%s()
 {
     return %sxxIsExtensionSupported("%s_%s");
 }
             fun_ret = ''
             if fun.returns != 'void': fun_ret = 'return '
             out_cpp.append('''
-%s %s_%s::%s%s(%s)
+GLXX_EXPORT %s  %s_%s::%s%s(%s)
 {
     %s%sxx_current_loader->%s(%s);
 }''' % (tm[fun.returns], prefix.lower(), category.lower(), prefix, fun.name, param_list,

File generator/wglxx.py

 #ifndef WGLXX
 #define WGLXX
 
+#include <glxx/private/glxx_config.h>
+
 #if defined(_WIN32) || defined(WIN32)
 #include <Windows.h>
 
         cpp.write(' */\n')
 
         cpp.write('''
-#include "config.h"
 
             
 #if defined(_WIN32) || defined(WIN32)
-QT       -= core gui
+QT -= core gui
+QT += opengl
 
 TARGET = glxx
 TEMPLATE = lib
-CONFIG += staticlib
 
 DESTDIR = $$PWD/$$QMAKE_HOST.arch
 CONFIG(debug, debug|release): TARGET = $${TARGET}_d
 CONFIG(release, debug|release): DEFINES += NDEBUG
 
+DEFINES += GLXX_LIBRARY_BUILD
+
 INCLUDEPATH += include
 
 SOURCES += \

File include/glXxx/glx_arb_create_context.h

 
 namespace glx_arb_create_context
 {
-    GLXContext glXCreateContextAttribsARB(Display* dpy, GLXFBConfig config, GLXContext share_context, Bool direct, const int* attrib_list);
+    GLXX_EXPORT GLXContext glXCreateContextAttribsARB(Display* dpy, GLXFBConfig config, GLXContext share_context, Bool direct, const int* attrib_list);
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_arb_create_context;
 #endif
 
-bool has_glx_arb_create_context();
-bool load_glx_arb_create_context();
+GLXX_EXPORT bool  has_glx_arb_create_context();
+GLXX_EXPORT bool  load_glx_arb_create_context();
 
 #endif

File include/glXxx/glx_arb_create_context_profile.h

 #define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
 #define GLX_CONTEXT_PROFILE_MASK_ARB 0x9126
 
-bool has_glx_arb_create_context_profile();
+GLXX_EXPORT bool  has_glx_arb_create_context_profile();
 
 #endif

File include/glXxx/glx_arb_create_context_robustness.h

 #define GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
 #define GLX_NO_RESET_NOTIFICATION_ARB 0x8261
 
-bool has_glx_arb_create_context_robustness();
+GLXX_EXPORT bool  has_glx_arb_create_context_robustness();
 
 #endif

File include/glXxx/glx_arb_fbconfig_float.h

 #define GLX_RGBA_FLOAT_TYPE_ARB 0x20B9
 #define GLX_RGBA_FLOAT_BIT_ARB 0x00000004
 
-bool has_glx_arb_fbconfig_float();
+GLXX_EXPORT bool  has_glx_arb_fbconfig_float();
 
 #endif

File include/glXxx/glx_arb_framebuffer_srgb.h

 
 #define GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20B2
 
-bool has_glx_arb_framebuffer_srgb();
+GLXX_EXPORT bool  has_glx_arb_framebuffer_srgb();
 
 #endif

File include/glXxx/glx_arb_get_proc_address.h

 
 namespace glx_arb_get_proc_address
 {
-    __GLXextFuncPtr glXGetProcAddressARB(const GLubyte* procName);
+    GLXX_EXPORT __GLXextFuncPtr glXGetProcAddressARB(const GLubyte* procName);
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_arb_get_proc_address;
 #endif
 
-bool has_glx_arb_get_proc_address();
-bool load_glx_arb_get_proc_address();
+GLXX_EXPORT bool  has_glx_arb_get_proc_address();
+GLXX_EXPORT bool  load_glx_arb_get_proc_address();
 
 #endif

File include/glXxx/glx_arb_multisample.h

 #define GLX_SAMPLE_BUFFERS_ARB 100000
 #define GLX_SAMPLES_ARB 100001
 
-bool has_glx_arb_multisample();
+GLXX_EXPORT bool  has_glx_arb_multisample();
 
 #endif

File include/glXxx/glx_ext_fbconfig_packed_float.h

 #define GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT 0x20B1
 #define GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT 0x00000008
 
-bool has_glx_ext_fbconfig_packed_float();
+GLXX_EXPORT bool  has_glx_ext_fbconfig_packed_float();
 
 #endif

File include/glXxx/glx_ext_framebuffer_srgb.h

 
 #define GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x20B2
 
-bool has_glx_ext_framebuffer_srgb();
+GLXX_EXPORT bool  has_glx_ext_framebuffer_srgb();
 
 #endif

File include/glXxx/glx_ext_import_context.h

 
 namespace glx_ext_import_context
 {
-    Display * glXGetCurrentDisplayEXT();
-    int glXQueryContextInfoEXT(Display* dpy, GLXContext context, int attribute, int* value);
-    GLXContextID glXGetContextIDEXT(const GLXContext context);
-    GLXContext glXImportContextEXT(Display* dpy, GLXContextID contextID);
-    void glXFreeContextEXT(Display* dpy, GLXContext context);
+    GLXX_EXPORT Display * glXGetCurrentDisplayEXT();
+    GLXX_EXPORT int glXQueryContextInfoEXT(Display* dpy, GLXContext context, int attribute, int* value);
+    GLXX_EXPORT GLXContextID glXGetContextIDEXT(const GLXContext context);
+    GLXX_EXPORT GLXContext glXImportContextEXT(Display* dpy, GLXContextID contextID);
+    GLXX_EXPORT void glXFreeContextEXT(Display* dpy, GLXContext context);
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_ext_import_context;
 #endif
 
-bool has_glx_ext_import_context();
-bool load_glx_ext_import_context();
+GLXX_EXPORT bool  has_glx_ext_import_context();
+GLXX_EXPORT bool  load_glx_ext_import_context();
 
 #endif

File include/glXxx/glx_ext_swap_control.h

 
 namespace glx_ext_swap_control
 {
-    int glXSwapIntervalEXT(Display* dpy, GLXDrawable drawable, int interval);
+    GLXX_EXPORT int glXSwapIntervalEXT(Display* dpy, GLXDrawable drawable, int interval);
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_ext_swap_control;
 #endif
 
-bool has_glx_ext_swap_control();
-bool load_glx_ext_swap_control();
+GLXX_EXPORT bool  has_glx_ext_swap_control();
+GLXX_EXPORT bool  load_glx_ext_swap_control();
 
 #endif

File include/glXxx/glx_ext_texture_from_pixmap.h

 
 namespace glx_ext_texture_from_pixmap
 {
-    void glXBindTexImageEXT(Display* dpy, GLXDrawable drawable, int buffer, const int* attrib_list);
-    void glXReleaseTexImageEXT(Display* dpy, GLXDrawable drawable, int buffer);
+    GLXX_EXPORT void glXBindTexImageEXT(Display* dpy, GLXDrawable drawable, int buffer, const int* attrib_list);
+    GLXX_EXPORT void glXReleaseTexImageEXT(Display* dpy, GLXDrawable drawable, int buffer);
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_ext_texture_from_pixmap;
 #endif
 
-bool has_glx_ext_texture_from_pixmap();
-bool load_glx_ext_texture_from_pixmap();
+GLXX_EXPORT bool  has_glx_ext_texture_from_pixmap();
+GLXX_EXPORT bool  load_glx_ext_texture_from_pixmap();
 
 #endif

File include/glXxx/glx_ext_visual_info.h

 #define GLX_TRANSPARENT_RGB_EXT 0x8008
 #define GLX_TRANSPARENT_INDEX_EXT 0x8009
 
-bool has_glx_ext_visual_info();
+GLXX_EXPORT bool  has_glx_ext_visual_info();
 
 #endif

File include/glXxx/glx_ext_visual_rating.h

 #define GLX_NON_CONFORMANT_VISUAL_EXT 0x800D
 #define GLX_NONE_EXT 0x8000
 
-bool has_glx_ext_visual_rating();
+GLXX_EXPORT bool  has_glx_ext_visual_rating();
 
 #endif

File include/glXxx/glx_intel_swap_event.h

 #define GLX_COPY_COMPLETE_INTEL 0x8181
 #define GLX_FLIP_COMPLETE_INTEL 0x8182
 
-bool has_glx_intel_swap_event();
+GLXX_EXPORT bool  has_glx_intel_swap_event();
 
 #endif

File include/glXxx/glx_mesa_agp_offset.h

 
 namespace glx_mesa_agp_offset
 {
-    unsigned int glXGetAGPOffsetMESA(const void* pointer);
+    GLXX_EXPORT unsigned int glXGetAGPOffsetMESA(const void* pointer);
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_mesa_agp_offset;
 #endif
 
-bool has_glx_mesa_agp_offset();
-bool load_glx_mesa_agp_offset();
+GLXX_EXPORT bool  has_glx_mesa_agp_offset();
+GLXX_EXPORT bool  load_glx_mesa_agp_offset();
 
 #endif

File include/glXxx/glx_mesa_copy_sub_buffer.h

 
 namespace glx_mesa_copy_sub_buffer
 {
-    void glXCopySubBufferMESA(Display* dpy, GLXDrawable drawable, int x, int y, int width, int height);
+    GLXX_EXPORT void glXCopySubBufferMESA(Display* dpy, GLXDrawable drawable, int x, int y, int width, int height);
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_mesa_copy_sub_buffer;
 #endif
 
-bool has_glx_mesa_copy_sub_buffer();
-bool load_glx_mesa_copy_sub_buffer();
+GLXX_EXPORT bool  has_glx_mesa_copy_sub_buffer();
+GLXX_EXPORT bool  load_glx_mesa_copy_sub_buffer();
 
 #endif

File include/glXxx/glx_mesa_pixmap_colormap.h

 
 namespace glx_mesa_pixmap_colormap
 {
-    GLXPixmap glXCreateGLXPixmapMESA(Display* dpy, XVisualInfo* visual, Pixmap pixmap, Colormap cmap);
+    GLXX_EXPORT GLXPixmap glXCreateGLXPixmapMESA(Display* dpy, XVisualInfo* visual, Pixmap pixmap, Colormap cmap);
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_mesa_pixmap_colormap;
 #endif
 
-bool has_glx_mesa_pixmap_colormap();
-bool load_glx_mesa_pixmap_colormap();
+GLXX_EXPORT bool  has_glx_mesa_pixmap_colormap();
+GLXX_EXPORT bool  load_glx_mesa_pixmap_colormap();
 
 #endif

File include/glXxx/glx_mesa_release_buffers.h

 
 namespace glx_mesa_release_buffers
 {
-    Bool glXReleaseBuffersMESA(Display* dpy, GLXDrawable drawable);
+    GLXX_EXPORT Bool glXReleaseBuffersMESA(Display* dpy, GLXDrawable drawable);
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_mesa_release_buffers;
 #endif
 
-bool has_glx_mesa_release_buffers();
-bool load_glx_mesa_release_buffers();
+GLXX_EXPORT bool  has_glx_mesa_release_buffers();
+GLXX_EXPORT bool  load_glx_mesa_release_buffers();
 
 #endif

File include/glXxx/glx_mesa_set_3dfx_mode.h

 
 namespace glx_mesa_set_3dfx_mode
 {
-    Bool glXSet3DfxModeMESA(int mode);
+    GLXX_EXPORT Bool glXSet3DfxModeMESA(int mode);
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_mesa_set_3dfx_mode;
 #endif
 
-bool has_glx_mesa_set_3dfx_mode();
-bool load_glx_mesa_set_3dfx_mode();
+GLXX_EXPORT bool  has_glx_mesa_set_3dfx_mode();
+GLXX_EXPORT bool  load_glx_mesa_set_3dfx_mode();
 
 #endif

File include/glXxx/glx_nv_copy_image.h

 
 namespace glx_nv_copy_image
 {
-    void glXCopyImageSubDataNV(Display* dpy, GLXContext srcCtx, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLXContext dstCtx, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth);
+    GLXX_EXPORT void glXCopyImageSubDataNV(Display* dpy, GLXContext srcCtx, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLXContext dstCtx, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth);
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_nv_copy_image;
 #endif
 
-bool has_glx_nv_copy_image();
-bool load_glx_nv_copy_image();
+GLXX_EXPORT bool  has_glx_nv_copy_image();
+GLXX_EXPORT bool  load_glx_nv_copy_image();
 
 #endif

File include/glXxx/glx_nv_float_buffer.h

 
 #define GLX_FLOAT_COMPONENTS_NV 0x20B0
 
-bool has_glx_nv_float_buffer();
+GLXX_EXPORT bool  has_glx_nv_float_buffer();
 
 #endif

File include/glXxx/glx_nv_multisample_coverage.h

 #define GLX_COVERAGE_SAMPLES_NV 100001
 #define GLX_COLOR_SAMPLES_NV 0x20B3
 
-bool has_glx_nv_multisample_coverage();
+GLXX_EXPORT bool  has_glx_nv_multisample_coverage();
 
 #endif

File include/glXxx/glx_nv_present_video.h

 
 namespace glx_nv_present_video
 {
-    unsigned int * glXEnumerateVideoDevicesNV(Display* dpy, int screen, int* nelements);
-    int glXBindVideoDeviceNV(Display* dpy, unsigned int video_slot, unsigned int video_device, const int* attrib_list);
+    GLXX_EXPORT unsigned int * glXEnumerateVideoDevicesNV(Display* dpy, int screen, int* nelements);
+    GLXX_EXPORT int glXBindVideoDeviceNV(Display* dpy, unsigned int video_slot, unsigned int video_device, const int* attrib_list);
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_nv_present_video;
 #endif
 
-bool has_glx_nv_present_video();
-bool load_glx_nv_present_video();
+GLXX_EXPORT bool  has_glx_nv_present_video();
+GLXX_EXPORT bool  load_glx_nv_present_video();
 
 #endif

File include/glXxx/glx_nv_swap_group.h

 
 namespace glx_nv_swap_group
 {
-    Bool glXJoinSwapGroupNV(Display* dpy, GLXDrawable drawable, GLuint group);
-    Bool glXBindSwapBarrierNV(Display* dpy, GLuint group, GLuint barrier);
-    Bool glXQuerySwapGroupNV(Display* dpy, GLXDrawable drawable, GLuint* group, GLuint* barrier);
-    Bool glXQueryMaxSwapGroupsNV(Display* dpy, int screen, GLuint* maxGroups, GLuint* maxBarriers);
-    Bool glXQueryFrameCountNV(Display* dpy, int screen, GLuint* count);
-    Bool glXResetFrameCountNV(Display* dpy, int screen);
+    GLXX_EXPORT Bool glXJoinSwapGroupNV(Display* dpy, GLXDrawable drawable, GLuint group);
+    GLXX_EXPORT Bool glXBindSwapBarrierNV(Display* dpy, GLuint group, GLuint barrier);
+    GLXX_EXPORT Bool glXQuerySwapGroupNV(Display* dpy, GLXDrawable drawable, GLuint* group, GLuint* barrier);
+    GLXX_EXPORT Bool glXQueryMaxSwapGroupsNV(Display* dpy, int screen, GLuint* maxGroups, GLuint* maxBarriers);
+    GLXX_EXPORT Bool glXQueryFrameCountNV(Display* dpy, int screen, GLuint* count);
+    GLXX_EXPORT Bool glXResetFrameCountNV(Display* dpy, int screen);
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_nv_swap_group;
 #endif
 
-bool has_glx_nv_swap_group();
-bool load_glx_nv_swap_group();
+GLXX_EXPORT bool  has_glx_nv_swap_group();
+GLXX_EXPORT bool  load_glx_nv_swap_group();
 
 #endif

File include/glXxx/glx_nv_video_capture.h

 
 namespace glx_nv_video_capture
 {
-    int glXBindVideoCaptureDeviceNV(Display* dpy, unsigned int video_capture_slot, GLXVideoCaptureDeviceNV device);
-    GLXVideoCaptureDeviceNV * glXEnumerateVideoCaptureDevicesNV(Display* dpy, int screen, int* nelements);
-    void glXLockVideoCaptureDeviceNV(Display* dpy, GLXVideoCaptureDeviceNV device);
-    int glXQueryVideoCaptureDeviceNV(Display* dpy, GLXVideoCaptureDeviceNV device, int attribute, int* value);
-    void glXReleaseVideoCaptureDeviceNV(Display* dpy, GLXVideoCaptureDeviceNV device);
+    GLXX_EXPORT int glXBindVideoCaptureDeviceNV(Display* dpy, unsigned int video_capture_slot, GLXVideoCaptureDeviceNV device);
+    GLXX_EXPORT GLXVideoCaptureDeviceNV * glXEnumerateVideoCaptureDevicesNV(Display* dpy, int screen, int* nelements);
+    GLXX_EXPORT void glXLockVideoCaptureDeviceNV(Display* dpy, GLXVideoCaptureDeviceNV device);
+    GLXX_EXPORT int glXQueryVideoCaptureDeviceNV(Display* dpy, GLXVideoCaptureDeviceNV device, int attribute, int* value);
+    GLXX_EXPORT void glXReleaseVideoCaptureDeviceNV(Display* dpy, GLXVideoCaptureDeviceNV device);
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_nv_video_capture;
 #endif
 
-bool has_glx_nv_video_capture();
-bool load_glx_nv_video_capture();
+GLXX_EXPORT bool  has_glx_nv_video_capture();
+GLXX_EXPORT bool  load_glx_nv_video_capture();
 
 #endif

File include/glXxx/glx_nv_video_output.h

 
 namespace glx_nv_video_output
 {
-    int glXGetVideoDeviceNV(Display* dpy, int screen, int numVideoDevices, GLXVideoDeviceNV* pVideoDevice);
-    int glXReleaseVideoDeviceNV(Display* dpy, int screen, GLXVideoDeviceNV VideoDevice);
-    int glXBindVideoImageNV(Display* dpy, GLXVideoDeviceNV VideoDevice, GLXPbuffer pbuf, int iVideoBuffer);
-    int glXReleaseVideoImageNV(Display* dpy, GLXPbuffer pbuf);
-    int glXSendPbufferToVideoNV(Display* dpy, GLXPbuffer pbuf, int iBufferType, unsigned long* pulCounterPbuffer, GLboolean bBlock);
-    int glXGetVideoInfoNV(Display* dpy, int screen, GLXVideoDeviceNV VideoDevice, unsigned long* pulCounterOutputPbuffer, unsigned long* pulCounterOutputVideo);
+    GLXX_EXPORT int glXGetVideoDeviceNV(Display* dpy, int screen, int numVideoDevices, GLXVideoDeviceNV* pVideoDevice);
+    GLXX_EXPORT int glXReleaseVideoDeviceNV(Display* dpy, int screen, GLXVideoDeviceNV VideoDevice);
+    GLXX_EXPORT int glXBindVideoImageNV(Display* dpy, GLXVideoDeviceNV VideoDevice, GLXPbuffer pbuf, int iVideoBuffer);
+    GLXX_EXPORT int glXReleaseVideoImageNV(Display* dpy, GLXPbuffer pbuf);
+    GLXX_EXPORT int glXSendPbufferToVideoNV(Display* dpy, GLXPbuffer pbuf, int iBufferType, unsigned long* pulCounterPbuffer, GLboolean bBlock);
+    GLXX_EXPORT int glXGetVideoInfoNV(Display* dpy, int screen, GLXVideoDeviceNV VideoDevice, unsigned long* pulCounterOutputPbuffer, unsigned long* pulCounterOutputVideo);
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_nv_video_output;
 #endif
 
-bool has_glx_nv_video_output();
-bool load_glx_nv_video_output();
+GLXX_EXPORT bool  has_glx_nv_video_output();
+GLXX_EXPORT bool  load_glx_nv_video_output();
 
 #endif

File include/glXxx/glx_oml_swap_method.h

 #define GLX_SWAP_COPY_OML 0x8062
 #define GLX_SWAP_UNDEFINED_OML 0x8063
 
-bool has_glx_oml_swap_method();
+GLXX_EXPORT bool  has_glx_oml_swap_method();
 
 #endif

File include/glXxx/glx_oml_sync_control.h

 
 namespace glx_oml_sync_control
 {
-    Bool glXGetSyncValuesOML(Display* dpy, GLXDrawable drawable, int64_t* ust, int64_t* msc, int64_t* sbc);
-    Bool glXGetMscRateOML(Display* dpy, GLXDrawable drawable, int32_t* numerator, int32_t* denominator);
-    int64_t glXSwapBuffersMscOML(Display* dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder);
-    Bool glXWaitForMscOML(Display* dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder, int64_t* ust, int64_t* msc, int64_t* sbc);
-    Bool glXWaitForSbcOML(Display* dpy, GLXDrawable drawable, int64_t target_sbc, int64_t* ust, int64_t* msc, int64_t* sbc);
+    GLXX_EXPORT Bool glXGetSyncValuesOML(Display* dpy, GLXDrawable drawable, int64_t* ust, int64_t* msc, int64_t* sbc);
+    GLXX_EXPORT Bool glXGetMscRateOML(Display* dpy, GLXDrawable drawable, int32_t* numerator, int32_t* denominator);
+    GLXX_EXPORT int64_t glXSwapBuffersMscOML(Display* dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder);
+    GLXX_EXPORT Bool glXWaitForMscOML(Display* dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder, int64_t* ust, int64_t* msc, int64_t* sbc);
+    GLXX_EXPORT Bool glXWaitForSbcOML(Display* dpy, GLXDrawable drawable, int64_t target_sbc, int64_t* ust, int64_t* msc, int64_t* sbc);
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_oml_sync_control;
 #endif
 
-bool has_glx_oml_sync_control();
-bool load_glx_oml_sync_control();
+GLXX_EXPORT bool  has_glx_oml_sync_control();
+GLXX_EXPORT bool  load_glx_oml_sync_control();
 
 #endif

File include/glXxx/glx_sgi_cushion.h

 
 namespace glx_sgi_cushion
 {
-    void glXCushionSGI(Display* dpy, Window window, float cushion);
+    GLXX_EXPORT void glXCushionSGI(Display* dpy, Window window, float cushion);
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_sgi_cushion;
 #endif
 
-bool has_glx_sgi_cushion();
-bool load_glx_sgi_cushion();
+GLXX_EXPORT bool  has_glx_sgi_cushion();
+GLXX_EXPORT bool  load_glx_sgi_cushion();
 
 #endif

File include/glXxx/glx_sgi_make_current_read.h

 
 namespace glx_sgi_make_current_read
 {
-    Bool glXMakeCurrentReadSGI(Display* dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
-    GLXDrawable glXGetCurrentReadDrawableSGI();
+    GLXX_EXPORT Bool glXMakeCurrentReadSGI(Display* dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+    GLXX_EXPORT GLXDrawable glXGetCurrentReadDrawableSGI();
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_sgi_make_current_read;
 #endif
 
-bool has_glx_sgi_make_current_read();
-bool load_glx_sgi_make_current_read();
+GLXX_EXPORT bool  has_glx_sgi_make_current_read();
+GLXX_EXPORT bool  load_glx_sgi_make_current_read();
 
 #endif

File include/glXxx/glx_sgi_swap_control.h

 
 namespace glx_sgi_swap_control
 {
-    int glXSwapIntervalSGI(int interval);
+    GLXX_EXPORT int glXSwapIntervalSGI(int interval);
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_sgi_swap_control;
 #endif
 
-bool has_glx_sgi_swap_control();
-bool load_glx_sgi_swap_control();
+GLXX_EXPORT bool  has_glx_sgi_swap_control();
+GLXX_EXPORT bool  load_glx_sgi_swap_control();
 
 #endif

File include/glXxx/glx_sgi_video_sync.h

 
 namespace glx_sgi_video_sync
 {
-    int glXGetVideoSyncSGI(unsigned int* count);
-    int glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int* count);
+    GLXX_EXPORT int glXGetVideoSyncSGI(unsigned int* count);
+    GLXX_EXPORT int glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int* count);
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_sgi_video_sync;
 #endif
 
-bool has_glx_sgi_video_sync();
-bool load_glx_sgi_video_sync();
+GLXX_EXPORT bool  has_glx_sgi_video_sync();
+GLXX_EXPORT bool  load_glx_sgi_video_sync();
 
 #endif

File include/glXxx/glx_sgis_multisample.h

 #define GLX_SAMPLE_BUFFERS_SGIS 100000
 #define GLX_SAMPLES_SGIS 100001
 
-bool has_glx_sgis_multisample();
+GLXX_EXPORT bool  has_glx_sgis_multisample();
 
 #endif

File include/glXxx/glx_sgix_dmbuffer.h

 
 namespace glx_sgix_dmbuffer
 {
-    Bool glXAssociateDMPbufferSGIX(Display* dpy, GLXPbufferSGIX pbuffer, DMparams* params, DMbuffer dmbuffer);
+    GLXX_EXPORT Bool glXAssociateDMPbufferSGIX(Display* dpy, GLXPbufferSGIX pbuffer, DMparams* params, DMbuffer dmbuffer);
 }
 
 #ifndef GLXX_NO_NAMESPACE_INJECTION
 using namespace glx_sgix_dmbuffer;
 #endif
 
-bool has_glx_sgix_dmbuffer();
-bool load_glx_sgix_dmbuffer();
+GLXX_EXPORT bool  has_glx_sgix_dmbuffer();
+GLXX_EXPORT bool  load_glx_sgix_dmbuffer();
 #endif /* _DM_BUFFER_H_ */
 #endif

File include/glXxx/glx_sgix_fbconfig.h