frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix GLX byteswapping.

This commit is contained in:
Kristian Høgsberg 2007-10-14 14:59:12 -04:00
parent 927757e102
commit ec0fc012e9
3 changed files with 143 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

136
GL/glx/glxcmds.c
View File

@ -109,9 +109,10 @@ static __GLXcontext *__glXdirectContextCreate(__GLXscreen *screen,
* same as the VisualID. * same as the VisualID.
*/ */
int DoCreateContext(__GLXclientState *cl, GLXContextID gcId, static int
GLXContextID shareList, VisualID visual, DoCreateContext(__GLXclientState *cl, GLXContextID gcId,
GLuint screen, GLboolean isDirect) GLXContextID shareList, VisualID visual,
GLuint screen, GLboolean isDirect)
{ {
ClientPtr client = cl->client; ClientPtr client = cl->client;
VisualPtr pVisual; VisualPtr pVisual;
@ -385,36 +386,6 @@ static void StartUsingContext(__GLXclientState *cl, __GLXcontext *glxc)
glxc->isCurrent = GL_TRUE; glxc->isCurrent = GL_TRUE;
} }
/*****************************************************************************/
/*
** Make an OpenGL context and drawable current.
*/
int __glXDisp_MakeCurrent(__GLXclientState *cl, GLbyte *pc)
{
xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) pc;
return DoMakeCurrent( cl, req->drawable, req->drawable,
req->context, req->oldContextTag );
}
int __glXDisp_MakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
{
xGLXMakeContextCurrentReq *req = (xGLXMakeContextCurrentReq *) pc;
return DoMakeCurrent( cl, req->drawable, req->readdrawable,
req->context, req->oldContextTag );
}
int __glXDisp_MakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
{
xGLXMakeCurrentReadSGIReq *req = (xGLXMakeCurrentReadSGIReq *) pc;
return DoMakeCurrent( cl, req->drawable, req->readable,
req->context, req->oldContextTag );
}
/** /**
* Given a drawable ID, get the associated drawable and / or pixmap. * Given a drawable ID, get the associated drawable and / or pixmap.
* *
@ -501,10 +472,15 @@ __glXGetDrawable(__GLXcontext *glxc, GLXDrawable drawId, ClientPtr client,
return pGlxDraw; return pGlxDraw;
} }
/*****************************************************************************/
/*
** Make an OpenGL context and drawable current.
*/
int DoMakeCurrent( __GLXclientState *cl, static int
GLXDrawable drawId, GLXDrawable readId, DoMakeCurrent(__GLXclientState *cl,
GLXContextID contextId, GLXContextTag tag ) GLXDrawable drawId, GLXDrawable readId,
GLXContextID contextId, GLXContextTag tag)
{ {
ClientPtr client = cl->client; ClientPtr client = cl->client;
xGLXMakeCurrentReply reply; xGLXMakeCurrentReply reply;
@ -658,6 +634,30 @@ int DoMakeCurrent( __GLXclientState *cl,
return Success; return Success;
} }
int __glXDisp_MakeCurrent(__GLXclientState *cl, GLbyte *pc)
{
xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) pc;
return DoMakeCurrent( cl, req->drawable, req->drawable,
req->context, req->oldContextTag );
}
int __glXDisp_MakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
{
xGLXMakeContextCurrentReq *req = (xGLXMakeContextCurrentReq *) pc;
return DoMakeCurrent( cl, req->drawable, req->readdrawable,
req->context, req->oldContextTag );
}
int __glXDisp_MakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
{
xGLXMakeCurrentReadSGIReq *req = (xGLXMakeCurrentReadSGIReq *) pc;
return DoMakeCurrent( cl, req->drawable, req->readable,
req->context, req->oldContextTag );
}
int __glXDisp_IsDirect(__GLXclientState *cl, GLbyte *pc) int __glXDisp_IsDirect(__GLXclientState *cl, GLbyte *pc)
{ {
ClientPtr client = cl->client; ClientPtr client = cl->client;
@ -830,8 +830,8 @@ int __glXDisp_CopyContext(__GLXclientState *cl, GLbyte *pc)
} }
int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen, static int
GLboolean do_swap) DoGetVisualConfigs(__GLXclientState *cl, unsigned screen)
{ {
ClientPtr client = cl->client; ClientPtr client = cl->client;
xGLXGetVisualConfigsReply reply; xGLXGetVisualConfigsReply reply;
@ -856,7 +856,7 @@ int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen,
reply.type = X_Reply; reply.type = X_Reply;
reply.sequenceNumber = client->sequence; reply.sequenceNumber = client->sequence;
if ( do_swap ) { if (client->swapped) {
__GLX_SWAP_SHORT(&reply.sequenceNumber); __GLX_SWAP_SHORT(&reply.sequenceNumber);
__GLX_SWAP_INT(&reply.length); __GLX_SWAP_INT(&reply.length);
__GLX_SWAP_INT(&reply.numVisuals); __GLX_SWAP_INT(&reply.numVisuals);
@ -910,7 +910,7 @@ int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen,
buf[p++] = GLX_TRANSPARENT_INDEX_VALUE; buf[p++] = GLX_TRANSPARENT_INDEX_VALUE;
buf[p++] = modes->transparentIndex; buf[p++] = modes->transparentIndex;
if ( do_swap ) { if (client->swapped) {
__GLX_SWAP_INT_ARRAY(buf, __GLX_TOTAL_CONFIG); __GLX_SWAP_INT_ARRAY(buf, __GLX_TOTAL_CONFIG);
} }
WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_TOTAL_CONFIG, WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_TOTAL_CONFIG,
@ -922,7 +922,7 @@ int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen,
int __glXDisp_GetVisualConfigs(__GLXclientState *cl, GLbyte *pc) int __glXDisp_GetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
{ {
xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc; xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
return DoGetVisualConfigs( cl, req->screen, GL_FALSE ); return DoGetVisualConfigs(cl, req->screen);
} }
@ -1018,7 +1018,8 @@ __glXCreateARGBConfig(__GLXscreen *screen)
* is the same, so this routine pulls double duty. * is the same, so this routine pulls double duty.
*/ */
int DoGetFBConfigs(__GLXclientState *cl, unsigned screen, GLboolean do_swap) static int
DoGetFBConfigs(__GLXclientState *cl, unsigned screen, GLboolean do_swap)
{ {
ClientPtr client = cl->client; ClientPtr client = cl->client;
xGLXGetFBConfigsReply reply; xGLXGetFBConfigsReply reply;
@ -1119,7 +1120,6 @@ int __glXDisp_GetFBConfigs(__GLXclientState *cl, GLbyte *pc)
return DoGetFBConfigs( cl, req->screen, GL_FALSE ); return DoGetFBConfigs( cl, req->screen, GL_FALSE );
} }
int __glXDisp_GetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc) int __glXDisp_GetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
{ {
xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *) pc; xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *) pc;
@ -1501,7 +1501,8 @@ int __glXDisp_SwapBuffers(__GLXclientState *cl, GLbyte *pc)
} }
int DoQueryContext(__GLXclientState *cl, GLXContextID gcId) static int
DoQueryContext(__GLXclientState *cl, GLXContextID gcId)
{ {
ClientPtr client = cl->client; ClientPtr client = cl->client;
__GLXcontext *ctx; __GLXcontext *ctx;
@ -1753,7 +1754,10 @@ int __glXDisp_GetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc)
** client library to send batches of GL rendering commands. ** client library to send batches of GL rendering commands.
*/ */
int DoRender(__GLXclientState *cl, GLbyte *pc, int do_swap) /*
** Execute all the drawing commands in a request.
*/
int __glXDisp_Render(__GLXclientState *cl, GLbyte *pc)
{ {
xGLXRenderReq *req; xGLXRenderReq *req;
ClientPtr client= cl->client; ClientPtr client= cl->client;
@ -1764,9 +1768,8 @@ int DoRender(__GLXclientState *cl, GLbyte *pc, int do_swap)
__GLXcontext *glxc; __GLXcontext *glxc;
__GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_VARIABLES;
req = (xGLXRenderReq *) pc; req = (xGLXRenderReq *) pc;
if (do_swap) { if (client->swapped) {
__GLX_SWAP_SHORT(&req->length); __GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->contextTag); __GLX_SWAP_INT(&req->contextTag);
} }
@ -1790,7 +1793,7 @@ int DoRender(__GLXclientState *cl, GLbyte *pc, int do_swap)
** Also, each command must be word aligned. ** Also, each command must be word aligned.
*/ */
hdr = (__GLXrenderHeader *) pc; hdr = (__GLXrenderHeader *) pc;
if (do_swap) { if (client->swapped) {
__GLX_SWAP_SHORT(&hdr->length); __GLX_SWAP_SHORT(&hdr->length);
__GLX_SWAP_SHORT(&hdr->opcode); __GLX_SWAP_SHORT(&hdr->opcode);
} }
@ -1802,7 +1805,8 @@ int DoRender(__GLXclientState *cl, GLbyte *pc, int do_swap)
*/ */
err = __glXGetProtocolSizeData(& Render_dispatch_info, opcode, & entry); err = __glXGetProtocolSizeData(& Render_dispatch_info, opcode, & entry);
proc = (__GLXdispatchRenderProcPtr) proc = (__GLXdispatchRenderProcPtr)
__glXGetProtocolDecodeFunction(& Render_dispatch_info, opcode, do_swap); __glXGetProtocolDecodeFunction(& Render_dispatch_info,
opcode, client->swapped);
if ((err < 0) || (proc == NULL)) { if ((err < 0) || (proc == NULL)) {
client->errorValue = commandsDone; client->errorValue = commandsDone;
@ -1811,7 +1815,8 @@ int DoRender(__GLXclientState *cl, GLbyte *pc, int do_swap)
if (entry.varsize) { if (entry.varsize) {
/* variable size command */ /* variable size command */
extra = (*entry.varsize)(pc + __GLX_RENDER_HDR_SIZE, do_swap); extra = (*entry.varsize)(pc + __GLX_RENDER_HDR_SIZE,
client->swapped);
if (extra < 0) { if (extra < 0) {
extra = 0; extra = 0;
} }
@ -1844,15 +1849,11 @@ int DoRender(__GLXclientState *cl, GLbyte *pc, int do_swap)
return Success; return Success;
} }
/*
** Execute all the drawing commands in a request.
*/
int __glXDisp_Render(__GLXclientState *cl, GLbyte *pc)
{
return DoRender(cl, pc, False);
}
int DoRenderLarge(__GLXclientState *cl, GLbyte *pc, int do_swap) /*
** Execute a large rendering request (one that spans multiple X requests).
*/
int __glXDisp_RenderLarge(__GLXclientState *cl, GLbyte *pc)
{ {
xGLXRenderLargeReq *req; xGLXRenderLargeReq *req;
ClientPtr client= cl->client; ClientPtr client= cl->client;
@ -1862,10 +1863,9 @@ int DoRenderLarge(__GLXclientState *cl, GLbyte *pc, int do_swap)
int error; int error;
CARD16 opcode; CARD16 opcode;
__GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_VARIABLES;
req = (xGLXRenderLargeReq *) pc; req = (xGLXRenderLargeReq *) pc;
if (do_swap) { if (client->swapped) {
__GLX_SWAP_SHORT(&req->length); __GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->contextTag); __GLX_SWAP_INT(&req->contextTag);
__GLX_SWAP_INT(&req->dataBytes); __GLX_SWAP_INT(&req->dataBytes);
@ -1908,7 +1908,7 @@ int DoRenderLarge(__GLXclientState *cl, GLbyte *pc, int do_swap)
} }
hdr = (__GLXrenderLargeHeader *) pc; hdr = (__GLXrenderLargeHeader *) pc;
if (do_swap) { if (client->swapped) {
__GLX_SWAP_INT(&hdr->length); __GLX_SWAP_INT(&hdr->length);
__GLX_SWAP_INT(&hdr->opcode); __GLX_SWAP_INT(&hdr->opcode);
} }
@ -1930,7 +1930,8 @@ int DoRenderLarge(__GLXclientState *cl, GLbyte *pc, int do_swap)
** be computed from its parameters), all the parameters needed ** be computed from its parameters), all the parameters needed
** will be in the 1st request, so it's okay to do this. ** will be in the 1st request, so it's okay to do this.
*/ */
extra = (*entry.varsize)(pc + __GLX_RENDER_LARGE_HDR_SIZE, do_swap); extra = (*entry.varsize)(pc + __GLX_RENDER_LARGE_HDR_SIZE,
client->swapped);
if (extra < 0) { if (extra < 0) {
extra = 0; extra = 0;
} }
@ -2030,7 +2031,8 @@ int DoRenderLarge(__GLXclientState *cl, GLbyte *pc, int do_swap)
opcode = hdr->opcode; opcode = hdr->opcode;
proc = (__GLXdispatchRenderProcPtr) proc = (__GLXdispatchRenderProcPtr)
__glXGetProtocolDecodeFunction(& Render_dispatch_info, opcode, do_swap); __glXGetProtocolDecodeFunction(& Render_dispatch_info, opcode,
client->swapped);
if (proc == NULL) { if (proc == NULL) {
client->errorValue = opcode; client->errorValue = opcode;
return __glXError(GLXBadLargeRequest); return __glXError(GLXBadLargeRequest);
@ -2055,14 +2057,6 @@ int DoRenderLarge(__GLXclientState *cl, GLbyte *pc, int do_swap)
} }
} }
/*
** Execute a large rendering request (one that spans multiple X requests).
*/
int __glXDisp_RenderLarge(__GLXclientState *cl, GLbyte *pc)
{
return DoRenderLarge(cl, pc, False);
}
extern RESTYPE __glXSwapBarrierRes; extern RESTYPE __glXSwapBarrierRes;
int __glXDisp_BindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc) int __glXDisp_BindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc)

