/* * Mesa 3-D graphics library * * Copyright (C) 1999-2007 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"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* * This is the GLX API dispatcher. It uses a dispatch table but that's * not really needed anymore since the table always points to the "fake" * GLX functions. */ #include #include #include #include #include "main/glheader.h" #include "glapi/glapi.h" #include "glxapi.h" extern struct _glxapi_table *_mesa_GetGLXDispatchTable(void); struct display_dispatch { Display *Dpy; struct _glxapi_table *Table; struct display_dispatch *Next; }; /** * When GLX_INDIRECT_RENDERING is defined, some symbols are missing in * libglapi.a. We need to define them here. */ #ifdef GLX_INDIRECT_RENDERING #include "glapi/glapitable.h" #define KEYWORD1 PUBLIC #if defined(USE_MGL_NAMESPACE) #define NAME(func) mgl##func #else #define NAME(func) gl##func #endif #define DISPATCH(FUNC, ARGS, MESSAGE) \ GET_DISPATCH()->FUNC ARGS #define RETURN_DISPATCH(FUNC, ARGS, MESSAGE) \ return GET_DISPATCH()->FUNC ARGS /* skip normal ones */ #define _GLAPI_SKIP_NORMAL_ENTRY_POINTS #include "glapi/glapitemp.h" #endif /* GLX_INDIRECT_RENDERING */ 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) { if (!dpy) return NULL; /* search list of display/dispatch pairs for this display */ { const struct display_dispatch *d = DispatchList; while (d) { if (d->Dpy == dpy) { prevDisplay = dpy; prevTable = d->Table; return d->Table; /* done! */ } d = d->Next; } } /* Setup the dispatch table */ { struct _glxapi_table *t = _mesa_GetGLXDispatchTable(); if (t) { struct display_dispatch *d; d = malloc(sizeof(struct display_dispatch)); if (d) { d->Dpy = dpy; d->Table = t; /* insert at head of list */ d->Next = DispatchList; DispatchList = d; /* update cache */ prevDisplay = dpy; prevTable = t; return t; } } } return NULL; } /* Don't use the GET_DISPATCH macro */ #undef GET_DISPATCH #define GET_DISPATCH(DPY, TABLE) \ if (DPY == prevDisplay) { \ TABLE = prevTable; \ } \ else if (!DPY) { \ TABLE = NULL; \ } \ else { \ TABLE = get_dispatch(DPY); \ } /* * GLX API entrypoints */ /*** GLX_VERSION_1_0 ***/ XVisualInfo PUBLIC * glXChooseVisual(Display *dpy, int screen, int *list) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return NULL; return t->ChooseVisual(dpy, screen, list); } void PUBLIC glXCopyContext(Display *dpy, GLXContext src, GLXContext dst, unsigned long mask) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return; t->CopyContext(dpy, src, dst, mask); } GLXContext PUBLIC glXCreateContext(Display *dpy, XVisualInfo *visinfo, GLXContext shareList, Bool direct) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return 0; return t->CreateContext(dpy, visinfo, shareList, direct); } GLXPixmap PUBLIC glXCreateGLXPixmap(Display *dpy, XVisualInfo *visinfo, Pixmap pixmap) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return 0; return t->CreateGLXPixmap(dpy, visinfo, pixmap); } void PUBLIC glXDestroyContext(Display *dpy, GLXContext ctx) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return; t->DestroyContext(dpy, ctx); } void PUBLIC glXDestroyGLXPixmap(Display *dpy, GLXPixmap pixmap) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return; t->DestroyGLXPixmap(dpy, pixmap); } int PUBLIC glXGetConfig(Display *dpy, XVisualInfo *visinfo, int attrib, int *value) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return GLX_NO_EXTENSION; return t->GetConfig(dpy, visinfo, attrib, value); } /* declare here to avoid including xmesa.h */ extern void *XMesaGetCurrentContext(void); GLXContext PUBLIC glXGetCurrentContext(void) { return (GLXContext) XMesaGetCurrentContext(); } GLXDrawable PUBLIC glXGetCurrentDrawable(void) { __GLXcontext *gc = (__GLXcontext *) glXGetCurrentContext(); return gc ? gc->currentDrawable : 0; } Bool PUBLIC glXIsDirect(Display *dpy, GLXContext ctx) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return False; return t->IsDirect(dpy, ctx); } Bool PUBLIC glXMakeCurrent(Display *dpy, GLXDrawable drawable, GLXContext ctx) { Bool b; struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) { return False; } b = t->MakeCurrent(dpy, drawable, ctx); return b; } Bool PUBLIC glXQueryExtension(Display *dpy, int *errorb, int *event) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return False; return t->QueryExtension(dpy, errorb, event); } Bool PUBLIC glXQueryVersion(Display *dpy, int *maj, int *min) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return False; return t->QueryVersion(dpy, maj, min); } void PUBLIC glXSwapBuffers(Display *dpy, GLXDrawable drawable) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return; t->SwapBuffers(dpy, drawable); } void PUBLIC glXUseXFont(Font font, int first, int count, int listBase) { struct _glxapi_table *t; Display *dpy = glXGetCurrentDisplay(); GET_DISPATCH(dpy, t); if (!t) return; t->UseXFont(font, first, count, listBase); } void PUBLIC glXWaitGL(void) { struct _glxapi_table *t; Display *dpy = glXGetCurrentDisplay(); GET_DISPATCH(dpy, t); if (!t) return; t->WaitGL(); } void PUBLIC glXWaitX(void) { struct _glxapi_table *t; Display *dpy = glXGetCurrentDisplay(); GET_DISPATCH(dpy, t); if (!t) return; t->WaitX(); } /*** GLX_VERSION_1_1 ***/ const char PUBLIC * glXGetClientString(Display *dpy, int name) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return NULL; return t->GetClientString(dpy, name); } const char PUBLIC * glXQueryExtensionsString(Display *dpy, int screen) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return NULL; return t->QueryExtensionsString(dpy, screen); } const char PUBLIC * glXQueryServerString(Display *dpy, int screen, int name) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return NULL; return t->QueryServerString(dpy, screen, name); } /*** GLX_VERSION_1_2 ***/ /* declare here to avoid including xmesa.h */ extern Display *XMesaGetCurrentDisplay(void); Display PUBLIC * glXGetCurrentDisplay(void) { return XMesaGetCurrentDisplay(); } /*** GLX_VERSION_1_3 ***/ GLXFBConfig PUBLIC * glXChooseFBConfig(Display *dpy, int screen, const int *attribList, int *nitems) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return 0; return t->ChooseFBConfig(dpy, screen, attribList, nitems); } GLXContext PUBLIC glXCreateNewContext(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return 0; return t->CreateNewContext(dpy, config, renderType, shareList, direct); } GLXPbuffer PUBLIC glXCreatePbuffer(Display *dpy, GLXFBConfig config, const int *attribList) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return 0; return t->CreatePbuffer(dpy, config, attribList); } GLXPixmap PUBLIC glXCreatePixmap(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return 0; return t->CreatePixmap(dpy, config, pixmap, attribList); } GLXWindow PUBLIC glXCreateWindow(Display *dpy, GLXFBConfig config, Window win, const int *attribList) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return 0; return t->CreateWindow(dpy, config, win, attribList); } void PUBLIC glXDestroyPbuffer(Display *dpy, GLXPbuffer pbuf) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return; t->DestroyPbuffer(dpy, pbuf); } void PUBLIC glXDestroyPixmap(Display *dpy, GLXPixmap pixmap) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return; t->DestroyPixmap(dpy, pixmap); } void PUBLIC glXDestroyWindow(Display *dpy, GLXWindow window) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return; t->DestroyWindow(dpy, window); } GLXDrawable PUBLIC glXGetCurrentReadDrawable(void) { __GLXcontext *gc = (__GLXcontext *) glXGetCurrentContext(); return gc ? gc->currentReadable : 0; } int PUBLIC glXGetFBConfigAttrib(Display *dpy, GLXFBConfig config, int attribute, int *value) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return GLX_NO_EXTENSION; return t->GetFBConfigAttrib(dpy, config, attribute, value); } GLXFBConfig PUBLIC * glXGetFBConfigs(Display *dpy, int screen, int *nelements) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return 0; return t->GetFBConfigs(dpy, screen, nelements); } void PUBLIC glXGetSelectedEvent(Display *dpy, GLXDrawable drawable, unsigned long *mask) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return; t->GetSelectedEvent(dpy, drawable, mask); } XVisualInfo PUBLIC * glXGetVisualFromFBConfig(Display *dpy, GLXFBConfig config) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return NULL; return t->GetVisualFromFBConfig(dpy, config); } Bool PUBLIC glXMakeContextCurrent(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx) { Bool b; struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return False; b = t->MakeContextCurrent(dpy, draw, read, ctx); return b; } int PUBLIC glXQueryContext(Display *dpy, GLXContext ctx, int attribute, int *value) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); assert(t); if (!t) return 0; /* XXX correct? */ return t->QueryContext(dpy, ctx, attribute, value); } void PUBLIC glXQueryDrawable(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return; t->QueryDrawable(dpy, draw, attribute, value); } void PUBLIC glXSelectEvent(Display *dpy, GLXDrawable drawable, unsigned long mask) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return; t->SelectEvent(dpy, drawable, mask); } /*** GLX_SGI_swap_control ***/ int PUBLIC glXSwapIntervalSGI(int interval) { struct _glxapi_table *t; Display *dpy = glXGetCurrentDisplay(); GET_DISPATCH(dpy, t); if (!t) return 0; return t->SwapIntervalSGI(interval); } /*** GLX_SGI_video_sync ***/ int PUBLIC glXGetVideoSyncSGI(unsigned int *count) { struct _glxapi_table *t; Display *dpy = glXGetCurrentDisplay(); GET_DISPATCH(dpy, t); if (!t || !glXGetCurrentContext()) return GLX_BAD_CONTEXT; return t->GetVideoSyncSGI(count); } int PUBLIC glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count) { struct _glxapi_table *t; Display *dpy = glXGetCurrentDisplay(); GET_DISPATCH(dpy, t); if (!t || !glXGetCurrentContext()) return GLX_BAD_CONTEXT; return t->WaitVideoSyncSGI(divisor, remainder, count); } /*** GLX_SGI_make_current_read ***/ Bool PUBLIC glXMakeCurrentReadSGI(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return False; return t->MakeCurrentReadSGI(dpy, draw, read, ctx); } GLXDrawable PUBLIC glXGetCurrentReadDrawableSGI(void) { return glXGetCurrentReadDrawable(); } #if defined(_VL_H) GLXVideoSourceSGIX PUBLIC 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 PUBLIC 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 PUBLIC glXFreeContextEXT(Display *dpy, GLXContext context) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return; t->FreeContextEXT(dpy, context); } GLXContextID PUBLIC glXGetContextIDEXT(const GLXContext context) { return ((__GLXcontext *) context)->xid; } Display PUBLIC * glXGetCurrentDisplayEXT(void) { return glXGetCurrentDisplay(); } GLXContext PUBLIC glXImportContextEXT(Display *dpy, GLXContextID contextID) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return 0; return t->ImportContextEXT(dpy, contextID); } int PUBLIC glXQueryContextInfoEXT(Display *dpy, GLXContext context, int attribute,int *value) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return 0; /* XXX ok? */ return t->QueryContextInfoEXT(dpy, context, attribute, value); } /*** GLX_SGIX_fbconfig ***/ int PUBLIC glXGetFBConfigAttribSGIX(Display *dpy, GLXFBConfigSGIX config, int attribute, int *value) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return 0; return t->GetFBConfigAttribSGIX(dpy, config, attribute, value); } GLXFBConfigSGIX PUBLIC * 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); } GLXPixmap PUBLIC glXCreateGLXPixmapWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, Pixmap pixmap) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return 0; return t->CreateGLXPixmapWithConfigSGIX(dpy, config, pixmap); } GLXContext PUBLIC 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 PUBLIC * glXGetVisualFromFBConfigSGIX(Display *dpy, GLXFBConfigSGIX config) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return 0; return t->GetVisualFromFBConfigSGIX(dpy, config); } GLXFBConfigSGIX PUBLIC 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 PUBLIC 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 PUBLIC glXDestroyGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return; t->DestroyGLXPbufferSGIX(dpy, pbuf); } int PUBLIC 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 PUBLIC 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 PUBLIC 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 PUBLIC 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 PUBLIC 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 PUBLIC 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 PUBLIC 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 PUBLIC 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 PUBLIC 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 PUBLIC 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 /*** GLX_SGIX_swap_group ***/ void PUBLIC 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 PUBLIC glXBindSwapBarrierSGIX(Display *dpy, GLXDrawable drawable, int barrier) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return; t->BindSwapBarrierSGIX(dpy, drawable, barrier); } Bool PUBLIC 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 PUBLIC 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 PUBLIC glXCopySubBufferMESA(Display *dpy, GLXDrawable drawable, int x, int y, int width, int height) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return; t->CopySubBufferMESA(dpy, drawable, x, y, width, height); } /*** GLX_MESA_release_buffers ***/ Bool PUBLIC glXReleaseBuffersMESA(Display *dpy, Window w) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return False; return t->ReleaseBuffersMESA(dpy, w); } /*** GLX_MESA_pixmap_colormap ***/ GLXPixmap PUBLIC glXCreateGLXPixmapMESA(Display *dpy, XVisualInfo *visinfo, Pixmap pixmap, Colormap cmap) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return 0; return t->CreateGLXPixmapMESA(dpy, visinfo, pixmap, cmap); } /*** GLX_EXT_texture_from_pixmap */ void PUBLIC glXBindTexImageEXT(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (t) t->BindTexImageEXT(dpy, drawable, buffer, attrib_list); } void PUBLIC glXReleaseTexImageEXT(Display *dpy, GLXDrawable drawable, int buffer) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (t) t->ReleaseTexImageEXT(dpy, drawable, buffer); } /**********************************************************************/ /* GLX API management functions */ /**********************************************************************/ const char * _glxapi_get_version(void) { return "1.3"; } /* * Return array of extension strings. */ const char ** _glxapi_get_extensions(void) { static const char *extensions[] = { "GLX_EXT_import_context", "GLX_SGI_video_sync", "GLX_MESA_copy_sub_buffer", "GLX_MESA_release_buffers", "GLX_MESA_pixmap_colormap", "GLX_SGIX_fbconfig", "GLX_SGIX_pbuffer", "GLX_EXT_texture_from_pixmap", "GLX_INTEL_swap_event", NULL }; return extensions; } /* * Return size of the GLX dispatch table, in entries, not bytes. */ GLuint _glxapi_get_dispatch_table_size(void) { return sizeof(struct _glxapi_table) / sizeof(void *); } static int generic_no_op_func(void) { return 0; } /* * Initialize all functions in given dispatch table to be no-ops */ void _glxapi_set_no_op_table(struct _glxapi_table *t) { typedef int (*nop_func)(void); nop_func *dispatch = (nop_func *) t; GLuint n = _glxapi_get_dispatch_table_size(); GLuint i; for (i = 0; i < n; i++) { dispatch[i] = generic_no_op_func; } } struct name_address_pair { const char *Name; __GLXextFuncPtr Address; }; static struct name_address_pair GLX_functions[] = { /*** GLX_VERSION_1_0 ***/ { "glXChooseVisual", (__GLXextFuncPtr) glXChooseVisual }, { "glXCopyContext", (__GLXextFuncPtr) glXCopyContext }, { "glXCreateContext", (__GLXextFuncPtr) glXCreateContext }, { "glXCreateGLXPixmap", (__GLXextFuncPtr) glXCreateGLXPixmap }, { "glXDestroyContext", (__GLXextFuncPtr) glXDestroyContext }, { "glXDestroyGLXPixmap", (__GLXextFuncPtr) glXDestroyGLXPixmap }, { "glXGetConfig", (__GLXextFuncPtr) glXGetConfig }, { "glXGetCurrentContext", (__GLXextFuncPtr) glXGetCurrentContext }, { "glXGetCurrentDrawable", (__GLXextFuncPtr) glXGetCurrentDrawable }, { "glXIsDirect", (__GLXextFuncPtr) glXIsDirect }, { "glXMakeCurrent", (__GLXextFuncPtr) glXMakeCurrent }, { "glXQueryExtension", (__GLXextFuncPtr) glXQueryExtension }, { "glXQueryVersion", (__GLXextFuncPtr) glXQueryVersion }, { "glXSwapBuffers", (__GLXextFuncPtr) glXSwapBuffers }, { "glXUseXFont", (__GLXextFuncPtr) glXUseXFont }, { "glXWaitGL", (__GLXextFuncPtr) glXWaitGL }, { "glXWaitX", (__GLXextFuncPtr) glXWaitX }, /*** GLX_VERSION_1_1 ***/ { "glXGetClientString", (__GLXextFuncPtr) glXGetClientString }, { "glXQueryExtensionsString", (__GLXextFuncPtr) glXQueryExtensionsString }, { "glXQueryServerString", (__GLXextFuncPtr) glXQueryServerString }, /*** GLX_VERSION_1_2 ***/ { "glXGetCurrentDisplay", (__GLXextFuncPtr) glXGetCurrentDisplay }, /*** GLX_VERSION_1_3 ***/ { "glXChooseFBConfig", (__GLXextFuncPtr) glXChooseFBConfig }, { "glXCreateNewContext", (__GLXextFuncPtr) glXCreateNewContext }, { "glXCreatePbuffer", (__GLXextFuncPtr) glXCreatePbuffer }, { "glXCreatePixmap", (__GLXextFuncPtr) glXCreatePixmap }, { "glXCreateWindow", (__GLXextFuncPtr) glXCreateWindow }, { "glXDestroyPbuffer", (__GLXextFuncPtr) glXDestroyPbuffer }, { "glXDestroyPixmap", (__GLXextFuncPtr) glXDestroyPixmap }, { "glXDestroyWindow", (__GLXextFuncPtr) glXDestroyWindow }, { "glXGetCurrentReadDrawable", (__GLXextFuncPtr) glXGetCurrentReadDrawable }, { "glXGetFBConfigAttrib", (__GLXextFuncPtr) glXGetFBConfigAttrib }, { "glXGetFBConfigs", (__GLXextFuncPtr) glXGetFBConfigs }, { "glXGetSelectedEvent", (__GLXextFuncPtr) glXGetSelectedEvent }, { "glXGetVisualFromFBConfig", (__GLXextFuncPtr) glXGetVisualFromFBConfig }, { "glXMakeContextCurrent", (__GLXextFuncPtr) glXMakeContextCurrent }, { "glXQueryContext", (__GLXextFuncPtr) glXQueryContext }, { "glXQueryDrawable", (__GLXextFuncPtr) glXQueryDrawable }, { "glXSelectEvent", (__GLXextFuncPtr) glXSelectEvent }, /*** GLX_VERSION_1_4 ***/ { "glXGetProcAddress", (__GLXextFuncPtr) glXGetProcAddress }, /*** GLX_SGI_swap_control ***/ { "glXSwapIntervalSGI", (__GLXextFuncPtr) glXSwapIntervalSGI }, /*** GLX_SGI_video_sync ***/ { "glXGetVideoSyncSGI", (__GLXextFuncPtr) glXGetVideoSyncSGI }, { "glXWaitVideoSyncSGI", (__GLXextFuncPtr) glXWaitVideoSyncSGI }, /*** GLX_SGI_make_current_read ***/ { "glXMakeCurrentReadSGI", (__GLXextFuncPtr) glXMakeCurrentReadSGI }, { "glXGetCurrentReadDrawableSGI", (__GLXextFuncPtr) glXGetCurrentReadDrawableSGI }, /*** GLX_SGIX_video_source ***/ #if defined(_VL_H) { "glXCreateGLXVideoSourceSGIX", (__GLXextFuncPtr) glXCreateGLXVideoSourceSGIX }, { "glXDestroyGLXVideoSourceSGIX", (__GLXextFuncPtr) glXDestroyGLXVideoSourceSGIX }, #endif /*** GLX_EXT_import_context ***/ { "glXFreeContextEXT", (__GLXextFuncPtr) glXFreeContextEXT }, { "glXGetContextIDEXT", (__GLXextFuncPtr) glXGetContextIDEXT }, { "glXGetCurrentDisplayEXT", (__GLXextFuncPtr) glXGetCurrentDisplayEXT }, { "glXImportContextEXT", (__GLXextFuncPtr) glXImportContextEXT }, { "glXQueryContextInfoEXT", (__GLXextFuncPtr) glXQueryContextInfoEXT }, /*** GLX_SGIX_fbconfig ***/ { "glXGetFBConfigAttribSGIX", (__GLXextFuncPtr) glXGetFBConfigAttribSGIX }, { "glXChooseFBConfigSGIX", (__GLXextFuncPtr) glXChooseFBConfigSGIX }, { "glXCreateGLXPixmapWithConfigSGIX", (__GLXextFuncPtr) glXCreateGLXPixmapWithConfigSGIX }, { "glXCreateContextWithConfigSGIX", (__GLXextFuncPtr) glXCreateContextWithConfigSGIX }, { "glXGetVisualFromFBConfigSGIX", (__GLXextFuncPtr) glXGetVisualFromFBConfigSGIX }, { "glXGetFBConfigFromVisualSGIX", (__GLXextFuncPtr) glXGetFBConfigFromVisualSGIX }, /*** GLX_SGIX_pbuffer ***/ { "glXCreateGLXPbufferSGIX", (__GLXextFuncPtr) glXCreateGLXPbufferSGIX }, { "glXDestroyGLXPbufferSGIX", (__GLXextFuncPtr) glXDestroyGLXPbufferSGIX }, { "glXQueryGLXPbufferSGIX", (__GLXextFuncPtr) glXQueryGLXPbufferSGIX }, { "glXSelectEventSGIX", (__GLXextFuncPtr) glXSelectEventSGIX }, { "glXGetSelectedEventSGIX", (__GLXextFuncPtr) glXGetSelectedEventSGIX }, /*** GLX_SGI_cushion ***/ { "glXCushionSGI", (__GLXextFuncPtr) glXCushionSGI }, /*** GLX_SGIX_video_resize ***/ { "glXBindChannelToWindowSGIX", (__GLXextFuncPtr) glXBindChannelToWindowSGIX }, { "glXChannelRectSGIX", (__GLXextFuncPtr) glXChannelRectSGIX }, { "glXQueryChannelRectSGIX", (__GLXextFuncPtr) glXQueryChannelRectSGIX }, { "glXQueryChannelDeltasSGIX", (__GLXextFuncPtr) glXQueryChannelDeltasSGIX }, { "glXChannelRectSyncSGIX", (__GLXextFuncPtr) glXChannelRectSyncSGIX }, /*** GLX_SGIX_dmbuffer **/ #if defined(_DM_BUFFER_H_) { "glXAssociateDMPbufferSGIX", (__GLXextFuncPtr) glXAssociateDMPbufferSGIX }, #endif /*** GLX_SGIX_swap_group ***/ { "glXJoinSwapGroupSGIX", (__GLXextFuncPtr) glXJoinSwapGroupSGIX }, /*** GLX_SGIX_swap_barrier ***/ { "glXBindSwapBarrierSGIX", (__GLXextFuncPtr) glXBindSwapBarrierSGIX }, { "glXQueryMaxSwapBarriersSGIX", (__GLXextFuncPtr) glXQueryMaxSwapBarriersSGIX }, /*** GLX_SUN_get_transparent_index ***/ { "glXGetTransparentIndexSUN", (__GLXextFuncPtr) glXGetTransparentIndexSUN }, /*** GLX_MESA_copy_sub_buffer ***/ { "glXCopySubBufferMESA", (__GLXextFuncPtr) glXCopySubBufferMESA }, /*** GLX_MESA_pixmap_colormap ***/ { "glXCreateGLXPixmapMESA", (__GLXextFuncPtr) glXCreateGLXPixmapMESA }, /*** GLX_MESA_release_buffers ***/ { "glXReleaseBuffersMESA", (__GLXextFuncPtr) glXReleaseBuffersMESA }, /*** GLX_ARB_get_proc_address ***/ { "glXGetProcAddressARB", (__GLXextFuncPtr) glXGetProcAddressARB }, /*** GLX_EXT_texture_from_pixmap ***/ { "glXBindTexImageEXT", (__GLXextFuncPtr) glXBindTexImageEXT }, { "glXReleaseTexImageEXT", (__GLXextFuncPtr) glXReleaseTexImageEXT }, /*** GLX_ARB_create_context ***/ { "glXCreateContextAttribsARB", (__GLXextFuncPtr) glXCreateContextAttribsARB }, { NULL, NULL } /* end of list */ }; /* * Return address of named glX function, or NULL if not found. */ __GLXextFuncPtr _glxapi_get_proc_address(const char *funcName) { GLuint i; for (i = 0; GLX_functions[i].Name; i++) { #ifdef MANGLE /* skip the "m" prefix on the name */ if (strcmp(GLX_functions[i].Name, funcName+1) == 0) #else if (strcmp(GLX_functions[i].Name, funcName) == 0) #endif return GLX_functions[i].Address; } return NULL; } /* * This function does not get dispatched through the dispatch table * since it's really a "meta" function. */ __GLXextFuncPtr PUBLIC glXGetProcAddressARB(const GLubyte *procName) { __GLXextFuncPtr f; f = _glxapi_get_proc_address((const char *) procName); if (f) { return f; } f = (__GLXextFuncPtr) _glapi_get_proc_address((const char *) procName); return f; } /* GLX 1.4 */ void PUBLIC (*glXGetProcAddress(const GLubyte *procName))() { return glXGetProcAddressARB(procName); } /** * Added in GLX_ARB_create_context. */ GLXContext PUBLIC glXCreateContextAttribsARB(Display *dpy, GLXFBConfig config, GLXContext share_context, Bool direct, const int *attrib_list) { struct _glxapi_table *t; GET_DISPATCH(dpy, t); if (!t) return 0; return t->CreateContextAttribs(dpy, config, share_context, direct, attrib_list); }