diff --git a/src/Makefile.am b/src/Makefile.am index 9479415..eb22ecf 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -89,16 +89,22 @@ libepoxy_la_SOURCES = \ dispatch_common.c \ dispatch_common.h \ $(GENERATED_GL) \ - $(BUILD_GENERATED_EGL) \ - $(BUILD_GENERATED_GLX) \ + $(BUILD_EGL_CODE) \ + $(BUILD_GLX_CODE) \ $() if BUILD_EGL -BUILD_GENERATED_EGL = $(GENERATED_EGL) +BUILD_EGL_CODE = \ + $(GENERATED_EGL) \ + dispatch_egl.c \ + $() endif if BUILD_GLX -BUILD_GENERATED_GLX = $(GENERATED_GLX) +BUILD_GLX_CODE = \ + $(GENERATED_GLX) \ + dispatch_glx.c \ + $() endif # These are generated alongside the .c file. diff --git a/src/dispatch_common.c b/src/dispatch_common.c index 0ce0218..fa8507d 100644 --- a/src/dispatch_common.c +++ b/src/dispatch_common.c @@ -235,76 +235,7 @@ epoxy_conservative_gl_version(void) return epoxy_internal_gl_version(100); } -/** - * If we can determine the GLX version from the current context, then - * return that, otherwise return a version that will just send us on - * to dlsym() or get_proc_address(). - */ -int -epoxy_conservative_glx_version(void) -{ - Display *dpy = glXGetCurrentDisplay(); - GLXContext ctx = glXGetCurrentContext(); - int screen; - - if (!dpy || !ctx) - return 14; - - glXQueryContext(dpy, ctx, GLX_SCREEN, &screen); - - return epoxy_glx_version(dpy, screen); -} - -PUBLIC int -epoxy_glx_version(Display *dpy, int screen) -{ - int server_major, server_minor; - int client_major, client_minor; - int server, client; - const char *version_string; - int ret; - - version_string = glXQueryServerString(dpy, screen, GLX_VERSION); - ret = sscanf(version_string, "%d.%d", &server_major, &server_minor); - assert(ret == 2); - server = server_major * 10 + server_minor; - - version_string = glXGetClientString(dpy, GLX_VERSION); - ret = sscanf(version_string, "%d.%d", &client_major, &client_minor); - assert(ret == 2); - client = client_major * 10 + client_minor; - - if (client < server) - return client; - else - return server; -} - -PUBLIC int -epoxy_conservative_egl_version(void) -{ - EGLDisplay *dpy = eglGetCurrentDisplay(); - - if (!dpy) - return 14; - - return epoxy_egl_version(dpy); -} - -PUBLIC int -epoxy_egl_version(EGLDisplay *dpy) -{ - int major, minor; - const char *version_string; - int ret; - - version_string = eglQueryString(dpy, EGL_VERSION); - ret = sscanf(version_string, "%d.%d", &major, &minor); - assert(ret == 2); - return major * 10 + minor; -} - -static bool +bool epoxy_extension_in_string(const char *extension_list, const char *ext) { const char *ptr = extension_list; @@ -366,55 +297,6 @@ epoxy_conservative_has_gl_extension(const char *ext) return epoxy_internal_has_gl_extension(ext, true); } -bool -epoxy_conservative_has_egl_extension(const char *ext) -{ - EGLDisplay *dpy = eglGetCurrentDisplay(); - - if (!dpy) - return true; - - return epoxy_has_egl_extension(dpy, ext); -} - -PUBLIC bool -epoxy_has_egl_extension(EGLDisplay *dpy, const char *ext) -{ - return epoxy_extension_in_string(eglQueryString(dpy, EGL_EXTENSIONS), ext); -} - -/** - * If we can determine the GLX extension support from the current - * context, then return that, otherwise give the answer that will just - * send us on to get_proc_address(). - */ -bool -epoxy_conservative_has_glx_extension(const char *ext) -{ - Display *dpy = glXGetCurrentDisplay(); - GLXContext ctx = glXGetCurrentContext(); - int screen; - - if (!dpy || !ctx) - return true; - - glXQueryContext(dpy, ctx, GLX_SCREEN, &screen); - - return epoxy_has_glx_extension(dpy, screen, ext); -} - -PUBLIC bool -epoxy_has_glx_extension(Display *dpy, int screen, const char *ext) - { - /* No, you can't just use glXGetClientString or - * glXGetServerString() here. Those each tell you about one half - * of what's needed for an extension to be supported, and - * glXQueryExtensionsString() is what gives you the intersection - * of the two. - */ - return epoxy_extension_in_string(glXQueryExtensionsString(dpy, screen), ext); -} - void * epoxy_egl_dlsym(const char *name) { diff --git a/src/dispatch_common.h b/src/dispatch_common.h index c7b6944..127845a 100644 --- a/src/dispatch_common.h +++ b/src/dispatch_common.h @@ -64,5 +64,7 @@ void epoxy_print_failure_reasons(const char *name, const char **provider_names, const int *providers); +bool epoxy_extension_in_string(const char *extension_list, const char *ext); + void epoxy_glBegin_unwrapped(GLenum primtype); void epoxy_glEnd_unwrapped(void); diff --git a/src/dispatch_egl.c b/src/dispatch_egl.c new file mode 100644 index 0000000..09eae00 --- /dev/null +++ b/src/dispatch_egl.c @@ -0,0 +1,69 @@ +/* + * Copyright © 2013 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#include +#include +#include + +#include "dispatch_common.h" + +PUBLIC int +epoxy_conservative_egl_version(void) +{ + EGLDisplay *dpy = eglGetCurrentDisplay(); + + if (!dpy) + return 14; + + return epoxy_egl_version(dpy); +} + +PUBLIC int +epoxy_egl_version(EGLDisplay *dpy) +{ + int major, minor; + const char *version_string; + int ret; + + version_string = eglQueryString(dpy, EGL_VERSION); + ret = sscanf(version_string, "%d.%d", &major, &minor); + assert(ret == 2); + return major * 10 + minor; +} + +bool +epoxy_conservative_has_egl_extension(const char *ext) +{ + EGLDisplay *dpy = eglGetCurrentDisplay(); + + if (!dpy) + return true; + + return epoxy_has_egl_extension(dpy, ext); +} + +PUBLIC bool +epoxy_has_egl_extension(EGLDisplay *dpy, const char *ext) +{ + return epoxy_extension_in_string(eglQueryString(dpy, EGL_EXTENSIONS), ext); +} diff --git a/src/dispatch_glx.c b/src/dispatch_glx.c new file mode 100644 index 0000000..78e61c2 --- /dev/null +++ b/src/dispatch_glx.c @@ -0,0 +1,105 @@ +/* + * Copyright © 2013 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#include +#include +#include + +#include "dispatch_common.h" + +/** + * If we can determine the GLX version from the current context, then + * return that, otherwise return a version that will just send us on + * to dlsym() or get_proc_address(). + */ +int +epoxy_conservative_glx_version(void) +{ + Display *dpy = glXGetCurrentDisplay(); + GLXContext ctx = glXGetCurrentContext(); + int screen; + + if (!dpy || !ctx) + return 14; + + glXQueryContext(dpy, ctx, GLX_SCREEN, &screen); + + return epoxy_glx_version(dpy, screen); +} + +PUBLIC int +epoxy_glx_version(Display *dpy, int screen) +{ + int server_major, server_minor; + int client_major, client_minor; + int server, client; + const char *version_string; + int ret; + + version_string = glXQueryServerString(dpy, screen, GLX_VERSION); + ret = sscanf(version_string, "%d.%d", &server_major, &server_minor); + assert(ret == 2); + server = server_major * 10 + server_minor; + + version_string = glXGetClientString(dpy, GLX_VERSION); + ret = sscanf(version_string, "%d.%d", &client_major, &client_minor); + assert(ret == 2); + client = client_major * 10 + client_minor; + + if (client < server) + return client; + else + return server; +} + +/** + * If we can determine the GLX extension support from the current + * context, then return that, otherwise give the answer that will just + * send us on to get_proc_address(). + */ +bool +epoxy_conservative_has_glx_extension(const char *ext) +{ + Display *dpy = glXGetCurrentDisplay(); + GLXContext ctx = glXGetCurrentContext(); + int screen; + + if (!dpy || !ctx) + return true; + + glXQueryContext(dpy, ctx, GLX_SCREEN, &screen); + + return epoxy_has_glx_extension(dpy, screen, ext); +} + +PUBLIC bool +epoxy_has_glx_extension(Display *dpy, int screen, const char *ext) + { + /* No, you can't just use glXGetClientString or + * glXGetServerString() here. Those each tell you about one half + * of what's needed for an extension to be supported, and + * glXQueryExtensionsString() is what gives you the intersection + * of the two. + */ + return epoxy_extension_in_string(glXQueryExtensionsString(dpy, screen), ext); +}