diff options
Diffstat (limited to 'plugins/gtkui/gtkglext-gtk2/gdk/win32/gdkglwglext.c')
| -rw-r--r-- | plugins/gtkui/gtkglext-gtk2/gdk/win32/gdkglwglext.c | 2186 |
1 files changed, 2186 insertions, 0 deletions
diff --git a/plugins/gtkui/gtkglext-gtk2/gdk/win32/gdkglwglext.c b/plugins/gtkui/gtkglext-gtk2/gdk/win32/gdkglwglext.c new file mode 100644 index 00000000..757857f9 --- /dev/null +++ b/plugins/gtkui/gtkglext-gtk2/gdk/win32/gdkglwglext.c @@ -0,0 +1,2186 @@ +/* GdkGLExt - OpenGL Extension to GDK + * Copyright (C) 2002-2004 Naofumi Yasufuku + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. + */ + +/* + * This is a generated file. Please modify "gen-gdkglwglext-c.pl". + */ + +#include "gdkglwin32.h" +#include "gdkglprivate-win32.h" +#include "gdkglwglext.h" + +/* + * WGL_ARB_buffer_region + */ + +static GdkGL_WGL_ARB_buffer_region _procs_WGL_ARB_buffer_region = { + (GdkGLProc_wglCreateBufferRegionARB) -1, + (GdkGLProc_wglDeleteBufferRegionARB) -1, + (GdkGLProc_wglSaveBufferRegionARB) -1, + (GdkGLProc_wglRestoreBufferRegionARB) -1 +}; + +/* wglCreateBufferRegionARB */ +GdkGLProc +gdk_gl_get_wglCreateBufferRegionARB (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_ARB_buffer_region.wglCreateBufferRegionARB == (GdkGLProc_wglCreateBufferRegionARB) -1) + _procs_WGL_ARB_buffer_region.wglCreateBufferRegionARB = + (GdkGLProc_wglCreateBufferRegionARB) gdk_gl_get_proc_address ("wglCreateBufferRegionARB"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglCreateBufferRegionARB () - %s", + (_procs_WGL_ARB_buffer_region.wglCreateBufferRegionARB) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_ARB_buffer_region.wglCreateBufferRegionARB); +} + +/* wglDeleteBufferRegionARB */ +GdkGLProc +gdk_gl_get_wglDeleteBufferRegionARB (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_ARB_buffer_region.wglDeleteBufferRegionARB == (GdkGLProc_wglDeleteBufferRegionARB) -1) + _procs_WGL_ARB_buffer_region.wglDeleteBufferRegionARB = + (GdkGLProc_wglDeleteBufferRegionARB) gdk_gl_get_proc_address ("wglDeleteBufferRegionARB"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglDeleteBufferRegionARB () - %s", + (_procs_WGL_ARB_buffer_region.wglDeleteBufferRegionARB) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_ARB_buffer_region.wglDeleteBufferRegionARB); +} + +/* wglSaveBufferRegionARB */ +GdkGLProc +gdk_gl_get_wglSaveBufferRegionARB (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_ARB_buffer_region.wglSaveBufferRegionARB == (GdkGLProc_wglSaveBufferRegionARB) -1) + _procs_WGL_ARB_buffer_region.wglSaveBufferRegionARB = + (GdkGLProc_wglSaveBufferRegionARB) gdk_gl_get_proc_address ("wglSaveBufferRegionARB"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglSaveBufferRegionARB () - %s", + (_procs_WGL_ARB_buffer_region.wglSaveBufferRegionARB) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_ARB_buffer_region.wglSaveBufferRegionARB); +} + +/* wglRestoreBufferRegionARB */ +GdkGLProc +gdk_gl_get_wglRestoreBufferRegionARB (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_ARB_buffer_region.wglRestoreBufferRegionARB == (GdkGLProc_wglRestoreBufferRegionARB) -1) + _procs_WGL_ARB_buffer_region.wglRestoreBufferRegionARB = + (GdkGLProc_wglRestoreBufferRegionARB) gdk_gl_get_proc_address ("wglRestoreBufferRegionARB"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglRestoreBufferRegionARB () - %s", + (_procs_WGL_ARB_buffer_region.wglRestoreBufferRegionARB) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_ARB_buffer_region.wglRestoreBufferRegionARB); +} + +/* Get WGL_ARB_buffer_region functions */ +GdkGL_WGL_ARB_buffer_region * +gdk_gl_get_WGL_ARB_buffer_region (GdkGLConfig *glconfig) +{ + static gint supported = -1; + + if (wglGetCurrentContext () == NULL) + return NULL; + + if (supported == -1) + { + supported = gdk_win32_gl_query_wgl_extension (glconfig, "WGL_ARB_buffer_region"); + + if (supported) + { + supported &= (gdk_gl_get_wglCreateBufferRegionARB () != NULL); + supported &= (gdk_gl_get_wglDeleteBufferRegionARB () != NULL); + supported &= (gdk_gl_get_wglSaveBufferRegionARB () != NULL); + supported &= (gdk_gl_get_wglRestoreBufferRegionARB () != NULL); + } + } + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_WGL_ARB_buffer_region () - %s", + (supported) ? "supported" : "not supported")); + + if (!supported) + return NULL; + + return &_procs_WGL_ARB_buffer_region; +} + +/* + * WGL_ARB_extensions_string + */ + +static GdkGL_WGL_ARB_extensions_string _procs_WGL_ARB_extensions_string = { + (GdkGLProc_wglGetExtensionsStringARB) -1 +}; + +/* wglGetExtensionsStringARB */ +GdkGLProc +gdk_gl_get_wglGetExtensionsStringARB (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_ARB_extensions_string.wglGetExtensionsStringARB == (GdkGLProc_wglGetExtensionsStringARB) -1) + _procs_WGL_ARB_extensions_string.wglGetExtensionsStringARB = + (GdkGLProc_wglGetExtensionsStringARB) gdk_gl_get_proc_address ("wglGetExtensionsStringARB"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetExtensionsStringARB () - %s", + (_procs_WGL_ARB_extensions_string.wglGetExtensionsStringARB) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_ARB_extensions_string.wglGetExtensionsStringARB); +} + +/* Get WGL_ARB_extensions_string functions */ +GdkGL_WGL_ARB_extensions_string * +gdk_gl_get_WGL_ARB_extensions_string (GdkGLConfig *glconfig) +{ + static gint supported = -1; + + if (wglGetCurrentContext () == NULL) + return NULL; + + if (supported == -1) + { + supported = gdk_win32_gl_query_wgl_extension (glconfig, "WGL_ARB_extensions_string"); + + if (supported) + { + supported &= (gdk_gl_get_wglGetExtensionsStringARB () != NULL); + } + } + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_WGL_ARB_extensions_string () - %s", + (supported) ? "supported" : "not supported")); + + if (!supported) + return NULL; + + return &_procs_WGL_ARB_extensions_string; +} + +/* + * WGL_ARB_pixel_format + */ + +static GdkGL_WGL_ARB_pixel_format _procs_WGL_ARB_pixel_format = { + (GdkGLProc_wglGetPixelFormatAttribivARB) -1, + (GdkGLProc_wglGetPixelFormatAttribfvARB) -1, + (GdkGLProc_wglChoosePixelFormatARB) -1 +}; + +/* wglGetPixelFormatAttribivARB */ +GdkGLProc +gdk_gl_get_wglGetPixelFormatAttribivARB (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_ARB_pixel_format.wglGetPixelFormatAttribivARB == (GdkGLProc_wglGetPixelFormatAttribivARB) -1) + _procs_WGL_ARB_pixel_format.wglGetPixelFormatAttribivARB = + (GdkGLProc_wglGetPixelFormatAttribivARB) gdk_gl_get_proc_address ("wglGetPixelFormatAttribivARB"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetPixelFormatAttribivARB () - %s", + (_procs_WGL_ARB_pixel_format.wglGetPixelFormatAttribivARB) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_ARB_pixel_format.wglGetPixelFormatAttribivARB); +} + +/* wglGetPixelFormatAttribfvARB */ +GdkGLProc +gdk_gl_get_wglGetPixelFormatAttribfvARB (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_ARB_pixel_format.wglGetPixelFormatAttribfvARB == (GdkGLProc_wglGetPixelFormatAttribfvARB) -1) + _procs_WGL_ARB_pixel_format.wglGetPixelFormatAttribfvARB = + (GdkGLProc_wglGetPixelFormatAttribfvARB) gdk_gl_get_proc_address ("wglGetPixelFormatAttribfvARB"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetPixelFormatAttribfvARB () - %s", + (_procs_WGL_ARB_pixel_format.wglGetPixelFormatAttribfvARB) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_ARB_pixel_format.wglGetPixelFormatAttribfvARB); +} + +/* wglChoosePixelFormatARB */ +GdkGLProc +gdk_gl_get_wglChoosePixelFormatARB (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_ARB_pixel_format.wglChoosePixelFormatARB == (GdkGLProc_wglChoosePixelFormatARB) -1) + _procs_WGL_ARB_pixel_format.wglChoosePixelFormatARB = + (GdkGLProc_wglChoosePixelFormatARB) gdk_gl_get_proc_address ("wglChoosePixelFormatARB"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglChoosePixelFormatARB () - %s", + (_procs_WGL_ARB_pixel_format.wglChoosePixelFormatARB) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_ARB_pixel_format.wglChoosePixelFormatARB); +} + +/* Get WGL_ARB_pixel_format functions */ +GdkGL_WGL_ARB_pixel_format * +gdk_gl_get_WGL_ARB_pixel_format (GdkGLConfig *glconfig) +{ + static gint supported = -1; + + if (wglGetCurrentContext () == NULL) + return NULL; + + if (supported == -1) + { + supported = gdk_win32_gl_query_wgl_extension (glconfig, "WGL_ARB_pixel_format"); + + if (supported) + { + supported &= (gdk_gl_get_wglGetPixelFormatAttribivARB () != NULL); + supported &= (gdk_gl_get_wglGetPixelFormatAttribfvARB () != NULL); + supported &= (gdk_gl_get_wglChoosePixelFormatARB () != NULL); + } + } + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_WGL_ARB_pixel_format () - %s", + (supported) ? "supported" : "not supported")); + + if (!supported) + return NULL; + + return &_procs_WGL_ARB_pixel_format; +} + +/* + * WGL_ARB_make_current_read + */ + +static GdkGL_WGL_ARB_make_current_read _procs_WGL_ARB_make_current_read = { + (GdkGLProc_wglMakeContextCurrentARB) -1, + (GdkGLProc_wglGetCurrentReadDCARB) -1 +}; + +/* wglMakeContextCurrentARB */ +GdkGLProc +gdk_gl_get_wglMakeContextCurrentARB (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_ARB_make_current_read.wglMakeContextCurrentARB == (GdkGLProc_wglMakeContextCurrentARB) -1) + _procs_WGL_ARB_make_current_read.wglMakeContextCurrentARB = + (GdkGLProc_wglMakeContextCurrentARB) gdk_gl_get_proc_address ("wglMakeContextCurrentARB"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglMakeContextCurrentARB () - %s", + (_procs_WGL_ARB_make_current_read.wglMakeContextCurrentARB) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_ARB_make_current_read.wglMakeContextCurrentARB); +} + +/* wglGetCurrentReadDCARB */ +GdkGLProc +gdk_gl_get_wglGetCurrentReadDCARB (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_ARB_make_current_read.wglGetCurrentReadDCARB == (GdkGLProc_wglGetCurrentReadDCARB) -1) + _procs_WGL_ARB_make_current_read.wglGetCurrentReadDCARB = + (GdkGLProc_wglGetCurrentReadDCARB) gdk_gl_get_proc_address ("wglGetCurrentReadDCARB"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetCurrentReadDCARB () - %s", + (_procs_WGL_ARB_make_current_read.wglGetCurrentReadDCARB) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_ARB_make_current_read.wglGetCurrentReadDCARB); +} + +/* Get WGL_ARB_make_current_read functions */ +GdkGL_WGL_ARB_make_current_read * +gdk_gl_get_WGL_ARB_make_current_read (GdkGLConfig *glconfig) +{ + static gint supported = -1; + + if (wglGetCurrentContext () == NULL) + return NULL; + + if (supported == -1) + { + supported = gdk_win32_gl_query_wgl_extension (glconfig, "WGL_ARB_make_current_read"); + + if (supported) + { + supported &= (gdk_gl_get_wglMakeContextCurrentARB () != NULL); + supported &= (gdk_gl_get_wglGetCurrentReadDCARB () != NULL); + } + } + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_WGL_ARB_make_current_read () - %s", + (supported) ? "supported" : "not supported")); + + if (!supported) + return NULL; + + return &_procs_WGL_ARB_make_current_read; +} + +/* + * WGL_ARB_pbuffer + */ + +static GdkGL_WGL_ARB_pbuffer _procs_WGL_ARB_pbuffer = { + (GdkGLProc_wglCreatePbufferARB) -1, + (GdkGLProc_wglGetPbufferDCARB) -1, + (GdkGLProc_wglReleasePbufferDCARB) -1, + (GdkGLProc_wglDestroyPbufferARB) -1, + (GdkGLProc_wglQueryPbufferARB) -1 +}; + +/* wglCreatePbufferARB */ +GdkGLProc +gdk_gl_get_wglCreatePbufferARB (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_ARB_pbuffer.wglCreatePbufferARB == (GdkGLProc_wglCreatePbufferARB) -1) + _procs_WGL_ARB_pbuffer.wglCreatePbufferARB = + (GdkGLProc_wglCreatePbufferARB) gdk_gl_get_proc_address ("wglCreatePbufferARB"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglCreatePbufferARB () - %s", + (_procs_WGL_ARB_pbuffer.wglCreatePbufferARB) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_ARB_pbuffer.wglCreatePbufferARB); +} + +/* wglGetPbufferDCARB */ +GdkGLProc +gdk_gl_get_wglGetPbufferDCARB (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_ARB_pbuffer.wglGetPbufferDCARB == (GdkGLProc_wglGetPbufferDCARB) -1) + _procs_WGL_ARB_pbuffer.wglGetPbufferDCARB = + (GdkGLProc_wglGetPbufferDCARB) gdk_gl_get_proc_address ("wglGetPbufferDCARB"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetPbufferDCARB () - %s", + (_procs_WGL_ARB_pbuffer.wglGetPbufferDCARB) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_ARB_pbuffer.wglGetPbufferDCARB); +} + +/* wglReleasePbufferDCARB */ +GdkGLProc +gdk_gl_get_wglReleasePbufferDCARB (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_ARB_pbuffer.wglReleasePbufferDCARB == (GdkGLProc_wglReleasePbufferDCARB) -1) + _procs_WGL_ARB_pbuffer.wglReleasePbufferDCARB = + (GdkGLProc_wglReleasePbufferDCARB) gdk_gl_get_proc_address ("wglReleasePbufferDCARB"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglReleasePbufferDCARB () - %s", + (_procs_WGL_ARB_pbuffer.wglReleasePbufferDCARB) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_ARB_pbuffer.wglReleasePbufferDCARB); +} + +/* wglDestroyPbufferARB */ +GdkGLProc +gdk_gl_get_wglDestroyPbufferARB (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_ARB_pbuffer.wglDestroyPbufferARB == (GdkGLProc_wglDestroyPbufferARB) -1) + _procs_WGL_ARB_pbuffer.wglDestroyPbufferARB = + (GdkGLProc_wglDestroyPbufferARB) gdk_gl_get_proc_address ("wglDestroyPbufferARB"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglDestroyPbufferARB () - %s", + (_procs_WGL_ARB_pbuffer.wglDestroyPbufferARB) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_ARB_pbuffer.wglDestroyPbufferARB); +} + +/* wglQueryPbufferARB */ +GdkGLProc +gdk_gl_get_wglQueryPbufferARB (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_ARB_pbuffer.wglQueryPbufferARB == (GdkGLProc_wglQueryPbufferARB) -1) + _procs_WGL_ARB_pbuffer.wglQueryPbufferARB = + (GdkGLProc_wglQueryPbufferARB) gdk_gl_get_proc_address ("wglQueryPbufferARB"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglQueryPbufferARB () - %s", + (_procs_WGL_ARB_pbuffer.wglQueryPbufferARB) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_ARB_pbuffer.wglQueryPbufferARB); +} + +/* Get WGL_ARB_pbuffer functions */ +GdkGL_WGL_ARB_pbuffer * +gdk_gl_get_WGL_ARB_pbuffer (GdkGLConfig *glconfig) +{ + static gint supported = -1; + + if (wglGetCurrentContext () == NULL) + return NULL; + + if (supported == -1) + { + supported = gdk_win32_gl_query_wgl_extension (glconfig, "WGL_ARB_pbuffer"); + + if (supported) + { + supported &= (gdk_gl_get_wglCreatePbufferARB () != NULL); + supported &= (gdk_gl_get_wglGetPbufferDCARB () != NULL); + supported &= (gdk_gl_get_wglReleasePbufferDCARB () != NULL); + supported &= (gdk_gl_get_wglDestroyPbufferARB () != NULL); + supported &= (gdk_gl_get_wglQueryPbufferARB () != NULL); + } + } + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_WGL_ARB_pbuffer () - %s", + (supported) ? "supported" : "not supported")); + + if (!supported) + return NULL; + + return &_procs_WGL_ARB_pbuffer; +} + +/* + * WGL_ARB_render_texture + */ + +static GdkGL_WGL_ARB_render_texture _procs_WGL_ARB_render_texture = { + (GdkGLProc_wglBindTexImageARB) -1, + (GdkGLProc_wglReleaseTexImageARB) -1, + (GdkGLProc_wglSetPbufferAttribARB) -1 +}; + +/* wglBindTexImageARB */ +GdkGLProc +gdk_gl_get_wglBindTexImageARB (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_ARB_render_texture.wglBindTexImageARB == (GdkGLProc_wglBindTexImageARB) -1) + _procs_WGL_ARB_render_texture.wglBindTexImageARB = + (GdkGLProc_wglBindTexImageARB) gdk_gl_get_proc_address ("wglBindTexImageARB"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglBindTexImageARB () - %s", + (_procs_WGL_ARB_render_texture.wglBindTexImageARB) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_ARB_render_texture.wglBindTexImageARB); +} + +/* wglReleaseTexImageARB */ +GdkGLProc +gdk_gl_get_wglReleaseTexImageARB (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_ARB_render_texture.wglReleaseTexImageARB == (GdkGLProc_wglReleaseTexImageARB) -1) + _procs_WGL_ARB_render_texture.wglReleaseTexImageARB = + (GdkGLProc_wglReleaseTexImageARB) gdk_gl_get_proc_address ("wglReleaseTexImageARB"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglReleaseTexImageARB () - %s", + (_procs_WGL_ARB_render_texture.wglReleaseTexImageARB) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_ARB_render_texture.wglReleaseTexImageARB); +} + +/* wglSetPbufferAttribARB */ +GdkGLProc +gdk_gl_get_wglSetPbufferAttribARB (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_ARB_render_texture.wglSetPbufferAttribARB == (GdkGLProc_wglSetPbufferAttribARB) -1) + _procs_WGL_ARB_render_texture.wglSetPbufferAttribARB = + (GdkGLProc_wglSetPbufferAttribARB) gdk_gl_get_proc_address ("wglSetPbufferAttribARB"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglSetPbufferAttribARB () - %s", + (_procs_WGL_ARB_render_texture.wglSetPbufferAttribARB) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_ARB_render_texture.wglSetPbufferAttribARB); +} + +/* Get WGL_ARB_render_texture functions */ +GdkGL_WGL_ARB_render_texture * +gdk_gl_get_WGL_ARB_render_texture (GdkGLConfig *glconfig) +{ + static gint supported = -1; + + if (wglGetCurrentContext () == NULL) + return NULL; + + if (supported == -1) + { + supported = gdk_win32_gl_query_wgl_extension (glconfig, "WGL_ARB_render_texture"); + + if (supported) + { + supported &= (gdk_gl_get_wglBindTexImageARB () != NULL); + supported &= (gdk_gl_get_wglReleaseTexImageARB () != NULL); + supported &= (gdk_gl_get_wglSetPbufferAttribARB () != NULL); + } + } + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_WGL_ARB_render_texture () - %s", + (supported) ? "supported" : "not supported")); + + if (!supported) + return NULL; + + return &_procs_WGL_ARB_render_texture; +} + +/* + * WGL_EXT_display_color_table + */ + +static GdkGL_WGL_EXT_display_color_table _procs_WGL_EXT_display_color_table = { + (GdkGLProc_wglCreateDisplayColorTableEXT) -1, + (GdkGLProc_wglLoadDisplayColorTableEXT) -1, + (GdkGLProc_wglBindDisplayColorTableEXT) -1, + (GdkGLProc_wglDestroyDisplayColorTableEXT) -1 +}; + +/* wglCreateDisplayColorTableEXT */ +GdkGLProc +gdk_gl_get_wglCreateDisplayColorTableEXT (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_EXT_display_color_table.wglCreateDisplayColorTableEXT == (GdkGLProc_wglCreateDisplayColorTableEXT) -1) + _procs_WGL_EXT_display_color_table.wglCreateDisplayColorTableEXT = + (GdkGLProc_wglCreateDisplayColorTableEXT) gdk_gl_get_proc_address ("wglCreateDisplayColorTableEXT"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglCreateDisplayColorTableEXT () - %s", + (_procs_WGL_EXT_display_color_table.wglCreateDisplayColorTableEXT) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_EXT_display_color_table.wglCreateDisplayColorTableEXT); +} + +/* wglLoadDisplayColorTableEXT */ +GdkGLProc +gdk_gl_get_wglLoadDisplayColorTableEXT (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_EXT_display_color_table.wglLoadDisplayColorTableEXT == (GdkGLProc_wglLoadDisplayColorTableEXT) -1) + _procs_WGL_EXT_display_color_table.wglLoadDisplayColorTableEXT = + (GdkGLProc_wglLoadDisplayColorTableEXT) gdk_gl_get_proc_address ("wglLoadDisplayColorTableEXT"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglLoadDisplayColorTableEXT () - %s", + (_procs_WGL_EXT_display_color_table.wglLoadDisplayColorTableEXT) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_EXT_display_color_table.wglLoadDisplayColorTableEXT); +} + +/* wglBindDisplayColorTableEXT */ +GdkGLProc +gdk_gl_get_wglBindDisplayColorTableEXT (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_EXT_display_color_table.wglBindDisplayColorTableEXT == (GdkGLProc_wglBindDisplayColorTableEXT) -1) + _procs_WGL_EXT_display_color_table.wglBindDisplayColorTableEXT = + (GdkGLProc_wglBindDisplayColorTableEXT) gdk_gl_get_proc_address ("wglBindDisplayColorTableEXT"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglBindDisplayColorTableEXT () - %s", + (_procs_WGL_EXT_display_color_table.wglBindDisplayColorTableEXT) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_EXT_display_color_table.wglBindDisplayColorTableEXT); +} + +/* wglDestroyDisplayColorTableEXT */ +GdkGLProc +gdk_gl_get_wglDestroyDisplayColorTableEXT (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_EXT_display_color_table.wglDestroyDisplayColorTableEXT == (GdkGLProc_wglDestroyDisplayColorTableEXT) -1) + _procs_WGL_EXT_display_color_table.wglDestroyDisplayColorTableEXT = + (GdkGLProc_wglDestroyDisplayColorTableEXT) gdk_gl_get_proc_address ("wglDestroyDisplayColorTableEXT"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglDestroyDisplayColorTableEXT () - %s", + (_procs_WGL_EXT_display_color_table.wglDestroyDisplayColorTableEXT) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_EXT_display_color_table.wglDestroyDisplayColorTableEXT); +} + +/* Get WGL_EXT_display_color_table functions */ +GdkGL_WGL_EXT_display_color_table * +gdk_gl_get_WGL_EXT_display_color_table (GdkGLConfig *glconfig) +{ + static gint supported = -1; + + if (wglGetCurrentContext () == NULL) + return NULL; + + if (supported == -1) + { + supported = gdk_win32_gl_query_wgl_extension (glconfig, "WGL_EXT_display_color_table"); + + if (supported) + { + supported &= (gdk_gl_get_wglCreateDisplayColorTableEXT () != NULL); + supported &= (gdk_gl_get_wglLoadDisplayColorTableEXT () != NULL); + supported &= (gdk_gl_get_wglBindDisplayColorTableEXT () != NULL); + supported &= (gdk_gl_get_wglDestroyDisplayColorTableEXT () != NULL); + } + } + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_WGL_EXT_display_color_table () - %s", + (supported) ? "supported" : "not supported")); + + if (!supported) + return NULL; + + return &_procs_WGL_EXT_display_color_table; +} + +/* + * WGL_EXT_extensions_string + */ + +static GdkGL_WGL_EXT_extensions_string _procs_WGL_EXT_extensions_string = { + (GdkGLProc_wglGetExtensionsStringEXT) -1 +}; + +/* wglGetExtensionsStringEXT */ +GdkGLProc +gdk_gl_get_wglGetExtensionsStringEXT (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_EXT_extensions_string.wglGetExtensionsStringEXT == (GdkGLProc_wglGetExtensionsStringEXT) -1) + _procs_WGL_EXT_extensions_string.wglGetExtensionsStringEXT = + (GdkGLProc_wglGetExtensionsStringEXT) gdk_gl_get_proc_address ("wglGetExtensionsStringEXT"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetExtensionsStringEXT () - %s", + (_procs_WGL_EXT_extensions_string.wglGetExtensionsStringEXT) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_EXT_extensions_string.wglGetExtensionsStringEXT); +} + +/* Get WGL_EXT_extensions_string functions */ +GdkGL_WGL_EXT_extensions_string * +gdk_gl_get_WGL_EXT_extensions_string (GdkGLConfig *glconfig) +{ + static gint supported = -1; + + if (wglGetCurrentContext () == NULL) + return NULL; + + if (supported == -1) + { + supported = gdk_win32_gl_query_wgl_extension (glconfig, "WGL_EXT_extensions_string"); + + if (supported) + { + supported &= (gdk_gl_get_wglGetExtensionsStringEXT () != NULL); + } + } + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_WGL_EXT_extensions_string () - %s", + (supported) ? "supported" : "not supported")); + + if (!supported) + return NULL; + + return &_procs_WGL_EXT_extensions_string; +} + +/* + * WGL_EXT_make_current_read + */ + +static GdkGL_WGL_EXT_make_current_read _procs_WGL_EXT_make_current_read = { + (GdkGLProc_wglMakeContextCurrentEXT) -1, + (GdkGLProc_wglGetCurrentReadDCEXT) -1 +}; + +/* wglMakeContextCurrentEXT */ +GdkGLProc +gdk_gl_get_wglMakeContextCurrentEXT (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_EXT_make_current_read.wglMakeContextCurrentEXT == (GdkGLProc_wglMakeContextCurrentEXT) -1) + _procs_WGL_EXT_make_current_read.wglMakeContextCurrentEXT = + (GdkGLProc_wglMakeContextCurrentEXT) gdk_gl_get_proc_address ("wglMakeContextCurrentEXT"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglMakeContextCurrentEXT () - %s", + (_procs_WGL_EXT_make_current_read.wglMakeContextCurrentEXT) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_EXT_make_current_read.wglMakeContextCurrentEXT); +} + +/* wglGetCurrentReadDCEXT */ +GdkGLProc +gdk_gl_get_wglGetCurrentReadDCEXT (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_EXT_make_current_read.wglGetCurrentReadDCEXT == (GdkGLProc_wglGetCurrentReadDCEXT) -1) + _procs_WGL_EXT_make_current_read.wglGetCurrentReadDCEXT = + (GdkGLProc_wglGetCurrentReadDCEXT) gdk_gl_get_proc_address ("wglGetCurrentReadDCEXT"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetCurrentReadDCEXT () - %s", + (_procs_WGL_EXT_make_current_read.wglGetCurrentReadDCEXT) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_EXT_make_current_read.wglGetCurrentReadDCEXT); +} + +/* Get WGL_EXT_make_current_read functions */ +GdkGL_WGL_EXT_make_current_read * +gdk_gl_get_WGL_EXT_make_current_read (GdkGLConfig *glconfig) +{ + static gint supported = -1; + + if (wglGetCurrentContext () == NULL) + return NULL; + + if (supported == -1) + { + supported = gdk_win32_gl_query_wgl_extension (glconfig, "WGL_EXT_make_current_read"); + + if (supported) + { + supported &= (gdk_gl_get_wglMakeContextCurrentEXT () != NULL); + supported &= (gdk_gl_get_wglGetCurrentReadDCEXT () != NULL); + } + } + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_WGL_EXT_make_current_read () - %s", + (supported) ? "supported" : "not supported")); + + if (!supported) + return NULL; + + return &_procs_WGL_EXT_make_current_read; +} + +/* + * WGL_EXT_pbuffer + */ + +static GdkGL_WGL_EXT_pbuffer _procs_WGL_EXT_pbuffer = { + (GdkGLProc_wglCreatePbufferEXT) -1, + (GdkGLProc_wglGetPbufferDCEXT) -1, + (GdkGLProc_wglReleasePbufferDCEXT) -1, + (GdkGLProc_wglDestroyPbufferEXT) -1, + (GdkGLProc_wglQueryPbufferEXT) -1 +}; + +/* wglCreatePbufferEXT */ +GdkGLProc +gdk_gl_get_wglCreatePbufferEXT (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_EXT_pbuffer.wglCreatePbufferEXT == (GdkGLProc_wglCreatePbufferEXT) -1) + _procs_WGL_EXT_pbuffer.wglCreatePbufferEXT = + (GdkGLProc_wglCreatePbufferEXT) gdk_gl_get_proc_address ("wglCreatePbufferEXT"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglCreatePbufferEXT () - %s", + (_procs_WGL_EXT_pbuffer.wglCreatePbufferEXT) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_EXT_pbuffer.wglCreatePbufferEXT); +} + +/* wglGetPbufferDCEXT */ +GdkGLProc +gdk_gl_get_wglGetPbufferDCEXT (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_EXT_pbuffer.wglGetPbufferDCEXT == (GdkGLProc_wglGetPbufferDCEXT) -1) + _procs_WGL_EXT_pbuffer.wglGetPbufferDCEXT = + (GdkGLProc_wglGetPbufferDCEXT) gdk_gl_get_proc_address ("wglGetPbufferDCEXT"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetPbufferDCEXT () - %s", + (_procs_WGL_EXT_pbuffer.wglGetPbufferDCEXT) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_EXT_pbuffer.wglGetPbufferDCEXT); +} + +/* wglReleasePbufferDCEXT */ +GdkGLProc +gdk_gl_get_wglReleasePbufferDCEXT (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_EXT_pbuffer.wglReleasePbufferDCEXT == (GdkGLProc_wglReleasePbufferDCEXT) -1) + _procs_WGL_EXT_pbuffer.wglReleasePbufferDCEXT = + (GdkGLProc_wglReleasePbufferDCEXT) gdk_gl_get_proc_address ("wglReleasePbufferDCEXT"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglReleasePbufferDCEXT () - %s", + (_procs_WGL_EXT_pbuffer.wglReleasePbufferDCEXT) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_EXT_pbuffer.wglReleasePbufferDCEXT); +} + +/* wglDestroyPbufferEXT */ +GdkGLProc +gdk_gl_get_wglDestroyPbufferEXT (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_EXT_pbuffer.wglDestroyPbufferEXT == (GdkGLProc_wglDestroyPbufferEXT) -1) + _procs_WGL_EXT_pbuffer.wglDestroyPbufferEXT = + (GdkGLProc_wglDestroyPbufferEXT) gdk_gl_get_proc_address ("wglDestroyPbufferEXT"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglDestroyPbufferEXT () - %s", + (_procs_WGL_EXT_pbuffer.wglDestroyPbufferEXT) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_EXT_pbuffer.wglDestroyPbufferEXT); +} + +/* wglQueryPbufferEXT */ +GdkGLProc +gdk_gl_get_wglQueryPbufferEXT (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_EXT_pbuffer.wglQueryPbufferEXT == (GdkGLProc_wglQueryPbufferEXT) -1) + _procs_WGL_EXT_pbuffer.wglQueryPbufferEXT = + (GdkGLProc_wglQueryPbufferEXT) gdk_gl_get_proc_address ("wglQueryPbufferEXT"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglQueryPbufferEXT () - %s", + (_procs_WGL_EXT_pbuffer.wglQueryPbufferEXT) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_EXT_pbuffer.wglQueryPbufferEXT); +} + +/* Get WGL_EXT_pbuffer functions */ +GdkGL_WGL_EXT_pbuffer * +gdk_gl_get_WGL_EXT_pbuffer (GdkGLConfig *glconfig) +{ + static gint supported = -1; + + if (wglGetCurrentContext () == NULL) + return NULL; + + if (supported == -1) + { + supported = gdk_win32_gl_query_wgl_extension (glconfig, "WGL_EXT_pbuffer"); + + if (supported) + { + supported &= (gdk_gl_get_wglCreatePbufferEXT () != NULL); + supported &= (gdk_gl_get_wglGetPbufferDCEXT () != NULL); + supported &= (gdk_gl_get_wglReleasePbufferDCEXT () != NULL); + supported &= (gdk_gl_get_wglDestroyPbufferEXT () != NULL); + supported &= (gdk_gl_get_wglQueryPbufferEXT () != NULL); + } + } + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_WGL_EXT_pbuffer () - %s", + (supported) ? "supported" : "not supported")); + + if (!supported) + return NULL; + + return &_procs_WGL_EXT_pbuffer; +} + +/* + * WGL_EXT_pixel_format + */ + +static GdkGL_WGL_EXT_pixel_format _procs_WGL_EXT_pixel_format = { + (GdkGLProc_wglGetPixelFormatAttribivEXT) -1, + (GdkGLProc_wglGetPixelFormatAttribfvEXT) -1, + (GdkGLProc_wglChoosePixelFormatEXT) -1 +}; + +/* wglGetPixelFormatAttribivEXT */ +GdkGLProc +gdk_gl_get_wglGetPixelFormatAttribivEXT (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_EXT_pixel_format.wglGetPixelFormatAttribivEXT == (GdkGLProc_wglGetPixelFormatAttribivEXT) -1) + _procs_WGL_EXT_pixel_format.wglGetPixelFormatAttribivEXT = + (GdkGLProc_wglGetPixelFormatAttribivEXT) gdk_gl_get_proc_address ("wglGetPixelFormatAttribivEXT"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetPixelFormatAttribivEXT () - %s", + (_procs_WGL_EXT_pixel_format.wglGetPixelFormatAttribivEXT) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_EXT_pixel_format.wglGetPixelFormatAttribivEXT); +} + +/* wglGetPixelFormatAttribfvEXT */ +GdkGLProc +gdk_gl_get_wglGetPixelFormatAttribfvEXT (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_EXT_pixel_format.wglGetPixelFormatAttribfvEXT == (GdkGLProc_wglGetPixelFormatAttribfvEXT) -1) + _procs_WGL_EXT_pixel_format.wglGetPixelFormatAttribfvEXT = + (GdkGLProc_wglGetPixelFormatAttribfvEXT) gdk_gl_get_proc_address ("wglGetPixelFormatAttribfvEXT"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetPixelFormatAttribfvEXT () - %s", + (_procs_WGL_EXT_pixel_format.wglGetPixelFormatAttribfvEXT) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_EXT_pixel_format.wglGetPixelFormatAttribfvEXT); +} + +/* wglChoosePixelFormatEXT */ +GdkGLProc +gdk_gl_get_wglChoosePixelFormatEXT (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_EXT_pixel_format.wglChoosePixelFormatEXT == (GdkGLProc_wglChoosePixelFormatEXT) -1) + _procs_WGL_EXT_pixel_format.wglChoosePixelFormatEXT = + (GdkGLProc_wglChoosePixelFormatEXT) gdk_gl_get_proc_address ("wglChoosePixelFormatEXT"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglChoosePixelFormatEXT () - %s", + (_procs_WGL_EXT_pixel_format.wglChoosePixelFormatEXT) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_EXT_pixel_format.wglChoosePixelFormatEXT); +} + +/* Get WGL_EXT_pixel_format functions */ +GdkGL_WGL_EXT_pixel_format * +gdk_gl_get_WGL_EXT_pixel_format (GdkGLConfig *glconfig) +{ + static gint supported = -1; + + if (wglGetCurrentContext () == NULL) + return NULL; + + if (supported == -1) + { + supported = gdk_win32_gl_query_wgl_extension (glconfig, "WGL_EXT_pixel_format"); + + if (supported) + { + supported &= (gdk_gl_get_wglGetPixelFormatAttribivEXT () != NULL); + supported &= (gdk_gl_get_wglGetPixelFormatAttribfvEXT () != NULL); + supported &= (gdk_gl_get_wglChoosePixelFormatEXT () != NULL); + } + } + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_WGL_EXT_pixel_format () - %s", + (supported) ? "supported" : "not supported")); + + if (!supported) + return NULL; + + return &_procs_WGL_EXT_pixel_format; +} + +/* + * WGL_EXT_swap_control + */ + +static GdkGL_WGL_EXT_swap_control _procs_WGL_EXT_swap_control = { + (GdkGLProc_wglSwapIntervalEXT) -1, + (GdkGLProc_wglGetSwapIntervalEXT) -1 +}; + +/* wglSwapIntervalEXT */ +GdkGLProc +gdk_gl_get_wglSwapIntervalEXT (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_EXT_swap_control.wglSwapIntervalEXT == (GdkGLProc_wglSwapIntervalEXT) -1) + _procs_WGL_EXT_swap_control.wglSwapIntervalEXT = + (GdkGLProc_wglSwapIntervalEXT) gdk_gl_get_proc_address ("wglSwapIntervalEXT"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglSwapIntervalEXT () - %s", + (_procs_WGL_EXT_swap_control.wglSwapIntervalEXT) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_EXT_swap_control.wglSwapIntervalEXT); +} + +/* wglGetSwapIntervalEXT */ +GdkGLProc +gdk_gl_get_wglGetSwapIntervalEXT (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_EXT_swap_control.wglGetSwapIntervalEXT == (GdkGLProc_wglGetSwapIntervalEXT) -1) + _procs_WGL_EXT_swap_control.wglGetSwapIntervalEXT = + (GdkGLProc_wglGetSwapIntervalEXT) gdk_gl_get_proc_address ("wglGetSwapIntervalEXT"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetSwapIntervalEXT () - %s", + (_procs_WGL_EXT_swap_control.wglGetSwapIntervalEXT) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_EXT_swap_control.wglGetSwapIntervalEXT); +} + +/* Get WGL_EXT_swap_control functions */ +GdkGL_WGL_EXT_swap_control * +gdk_gl_get_WGL_EXT_swap_control (GdkGLConfig *glconfig) +{ + static gint supported = -1; + + if (wglGetCurrentContext () == NULL) + return NULL; + + if (supported == -1) + { + supported = gdk_win32_gl_query_wgl_extension (glconfig, "WGL_EXT_swap_control"); + + if (supported) + { + supported &= (gdk_gl_get_wglSwapIntervalEXT () != NULL); + supported &= (gdk_gl_get_wglGetSwapIntervalEXT () != NULL); + } + } + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_WGL_EXT_swap_control () - %s", + (supported) ? "supported" : "not supported")); + + if (!supported) + return NULL; + + return &_procs_WGL_EXT_swap_control; +} + +/* + * WGL_NV_vertex_array_range + */ + +static GdkGL_WGL_NV_vertex_array_range _procs_WGL_NV_vertex_array_range = { + (GdkGLProc_wglAllocateMemoryNV) -1, + (GdkGLProc_wglFreeMemoryNV) -1 +}; + +/* wglAllocateMemoryNV */ +GdkGLProc +gdk_gl_get_wglAllocateMemoryNV (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_NV_vertex_array_range.wglAllocateMemoryNV == (GdkGLProc_wglAllocateMemoryNV) -1) + _procs_WGL_NV_vertex_array_range.wglAllocateMemoryNV = + (GdkGLProc_wglAllocateMemoryNV) gdk_gl_get_proc_address ("wglAllocateMemoryNV"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglAllocateMemoryNV () - %s", + (_procs_WGL_NV_vertex_array_range.wglAllocateMemoryNV) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_NV_vertex_array_range.wglAllocateMemoryNV); +} + +/* wglFreeMemoryNV */ +GdkGLProc +gdk_gl_get_wglFreeMemoryNV (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_NV_vertex_array_range.wglFreeMemoryNV == (GdkGLProc_wglFreeMemoryNV) -1) + _procs_WGL_NV_vertex_array_range.wglFreeMemoryNV = + (GdkGLProc_wglFreeMemoryNV) gdk_gl_get_proc_address ("wglFreeMemoryNV"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglFreeMemoryNV () - %s", + (_procs_WGL_NV_vertex_array_range.wglFreeMemoryNV) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_NV_vertex_array_range.wglFreeMemoryNV); +} + +/* Get WGL_NV_vertex_array_range functions */ +GdkGL_WGL_NV_vertex_array_range * +gdk_gl_get_WGL_NV_vertex_array_range (GdkGLConfig *glconfig) +{ + static gint supported = -1; + + if (wglGetCurrentContext () == NULL) + return NULL; + + if (supported == -1) + { + supported = gdk_win32_gl_query_wgl_extension (glconfig, "WGL_NV_vertex_array_range"); + + if (supported) + { + supported &= (gdk_gl_get_wglAllocateMemoryNV () != NULL); + supported &= (gdk_gl_get_wglFreeMemoryNV () != NULL); + } + } + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_WGL_NV_vertex_array_range () - %s", + (supported) ? "supported" : "not supported")); + + if (!supported) + return NULL; + + return &_procs_WGL_NV_vertex_array_range; +} + +/* + * WGL_OML_sync_control + */ + +static GdkGL_WGL_OML_sync_control _procs_WGL_OML_sync_control = { + (GdkGLProc_wglGetSyncValuesOML) -1, + (GdkGLProc_wglGetMscRateOML) -1, + (GdkGLProc_wglSwapBuffersMscOML) -1, + (GdkGLProc_wglSwapLayerBuffersMscOML) -1, + (GdkGLProc_wglWaitForMscOML) -1, + (GdkGLProc_wglWaitForSbcOML) -1 +}; + +/* wglGetSyncValuesOML */ +GdkGLProc +gdk_gl_get_wglGetSyncValuesOML (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_OML_sync_control.wglGetSyncValuesOML == (GdkGLProc_wglGetSyncValuesOML) -1) + _procs_WGL_OML_sync_control.wglGetSyncValuesOML = + (GdkGLProc_wglGetSyncValuesOML) gdk_gl_get_proc_address ("wglGetSyncValuesOML"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetSyncValuesOML () - %s", + (_procs_WGL_OML_sync_control.wglGetSyncValuesOML) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_OML_sync_control.wglGetSyncValuesOML); +} + +/* wglGetMscRateOML */ +GdkGLProc +gdk_gl_get_wglGetMscRateOML (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_OML_sync_control.wglGetMscRateOML == (GdkGLProc_wglGetMscRateOML) -1) + _procs_WGL_OML_sync_control.wglGetMscRateOML = + (GdkGLProc_wglGetMscRateOML) gdk_gl_get_proc_address ("wglGetMscRateOML"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetMscRateOML () - %s", + (_procs_WGL_OML_sync_control.wglGetMscRateOML) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_OML_sync_control.wglGetMscRateOML); +} + +/* wglSwapBuffersMscOML */ +GdkGLProc +gdk_gl_get_wglSwapBuffersMscOML (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_OML_sync_control.wglSwapBuffersMscOML == (GdkGLProc_wglSwapBuffersMscOML) -1) + _procs_WGL_OML_sync_control.wglSwapBuffersMscOML = + (GdkGLProc_wglSwapBuffersMscOML) gdk_gl_get_proc_address ("wglSwapBuffersMscOML"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglSwapBuffersMscOML () - %s", + (_procs_WGL_OML_sync_control.wglSwapBuffersMscOML) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_OML_sync_control.wglSwapBuffersMscOML); +} + +/* wglSwapLayerBuffersMscOML */ +GdkGLProc +gdk_gl_get_wglSwapLayerBuffersMscOML (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_OML_sync_control.wglSwapLayerBuffersMscOML == (GdkGLProc_wglSwapLayerBuffersMscOML) -1) + _procs_WGL_OML_sync_control.wglSwapLayerBuffersMscOML = + (GdkGLProc_wglSwapLayerBuffersMscOML) gdk_gl_get_proc_address ("wglSwapLayerBuffersMscOML"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglSwapLayerBuffersMscOML () - %s", + (_procs_WGL_OML_sync_control.wglSwapLayerBuffersMscOML) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_OML_sync_control.wglSwapLayerBuffersMscOML); +} + +/* wglWaitForMscOML */ +GdkGLProc +gdk_gl_get_wglWaitForMscOML (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_OML_sync_control.wglWaitForMscOML == (GdkGLProc_wglWaitForMscOML) -1) + _procs_WGL_OML_sync_control.wglWaitForMscOML = + (GdkGLProc_wglWaitForMscOML) gdk_gl_get_proc_address ("wglWaitForMscOML"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglWaitForMscOML () - %s", + (_procs_WGL_OML_sync_control.wglWaitForMscOML) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_OML_sync_control.wglWaitForMscOML); +} + +/* wglWaitForSbcOML */ +GdkGLProc +gdk_gl_get_wglWaitForSbcOML (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_OML_sync_control.wglWaitForSbcOML == (GdkGLProc_wglWaitForSbcOML) -1) + _procs_WGL_OML_sync_control.wglWaitForSbcOML = + (GdkGLProc_wglWaitForSbcOML) gdk_gl_get_proc_address ("wglWaitForSbcOML"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglWaitForSbcOML () - %s", + (_procs_WGL_OML_sync_control.wglWaitForSbcOML) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_OML_sync_control.wglWaitForSbcOML); +} + +/* Get WGL_OML_sync_control functions */ +GdkGL_WGL_OML_sync_control * +gdk_gl_get_WGL_OML_sync_control (GdkGLConfig *glconfig) +{ + static gint supported = -1; + + if (wglGetCurrentContext () == NULL) + return NULL; + + if (supported == -1) + { + supported = gdk_win32_gl_query_wgl_extension (glconfig, "WGL_OML_sync_control"); + + if (supported) + { + supported &= (gdk_gl_get_wglGetSyncValuesOML () != NULL); + supported &= (gdk_gl_get_wglGetMscRateOML () != NULL); + supported &= (gdk_gl_get_wglSwapBuffersMscOML () != NULL); + supported &= (gdk_gl_get_wglSwapLayerBuffersMscOML () != NULL); + supported &= (gdk_gl_get_wglWaitForMscOML () != NULL); + supported &= (gdk_gl_get_wglWaitForSbcOML () != NULL); + } + } + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_WGL_OML_sync_control () - %s", + (supported) ? "supported" : "not supported")); + + if (!supported) + return NULL; + + return &_procs_WGL_OML_sync_control; +} + +/* + * WGL_I3D_digital_video_control + */ + +static GdkGL_WGL_I3D_digital_video_control _procs_WGL_I3D_digital_video_control = { + (GdkGLProc_wglGetDigitalVideoParametersI3D) -1, + (GdkGLProc_wglSetDigitalVideoParametersI3D) -1 +}; + +/* wglGetDigitalVideoParametersI3D */ +GdkGLProc +gdk_gl_get_wglGetDigitalVideoParametersI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_digital_video_control.wglGetDigitalVideoParametersI3D == (GdkGLProc_wglGetDigitalVideoParametersI3D) -1) + _procs_WGL_I3D_digital_video_control.wglGetDigitalVideoParametersI3D = + (GdkGLProc_wglGetDigitalVideoParametersI3D) gdk_gl_get_proc_address ("wglGetDigitalVideoParametersI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetDigitalVideoParametersI3D () - %s", + (_procs_WGL_I3D_digital_video_control.wglGetDigitalVideoParametersI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_digital_video_control.wglGetDigitalVideoParametersI3D); +} + +/* wglSetDigitalVideoParametersI3D */ +GdkGLProc +gdk_gl_get_wglSetDigitalVideoParametersI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_digital_video_control.wglSetDigitalVideoParametersI3D == (GdkGLProc_wglSetDigitalVideoParametersI3D) -1) + _procs_WGL_I3D_digital_video_control.wglSetDigitalVideoParametersI3D = + (GdkGLProc_wglSetDigitalVideoParametersI3D) gdk_gl_get_proc_address ("wglSetDigitalVideoParametersI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglSetDigitalVideoParametersI3D () - %s", + (_procs_WGL_I3D_digital_video_control.wglSetDigitalVideoParametersI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_digital_video_control.wglSetDigitalVideoParametersI3D); +} + +/* Get WGL_I3D_digital_video_control functions */ +GdkGL_WGL_I3D_digital_video_control * +gdk_gl_get_WGL_I3D_digital_video_control (GdkGLConfig *glconfig) +{ + static gint supported = -1; + + if (wglGetCurrentContext () == NULL) + return NULL; + + if (supported == -1) + { + supported = gdk_win32_gl_query_wgl_extension (glconfig, "WGL_I3D_digital_video_control"); + + if (supported) + { + supported &= (gdk_gl_get_wglGetDigitalVideoParametersI3D () != NULL); + supported &= (gdk_gl_get_wglSetDigitalVideoParametersI3D () != NULL); + } + } + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_WGL_I3D_digital_video_control () - %s", + (supported) ? "supported" : "not supported")); + + if (!supported) + return NULL; + + return &_procs_WGL_I3D_digital_video_control; +} + +/* + * WGL_I3D_gamma + */ + +static GdkGL_WGL_I3D_gamma _procs_WGL_I3D_gamma = { + (GdkGLProc_wglGetGammaTableParametersI3D) -1, + (GdkGLProc_wglSetGammaTableParametersI3D) -1, + (GdkGLProc_wglGetGammaTableI3D) -1, + (GdkGLProc_wglSetGammaTableI3D) -1 +}; + +/* wglGetGammaTableParametersI3D */ +GdkGLProc +gdk_gl_get_wglGetGammaTableParametersI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_gamma.wglGetGammaTableParametersI3D == (GdkGLProc_wglGetGammaTableParametersI3D) -1) + _procs_WGL_I3D_gamma.wglGetGammaTableParametersI3D = + (GdkGLProc_wglGetGammaTableParametersI3D) gdk_gl_get_proc_address ("wglGetGammaTableParametersI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetGammaTableParametersI3D () - %s", + (_procs_WGL_I3D_gamma.wglGetGammaTableParametersI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_gamma.wglGetGammaTableParametersI3D); +} + +/* wglSetGammaTableParametersI3D */ +GdkGLProc +gdk_gl_get_wglSetGammaTableParametersI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_gamma.wglSetGammaTableParametersI3D == (GdkGLProc_wglSetGammaTableParametersI3D) -1) + _procs_WGL_I3D_gamma.wglSetGammaTableParametersI3D = + (GdkGLProc_wglSetGammaTableParametersI3D) gdk_gl_get_proc_address ("wglSetGammaTableParametersI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglSetGammaTableParametersI3D () - %s", + (_procs_WGL_I3D_gamma.wglSetGammaTableParametersI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_gamma.wglSetGammaTableParametersI3D); +} + +/* wglGetGammaTableI3D */ +GdkGLProc +gdk_gl_get_wglGetGammaTableI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_gamma.wglGetGammaTableI3D == (GdkGLProc_wglGetGammaTableI3D) -1) + _procs_WGL_I3D_gamma.wglGetGammaTableI3D = + (GdkGLProc_wglGetGammaTableI3D) gdk_gl_get_proc_address ("wglGetGammaTableI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetGammaTableI3D () - %s", + (_procs_WGL_I3D_gamma.wglGetGammaTableI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_gamma.wglGetGammaTableI3D); +} + +/* wglSetGammaTableI3D */ +GdkGLProc +gdk_gl_get_wglSetGammaTableI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_gamma.wglSetGammaTableI3D == (GdkGLProc_wglSetGammaTableI3D) -1) + _procs_WGL_I3D_gamma.wglSetGammaTableI3D = + (GdkGLProc_wglSetGammaTableI3D) gdk_gl_get_proc_address ("wglSetGammaTableI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglSetGammaTableI3D () - %s", + (_procs_WGL_I3D_gamma.wglSetGammaTableI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_gamma.wglSetGammaTableI3D); +} + +/* Get WGL_I3D_gamma functions */ +GdkGL_WGL_I3D_gamma * +gdk_gl_get_WGL_I3D_gamma (GdkGLConfig *glconfig) +{ + static gint supported = -1; + + if (wglGetCurrentContext () == NULL) + return NULL; + + if (supported == -1) + { + supported = gdk_win32_gl_query_wgl_extension (glconfig, "WGL_I3D_gamma"); + + if (supported) + { + supported &= (gdk_gl_get_wglGetGammaTableParametersI3D () != NULL); + supported &= (gdk_gl_get_wglSetGammaTableParametersI3D () != NULL); + supported &= (gdk_gl_get_wglGetGammaTableI3D () != NULL); + supported &= (gdk_gl_get_wglSetGammaTableI3D () != NULL); + } + } + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_WGL_I3D_gamma () - %s", + (supported) ? "supported" : "not supported")); + + if (!supported) + return NULL; + + return &_procs_WGL_I3D_gamma; +} + +/* + * WGL_I3D_genlock + */ + +static GdkGL_WGL_I3D_genlock _procs_WGL_I3D_genlock = { + (GdkGLProc_wglEnableGenlockI3D) -1, + (GdkGLProc_wglDisableGenlockI3D) -1, + (GdkGLProc_wglIsEnabledGenlockI3D) -1, + (GdkGLProc_wglGenlockSourceI3D) -1, + (GdkGLProc_wglGetGenlockSourceI3D) -1, + (GdkGLProc_wglGenlockSourceEdgeI3D) -1, + (GdkGLProc_wglGetGenlockSourceEdgeI3D) -1, + (GdkGLProc_wglGenlockSampleRateI3D) -1, + (GdkGLProc_wglGetGenlockSampleRateI3D) -1, + (GdkGLProc_wglGenlockSourceDelayI3D) -1, + (GdkGLProc_wglGetGenlockSourceDelayI3D) -1, + (GdkGLProc_wglQueryGenlockMaxSourceDelayI3D) -1 +}; + +/* wglEnableGenlockI3D */ +GdkGLProc +gdk_gl_get_wglEnableGenlockI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_genlock.wglEnableGenlockI3D == (GdkGLProc_wglEnableGenlockI3D) -1) + _procs_WGL_I3D_genlock.wglEnableGenlockI3D = + (GdkGLProc_wglEnableGenlockI3D) gdk_gl_get_proc_address ("wglEnableGenlockI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglEnableGenlockI3D () - %s", + (_procs_WGL_I3D_genlock.wglEnableGenlockI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_genlock.wglEnableGenlockI3D); +} + +/* wglDisableGenlockI3D */ +GdkGLProc +gdk_gl_get_wglDisableGenlockI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_genlock.wglDisableGenlockI3D == (GdkGLProc_wglDisableGenlockI3D) -1) + _procs_WGL_I3D_genlock.wglDisableGenlockI3D = + (GdkGLProc_wglDisableGenlockI3D) gdk_gl_get_proc_address ("wglDisableGenlockI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglDisableGenlockI3D () - %s", + (_procs_WGL_I3D_genlock.wglDisableGenlockI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_genlock.wglDisableGenlockI3D); +} + +/* wglIsEnabledGenlockI3D */ +GdkGLProc +gdk_gl_get_wglIsEnabledGenlockI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_genlock.wglIsEnabledGenlockI3D == (GdkGLProc_wglIsEnabledGenlockI3D) -1) + _procs_WGL_I3D_genlock.wglIsEnabledGenlockI3D = + (GdkGLProc_wglIsEnabledGenlockI3D) gdk_gl_get_proc_address ("wglIsEnabledGenlockI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglIsEnabledGenlockI3D () - %s", + (_procs_WGL_I3D_genlock.wglIsEnabledGenlockI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_genlock.wglIsEnabledGenlockI3D); +} + +/* wglGenlockSourceI3D */ +GdkGLProc +gdk_gl_get_wglGenlockSourceI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_genlock.wglGenlockSourceI3D == (GdkGLProc_wglGenlockSourceI3D) -1) + _procs_WGL_I3D_genlock.wglGenlockSourceI3D = + (GdkGLProc_wglGenlockSourceI3D) gdk_gl_get_proc_address ("wglGenlockSourceI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGenlockSourceI3D () - %s", + (_procs_WGL_I3D_genlock.wglGenlockSourceI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_genlock.wglGenlockSourceI3D); +} + +/* wglGetGenlockSourceI3D */ +GdkGLProc +gdk_gl_get_wglGetGenlockSourceI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_genlock.wglGetGenlockSourceI3D == (GdkGLProc_wglGetGenlockSourceI3D) -1) + _procs_WGL_I3D_genlock.wglGetGenlockSourceI3D = + (GdkGLProc_wglGetGenlockSourceI3D) gdk_gl_get_proc_address ("wglGetGenlockSourceI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetGenlockSourceI3D () - %s", + (_procs_WGL_I3D_genlock.wglGetGenlockSourceI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_genlock.wglGetGenlockSourceI3D); +} + +/* wglGenlockSourceEdgeI3D */ +GdkGLProc +gdk_gl_get_wglGenlockSourceEdgeI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_genlock.wglGenlockSourceEdgeI3D == (GdkGLProc_wglGenlockSourceEdgeI3D) -1) + _procs_WGL_I3D_genlock.wglGenlockSourceEdgeI3D = + (GdkGLProc_wglGenlockSourceEdgeI3D) gdk_gl_get_proc_address ("wglGenlockSourceEdgeI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGenlockSourceEdgeI3D () - %s", + (_procs_WGL_I3D_genlock.wglGenlockSourceEdgeI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_genlock.wglGenlockSourceEdgeI3D); +} + +/* wglGetGenlockSourceEdgeI3D */ +GdkGLProc +gdk_gl_get_wglGetGenlockSourceEdgeI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_genlock.wglGetGenlockSourceEdgeI3D == (GdkGLProc_wglGetGenlockSourceEdgeI3D) -1) + _procs_WGL_I3D_genlock.wglGetGenlockSourceEdgeI3D = + (GdkGLProc_wglGetGenlockSourceEdgeI3D) gdk_gl_get_proc_address ("wglGetGenlockSourceEdgeI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetGenlockSourceEdgeI3D () - %s", + (_procs_WGL_I3D_genlock.wglGetGenlockSourceEdgeI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_genlock.wglGetGenlockSourceEdgeI3D); +} + +/* wglGenlockSampleRateI3D */ +GdkGLProc +gdk_gl_get_wglGenlockSampleRateI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_genlock.wglGenlockSampleRateI3D == (GdkGLProc_wglGenlockSampleRateI3D) -1) + _procs_WGL_I3D_genlock.wglGenlockSampleRateI3D = + (GdkGLProc_wglGenlockSampleRateI3D) gdk_gl_get_proc_address ("wglGenlockSampleRateI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGenlockSampleRateI3D () - %s", + (_procs_WGL_I3D_genlock.wglGenlockSampleRateI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_genlock.wglGenlockSampleRateI3D); +} + +/* wglGetGenlockSampleRateI3D */ +GdkGLProc +gdk_gl_get_wglGetGenlockSampleRateI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_genlock.wglGetGenlockSampleRateI3D == (GdkGLProc_wglGetGenlockSampleRateI3D) -1) + _procs_WGL_I3D_genlock.wglGetGenlockSampleRateI3D = + (GdkGLProc_wglGetGenlockSampleRateI3D) gdk_gl_get_proc_address ("wglGetGenlockSampleRateI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetGenlockSampleRateI3D () - %s", + (_procs_WGL_I3D_genlock.wglGetGenlockSampleRateI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_genlock.wglGetGenlockSampleRateI3D); +} + +/* wglGenlockSourceDelayI3D */ +GdkGLProc +gdk_gl_get_wglGenlockSourceDelayI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_genlock.wglGenlockSourceDelayI3D == (GdkGLProc_wglGenlockSourceDelayI3D) -1) + _procs_WGL_I3D_genlock.wglGenlockSourceDelayI3D = + (GdkGLProc_wglGenlockSourceDelayI3D) gdk_gl_get_proc_address ("wglGenlockSourceDelayI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGenlockSourceDelayI3D () - %s", + (_procs_WGL_I3D_genlock.wglGenlockSourceDelayI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_genlock.wglGenlockSourceDelayI3D); +} + +/* wglGetGenlockSourceDelayI3D */ +GdkGLProc +gdk_gl_get_wglGetGenlockSourceDelayI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_genlock.wglGetGenlockSourceDelayI3D == (GdkGLProc_wglGetGenlockSourceDelayI3D) -1) + _procs_WGL_I3D_genlock.wglGetGenlockSourceDelayI3D = + (GdkGLProc_wglGetGenlockSourceDelayI3D) gdk_gl_get_proc_address ("wglGetGenlockSourceDelayI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetGenlockSourceDelayI3D () - %s", + (_procs_WGL_I3D_genlock.wglGetGenlockSourceDelayI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_genlock.wglGetGenlockSourceDelayI3D); +} + +/* wglQueryGenlockMaxSourceDelayI3D */ +GdkGLProc +gdk_gl_get_wglQueryGenlockMaxSourceDelayI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_genlock.wglQueryGenlockMaxSourceDelayI3D == (GdkGLProc_wglQueryGenlockMaxSourceDelayI3D) -1) + _procs_WGL_I3D_genlock.wglQueryGenlockMaxSourceDelayI3D = + (GdkGLProc_wglQueryGenlockMaxSourceDelayI3D) gdk_gl_get_proc_address ("wglQueryGenlockMaxSourceDelayI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglQueryGenlockMaxSourceDelayI3D () - %s", + (_procs_WGL_I3D_genlock.wglQueryGenlockMaxSourceDelayI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_genlock.wglQueryGenlockMaxSourceDelayI3D); +} + +/* Get WGL_I3D_genlock functions */ +GdkGL_WGL_I3D_genlock * +gdk_gl_get_WGL_I3D_genlock (GdkGLConfig *glconfig) +{ + static gint supported = -1; + + if (wglGetCurrentContext () == NULL) + return NULL; + + if (supported == -1) + { + supported = gdk_win32_gl_query_wgl_extension (glconfig, "WGL_I3D_genlock"); + + if (supported) + { + supported &= (gdk_gl_get_wglEnableGenlockI3D () != NULL); + supported &= (gdk_gl_get_wglDisableGenlockI3D () != NULL); + supported &= (gdk_gl_get_wglIsEnabledGenlockI3D () != NULL); + supported &= (gdk_gl_get_wglGenlockSourceI3D () != NULL); + supported &= (gdk_gl_get_wglGetGenlockSourceI3D () != NULL); + supported &= (gdk_gl_get_wglGenlockSourceEdgeI3D () != NULL); + supported &= (gdk_gl_get_wglGetGenlockSourceEdgeI3D () != NULL); + supported &= (gdk_gl_get_wglGenlockSampleRateI3D () != NULL); + supported &= (gdk_gl_get_wglGetGenlockSampleRateI3D () != NULL); + supported &= (gdk_gl_get_wglGenlockSourceDelayI3D () != NULL); + supported &= (gdk_gl_get_wglGetGenlockSourceDelayI3D () != NULL); + supported &= (gdk_gl_get_wglQueryGenlockMaxSourceDelayI3D () != NULL); + } + } + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_WGL_I3D_genlock () - %s", + (supported) ? "supported" : "not supported")); + + if (!supported) + return NULL; + + return &_procs_WGL_I3D_genlock; +} + +/* + * WGL_I3D_image_buffer + */ + +static GdkGL_WGL_I3D_image_buffer _procs_WGL_I3D_image_buffer = { + (GdkGLProc_wglCreateImageBufferI3D) -1, + (GdkGLProc_wglDestroyImageBufferI3D) -1, + (GdkGLProc_wglAssociateImageBufferEventsI3D) -1, + (GdkGLProc_wglReleaseImageBufferEventsI3D) -1 +}; + +/* wglCreateImageBufferI3D */ +GdkGLProc +gdk_gl_get_wglCreateImageBufferI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_image_buffer.wglCreateImageBufferI3D == (GdkGLProc_wglCreateImageBufferI3D) -1) + _procs_WGL_I3D_image_buffer.wglCreateImageBufferI3D = + (GdkGLProc_wglCreateImageBufferI3D) gdk_gl_get_proc_address ("wglCreateImageBufferI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglCreateImageBufferI3D () - %s", + (_procs_WGL_I3D_image_buffer.wglCreateImageBufferI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_image_buffer.wglCreateImageBufferI3D); +} + +/* wglDestroyImageBufferI3D */ +GdkGLProc +gdk_gl_get_wglDestroyImageBufferI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_image_buffer.wglDestroyImageBufferI3D == (GdkGLProc_wglDestroyImageBufferI3D) -1) + _procs_WGL_I3D_image_buffer.wglDestroyImageBufferI3D = + (GdkGLProc_wglDestroyImageBufferI3D) gdk_gl_get_proc_address ("wglDestroyImageBufferI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglDestroyImageBufferI3D () - %s", + (_procs_WGL_I3D_image_buffer.wglDestroyImageBufferI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_image_buffer.wglDestroyImageBufferI3D); +} + +/* wglAssociateImageBufferEventsI3D */ +GdkGLProc +gdk_gl_get_wglAssociateImageBufferEventsI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_image_buffer.wglAssociateImageBufferEventsI3D == (GdkGLProc_wglAssociateImageBufferEventsI3D) -1) + _procs_WGL_I3D_image_buffer.wglAssociateImageBufferEventsI3D = + (GdkGLProc_wglAssociateImageBufferEventsI3D) gdk_gl_get_proc_address ("wglAssociateImageBufferEventsI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglAssociateImageBufferEventsI3D () - %s", + (_procs_WGL_I3D_image_buffer.wglAssociateImageBufferEventsI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_image_buffer.wglAssociateImageBufferEventsI3D); +} + +/* wglReleaseImageBufferEventsI3D */ +GdkGLProc +gdk_gl_get_wglReleaseImageBufferEventsI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_image_buffer.wglReleaseImageBufferEventsI3D == (GdkGLProc_wglReleaseImageBufferEventsI3D) -1) + _procs_WGL_I3D_image_buffer.wglReleaseImageBufferEventsI3D = + (GdkGLProc_wglReleaseImageBufferEventsI3D) gdk_gl_get_proc_address ("wglReleaseImageBufferEventsI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglReleaseImageBufferEventsI3D () - %s", + (_procs_WGL_I3D_image_buffer.wglReleaseImageBufferEventsI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_image_buffer.wglReleaseImageBufferEventsI3D); +} + +/* Get WGL_I3D_image_buffer functions */ +GdkGL_WGL_I3D_image_buffer * +gdk_gl_get_WGL_I3D_image_buffer (GdkGLConfig *glconfig) +{ + static gint supported = -1; + + if (wglGetCurrentContext () == NULL) + return NULL; + + if (supported == -1) + { + supported = gdk_win32_gl_query_wgl_extension (glconfig, "WGL_I3D_image_buffer"); + + if (supported) + { + supported &= (gdk_gl_get_wglCreateImageBufferI3D () != NULL); + supported &= (gdk_gl_get_wglDestroyImageBufferI3D () != NULL); + supported &= (gdk_gl_get_wglAssociateImageBufferEventsI3D () != NULL); + supported &= (gdk_gl_get_wglReleaseImageBufferEventsI3D () != NULL); + } + } + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_WGL_I3D_image_buffer () - %s", + (supported) ? "supported" : "not supported")); + + if (!supported) + return NULL; + + return &_procs_WGL_I3D_image_buffer; +} + +/* + * WGL_I3D_swap_frame_lock + */ + +static GdkGL_WGL_I3D_swap_frame_lock _procs_WGL_I3D_swap_frame_lock = { + (GdkGLProc_wglEnableFrameLockI3D) -1, + (GdkGLProc_wglDisableFrameLockI3D) -1, + (GdkGLProc_wglIsEnabledFrameLockI3D) -1, + (GdkGLProc_wglQueryFrameLockMasterI3D) -1 +}; + +/* wglEnableFrameLockI3D */ +GdkGLProc +gdk_gl_get_wglEnableFrameLockI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_swap_frame_lock.wglEnableFrameLockI3D == (GdkGLProc_wglEnableFrameLockI3D) -1) + _procs_WGL_I3D_swap_frame_lock.wglEnableFrameLockI3D = + (GdkGLProc_wglEnableFrameLockI3D) gdk_gl_get_proc_address ("wglEnableFrameLockI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglEnableFrameLockI3D () - %s", + (_procs_WGL_I3D_swap_frame_lock.wglEnableFrameLockI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_swap_frame_lock.wglEnableFrameLockI3D); +} + +/* wglDisableFrameLockI3D */ +GdkGLProc +gdk_gl_get_wglDisableFrameLockI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_swap_frame_lock.wglDisableFrameLockI3D == (GdkGLProc_wglDisableFrameLockI3D) -1) + _procs_WGL_I3D_swap_frame_lock.wglDisableFrameLockI3D = + (GdkGLProc_wglDisableFrameLockI3D) gdk_gl_get_proc_address ("wglDisableFrameLockI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglDisableFrameLockI3D () - %s", + (_procs_WGL_I3D_swap_frame_lock.wglDisableFrameLockI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_swap_frame_lock.wglDisableFrameLockI3D); +} + +/* wglIsEnabledFrameLockI3D */ +GdkGLProc +gdk_gl_get_wglIsEnabledFrameLockI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_swap_frame_lock.wglIsEnabledFrameLockI3D == (GdkGLProc_wglIsEnabledFrameLockI3D) -1) + _procs_WGL_I3D_swap_frame_lock.wglIsEnabledFrameLockI3D = + (GdkGLProc_wglIsEnabledFrameLockI3D) gdk_gl_get_proc_address ("wglIsEnabledFrameLockI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglIsEnabledFrameLockI3D () - %s", + (_procs_WGL_I3D_swap_frame_lock.wglIsEnabledFrameLockI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_swap_frame_lock.wglIsEnabledFrameLockI3D); +} + +/* wglQueryFrameLockMasterI3D */ +GdkGLProc +gdk_gl_get_wglQueryFrameLockMasterI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_swap_frame_lock.wglQueryFrameLockMasterI3D == (GdkGLProc_wglQueryFrameLockMasterI3D) -1) + _procs_WGL_I3D_swap_frame_lock.wglQueryFrameLockMasterI3D = + (GdkGLProc_wglQueryFrameLockMasterI3D) gdk_gl_get_proc_address ("wglQueryFrameLockMasterI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglQueryFrameLockMasterI3D () - %s", + (_procs_WGL_I3D_swap_frame_lock.wglQueryFrameLockMasterI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_swap_frame_lock.wglQueryFrameLockMasterI3D); +} + +/* Get WGL_I3D_swap_frame_lock functions */ +GdkGL_WGL_I3D_swap_frame_lock * +gdk_gl_get_WGL_I3D_swap_frame_lock (GdkGLConfig *glconfig) +{ + static gint supported = -1; + + if (wglGetCurrentContext () == NULL) + return NULL; + + if (supported == -1) + { + supported = gdk_win32_gl_query_wgl_extension (glconfig, "WGL_I3D_swap_frame_lock"); + + if (supported) + { + supported &= (gdk_gl_get_wglEnableFrameLockI3D () != NULL); + supported &= (gdk_gl_get_wglDisableFrameLockI3D () != NULL); + supported &= (gdk_gl_get_wglIsEnabledFrameLockI3D () != NULL); + supported &= (gdk_gl_get_wglQueryFrameLockMasterI3D () != NULL); + } + } + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_WGL_I3D_swap_frame_lock () - %s", + (supported) ? "supported" : "not supported")); + + if (!supported) + return NULL; + + return &_procs_WGL_I3D_swap_frame_lock; +} + +/* + * WGL_I3D_swap_frame_usage + */ + +static GdkGL_WGL_I3D_swap_frame_usage _procs_WGL_I3D_swap_frame_usage = { + (GdkGLProc_wglGetFrameUsageI3D) -1, + (GdkGLProc_wglBeginFrameTrackingI3D) -1, + (GdkGLProc_wglEndFrameTrackingI3D) -1, + (GdkGLProc_wglQueryFrameTrackingI3D) -1 +}; + +/* wglGetFrameUsageI3D */ +GdkGLProc +gdk_gl_get_wglGetFrameUsageI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_swap_frame_usage.wglGetFrameUsageI3D == (GdkGLProc_wglGetFrameUsageI3D) -1) + _procs_WGL_I3D_swap_frame_usage.wglGetFrameUsageI3D = + (GdkGLProc_wglGetFrameUsageI3D) gdk_gl_get_proc_address ("wglGetFrameUsageI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglGetFrameUsageI3D () - %s", + (_procs_WGL_I3D_swap_frame_usage.wglGetFrameUsageI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_swap_frame_usage.wglGetFrameUsageI3D); +} + +/* wglBeginFrameTrackingI3D */ +GdkGLProc +gdk_gl_get_wglBeginFrameTrackingI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_swap_frame_usage.wglBeginFrameTrackingI3D == (GdkGLProc_wglBeginFrameTrackingI3D) -1) + _procs_WGL_I3D_swap_frame_usage.wglBeginFrameTrackingI3D = + (GdkGLProc_wglBeginFrameTrackingI3D) gdk_gl_get_proc_address ("wglBeginFrameTrackingI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglBeginFrameTrackingI3D () - %s", + (_procs_WGL_I3D_swap_frame_usage.wglBeginFrameTrackingI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_swap_frame_usage.wglBeginFrameTrackingI3D); +} + +/* wglEndFrameTrackingI3D */ +GdkGLProc +gdk_gl_get_wglEndFrameTrackingI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_swap_frame_usage.wglEndFrameTrackingI3D == (GdkGLProc_wglEndFrameTrackingI3D) -1) + _procs_WGL_I3D_swap_frame_usage.wglEndFrameTrackingI3D = + (GdkGLProc_wglEndFrameTrackingI3D) gdk_gl_get_proc_address ("wglEndFrameTrackingI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglEndFrameTrackingI3D () - %s", + (_procs_WGL_I3D_swap_frame_usage.wglEndFrameTrackingI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_swap_frame_usage.wglEndFrameTrackingI3D); +} + +/* wglQueryFrameTrackingI3D */ +GdkGLProc +gdk_gl_get_wglQueryFrameTrackingI3D (void) +{ + if (wglGetCurrentContext () == NULL) + return NULL; + + if (_procs_WGL_I3D_swap_frame_usage.wglQueryFrameTrackingI3D == (GdkGLProc_wglQueryFrameTrackingI3D) -1) + _procs_WGL_I3D_swap_frame_usage.wglQueryFrameTrackingI3D = + (GdkGLProc_wglQueryFrameTrackingI3D) gdk_gl_get_proc_address ("wglQueryFrameTrackingI3D"); + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_wglQueryFrameTrackingI3D () - %s", + (_procs_WGL_I3D_swap_frame_usage.wglQueryFrameTrackingI3D) ? "supported" : "not supported")); + + return (GdkGLProc) (_procs_WGL_I3D_swap_frame_usage.wglQueryFrameTrackingI3D); +} + +/* Get WGL_I3D_swap_frame_usage functions */ +GdkGL_WGL_I3D_swap_frame_usage * +gdk_gl_get_WGL_I3D_swap_frame_usage (GdkGLConfig *glconfig) +{ + static gint supported = -1; + + if (wglGetCurrentContext () == NULL) + return NULL; + + if (supported == -1) + { + supported = gdk_win32_gl_query_wgl_extension (glconfig, "WGL_I3D_swap_frame_usage"); + + if (supported) + { + supported &= (gdk_gl_get_wglGetFrameUsageI3D () != NULL); + supported &= (gdk_gl_get_wglBeginFrameTrackingI3D () != NULL); + supported &= (gdk_gl_get_wglEndFrameTrackingI3D () != NULL); + supported &= (gdk_gl_get_wglQueryFrameTrackingI3D () != NULL); + } + } + + GDK_GL_NOTE (MISC, + g_message (" - gdk_gl_get_WGL_I3D_swap_frame_usage () - %s", + (supported) ? "supported" : "not supported")); + + if (!supported) + return NULL; + + return &_procs_WGL_I3D_swap_frame_usage; +} + |