diff options
Diffstat (limited to 'xc/extras/Mesa/src/X/glxapi.c')
| -rw-r--r-- | xc/extras/Mesa/src/X/glxapi.c | 837 |
1 files changed, 694 insertions, 143 deletions
diff --git a/xc/extras/Mesa/src/X/glxapi.c b/xc/extras/Mesa/src/X/glxapi.c index cd71f2c98..2a9e26861 100644 --- a/xc/extras/Mesa/src/X/glxapi.c +++ b/xc/extras/Mesa/src/X/glxapi.c @@ -1,9 +1,10 @@ +/* $Id: glxapi.c,v 1.8 2002/02/14 01:59:35 dawes Exp $ */ /* * Mesa 3-D graphics library - * Version: 3.3 + * Version: 3.5 * - * Copyright (C) 1999-2000 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2001 Brian Paul All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), @@ -26,35 +27,21 @@ /* * This is the GLX API dispatcher. Calls to the glX* functions are - * either routed to real (SGI / Utah) GLX encoders or to Mesa's - * pseudo-GLX module. + * either routed to the real GLX encoders or to Mesa's pseudo-GLX functions. */ #include <assert.h> #include <stdlib.h> +#include <stdio.h> +#include <string.h> +/*#include <dlfcn.h>*/ /* XXX not portable? */ #include "glapi.h" #include "glxapi.h" -/* - * XXX - this really shouldn't be here. - * Instead, add -DUSE_MESA_GLX to the compiler flags when needed. - */ -#define USE_MESA_GLX 1 - - -/* Rather than include possibly non-existant headers... */ -#ifdef USE_SGI_GLX -extern struct _glxapi_table *_sgi_GetGLXDispatchtable(void); -#endif -#ifdef USE_UTAH_GLX -extern struct _glxapi_table *_utah_GetGLXDispatchTable(void); -#endif -#ifdef USE_MESA_GLX +extern struct _glxapi_table *_real_GetGLXDispatchTable(void); extern struct _glxapi_table *_mesa_GetGLXDispatchTable(void); -#endif - struct display_dispatch { @@ -66,20 +53,17 @@ struct display_dispatch { static struct display_dispatch *DispatchList = NULL; +/* Display -> Dispatch caching */ +static Display *prevDisplay = NULL; +static struct _glxapi_table *prevTable = NULL; + + static struct _glxapi_table * get_dispatch(Display *dpy) { - static Display *prevDisplay = NULL; - static struct _glxapi_table *prevTable = NULL; - if (!dpy) return NULL; - /* try cached display */ - if (dpy == prevDisplay) { - return prevTable; - } - /* search list of display/dispatch pairs for this display */ { const struct display_dispatch *d = DispatchList; @@ -93,32 +77,35 @@ get_dispatch(Display *dpy) } } - /* A new display, determine if we should use real GLX (SGI / Utah) + /* A new display, determine if we should use real GLX * or Mesa's pseudo-GLX. */ { struct _glxapi_table *t = NULL; -#if defined(USE_SGI_GLX) || defined(USE_UTAH_GLX) - if (!getenv("MESA_FORCE_SOFTX")) { +#ifdef GLX_BUILT_IN_XMESA + if (!getenv("LIBGL_FORCE_XMESA")) { int ignore; if (XQueryExtension( dpy, "GLX", &ignore, &ignore, &ignore )) { /* the X server has the GLX extension */ -#if defined(USE_SGI_GLX) - t = _sgi_GetGLXDispatchtable(); -#elif defined(USE_UTAH_GLX) - t = _utah_GetGLXDispatchTable(); -#endif + t = _real_GetGLXDispatchTable(); } } #endif -#if defined(USE_MESA_GLX) if (!t) { + /* Fallback to Mesa with Xlib driver */ +#ifdef GLX_BUILT_IN_XMESA + if (getenv("LIBGL_DEBUG")) { + fprintf(stderr, + "libGL: server %s lacks the GLX extension.", + dpy->display_name); + fprintf(stderr, " Using Mesa Xlib renderer.\n"); + } +#endif t = _mesa_GetGLXDispatchTable(); assert(t); /* this has to work */ } -#endif if (t) { struct display_dispatch *d; @@ -145,23 +132,37 @@ get_dispatch(Display *dpy) } +#define GET_DISPATCH(DPY, TABLE) \ + if (DPY == prevDisplay) { \ + TABLE = prevTable; \ + } \ + else if (!DPY) { \ + TABLE = NULL; \ + } \ + else { \ + TABLE = get_dispatch(DPY); \ + } + + + /* Set by glXMakeCurrent() and glXMakeContextCurrent() only */ -static Display *CurrentDisplay = NULL; +#ifndef GLX_BUILT_IN_XMESA static GLXContext CurrentContext = 0; -static GLXDrawable CurrentDrawable = 0; -static GLXDrawable CurrentReadDrawable = 0; - +#define __glXGetCurrentContext() CurrentContext; +#endif /* * GLX API entrypoints */ +/*** GLX_VERSION_1_0 ***/ XVisualInfo *glXChooseVisual(Display *dpy, int screen, int *list) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return NULL; return (t->ChooseVisual)(dpy, screen, list); @@ -170,7 +171,8 @@ XVisualInfo *glXChooseVisual(Display *dpy, int screen, int *list) void glXCopyContext(Display *dpy, GLXContext src, GLXContext dst, unsigned long mask) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return; (t->CopyContext)(dpy, src, dst, mask); @@ -179,7 +181,8 @@ void glXCopyContext(Display *dpy, GLXContext src, GLXContext dst, unsigned long GLXContext glXCreateContext(Display *dpy, XVisualInfo *visinfo, GLXContext shareList, Bool direct) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return 0; return (t->CreateContext)(dpy, visinfo, shareList, direct); @@ -188,7 +191,8 @@ GLXContext glXCreateContext(Display *dpy, XVisualInfo *visinfo, GLXContext share GLXPixmap glXCreateGLXPixmap(Display *dpy, XVisualInfo *visinfo, Pixmap pixmap) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return 0; return (t->CreateGLXPixmap)(dpy, visinfo, pixmap); @@ -197,7 +201,8 @@ GLXPixmap glXCreateGLXPixmap(Display *dpy, XVisualInfo *visinfo, Pixmap pixmap) void glXDestroyContext(Display *dpy, GLXContext ctx) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return; (t->DestroyContext)(dpy, ctx); @@ -206,7 +211,8 @@ void glXDestroyContext(Display *dpy, GLXContext ctx) void glXDestroyGLXPixmap(Display *dpy, GLXPixmap pixmap) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return; (t->DestroyGLXPixmap)(dpy, pixmap); @@ -215,28 +221,41 @@ void glXDestroyGLXPixmap(Display *dpy, GLXPixmap pixmap) int glXGetConfig(Display *dpy, XVisualInfo *visinfo, int attrib, int *value) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return GLX_NO_EXTENSION; return (t->GetConfig)(dpy, visinfo, attrib, value); } +#ifdef GLX_BUILT_IN_XMESA +/* Use real libGL's glXGetCurrentContext() function */ +#else +/* stand-alone Mesa */ GLXContext glXGetCurrentContext(void) { return CurrentContext; } +#endif +#ifdef GLX_BUILT_IN_XMESA +/* Use real libGL's glXGetCurrentContext() function */ +#else +/* stand-alone Mesa */ GLXDrawable glXGetCurrentDrawable(void) { - return CurrentDrawable; + __GLXcontext *gc = (__GLXcontext *) glXGetCurrentContext(); + return gc ? gc->currentDrawable : 0; } +#endif Bool glXIsDirect(Display *dpy, GLXContext ctx) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return False; return (t->IsDirect)(dpy, ctx); @@ -246,23 +265,25 @@ Bool glXIsDirect(Display *dpy, GLXContext ctx) Bool glXMakeCurrent(Display *dpy, GLXDrawable drawable, GLXContext ctx) { Bool b; - struct _glxapi_table *t = get_dispatch(dpy); - if (!t) + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) { return False; + } b = (*t->MakeCurrent)(dpy, drawable, ctx); +#ifndef GLX_BUILT_IN_XMESA if (b) { - CurrentDisplay = dpy; CurrentContext = ctx; - CurrentDrawable = drawable; - CurrentReadDrawable = drawable; } +#endif return b; } Bool glXQueryExtension(Display *dpy, int *errorb, int *event) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return False; return (t->QueryExtension)(dpy, errorb, event); @@ -271,7 +292,8 @@ Bool glXQueryExtension(Display *dpy, int *errorb, int *event) Bool glXQueryVersion(Display *dpy, int *maj, int *min) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return False; return (t->QueryVersion)(dpy, maj, min); @@ -280,7 +302,8 @@ Bool glXQueryVersion(Display *dpy, int *maj, int *min) void glXSwapBuffers(Display *dpy, GLXDrawable drawable) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return; (t->SwapBuffers)(dpy, drawable); @@ -289,7 +312,9 @@ void glXSwapBuffers(Display *dpy, GLXDrawable drawable) void glXUseXFont(Font font, int first, int count, int listBase) { - struct _glxapi_table *t = get_dispatch(CurrentDisplay); + struct _glxapi_table *t; + Display *dpy = glXGetCurrentDisplay(); + GET_DISPATCH(dpy, t); if (!t) return; (t->UseXFont)(font, first, count, listBase); @@ -298,7 +323,9 @@ void glXUseXFont(Font font, int first, int count, int listBase) void glXWaitGL(void) { - struct _glxapi_table *t = get_dispatch(CurrentDisplay); + struct _glxapi_table *t; + Display *dpy = glXGetCurrentDisplay(); + GET_DISPATCH(dpy, t); if (!t) return; (t->WaitGL)(); @@ -307,7 +334,9 @@ void glXWaitGL(void) void glXWaitX(void) { - struct _glxapi_table *t = get_dispatch(CurrentDisplay); + struct _glxapi_table *t; + Display *dpy = glXGetCurrentDisplay(); + GET_DISPATCH(dpy, t); if (!t) return; (t->WaitX)(); @@ -315,11 +344,12 @@ void glXWaitX(void) -#ifdef GLX_VERSION_1_1 +/*** GLX_VERSION_1_1 ***/ const char *glXGetClientString(Display *dpy, int name) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return NULL; return (t->GetClientString)(dpy, name); @@ -328,7 +358,8 @@ const char *glXGetClientString(Display *dpy, int name) const char *glXQueryExtensionsString(Display *dpy, int screen) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return NULL; return (t->QueryExtensionsString)(dpy, screen); @@ -337,30 +368,34 @@ const char *glXQueryExtensionsString(Display *dpy, int screen) const char *glXQueryServerString(Display *dpy, int screen, int name) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return NULL; return (t->QueryServerString)(dpy, screen, name); } -#endif - +/*** GLX_VERSION_1_2 ***/ -#ifdef GLX_VERSION_1_2 +#if !defined(GLX_BUILT_IN_XMESA) Display *glXGetCurrentDisplay(void) { - return CurrentDisplay; + /* Same code as in libGL's glxext.c */ + __GLXcontext *gc = (__GLXcontext *) glXGetCurrentContext(); + if (NULL == gc) return NULL; + return gc->currentDpy; } #endif -#ifdef GLX_VERSION_1_3 +/*** GLX_VERSION_1_3 ***/ GLXFBConfig *glXChooseFBConfig(Display *dpy, int screen, const int *attribList, int *nitems) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return 0; return (t->ChooseFBConfig)(dpy, screen, attribList, nitems); @@ -369,7 +404,8 @@ GLXFBConfig *glXChooseFBConfig(Display *dpy, int screen, const int *attribList, GLXContext glXCreateNewContext(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return 0; return (t->CreateNewContext)(dpy, config, renderType, shareList, direct); @@ -378,7 +414,8 @@ GLXContext glXCreateNewContext(Display *dpy, GLXFBConfig config, int renderType, GLXPbuffer glXCreatePbuffer(Display *dpy, GLXFBConfig config, const int *attribList) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return 0; return (t->CreatePbuffer)(dpy, config, attribList); @@ -387,7 +424,8 @@ GLXPbuffer glXCreatePbuffer(Display *dpy, GLXFBConfig config, const int *attribL GLXPixmap glXCreatePixmap(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return 0; return (t->CreatePixmap)(dpy, config, pixmap, attribList); @@ -396,7 +434,8 @@ GLXPixmap glXCreatePixmap(Display *dpy, GLXFBConfig config, Pixmap pixmap, const GLXWindow glXCreateWindow(Display *dpy, GLXFBConfig config, Window win, const int *attribList) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return 0; return (t->CreateWindow)(dpy, config, win, attribList); @@ -405,7 +444,8 @@ GLXWindow glXCreateWindow(Display *dpy, GLXFBConfig config, Window win, const in void glXDestroyPbuffer(Display *dpy, GLXPbuffer pbuf) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return; (t->DestroyPbuffer)(dpy, pbuf); @@ -414,7 +454,8 @@ void glXDestroyPbuffer(Display *dpy, GLXPbuffer pbuf) void glXDestroyPixmap(Display *dpy, GLXPixmap pixmap) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return; (t->DestroyPixmap)(dpy, pixmap); @@ -423,22 +464,29 @@ void glXDestroyPixmap(Display *dpy, GLXPixmap pixmap) void glXDestroyWindow(Display *dpy, GLXWindow window) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return; (t->DestroyWindow)(dpy, window); } +#ifdef GLX_BUILT_IN_XMESA +/* Use the glXGetCurrentReadDrawable() function from libGL */ +#else GLXDrawable glXGetCurrentReadDrawable(void) { - return CurrentReadDrawable; + __GLXcontext *gc = (__GLXcontext *) glXGetCurrentContext(); + return gc ? gc->currentReadable : 0; } +#endif int glXGetFBConfigAttrib(Display *dpy, GLXFBConfig config, int attribute, int *value) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return GLX_NO_EXTENSION; return (t->GetFBConfigAttrib)(dpy, config, attribute, value); @@ -447,7 +495,8 @@ int glXGetFBConfigAttrib(Display *dpy, GLXFBConfig config, int attribute, int *v GLXFBConfig *glXGetFBConfigs(Display *dpy, int screen, int *nelements) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return 0; return (t->GetFBConfigs)(dpy, screen, nelements); @@ -455,7 +504,8 @@ GLXFBConfig *glXGetFBConfigs(Display *dpy, int screen, int *nelements) void glXGetSelectedEvent(Display *dpy, GLXDrawable drawable, unsigned long *mask) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return; (t->GetSelectedEvent)(dpy, drawable, mask); @@ -464,7 +514,8 @@ void glXGetSelectedEvent(Display *dpy, GLXDrawable drawable, unsigned long *mask XVisualInfo *glXGetVisualFromFBConfig(Display *dpy, GLXFBConfig config) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return NULL; return (t->GetVisualFromFBConfig)(dpy, config); @@ -473,24 +524,25 @@ XVisualInfo *glXGetVisualFromFBConfig(Display *dpy, GLXFBConfig config) Bool glXMakeContextCurrent(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx) { - struct _glxapi_table *t = get_dispatch(dpy); Bool b; + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return False; b = (t->MakeContextCurrent)(dpy, draw, read, ctx); +#ifndef GLX_BUILT_IN_XMESA if (b) { - CurrentDisplay = dpy; CurrentContext = ctx; - CurrentDrawable = draw; - CurrentReadDrawable = read; } +#endif return b; } int glXQueryContext(Display *dpy, GLXContext ctx, int attribute, int *value) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); assert(t); if (!t) return 0; /* XXX correct? */ @@ -500,7 +552,8 @@ int glXQueryContext(Display *dpy, GLXContext ctx, int attribute, int *value) void glXQueryDrawable(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return; (t->QueryDrawable)(dpy, draw, attribute, value); @@ -509,45 +562,133 @@ void glXQueryDrawable(Display *dpy, GLXDrawable draw, int attribute, unsigned in void glXSelectEvent(Display *dpy, GLXDrawable drawable, unsigned long mask) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return; (t->SelectEvent)(dpy, drawable, mask); } -#endif /* GLX_VERSION_1_3 */ -#ifdef GLX_EXT_import_context +/*** GLX_SGI_swap_control ***/ -void glXFreeContextEXT(Display *dpy, GLXContext context) +int glXSwapIntervalSGI(int interval) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + Display *dpy = glXGetCurrentDisplay(); + GET_DISPATCH(dpy, t); if (!t) - return; - (t->FreeContextEXT)(dpy, context); + return 0; + return (t->SwapIntervalSGI)(interval); } -GLXContextID glXGetContextIDEXT(const GLXContext context) + +/*** GLX_SGI_video_sync ***/ + +int glXGetVideoSyncSGI(unsigned int *count) { - /* XXX is this function right? */ - struct _glxapi_table *t = get_dispatch(CurrentDisplay); + struct _glxapi_table *t; + Display *dpy = glXGetCurrentDisplay(); + GET_DISPATCH(dpy, t); if (!t) return 0; - return (t->GetContextIDEXT)(context); + return (t->GetVideoSyncSGI)(count); } +int glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count) +{ + struct _glxapi_table *t; + Display *dpy = glXGetCurrentDisplay(); + GET_DISPATCH(dpy, t); + if (!t) + return 0; + return (t->WaitVideoSyncSGI)(divisor, remainder, count); +} -Display *glXGetCurrentDisplayEXT(void) + + +/*** GLX_SGI_make_current_read ***/ + +Bool glXMakeCurrentReadSGI(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx) { - return CurrentDisplay; + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return 0; + return (t->MakeCurrentReadSGI)(dpy, draw, read, ctx); +} + +#ifdef GLX_BUILT_IN_XMESA +/* Use glXGetCurrentReadDrawableSGI() from libGL */ +#else +/* stand-alone Mesa */ +GLXDrawable glXGetCurrentReadDrawableSGI(void) +{ + return glXGetCurrentReadDrawable(); } +#endif + + +#if defined(_VL_H) +GLXVideoSourceSGIX glXCreateGLXVideoSourceSGIX(Display *dpy, int screen, VLServer server, VLPath path, int nodeClass, VLNode drainNode) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return 0; + return (t->CreateGLXVideoSourceSGIX)(dpy, screen, server, path, nodeClass, drainNode); +} + +void glXDestroyGLXVideoSourceSGIX(Display *dpy, GLXVideoSourceSGIX src) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return 0; + return (t->DestroyGLXVideoSourceSGIX)(dpy, src); +} + +#endif + + +/*** GLX_EXT_import_context ***/ + +void glXFreeContextEXT(Display *dpy, GLXContext context) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return; + (t->FreeContextEXT)(dpy, context); +} + +#ifdef GLX_BUILT_IN_XMESA +/* Use real libGL's glXGetContextIDEXT() function */ +#else +/* stand-alone Mesa */ +GLXContextID glXGetContextIDEXT(const GLXContext context) +{ + return ((__GLXcontext *) context)->xid; +} +#endif + +#ifdef GLX_BUILT_IN_XMESA +/* Use real libGL's glXGetCurrentDisplayEXT() function */ +#else +/* stand-alone Mesa */ +Display *glXGetCurrentDisplayEXT(void) +{ + return glXGetCurrentDisplay(); +} +#endif GLXContext glXImportContextEXT(Display *dpy, GLXContextID contextID) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return 0; return (t->ImportContextEXT)(dpy, contextID); @@ -555,87 +696,296 @@ GLXContext glXImportContextEXT(Display *dpy, GLXContextID contextID) int glXQueryContextInfoEXT(Display *dpy, GLXContext context, int attribute,int *value) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return 0; /* XXX ok? */ return (t->QueryContextInfoEXT)(dpy, context, attribute, value); } -#endif -#ifdef GLX_SGI_video_sync +/*** GLX_SGIX_fbconfig ***/ -int glXGetVideoSyncSGI(unsigned int *count) +int glXGetFBConfigAttribSGIX(Display *dpy, GLXFBConfigSGIX config, int attribute, int *value) { - struct _glxapi_table *t = get_dispatch(CurrentDisplay); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return 0; - return (t->GetVideoSyncSGI)(count); + return (t->GetFBConfigAttribSGIX)(dpy, config, attribute, value); } +GLXFBConfigSGIX *glXChooseFBConfigSGIX(Display *dpy, int screen, int *attrib_list, int *nelements) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return 0; + return (t->ChooseFBConfigSGIX)(dpy, screen, attrib_list, nelements); +} -int glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count) +GLXPixmap glXCreateGLXPixmapWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, Pixmap pixmap) { - struct _glxapi_table *t = get_dispatch(CurrentDisplay); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return 0; - return (t->WaitVideoSyncSGI)(divisor, remainder, count); + return (t->CreateGLXPixmapWithConfigSGIX)(dpy, config, pixmap); +} + +GLXContext glXCreateContextWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return 0; + return (t->CreateContextWithConfigSGIX)(dpy, config, render_type, share_list, direct); +} + +XVisualInfo * glXGetVisualFromFBConfigSGIX(Display *dpy, GLXFBConfigSGIX config) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return 0; + return (t->GetVisualFromFBConfigSGIX)(dpy, config); +} + +GLXFBConfigSGIX glXGetFBConfigFromVisualSGIX(Display *dpy, XVisualInfo *vis) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return 0; + return (t->GetFBConfigFromVisualSGIX)(dpy, vis); +} + + + +/*** GLX_SGIX_pbuffer ***/ + +GLXPbufferSGIX glXCreateGLXPbufferSGIX(Display *dpy, GLXFBConfigSGIX config, unsigned int width, unsigned int height, int *attrib_list) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return 0; + return (t->CreateGLXPbufferSGIX)(dpy, config, width, height, attrib_list); +} + +void glXDestroyGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return; + (t->DestroyGLXPbufferSGIX)(dpy, pbuf); +} + +int glXQueryGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf, int attribute, unsigned int *value) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return 0; + return (t->QueryGLXPbufferSGIX)(dpy, pbuf, attribute, value); +} + +void glXSelectEventSGIX(Display *dpy, GLXDrawable drawable, unsigned long mask) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return; + (t->SelectEventSGIX)(dpy, drawable, mask); +} + +void glXGetSelectedEventSGIX(Display *dpy, GLXDrawable drawable, unsigned long *mask) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return; + (t->GetSelectedEventSGIX)(dpy, drawable, mask); +} + + + +/*** GLX_SGI_cushion ***/ + +void glXCushionSGI(Display *dpy, Window win, float cushion) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return; + (t->CushionSGI)(dpy, win, cushion); +} + + + +/*** GLX_SGIX_video_resize ***/ + +int glXBindChannelToWindowSGIX(Display *dpy, int screen, int channel , Window window) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return 0; + return (t->BindChannelToWindowSGIX)(dpy, screen, channel, window); +} + +int glXChannelRectSGIX(Display *dpy, int screen, int channel, int x, int y, int w, int h) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return 0; + return (t->ChannelRectSGIX)(dpy, screen, channel, x, y, w, h); +} + +int glXQueryChannelRectSGIX(Display *dpy, int screen, int channel, int *x, int *y, int *w, int *h) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return 0; + return (t->QueryChannelRectSGIX)(dpy, screen, channel, x, y, w, h); +} + +int glXQueryChannelDeltasSGIX(Display *dpy, int screen, int channel, int *dx, int *dy, int *dw, int *dh) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return 0; + return (t->QueryChannelDeltasSGIX)(dpy, screen, channel, dx, dy, dw, dh); +} + +int glXChannelRectSyncSGIX(Display *dpy, int screen, int channel, GLenum synctype) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return 0; + return (t->ChannelRectSyncSGIX)(dpy, screen, channel, synctype); +} + + + +#if defined(_DM_BUFFER_H_) + +Bool glXAssociateDMPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuffer, DMparams *params, DMbuffer dmbuffer) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return False; + return (t->AssociateDMPbufferSGIX)(dpy, pbuffer, params, dmbuffer); } #endif -#ifdef GLX_MESA_copy_sub_buffer +/*** GLX_SGIX_swap_group ***/ + +void glXJoinSwapGroupSGIX(Display *dpy, GLXDrawable drawable, GLXDrawable member) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return; + (*t->JoinSwapGroupSGIX)(dpy, drawable, member); +} + + +/*** GLX_SGIX_swap_barrier ***/ + +void glXBindSwapBarrierSGIX(Display *dpy, GLXDrawable drawable, int barrier) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return; + (*t->BindSwapBarrierSGIX)(dpy, drawable, barrier); +} + +Bool glXQueryMaxSwapBarriersSGIX(Display *dpy, int screen, int *max) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return False; + return (*t->QueryMaxSwapBarriersSGIX)(dpy, screen, max); +} + + + +/*** GLX_SUN_get_transparent_index ***/ + +Status glXGetTransparentIndexSUN(Display *dpy, Window overlay, Window underlay, long *pTransparent) +{ + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); + if (!t) + return False; + return (*t->GetTransparentIndexSUN)(dpy, overlay, underlay, pTransparent); +} + + + +/*** GLX_MESA_copy_sub_buffer ***/ void glXCopySubBufferMESA(Display *dpy, GLXDrawable drawable, int x, int y, int width, int height) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return; (t->CopySubBufferMESA)(dpy, drawable, x, y, width, height); } -#endif -#ifdef GLX_MESA_release_buffers +/*** GLX_MESA_release_buffers ***/ Bool glXReleaseBuffersMESA(Display *dpy, Window w) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return False; return (t->ReleaseBuffersMESA)(dpy, w); } -#endif -#ifdef GLX_MESA_pixmap_colormap +/*** GLX_MESA_pixmap_colormap ***/ GLXPixmap glXCreateGLXPixmapMESA(Display *dpy, XVisualInfo *visinfo, Pixmap pixmap, Colormap cmap) { - struct _glxapi_table *t = get_dispatch(dpy); + struct _glxapi_table *t; + GET_DISPATCH(dpy, t); if (!t) return 0; return (t->CreateGLXPixmapMESA)(dpy, visinfo, pixmap, cmap); } -#endif -#ifdef GLX_MESA_set_3dfx_mode +/*** GLX_MESA_set_3dfx_mode ***/ -GLboolean glXSet3DfxModeMESA(GLint mode) +Bool glXSet3DfxModeMESA(int mode) { - struct _glxapi_table *t = get_dispatch(CurrentDisplay); + struct _glxapi_table *t; + Display *dpy = glXGetCurrentDisplay(); + GET_DISPATCH(dpy, t); if (!t) return False; return (t->Set3DfxModeMESA)(mode); } -#endif @@ -714,6 +1064,142 @@ _glxapi_set_no_op_table(struct _glxapi_table *t) } +#if 00 +/* + * Open the named library and use dlsym() to populate the given dispatch + * table with GLX function pointers. + * Return: true = all OK + * false = can't open libName or can't get required GLX function + */ +GLboolean +_glxapi_load_library_table(const char *libName, struct _glxapi_table *t) +{ + void *libHandle; + void **entry; /* used to avoid a lot of cast/type warnings */ + + libHandle = dlopen(libName, 0); + if (!libHandle) { + return GL_FALSE; + } + +#define GET_REQ_FUNCTION(ENTRY, NAME) \ + entry = (void **) &(t->ENTRY); \ + *entry = dlsym(libHandle, NAME); \ + if (!*entry) { \ + fprintf(stderr, "libGL Error: couldn't load %s from %s\n", \ + NAME, libName); \ + dlclose(libHandle); \ + return GL_FALSE; \ + } + + /* 1.0 and 1.1 functions */ + GET_REQ_FUNCTION(ChooseVisual, "glXChooseVisual"); + GET_REQ_FUNCTION(CopyContext, "glXCopyContext"); + GET_REQ_FUNCTION(CreateContext, "glXCreateContext"); + GET_REQ_FUNCTION(CreateGLXPixmap, "glXCreateGLXPixmap"); + GET_REQ_FUNCTION(DestroyContext, "glXDestroyContext"); + GET_REQ_FUNCTION(GetConfig, "glXGetConfig"); + GET_REQ_FUNCTION(IsDirect, "glXIsDirect"); + GET_REQ_FUNCTION(MakeCurrent, "glXMakeCurrent"); + GET_REQ_FUNCTION(QueryExtension, "glXQueryExtension"); + GET_REQ_FUNCTION(QueryVersion, "glXQueryVersion"); + GET_REQ_FUNCTION(SwapBuffers, "glXSwapBuffers"); + GET_REQ_FUNCTION(UseXFont, "glXUseXFont"); + GET_REQ_FUNCTION(WaitGL, "glXWaitGL"); + GET_REQ_FUNCTION(WaitX, "glXWaitX"); + GET_REQ_FUNCTION(GetClientString, "glXGetClientString"); + GET_REQ_FUNCTION(QueryExtensionsString, "glXQueryExtensionsString"); + GET_REQ_FUNCTION(QueryServerString, "glXQueryServerString"); + +#define GET_OPT_FUNCTION(ENTRY, NAME) \ + entry = (void **) &(t->ENTRY); \ + *entry = dlsym(libHandle, NAME); \ + if (!*entry) { \ + *entry = (void *) generic_no_op_func; \ + } + + /* 1.2, 1.3 and extensions */ + GET_OPT_FUNCTION(ChooseFBConfig, "glXChooseFBConfig"); + GET_OPT_FUNCTION(CreateNewContext, "glXCreateNewContext"); + GET_OPT_FUNCTION(CreatePbuffer, "glXCreatePbuffer"); + GET_OPT_FUNCTION(CreatePixmap, "glXCreatePixmap"); + GET_OPT_FUNCTION(CreateWindow, "glXCreateWindow"); + GET_OPT_FUNCTION(DestroyPbuffer, "glXDestroyPbuffer"); + GET_OPT_FUNCTION(DestroyPixmap, "glXDestroyPixmap"); + GET_OPT_FUNCTION(DestroyWindow, "glXDestroyWindow"); + GET_OPT_FUNCTION(GetFBConfigAttrib, "glXGetFBConfigAttrib"); + GET_OPT_FUNCTION(GetFBConfigs, "glXGetFBConfigs"); + GET_OPT_FUNCTION(GetSelectedEvent, "glXGetSelectedEvent"); + GET_OPT_FUNCTION(GetVisualFromFBConfig, "glXGetVisualFromFBConfig"); + GET_OPT_FUNCTION(MakeContextCurrent, "glXMakeContextCurrent"); + GET_OPT_FUNCTION(QueryContext, "glXQueryContext"); + GET_OPT_FUNCTION(QueryDrawable, "glXQueryDrawable"); + GET_OPT_FUNCTION(SelectEvent, "glXSelectEvent"); + /*** GLX_SGI_swap_control ***/ + GET_OPT_FUNCTION(SwapIntervalSGI, "glXSwapIntervalSGI"); + /*** GLX_SGI_video_sync ***/ + GET_OPT_FUNCTION(GetVideoSyncSGI, "glXGetVideoSyncSGI"); + GET_OPT_FUNCTION(WaitVideoSyncSGI, "glXWaitVideoSyncSGI"); + /*** GLX_SGI_make_current_read ***/ + GET_OPT_FUNCTION(MakeCurrentReadSGI, "glXMakeCurrentReadSGI"); + GET_OPT_FUNCTION(GetCurrentReadDrawableSGI, "glXGetCurrentReadDrawableSGI"); + /*** GLX_SGIX_video_source ***/ +#if defined(_VL_H) + GET_OPT_FUNCTION(CreateGLXVideoSourceSGIX, "glXCreateGLXVideoSourceSGIX"); + GET_OPT_FUNCTION(DestroyGLXVideoSourceSGIX, "glXDestroyGLXVideoSourceSGIX"); +#endif + /*** GLX_EXT_import_context ***/ + GET_OPT_FUNCTION(FreeContextEXT, "glXFreeContextEXT"); + GET_OPT_FUNCTION(GetContextIDEXT, "glXGetContextIDEXT"); + GET_OPT_FUNCTION(GetCurrentDisplayEXT, "glXGetCurrentDisplayEXT"); + GET_OPT_FUNCTION(ImportContextEXT, "glXImportContextEXT"); + GET_OPT_FUNCTION(QueryContextInfoEXT, "glXQueryContextInfoEXT"); + /*** GLX_SGIX_fbconfig ***/ + GET_OPT_FUNCTION(GetFBConfigAttribSGIX, "glXGetFBConfigAttribSGIX"); + GET_OPT_FUNCTION(ChooseFBConfigSGIX, "glXChooseFBConfigSGIX"); + GET_OPT_FUNCTION(CreateGLXPixmapWithConfigSGIX, "glXCreateGLXPixmapWithConfigSGIX"); + GET_OPT_FUNCTION(CreateContextWithConfigSGIX, "glXCreateContextWithConfigSGIX"); + GET_OPT_FUNCTION(GetVisualFromFBConfigSGIX, "glXGetVisualFromFBConfigSGIX"); + GET_OPT_FUNCTION(GetFBConfigFromVisualSGIX, "glXGetFBConfigFromVisualSGIX"); + /*** GLX_SGIX_pbuffer ***/ + GET_OPT_FUNCTION(CreateGLXPbufferSGIX, "glXCreateGLXPbufferSGIX"); + GET_OPT_FUNCTION(DestroyGLXPbufferSGIX, "glXDestroyGLXPbufferSGIX"); + GET_OPT_FUNCTION(QueryGLXPbufferSGIX, "glXQueryGLXPbufferSGIX"); + GET_OPT_FUNCTION(SelectEventSGIX, "glXSelectEventSGIX"); + GET_OPT_FUNCTION(GetSelectedEventSGIX, "glXGetSelectedEventSGIX"); + /*** GLX_SGI_cushion ***/ + GET_OPT_FUNCTION(CushionSGI, "glXCushionSGI"); + /*** GLX_SGIX_video_resize ***/ + GET_OPT_FUNCTION(BindChannelToWindowSGIX, "glXBindChannelToWindowSGIX"); + GET_OPT_FUNCTION(ChannelRectSGIX, "glXChannelRectSGIX"); + GET_OPT_FUNCTION(QueryChannelRectSGIX, "glXQueryChannelRectSGIX"); + GET_OPT_FUNCTION(QueryChannelDeltasSGIX, "glXQueryChannelDeltasSGIX"); + GET_OPT_FUNCTION(ChannelRectSyncSGIX, "glXChannelRectSyncSGIX"); + /*** GLX_SGIX_dmbuffer ***/ +#if defined (_DM_BUFFER_H_) + GET_OPT_FUNCTION(AssociateDMPbufferSGIX, "glXAssociateDMPbufferSGIX"); +#endif + /*** GLX_SGIX_swap_group ***/ + GET_OPT_FUNCTION(JoinSwapGroupSGIX, "glXJoinSwapGroupSGIX"); + /*** GLX_SGIX_swap_barrier ***/ + GET_OPT_FUNCTION(BindSwapBarrierSGIX, "glXBindSwapBarrierSGIX"); + GET_OPT_FUNCTION(QueryMaxSwapBarriersSGIX, "glXQueryMaxSwapBarriersSGIX"); + /*** GLX_SUN_get_transparent_index ***/ + GET_OPT_FUNCTION(GetTransparentIndexSUN, "glXGetTransparentIndexSUN"); + /*** GLX_MESA_copy_sub_buffer ***/ + GET_OPT_FUNCTION(CopySubBufferMESA, "glXCopySubBufferMESA"); + /*** GLX_MESA_release_buffers ***/ + GET_OPT_FUNCTION(ReleaseBuffersMESA, "glXReleaseBuffersMESA"); + /*** GLX_MESA_pixmap_colormap ***/ + GET_OPT_FUNCTION(CreateGLXPixmapMESA, "glXCreateGLXPixmapMESA"); + /*** GLX_MESA_set_3dfx_mode ***/ + GET_OPT_FUNCTION(Set3DfxModeMESA, "glXSet3DfxModeMESA"); + + return GL_TRUE; +} +#endif + + struct name_address_pair { const char *Name; @@ -721,6 +1207,7 @@ struct name_address_pair { }; static struct name_address_pair GLX_functions[] = { + /*** GLX_VERSION_1_0 ***/ { "glXChooseVisual", (GLvoid *) glXChooseVisual }, { "glXCopyContext", (GLvoid *) glXCopyContext }, { "glXCreateContext", (GLvoid *) glXCreateContext }, @@ -739,17 +1226,15 @@ static struct name_address_pair GLX_functions[] = { { "glXWaitGL", (GLvoid *) glXWaitGL }, { "glXWaitX", (GLvoid *) glXWaitX }, -#ifdef GLX_VERSION_1_1 + /*** GLX_VERSION_1_1 ***/ { "glXGetClientString", (GLvoid *) glXGetClientString }, { "glXQueryExtensionsString", (GLvoid *) glXQueryExtensionsString }, { "glXQueryServerString", (GLvoid *) glXQueryServerString }, -#endif -#ifdef GLX_VERSION_1_2 + /*** GLX_VERSION_1_2 ***/ { "glXGetCurrentDisplay", (GLvoid *) glXGetCurrentDisplay }, -#endif -#ifdef GLX_VERSION_1_3 + /*** GLX_VERSION_1_3 ***/ { "glXChooseFBConfig", (GLvoid *) glXChooseFBConfig }, { "glXCreateNewContext", (GLvoid *) glXCreateNewContext }, { "glXCreatePbuffer", (GLvoid *) glXCreatePbuffer }, @@ -760,35 +1245,94 @@ static struct name_address_pair GLX_functions[] = { { "glXDestroyWindow", (GLvoid *) glXDestroyWindow }, { "glXGetCurrentReadDrawable", (GLvoid *) glXGetCurrentReadDrawable }, { "glXGetFBConfigAttrib", (GLvoid *) glXGetFBConfigAttrib }, + { "glXGetFBConfigs", (GLvoid *) glXGetFBConfigs }, { "glXGetSelectedEvent", (GLvoid *) glXGetSelectedEvent }, { "glXGetVisualFromFBConfig", (GLvoid *) glXGetVisualFromFBConfig }, { "glXMakeContextCurrent", (GLvoid *) glXMakeContextCurrent }, { "glXQueryContext", (GLvoid *) glXQueryContext }, { "glXQueryDrawable", (GLvoid *) glXQueryDrawable }, { "glXSelectEvent", (GLvoid *) glXSelectEvent }, -#endif -#ifdef GLX_SGI_video_sync + /*** GLX_VERSION_1_4 ***/ + { "glXGetProcAddress", (GLvoid *) glXGetProcAddress }, + + /*** GLX_SGI_swap_control ***/ + { "glXSwapIntervalSGI", (GLvoid *) glXSwapIntervalSGI }, + + /*** GLX_SGI_video_sync ***/ { "glXGetVideoSyncSGI", (GLvoid *) glXGetVideoSyncSGI }, { "glXWaitVideoSyncSGI", (GLvoid *) glXWaitVideoSyncSGI }, -#endif -#ifdef GLX_MESA_copy_sub_buffer - { "glXCopySubBufferMESA", (GLvoid *) glXCopySubBufferMESA }, + /*** GLX_SGI_make_current_read ***/ + { "glXMakeCurrentReadSGI", (GLvoid *) glXMakeCurrentReadSGI }, + { "glXGetCurrentReadDrawableSGI", (GLvoid *) glXGetCurrentReadDrawableSGI }, + + /*** GLX_SGIX_video_source ***/ +#if defined(_VL_H) + { "glXCreateGLXVideoSourceSGIX", (GLvoid *) glXCreateGLXVideoSourceSGIX }, + { "glXDestroyGLXVideoSourceSGIX", (GLvoid *) glXDestroyGLXVideoSourceSGIX }, #endif -#ifdef GLX_MESA_release_buffers - { "glXReleaseBuffersMESA", (GLvoid *) glXReleaseBuffersMESA }, + /*** GLX_EXT_import_context ***/ + { "glXFreeContextEXT", (GLvoid *) glXFreeContextEXT }, + { "glXGetContextIDEXT", (GLvoid *) glXGetContextIDEXT }, + { "glXGetCurrentDisplayEXT", (GLvoid *) glXGetCurrentDisplayEXT }, + { "glXImportContextEXT", (GLvoid *) glXImportContextEXT }, + { "glXQueryContextInfoEXT", (GLvoid *) glXQueryContextInfoEXT }, + + /*** GLX_SGIX_fbconfig ***/ + { "glXGetFBConfigAttribSGIX", (GLvoid *) glXGetFBConfigAttribSGIX }, + { "glXChooseFBConfigSGIX", (GLvoid *) glXChooseFBConfigSGIX }, + { "glXCreateGLXPixmapWithConfigSGIX", (GLvoid *) glXCreateGLXPixmapWithConfigSGIX }, + { "glXCreateContextWithConfigSGIX", (GLvoid *) glXCreateContextWithConfigSGIX }, + { "glXGetVisualFromFBConfigSGIX", (GLvoid *) glXGetVisualFromFBConfigSGIX }, + { "glXGetFBConfigFromVisualSGIX", (GLvoid *) glXGetFBConfigFromVisualSGIX }, + + /*** GLX_SGIX_pbuffer ***/ + { "glXCreateGLXPbufferSGIX", (GLvoid *) glXCreateGLXPbufferSGIX }, + { "glXDestroyGLXPbufferSGIX", (GLvoid *) glXDestroyGLXPbufferSGIX }, + { "glXQueryGLXPbufferSGIX", (GLvoid *) glXQueryGLXPbufferSGIX }, + { "glXSelectEventSGIX", (GLvoid *) glXSelectEventSGIX }, + { "glXGetSelectedEventSGIX", (GLvoid *) glXGetSelectedEventSGIX }, + + /*** GLX_SGI_cushion ***/ + { "glXCushionSGI", (GLvoid *) glXCushionSGI }, + + /*** GLX_SGIX_video_resize ***/ + { "glXBindChannelToWindowSGIX", (GLvoid *) glXBindChannelToWindowSGIX }, + { "glXChannelRectSGIX", (GLvoid *) glXChannelRectSGIX }, + { "glXQueryChannelRectSGIX", (GLvoid *) glXQueryChannelRectSGIX }, + { "glXQueryChannelDeltasSGIX", (GLvoid *) glXQueryChannelDeltasSGIX }, + { "glXChannelRectSyncSGIX", (GLvoid *) glXChannelRectSyncSGIX }, + + /*** GLX_SGIX_dmbuffer **/ +#if defined(_DM_BUFFER_H_) + { "glXAssociateDMPbufferSGIX", (GLvoid *) glXAssociateDMPbufferSGIX }, #endif -#ifdef GLX_MESA_pixmap_colormap + /*** GLX_SGIX_swap_group ***/ + { "glXJoinSwapGroupSGIX", (GLvoid *) glXJoinSwapGroupSGIX }, + + /*** GLX_SGIX_swap_barrier ***/ + { "glXBindSwapBarrierSGIX", (GLvoid *) glXBindSwapBarrierSGIX }, + { "glXQueryMaxSwapBarriersSGIX", (GLvoid *) glXQueryMaxSwapBarriersSGIX }, + + /*** GLX_SUN_get_transparent_index ***/ + { "glXGetTransparentIndexSUN", (GLvoid *) glXGetTransparentIndexSUN }, + + /*** GLX_MESA_copy_sub_buffer ***/ + { "glXCopySubBufferMESA", (GLvoid *) glXCopySubBufferMESA }, + + /*** GLX_MESA_pixmap_colormap ***/ { "glXCreateGLXPixmapMESA", (GLvoid *) glXCreateGLXPixmapMESA }, -#endif -#ifdef GLX_MESA_set_3dfx_mode + /*** GLX_MESA_release_buffers ***/ + { "glXReleaseBuffersMESA", (GLvoid *) glXReleaseBuffersMESA }, + + /*** GLX_MESA_set_3dfx_mode ***/ { "glXSet3DfxModeMESA", (GLvoid *) glXSet3DfxModeMESA }, -#endif + /*** GLX_ARB_get_proc_address ***/ { "glXGetProcAddressARB", (GLvoid *) glXGetProcAddressARB }, { NULL, NULL } /* end of list */ @@ -829,3 +1373,10 @@ void (*glXGetProcAddressARB(const GLubyte *procName))() f = (gl_function) _glapi_get_proc_address((const char *) procName); return f; } + + +/* GLX 1.4 */ +void (*glXGetProcAddress(const GLubyte *procName))() +{ + return glXGetProcAddressARB(procName); +} |