X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fglx%2Fx11%2Fglx_pbuffer.c;h=c63d53439d54a0ac80766f2b6b36ed092719e7e7;hb=e1fbb30211549f2ee79d8ff9764f833e5317bebe;hp=a03189ae3e6313d77007f1e9010314bdff304f9a;hpb=cb3610e37c4c0a40520441b8515d044dabcc8854;p=mesa.git diff --git a/src/glx/x11/glx_pbuffer.c b/src/glx/x11/glx_pbuffer.c index a03189ae3e6..c63d53439d5 100644 --- a/src/glx/x11/glx_pbuffer.c +++ b/src/glx/x11/glx_pbuffer.c @@ -31,30 +31,14 @@ #include #include "glxclient.h" -#include -#include +#include +#include #include #include #include "glapi.h" #include "glxextensions.h" #include "glcontextmodes.h" -#ifdef IN_DOXYGEN -#define GLX_PREFIX(x) x -#endif /* IN_DOXYGEN */ - -static void ChangeDrawableAttribute( Display * dpy, GLXDrawable drawable, - const CARD32 * attribs, size_t num_attribs ); - -static void DestroyPbuffer( Display * dpy, GLXDrawable drawable ); - -static GLXDrawable CreatePbuffer( Display *dpy, - const __GLcontextModes * fbconfig, unsigned int width, unsigned int height, - const int *attrib_list, GLboolean size_in_attribs ); - -static int GetDrawableAttribute( Display *dpy, GLXDrawable drawable, - int attribute, unsigned int *value ); - /** * Change a drawable's attribute. @@ -70,27 +54,30 @@ static int GetDrawableAttribute( Display *dpy, GLXDrawable drawable, * This function needs to be modified to work with direct-rendering drivers. */ static void -ChangeDrawableAttribute( Display * dpy, GLXDrawable drawable, - const CARD32 * attribs, size_t num_attribs ) +ChangeDrawableAttribute(Display * dpy, GLXDrawable drawable, + const CARD32 * attribs, size_t num_attribs) { __GLXdisplayPrivate *priv = __glXInitialize(dpy); - CARD32 * output; - + CARD32 *output; + CARD8 opcode; - if ( (dpy == NULL) || (drawable == 0) ) { + if ((dpy == NULL) || (drawable == 0)) { return; } + opcode = __glXSetupForCommand(dpy); + if (!opcode) + return; LockDisplay(dpy); - if ( (priv->majorVersion > 1) || (priv->minorVersion >= 3) ) { + if ((priv->majorVersion > 1) || (priv->minorVersion >= 3)) { xGLXChangeDrawableAttributesReq *req; - GetReqExtra( GLXChangeDrawableAttributes, 8 + (8 * num_attribs), req ); + GetReqExtra(GLXChangeDrawableAttributes, 8 + (8 * num_attribs), req); output = (CARD32 *) (req + 1); - req->reqType = __glXSetupForCommand(dpy); + req->reqType = opcode; req->glxCode = X_GLXChangeDrawableAttributes; req->drawable = drawable; req->numAttribs = (CARD32) num_attribs; @@ -98,10 +85,10 @@ ChangeDrawableAttribute( Display * dpy, GLXDrawable drawable, else { xGLXVendorPrivateWithReplyReq *vpreq; - GetReqExtra( GLXVendorPrivateWithReply, 4 + (8 * num_attribs), vpreq ); + GetReqExtra(GLXVendorPrivateWithReply, 4 + (8 * num_attribs), vpreq); output = (CARD32 *) (vpreq + 1); - vpreq->reqType = __glXSetupForCommand(dpy); + vpreq->reqType = opcode; vpreq->glxCode = X_GLXVendorPrivateWithReply; vpreq->vendorCode = X_GLXvop_ChangeDrawableAttributesSGIX; @@ -109,7 +96,7 @@ ChangeDrawableAttribute( Display * dpy, GLXDrawable drawable, output++; } - (void) memcpy( output, attribs, sizeof( CARD32 ) * 2 * num_attribs ); + (void) memcpy(output, attribs, sizeof(CARD32) * 2 * num_attribs); UnlockDisplay(dpy); SyncHandle(); @@ -132,35 +119,39 @@ ChangeDrawableAttribute( Display * dpy, GLXDrawable drawable, * This function needs to be modified to work with direct-rendering drivers. */ static void -DestroyPbuffer( Display * dpy, GLXDrawable drawable ) +DestroyPbuffer(Display * dpy, GLXDrawable drawable) { __GLXdisplayPrivate *priv = __glXInitialize(dpy); + CARD8 opcode; - if ( (dpy == NULL) || (drawable == 0) ) { + if ((dpy == NULL) || (drawable == 0)) { return; } + opcode = __glXSetupForCommand(dpy); + if (!opcode) + return; LockDisplay(dpy); - if ( (priv->majorVersion > 1) || (priv->minorVersion >= 3) ) { - xGLXDestroyPbufferReq * req; + if ((priv->majorVersion > 1) || (priv->minorVersion >= 3)) { + xGLXDestroyPbufferReq *req; - GetReqExtra( GLXDestroyPbuffer, 4, req ); - req->reqType = __glXSetupForCommand(dpy); + GetReq(GLXDestroyPbuffer, req); + req->reqType = opcode; req->glxCode = X_GLXDestroyPbuffer; req->pbuffer = (GLXPbuffer) drawable; } else { xGLXVendorPrivateWithReplyReq *vpreq; - CARD32 * data; + CARD32 *data; - GetReqExtra( GLXVendorPrivateWithReply, 4, vpreq ); + GetReqExtra(GLXVendorPrivateWithReply, 4, vpreq); data = (CARD32 *) (vpreq + 1); data[0] = (CARD32) drawable; - vpreq->reqType = __glXSetupForCommand(dpy); + vpreq->reqType = opcode; vpreq->glxCode = X_GLXVendorPrivateWithReply; vpreq->vendorCode = X_GLXvop_DestroyGLXPbufferSGIX; } @@ -172,6 +163,34 @@ DestroyPbuffer( Display * dpy, GLXDrawable drawable ) } +#ifdef GLX_DIRECT_RENDERING +extern __GLXDRIdrawable *GetGLXDRIDrawable(Display * dpy, + GLXDrawable drawable, + int *const scrn_num); + +static GLenum +determineTextureTarget(const int *attribs, int numAttribs) +{ + GLenum target = 0; + int i; + + for (i = 0; i < numAttribs; i++) { + if (attribs[2 * i] == GLX_TEXTURE_TARGET_EXT) { + switch (attribs[2 * i + 1]) { + case GLX_TEXTURE_2D_EXT: + target = GL_TEXTURE_2D; + break; + case GLX_TEXTURE_RECTANGLE_EXT: + target = GL_TEXTURE_RECTANGLE_ARB; + break; + } + } + } + + return target; +} +#endif + /** * Get a drawable's attribute. * @@ -191,79 +210,103 @@ DestroyPbuffer( Display * dpy, GLXDrawable drawable ) * This function needs to be modified to work with direct-rendering drivers. */ static int -GetDrawableAttribute( Display *dpy, GLXDrawable drawable, - int attribute, unsigned int *value ) +GetDrawableAttribute(Display * dpy, GLXDrawable drawable, + int attribute, unsigned int *value) { - __GLXdisplayPrivate *priv = __glXInitialize(dpy); + __GLXdisplayPrivate *priv; xGLXGetDrawableAttributesReply reply; - CARD32 * data; + CARD32 *data; + CARD8 opcode; unsigned int length; unsigned int i; unsigned int num_attributes; + + if ((dpy == NULL) || (drawable == 0)) { + return 0; + } + + priv = __glXInitialize(dpy); GLboolean use_glx_1_3 = ((priv->majorVersion > 1) - || (priv->minorVersion >= 3)); + || (priv->minorVersion >= 3)); + + *value = 0; - if ( (dpy == NULL) || (drawable == 0) ) { + opcode = __glXSetupForCommand(dpy); + if (!opcode) return 0; - } - LockDisplay(dpy); - if ( use_glx_1_3 ) { + if (use_glx_1_3) { xGLXGetDrawableAttributesReq *req; - GetReqExtra( GLXGetDrawableAttributes, 4, req ); - req->reqType = __glXSetupForCommand(dpy); + GetReqExtra(GLXGetDrawableAttributes, 4, req); + req->reqType = opcode; req->glxCode = X_GLXGetDrawableAttributes; req->drawable = drawable; } else { xGLXVendorPrivateWithReplyReq *vpreq; - GetReqExtra( GLXVendorPrivateWithReply, 4, vpreq ); + GetReqExtra(GLXVendorPrivateWithReply, 4, vpreq); data = (CARD32 *) (vpreq + 1); data[0] = (CARD32) drawable; - vpreq->reqType = __glXSetupForCommand(dpy); + vpreq->reqType = opcode; vpreq->glxCode = X_GLXVendorPrivateWithReply; vpreq->vendorCode = X_GLXvop_GetDrawableAttributesSGIX; } - _XReply(dpy, (xReply*) &reply, 0, False); + _XReply(dpy, (xReply *) & reply, 0, False); - length = reply.length; - num_attributes = (use_glx_1_3) ? reply.numAttribs : length / 2; - data = (CARD32 *) Xmalloc( length * sizeof(CARD32) ); - if ( data == NULL ) { - /* Throw data on the floor */ - _XEatData(dpy, length); - } else { - _XRead(dpy, (char *)data, length * sizeof(CARD32) ); + if (reply.type == X_Error) { + UnlockDisplay(dpy); + SyncHandle(); + return 0; } - UnlockDisplay(dpy); - SyncHandle(); - - - /* Search the set of returned attributes for the attribute requested by - * the caller. - */ - - for ( i = 0 ; i < num_attributes ; i++ ) { - if ( data[i*2] == attribute ) { - *value = data[ (i*2) + 1 ]; - break; + length = reply.length; + if (length) { + num_attributes = (use_glx_1_3) ? reply.numAttribs : length / 2; + data = (CARD32 *) Xmalloc(length * sizeof(CARD32)); + if (data == NULL) { + /* Throw data on the floor */ + _XEatData(dpy, length); + } + else { + _XRead(dpy, (char *) data, length * sizeof(CARD32)); + + /* Search the set of returned attributes for the attribute requested by + * the caller. + */ + for (i = 0; i < num_attributes; i++) { + if (data[i * 2] == attribute) { + *value = data[(i * 2) + 1]; + break; + } + } + +#ifdef GLX_DIRECT_RENDERING + { + __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, NULL); + + if (pdraw != NULL && !pdraw->textureTarget) + pdraw->textureTarget = + determineTextureTarget((const int *) data, num_attributes); + } +#endif + + Xfree(data); } } - Xfree( data ); + UnlockDisplay(dpy); + SyncHandle(); return 0; } - /** * Create a non-pbuffer GLX drawable. * @@ -271,33 +314,70 @@ GetDrawableAttribute( Display *dpy, GLXDrawable drawable, * This function needs to be modified to work with direct-rendering drivers. */ static GLXDrawable -CreateDrawable( Display *dpy, const __GLcontextModes * fbconfig, - Drawable drawable, const int *attrib_list, - CARD8 glxCode ) +CreateDrawable(Display * dpy, const __GLcontextModes * fbconfig, + Drawable drawable, const int *attrib_list, CARD8 glxCode) { - xGLXCreateWindowReq * req; - CARD32 * data; - unsigned int i; + xGLXCreateWindowReq *req; + CARD32 *data; + unsigned int i; + CARD8 opcode; + i = 0; + if (attrib_list) { + while (attrib_list[i * 2] != None) + i++; + } - for ( i = 0 ; attrib_list[i * 2] != None ; i++ ) - /* empty */ ; + opcode = __glXSetupForCommand(dpy); + if (!opcode) + return None; LockDisplay(dpy); - GetReqExtra( GLXCreateWindow, 20 + (8 * i), req ); + GetReqExtra(GLXCreateWindow, 8 * i, req); data = (CARD32 *) (req + 1); - req->reqType = __glXSetupForCommand(dpy); + req->reqType = opcode; req->glxCode = glxCode; req->screen = (CARD32) fbconfig->screen; req->fbconfig = fbconfig->fbconfigID; - req->window = (GLXPbuffer) drawable; + req->window = (CARD32) drawable; + req->glxwindow = (GLXWindow) XAllocID(dpy); req->numAttribs = (CARD32) i; + memcpy(data, attrib_list, 8 * i); + UnlockDisplay(dpy); SyncHandle(); - - return drawable; + +#ifdef GLX_DIRECT_RENDERING + do { + /* FIXME: Maybe delay __DRIdrawable creation until the drawable + * is actually bound to a context... */ + + __GLXdisplayPrivate *const priv = __glXInitialize(dpy); + __GLXDRIdrawable *pdraw; + __GLXscreenConfigs *psc; + + psc = &priv->screenConfigs[fbconfig->screen]; + if (psc->driScreen == NULL) + break; + pdraw = psc->driScreen->createDrawable(psc, drawable, + req->glxwindow, fbconfig); + if (pdraw == NULL) { + fprintf(stderr, "failed to create drawable\n"); + break; + } + + if (__glxHashInsert(psc->drawHash, req->glxwindow, pdraw)) { + (*pdraw->destroyDrawable) (pdraw); + return None; /* FIXME: Check what we're supposed to do here... */ + } + + pdraw->textureTarget = determineTextureTarget(attrib_list, i); + } while (0); +#endif + + return (GLXDrawable) req->glxwindow; } @@ -308,25 +388,44 @@ CreateDrawable( Display *dpy, const __GLcontextModes * fbconfig, * This function needs to be modified to work with direct-rendering drivers. */ static void -DestroyDrawable( Display * dpy, GLXDrawable drawable, CARD32 glxCode ) +DestroyDrawable(Display * dpy, GLXDrawable drawable, CARD32 glxCode) { - xGLXDestroyPbufferReq * req; + xGLXDestroyPbufferReq *req; + CARD8 opcode; - if ( (dpy == NULL) || (drawable == 0) ) { + if ((dpy == NULL) || (drawable == 0)) { return; } + opcode = __glXSetupForCommand(dpy); + if (!opcode) + return; + LockDisplay(dpy); - GetReqExtra( GLXDestroyPbuffer, 4, req ); - req->reqType = __glXSetupForCommand(dpy); + GetReqExtra(GLXDestroyPbuffer, 4, req); + req->reqType = opcode; req->glxCode = glxCode; req->pbuffer = (GLXPbuffer) drawable; UnlockDisplay(dpy); SyncHandle(); +#ifdef GLX_DIRECT_RENDERING + { + int screen; + __GLXdisplayPrivate *const priv = __glXInitialize(dpy); + __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &screen); + __GLXscreenConfigs *psc = &priv->screenConfigs[screen]; + + if (pdraw != NULL) { + (*pdraw->destroyDrawable) (pdraw); + __glxHashDelete(psc->drawHash, drawable); + } + } +#endif + return; } @@ -345,52 +444,58 @@ DestroyDrawable( Display * dpy, GLXDrawable drawable, CARD32 glxCode ) * This function needs to be modified to work with direct-rendering drivers. */ static GLXDrawable -CreatePbuffer( Display *dpy, const __GLcontextModes * fbconfig, - unsigned int width, unsigned int height, - const int *attrib_list, GLboolean size_in_attribs ) +CreatePbuffer(Display * dpy, const __GLcontextModes * fbconfig, + unsigned int width, unsigned int height, + const int *attrib_list, GLboolean size_in_attribs) { __GLXdisplayPrivate *priv = __glXInitialize(dpy); GLXDrawable id = 0; - CARD32 * data; - unsigned int i; - + CARD32 *data; + CARD8 opcode; + unsigned int i; - for ( i = 0 ; attrib_list[i * 2] != None ; i++ ) - /* empty */ ; + i = 0; + if (attrib_list) { + while (attrib_list[i * 2]) + i++; + } + opcode = __glXSetupForCommand(dpy); + if (!opcode) + return None; LockDisplay(dpy); id = XAllocID(dpy); - if ( (priv->majorVersion > 1) || (priv->minorVersion >= 3) ) { - xGLXCreatePbufferReq * req; + if ((priv->majorVersion > 1) || (priv->minorVersion >= 3)) { + xGLXCreatePbufferReq *req; unsigned int extra = (size_in_attribs) ? 0 : 2; - GetReqExtra( GLXCreatePbuffer, (8 * (i + extra)), req ); + GetReqExtra(GLXCreatePbuffer, (8 * (i + extra)), req); data = (CARD32 *) (req + 1); - req->reqType = __glXSetupForCommand(dpy); + req->reqType = opcode; req->glxCode = X_GLXCreatePbuffer; req->screen = (CARD32) fbconfig->screen; req->fbconfig = fbconfig->fbconfigID; req->pbuffer = (GLXPbuffer) id; req->numAttribs = (CARD32) (i + extra); - if ( ! size_in_attribs ) { - data[(2 * i) + 0] = GLX_PBUFFER_WIDTH; - data[(2 * i) + 1] = width; - data[(2 * i) + 2] = GLX_PBUFFER_HEIGHT; - data[(2 * i) + 3] = height; - data += 4; + if (!size_in_attribs) { + data[(2 * i) + 0] = GLX_PBUFFER_WIDTH; + data[(2 * i) + 1] = width; + data[(2 * i) + 2] = GLX_PBUFFER_HEIGHT; + data[(2 * i) + 3] = height; + data += 4; } } else { xGLXVendorPrivateReq *vpreq; - GetReqExtra( GLXVendorPrivate, 20 + (8 * i), vpreq ); + GetReqExtra(GLXVendorPrivate, 20 + (8 * i), vpreq); data = (CARD32 *) (vpreq + 1); - vpreq->reqType = __glXSetupForCommand(dpy); + vpreq->reqType = opcode; vpreq->glxCode = X_GLXVendorPrivate; vpreq->vendorCode = X_GLXvop_CreateGLXPbufferSGIX; @@ -402,7 +507,7 @@ CreatePbuffer( Display *dpy, const __GLcontextModes * fbconfig, data += 5; } - (void) memcpy( data, attrib_list, sizeof(CARD32) * 2 * i ); + (void) memcpy(data, attrib_list, sizeof(CARD32) * 2 * i); UnlockDisplay(dpy); SyncHandle(); @@ -414,84 +519,96 @@ CreatePbuffer( Display *dpy, const __GLcontextModes * fbconfig, /** * Create a new pbuffer. */ -GLXPbufferSGIX -GLX_PREFIX(glXCreateGLXPbufferSGIX)(Display *dpy, GLXFBConfigSGIX config, - unsigned int width, unsigned int height, - int *attrib_list) +PUBLIC GLXPbufferSGIX +glXCreateGLXPbufferSGIX(Display * dpy, GLXFBConfigSGIX config, + unsigned int width, unsigned int height, + int *attrib_list) { - return (GLXPbufferSGIX) CreatePbuffer( dpy, (__GLcontextModes *) config, - width, height, - attrib_list, GL_FALSE ); + return (GLXPbufferSGIX) CreatePbuffer(dpy, (__GLcontextModes *) config, + width, height, + attrib_list, GL_FALSE); } /** * Create a new pbuffer. */ -GLXPbuffer -GLX_PREFIX(glXCreatePbuffer)(Display *dpy, GLXFBConfig config, - const int *attrib_list) +PUBLIC GLXPbuffer +glXCreatePbuffer(Display * dpy, GLXFBConfig config, const int *attrib_list) { - return (GLXPbuffer) CreatePbuffer( dpy, (__GLcontextModes *) config, - 0, 0, - attrib_list, GL_TRUE ); + int i, width, height; + + width = 0; + height = 0; + + for (i = 0; attrib_list[i * 2]; i++) { + switch (attrib_list[i * 2]) { + case GLX_PBUFFER_WIDTH: + width = attrib_list[i * 2 + 1]; + break; + case GLX_PBUFFER_HEIGHT: + height = attrib_list[i * 2 + 1]; + break; + } + } + + return (GLXPbuffer) CreatePbuffer(dpy, (__GLcontextModes *) config, + width, height, attrib_list, GL_TRUE); } /** * Destroy an existing pbuffer. */ -void -GLX_PREFIX(glXDestroyPbuffer)(Display *dpy, GLXPbuffer pbuf) +PUBLIC void +glXDestroyPbuffer(Display * dpy, GLXPbuffer pbuf) { - DestroyPbuffer( dpy, pbuf ); + DestroyPbuffer(dpy, pbuf); } /** * Query an attribute of a drawable. */ -void -GLX_PREFIX(glXQueryDrawable)(Display *dpy, GLXDrawable drawable, - int attribute, unsigned int *value) +PUBLIC void +glXQueryDrawable(Display * dpy, GLXDrawable drawable, + int attribute, unsigned int *value) { - GetDrawableAttribute( dpy, drawable, attribute, value ); + GetDrawableAttribute(dpy, drawable, attribute, value); } /** * Query an attribute of a pbuffer. */ -int -GLX_PREFIX(glXQueryGLXPbufferSGIX)(Display *dpy, GLXPbufferSGIX drawable, - int attribute, unsigned int *value) +PUBLIC int +glXQueryGLXPbufferSGIX(Display * dpy, GLXPbufferSGIX drawable, + int attribute, unsigned int *value) { - return GetDrawableAttribute( dpy, drawable, attribute, value ); + return GetDrawableAttribute(dpy, drawable, attribute, value); } /** * Select the event mask for a drawable. */ -void -GLX_PREFIX(glXSelectEvent)(Display *dpy, GLXDrawable drawable, - unsigned long mask) +PUBLIC void +glXSelectEvent(Display * dpy, GLXDrawable drawable, unsigned long mask) { CARD32 attribs[2]; attribs[0] = (CARD32) GLX_EVENT_MASK; attribs[1] = (CARD32) mask; - ChangeDrawableAttribute( dpy, drawable, attribs, 1 ); + ChangeDrawableAttribute(dpy, drawable, attribs, 1); } /** * Get the selected event mask for a drawable. */ -void -GLX_PREFIX(glXGetSelectedEvent)(Display *dpy, GLXDrawable drawable, - unsigned long *mask) +PUBLIC void +glXGetSelectedEvent(Display * dpy, GLXDrawable drawable, unsigned long *mask) { unsigned int value; @@ -501,56 +618,56 @@ GLX_PREFIX(glXGetSelectedEvent)(Display *dpy, GLXDrawable drawable, * we could just type-cast the pointer, but why? */ - GetDrawableAttribute( dpy, drawable, GLX_EVENT_MASK_SGIX, & value ); + GetDrawableAttribute(dpy, drawable, GLX_EVENT_MASK_SGIX, &value); *mask = value; } -GLXPixmap -GLX_PREFIX(glXCreatePixmap)( Display *dpy, GLXFBConfig config, Pixmap pixmap, - const int *attrib_list ) +PUBLIC GLXPixmap +glXCreatePixmap(Display * dpy, GLXFBConfig config, Pixmap pixmap, + const int *attrib_list) { - return CreateDrawable( dpy, (__GLcontextModes *) config, - (Drawable) pixmap, attrib_list, - X_GLXCreatePixmap ); + return CreateDrawable(dpy, (__GLcontextModes *) config, + (Drawable) pixmap, attrib_list, X_GLXCreatePixmap); } -GLXWindow -GLX_PREFIX(glXCreateWindow)( Display *dpy, GLXFBConfig config, Window win, - const int *attrib_list ) +PUBLIC GLXWindow +glXCreateWindow(Display * dpy, GLXFBConfig config, Window win, + const int *attrib_list) { - return CreateDrawable( dpy, (__GLcontextModes *) config, - (Drawable) win, attrib_list, - X_GLXCreateWindow ); + return CreateDrawable(dpy, (__GLcontextModes *) config, + (Drawable) win, attrib_list, X_GLXCreateWindow); } -void -GLX_PREFIX(glXDestroyPixmap)(Display *dpy, GLXPixmap pixmap) +PUBLIC void +glXDestroyPixmap(Display * dpy, GLXPixmap pixmap) { - DestroyDrawable( dpy, (GLXDrawable) pixmap, X_GLXDestroyPixmap ); + DestroyDrawable(dpy, (GLXDrawable) pixmap, X_GLXDestroyPixmap); } -void -GLX_PREFIX(glXDestroyWindow)(Display *dpy, GLXWindow win) +PUBLIC void +glXDestroyWindow(Display * dpy, GLXWindow win) { - DestroyDrawable( dpy, (GLXDrawable) win, X_GLXDestroyWindow ); + DestroyDrawable(dpy, (GLXDrawable) win, X_GLXDestroyWindow); } +PUBLIC GLX_ALIAS_VOID(glXDestroyGLXPbufferSGIX, - (Display *dpy, GLXPbufferSGIX pbuf), - (dpy, pbuf), - glXDestroyPbuffer) + (Display * dpy, GLXPbufferSGIX pbuf), + (dpy, pbuf), glXDestroyPbuffer) +PUBLIC GLX_ALIAS_VOID(glXSelectEventSGIX, - (Display *dpy, GLXDrawable drawable, unsigned long mask), - (dpy, drawable, mask), - glXSelectEvent) + (Display * dpy, GLXDrawable drawable, + unsigned long mask), (dpy, drawable, mask), + glXSelectEvent) +PUBLIC GLX_ALIAS_VOID(glXGetSelectedEventSGIX, - (Display *dpy, GLXDrawable drawable, unsigned long *mask), - (dpy, drawable, mask), - glXGetSelectedEvent) + (Display * dpy, GLXDrawable drawable, + unsigned long *mask), (dpy, drawable, mask), + glXGetSelectedEvent)