117
GL/glx/glxcmdsswap.c
View File

@ -77,8 +77,7 @@ int __glXDispSwap_CreateContext(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_INT(&req->screen); __GLX_SWAP_INT(&req->screen);
__GLX_SWAP_INT(&req->shareList); __GLX_SWAP_INT(&req->shareList);
return DoCreateContext( cl, req->context, req->shareList, req->visual, return __glXDisp_CreateContext(cl, pc);
req->screen, req->isDirect );
} }
int __glXDispSwap_CreateNewContext(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_CreateNewContext(__GLXclientState *cl, GLbyte *pc)
@ -93,8 +92,7 @@ int __glXDispSwap_CreateNewContext(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_INT(&req->renderType); __GLX_SWAP_INT(&req->renderType);
__GLX_SWAP_INT(&req->shareList); __GLX_SWAP_INT(&req->shareList);
return DoCreateContext( cl, req->context, req->shareList, req->fbconfig, return __glXDisp_CreateNewContext(cl, pc);
req->screen, req->isDirect );
} }
int __glXDispSwap_CreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_CreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
@ -110,8 +108,7 @@ int __glXDispSwap_CreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_INT(&req->renderType); __GLX_SWAP_INT(&req->renderType);
__GLX_SWAP_INT(&req->shareList); __GLX_SWAP_INT(&req->shareList);
return DoCreateContext( cl, req->context, req->shareList, req->fbconfig, return __glXDisp_CreateContextWithConfigSGIX(cl, pc);
req->screen, req->isDirect );
} }
int __glXDispSwap_DestroyContext(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_DestroyContext(__GLXclientState *cl, GLbyte *pc)
@ -135,8 +132,7 @@ int __glXDispSwap_MakeCurrent(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_INT(&req->context); __GLX_SWAP_INT(&req->context);
__GLX_SWAP_INT(&req->oldContextTag); __GLX_SWAP_INT(&req->oldContextTag);
return DoMakeCurrent( cl, req->drawable, req->drawable, return __glXDisp_MakeCurrent(cl, pc);
req->context, req->oldContextTag );
} }
int __glXDispSwap_MakeContextCurrent(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_MakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
@ -150,8 +146,7 @@ int __glXDispSwap_MakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_INT(&req->context); __GLX_SWAP_INT(&req->context);
__GLX_SWAP_INT(&req->oldContextTag); __GLX_SWAP_INT(&req->oldContextTag);
return DoMakeCurrent( cl, req->drawable, req->readdrawable, return __glXDisp_MakeContextCurrent(cl, pc);
req->context, req->oldContextTag );
} }
int __glXDispSwap_MakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_MakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
@ -165,8 +160,7 @@ int __glXDispSwap_MakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_INT(&req->context); __GLX_SWAP_INT(&req->context);
__GLX_SWAP_INT(&req->oldContextTag); __GLX_SWAP_INT(&req->oldContextTag);
return DoMakeCurrent( cl, req->drawable, req->readable, return __glXDisp_MakeCurrentReadSGI(cl, pc);
req->context, req->oldContextTag );
} }
int __glXDispSwap_IsDirect(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_IsDirect(__GLXclientState *cl, GLbyte *pc)
@ -233,7 +227,7 @@ int __glXDispSwap_GetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
__GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT(&req->screen); __GLX_SWAP_INT(&req->screen);
return DoGetVisualConfigs( cl, req->screen, GL_TRUE ); return __glXDisp_GetVisualConfigs(cl, pc);
} }
int __glXDispSwap_GetFBConfigs(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_GetFBConfigs(__GLXclientState *cl, GLbyte *pc)
@ -242,7 +236,7 @@ int __glXDispSwap_GetFBConfigs(__GLXclientState *cl, GLbyte *pc)
__GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT(&req->screen); __GLX_SWAP_INT(&req->screen);
return DoGetFBConfigs( cl, req->screen, GL_TRUE ); return __glXDisp_GetFBConfigs(cl, pc);
} }
int __glXDispSwap_GetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_GetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
@ -251,7 +245,7 @@ int __glXDispSwap_GetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
__GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT(&req->screen); __GLX_SWAP_INT(&req->screen);
return DoGetFBConfigs( cl, req->screen, GL_TRUE ); return __glXDisp_GetFBConfigsSGIX(cl, pc);
} }
int __glXDispSwap_CreateGLXPixmap(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_CreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
@ -265,14 +259,15 @@ int __glXDispSwap_CreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_INT(&req->pixmap); __GLX_SWAP_INT(&req->pixmap);
__GLX_SWAP_INT(&req->glxpixmap); __GLX_SWAP_INT(&req->glxpixmap);
return DoCreateGLXPixmap( cl, req->visual, req->screen, return __glXDisp_CreateGLXPixmap(cl, pc);
req->pixmap, req->glxpixmap, NULL, 0 );
} }
int __glXDispSwap_CreatePixmap(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_CreatePixmap(__GLXclientState *cl, GLbyte *pc)
{ {
xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc; xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
CARD32 *attribs;
__GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_VARIABLES;
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
__GLX_SWAP_SHORT(&req->length); __GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->screen); __GLX_SWAP_INT(&req->screen);
@ -280,11 +275,10 @@ int __glXDispSwap_CreatePixmap(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_INT(&req->pixmap); __GLX_SWAP_INT(&req->pixmap);
__GLX_SWAP_INT(&req->glxpixmap); __GLX_SWAP_INT(&req->glxpixmap);
__GLX_SWAP_INT(&req->numAttribs); __GLX_SWAP_INT(&req->numAttribs);
attribs = (CARD32*)(req + 1);
__GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
return DoCreateGLXPixmap( cl, req->fbconfig, req->screen, return __glXDisp_CreatePixmap(cl, pc);
req->pixmap, req->glxpixmap,
(CARD32*)(req + 1),
req->numAttribs );
} }
int __glXDispSwap_CreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_CreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
@ -299,8 +293,7 @@ int __glXDispSwap_CreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc
__GLX_SWAP_INT(&req->pixmap); __GLX_SWAP_INT(&req->pixmap);
__GLX_SWAP_INT(&req->glxpixmap); __GLX_SWAP_INT(&req->glxpixmap);
return DoCreateGLXPixmap( cl, req->fbconfig, req->screen, return __glXDisp_CreateGLXPixmapWithConfigSGIX(cl, pc);
req->pixmap, req->glxpixmap, NULL, 0 );
} }
int __glXDispSwap_DestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_DestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
@ -328,50 +321,78 @@ int __glXDispSwap_DestroyPixmap(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_QueryContext(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_QueryContext(__GLXclientState *cl, GLbyte *pc)
{ {
xGLXQueryContextReq *req = (xGLXQueryContextReq *) pc; xGLXQueryContextReq *req = (xGLXQueryContextReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
(void) req; __GLX_SWAP_INT(&req->context);
return BadRequest; return __glXDisp_QueryContext(cl, pc);
} }
int __glXDispSwap_CreatePbuffer(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_CreatePbuffer(__GLXclientState *cl, GLbyte *pc)
{ {
xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *) pc; xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
CARD32 *attribs;
(void) req; __GLX_SWAP_INT(&req->screen);
__GLX_SWAP_INT(&req->fbconfig);
__GLX_SWAP_INT(&req->pbuffer);
__GLX_SWAP_INT(&req->numAttribs);
attribs = (CARD32*)(req + 1);
__GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
return BadRequest; return __glXDisp_CreatePbuffer(cl, pc);
} }
int __glXDispSwap_CreateGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_CreateGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc)
{ {
xGLXCreateGLXPbufferSGIXReq *req = (xGLXCreateGLXPbufferSGIXReq *) pc; xGLXCreateGLXPbufferSGIXReq *req = (xGLXCreateGLXPbufferSGIXReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
(void) req; __GLX_SWAP_INT(&req->screen);
__GLX_SWAP_INT(&req->fbconfig);
__GLX_SWAP_INT(&req->pbuffer);
__GLX_SWAP_INT(&req->width);
__GLX_SWAP_INT(&req->height);
return BadRequest; return __glXDisp_CreateGLXPbufferSGIX(cl, pc);
} }
int __glXDispSwap_DestroyPbuffer(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_DestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
{ {
xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) req; xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) req;
__GLX_DECLARE_SWAP_VARIABLES;
return BadRequest; __GLX_SWAP_INT(&req->pbuffer);
return __glXDisp_DestroyPbuffer(cl, pc);
} }
int __glXDispSwap_DestroyGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_DestroyGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc)
{ {
xGLXDestroyGLXPbufferSGIXReq *req = (xGLXDestroyGLXPbufferSGIXReq *) req; xGLXDestroyGLXPbufferSGIXReq *req = (xGLXDestroyGLXPbufferSGIXReq *) req;
__GLX_DECLARE_SWAP_VARIABLES;
return BadRequest; __GLX_SWAP_INT(&req->pbuffer);
return __glXDisp_DestroyGLXPbufferSGIX(cl, pc);
} }
int __glXDispSwap_ChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_ChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
{ {
xGLXChangeDrawableAttributesReq *req = xGLXChangeDrawableAttributesReq *req =
(xGLXChangeDrawableAttributesReq *) req; (xGLXChangeDrawableAttributesReq *) req;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
CARD32 *attribs;
return BadRequest; __GLX_SWAP_INT(&req->drawable);
__GLX_SWAP_INT(&req->numAttribs);
attribs = (CARD32*)(req + 1);
__GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
return __glXDisp_ChangeDrawableAttributes(cl, pc);
} }
int __glXDispSwap_ChangeDrawableAttributesSGIX(__GLXclientState *cl, int __glXDispSwap_ChangeDrawableAttributesSGIX(__GLXclientState *cl,
@ -379,26 +400,44 @@ int __glXDispSwap_ChangeDrawableAttributesSGIX(__GLXclientState *cl,
{ {
xGLXChangeDrawableAttributesSGIXReq *req = xGLXChangeDrawableAttributesSGIXReq *req =
(xGLXChangeDrawableAttributesSGIXReq *) req; (xGLXChangeDrawableAttributesSGIXReq *) req;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
CARD32 *attribs;
return BadRequest; __GLX_SWAP_INT(&req->drawable);
__GLX_SWAP_INT(&req->numAttribs);
attribs = (CARD32*)(req + 1);
__GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
return __glXDisp_ChangeDrawableAttributesSGIX(cl, pc);
} }
int __glXDispSwap_CreateWindow(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_CreateWindow(__GLXclientState *cl, GLbyte *pc)
{ {
xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc; xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
CARD32 *attribs;
(void) req; __GLX_SWAP_INT(&req->screen);
__GLX_SWAP_INT(&req->fbconfig);
__GLX_SWAP_INT(&req->window);
__GLX_SWAP_INT(&req->glxwindow);
__GLX_SWAP_INT(&req->numAttribs);
attribs = (CARD32*)(req + 1);
__GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
return BadRequest; return __glXDisp_CreateWindow(cl, pc);
} }
int __glXDispSwap_DestroyWindow(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_DestroyWindow(__GLXclientState *cl, GLbyte *pc)
{ {
xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc; xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
(void) req; __GLX_SWAP_INT(&req->glxwindow);
return BadRequest; return __glXDisp_DestroyWindow(cl, pc);
} }
int __glXDispSwap_SwapBuffers(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_SwapBuffers(__GLXclientState *cl, GLbyte *pc)
@ -668,7 +707,7 @@ void __glXSwapGetDrawableAttributesReply(ClientPtr client,
int __glXDispSwap_Render(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_Render(__GLXclientState *cl, GLbyte *pc)
{ {
return DoRender(cl, pc, True); return __glXDisp_Render(cl, pc);
} }
/* /*
@ -676,7 +715,7 @@ int __glXDispSwap_Render(__GLXclientState *cl, GLbyte *pc)
*/ */
int __glXDispSwap_RenderLarge(__GLXclientState *cl, GLbyte *pc) int __glXDispSwap_RenderLarge(__GLXclientState *cl, GLbyte *pc)
{ {
return DoRenderLarge(cl, pc, True); return __glXDisp_RenderLarge(cl, pc);
} }
/************************************************************************/ /************************************************************************/

13
GL/glx/glxext.h
View File

@ -71,19 +71,6 @@ extern void __glXClearErrorOccured(void);
extern GLboolean __glXErrorOccured(void); extern GLboolean __glXErrorOccured(void);
extern void __glXResetLargeCommandStatus(__GLXclientState*); extern void __glXResetLargeCommandStatus(__GLXclientState*);
extern int DoMakeCurrent( __GLXclientState *cl, GLXDrawable drawId,
GLXDrawable readId, GLXContextID contextId, GLXContextTag tag );
extern int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen,
GLboolean do_swap);
extern int DoGetFBConfigs(__GLXclientState *cl, unsigned screen,
GLboolean do_swap);
extern int DoCreateContext(__GLXclientState *cl, GLXContextID gcId,
GLXContextID shareList, VisualID visual, GLuint screen, GLboolean isDirect);
extern int DoQueryContext(__GLXclientState *cl, GLXContextID gcId);
extern int DoRender(__GLXclientState *cl, GLbyte *pc, int do_swap);
extern int DoRenderLarge(__GLXclientState *cl, GLbyte *pc, int do_swap);
extern void GlxExtensionInit(void); extern void GlxExtensionInit(void);
extern const char GLServerVersion[]; extern const char GLServerVersion[];