| /* |
| * THIS FILE IS AUTOMATICALLY GENERATED BY gen_scrn_dispatch.pl |
| * DO NOT EDIT!! |
| */ |
| #include <stdlib.h> |
| |
| #include "glxclient.h" |
| #include "glxglvnd.h" |
| #include "glxglvnddispatchfuncs.h" |
| #include "g_glxglvnddispatchindices.h" |
| |
| const int DI_FUNCTION_COUNT = DI_LAST_INDEX; |
| /* Allocate an extra 'dummy' to ease lookup. See FindGLXFunction() */ |
| int __glXDispatchTableIndices[DI_LAST_INDEX + 1]; |
| const __GLXapiExports *__glXGLVNDAPIExports; |
| |
| const char * const __glXDispatchTableStrings[DI_LAST_INDEX] = { |
| #define __ATTRIB(field) \ |
| [DI_##field] = "glX"#field |
| |
| __ATTRIB(BindSwapBarrierSGIX), |
| __ATTRIB(BindTexImageEXT), |
| // glXChooseFBConfig implemented by libglvnd |
| __ATTRIB(ChooseFBConfigSGIX), |
| // glXChooseVisual implemented by libglvnd |
| // glXCopyContext implemented by libglvnd |
| __ATTRIB(CopySubBufferMESA), |
| // glXCreateContext implemented by libglvnd |
| __ATTRIB(CreateContextAttribsARB), |
| __ATTRIB(CreateContextWithConfigSGIX), |
| __ATTRIB(CreateGLXPbufferSGIX), |
| // glXCreateGLXPixmap implemented by libglvnd |
| __ATTRIB(CreateGLXPixmapMESA), |
| __ATTRIB(CreateGLXPixmapWithConfigSGIX), |
| // glXCreateNewContext implemented by libglvnd |
| // glXCreatePbuffer implemented by libglvnd |
| // glXCreatePixmap implemented by libglvnd |
| // glXCreateWindow implemented by libglvnd |
| // glXDestroyContext implemented by libglvnd |
| __ATTRIB(DestroyGLXPbufferSGIX), |
| // glXDestroyGLXPixmap implemented by libglvnd |
| // glXDestroyPbuffer implemented by libglvnd |
| // glXDestroyPixmap implemented by libglvnd |
| // glXDestroyWindow implemented by libglvnd |
| // glXFreeContextEXT implemented by libglvnd |
| // glXGetClientString implemented by libglvnd |
| // glXGetConfig implemented by libglvnd |
| __ATTRIB(GetContextIDEXT), |
| // glXGetCurrentContext implemented by libglvnd |
| // glXGetCurrentDisplay implemented by libglvnd |
| __ATTRIB(GetCurrentDisplayEXT), |
| // glXGetCurrentDrawable implemented by libglvnd |
| // glXGetCurrentReadDrawable implemented by libglvnd |
| __ATTRIB(GetDriverConfig), |
| // glXGetFBConfigAttrib implemented by libglvnd |
| __ATTRIB(GetFBConfigAttribSGIX), |
| __ATTRIB(GetFBConfigFromVisualSGIX), |
| // glXGetFBConfigs implemented by libglvnd |
| __ATTRIB(GetMscRateOML), |
| // glXGetProcAddress implemented by libglvnd |
| // glXGetProcAddressARB implemented by libglvnd |
| __ATTRIB(GetScreenDriver), |
| // glXGetSelectedEvent implemented by libglvnd |
| __ATTRIB(GetSelectedEventSGIX), |
| __ATTRIB(GetSwapIntervalMESA), |
| __ATTRIB(GetSyncValuesOML), |
| __ATTRIB(GetVideoSyncSGI), |
| // glXGetVisualFromFBConfig implemented by libglvnd |
| __ATTRIB(GetVisualFromFBConfigSGIX), |
| // glXImportContextEXT implemented by libglvnd |
| // glXIsDirect implemented by libglvnd |
| __ATTRIB(JoinSwapGroupSGIX), |
| // glXMakeContextCurrent implemented by libglvnd |
| // glXMakeCurrent implemented by libglvnd |
| // glXQueryContext implemented by libglvnd |
| __ATTRIB(QueryContextInfoEXT), |
| __ATTRIB(QueryCurrentRendererIntegerMESA), |
| __ATTRIB(QueryCurrentRendererStringMESA), |
| // glXQueryDrawable implemented by libglvnd |
| // glXQueryExtension implemented by libglvnd |
| // glXQueryExtensionsString implemented by libglvnd |
| __ATTRIB(QueryGLXPbufferSGIX), |
| __ATTRIB(QueryMaxSwapBarriersSGIX), |
| __ATTRIB(QueryRendererIntegerMESA), |
| __ATTRIB(QueryRendererStringMESA), |
| // glXQueryServerString implemented by libglvnd |
| // glXQueryVersion implemented by libglvnd |
| __ATTRIB(ReleaseBuffersMESA), |
| __ATTRIB(ReleaseTexImageEXT), |
| // glXSelectEvent implemented by libglvnd |
| __ATTRIB(SelectEventSGIX), |
| // glXSwapBuffers implemented by libglvnd |
| __ATTRIB(SwapBuffersMscOML), |
| __ATTRIB(SwapIntervalMESA), |
| __ATTRIB(SwapIntervalSGI), |
| // glXUseXFont implemented by libglvnd |
| __ATTRIB(WaitForMscOML), |
| __ATTRIB(WaitForSbcOML), |
| // glXWaitGL implemented by libglvnd |
| __ATTRIB(WaitVideoSyncSGI), |
| // glXWaitX implemented by libglvnd |
| |
| #undef __ATTRIB |
| }; |
| |
| #define __FETCH_FUNCTION_PTR(func_name) \ |
| p##func_name = (void *) \ |
| __VND->fetchDispatchEntry(dd, __glXDispatchTableIndices[DI_##func_name]) |
| |
| |
| static void dispatch_BindTexImageEXT(Display *dpy, GLXDrawable drawable, |
| int buffer, const int *attrib_list) |
| { |
| PFNGLXBINDTEXIMAGEEXTPROC pBindTexImageEXT; |
| __GLXvendorInfo *dd; |
| |
| dd = GetDispatchFromDrawable(dpy, drawable); |
| if (dd == NULL) |
| return; |
| |
| __FETCH_FUNCTION_PTR(BindTexImageEXT); |
| if (pBindTexImageEXT == NULL) |
| return; |
| |
| (*pBindTexImageEXT)(dpy, drawable, buffer, attrib_list); |
| } |
| |
| |
| |
| static GLXFBConfigSGIX *dispatch_ChooseFBConfigSGIX(Display *dpy, int screen, |
| const int *attrib_list, |
| int *nelements) |
| { |
| PFNGLXCHOOSEFBCONFIGSGIXPROC pChooseFBConfigSGIX; |
| __GLXvendorInfo *dd; |
| GLXFBConfigSGIX *ret; |
| |
| dd = __VND->getDynDispatch(dpy, screen); |
| if (dd == NULL) |
| return NULL; |
| |
| __FETCH_FUNCTION_PTR(ChooseFBConfigSGIX); |
| if (pChooseFBConfigSGIX == NULL) |
| return NULL; |
| |
| ret = (*pChooseFBConfigSGIX)(dpy, screen, attrib_list, nelements); |
| if (AddFBConfigsMapping(dpy, ret, nelements, dd)) { |
| free(ret); |
| return NULL; |
| } |
| |
| return ret; |
| } |
| |
| |
| |
| static GLXContext dispatch_CreateContextAttribsARB(Display *dpy, |
| GLXFBConfig config, |
| GLXContext share_list, |
| Bool direct, |
| const int *attrib_list) |
| { |
| PFNGLXCREATECONTEXTATTRIBSARBPROC pCreateContextAttribsARB; |
| __GLXvendorInfo *dd; |
| GLXContext ret; |
| |
| dd = GetDispatchFromFBConfig(dpy, config); |
| if (dd == NULL) |
| return None; |
| |
| __FETCH_FUNCTION_PTR(CreateContextAttribsARB); |
| if (pCreateContextAttribsARB == NULL) |
| return None; |
| |
| ret = (*pCreateContextAttribsARB)(dpy, config, share_list, direct, attrib_list); |
| if (AddContextMapping(dpy, ret, dd)) { |
| /* XXX: Call glXDestroyContext which lives in libglvnd. If we're not |
| * allowed to call it from here, should we extend __glXDispatchTableIndices ? |
| */ |
| return None; |
| } |
| |
| return ret; |
| } |
| |
| |
| |
| static GLXContext dispatch_CreateContextWithConfigSGIX(Display *dpy, |
| GLXFBConfigSGIX config, |
| int render_type, |
| GLXContext share_list, |
| Bool direct) |
| { |
| PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC pCreateContextWithConfigSGIX; |
| __GLXvendorInfo *dd; |
| GLXContext ret; |
| |
| dd = GetDispatchFromFBConfig(dpy, config); |
| if (dd == NULL) |
| return None; |
| |
| __FETCH_FUNCTION_PTR(CreateContextWithConfigSGIX); |
| if (pCreateContextWithConfigSGIX == NULL) |
| return None; |
| |
| ret = (*pCreateContextWithConfigSGIX)(dpy, config, render_type, share_list, direct); |
| if (AddContextMapping(dpy, ret, dd)) { |
| /* XXX: Call glXDestroyContext which lives in libglvnd. If we're not |
| * allowed to call it from here, should we extend __glXDispatchTableIndices ? |
| */ |
| return None; |
| } |
| |
| return ret; |
| } |
| |
| |
| |
| static GLXPbuffer dispatch_CreateGLXPbufferSGIX(Display *dpy, |
| GLXFBConfig config, |
| unsigned int width, |
| unsigned int height, |
| const int *attrib_list) |
| { |
| PFNGLXCREATEGLXPBUFFERSGIXPROC pCreateGLXPbufferSGIX; |
| __GLXvendorInfo *dd; |
| GLXPbuffer ret; |
| |
| dd = GetDispatchFromFBConfig(dpy, config); |
| if (dd == NULL) |
| return None; |
| |
| __FETCH_FUNCTION_PTR(CreateGLXPbufferSGIX); |
| if (pCreateGLXPbufferSGIX == NULL) |
| return None; |
| |
| ret = (*pCreateGLXPbufferSGIX)(dpy, config, width, height, attrib_list); |
| if (AddDrawableMapping(dpy, ret, dd)) { |
| PFNGLXDESTROYGLXPBUFFERSGIXPROC pDestroyGLXPbufferSGIX; |
| |
| __FETCH_FUNCTION_PTR(DestroyGLXPbufferSGIX); |
| if (pDestroyGLXPbufferSGIX) |
| (*pDestroyGLXPbufferSGIX)(dpy, ret); |
| |
| return None; |
| } |
| |
| return ret; |
| } |
| |
| |
| |
| static GLXPixmap dispatch_CreateGLXPixmapWithConfigSGIX(Display *dpy, |
| GLXFBConfigSGIX config, |
| Pixmap pixmap) |
| { |
| PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC pCreateGLXPixmapWithConfigSGIX; |
| __GLXvendorInfo *dd; |
| GLXPixmap ret; |
| |
| dd = GetDispatchFromFBConfig(dpy, config); |
| if (dd == NULL) |
| return None; |
| |
| __FETCH_FUNCTION_PTR(CreateGLXPixmapWithConfigSGIX); |
| if (pCreateGLXPixmapWithConfigSGIX == NULL) |
| return None; |
| |
| ret = (*pCreateGLXPixmapWithConfigSGIX)(dpy, config, pixmap); |
| if (AddDrawableMapping(dpy, ret, dd)) { |
| /* XXX: Call glXDestroyGLXPixmap which lives in libglvnd. If we're not |
| * allowed to call it from here, should we extend __glXDispatchTableIndices ? |
| */ |
| return None; |
| } |
| |
| return ret; |
| } |
| |
| |
| |
| static void dispatch_DestroyGLXPbufferSGIX(Display *dpy, GLXPbuffer pbuf) |
| { |
| PFNGLXDESTROYGLXPBUFFERSGIXPROC pDestroyGLXPbufferSGIX; |
| __GLXvendorInfo *dd; |
| |
| dd = GetDispatchFromDrawable(dpy, pbuf); |
| if (dd == NULL) |
| return; |
| |
| __FETCH_FUNCTION_PTR(DestroyGLXPbufferSGIX); |
| if (pDestroyGLXPbufferSGIX == NULL) |
| return; |
| |
| (*pDestroyGLXPbufferSGIX)(dpy, pbuf); |
| } |
| |
| |
| |
| static GLXContextID dispatch_GetContextIDEXT(const GLXContext ctx) |
| { |
| PFNGLXGETCONTEXTIDEXTPROC pGetContextIDEXT; |
| __GLXvendorInfo *dd; |
| |
| dd = GetDispatchFromContext(ctx); |
| if (dd == NULL) |
| return None; |
| |
| __FETCH_FUNCTION_PTR(GetContextIDEXT); |
| if (pGetContextIDEXT == NULL) |
| return None; |
| |
| return (*pGetContextIDEXT)(ctx); |
| } |
| |
| |
| |
| static Display *dispatch_GetCurrentDisplayEXT(void) |
| { |
| PFNGLXGETCURRENTDISPLAYEXTPROC pGetCurrentDisplayEXT; |
| __GLXvendorInfo *dd; |
| |
| if (!__VND->getCurrentContext()) |
| return NULL; |
| |
| dd = __VND->getCurrentDynDispatch(); |
| if (dd == NULL) |
| return NULL; |
| |
| __FETCH_FUNCTION_PTR(GetCurrentDisplayEXT); |
| if (pGetCurrentDisplayEXT == NULL) |
| return NULL; |
| |
| return (*pGetCurrentDisplayEXT)(); |
| } |
| |
| |
| |
| static const char *dispatch_GetDriverConfig(const char *driverName) |
| { |
| /* |
| * The options are constant for a given driverName, so we do not need |
| * a context (and apps expect to be able to call this without one). |
| */ |
| return glXGetDriverConfig(driverName); |
| } |
| |
| |
| |
| static int dispatch_GetFBConfigAttribSGIX(Display *dpy, GLXFBConfigSGIX config, |
| int attribute, int *value_return) |
| { |
| PFNGLXGETFBCONFIGATTRIBSGIXPROC pGetFBConfigAttribSGIX; |
| __GLXvendorInfo *dd; |
| |
| dd = GetDispatchFromFBConfig(dpy, config); |
| if (dd == NULL) |
| return GLX_NO_EXTENSION; |
| |
| __FETCH_FUNCTION_PTR(GetFBConfigAttribSGIX); |
| if (pGetFBConfigAttribSGIX == NULL) |
| return GLX_NO_EXTENSION; |
| |
| return (*pGetFBConfigAttribSGIX)(dpy, config, attribute, value_return); |
| } |
| |
| |
| |
| static GLXFBConfigSGIX dispatch_GetFBConfigFromVisualSGIX(Display *dpy, |
| XVisualInfo *vis) |
| { |
| PFNGLXGETFBCONFIGFROMVISUALSGIXPROC pGetFBConfigFromVisualSGIX; |
| __GLXvendorInfo *dd; |
| GLXFBConfigSGIX ret = NULL; |
| |
| dd = GetDispatchFromVisual(dpy, vis); |
| if (dd == NULL) |
| return NULL; |
| |
| __FETCH_FUNCTION_PTR(GetFBConfigFromVisualSGIX); |
| if (pGetFBConfigFromVisualSGIX == NULL) |
| return NULL; |
| |
| ret = (*pGetFBConfigFromVisualSGIX)(dpy, vis); |
| if (AddFBConfigMapping(dpy, ret, dd)) |
| /* XXX: dealloc ret ? */ |
| return NULL; |
| |
| return ret; |
| } |
| |
| |
| |
| static void dispatch_GetSelectedEventSGIX(Display *dpy, GLXDrawable drawable, |
| unsigned long *mask) |
| { |
| PFNGLXGETSELECTEDEVENTSGIXPROC pGetSelectedEventSGIX; |
| __GLXvendorInfo *dd; |
| |
| dd = GetDispatchFromDrawable(dpy, drawable); |
| if (dd == NULL) |
| return; |
| |
| __FETCH_FUNCTION_PTR(GetSelectedEventSGIX); |
| if (pGetSelectedEventSGIX == NULL) |
| return; |
| |
| (*pGetSelectedEventSGIX)(dpy, drawable, mask); |
| } |
| |
| |
| |
| static int dispatch_GetVideoSyncSGI(unsigned int *count) |
| { |
| PFNGLXGETVIDEOSYNCSGIPROC pGetVideoSyncSGI; |
| __GLXvendorInfo *dd; |
| |
| if (!__VND->getCurrentContext()) |
| return GLX_BAD_CONTEXT; |
| |
| dd = __VND->getCurrentDynDispatch(); |
| if (dd == NULL) |
| return GLX_NO_EXTENSION; |
| |
| __FETCH_FUNCTION_PTR(GetVideoSyncSGI); |
| if (pGetVideoSyncSGI == NULL) |
| return GLX_NO_EXTENSION; |
| |
| return (*pGetVideoSyncSGI)(count); |
| } |
| |
| |
| |
| static XVisualInfo *dispatch_GetVisualFromFBConfigSGIX(Display *dpy, |
| GLXFBConfigSGIX config) |
| { |
| PFNGLXGETVISUALFROMFBCONFIGSGIXPROC pGetVisualFromFBConfigSGIX; |
| __GLXvendorInfo *dd; |
| |
| dd = GetDispatchFromFBConfig(dpy, config); |
| if (dd == NULL) |
| return NULL; |
| |
| __FETCH_FUNCTION_PTR(GetVisualFromFBConfigSGIX); |
| if (pGetVisualFromFBConfigSGIX == NULL) |
| return NULL; |
| |
| return (*pGetVisualFromFBConfigSGIX)(dpy, config); |
| } |
| |
| |
| |
| static int dispatch_QueryContextInfoEXT(Display *dpy, GLXContext ctx, |
| int attribute, int *value) |
| { |
| PFNGLXQUERYCONTEXTINFOEXTPROC pQueryContextInfoEXT; |
| __GLXvendorInfo *dd; |
| |
| dd = GetDispatchFromContext(ctx); |
| if (dd == NULL) |
| return GLX_NO_EXTENSION; |
| |
| __FETCH_FUNCTION_PTR(QueryContextInfoEXT); |
| if (pQueryContextInfoEXT == NULL) |
| return GLX_NO_EXTENSION; |
| |
| return (*pQueryContextInfoEXT)(dpy, ctx, attribute, value); |
| } |
| |
| |
| |
| static void dispatch_QueryGLXPbufferSGIX(Display *dpy, GLXPbuffer pbuf, |
| int attribute, unsigned int *value) |
| { |
| PFNGLXQUERYGLXPBUFFERSGIXPROC pQueryGLXPbufferSGIX; |
| __GLXvendorInfo *dd; |
| |
| dd = GetDispatchFromDrawable(dpy, pbuf); |
| if (dd == NULL) |
| return; |
| |
| __FETCH_FUNCTION_PTR(QueryGLXPbufferSGIX); |
| if (pQueryGLXPbufferSGIX == NULL) |
| return; |
| |
| (*pQueryGLXPbufferSGIX)(dpy, pbuf, attribute, value); |
| } |
| |
| |
| |
| static void dispatch_ReleaseTexImageEXT(Display *dpy, GLXDrawable drawable, |
| int buffer) |
| { |
| PFNGLXRELEASETEXIMAGEEXTPROC pReleaseTexImageEXT; |
| __GLXvendorInfo *dd; |
| |
| dd = GetDispatchFromDrawable(dpy, drawable); |
| if (dd == NULL) |
| return; |
| |
| __FETCH_FUNCTION_PTR(ReleaseTexImageEXT); |
| if (pReleaseTexImageEXT == NULL) |
| return; |
| |
| (*pReleaseTexImageEXT)(dpy, drawable, buffer); |
| } |
| |
| |
| |
| static void dispatch_SelectEventSGIX(Display *dpy, GLXDrawable drawable, |
| unsigned long mask) |
| { |
| PFNGLXSELECTEVENTSGIXPROC pSelectEventSGIX; |
| __GLXvendorInfo *dd; |
| |
| dd = GetDispatchFromDrawable(dpy, drawable); |
| if (dd == NULL) |
| return; |
| |
| __FETCH_FUNCTION_PTR(SelectEventSGIX); |
| if (pSelectEventSGIX == NULL) |
| return; |
| |
| (*pSelectEventSGIX)(dpy, drawable, mask); |
| } |
| |
| |
| |
| static int dispatch_SwapIntervalSGI(int interval) |
| { |
| PFNGLXSWAPINTERVALSGIPROC pSwapIntervalSGI; |
| __GLXvendorInfo *dd; |
| |
| if (!__VND->getCurrentContext()) |
| return GLX_BAD_CONTEXT; |
| |
| dd = __VND->getCurrentDynDispatch(); |
| if (dd == NULL) |
| return GLX_NO_EXTENSION; |
| |
| __FETCH_FUNCTION_PTR(SwapIntervalSGI); |
| if (pSwapIntervalSGI == NULL) |
| return GLX_NO_EXTENSION; |
| |
| return (*pSwapIntervalSGI)(interval); |
| } |
| |
| |
| |
| static int dispatch_WaitVideoSyncSGI(int divisor, int remainder, |
| unsigned int *count) |
| { |
| PFNGLXWAITVIDEOSYNCSGIPROC pWaitVideoSyncSGI; |
| __GLXvendorInfo *dd; |
| |
| if (!__VND->getCurrentContext()) |
| return GLX_BAD_CONTEXT; |
| |
| dd = __VND->getCurrentDynDispatch(); |
| if (dd == NULL) |
| return GLX_NO_EXTENSION; |
| |
| __FETCH_FUNCTION_PTR(WaitVideoSyncSGI); |
| if (pWaitVideoSyncSGI == NULL) |
| return GLX_NO_EXTENSION; |
| |
| return (*pWaitVideoSyncSGI)(divisor, remainder, count); |
| } |
| |
| |
| |
| static void dispatch_BindSwapBarrierSGIX(Display *dpy, GLXDrawable drawable, |
| int barrier) |
| { |
| PFNGLXBINDSWAPBARRIERSGIXPROC pBindSwapBarrierSGIX; |
| __GLXvendorInfo *dd; |
| |
| dd = GetDispatchFromDrawable(dpy, drawable); |
| if (dd == NULL) |
| return; |
| |
| __FETCH_FUNCTION_PTR(BindSwapBarrierSGIX); |
| if (pBindSwapBarrierSGIX == NULL) |
| return; |
| |
| (*pBindSwapBarrierSGIX)(dpy, drawable, barrier); |
| } |
| |
| |
| |
| static void dispatch_CopySubBufferMESA(Display *dpy, GLXDrawable drawable, |
| int x, int y, int width, int height) |
| { |
| PFNGLXCOPYSUBBUFFERMESAPROC pCopySubBufferMESA; |
| __GLXvendorInfo *dd; |
| |
| dd = GetDispatchFromDrawable(dpy, drawable); |
| if (dd == NULL) |
| return; |
| |
| __FETCH_FUNCTION_PTR(CopySubBufferMESA); |
| if (pCopySubBufferMESA == NULL) |
| return; |
| |
| (*pCopySubBufferMESA)(dpy, drawable, x, y, width, height); |
| } |
| |
| |
| |
| static GLXPixmap dispatch_CreateGLXPixmapMESA(Display *dpy, |
| XVisualInfo *visinfo, |
| Pixmap pixmap, Colormap cmap) |
| { |
| PFNGLXCREATEGLXPIXMAPMESAPROC pCreateGLXPixmapMESA; |
| __GLXvendorInfo *dd; |
| GLXPixmap ret; |
| |
| dd = GetDispatchFromVisual(dpy, visinfo); |
| if (dd == NULL) |
| return None; |
| |
| __FETCH_FUNCTION_PTR(CreateGLXPixmapMESA); |
| if (pCreateGLXPixmapMESA == NULL) |
| return None; |
| |
| ret = (*pCreateGLXPixmapMESA)(dpy, visinfo, pixmap, cmap); |
| if (AddDrawableMapping(dpy, ret, dd)) { |
| /* XXX: Call glXDestroyGLXPixmap which lives in libglvnd. If we're not |
| * allowed to call it from here, should we extend __glXDispatchTableIndices ? |
| */ |
| return None; |
| } |
| |
| return ret; |
| } |
| |
| |
| |
| static GLboolean dispatch_GetMscRateOML(Display *dpy, GLXDrawable drawable, |
| int32_t *numerator, int32_t *denominator) |
| { |
| PFNGLXGETMSCRATEOMLPROC pGetMscRateOML; |
| __GLXvendorInfo *dd; |
| |
| dd = GetDispatchFromDrawable(dpy, drawable); |
| if (dd == NULL) |
| return GL_FALSE; |
| |
| __FETCH_FUNCTION_PTR(GetMscRateOML); |
| if (pGetMscRateOML == NULL) |
| return GL_FALSE; |
| |
| return (*pGetMscRateOML)(dpy, drawable, numerator, denominator); |
| } |
| |
| |
| |
| static const char *dispatch_GetScreenDriver(Display *dpy, int scrNum) |
| { |
| typedef const char *(*fn_glXGetScreenDriver_ptr)(Display *dpy, int scrNum); |
| fn_glXGetScreenDriver_ptr pGetScreenDriver; |
| __GLXvendorInfo *dd; |
| |
| dd = __VND->getDynDispatch(dpy, scrNum); |
| if (dd == NULL) |
| return NULL; |
| |
| __FETCH_FUNCTION_PTR(GetScreenDriver); |
| if (pGetScreenDriver == NULL) |
| return NULL; |
| |
| return (*pGetScreenDriver)(dpy, scrNum); |
| } |
| |
| |
| |
| static int dispatch_GetSwapIntervalMESA(void) |
| { |
| PFNGLXGETSWAPINTERVALMESAPROC pGetSwapIntervalMESA; |
| __GLXvendorInfo *dd; |
| |
| if (!__VND->getCurrentContext()) |
| return GLX_BAD_CONTEXT; |
| |
| dd = __VND->getCurrentDynDispatch(); |
| if (dd == NULL) |
| return 0; |
| |
| __FETCH_FUNCTION_PTR(GetSwapIntervalMESA); |
| if (pGetSwapIntervalMESA == NULL) |
| return 0; |
| |
| return (*pGetSwapIntervalMESA)(); |
| } |
| |
| |
| |
| static Bool dispatch_GetSyncValuesOML(Display *dpy, GLXDrawable drawable, |
| int64_t *ust, int64_t *msc, int64_t *sbc) |
| { |
| PFNGLXGETSYNCVALUESOMLPROC pGetSyncValuesOML; |
| __GLXvendorInfo *dd; |
| |
| dd = GetDispatchFromDrawable(dpy, drawable); |
| if (dd == NULL) |
| return False; |
| |
| __FETCH_FUNCTION_PTR(GetSyncValuesOML); |
| if (pGetSyncValuesOML == NULL) |
| return False; |
| |
| return (*pGetSyncValuesOML)(dpy, drawable, ust, msc, sbc); |
| } |
| |
| |
| |
| static void dispatch_JoinSwapGroupSGIX(Display *dpy, GLXDrawable drawable, |
| GLXDrawable member) |
| { |
| PFNGLXJOINSWAPGROUPSGIXPROC pJoinSwapGroupSGIX; |
| __GLXvendorInfo *dd; |
| |
| dd = GetDispatchFromDrawable(dpy, drawable); |
| if (dd == NULL) |
| return; |
| |
| __FETCH_FUNCTION_PTR(JoinSwapGroupSGIX); |
| if (pJoinSwapGroupSGIX == NULL) |
| return; |
| |
| (*pJoinSwapGroupSGIX)(dpy, drawable, member); |
| } |
| |
| |
| |
| static Bool dispatch_QueryCurrentRendererIntegerMESA(int attribute, |
| unsigned int *value) |
| { |
| PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC pQueryCurrentRendererIntegerMESA; |
| __GLXvendorInfo *dd; |
| |
| if (!__VND->getCurrentContext()) |
| return False; |
| |
| dd = __VND->getCurrentDynDispatch(); |
| if (dd == NULL) |
| return False; |
| |
| __FETCH_FUNCTION_PTR(QueryCurrentRendererIntegerMESA); |
| if (pQueryCurrentRendererIntegerMESA == NULL) |
| return False; |
| |
| return (*pQueryCurrentRendererIntegerMESA)(attribute, value); |
| } |
| |
| |
| |
| static const char *dispatch_QueryCurrentRendererStringMESA(int attribute) |
| { |
| PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC pQueryCurrentRendererStringMESA; |
| __GLXvendorInfo *dd; |
| |
| if (!__VND->getCurrentContext()) |
| return NULL; |
| |
| dd = __VND->getCurrentDynDispatch(); |
| if (dd == NULL) |
| return NULL; |
| |
| __FETCH_FUNCTION_PTR(QueryCurrentRendererStringMESA); |
| if (pQueryCurrentRendererStringMESA == NULL) |
| return NULL; |
| |
| return (*pQueryCurrentRendererStringMESA)(attribute); |
| } |
| |
| |
| |
| static Bool dispatch_QueryMaxSwapBarriersSGIX(Display *dpy, int screen, |
| int *max) |
| { |
| PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC pQueryMaxSwapBarriersSGIX; |
| __GLXvendorInfo *dd; |
| |
| dd = __VND->getDynDispatch(dpy, screen); |
| if (dd == NULL) |
| return False; |
| |
| __FETCH_FUNCTION_PTR(QueryMaxSwapBarriersSGIX); |
| if (pQueryMaxSwapBarriersSGIX == NULL) |
| return False; |
| |
| return (*pQueryMaxSwapBarriersSGIX)(dpy, screen, max); |
| } |
| |
| |
| |
| static Bool dispatch_QueryRendererIntegerMESA(Display *dpy, int screen, |
| int renderer, int attribute, |
| unsigned int *value) |
| { |
| PFNGLXQUERYRENDERERINTEGERMESAPROC pQueryRendererIntegerMESA; |
| __GLXvendorInfo *dd; |
| |
| dd = __VND->getDynDispatch(dpy, screen); |
| if (dd == NULL) |
| return False; |
| |
| __FETCH_FUNCTION_PTR(QueryRendererIntegerMESA); |
| if (pQueryRendererIntegerMESA == NULL) |
| return False; |
| |
| return (*pQueryRendererIntegerMESA)(dpy, screen, renderer, attribute, value); |
| } |
| |
| |
| |
| static const char *dispatch_QueryRendererStringMESA(Display *dpy, int screen, |
| int renderer, int attribute) |
| { |
| PFNGLXQUERYRENDERERSTRINGMESAPROC pQueryRendererStringMESA; |
| __GLXvendorInfo *dd = NULL; |
| |
| dd = __VND->getDynDispatch(dpy, screen); |
| if (dd == NULL) |
| return NULL; |
| |
| __FETCH_FUNCTION_PTR(QueryRendererStringMESA); |
| if (pQueryRendererStringMESA == NULL) |
| return NULL; |
| |
| return (*pQueryRendererStringMESA)(dpy, screen, renderer, attribute); |
| } |
| |
| |
| |
| static Bool dispatch_ReleaseBuffersMESA(Display *dpy, GLXDrawable d) |
| { |
| PFNGLXRELEASEBUFFERSMESAPROC pReleaseBuffersMESA; |
| __GLXvendorInfo *dd; |
| |
| dd = GetDispatchFromDrawable(dpy, d); |
| if (dd == NULL) |
| return False; |
| |
| __FETCH_FUNCTION_PTR(ReleaseBuffersMESA); |
| if (pReleaseBuffersMESA == NULL) |
| return False; |
| |
| return (*pReleaseBuffersMESA)(dpy, d); |
| } |
| |
| |
| |
| static int64_t dispatch_SwapBuffersMscOML(Display *dpy, GLXDrawable drawable, |
| int64_t target_msc, int64_t divisor, |
| int64_t remainder) |
| { |
| PFNGLXSWAPBUFFERSMSCOMLPROC pSwapBuffersMscOML; |
| __GLXvendorInfo *dd; |
| |
| dd = GetDispatchFromDrawable(dpy, drawable); |
| if (dd == NULL) |
| return 0; |
| |
| __FETCH_FUNCTION_PTR(SwapBuffersMscOML); |
| if (pSwapBuffersMscOML == NULL) |
| return 0; |
| |
| return (*pSwapBuffersMscOML)(dpy, drawable, target_msc, divisor, remainder); |
| } |
| |
| |
| |
| static int dispatch_SwapIntervalMESA(unsigned int interval) |
| { |
| PFNGLXSWAPINTERVALMESAPROC pSwapIntervalMESA; |
| __GLXvendorInfo *dd; |
| |
| if (!__VND->getCurrentContext()) |
| return GLX_BAD_CONTEXT; |
| |
| dd = __VND->getCurrentDynDispatch(); |
| if (dd == NULL) |
| return 0; |
| |
| __FETCH_FUNCTION_PTR(SwapIntervalMESA); |
| if (pSwapIntervalMESA == NULL) |
| return 0; |
| |
| return (*pSwapIntervalMESA)(interval); |
| } |
| |
| |
| |
| static Bool dispatch_WaitForMscOML(Display *dpy, GLXDrawable drawable, |
| int64_t target_msc, int64_t divisor, |
| int64_t remainder, int64_t *ust, |
| int64_t *msc, int64_t *sbc) |
| { |
| PFNGLXWAITFORMSCOMLPROC pWaitForMscOML; |
| __GLXvendorInfo *dd; |
| |
| dd = GetDispatchFromDrawable(dpy, drawable); |
| if (dd == NULL) |
| return False; |
| |
| __FETCH_FUNCTION_PTR(WaitForMscOML); |
| if (pWaitForMscOML == NULL) |
| return False; |
| |
| return (*pWaitForMscOML)(dpy, drawable, target_msc, divisor, remainder, ust, msc, sbc); |
| } |
| |
| |
| |
| static Bool dispatch_WaitForSbcOML(Display *dpy, GLXDrawable drawable, |
| int64_t target_sbc, int64_t *ust, |
| int64_t *msc, int64_t *sbc) |
| { |
| PFNGLXWAITFORSBCOMLPROC pWaitForSbcOML; |
| __GLXvendorInfo *dd; |
| |
| dd = GetDispatchFromDrawable(dpy, drawable); |
| if (dd == NULL) |
| return False; |
| |
| __FETCH_FUNCTION_PTR(WaitForSbcOML); |
| if (pWaitForSbcOML == NULL) |
| return False; |
| |
| return (*pWaitForSbcOML)(dpy, drawable, target_sbc, ust, msc, sbc); |
| } |
| |
| #undef __FETCH_FUNCTION_PTR |
| |
| |
| /* Allocate an extra 'dummy' to ease lookup. See FindGLXFunction() */ |
| const void * const __glXDispatchFunctions[DI_LAST_INDEX + 1] = { |
| #define __ATTRIB(field) \ |
| [DI_##field] = (void *)dispatch_##field |
| |
| __ATTRIB(BindSwapBarrierSGIX), |
| __ATTRIB(BindTexImageEXT), |
| __ATTRIB(ChooseFBConfigSGIX), |
| __ATTRIB(CopySubBufferMESA), |
| __ATTRIB(CreateContextAttribsARB), |
| __ATTRIB(CreateContextWithConfigSGIX), |
| __ATTRIB(CreateGLXPbufferSGIX), |
| __ATTRIB(CreateGLXPixmapMESA), |
| __ATTRIB(CreateGLXPixmapWithConfigSGIX), |
| __ATTRIB(DestroyGLXPbufferSGIX), |
| __ATTRIB(GetContextIDEXT), |
| __ATTRIB(GetCurrentDisplayEXT), |
| __ATTRIB(GetDriverConfig), |
| __ATTRIB(GetFBConfigAttribSGIX), |
| __ATTRIB(GetFBConfigFromVisualSGIX), |
| __ATTRIB(GetMscRateOML), |
| __ATTRIB(GetScreenDriver), |
| __ATTRIB(GetSelectedEventSGIX), |
| __ATTRIB(GetSwapIntervalMESA), |
| __ATTRIB(GetSyncValuesOML), |
| __ATTRIB(GetVideoSyncSGI), |
| __ATTRIB(GetVisualFromFBConfigSGIX), |
| __ATTRIB(JoinSwapGroupSGIX), |
| __ATTRIB(QueryContextInfoEXT), |
| __ATTRIB(QueryCurrentRendererIntegerMESA), |
| __ATTRIB(QueryCurrentRendererStringMESA), |
| __ATTRIB(QueryGLXPbufferSGIX), |
| __ATTRIB(QueryMaxSwapBarriersSGIX), |
| __ATTRIB(QueryRendererIntegerMESA), |
| __ATTRIB(QueryRendererStringMESA), |
| __ATTRIB(ReleaseBuffersMESA), |
| __ATTRIB(ReleaseTexImageEXT), |
| __ATTRIB(SelectEventSGIX), |
| __ATTRIB(SwapBuffersMscOML), |
| __ATTRIB(SwapIntervalMESA), |
| __ATTRIB(SwapIntervalSGI), |
| __ATTRIB(WaitForMscOML), |
| __ATTRIB(WaitForSbcOML), |
| __ATTRIB(WaitVideoSyncSGI), |
| |
| [DI_LAST_INDEX] = NULL, |
| #undef __ATTRIB |
| }; |