include/GL/glxproto.h | 177 +++++++++++++++++++++++++ programs/Xserver/GL/glx/global.c | 1 programs/Xserver/GL/glx/glxcmds.c | 245 +++++++++++++++++++++++++++++++++++ programs/Xserver/GL/glx/glxext.c | 14 ++ programs/Xserver/GL/glx/glxext.h | 20 ++ programs/Xserver/GL/glx/glxscreens.c | 47 ++++++ 6 files changed, 504 insertions(+) Index: include/GL/glxproto.h =================================================================== RCS file: /cvs/xorg/xc/include/GL/glxproto.h,v retrieving revision 1.4 diff -u -d -r1.4 glxproto.h --- include/GL/glxproto.h 30 Jun 2004 20:06:52 -0000 1.4 +++ include/GL/glxproto.h 29 Aug 2005 23:54:44 -0000 @@ -1082,6 +1082,183 @@ } xGLXQueryMaxSwapBarriersSGIXReply; #define sz_xGLXQueryMaxSwapBarriersSGIXReply 32 +/* +** glXBindSwapBarrierSGIX request +*/ +typedef struct GLXBindSwapBarrierSGIX { + CARD8 reqType; + CARD8 glxCode; + CARD16 length B16; + CARD32 vendorCode B32; /* vendor-specific opcode */ + CARD32 pad1 B32; /* unused; corresponds to contextTag in header */ + GLXDrawable drawable B32; + CARD32 barrier B32; +} xGLXBindSwapBarrierSGIXReq; +#define sz_xGLXBindSwapBarrierSGIXReq 20 + +/* +** glXQueryMaxSwapBarriersSGIX request +*/ +typedef struct GLXQueryMaxSwapBarriersSGIX { + CARD8 reqType; + CARD8 glxCode; + CARD16 length B16; + CARD32 vendorCode B32; /* vendor-specific opcode */ + CARD32 pad1 B32; /* unused; corresponds to contextTag in header */ + CARD32 screen B32; +} xGLXQueryMaxSwapBarriersSGIXReq; +#define sz_xGLXQueryMaxSwapBarriersSGIXReq 16 + +/* +** glXQueryMaxSwapBarriersSGIX reply +*/ +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; /* not used */ + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD32 max B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; +} xGLXQueryMaxSwapBarriersSGIXReply; +#define sz_xGLXQueryMaxSwapBarriersSGIXReply 32 + +/* +** glXQueryHyperpipeNetworkSGIX request +*/ +typedef struct GLXQueryHyperpipeNetworkSGIX { + CARD8 reqType; + CARD8 glxCode; + CARD16 length B16; + CARD32 vendorCode B32; /* vendor-specific opcode */ + CARD32 pad1 B32; /* unused; corresponds to contextTag in header */ + CARD32 screen B32; +} xGLXQueryHyperpipeNetworkSGIXReq; +#define sz_xGLXQueryHyperpipeNetworkSGIXReq 16 + +/* +** glXQueryHyperpipeNetworkSGIX reply +*/ +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; /* not used */ + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD32 pad1 B32; + CARD32 n B32; + CARD32 npipes B32; /* NOTE: may hold a single value */ + CARD32 pad4 B32; /* NOTE: may hold half a double */ + CARD32 pad5 B32; + CARD32 pad6 B32; +} xGLXQueryHyperpipeNetworkSGIXReply; +#define sz_xGLXQueryHyperpipeNetworkSGIXReply 32 + +/* +** glXDestroyHyperpipeConfigSGIX request +*/ +typedef struct GLXDestroyHyperpipeConfigSGIX { + CARD8 reqType; + CARD8 glxCode; + CARD16 length B16; + CARD32 vendorCode B32; /* vendor-specific opcode */ + CARD32 pad1 B32; /* unused; corresponds to contextTag in header */ + CARD32 screen B32; + CARD32 hpId B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; +} xGLXDestroyHyperpipeConfigSGIXReq; +#define sz_xGLXDestroyHyperpipeConfigSGIXReq 32 + +/* +** glXDestroyHyperpipeConfigSGIX reply +*/ +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; /* not used */ + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD32 pad1 B32; + CARD32 n B32; + CARD32 success B32; /* NOTE: may hold a single value */ + CARD32 pad4 B32; /* NOTE: may hold half a double */ + CARD32 pad5 B32; + CARD32 pad6 B32; +} xGLXDestroyHyperpipeConfigSGIXReply; +#define sz_xGLXDestroyHyperpipeConfigSGIXReply 32 + +/* +** glXQueryHyperpipeConfigSGIX request +*/ +typedef struct GLXQueryHyperpipeConfigSGIX { + CARD8 reqType; + CARD8 glxCode; + CARD16 length B16; + CARD32 vendorCode B32; /* vendor-specific opcode */ + CARD32 pad1 B32; /* unused; corresponds to contextTag in header */ + CARD32 screen B32; + CARD32 hpId B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; +} xGLXQueryHyperpipeConfigSGIXReq; +#define sz_xGLXQueryHyperpipeConfigSGIXReq 32 + +/* +** glXQueryHyperpipeConfigSGIX reply +*/ +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; /* not used */ + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD32 pad1 B32; + CARD32 n B32; + CARD32 npipes B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; +} xGLXQueryHyperpipeConfigSGIXReply; +#define sz_xGLXQueryHyperpipeConfigSGIXReply 32 + +/* +** glXHyperpipeConfigSGIX request +*/ +typedef struct GLXHyperpipeConfigSGIX { + CARD8 reqType; + CARD8 glxCode; + CARD16 length B16; + CARD32 vendorCode B32; /* vendor-specific opcode */ + CARD32 pad1 B32; /* unused; corresponds to contextTag in header */ + CARD32 screen B32; + CARD32 npipes B32; + CARD32 networkId B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + /* followed by attribute list */ +} xGLXHyperpipeConfigSGIXReq; +#define sz_xGLXHyperpipeConfigSGIXReq 32 + +/* +** glXHyperpipeConfigSGIX reply +*/ +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; /* not used */ + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD32 pad1 B32; + CARD32 n B32; + CARD32 npipes B32; + CARD32 hpId B32; + CARD32 pad5 B32; + CARD32 pad6 B32; +} xGLXHyperpipeConfigSGIXReply; +#define sz_xGLXHyperpipeConfigSGIXReply 32 + /************************************************************************/ /* Index: programs/Xserver/GL/glx/global.c =================================================================== RCS file: /cvs/xorg/xc/programs/Xserver/GL/glx/global.c,v retrieving revision 1.3 diff -u -d -r1.3 global.c --- programs/Xserver/GL/glx/global.c 3 Jul 2005 07:01:02 -0000 1.3 +++ programs/Xserver/GL/glx/global.c 29 Aug 2005 23:54:45 -0000 @@ -53,6 +53,7 @@ RESTYPE __glXContextRes; RESTYPE __glXClientRes; RESTYPE __glXPixmapRes; +RESTYPE __glXSwapBarrierRes; /* ** Error codes with the extension error base already added in. Index: programs/Xserver/GL/glx/glxcmds.c =================================================================== RCS file: /cvs/xorg/xc/programs/Xserver/GL/glx/glxcmds.c,v retrieving revision 1.7 diff -u -d -r1.7 glxcmds.c --- programs/Xserver/GL/glx/glxcmds.c 6 Jul 2005 07:16:19 -0000 1.7 +++ programs/Xserver/GL/glx/glxcmds.c 29 Aug 2005 23:54:45 -0000 @@ -78,6 +78,14 @@ static int __glXCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc); static int __glXMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc); +static int __glXBindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc); +static int __glXQueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc); +static int __glxQueryHyperpipeNetworkSGIX(__GLXclientState *cl, GLbyte *pc); +static int __glxDestroyHyperpipeConfigSGIX (__GLXclientState *cl, GLbyte *pc); +static int __glxQueryHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc); +static int __glxHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc); + + /************************************************************************/ /** @@ -1719,6 +1727,231 @@ } } +extern RESTYPE __glXSwapBarrierRes; + +static int __glXBindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc) +{ + ClientPtr client = cl->client; + xGLXBindSwapBarrierSGIXReq *req = (xGLXBindSwapBarrierSGIXReq *) pc; + XID drawable = req->drawable; + int barrier = req->barrier; + DrawablePtr pDraw = (DrawablePtr) LookupDrawable(drawable, client); + int screen = pDraw->pScreen->myNum; + + + if (pDraw && (pDraw->type == DRAWABLE_WINDOW)) { + if (__glXSwapBarrierFuncs && + __glXSwapBarrierFuncs[screen].bindSwapBarrierFunc) { + int ret = __glXSwapBarrierFuncs[screen].bindSwapBarrierFunc(screen, drawable, barrier); + if (ret == Success) { + if (barrier) + /* add source for cleanup when drawable is gone */ + AddResource(drawable, __glXSwapBarrierRes, (pointer)screen); + else + /* delete source */ + FreeResourceByType(drawable, __glXSwapBarrierRes, FALSE); + } + return ret; + } + } + client->errorValue = drawable; + return __glXBadDrawable; +} + + +static int __glXQueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc) +{ + ClientPtr client = cl->client; + xGLXQueryMaxSwapBarriersSGIXReq *req = + (xGLXQueryMaxSwapBarriersSGIXReq *) pc; + xGLXQueryMaxSwapBarriersSGIXReply reply; + int screen = req->screen; + + if (__glXSwapBarrierFuncs && + __glXSwapBarrierFuncs[screen].queryMaxSwapBarriersFunc) + reply.max = __glXSwapBarrierFuncs[screen].queryMaxSwapBarriersFunc(screen); + else + reply.max = 0; + + + reply.length = 0; + reply.type = X_Reply; + reply.sequenceNumber = client->sequence; + + if (client->swapped) { + __GLX_DECLARE_SWAP_VARIABLES; + __GLX_SWAP_SHORT(&reply.sequenceNumber); + } + + WriteToClient(client, sz_xGLXQueryMaxSwapBarriersSGIXReply, + (char *) &reply); + return Success; +} + +#define GLX_BAD_HYPERPIPE_SGIX 92 + +static int __glxQueryHyperpipeNetworkSGIX(__GLXclientState *cl, GLbyte *pc) +{ + ClientPtr client = cl->client; + xGLXQueryHyperpipeNetworkSGIXReq * req = (xGLXQueryHyperpipeNetworkSGIXReq *) pc; + xGLXQueryHyperpipeNetworkSGIXReply reply; + int screen = req->screen; + void *rdata = NULL; + + int length=0; + int npipes=0; + + int n= 0; + + if (__glXHyperpipeFuncs && + __glXHyperpipeFuncs[screen].queryHyperpipeNetworkFunc != NULL) { + rdata = + (__glXHyperpipeFuncs[screen].queryHyperpipeNetworkFunc(screen, &npipes, &n)); + } + length = __GLX_PAD(n) >> 2; + reply.type = X_Reply; + reply.sequenceNumber = client->sequence; + reply.length = length; + reply.n = n; + reply.npipes = npipes; + + if (client->swapped) { + __GLX_DECLARE_SWAP_VARIABLES; + __GLX_SWAP_SHORT(&reply.sequenceNumber); + __GLX_SWAP_INT(&reply.length); + __GLX_SWAP_INT(&reply.n); + __GLX_SWAP_INT(&reply.npipes); + } + WriteToClient(client, sz_xGLXQueryHyperpipeNetworkSGIXReply, + (char *) &reply); + + WriteToClient(client, length << 2, (char *)rdata); + + return Success; +} + +static int __glxDestroyHyperpipeConfigSGIX (__GLXclientState *cl, GLbyte *pc) +{ + ClientPtr client = cl->client; + xGLXDestroyHyperpipeConfigSGIXReq * req = + (xGLXDestroyHyperpipeConfigSGIXReq *) pc; + xGLXDestroyHyperpipeConfigSGIXReply reply; + int screen = req->screen; + int success = GLX_BAD_HYPERPIPE_SGIX; + int hpId ; + + hpId = req->hpId; + + + if (__glXHyperpipeFuncs && + __glXHyperpipeFuncs[screen].destroyHyperpipeConfigFunc != NULL) { + success = __glXHyperpipeFuncs[screen].destroyHyperpipeConfigFunc(screen, hpId); + } + + reply.type = X_Reply; + reply.sequenceNumber = client->sequence; + reply.length = __GLX_PAD(0) >> 2; + reply.n = 0; + reply.success = success; + + + if (client->swapped) { + __GLX_DECLARE_SWAP_VARIABLES; + __GLX_SWAP_SHORT(&reply.sequenceNumber); + } + WriteToClient(client, + sz_xGLXDestroyHyperpipeConfigSGIXReply, + (char *) &reply); + return Success; +} + +static int __glxQueryHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc) +{ + ClientPtr client = cl->client; + xGLXQueryHyperpipeConfigSGIXReq * req = + (xGLXQueryHyperpipeConfigSGIXReq *) pc; + xGLXQueryHyperpipeConfigSGIXReply reply; + int screen = req->screen; + void *rdata = NULL; + int length; + int npipes=0; + int n= 0; + int hpId; + + hpId = req->hpId; + + if (__glXHyperpipeFuncs && + __glXHyperpipeFuncs[screen].queryHyperpipeConfigFunc != NULL) { + rdata = __glXHyperpipeFuncs[screen].queryHyperpipeConfigFunc(screen, hpId,&npipes, &n); + } + + length = __GLX_PAD(n) >> 2; + reply.type = X_Reply; + reply.sequenceNumber = client->sequence; + reply.length = length; + reply.n = n; + reply.npipes = npipes; + + + if (client->swapped) { + __GLX_DECLARE_SWAP_VARIABLES; + __GLX_SWAP_SHORT(&reply.sequenceNumber); + __GLX_SWAP_INT(&reply.length); + __GLX_SWAP_INT(&reply.n); + __GLX_SWAP_INT(&reply.npipes); + } + + WriteToClient(client, sz_xGLXQueryHyperpipeConfigSGIXReply, + (char *) &reply); + + WriteToClient(client, length << 2, (char *)rdata); + + return Success; +} + +static int __glxHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc) +{ + ClientPtr client = cl->client; + xGLXHyperpipeConfigSGIXReq * req = + (xGLXHyperpipeConfigSGIXReq *) pc; + xGLXHyperpipeConfigSGIXReply reply; + int screen = req->screen; + void *rdata; + + int npipes=0, networkId; + int hpId=-1; + + networkId = (int)req->networkId; + npipes = (int)req->npipes; + rdata = (void *)(req +1); + + if (__glXHyperpipeFuncs && + __glXHyperpipeFuncs[screen].hyperpipeConfigFunc != NULL) { + __glXHyperpipeFuncs[screen].hyperpipeConfigFunc(screen,networkId, + &hpId, &npipes, + (void *) rdata); + } + + reply.type = X_Reply; + reply.sequenceNumber = client->sequence; + reply.length = __GLX_PAD(0) >> 2; + reply.n = 0; + reply.npipes = npipes; + reply.hpId = hpId; + + if (client->swapped) { + __GLX_DECLARE_SWAP_VARIABLES; + __GLX_SWAP_SHORT(&reply.sequenceNumber); + __GLX_SWAP_INT(&reply.npipes); + __GLX_SWAP_INT(&reply.hpId); + } + + WriteToClient(client, sz_xGLXHyperpipeConfigSGIXReply, + (char *) &reply); + + return Success; +} + /************************************************************************/ @@ -1744,6 +1977,8 @@ case X_GLvop_SamplePatternSGIS: glSamplePatternSGIS( *(GLenum *)(pc + 4)); return Success; + case X_GLXvop_BindSwapBarrierSGIX: + return __glXBindSwapBarrierSGIX(cl, pc); } #endif @@ -1773,6 +2008,16 @@ return __glXQueryContextInfoEXT(cl, pc); case X_GLXvop_MakeCurrentReadSGI: return __glXMakeCurrentReadSGI(cl, pc); + case X_GLXvop_QueryMaxSwapBarriersSGIX: + return __glXQueryMaxSwapBarriersSGIX(cl, pc); + case X_GLXvop_QueryHyperpipeNetworkSGIX: + return __glxQueryHyperpipeNetworkSGIX(cl, pc); + case X_GLXvop_QueryHyperpipeConfigSGIX: + return __glxQueryHyperpipeConfigSGIX(cl, pc); + case X_GLXvop_DestroyHyperpipeConfigSGIX: + return __glxDestroyHyperpipeConfigSGIX(cl, pc); + case X_GLXvop_HyperpipeConfigSGIX: + return __glxHyperpipeConfigSGIX(cl, pc); case X_GLXvop_GetFBConfigsSGIX: return __glXGetFBConfigsSGIX(cl, pc); case X_GLXvop_CreateContextWithConfigSGIX: Index: programs/Xserver/GL/glx/glxext.c =================================================================== RCS file: /cvs/xorg/xc/programs/Xserver/GL/glx/glxext.c,v retrieving revision 1.5 diff -u -d -r1.5 glxext.c --- programs/Xserver/GL/glx/glxext.c 3 Jul 2005 07:01:02 -0000 1.5 +++ programs/Xserver/GL/glx/glxext.c 29 Aug 2005 23:54:45 -0000 @@ -180,6 +180,18 @@ return GL_TRUE; } +extern RESTYPE __glXSwapBarrierRes; + +static int SwapBarrierGone(int screen, XID drawable) +{ + if (__glXSwapBarrierFuncs && + __glXSwapBarrierFuncs[screen].bindSwapBarrierFunc != NULL) { + __glXSwapBarrierFuncs[screen].bindSwapBarrierFunc(screen, drawable, 0); + } + FreeResourceByType(drawable, __glXSwapBarrierRes, FALSE); + return True; +} + /************************************************************************/ /* @@ -256,6 +268,8 @@ __glXUnsupportedPrivateRequest = extEntry->errorBase + GLXUnsupportedPrivateRequest; + __glXSwapBarrierRes = CreateNewResourceType((DeleteType)SwapBarrierGone); + /* ** Initialize table of client state. There is never a client 0. */ Index: programs/Xserver/GL/glx/glxext.h =================================================================== RCS file: /cvs/xorg/xc/programs/Xserver/GL/glx/glxext.h,v retrieving revision 1.4 diff -u -d -r1.4 glxext.h --- programs/Xserver/GL/glx/glxext.h 3 Jul 2005 07:01:02 -0000 1.4 +++ programs/Xserver/GL/glx/glxext.h 29 Aug 2005 23:54:45 -0000 @@ -107,5 +107,25 @@ int preferredVis ); +typedef struct { + void * (* queryHyperpipeNetworkFunc)(int, int *, int *); + void * (* queryHyperpipeConfigFunc)(int, int, int *, int *); + int (* destroyHyperpipeConfigFunc)(int, int); + void * (* hyperpipeConfigFunc)(int, int, int *, int *, void *); +} __GLXHyperpipeExtensionFuncs; + +extern void __glXHyperpipeInit(int screen, __GLXHyperpipeExtensionFuncs *funcs); + +extern __GLXHyperpipeExtensionFuncs *__glXHyperpipeFuncs; + +typedef struct { + int (* bindSwapBarrierFunc)(int, XID, int); + int (* queryMaxSwapBarriersFunc)(int); +} __GLXSwapBarrierExtensionFuncs; + +extern void __glXSwapBarrierInit(int screen, __GLXSwapBarrierExtensionFuncs *funcs); + +extern __GLXSwapBarrierExtensionFuncs *__glXSwapBarrierFuncs; + #endif /* _glxext_h_ */ Index: programs/Xserver/GL/glx/glxscreens.c =================================================================== RCS file: /cvs/xorg/xc/programs/Xserver/GL/glx/glxscreens.c,v retrieving revision 1.7 diff -u -d -r1.7 glxscreens.c --- programs/Xserver/GL/glx/glxscreens.c 3 Jul 2005 07:01:02 -0000 1.7 +++ programs/Xserver/GL/glx/glxscreens.c 29 Aug 2005 23:54:45 -0000 @@ -49,6 +49,7 @@ #include "glxserver.h" #include "glxutil.h" +#include "glxext.h" const char GLServerVersion[] = "1.2"; static const char GLServerExtensions[] = @@ -135,6 +136,8 @@ "GLX_SGI_make_current_read " #ifndef __DARWIN__ "GLX_SGIS_multisample " + "GLX_SGIX_hyperpipe " + "GLX_SGIX_swap_barrier " #endif "GLX_SGIX_fbconfig " ; @@ -154,6 +157,12 @@ __GLXscreenInfo *__glXActiveScreens; GLint __glXNumActiveScreens; +__GLXSwapBarrierExtensionFuncs *__glXSwapBarrierFuncs = NULL; +static int __glXNumSwapBarrierFuncs = 0; +__GLXHyperpipeExtensionFuncs *__glXHyperpipeFuncs = NULL; +static int __glXNumHyperpipeFuncs = 0; + + RESTYPE __glXDrawableRes; __GLXscreenInfo *__glXgetActiveScreen(int num) { @@ -270,6 +279,38 @@ pScreen->PositionWindow = PositionWindow; } +void __glXHyperpipeInit(int screen, __GLXHyperpipeExtensionFuncs *funcs) +{ + if (__glXNumHyperpipeFuncs < screen + 1) { + __glXHyperpipeFuncs = __glXRealloc(__glXHyperpipeFuncs, + (screen+1) * sizeof(__GLXHyperpipeExtensionFuncs)); + __glXNumHyperpipeFuncs = screen + 1; + } + + __glXHyperpipeFuncs[screen].queryHyperpipeNetworkFunc = + *funcs->queryHyperpipeNetworkFunc; + __glXHyperpipeFuncs[screen].queryHyperpipeConfigFunc = + *funcs->queryHyperpipeConfigFunc; + __glXHyperpipeFuncs[screen].destroyHyperpipeConfigFunc = + *funcs->destroyHyperpipeConfigFunc; + __glXHyperpipeFuncs[screen].hyperpipeConfigFunc = + *funcs->hyperpipeConfigFunc; +} + +void __glXSwapBarrierInit(int screen, __GLXSwapBarrierExtensionFuncs *funcs) +{ + if (__glXNumSwapBarrierFuncs < screen + 1) { + __glXSwapBarrierFuncs = __glXRealloc(__glXSwapBarrierFuncs, + (screen+1) * sizeof(__GLXSwapBarrierExtensionFuncs)); + __glXNumSwapBarrierFuncs = screen + 1; + } + + __glXSwapBarrierFuncs[screen].bindSwapBarrierFunc = + funcs->bindSwapBarrierFunc; + __glXSwapBarrierFuncs[screen].queryMaxSwapBarriersFunc = + funcs->queryMaxSwapBarriersFunc; +} + void __glXScreenInit(GLint numscreens) { GLint i,j; @@ -315,6 +356,12 @@ __glXFree(__glXActiveScreens[i].GLextensions); } xfree(__glXActiveScreens); + xfree(__glXHyperpipeFuncs); + xfree(__glXSwapBarrierFuncs); + __glXNumHyperpipeFuncs = 0; + __glXNumSwapBarrierFuncs = 0; + __glXHyperpipeFuncs = NULL; + __glXSwapBarrierFuncs = NULL; __glXActiveScreens = NULL; __glXNumActiveScreens = 0; }