2 * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
3 * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
12 * The above copyright notice including the dates of first publication and
13 * either this permission notice or a reference to
14 * http://oss.sgi.com/projects/FreeB/
15 * shall be included in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
22 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25 * Except as contained in this notice, the name of Silicon Graphics, Inc.
26 * shall not be used in advertising or otherwise to promote the sale, use or
27 * other dealings in this Software without prior written authorization from
28 * Silicon Graphics, Inc.
31 #ifdef HAVE_DIX_CONFIG_H
32 #include <dix-config.h>
36 #include "glxserver.h"
38 #include <GL/glxtokens.h>
40 #include <pixmapstr.h>
41 #include <windowstr.h>
43 #include "indirect_dispatch.h"
44 #include "indirect_table.h"
45 #include "indirect_util.h"
47 /************************************************************************/
50 ** Byteswapping versions of GLX commands. In most cases they just swap
51 ** the incoming arguments and then call the unswapped routine. For commands
52 ** that have replies, a separate swapping routine for the reply is provided;
53 ** it is called at the end of the unswapped routine.
57 __glXDispSwap_CreateContext(__GLXclientState
* cl
, GLbyte
* pc
)
59 ClientPtr client
= cl
->client
;
60 xGLXCreateContextReq
*req
= (xGLXCreateContextReq
*) pc
;
62 __GLX_DECLARE_SWAP_VARIABLES
;
64 REQUEST_SIZE_MATCH(xGLXCreateContextReq
);
66 __GLX_SWAP_SHORT(&req
->length
);
67 __GLX_SWAP_INT(&req
->context
);
68 __GLX_SWAP_INT(&req
->visual
);
69 __GLX_SWAP_INT(&req
->screen
);
70 __GLX_SWAP_INT(&req
->shareList
);
72 return __glXDisp_CreateContext(cl
, pc
);
76 __glXDispSwap_CreateNewContext(__GLXclientState
* cl
, GLbyte
* pc
)
78 ClientPtr client
= cl
->client
;
79 xGLXCreateNewContextReq
*req
= (xGLXCreateNewContextReq
*) pc
;
81 __GLX_DECLARE_SWAP_VARIABLES
;
83 REQUEST_SIZE_MATCH(xGLXCreateNewContextReq
);
85 __GLX_SWAP_SHORT(&req
->length
);
86 __GLX_SWAP_INT(&req
->context
);
87 __GLX_SWAP_INT(&req
->fbconfig
);
88 __GLX_SWAP_INT(&req
->screen
);
89 __GLX_SWAP_INT(&req
->renderType
);
90 __GLX_SWAP_INT(&req
->shareList
);
92 return __glXDisp_CreateNewContext(cl
, pc
);
96 __glXDispSwap_CreateContextWithConfigSGIX(__GLXclientState
* cl
, GLbyte
* pc
)
98 ClientPtr client
= cl
->client
;
99 xGLXCreateContextWithConfigSGIXReq
*req
=
100 (xGLXCreateContextWithConfigSGIXReq
*) pc
;
101 __GLX_DECLARE_SWAP_VARIABLES
;
103 REQUEST_SIZE_MATCH(xGLXCreateContextWithConfigSGIXReq
);
105 __GLX_SWAP_SHORT(&req
->length
);
106 __GLX_SWAP_INT(&req
->context
);
107 __GLX_SWAP_INT(&req
->fbconfig
);
108 __GLX_SWAP_INT(&req
->screen
);
109 __GLX_SWAP_INT(&req
->renderType
);
110 __GLX_SWAP_INT(&req
->shareList
);
112 return __glXDisp_CreateContextWithConfigSGIX(cl
, pc
);
116 __glXDispSwap_DestroyContext(__GLXclientState
* cl
, GLbyte
* pc
)
118 ClientPtr client
= cl
->client
;
119 xGLXDestroyContextReq
*req
= (xGLXDestroyContextReq
*) pc
;
121 __GLX_DECLARE_SWAP_VARIABLES
;
123 REQUEST_SIZE_MATCH(xGLXDestroyContextReq
);
125 __GLX_SWAP_SHORT(&req
->length
);
126 __GLX_SWAP_INT(&req
->context
);
128 return __glXDisp_DestroyContext(cl
, pc
);
132 __glXDispSwap_MakeCurrent(__GLXclientState
* cl
, GLbyte
* pc
)
134 ClientPtr client
= cl
->client
;
135 xGLXMakeCurrentReq
*req
= (xGLXMakeCurrentReq
*) pc
;
137 __GLX_DECLARE_SWAP_VARIABLES
;
139 REQUEST_SIZE_MATCH(xGLXMakeCurrentReq
);
141 __GLX_SWAP_SHORT(&req
->length
);
142 __GLX_SWAP_INT(&req
->drawable
);
143 __GLX_SWAP_INT(&req
->context
);
144 __GLX_SWAP_INT(&req
->oldContextTag
);
146 return __glXDisp_MakeCurrent(cl
, pc
);
150 __glXDispSwap_MakeContextCurrent(__GLXclientState
* cl
, GLbyte
* pc
)
152 ClientPtr client
= cl
->client
;
153 xGLXMakeContextCurrentReq
*req
= (xGLXMakeContextCurrentReq
*) pc
;
155 __GLX_DECLARE_SWAP_VARIABLES
;
157 REQUEST_SIZE_MATCH(xGLXMakeContextCurrentReq
);
159 __GLX_SWAP_SHORT(&req
->length
);
160 __GLX_SWAP_INT(&req
->drawable
);
161 __GLX_SWAP_INT(&req
->readdrawable
);
162 __GLX_SWAP_INT(&req
->context
);
163 __GLX_SWAP_INT(&req
->oldContextTag
);
165 return __glXDisp_MakeContextCurrent(cl
, pc
);
169 __glXDispSwap_MakeCurrentReadSGI(__GLXclientState
* cl
, GLbyte
* pc
)
171 ClientPtr client
= cl
->client
;
172 xGLXMakeCurrentReadSGIReq
*req
= (xGLXMakeCurrentReadSGIReq
*) pc
;
174 __GLX_DECLARE_SWAP_VARIABLES
;
176 REQUEST_SIZE_MATCH(xGLXMakeCurrentReadSGIReq
);
178 __GLX_SWAP_SHORT(&req
->length
);
179 __GLX_SWAP_INT(&req
->drawable
);
180 __GLX_SWAP_INT(&req
->readable
);
181 __GLX_SWAP_INT(&req
->context
);
182 __GLX_SWAP_INT(&req
->oldContextTag
);
184 return __glXDisp_MakeCurrentReadSGI(cl
, pc
);
188 __glXDispSwap_IsDirect(__GLXclientState
* cl
, GLbyte
* pc
)
190 ClientPtr client
= cl
->client
;
191 xGLXIsDirectReq
*req
= (xGLXIsDirectReq
*) pc
;
193 __GLX_DECLARE_SWAP_VARIABLES
;
195 REQUEST_SIZE_MATCH(xGLXIsDirectReq
);
197 __GLX_SWAP_SHORT(&req
->length
);
198 __GLX_SWAP_INT(&req
->context
);
200 return __glXDisp_IsDirect(cl
, pc
);
204 __glXDispSwap_QueryVersion(__GLXclientState
* cl
, GLbyte
* pc
)
206 ClientPtr client
= cl
->client
;
207 xGLXQueryVersionReq
*req
= (xGLXQueryVersionReq
*) pc
;
209 __GLX_DECLARE_SWAP_VARIABLES
;
211 REQUEST_SIZE_MATCH(xGLXQueryVersionReq
);
213 __GLX_SWAP_SHORT(&req
->length
);
214 __GLX_SWAP_INT(&req
->majorVersion
);
215 __GLX_SWAP_INT(&req
->minorVersion
);
217 return __glXDisp_QueryVersion(cl
, pc
);
221 __glXDispSwap_WaitGL(__GLXclientState
* cl
, GLbyte
* pc
)
223 ClientPtr client
= cl
->client
;
224 xGLXWaitGLReq
*req
= (xGLXWaitGLReq
*) pc
;
226 __GLX_DECLARE_SWAP_VARIABLES
;
228 REQUEST_SIZE_MATCH(xGLXWaitGLReq
);
230 __GLX_SWAP_SHORT(&req
->length
);
231 __GLX_SWAP_INT(&req
->contextTag
);
233 return __glXDisp_WaitGL(cl
, pc
);
237 __glXDispSwap_WaitX(__GLXclientState
* cl
, GLbyte
* pc
)
239 ClientPtr client
= cl
->client
;
240 xGLXWaitXReq
*req
= (xGLXWaitXReq
*) pc
;
242 __GLX_DECLARE_SWAP_VARIABLES
;
244 REQUEST_SIZE_MATCH(xGLXWaitXReq
);
246 __GLX_SWAP_SHORT(&req
->length
);
247 __GLX_SWAP_INT(&req
->contextTag
);
249 return __glXDisp_WaitX(cl
, pc
);
253 __glXDispSwap_CopyContext(__GLXclientState
* cl
, GLbyte
* pc
)
255 ClientPtr client
= cl
->client
;
256 xGLXCopyContextReq
*req
= (xGLXCopyContextReq
*) pc
;
258 __GLX_DECLARE_SWAP_VARIABLES
;
260 REQUEST_SIZE_MATCH(xGLXCopyContextReq
);
262 __GLX_SWAP_SHORT(&req
->length
);
263 __GLX_SWAP_INT(&req
->source
);
264 __GLX_SWAP_INT(&req
->dest
);
265 __GLX_SWAP_INT(&req
->mask
);
267 return __glXDisp_CopyContext(cl
, pc
);
271 __glXDispSwap_GetVisualConfigs(__GLXclientState
* cl
, GLbyte
* pc
)
273 ClientPtr client
= cl
->client
;
274 xGLXGetVisualConfigsReq
*req
= (xGLXGetVisualConfigsReq
*) pc
;
276 __GLX_DECLARE_SWAP_VARIABLES
;
278 REQUEST_SIZE_MATCH(xGLXGetVisualConfigsReq
);
280 __GLX_SWAP_INT(&req
->screen
);
281 return __glXDisp_GetVisualConfigs(cl
, pc
);
285 __glXDispSwap_GetFBConfigs(__GLXclientState
* cl
, GLbyte
* pc
)
287 ClientPtr client
= cl
->client
;
288 xGLXGetFBConfigsReq
*req
= (xGLXGetFBConfigsReq
*) pc
;
290 __GLX_DECLARE_SWAP_VARIABLES
;
292 REQUEST_SIZE_MATCH(xGLXGetFBConfigsReq
);
294 __GLX_SWAP_INT(&req
->screen
);
295 return __glXDisp_GetFBConfigs(cl
, pc
);
299 __glXDispSwap_GetFBConfigsSGIX(__GLXclientState
* cl
, GLbyte
* pc
)
301 ClientPtr client
= cl
->client
;
302 xGLXGetFBConfigsSGIXReq
*req
= (xGLXGetFBConfigsSGIXReq
*) pc
;
304 __GLX_DECLARE_SWAP_VARIABLES
;
306 REQUEST_AT_LEAST_SIZE(xGLXGetFBConfigsSGIXReq
);
308 __GLX_SWAP_INT(&req
->screen
);
309 return __glXDisp_GetFBConfigsSGIX(cl
, pc
);
313 __glXDispSwap_CreateGLXPixmap(__GLXclientState
* cl
, GLbyte
* pc
)
315 ClientPtr client
= cl
->client
;
316 xGLXCreateGLXPixmapReq
*req
= (xGLXCreateGLXPixmapReq
*) pc
;
318 __GLX_DECLARE_SWAP_VARIABLES
;
320 REQUEST_SIZE_MATCH(xGLXCreateGLXPixmapReq
);
322 __GLX_SWAP_SHORT(&req
->length
);
323 __GLX_SWAP_INT(&req
->screen
);
324 __GLX_SWAP_INT(&req
->visual
);
325 __GLX_SWAP_INT(&req
->pixmap
);
326 __GLX_SWAP_INT(&req
->glxpixmap
);
328 return __glXDisp_CreateGLXPixmap(cl
, pc
);
332 __glXDispSwap_CreatePixmap(__GLXclientState
* cl
, GLbyte
* pc
)
334 ClientPtr client
= cl
->client
;
335 xGLXCreatePixmapReq
*req
= (xGLXCreatePixmapReq
*) pc
;
338 __GLX_DECLARE_SWAP_VARIABLES
;
339 __GLX_DECLARE_SWAP_ARRAY_VARIABLES
;
341 REQUEST_AT_LEAST_SIZE(xGLXCreatePixmapReq
);
343 __GLX_SWAP_SHORT(&req
->length
);
344 __GLX_SWAP_INT(&req
->screen
);
345 __GLX_SWAP_INT(&req
->fbconfig
);
346 __GLX_SWAP_INT(&req
->pixmap
);
347 __GLX_SWAP_INT(&req
->glxpixmap
);
348 __GLX_SWAP_INT(&req
->numAttribs
);
350 if (req
->numAttribs
> (UINT32_MAX
>> 3)) {
351 client
->errorValue
= req
->numAttribs
;
354 REQUEST_FIXED_SIZE(xGLXCreatePixmapReq
, req
->numAttribs
<< 3);
355 attribs
= (CARD32
*) (req
+ 1);
356 __GLX_SWAP_INT_ARRAY(attribs
, req
->numAttribs
<< 1);
358 return __glXDisp_CreatePixmap(cl
, pc
);
362 __glXDispSwap_CreateGLXPixmapWithConfigSGIX(__GLXclientState
* cl
, GLbyte
* pc
)
364 ClientPtr client
= cl
->client
;
365 xGLXCreateGLXPixmapWithConfigSGIXReq
*req
=
366 (xGLXCreateGLXPixmapWithConfigSGIXReq
*) pc
;
367 __GLX_DECLARE_SWAP_VARIABLES
;
369 REQUEST_SIZE_MATCH(xGLXCreateGLXPixmapWithConfigSGIXReq
);
371 __GLX_SWAP_SHORT(&req
->length
);
372 __GLX_SWAP_INT(&req
->screen
);
373 __GLX_SWAP_INT(&req
->fbconfig
);
374 __GLX_SWAP_INT(&req
->pixmap
);
375 __GLX_SWAP_INT(&req
->glxpixmap
);
377 return __glXDisp_CreateGLXPixmapWithConfigSGIX(cl
, pc
);
381 __glXDispSwap_DestroyGLXPixmap(__GLXclientState
* cl
, GLbyte
* pc
)
383 ClientPtr client
= cl
->client
;
384 xGLXDestroyGLXPixmapReq
*req
= (xGLXDestroyGLXPixmapReq
*) pc
;
386 __GLX_DECLARE_SWAP_VARIABLES
;
388 REQUEST_SIZE_MATCH(xGLXDestroyGLXPixmapReq
);
390 __GLX_SWAP_SHORT(&req
->length
);
391 __GLX_SWAP_INT(&req
->glxpixmap
);
393 return __glXDisp_DestroyGLXPixmap(cl
, pc
);
397 __glXDispSwap_DestroyPixmap(__GLXclientState
* cl
, GLbyte
* pc
)
399 ClientPtr client
= cl
->client
;
400 xGLXDestroyGLXPixmapReq
*req
= (xGLXDestroyGLXPixmapReq
*) pc
;
402 __GLX_DECLARE_SWAP_VARIABLES
;
404 REQUEST_AT_LEAST_SIZE(xGLXDestroyGLXPixmapReq
);
406 __GLX_SWAP_SHORT(&req
->length
);
407 __GLX_SWAP_INT(&req
->glxpixmap
);
409 return __glXDisp_DestroyGLXPixmap(cl
, pc
);
413 __glXDispSwap_QueryContext(__GLXclientState
* cl
, GLbyte
* pc
)
415 ClientPtr client
= cl
->client
;
416 xGLXQueryContextReq
*req
= (xGLXQueryContextReq
*) pc
;
418 __GLX_DECLARE_SWAP_VARIABLES
;
420 REQUEST_SIZE_MATCH(xGLXQueryContextReq
);
422 __GLX_SWAP_INT(&req
->context
);
424 return __glXDisp_QueryContext(cl
, pc
);
428 __glXDispSwap_CreatePbuffer(__GLXclientState
* cl
, GLbyte
* pc
)
430 ClientPtr client
= cl
->client
;
431 xGLXCreatePbufferReq
*req
= (xGLXCreatePbufferReq
*) pc
;
433 __GLX_DECLARE_SWAP_VARIABLES
;
434 __GLX_DECLARE_SWAP_ARRAY_VARIABLES
;
437 REQUEST_AT_LEAST_SIZE(xGLXCreatePbufferReq
);
439 __GLX_SWAP_INT(&req
->screen
);
440 __GLX_SWAP_INT(&req
->fbconfig
);
441 __GLX_SWAP_INT(&req
->pbuffer
);
442 __GLX_SWAP_INT(&req
->numAttribs
);
444 if (req
->numAttribs
> (UINT32_MAX
>> 3)) {
445 client
->errorValue
= req
->numAttribs
;
448 REQUEST_FIXED_SIZE(xGLXCreatePbufferReq
, req
->numAttribs
<< 3);
449 attribs
= (CARD32
*) (req
+ 1);
450 __GLX_SWAP_INT_ARRAY(attribs
, req
->numAttribs
<< 1);
452 return __glXDisp_CreatePbuffer(cl
, pc
);
456 __glXDispSwap_CreateGLXPbufferSGIX(__GLXclientState
* cl
, GLbyte
* pc
)
458 ClientPtr client
= cl
->client
;
459 xGLXCreateGLXPbufferSGIXReq
*req
= (xGLXCreateGLXPbufferSGIXReq
*) pc
;
461 __GLX_DECLARE_SWAP_VARIABLES
;
463 REQUEST_AT_LEAST_SIZE(xGLXCreateGLXPbufferSGIXReq
);
465 __GLX_SWAP_INT(&req
->screen
);
466 __GLX_SWAP_INT(&req
->fbconfig
);
467 __GLX_SWAP_INT(&req
->pbuffer
);
468 __GLX_SWAP_INT(&req
->width
);
469 __GLX_SWAP_INT(&req
->height
);
471 return __glXDisp_CreateGLXPbufferSGIX(cl
, pc
);
475 __glXDispSwap_DestroyPbuffer(__GLXclientState
* cl
, GLbyte
* pc
)
477 ClientPtr client
= cl
->client
;
478 xGLXDestroyPbufferReq
*req
= (xGLXDestroyPbufferReq
*) pc
;
480 __GLX_DECLARE_SWAP_VARIABLES
;
482 REQUEST_SIZE_MATCH(xGLXDestroyPbufferReq
);
484 __GLX_SWAP_INT(&req
->pbuffer
);
486 return __glXDisp_DestroyPbuffer(cl
, pc
);
490 __glXDispSwap_DestroyGLXPbufferSGIX(__GLXclientState
* cl
, GLbyte
* pc
)
492 ClientPtr client
= cl
->client
;
493 xGLXDestroyGLXPbufferSGIXReq
*req
= (xGLXDestroyGLXPbufferSGIXReq
*) pc
;
495 __GLX_DECLARE_SWAP_VARIABLES
;
497 REQUEST_SIZE_MATCH(xGLXDestroyGLXPbufferSGIXReq
);
499 __GLX_SWAP_INT(&req
->pbuffer
);
501 return __glXDisp_DestroyGLXPbufferSGIX(cl
, pc
);
505 __glXDispSwap_ChangeDrawableAttributes(__GLXclientState
* cl
, GLbyte
* pc
)
507 ClientPtr client
= cl
->client
;
508 xGLXChangeDrawableAttributesReq
*req
=
509 (xGLXChangeDrawableAttributesReq
*) pc
;
510 __GLX_DECLARE_SWAP_VARIABLES
;
511 __GLX_DECLARE_SWAP_ARRAY_VARIABLES
;
514 REQUEST_AT_LEAST_SIZE(xGLXChangeDrawableAttributesReq
);
516 __GLX_SWAP_INT(&req
->drawable
);
517 __GLX_SWAP_INT(&req
->numAttribs
);
519 if (req
->numAttribs
> (UINT32_MAX
>> 3)) {
520 client
->errorValue
= req
->numAttribs
;
523 if (((sizeof(xGLXChangeDrawableAttributesReq
) +
524 (req
->numAttribs
<< 3)) >> 2) < client
->req_len
)
527 attribs
= (CARD32
*) (req
+ 1);
528 __GLX_SWAP_INT_ARRAY(attribs
, req
->numAttribs
<< 1);
530 return __glXDisp_ChangeDrawableAttributes(cl
, pc
);
534 __glXDispSwap_ChangeDrawableAttributesSGIX(__GLXclientState
* cl
, GLbyte
* pc
)
536 ClientPtr client
= cl
->client
;
537 xGLXChangeDrawableAttributesSGIXReq
*req
=
538 (xGLXChangeDrawableAttributesSGIXReq
*) pc
;
539 __GLX_DECLARE_SWAP_VARIABLES
;
540 __GLX_DECLARE_SWAP_ARRAY_VARIABLES
;
543 REQUEST_AT_LEAST_SIZE(xGLXChangeDrawableAttributesSGIXReq
);
545 __GLX_SWAP_INT(&req
->drawable
);
546 __GLX_SWAP_INT(&req
->numAttribs
);
548 if (req
->numAttribs
> (UINT32_MAX
>> 3)) {
549 client
->errorValue
= req
->numAttribs
;
552 REQUEST_FIXED_SIZE(xGLXChangeDrawableAttributesSGIXReq
,
553 req
->numAttribs
<< 3);
554 attribs
= (CARD32
*) (req
+ 1);
555 __GLX_SWAP_INT_ARRAY(attribs
, req
->numAttribs
<< 1);
557 return __glXDisp_ChangeDrawableAttributesSGIX(cl
, pc
);
561 __glXDispSwap_CreateWindow(__GLXclientState
* cl
, GLbyte
* pc
)
563 ClientPtr client
= cl
->client
;
564 xGLXCreateWindowReq
*req
= (xGLXCreateWindowReq
*) pc
;
566 __GLX_DECLARE_SWAP_VARIABLES
;
567 __GLX_DECLARE_SWAP_ARRAY_VARIABLES
;
570 REQUEST_AT_LEAST_SIZE(xGLXCreateWindowReq
);
572 __GLX_SWAP_INT(&req
->screen
);
573 __GLX_SWAP_INT(&req
->fbconfig
);
574 __GLX_SWAP_INT(&req
->window
);
575 __GLX_SWAP_INT(&req
->glxwindow
);
576 __GLX_SWAP_INT(&req
->numAttribs
);
578 if (req
->numAttribs
> (UINT32_MAX
>> 3)) {
579 client
->errorValue
= req
->numAttribs
;
582 REQUEST_FIXED_SIZE(xGLXCreateWindowReq
, req
->numAttribs
<< 3);
583 attribs
= (CARD32
*) (req
+ 1);
584 __GLX_SWAP_INT_ARRAY(attribs
, req
->numAttribs
<< 1);
586 return __glXDisp_CreateWindow(cl
, pc
);
590 __glXDispSwap_DestroyWindow(__GLXclientState
* cl
, GLbyte
* pc
)
592 ClientPtr client
= cl
->client
;
593 xGLXDestroyWindowReq
*req
= (xGLXDestroyWindowReq
*) pc
;
595 __GLX_DECLARE_SWAP_VARIABLES
;
597 REQUEST_AT_LEAST_SIZE(xGLXDestroyWindowReq
);
599 __GLX_SWAP_INT(&req
->glxwindow
);
601 return __glXDisp_DestroyWindow(cl
, pc
);
605 __glXDispSwap_SwapBuffers(__GLXclientState
* cl
, GLbyte
* pc
)
607 ClientPtr client
= cl
->client
;
608 xGLXSwapBuffersReq
*req
= (xGLXSwapBuffersReq
*) pc
;
610 __GLX_DECLARE_SWAP_VARIABLES
;
612 REQUEST_SIZE_MATCH(xGLXSwapBuffersReq
);
614 __GLX_SWAP_SHORT(&req
->length
);
615 __GLX_SWAP_INT(&req
->contextTag
);
616 __GLX_SWAP_INT(&req
->drawable
);
618 return __glXDisp_SwapBuffers(cl
, pc
);
622 __glXDispSwap_UseXFont(__GLXclientState
* cl
, GLbyte
* pc
)
624 ClientPtr client
= cl
->client
;
625 xGLXUseXFontReq
*req
= (xGLXUseXFontReq
*) pc
;
627 __GLX_DECLARE_SWAP_VARIABLES
;
629 REQUEST_SIZE_MATCH(xGLXUseXFontReq
);
631 __GLX_SWAP_SHORT(&req
->length
);
632 __GLX_SWAP_INT(&req
->contextTag
);
633 __GLX_SWAP_INT(&req
->font
);
634 __GLX_SWAP_INT(&req
->first
);
635 __GLX_SWAP_INT(&req
->count
);
636 __GLX_SWAP_INT(&req
->listBase
);
638 return __glXDisp_UseXFont(cl
, pc
);
642 __glXDispSwap_QueryExtensionsString(__GLXclientState
* cl
, GLbyte
* pc
)
644 ClientPtr client
= cl
->client
;
645 xGLXQueryExtensionsStringReq
*req
= (xGLXQueryExtensionsStringReq
*) pc
;
647 __GLX_DECLARE_SWAP_VARIABLES
;
649 REQUEST_SIZE_MATCH(xGLXQueryExtensionsStringReq
);
651 __GLX_SWAP_SHORT(&req
->length
);
652 __GLX_SWAP_INT(&req
->screen
);
654 return __glXDisp_QueryExtensionsString(cl
, pc
);
658 __glXDispSwap_QueryServerString(__GLXclientState
* cl
, GLbyte
* pc
)
660 ClientPtr client
= cl
->client
;
661 xGLXQueryServerStringReq
*req
= (xGLXQueryServerStringReq
*) pc
;
663 __GLX_DECLARE_SWAP_VARIABLES
;
665 REQUEST_SIZE_MATCH(xGLXQueryServerStringReq
);
667 __GLX_SWAP_SHORT(&req
->length
);
668 __GLX_SWAP_INT(&req
->screen
);
669 __GLX_SWAP_INT(&req
->name
);
671 return __glXDisp_QueryServerString(cl
, pc
);
675 __glXDispSwap_ClientInfo(__GLXclientState
* cl
, GLbyte
* pc
)
677 ClientPtr client
= cl
->client
;
678 xGLXClientInfoReq
*req
= (xGLXClientInfoReq
*) pc
;
680 __GLX_DECLARE_SWAP_VARIABLES
;
682 REQUEST_AT_LEAST_SIZE(xGLXClientInfoReq
);
684 __GLX_SWAP_SHORT(&req
->length
);
685 __GLX_SWAP_INT(&req
->major
);
686 __GLX_SWAP_INT(&req
->minor
);
687 __GLX_SWAP_INT(&req
->numbytes
);
689 return __glXDisp_ClientInfo(cl
, pc
);
693 __glXDispSwap_QueryContextInfoEXT(__GLXclientState
* cl
, GLbyte
* pc
)
695 ClientPtr client
= cl
->client
;
696 xGLXQueryContextInfoEXTReq
*req
= (xGLXQueryContextInfoEXTReq
*) pc
;
698 __GLX_DECLARE_SWAP_VARIABLES
;
700 REQUEST_SIZE_MATCH(xGLXQueryContextInfoEXTReq
);
702 __GLX_SWAP_SHORT(&req
->length
);
703 __GLX_SWAP_INT(&req
->context
);
705 return __glXDisp_QueryContextInfoEXT(cl
, pc
);
709 __glXDispSwap_BindTexImageEXT(__GLXclientState
* cl
, GLbyte
* pc
)
711 ClientPtr client
= cl
->client
;
712 xGLXVendorPrivateReq
*req
= (xGLXVendorPrivateReq
*) pc
;
717 __GLX_DECLARE_SWAP_VARIABLES
;
719 if ((sizeof(xGLXVendorPrivateReq
) + 12) >> 2 > client
->req_len
)
722 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
724 drawId
= ((GLXDrawable
*) (pc
));
725 buffer
= ((int *) (pc
+ 4));
726 num_attribs
= ((CARD32
*) (pc
+ 8));
728 __GLX_SWAP_SHORT(&req
->length
);
729 __GLX_SWAP_INT(&req
->contextTag
);
730 __GLX_SWAP_INT(drawId
);
731 __GLX_SWAP_INT(buffer
);
732 __GLX_SWAP_INT(num_attribs
);
734 return __glXDisp_BindTexImageEXT(cl
, (GLbyte
*) pc
);
738 __glXDispSwap_ReleaseTexImageEXT(__GLXclientState
* cl
, GLbyte
* pc
)
740 ClientPtr client
= cl
->client
;
741 xGLXVendorPrivateReq
*req
= (xGLXVendorPrivateReq
*) pc
;
745 __GLX_DECLARE_SWAP_VARIABLES
;
747 REQUEST_FIXED_SIZE(xGLXVendorPrivateReq
, 8);
749 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
751 drawId
= ((GLXDrawable
*) (pc
));
752 buffer
= ((int *) (pc
+ 4));
754 __GLX_SWAP_SHORT(&req
->length
);
755 __GLX_SWAP_INT(&req
->contextTag
);
756 __GLX_SWAP_INT(drawId
);
757 __GLX_SWAP_INT(buffer
);
759 return __glXDisp_ReleaseTexImageEXT(cl
, (GLbyte
*) pc
);
763 __glXDispSwap_CopySubBufferMESA(__GLXclientState
* cl
, GLbyte
* pc
)
765 ClientPtr client
= cl
->client
;
766 xGLXVendorPrivateReq
*req
= (xGLXVendorPrivateReq
*) pc
;
770 __GLX_DECLARE_SWAP_VARIABLES
;
772 REQUEST_FIXED_SIZE(xGLXVendorPrivateReq
, 20);
777 pc
+= __GLX_VENDPRIV_HDR_SIZE
;
779 __GLX_SWAP_SHORT(&req
->length
);
780 __GLX_SWAP_INT(&req
->contextTag
);
782 __GLX_SWAP_INT(pc
+ 4);
783 __GLX_SWAP_INT(pc
+ 8);
784 __GLX_SWAP_INT(pc
+ 12);
785 __GLX_SWAP_INT(pc
+ 16);
787 return __glXDisp_CopySubBufferMESA(cl
, pc
);
792 __glXDispSwap_GetDrawableAttributesSGIX(__GLXclientState
* cl
, GLbyte
* pc
)
794 ClientPtr client
= cl
->client
;
795 xGLXVendorPrivateWithReplyReq
*req
= (xGLXVendorPrivateWithReplyReq
*) pc
;
798 __GLX_DECLARE_SWAP_VARIABLES
;
800 REQUEST_SIZE_MATCH(xGLXGetDrawableAttributesSGIXReq
);
802 data
= (CARD32
*) (req
+ 1);
803 __GLX_SWAP_SHORT(&req
->length
);
804 __GLX_SWAP_INT(&req
->contextTag
);
805 __GLX_SWAP_INT(data
);
807 return __glXDisp_GetDrawableAttributesSGIX(cl
, pc
);
811 __glXDispSwap_GetDrawableAttributes(__GLXclientState
* cl
, GLbyte
* pc
)
813 ClientPtr client
= cl
->client
;
814 xGLXGetDrawableAttributesReq
*req
= (xGLXGetDrawableAttributesReq
*) pc
;
816 __GLX_DECLARE_SWAP_VARIABLES
;
818 REQUEST_AT_LEAST_SIZE(xGLXGetDrawableAttributesReq
);
820 __GLX_SWAP_SHORT(&req
->length
);
821 __GLX_SWAP_INT(&req
->drawable
);
823 return __glXDisp_GetDrawableAttributes(cl
, pc
);
826 /************************************************************************/
833 __glXSwapMakeCurrentReply(ClientPtr client
, xGLXMakeCurrentReply
* reply
)
835 __GLX_DECLARE_SWAP_VARIABLES
;
836 __GLX_SWAP_SHORT(&reply
->sequenceNumber
);
837 __GLX_SWAP_INT(&reply
->length
);
838 __GLX_SWAP_INT(&reply
->contextTag
);
839 WriteToClient(client
, sz_xGLXMakeCurrentReply
, reply
);
843 __glXSwapIsDirectReply(ClientPtr client
, xGLXIsDirectReply
* reply
)
845 __GLX_DECLARE_SWAP_VARIABLES
;
846 __GLX_SWAP_SHORT(&reply
->sequenceNumber
);
847 __GLX_SWAP_INT(&reply
->length
);
848 WriteToClient(client
, sz_xGLXIsDirectReply
, reply
);
852 __glXSwapQueryVersionReply(ClientPtr client
, xGLXQueryVersionReply
* reply
)
854 __GLX_DECLARE_SWAP_VARIABLES
;
855 __GLX_SWAP_SHORT(&reply
->sequenceNumber
);
856 __GLX_SWAP_INT(&reply
->length
);
857 __GLX_SWAP_INT(&reply
->majorVersion
);
858 __GLX_SWAP_INT(&reply
->minorVersion
);
859 WriteToClient(client
, sz_xGLXQueryVersionReply
, reply
);
863 glxSwapQueryExtensionsStringReply(ClientPtr client
,
864 xGLXQueryExtensionsStringReply
* reply
,
867 int length
= reply
->length
;
869 __GLX_DECLARE_SWAP_VARIABLES
;
870 __GLX_DECLARE_SWAP_ARRAY_VARIABLES
;
871 __GLX_SWAP_SHORT(&reply
->sequenceNumber
);
872 __GLX_SWAP_INT(&reply
->length
);
873 __GLX_SWAP_INT(&reply
->n
);
874 WriteToClient(client
, sz_xGLXQueryExtensionsStringReply
, reply
);
875 __GLX_SWAP_INT_ARRAY((int *) buf
, length
);
876 WriteToClient(client
, length
<< 2, buf
);
880 glxSwapQueryServerStringReply(ClientPtr client
,
881 xGLXQueryServerStringReply
* reply
, char *buf
)
883 int length
= reply
->length
;
885 __GLX_DECLARE_SWAP_VARIABLES
;
886 __GLX_SWAP_SHORT(&reply
->sequenceNumber
);
887 __GLX_SWAP_INT(&reply
->length
);
888 __GLX_SWAP_INT(&reply
->n
);
889 WriteToClient(client
, sz_xGLXQueryServerStringReply
, reply
);
890 /** no swap is needed for an array of chars **/
891 /* __GLX_SWAP_INT_ARRAY((int *)buf, length); */
892 WriteToClient(client
, length
<< 2, buf
);
896 __glXSwapQueryContextInfoEXTReply(ClientPtr client
,
897 xGLXQueryContextInfoEXTReply
* reply
,
900 int length
= reply
->length
;
902 __GLX_DECLARE_SWAP_VARIABLES
;
903 __GLX_DECLARE_SWAP_ARRAY_VARIABLES
;
904 __GLX_SWAP_SHORT(&reply
->sequenceNumber
);
905 __GLX_SWAP_INT(&reply
->length
);
906 __GLX_SWAP_INT(&reply
->n
);
907 WriteToClient(client
, sz_xGLXQueryContextInfoEXTReply
, reply
);
908 __GLX_SWAP_INT_ARRAY((int *) buf
, length
);
909 WriteToClient(client
, length
<< 2, buf
);
913 __glXSwapGetDrawableAttributesReply(ClientPtr client
,
914 xGLXGetDrawableAttributesReply
* reply
,
917 int length
= reply
->length
;
919 __GLX_DECLARE_SWAP_VARIABLES
;
920 __GLX_DECLARE_SWAP_ARRAY_VARIABLES
;
921 __GLX_SWAP_SHORT(&reply
->sequenceNumber
);
922 __GLX_SWAP_INT(&reply
->length
);
923 __GLX_SWAP_INT(&reply
->numAttribs
);
924 WriteToClient(client
, sz_xGLXGetDrawableAttributesReply
, reply
);
925 __GLX_SWAP_INT_ARRAY((int *) buf
, length
);
926 WriteToClient(client
, length
<< 2, buf
);
929 /************************************************************************/
932 ** Render and Renderlarge are not in the GLX API. They are used by the GLX
933 ** client library to send batches of GL rendering commands.
937 __glXDispSwap_Render(__GLXclientState
* cl
, GLbyte
* pc
)
939 return __glXDisp_Render(cl
, pc
);
943 ** Execute a large rendering request (one that spans multiple X requests).
946 __glXDispSwap_RenderLarge(__GLXclientState
* cl
, GLbyte
* pc
)
948 return __glXDisp_RenderLarge(cl
, pc
);
951 /************************************************************************/
954 ** No support is provided for the vendor-private requests other than
955 ** allocating these entry points in the dispatch table.
959 __glXDispSwap_VendorPrivate(__GLXclientState
* cl
, GLbyte
* pc
)
961 xGLXVendorPrivateReq
*req
;
963 __GLXdispatchVendorPrivProcPtr proc
;
965 __GLX_DECLARE_SWAP_VARIABLES
;
967 req
= (xGLXVendorPrivateReq
*) pc
;
968 __GLX_SWAP_SHORT(&req
->length
);
969 __GLX_SWAP_INT(&req
->vendorCode
);
971 vendorcode
= req
->vendorCode
;
973 proc
= (__GLXdispatchVendorPrivProcPtr
)
974 __glXGetProtocolDecodeFunction(&VendorPriv_dispatch_info
,
977 (*proc
) (cl
, (GLbyte
*) req
);
981 cl
->client
->errorValue
= req
->vendorCode
;
982 return __glXError(GLXUnsupportedPrivateRequest
);
986 __glXDispSwap_VendorPrivateWithReply(__GLXclientState
* cl
, GLbyte
* pc
)
988 xGLXVendorPrivateWithReplyReq
*req
;
990 __GLXdispatchVendorPrivProcPtr proc
;
992 __GLX_DECLARE_SWAP_VARIABLES
;
994 req
= (xGLXVendorPrivateWithReplyReq
*) pc
;
995 __GLX_SWAP_SHORT(&req
->length
);
996 __GLX_SWAP_INT(&req
->vendorCode
);
998 vendorcode
= req
->vendorCode
;
1000 proc
= (__GLXdispatchVendorPrivProcPtr
)
1001 __glXGetProtocolDecodeFunction(&VendorPriv_dispatch_info
,
1004 return (*proc
) (cl
, (GLbyte
*) req
);
1007 cl
->client
->errorValue
= req
->vendorCode
;
1008 return __glXError(GLXUnsupportedPrivateRequest
);