1 module glx.glxproto; 2 3 // This file is generated using dstep 4 5 version(linux): 6 extern (C): 7 8 private import x11.Xmd; 9 private import glx.glx; 10 private import glx.glxmd; 11 12 13 /* 14 ** Errrors. 15 */ 16 enum GLXBadContext = 0; 17 enum GLXBadContextState = 1; 18 enum GLXBadDrawable = 2; 19 enum GLXBadPixmap = 3; 20 enum GLXBadContextTag = 4; 21 enum GLXBadCurrentWindow = 5; 22 enum GLXBadRenderRequest = 6; 23 enum GLXBadLargeRequest = 7; 24 enum GLXUnsupportedPrivateRequest = 8; 25 enum GLXBadFBConfig = 9; 26 enum GLXBadPbuffer = 10; 27 enum GLXBadCurrentDrawable = 11; 28 enum GLXBadWindow = 12; 29 enum GLXBadProfileARB = 13; 30 31 enum __GLX_NUMBER_ERRORS = 14; 32 33 /* 34 ** Events. 35 ** __GLX_NUMBER_EVENTS is set to 17 to account for the BufferClobberSGIX 36 ** event - this helps initialization if the server supports the pbuffer 37 ** extension and the client doesn't. 38 */ 39 enum GLX_PbufferClobber = 0; 40 enum GLX_BufferSwapComplete = 1; 41 42 enum __GLX_NUMBER_EVENTS = 17; 43 44 enum GLX_EXTENSION_NAME = "GLX"; 45 enum GLX_EXTENSION_ALIAS = "SGI-GLX"; 46 47 enum __GLX_MAX_CONTEXT_PROPS = 3; 48 49 /*****************************************************************************/ 50 51 /* 52 ** For the structure definitions in this file, we must redefine these types in 53 ** terms of Xmd.h types, which may include bitfields. All of these are 54 ** undef'ed at the end of this file, restoring the definitions in glx.h. 55 */ 56 alias GLXContextID = CARD32; 57 alias GLXPixmap = CARD32; 58 alias GLXDrawable = CARD32; 59 alias GLXPbuffer = CARD32; 60 alias GLXWindow = CARD32; 61 alias GLXFBConfigID = CARD32; 62 alias GLXFBConfigIDSGIX = CARD32; 63 alias GLXPbufferSGIX = CARD32; 64 65 /* 66 ** ContextTag is not exposed to the API. 67 */ 68 alias GLXContextTag = uint; 69 70 /*****************************************************************************/ 71 72 /* 73 ** Sizes of basic wire types. 74 */ 75 enum __GLX_SIZE_INT8 = 1; 76 enum __GLX_SIZE_INT16 = 2; 77 enum __GLX_SIZE_INT32 = 4; 78 enum __GLX_SIZE_CARD8 = 1; 79 enum __GLX_SIZE_CARD16 = 2; 80 enum __GLX_SIZE_CARD32 = 4; 81 enum __GLX_SIZE_FLOAT32 = 4; 82 enum __GLX_SIZE_FLOAT64 = 8; 83 84 /*****************************************************************************/ 85 86 /* Requests */ 87 88 /* 89 ** Render command request. A bunch of rendering commands are packed into 90 ** a single X extension request. 91 */ 92 struct GLXRender 93 { 94 CARD8 reqType; 95 CARD8 glxCode; 96 CARD16 length; 97 GLXContextTag contextTag; 98 } 99 100 alias xGLXRenderReq = GLXRender; 101 enum sz_xGLXRenderReq = 8; 102 103 /* 104 ** The maximum size that a GLXRender command can be. The value must fit 105 ** in 16 bits and should be a multiple of 4. 106 */ 107 enum __GLX_MAX_RENDER_CMD_SIZE = 64000; 108 109 /* 110 ** Large render command request. A single large rendering command 111 ** is output in multiple X extension requests. The first packet 112 ** contains an opcode dependent header (see below) that describes 113 ** the data that follows. 114 */ 115 struct GLXRenderLarge 116 { 117 CARD8 reqType; 118 CARD8 glxCode; 119 CARD16 length; 120 GLXContextTag contextTag; 121 CARD16 requestNumber; 122 CARD16 requestTotal; 123 CARD32 dataBytes; 124 } 125 126 alias xGLXRenderLargeReq = GLXRenderLarge; 127 enum sz_xGLXRenderLargeReq = 16; 128 129 /* 130 ** GLX single request. Commands that go over as single GLX protocol 131 ** requests use this structure. The glxCode will be one of the X_GLsop 132 ** opcodes. 133 */ 134 struct GLXSingle 135 { 136 CARD8 reqType; 137 CARD8 glxCode; 138 CARD16 length; 139 GLXContextTag contextTag; 140 } 141 142 alias xGLXSingleReq = GLXSingle; 143 enum sz_xGLXSingleReq = 8; 144 145 /* 146 ** glXQueryVersion request 147 */ 148 struct GLXQueryVersion 149 { 150 CARD8 reqType; 151 CARD8 glxCode; 152 CARD16 length; 153 CARD32 majorVersion; 154 CARD32 minorVersion; 155 } 156 157 alias xGLXQueryVersionReq = GLXQueryVersion; 158 enum sz_xGLXQueryVersionReq = 12; 159 160 /* 161 ** glXIsDirect request 162 */ 163 struct GLXIsDirect 164 { 165 CARD8 reqType; 166 CARD8 glxCode; 167 CARD16 length; 168 CARD32 context; 169 } 170 171 alias xGLXIsDirectReq = GLXIsDirect; 172 enum sz_xGLXIsDirectReq = 8; 173 174 /* 175 ** glXCreateContext request 176 */ 177 struct GLXCreateContext 178 { 179 CARD8 reqType; 180 CARD8 glxCode; 181 CARD16 length; 182 CARD32 context; 183 CARD32 visual; 184 CARD32 screen; 185 CARD32 shareList; 186 BOOL isDirect; 187 CARD8 reserved1; 188 CARD16 reserved2; 189 } 190 191 alias xGLXCreateContextReq = GLXCreateContext; 192 enum sz_xGLXCreateContextReq = 24; 193 194 /* 195 ** glXDestroyContext request 196 */ 197 struct GLXDestroyContext 198 { 199 CARD8 reqType; 200 CARD8 glxCode; 201 CARD16 length; 202 CARD32 context; 203 } 204 205 alias xGLXDestroyContextReq = GLXDestroyContext; 206 enum sz_xGLXDestroyContextReq = 8; 207 208 /* 209 ** glXMakeCurrent request 210 */ 211 struct GLXMakeCurrent 212 { 213 CARD8 reqType; 214 CARD8 glxCode; 215 CARD16 length; 216 CARD32 drawable; 217 CARD32 context; 218 GLXContextTag oldContextTag; 219 } 220 221 alias xGLXMakeCurrentReq = GLXMakeCurrent; 222 enum sz_xGLXMakeCurrentReq = 16; 223 224 /* 225 ** glXWaitGL request 226 */ 227 struct GLXWaitGL 228 { 229 CARD8 reqType; 230 CARD8 glxCode; 231 CARD16 length; 232 GLXContextTag contextTag; 233 } 234 235 alias xGLXWaitGLReq = GLXWaitGL; 236 enum sz_xGLXWaitGLReq = 8; 237 238 /* 239 ** glXWaitX request 240 */ 241 struct GLXWaitX 242 { 243 CARD8 reqType; 244 CARD8 glxCode; 245 CARD16 length; 246 GLXContextTag contextTag; 247 } 248 249 alias xGLXWaitXReq = GLXWaitX; 250 enum sz_xGLXWaitXReq = 8; 251 252 /* 253 ** glXCopyContext request 254 */ 255 struct GLXCopyContext 256 { 257 CARD8 reqType; 258 CARD8 glxCode; 259 CARD16 length; 260 CARD32 source; 261 CARD32 dest; 262 CARD32 mask; 263 GLXContextTag contextTag; 264 } 265 266 alias xGLXCopyContextReq = GLXCopyContext; 267 enum sz_xGLXCopyContextReq = 20; 268 269 /* 270 ** glXSwapBuffers request 271 */ 272 struct GLXSwapBuffers 273 { 274 CARD8 reqType; 275 CARD8 glxCode; 276 CARD16 length; 277 GLXContextTag contextTag; 278 CARD32 drawable; 279 } 280 281 alias xGLXSwapBuffersReq = GLXSwapBuffers; 282 enum sz_xGLXSwapBuffersReq = 12; 283 284 /* 285 ** glXUseXFont request 286 */ 287 struct GLXUseXFont 288 { 289 CARD8 reqType; 290 CARD8 glxCode; 291 CARD16 length; 292 GLXContextTag contextTag; 293 CARD32 font; 294 CARD32 first; 295 CARD32 count; 296 CARD32 listBase; 297 } 298 299 alias xGLXUseXFontReq = GLXUseXFont; 300 enum sz_xGLXUseXFontReq = 24; 301 302 /* 303 ** glXCreateGLXPixmap request 304 */ 305 struct GLXCreateGLXPixmap 306 { 307 CARD8 reqType; 308 CARD8 glxCode; 309 CARD16 length; 310 CARD32 screen; 311 CARD32 visual; 312 CARD32 pixmap; 313 CARD32 glxpixmap; 314 } 315 316 alias xGLXCreateGLXPixmapReq = GLXCreateGLXPixmap; 317 enum sz_xGLXCreateGLXPixmapReq = 20; 318 319 /* 320 ** glXDestroyGLXPixmap request 321 */ 322 struct GLXDestroyGLXPixmap 323 { 324 CARD8 reqType; 325 CARD8 glxCode; 326 CARD16 length; 327 CARD32 glxpixmap; 328 } 329 330 alias xGLXDestroyGLXPixmapReq = GLXDestroyGLXPixmap; 331 enum sz_xGLXDestroyGLXPixmapReq = 8; 332 333 /* 334 ** glXGetVisualConfigs request 335 */ 336 struct GLXGetVisualConfigs 337 { 338 CARD8 reqType; 339 CARD8 glxCode; 340 CARD16 length; 341 CARD32 screen; 342 } 343 344 alias xGLXGetVisualConfigsReq = GLXGetVisualConfigs; 345 enum sz_xGLXGetVisualConfigsReq = 8; 346 347 /* 348 ** glXVendorPrivate request. 349 */ 350 struct GLXVendorPrivate 351 { 352 CARD8 reqType; 353 CARD8 glxCode; 354 CARD16 length; 355 CARD32 vendorCode; /* vendor-specific opcode */ 356 GLXContextTag contextTag; 357 /* 358 ** More data may follow; this is just the header. 359 */ 360 } 361 362 alias xGLXVendorPrivateReq = GLXVendorPrivate; 363 enum sz_xGLXVendorPrivateReq = 12; 364 365 /* 366 ** glXVendorPrivateWithReply request 367 */ 368 struct GLXVendorPrivateWithReply 369 { 370 CARD8 reqType; 371 CARD8 glxCode; 372 CARD16 length; 373 CARD32 vendorCode; /* vendor-specific opcode */ 374 GLXContextTag contextTag; 375 /* 376 ** More data may follow; this is just the header. 377 */ 378 } 379 380 alias xGLXVendorPrivateWithReplyReq = GLXVendorPrivateWithReply; 381 enum sz_xGLXVendorPrivateWithReplyReq = 12; 382 383 /* 384 ** glXQueryExtensionsString request 385 */ 386 struct GLXQueryExtensionsString 387 { 388 CARD8 reqType; 389 CARD8 glxCode; 390 CARD16 length; 391 CARD32 screen; 392 } 393 394 alias xGLXQueryExtensionsStringReq = GLXQueryExtensionsString; 395 enum sz_xGLXQueryExtensionsStringReq = 8; 396 397 /* 398 ** glXQueryServerString request 399 */ 400 struct GLXQueryServerString 401 { 402 CARD8 reqType; 403 CARD8 glxCode; 404 CARD16 length; 405 CARD32 screen; 406 CARD32 name; 407 } 408 409 alias xGLXQueryServerStringReq = GLXQueryServerString; 410 enum sz_xGLXQueryServerStringReq = 12; 411 412 /* 413 ** glXClientInfo request 414 */ 415 struct GLXClientInfo 416 { 417 CARD8 reqType; 418 CARD8 glxCode; 419 CARD16 length; 420 CARD32 major; 421 CARD32 minor; 422 CARD32 numbytes; 423 } 424 425 alias xGLXClientInfoReq = GLXClientInfo; 426 enum sz_xGLXClientInfoReq = 16; 427 428 /*** Start of GLX 1.3 requests */ 429 430 /* 431 ** glXGetFBConfigs request 432 */ 433 struct GLXGetFBConfigs 434 { 435 CARD8 reqType; 436 CARD8 glxCode; 437 CARD16 length; 438 CARD32 screen; 439 } 440 441 alias xGLXGetFBConfigsReq = GLXGetFBConfigs; 442 enum sz_xGLXGetFBConfigsReq = 8; 443 444 /* 445 ** glXCreatePixmap request 446 */ 447 struct GLXCreatePixmap 448 { 449 CARD8 reqType; 450 CARD8 glxCode; 451 CARD16 length; 452 CARD32 screen; 453 CARD32 fbconfig; 454 CARD32 pixmap; 455 CARD32 glxpixmap; 456 CARD32 numAttribs; 457 /* followed by attribute list */ 458 } 459 460 alias xGLXCreatePixmapReq = GLXCreatePixmap; 461 enum sz_xGLXCreatePixmapReq = 24; 462 463 /* 464 ** glXDestroyPixmap request 465 */ 466 struct GLXDestroyPixmap 467 { 468 CARD8 reqType; 469 CARD8 glxCode; 470 CARD16 length; 471 CARD32 glxpixmap; 472 } 473 474 alias xGLXDestroyPixmapReq = GLXDestroyPixmap; 475 enum sz_xGLXDestroyPixmapReq = 8; 476 477 /* 478 ** glXCreateNewContext request 479 */ 480 struct GLXCreateNewContext 481 { 482 CARD8 reqType; 483 CARD8 glxCode; 484 CARD16 length; 485 CARD32 context; 486 CARD32 fbconfig; 487 CARD32 screen; 488 CARD32 renderType; 489 CARD32 shareList; 490 BOOL isDirect; 491 CARD8 reserved1; 492 CARD16 reserved2; 493 } 494 495 alias xGLXCreateNewContextReq = GLXCreateNewContext; 496 enum sz_xGLXCreateNewContextReq = 28; 497 498 /* 499 ** glXQueryContext request 500 */ 501 struct GLXQueryContext 502 { 503 CARD8 reqType; 504 CARD8 glxCode; 505 CARD16 length; 506 CARD32 context; 507 } 508 509 alias xGLXQueryContextReq = GLXQueryContext; 510 enum sz_xGLXQueryContextReq = 8; 511 512 /* 513 ** glXMakeContextCurrent request 514 */ 515 struct GLXMakeContextCurrent 516 { 517 CARD8 reqType; 518 CARD8 glxCode; 519 CARD16 length; 520 GLXContextTag oldContextTag; 521 CARD32 drawable; 522 CARD32 readdrawable; 523 CARD32 context; 524 } 525 526 alias xGLXMakeContextCurrentReq = GLXMakeContextCurrent; 527 enum sz_xGLXMakeContextCurrentReq = 20; 528 529 /* 530 ** glXCreatePbuffer request 531 */ 532 struct GLXCreatePbuffer 533 { 534 CARD8 reqType; 535 CARD8 glxCode; 536 CARD16 length; 537 CARD32 screen; 538 CARD32 fbconfig; 539 CARD32 pbuffer; 540 CARD32 numAttribs; 541 /* followed by attribute list */ 542 } 543 544 alias xGLXCreatePbufferReq = GLXCreatePbuffer; 545 enum sz_xGLXCreatePbufferReq = 20; 546 547 /* 548 ** glXDestroyPbuffer request 549 */ 550 struct GLXDestroyPbuffer 551 { 552 CARD8 reqType; 553 CARD8 glxCode; 554 CARD16 length; 555 CARD32 pbuffer; 556 } 557 558 alias xGLXDestroyPbufferReq = GLXDestroyPbuffer; 559 enum sz_xGLXDestroyPbufferReq = 8; 560 561 /* 562 ** glXGetDrawableAttributes request 563 */ 564 struct GLXGetDrawableAttributes 565 { 566 CARD8 reqType; 567 CARD8 glxCode; 568 CARD16 length; 569 CARD32 drawable; 570 } 571 572 alias xGLXGetDrawableAttributesReq = GLXGetDrawableAttributes; 573 enum sz_xGLXGetDrawableAttributesReq = 8; 574 575 /* 576 ** glXChangeDrawableAttributes request 577 */ 578 struct GLXChangeDrawableAttributes 579 { 580 CARD8 reqType; 581 CARD8 glxCode; 582 CARD16 length; 583 CARD32 drawable; 584 CARD32 numAttribs; 585 /* followed by attribute list */ 586 } 587 588 alias xGLXChangeDrawableAttributesReq = GLXChangeDrawableAttributes; 589 enum sz_xGLXChangeDrawableAttributesReq = 12; 590 591 /* 592 ** glXCreateWindow request 593 */ 594 struct GLXCreateWindow 595 { 596 CARD8 reqType; 597 CARD8 glxCode; 598 CARD16 length; 599 CARD32 screen; 600 CARD32 fbconfig; 601 CARD32 window; 602 CARD32 glxwindow; 603 CARD32 numAttribs; 604 /* followed by attribute list */ 605 } 606 607 alias xGLXCreateWindowReq = GLXCreateWindow; 608 enum sz_xGLXCreateWindowReq = 24; 609 610 /* 611 ** glXDestroyWindow request 612 */ 613 struct GLXDestroyWindow 614 { 615 CARD8 reqType; 616 CARD8 glxCode; 617 CARD16 length; 618 CARD32 glxwindow; 619 } 620 621 alias xGLXDestroyWindowReq = GLXDestroyWindow; 622 enum sz_xGLXDestroyWindowReq = 8; 623 624 /* Replies */ 625 626 struct xGLXGetErrorReply 627 { 628 BYTE type; /* X_Reply */ 629 CARD8 unused; /* not used */ 630 CARD16 sequenceNumber; 631 CARD32 length; 632 CARD32 error; 633 CARD32 pad2; 634 CARD32 pad3; 635 CARD32 pad4; 636 CARD32 pad5; 637 CARD32 pad6; 638 } 639 640 enum sz_xGLXGetErrorReply = 32; 641 642 struct xGLXMakeCurrentReply 643 { 644 BYTE type; /* X_Reply */ 645 CARD8 unused; /* not used */ 646 CARD16 sequenceNumber; 647 CARD32 length; 648 GLXContextTag contextTag; 649 CARD32 pad2; 650 CARD32 pad3; 651 CARD32 pad4; 652 CARD32 pad5; 653 CARD32 pad6; 654 } 655 656 enum sz_xGLXMakeCurrentReply = 32; 657 658 struct xGLXReadPixelsReply 659 { 660 BYTE type; /* X_Reply */ 661 CARD8 unused; /* not used */ 662 CARD16 sequenceNumber; 663 CARD32 length; 664 CARD32 pad1; 665 CARD32 pad2; 666 CARD32 pad3; 667 CARD32 pad4; 668 CARD32 pad5; 669 CARD32 pad6; 670 } 671 672 enum sz_xGLXReadPixelsReply = 32; 673 674 struct xGLXGetTexImageReply 675 { 676 BYTE type; /* X_Reply */ 677 CARD8 unused; /* not used */ 678 CARD16 sequenceNumber; 679 CARD32 length; 680 CARD32 pad1; 681 CARD32 pad2; 682 CARD32 width; 683 CARD32 height; 684 CARD32 depth; 685 CARD32 pad6; 686 } 687 688 enum sz_xGLXGetTexImageReply = 32; 689 690 struct xGLXGetSeparableFilterReply 691 { 692 BYTE type; /* X_Reply */ 693 CARD8 unused; /* not used */ 694 CARD16 sequenceNumber; 695 CARD32 length; 696 CARD32 pad1; 697 CARD32 pad2; 698 CARD32 width; 699 CARD32 height; 700 CARD32 pad5; 701 CARD32 pad6; 702 } 703 704 enum sz_xGLXGetSeparableFilterReply = 32; 705 706 struct xGLXGetConvolutionFilterReply 707 { 708 BYTE type; /* X_Reply */ 709 CARD8 unused; /* not used */ 710 CARD16 sequenceNumber; 711 CARD32 length; 712 CARD32 pad1; 713 CARD32 pad2; 714 CARD32 width; 715 CARD32 height; 716 CARD32 pad5; 717 CARD32 pad6; 718 } 719 720 enum sz_xGLXGetConvolutionFilterReply = 32; 721 722 struct xGLXGetHistogramReply 723 { 724 BYTE type; /* X_Reply */ 725 CARD8 unused; /* not used */ 726 CARD16 sequenceNumber; 727 CARD32 length; 728 CARD32 pad1; 729 CARD32 pad2; 730 CARD32 width; 731 CARD32 pad4; 732 CARD32 pad5; 733 CARD32 pad6; 734 } 735 736 enum sz_xGLXGetHistogramReply = 32; 737 738 struct xGLXGetMinmaxReply 739 { 740 BYTE type; /* X_Reply */ 741 CARD8 unused; /* not used */ 742 CARD16 sequenceNumber; 743 CARD32 length; 744 CARD32 pad1; 745 CARD32 pad2; 746 CARD32 pad3; 747 CARD32 pad4; 748 CARD32 pad5; 749 CARD32 pad6; 750 } 751 752 enum sz_xGLXGetMinmaxReply = 32; 753 754 struct xGLXRenderModeReply 755 { 756 BYTE type; /* X_Reply */ 757 CARD8 unused; /* not used */ 758 CARD16 sequenceNumber; 759 CARD32 length; 760 CARD32 retval; 761 CARD32 size; 762 CARD32 newMode; 763 CARD32 pad4; 764 CARD32 pad5; 765 CARD32 pad6; 766 } 767 768 enum sz_xGLXRenderModeReply = 32; 769 770 struct xGLXQueryVersionReply 771 { 772 BYTE type; /* X_Reply */ 773 CARD8 unused; /* not used */ 774 CARD16 sequenceNumber; 775 CARD32 length; 776 CARD32 majorVersion; 777 CARD32 minorVersion; 778 CARD32 pad3; 779 CARD32 pad4; 780 CARD32 pad5; 781 CARD32 pad6; 782 } 783 784 enum sz_xGLXQueryVersionReply = 32; 785 786 struct xGLXGetVisualConfigsReply 787 { 788 BYTE type; /* X_Reply */ 789 CARD8 unused; /* not used */ 790 CARD16 sequenceNumber; 791 CARD32 length; 792 CARD32 numVisuals; 793 CARD32 numProps; 794 CARD32 pad3; 795 CARD32 pad4; 796 CARD32 pad5; 797 CARD32 pad6; 798 } 799 800 enum sz_xGLXGetVisualConfigsReply = 32; 801 802 struct xGLXIsDirectReply 803 { 804 BYTE type; /* X_Reply */ 805 CARD8 unused; /* not used */ 806 CARD16 sequenceNumber; 807 CARD32 length; 808 BOOL isDirect; 809 CARD8 pad1; 810 CARD16 pad2; 811 CARD32 pad3; 812 CARD32 pad4; 813 CARD32 pad5; 814 CARD32 pad6; 815 CARD32 pad7; 816 } 817 818 enum sz_xGLXIsDirectReply = 32; 819 820 /* 821 ** This reply structure is used for all single replies. Single replies 822 ** ship either 1 piece of data or N pieces of data. In these cases 823 ** size indicates how much data is to be returned. 824 */ 825 struct xGLXSingleReply 826 { 827 BYTE type; /* X_Reply */ 828 CARD8 unused; /* not used */ 829 CARD16 sequenceNumber; 830 CARD32 length; 831 CARD32 retval; 832 CARD32 size; 833 CARD32 pad3; /* NOTE: may hold a single value */ 834 CARD32 pad4; /* NOTE: may hold half a double */ 835 CARD32 pad5; 836 CARD32 pad6; 837 } 838 839 enum sz_xGLXSingleReply = 32; 840 841 /* 842 ** This reply structure is used for all Vendor Private replies. Vendor 843 ** Private replies can ship up to 24 bytes within the header or can 844 ** be variable sized, in which case, the reply length field indicates 845 ** the number of words of data which follow the header. 846 */ 847 struct xGLXVendorPrivReply 848 { 849 BYTE type; /* X_Reply */ 850 CARD8 unused; /* not used */ 851 CARD16 sequenceNumber; 852 CARD32 length; 853 CARD32 retval; 854 CARD32 size; 855 CARD32 pad3; 856 CARD32 pad4; 857 CARD32 pad5; 858 CARD32 pad6; 859 } 860 861 enum sz_xGLXVendorPrivReply = 32; 862 863 /* 864 ** QueryExtensionsStringReply 865 ** n indicates the number of bytes to be returned. 866 */ 867 struct xGLXQueryExtensionsStringReply 868 { 869 BYTE type; /* X_Reply */ 870 CARD8 unused; /* not used */ 871 CARD16 sequenceNumber; 872 CARD32 length; 873 CARD32 pad1; 874 CARD32 n; 875 CARD32 pad3; 876 CARD32 pad4; 877 CARD32 pad5; 878 CARD32 pad6; 879 } 880 881 enum sz_xGLXQueryExtensionsStringReply = 32; 882 883 /* 884 ** QueryServerString Reply struct 885 ** n indicates the number of bytes to be returned. 886 */ 887 struct xGLXQueryServerStringReply 888 { 889 BYTE type; /* X_Reply */ 890 CARD8 unused; /* not used */ 891 CARD16 sequenceNumber; 892 CARD32 length; 893 CARD32 pad1; 894 CARD32 n; 895 CARD32 pad3; /* NOTE: may hold a single value */ 896 CARD32 pad4; /* NOTE: may hold half a double */ 897 CARD32 pad5; 898 CARD32 pad6; 899 } 900 901 enum sz_xGLXQueryServerStringReply = 32; 902 903 /*** Start of GLX 1.3 replies */ 904 905 /* 906 ** glXGetFBConfigs reply 907 */ 908 struct xGLXGetFBConfigsReply 909 { 910 BYTE type; /* X_Reply */ 911 CARD8 unused; /* not used */ 912 CARD16 sequenceNumber; 913 CARD32 length; 914 CARD32 numFBConfigs; 915 CARD32 numAttribs; 916 CARD32 pad3; 917 CARD32 pad4; 918 CARD32 pad5; 919 CARD32 pad6; 920 } 921 922 enum sz_xGLXGetFBConfigsReply = 32; 923 924 /* 925 ** glXQueryContext reply 926 */ 927 struct xGLXQueryContextReply 928 { 929 BYTE type; /* X_Reply */ 930 CARD8 unused; /* not used */ 931 CARD16 sequenceNumber; 932 CARD32 length; 933 CARD32 n; /* number of attribute/value pairs */ 934 CARD32 pad2; 935 CARD32 pad3; 936 CARD32 pad4; 937 CARD32 pad5; 938 CARD32 pad6; 939 } 940 941 enum sz_xGLXQueryContextReply = 32; 942 943 /* 944 ** glXMakeContextCurrent reply 945 */ 946 struct xGLXMakeContextCurrentReply 947 { 948 BYTE type; /* X_Reply */ 949 CARD8 unused; /* not used */ 950 CARD16 sequenceNumber; 951 CARD32 length; 952 GLXContextTag contextTag; 953 CARD32 pad2; 954 CARD32 pad3; 955 CARD32 pad4; 956 CARD32 pad5; 957 CARD32 pad6; 958 } 959 960 enum sz_xGLXMakeContextCurrentReply = 32; 961 962 /* 963 ** glXCreateGLXPbuffer reply 964 ** This is used only in the direct rendering case on SGIs - otherwise 965 ** CreateGLXPbuffer has no reply. It is not part of GLX 1.3. 966 */ 967 struct xGLXCreateGLXPbufferReply 968 { 969 BYTE type; /* X_Reply */ 970 CARD8 success; 971 CARD16 sequenceNumber; 972 CARD32 length; 973 CARD32 pad1; 974 CARD32 pad2; 975 CARD32 pad3; 976 CARD32 pad4; 977 CARD32 pad5; 978 CARD32 pad6; 979 } 980 981 enum sz_xGLXCreateGLXPbufferReply = 32; 982 983 /* 984 ** glXGetDrawableAttributes reply 985 */ 986 struct xGLXGetDrawableAttributesReply 987 { 988 BYTE type; /* X_Reply */ 989 CARD8 unused; /* not used */ 990 CARD16 sequenceNumber; 991 CARD32 length; 992 CARD32 numAttribs; 993 CARD32 pad2; 994 CARD32 pad3; 995 CARD32 pad4; 996 CARD32 pad5; 997 CARD32 pad6; 998 } 999 1000 enum sz_xGLXGetDrawableAttributesReply = 32; 1001 1002 /* 1003 ** glXGetColorTable reply 1004 */ 1005 struct xGLXGetColorTableReply 1006 { 1007 BYTE type; /* X_Reply */ 1008 CARD8 unused; /* not used */ 1009 CARD16 sequenceNumber; 1010 CARD32 length; 1011 CARD32 pad1; 1012 CARD32 pad2; 1013 CARD32 width; 1014 CARD32 pad4; 1015 CARD32 pad5; 1016 CARD32 pad6; 1017 } 1018 1019 enum sz_xGLXGetColorTableReply = 32; 1020 1021 /************************************************************************/ 1022 1023 /* GLX extension requests and replies */ 1024 1025 /* 1026 ** glXQueryContextInfoEXT request 1027 */ 1028 struct GLXQueryContextInfoEXT 1029 { 1030 CARD8 reqType; 1031 CARD8 glxCode; 1032 CARD16 length; 1033 CARD32 vendorCode; /* vendor-specific opcode */ 1034 CARD32 pad1; /* unused; corresponds to contextTag in header */ 1035 CARD32 context; 1036 } 1037 1038 alias xGLXQueryContextInfoEXTReq = GLXQueryContextInfoEXT; 1039 enum sz_xGLXQueryContextInfoEXTReq = 16; 1040 1041 /* 1042 ** glXQueryContextInfoEXT reply 1043 */ 1044 struct xGLXQueryContextInfoEXTReply 1045 { 1046 BYTE type; /* X_Reply */ 1047 CARD8 unused; /* not used */ 1048 CARD16 sequenceNumber; 1049 CARD32 length; 1050 CARD32 n; /* number of attribute/value pairs */ 1051 CARD32 pad2; 1052 CARD32 pad3; 1053 CARD32 pad4; 1054 CARD32 pad5; 1055 CARD32 pad6; 1056 } 1057 1058 enum sz_xGLXQueryContextInfoEXTReply = 32; 1059 1060 /* 1061 ** glXMakeCurrentReadSGI request 1062 */ 1063 struct GLXMakeCurrentReadSGI 1064 { 1065 CARD8 reqType; 1066 CARD8 glxCode; 1067 CARD16 length; 1068 CARD32 vendorCode; /* vendor-specific opcode */ 1069 GLXContextTag oldContextTag; 1070 CARD32 drawable; 1071 CARD32 readable; 1072 CARD32 context; 1073 } 1074 1075 alias xGLXMakeCurrentReadSGIReq = GLXMakeCurrentReadSGI; 1076 enum sz_xGLXMakeCurrentReadSGIReq = 24; 1077 1078 struct xGLXMakeCurrentReadSGIReply 1079 { 1080 BYTE type; /* X_Reply */ 1081 CARD8 unused; /* not used */ 1082 CARD16 sequenceNumber; 1083 CARD32 length; 1084 GLXContextTag contextTag; 1085 CARD32 writeVid; 1086 CARD32 writeType; 1087 CARD32 readVid; 1088 CARD32 readType; 1089 CARD32 pad6; 1090 } 1091 1092 enum sz_xGLXMakeCurrentReadSGIReply = 32; 1093 1094 /* 1095 ** glXGetFBConfigsSGIX request 1096 */ 1097 struct GLXGetFBConfigsSGIX 1098 { 1099 CARD8 reqType; 1100 CARD8 glxCode; 1101 CARD16 length; 1102 CARD32 vendorCode; /* vendor-specific opcode */ 1103 CARD32 pad1; /* unused; corresponds to contextTag in header */ 1104 CARD32 screen; 1105 } 1106 1107 alias xGLXGetFBConfigsSGIXReq = GLXGetFBConfigsSGIX; 1108 enum sz_xGLXGetFBConfigsSGIXReq = 16; 1109 1110 /* 1111 ** glXCreateContextWithConfigSGIX request 1112 */ 1113 1114 struct GLXCreateContextWithConfigSGIX 1115 { 1116 CARD8 reqType; 1117 CARD8 glxCode; 1118 CARD16 length; 1119 CARD32 vendorCode; /* vendor-specific opcode */ 1120 CARD32 pad1; /* unused; corresponds to contextTag in header */ 1121 CARD32 context; 1122 CARD32 fbconfig; 1123 CARD32 screen; 1124 CARD32 renderType; 1125 CARD32 shareList; 1126 BOOL isDirect; 1127 CARD8 reserved1; 1128 CARD16 reserved2; 1129 } 1130 1131 alias xGLXCreateContextWithConfigSGIXReq = GLXCreateContextWithConfigSGIX; 1132 enum sz_xGLXCreateContextWithConfigSGIXReq = 36; 1133 1134 /* 1135 ** glXCreatePixmapWithConfigSGIX request 1136 */ 1137 1138 struct GLXCreateGLXPixmapWithConfigSGIX 1139 { 1140 CARD8 reqType; 1141 CARD8 glxCode; 1142 CARD16 length; 1143 CARD32 vendorCode; /* vendor-specific opcode */ 1144 CARD32 pad1; /* unused; corresponds to contextTag in header */ 1145 CARD32 screen; 1146 CARD32 fbconfig; 1147 CARD32 pixmap; 1148 CARD32 glxpixmap; 1149 } 1150 1151 alias xGLXCreateGLXPixmapWithConfigSGIXReq = GLXCreateGLXPixmapWithConfigSGIX; 1152 enum sz_xGLXCreateGLXPixmapWithConfigSGIXReq = 28; 1153 1154 /* 1155 ** glXCreateGLXPbufferSGIX request 1156 */ 1157 struct GLXCreateGLXPbufferSGIX 1158 { 1159 CARD8 reqType; 1160 CARD8 glxCode; 1161 CARD16 length; 1162 CARD32 vendorCode; /* vendor-specific opcode */ 1163 CARD32 pad1; /* unused; corresponds to contextTag in header */ 1164 CARD32 screen; 1165 CARD32 fbconfig; 1166 CARD32 pbuffer; 1167 CARD32 width; 1168 CARD32 height; 1169 /* followed by attribute list */ 1170 } 1171 1172 alias xGLXCreateGLXPbufferSGIXReq = GLXCreateGLXPbufferSGIX; 1173 enum sz_xGLXCreateGLXPbufferSGIXReq = 32; 1174 1175 /* 1176 ** glXDestroyGLXPbufferSGIX request 1177 */ 1178 struct GLXDestroyGLXPbuffer 1179 { 1180 CARD8 reqType; 1181 CARD8 glxCode; 1182 CARD16 length; 1183 CARD32 vendorCode; /* vendor-specific opcode */ 1184 CARD32 pad1; /* unused; corresponds to contextTag in header */ 1185 CARD32 pbuffer; 1186 } 1187 1188 alias xGLXDestroyGLXPbufferSGIXReq = GLXDestroyGLXPbuffer; 1189 enum sz_xGLXDestroyGLXPbufferSGIXReq = 16; 1190 1191 /* 1192 ** glXChangeDrawableAttributesSGIX request 1193 */ 1194 struct GLXChangeDrawableAttributesSGIX 1195 { 1196 CARD8 reqType; 1197 CARD8 glxCode; 1198 CARD16 length; 1199 CARD32 vendorCode; /* vendor-specific opcode */ 1200 CARD32 pad1; /* unused; corresponds to contextTag in header */ 1201 CARD32 drawable; 1202 CARD32 numAttribs; 1203 /* followed by attribute list */ 1204 } 1205 1206 alias xGLXChangeDrawableAttributesSGIXReq = GLXChangeDrawableAttributesSGIX; 1207 enum sz_xGLXChangeDrawableAttributesSGIXReq = 20; 1208 1209 /* 1210 ** glXGetDrawableAttributesSGIX request 1211 */ 1212 struct GLXGetDrawableAttributesSGIX 1213 { 1214 CARD8 reqType; 1215 CARD8 glxCode; 1216 CARD16 length; 1217 CARD32 vendorCode; /* vendor-specific opcode */ 1218 CARD32 pad1; /* unused; corresponds to contextTag in header */ 1219 CARD32 drawable; 1220 } 1221 1222 alias xGLXGetDrawableAttributesSGIXReq = GLXGetDrawableAttributesSGIX; 1223 enum sz_xGLXGetDrawableAttributesSGIXReq = 16; 1224 1225 /* 1226 ** glXGetDrawableAttributesSGIX reply 1227 */ 1228 struct xGLXGetDrawableAttributesSGIXReply 1229 { 1230 BYTE type; /* X_Reply */ 1231 CARD8 unused; /* not used */ 1232 CARD16 sequenceNumber; 1233 CARD32 length; 1234 CARD32 numAttribs; 1235 CARD32 pad2; 1236 CARD32 pad3; 1237 CARD32 pad4; 1238 CARD32 pad5; 1239 CARD32 pad6; 1240 } 1241 1242 enum sz_xGLXGetDrawableAttributesSGIXReply = 32; 1243 1244 /* 1245 ** glXJoinSwapGroupSGIX request 1246 */ 1247 struct GLXJoinSwapGroupSGIX 1248 { 1249 CARD8 reqType; 1250 CARD8 glxCode; 1251 CARD16 length; 1252 CARD32 vendorCode; /* vendor-specific opcode */ 1253 CARD32 unused; /* corresponds to contextTag in hdr */ 1254 CARD32 drawable; 1255 CARD32 member; 1256 } 1257 1258 alias xGLXJoinSwapGroupSGIXReq = GLXJoinSwapGroupSGIX; 1259 enum sz_xGLXJoinSwapGroupSGIXReq = 20; 1260 1261 /* 1262 ** glXBindSwapBarrierSGIX request 1263 */ 1264 struct GLXBindSwapBarrierSGIX 1265 { 1266 CARD8 reqType; 1267 CARD8 glxCode; 1268 CARD16 length; 1269 CARD32 vendorCode; /* vendor-specific opcode */ 1270 CARD32 unused; /* corresponds to contextTag in hdr */ 1271 CARD32 drawable; 1272 CARD32 barrier; 1273 } 1274 1275 alias xGLXBindSwapBarrierSGIXReq = GLXBindSwapBarrierSGIX; 1276 enum sz_xGLXBindSwapBarrierSGIXReq = 20; 1277 1278 /* 1279 ** glXQueryMaxSwapBarriersSGIX request 1280 */ 1281 struct GLXQueryMaxSwapBarriersSGIX 1282 { 1283 CARD8 reqType; 1284 CARD8 glxCode; 1285 CARD16 length; 1286 CARD32 vendorCode; /* vendor-specific opcode */ 1287 CARD32 unused; /* corresponds to contextTag in hdr */ 1288 CARD32 screen; 1289 } 1290 1291 alias xGLXQueryMaxSwapBarriersSGIXReq = GLXQueryMaxSwapBarriersSGIX; 1292 enum sz_xGLXQueryMaxSwapBarriersSGIXReq = 16; 1293 1294 struct xGLXQueryMaxSwapBarriersSGIXReply 1295 { 1296 BYTE type; /* X_Reply */ 1297 CARD8 unused; /* not used */ 1298 CARD16 sequenceNumber; 1299 CARD32 length; 1300 CARD32 max; 1301 CARD32 size; 1302 CARD32 pad3; 1303 CARD32 pad4; 1304 CARD32 pad5; 1305 CARD32 pad6; 1306 } 1307 1308 enum sz_xGLXQueryMaxSwapBarriersSGIXReply = 32; 1309 1310 /* 1311 ** glXQueryHyperpipeNetworkSGIX request 1312 */ 1313 struct GLXQueryHyperpipeNetworkSGIX 1314 { 1315 CARD8 reqType; 1316 CARD8 glxCode; 1317 CARD16 length; 1318 CARD32 vendorCode; /* vendor-specific opcode */ 1319 CARD32 pad1; /* unused; corresponds to contextTag in header */ 1320 CARD32 screen; 1321 } 1322 1323 alias xGLXQueryHyperpipeNetworkSGIXReq = GLXQueryHyperpipeNetworkSGIX; 1324 enum sz_xGLXQueryHyperpipeNetworkSGIXReq = 16; 1325 1326 /* 1327 ** glXQueryHyperpipeNetworkSGIX reply 1328 */ 1329 struct xGLXQueryHyperpipeNetworkSGIXReply 1330 { 1331 BYTE type; /* X_Reply */ 1332 CARD8 unused; /* not used */ 1333 CARD16 sequenceNumber; 1334 CARD32 length; 1335 CARD32 pad1; 1336 CARD32 n; 1337 CARD32 npipes; /* NOTE: may hold a single value */ 1338 CARD32 pad4; /* NOTE: may hold half a double */ 1339 CARD32 pad5; 1340 CARD32 pad6; 1341 } 1342 1343 enum sz_xGLXQueryHyperpipeNetworkSGIXReply = 32; 1344 1345 /* 1346 ** glXDestroyHyperpipeConfigSGIX request 1347 */ 1348 struct GLXDestroyHyperpipeConfigSGIX 1349 { 1350 CARD8 reqType; 1351 CARD8 glxCode; 1352 CARD16 length; 1353 CARD32 vendorCode; /* vendor-specific opcode */ 1354 CARD32 pad1; /* unused; corresponds to contextTag in header */ 1355 CARD32 screen; 1356 CARD32 hpId; 1357 CARD32 pad2; 1358 CARD32 pad3; 1359 CARD32 pad4; 1360 } 1361 1362 alias xGLXDestroyHyperpipeConfigSGIXReq = GLXDestroyHyperpipeConfigSGIX; 1363 enum sz_xGLXDestroyHyperpipeConfigSGIXReq = 32; 1364 1365 /* 1366 ** glXDestroyHyperpipeConfigSGIX reply 1367 */ 1368 struct xGLXDestroyHyperpipeConfigSGIXReply 1369 { 1370 BYTE type; /* X_Reply */ 1371 CARD8 unused; /* not used */ 1372 CARD16 sequenceNumber; 1373 CARD32 length; 1374 CARD32 pad1; 1375 CARD32 n; 1376 CARD32 success; /* NOTE: may hold a single value */ 1377 CARD32 pad4; /* NOTE: may hold half a double */ 1378 CARD32 pad5; 1379 CARD32 pad6; 1380 } 1381 1382 enum sz_xGLXDestroyHyperpipeConfigSGIXReply = 32; 1383 1384 /* 1385 ** glXQueryHyperpipeConfigSGIX request 1386 */ 1387 struct GLXQueryHyperpipeConfigSGIX 1388 { 1389 CARD8 reqType; 1390 CARD8 glxCode; 1391 CARD16 length; 1392 CARD32 vendorCode; /* vendor-specific opcode */ 1393 CARD32 pad1; /* unused; corresponds to contextTag in header */ 1394 CARD32 screen; 1395 CARD32 hpId; 1396 CARD32 pad2; 1397 CARD32 pad3; 1398 CARD32 pad4; 1399 } 1400 1401 alias xGLXQueryHyperpipeConfigSGIXReq = GLXQueryHyperpipeConfigSGIX; 1402 enum sz_xGLXQueryHyperpipeConfigSGIXReq = 32; 1403 1404 /* 1405 ** glXQueryHyperpipeConfigSGIX reply 1406 */ 1407 struct xGLXQueryHyperpipeConfigSGIXReply 1408 { 1409 BYTE type; /* X_Reply */ 1410 CARD8 unused; /* not used */ 1411 CARD16 sequenceNumber; 1412 CARD32 length; 1413 CARD32 pad1; 1414 CARD32 n; 1415 CARD32 npipes; 1416 CARD32 pad4; 1417 CARD32 pad5; 1418 CARD32 pad6; 1419 } 1420 1421 enum sz_xGLXQueryHyperpipeConfigSGIXReply = 32; 1422 1423 /* 1424 ** glXHyperpipeConfigSGIX request 1425 */ 1426 struct xGLXHyperpipeConfigSGIXReq 1427 { 1428 CARD8 reqType; 1429 CARD8 glxCode; 1430 CARD16 length; 1431 CARD32 vendorCode; /* vendor-specific opcode */ 1432 CARD32 pad1; /* unused; corresponds to contextTag in header */ 1433 CARD32 screen; 1434 CARD32 npipes; 1435 CARD32 networkId; 1436 CARD32 pad2; 1437 CARD32 pad3; 1438 /* followed by attribute list */ 1439 } 1440 1441 enum sz_xGLXHyperpipeConfigSGIXReq = 32; 1442 1443 /* 1444 ** glXHyperpipeConfigSGIX reply 1445 */ 1446 struct xGLXHyperpipeConfigSGIXReply 1447 { 1448 BYTE type; /* X_Reply */ 1449 CARD8 unused; /* not used */ 1450 CARD16 sequenceNumber; 1451 CARD32 length; 1452 CARD32 pad1; 1453 CARD32 n; 1454 CARD32 npipes; 1455 CARD32 hpId; 1456 CARD32 pad5; 1457 CARD32 pad6; 1458 } 1459 1460 enum sz_xGLXHyperpipeConfigSGIXReply = 32; 1461 1462 /** 1463 * \name Protocol structures for GLX_ARB_create_context and 1464 * GLX_ARB_create_context_profile 1465 */ 1466 /*@{*/ 1467 /** 1468 * Protocol header for glXSetClientInfoARB 1469 * 1470 * This structure is follwed by \c numVersions * 2 \c CARD32 values listing 1471 * the OpenGL versions supported by the client. The pairs of values are an 1472 * OpenGL major version followed by a minor version. For example, 1473 * 1474 * CARD32 versions[4] = { 2, 1, 3, 0 }; 1475 * 1476 * says that the client supports OpenGL 2.1 and OpenGL 3.0. 1477 * 1478 * These are followed by \c numGLExtensionBytes bytes of \c STRING8 containing 1479 * the OpenGL extension string supported by the client and up to 3 bytes of 1480 * padding. 1481 * 1482 * The list of OpenGL extensions is followed by \c numGLXExtensionBytes bytes 1483 * of \c STRING8 containing the GLX extension string supported by the client 1484 * and up to 3 bytes of padding. 1485 * 1486 * This protocol replaces \c GLXClientInfo. 1487 * 1488 * \sa GLXClientInfo, GLXSetClientInfo2ARB 1489 */ 1490 struct GLXSetClientInfoARB 1491 { 1492 CARD8 reqType; 1493 CARD8 glxCode; 1494 CARD16 length; 1495 CARD32 major; 1496 CARD32 minor; 1497 CARD32 numVersions; 1498 CARD32 numGLExtensionBytes; 1499 CARD32 numGLXExtensionBytes; 1500 /* 1501 ** More data may follow; this is just the header. 1502 */ 1503 } 1504 1505 alias xGLXSetClientInfoARBReq = GLXSetClientInfoARB; 1506 enum sz_xGLXSetClientInfoARBReq = 24; 1507 1508 /** 1509 * Protocol head for glXCreateContextAttribsARB 1510 * 1511 * This protocol replaces \c GLXCreateContext, \c GLXCreateNewContext, and 1512 * \c GLXCreateContextWithConfigSGIX. 1513 */ 1514 struct GLXCreateContextAttribsARB 1515 { 1516 CARD8 reqType; 1517 CARD8 glxCode; 1518 CARD16 length; 1519 CARD32 context; 1520 CARD32 fbconfig; 1521 CARD32 screen; 1522 CARD32 shareList; 1523 BOOL isDirect; 1524 CARD8 reserved1; 1525 CARD16 reserved2; 1526 CARD32 numAttribs; 1527 /* followed by attribute list */ 1528 } 1529 1530 alias xGLXCreateContextAttribsARBReq = GLXCreateContextAttribsARB; 1531 enum sz_xGLXCreateContextAttribsARBReq = 28; 1532 1533 /** 1534 * Protocol header for glXSetClientInfo2ARB 1535 * 1536 * The glXSetClientInfo2ARB protocol differs from glXSetClientInfoARB in that 1537 * the list of OpenGL versions supported by the client is 3 \c CARD32 values 1538 * per version: major version, minor version, and supported profile mask. 1539 * 1540 * This protocol replaces \c GLXClientInfo and \c GLXSetClientInfoARB. 1541 * 1542 * \sa GLXClientInfo, GLXSetClientInfoARB 1543 */ 1544 struct GLXSetClientInfo2ARB 1545 { 1546 CARD8 reqType; 1547 CARD8 glxCode; 1548 CARD16 length; 1549 CARD32 major; 1550 CARD32 minor; 1551 CARD32 numVersions; 1552 CARD32 numGLExtensionBytes; 1553 CARD32 numGLXExtensionBytes; 1554 /* 1555 ** More data may follow; this is just the header. 1556 */ 1557 } 1558 1559 alias xGLXSetClientInfo2ARBReq = GLXSetClientInfo2ARB; 1560 enum sz_xGLXSetClientInfo2ARBReq = 24; 1561 /*@}*/ 1562 1563 /************************************************************************/ 1564 1565 /* 1566 ** Events 1567 */ 1568 1569 struct xGLXPbufferClobberEvent 1570 { 1571 BYTE type; 1572 BYTE pad; 1573 CARD16 sequenceNumber; 1574 CARD16 event_type; /*** was clobber_class */ 1575 CARD16 draw_type; 1576 CARD32 drawable; 1577 CARD32 buffer_mask; /*** was mask */ 1578 CARD16 aux_buffer; 1579 CARD16 x; 1580 CARD16 y; 1581 CARD16 width; 1582 CARD16 height; 1583 CARD16 count; 1584 CARD32 unused2; 1585 } 1586 1587 struct xGLXBufferSwapComplete 1588 { 1589 BYTE type; 1590 BYTE pad; 1591 CARD16 sequenceNumber; 1592 CARD16 event_type; 1593 CARD32 drawable; 1594 CARD32 ust_hi; 1595 CARD32 ust_lo; 1596 CARD32 msc_hi; 1597 CARD32 msc_lo; 1598 CARD32 sbc_hi; 1599 CARD32 sbc_lo; 1600 } 1601 1602 struct xGLXBufferSwapComplete2 1603 { 1604 BYTE type; 1605 BYTE pad; 1606 CARD16 sequenceNumber; 1607 CARD16 event_type; 1608 CARD16 pad2; 1609 CARD32 drawable; 1610 CARD32 ust_hi; 1611 CARD32 ust_lo; 1612 CARD32 msc_hi; 1613 CARD32 msc_lo; 1614 CARD32 sbc; 1615 } 1616 1617 /************************************************************************/ 1618 1619 /* 1620 ** Size of the standard X request header. 1621 */ 1622 enum __GLX_SINGLE_HDR_SIZE = sz_xGLXSingleReq; 1623 enum __GLX_VENDPRIV_HDR_SIZE = sz_xGLXVendorPrivateReq; 1624 1625 enum __GLX_RENDER_HDR_SIZE = 4; 1626 1627 struct __GLXrenderHeader 1628 { 1629 CARD16 length; 1630 CARD16 opcode; 1631 } 1632 1633 enum __GLX_RENDER_LARGE_HDR_SIZE = 8; 1634 1635 struct __GLXrenderLargeHeader 1636 { 1637 CARD32 length; 1638 CARD32 opcode; 1639 } 1640 1641 /* 1642 ** The glBitmap, glPolygonStipple, glTexImage[12]D, glTexSubImage[12]D 1643 ** and glDrawPixels calls all have a pixel header transmitted after the 1644 ** Render or RenderLarge header and before their own opcode specific 1645 ** headers. 1646 */ 1647 1648 enum __GLX_PIXEL_HDR_SIZE = 20; 1649 1650 struct __GLXpixelHeader 1651 { 1652 BOOL swapBytes; 1653 BOOL lsbFirst; 1654 CARD8 reserved0; 1655 CARD8 reserved1; 1656 CARD32 rowLength; 1657 CARD32 skipRows; 1658 CARD32 skipPixels; 1659 CARD32 alignment; 1660 } 1661 1662 /* 1663 ** glTexImage[34]D and glTexSubImage[34]D calls 1664 ** all have a pixel header transmitted after the Render or RenderLarge 1665 ** header and before their own opcode specific headers. 1666 */ 1667 1668 enum __GLX_PIXEL_3D_HDR_SIZE = 36; 1669 1670 /* 1671 ** Data that is specific to a glBitmap call. The data is sent in the 1672 ** following order: 1673 ** Render or RenderLarge header 1674 ** Pixel header 1675 ** Bitmap header 1676 */ 1677 1678 struct __GLXbitmapHeader 1679 { 1680 CARD16 length; 1681 CARD16 opcode; 1682 BOOL swapBytes; 1683 BOOL lsbFirst; 1684 CARD8 reserved0; 1685 CARD8 reserved1; 1686 CARD32 rowLength; 1687 CARD32 skipRows; 1688 CARD32 skipPixels; 1689 CARD32 alignment; 1690 CARD32 width; 1691 CARD32 height; 1692 FLOAT32 xorig; 1693 FLOAT32 yorig; 1694 FLOAT32 xmove; 1695 FLOAT32 ymove; 1696 } 1697 1698 struct __GLXbitmapLargeHeader 1699 { 1700 CARD32 length; 1701 CARD32 opcode; 1702 BOOL swapBytes; 1703 BOOL lsbFirst; 1704 CARD8 reserved0; 1705 CARD8 reserved1; 1706 CARD32 rowLength; 1707 CARD32 skipRows; 1708 CARD32 skipPixels; 1709 CARD32 alignment; 1710 CARD32 width; 1711 CARD32 height; 1712 FLOAT32 xorig; 1713 FLOAT32 yorig; 1714 FLOAT32 xmove; 1715 FLOAT32 ymove; 1716 } 1717 1718 struct __GLXdispatchBitmapHeader 1719 { 1720 BOOL swapBytes; 1721 BOOL lsbFirst; 1722 CARD8 reserved0; 1723 CARD8 reserved1; 1724 CARD32 rowLength; 1725 CARD32 skipRows; 1726 CARD32 skipPixels; 1727 CARD32 alignment; 1728 CARD32 width; 1729 CARD32 height; 1730 FLOAT32 xorig; 1731 FLOAT32 yorig; 1732 FLOAT32 xmove; 1733 FLOAT32 ymove; 1734 } 1735 1736 enum __GLX_BITMAP_HDR_SIZE = 24; 1737 1738 enum __GLX_BITMAP_CMD_HDR_SIZE = __GLX_RENDER_HDR_SIZE + __GLX_PIXEL_HDR_SIZE + __GLX_BITMAP_HDR_SIZE; 1739 1740 enum __GLX_BITMAP_CMD_DISPATCH_HDR_SIZE = __GLX_PIXEL_HDR_SIZE + __GLX_BITMAP_HDR_SIZE; 1741 1742 struct __GLXpolygonStippleHeader 1743 { 1744 CARD16 length; 1745 CARD16 opcode; 1746 BOOL swapBytes; 1747 BOOL lsbFirst; 1748 CARD8 reserved0; 1749 CARD8 reserved1; 1750 CARD32 rowLength; 1751 CARD32 skipRows; 1752 CARD32 skipPixels; 1753 CARD32 alignment; 1754 } 1755 1756 enum __GLX_POLYGONSTIPPLE_CMD_HDR_SIZE = __GLX_RENDER_HDR_SIZE + __GLX_PIXEL_HDR_SIZE; 1757 1758 /* 1759 ** Data that is specific to a glTexImage1D or glTexImage2D call. The 1760 ** data is sent in the following order: 1761 ** Render or RenderLarge header 1762 ** Pixel header 1763 ** TexImage header 1764 ** When a glTexImage1D call the height field is unexamined by the server. 1765 */ 1766 1767 enum __GLX_TEXIMAGE_HDR_SIZE = 32; 1768 1769 enum __GLX_TEXIMAGE_CMD_HDR_SIZE = __GLX_RENDER_HDR_SIZE + __GLX_PIXEL_HDR_SIZE + __GLX_TEXIMAGE_HDR_SIZE; 1770 1771 enum __GLX_TEXIMAGE_CMD_DISPATCH_HDR_SIZE = __GLX_PIXEL_HDR_SIZE + __GLX_TEXIMAGE_HDR_SIZE; 1772 1773 struct __GLXtexImageHeader 1774 { 1775 CARD16 length; 1776 CARD16 opcode; 1777 BOOL swapBytes; 1778 BOOL lsbFirst; 1779 CARD8 reserved0; 1780 CARD8 reserved1; 1781 CARD32 rowLength; 1782 CARD32 skipRows; 1783 CARD32 skipPixels; 1784 CARD32 alignment; 1785 CARD32 target; 1786 CARD32 level; 1787 CARD32 components; 1788 CARD32 width; 1789 CARD32 height; 1790 CARD32 border; 1791 CARD32 format; 1792 CARD32 type; 1793 } 1794 1795 struct __GLXtexImageLargeHeader 1796 { 1797 CARD32 length; 1798 CARD32 opcode; 1799 BOOL swapBytes; 1800 BOOL lsbFirst; 1801 CARD8 reserved0; 1802 CARD8 reserved1; 1803 CARD32 rowLength; 1804 CARD32 skipRows; 1805 CARD32 skipPixels; 1806 CARD32 alignment; 1807 CARD32 target; 1808 CARD32 level; 1809 CARD32 components; 1810 CARD32 width; 1811 CARD32 height; 1812 CARD32 border; 1813 CARD32 format; 1814 CARD32 type; 1815 } 1816 1817 struct __GLXdispatchTexImageHeader 1818 { 1819 BOOL swapBytes; 1820 BOOL lsbFirst; 1821 CARD8 reserved0; 1822 CARD8 reserved1; 1823 CARD32 rowLength; 1824 CARD32 skipRows; 1825 CARD32 skipPixels; 1826 CARD32 alignment; 1827 CARD32 target; 1828 CARD32 level; 1829 CARD32 components; 1830 CARD32 width; 1831 CARD32 height; 1832 CARD32 border; 1833 CARD32 format; 1834 CARD32 type; 1835 } 1836 1837 /* 1838 ** Data that is specific to a glTexImage3D or glTexImage4D call. The 1839 ** data is sent in the following order: 1840 ** Render or RenderLarge header 1841 ** Pixel 3D header 1842 ** TexImage 3D header 1843 ** When a glTexImage3D call the size4d and woffset fields are unexamined 1844 ** by the server. 1845 ** Could be used by all TexImage commands and perhaps should be in the 1846 ** future. 1847 */ 1848 1849 enum __GLX_TEXIMAGE_3D_HDR_SIZE = 44; 1850 1851 enum __GLX_TEXIMAGE_3D_CMD_HDR_SIZE = __GLX_RENDER_HDR_SIZE + __GLX_PIXEL_3D_HDR_SIZE + __GLX_TEXIMAGE_3D_HDR_SIZE; 1852 1853 enum __GLX_TEXIMAGE_3D_CMD_DISPATCH_HDR_SIZE = __GLX_PIXEL_3D_HDR_SIZE + __GLX_TEXIMAGE_3D_HDR_SIZE; 1854 1855 struct __GLXtexImage3DHeader 1856 { 1857 CARD16 length; 1858 CARD16 opcode; 1859 BOOL swapBytes; 1860 BOOL lsbFirst; 1861 CARD8 reserved0; 1862 CARD8 reserved1; 1863 CARD32 rowLength; 1864 CARD32 imageHeight; 1865 CARD32 imageDepth; 1866 CARD32 skipRows; 1867 CARD32 skipImages; 1868 CARD32 skipVolumes; 1869 CARD32 skipPixels; 1870 CARD32 alignment; 1871 CARD32 target; 1872 CARD32 level; 1873 CARD32 internalformat; 1874 CARD32 width; 1875 CARD32 height; 1876 CARD32 depth; 1877 CARD32 size4d; 1878 CARD32 border; 1879 CARD32 format; 1880 CARD32 type; 1881 CARD32 nullimage; 1882 } 1883 1884 struct __GLXtexImage3DLargeHeader 1885 { 1886 CARD32 length; 1887 CARD32 opcode; 1888 BOOL swapBytes; 1889 BOOL lsbFirst; 1890 CARD8 reserved0; 1891 CARD8 reserved1; 1892 CARD32 rowLength; 1893 CARD32 imageHeight; 1894 CARD32 imageDepth; 1895 CARD32 skipRows; 1896 CARD32 skipImages; 1897 CARD32 skipVolumes; 1898 CARD32 skipPixels; 1899 CARD32 alignment; 1900 CARD32 target; 1901 CARD32 level; 1902 CARD32 internalformat; 1903 CARD32 width; 1904 CARD32 height; 1905 CARD32 depth; 1906 CARD32 size4d; 1907 CARD32 border; 1908 CARD32 format; 1909 CARD32 type; 1910 CARD32 nullimage; 1911 } 1912 1913 struct __GLXdispatchTexImage3DHeader 1914 { 1915 BOOL swapBytes; 1916 BOOL lsbFirst; 1917 CARD8 reserved0; 1918 CARD8 reserved1; 1919 CARD32 rowLength; 1920 CARD32 imageHeight; 1921 CARD32 imageDepth; 1922 CARD32 skipRows; 1923 CARD32 skipImages; 1924 CARD32 skipVolumes; 1925 CARD32 skipPixels; 1926 CARD32 alignment; 1927 CARD32 target; 1928 CARD32 level; 1929 CARD32 internalformat; 1930 CARD32 width; 1931 CARD32 height; 1932 CARD32 depth; 1933 CARD32 size4d; 1934 CARD32 border; 1935 CARD32 format; 1936 CARD32 type; 1937 CARD32 nullimage; 1938 } 1939 1940 /* 1941 ** Data that is specific to a glTexSubImage1D or glTexSubImage2D call. The 1942 ** data is sent in the following order: 1943 ** Render or RenderLarge header 1944 ** Pixel header 1945 ** TexSubImage header 1946 ** When a glTexSubImage1D call is made, the yoffset and height fields 1947 ** are unexamined by the server and are considered to be padding. 1948 */ 1949 1950 enum __GLX_TEXSUBIMAGE_HDR_SIZE = 36; 1951 1952 enum __GLX_TEXSUBIMAGE_CMD_HDR_SIZE = __GLX_RENDER_HDR_SIZE + __GLX_PIXEL_HDR_SIZE + __GLX_TEXSUBIMAGE_HDR_SIZE; 1953 1954 enum __GLX_TEXSUBIMAGE_CMD_DISPATCH_HDR_SIZE = __GLX_PIXEL_HDR_SIZE + __GLX_TEXSUBIMAGE_HDR_SIZE; 1955 1956 struct __GLXtexSubImageHeader 1957 { 1958 CARD16 length; 1959 CARD16 opcode; 1960 BOOL swapBytes; 1961 BOOL lsbFirst; 1962 CARD8 reserved0; 1963 CARD8 reserved1; 1964 CARD32 rowLength; 1965 CARD32 skipRows; 1966 CARD32 skipPixels; 1967 CARD32 alignment; 1968 CARD32 target; 1969 CARD32 level; 1970 CARD32 xoffset; 1971 CARD32 yoffset; 1972 CARD32 width; 1973 CARD32 height; 1974 CARD32 format; 1975 CARD32 type; 1976 CARD32 nullImage; 1977 } 1978 1979 struct __GLXtexSubImageLargeHeader 1980 { 1981 CARD32 length; 1982 CARD32 opcode; 1983 BOOL swapBytes; 1984 BOOL lsbFirst; 1985 CARD8 reserved0; 1986 CARD8 reserved1; 1987 CARD32 rowLength; 1988 CARD32 skipRows; 1989 CARD32 skipPixels; 1990 CARD32 alignment; 1991 CARD32 target; 1992 CARD32 level; 1993 CARD32 xoffset; 1994 CARD32 yoffset; 1995 CARD32 width; 1996 CARD32 height; 1997 CARD32 format; 1998 CARD32 type; 1999 CARD32 nullImage; 2000 } 2001 2002 struct __GLXdispatchTexSubImageHeader 2003 { 2004 BOOL swapBytes; 2005 BOOL lsbFirst; 2006 CARD8 reserved0; 2007 CARD8 reserved1; 2008 CARD32 rowLength; 2009 CARD32 skipRows; 2010 CARD32 skipPixels; 2011 CARD32 alignment; 2012 CARD32 target; 2013 CARD32 level; 2014 CARD32 xoffset; 2015 CARD32 yoffset; 2016 CARD32 width; 2017 CARD32 height; 2018 CARD32 format; 2019 CARD32 type; 2020 CARD32 nullImage; 2021 } 2022 2023 /* 2024 ** Data that is specific to a glTexSubImage3D and 4D calls. The 2025 ** data is sent in the following order: 2026 ** Render or RenderLarge header 2027 ** Pixel 3D header 2028 ** TexSubImage 3D header 2029 ** When a glTexSubImage3D call is made, the woffset and size4d fields 2030 ** are unexamined by the server and are considered to be padding. 2031 */ 2032 2033 enum __GLX_TEXSUBIMAGE_3D_HDR_SIZE = 52; 2034 2035 enum __GLX_TEXSUBIMAGE_3D_CMD_HDR_SIZE = __GLX_RENDER_HDR_SIZE + __GLX_PIXEL_3D_HDR_SIZE + __GLX_TEXSUBIMAGE_3D_HDR_SIZE; 2036 2037 enum __GLX_TEXSUBIMAGE_3D_CMD_DISPATCH_HDR_SIZE = __GLX_PIXEL_3D_HDR_SIZE + __GLX_TEXSUBIMAGE_3D_HDR_SIZE; 2038 2039 struct __GLXtexSubImage3DHeader 2040 { 2041 CARD16 length; 2042 CARD16 opcode; 2043 BOOL swapBytes; 2044 BOOL lsbFirst; 2045 CARD8 reserved0; 2046 CARD8 reserved1; 2047 CARD32 rowLength; 2048 CARD32 imageHeight; 2049 CARD32 imageDepth; 2050 CARD32 skipRows; 2051 CARD32 skipImages; 2052 CARD32 skipVolumes; 2053 CARD32 skipPixels; 2054 CARD32 alignment; 2055 CARD32 target; 2056 CARD32 level; 2057 CARD32 xoffset; 2058 CARD32 yoffset; 2059 CARD32 zoffset; 2060 CARD32 woffset; 2061 CARD32 width; 2062 CARD32 height; 2063 CARD32 depth; 2064 CARD32 size4d; 2065 CARD32 format; 2066 CARD32 type; 2067 CARD32 nullImage; 2068 } 2069 2070 struct __GLXtexSubImage3DLargeHeader 2071 { 2072 CARD32 length; 2073 CARD32 opcode; 2074 BOOL swapBytes; 2075 BOOL lsbFirst; 2076 CARD8 reserved0; 2077 CARD8 reserved1; 2078 CARD32 rowLength; 2079 CARD32 imageHeight; 2080 CARD32 imageDepth; 2081 CARD32 skipRows; 2082 CARD32 skipImages; 2083 CARD32 skipVolumes; 2084 CARD32 skipPixels; 2085 CARD32 alignment; 2086 CARD32 target; 2087 CARD32 level; 2088 CARD32 xoffset; 2089 CARD32 yoffset; 2090 CARD32 zoffset; 2091 CARD32 woffset; 2092 CARD32 width; 2093 CARD32 height; 2094 CARD32 depth; 2095 CARD32 size4d; 2096 CARD32 format; 2097 CARD32 type; 2098 CARD32 nullImage; 2099 } 2100 2101 struct __GLXdispatchTexSubImage3DHeader 2102 { 2103 BOOL swapBytes; 2104 BOOL lsbFirst; 2105 CARD8 reserved0; 2106 CARD8 reserved1; 2107 CARD32 rowLength; 2108 CARD32 imageHeight; 2109 CARD32 imageDepth; 2110 CARD32 skipRows; 2111 CARD32 skipImages; 2112 CARD32 skipVolumes; 2113 CARD32 skipPixels; 2114 CARD32 alignment; 2115 CARD32 target; 2116 CARD32 level; 2117 CARD32 xoffset; 2118 CARD32 yoffset; 2119 CARD32 zoffset; 2120 CARD32 woffset; 2121 CARD32 width; 2122 CARD32 height; 2123 CARD32 depth; 2124 CARD32 size4d; 2125 CARD32 format; 2126 CARD32 type; 2127 CARD32 nullImage; 2128 } 2129 2130 /** 2131 * Data that is specific to a \c glCompressedTexImage1D or 2132 * \c glCompressedTexImage2D call. The data is sent in the following 2133 * order: 2134 * - Render or RenderLarge header 2135 * - CompressedTexImage header 2136 * 2137 * When a \c glCompressedTexImage1D call is made, the \c height field is 2138 * not examined by the server and is considered padding. 2139 */ 2140 2141 enum __GLX_COMPRESSED_TEXIMAGE_HDR_SIZE = 28; 2142 2143 enum __GLX_COMPRESSED_TEXIMAGE_CMD_HDR_SIZE = __GLX_RENDER_HDR_SIZE + __GLX_COMPRESSED_TEXIMAGE_HDR_SIZE; 2144 2145 enum __GLX_COMPRESSED_TEXIMAGE_DISPATCH_HDR_SIZE = __GLX_COMPRESSED_TEXIMAGE_HDR_SIZE; 2146 2147 struct __GLXcompressedTexImageHeader 2148 { 2149 CARD16 length; 2150 CARD16 opcode; 2151 CARD32 target; 2152 CARD32 level; 2153 CARD32 internalFormat; 2154 CARD32 width; 2155 CARD32 height; 2156 CARD32 border; 2157 CARD32 imageSize; 2158 } 2159 2160 struct __GLXcompressedTexImageLargeHeader 2161 { 2162 CARD32 length; 2163 CARD32 opcode; 2164 CARD32 target; 2165 CARD32 level; 2166 CARD32 internalFormat; 2167 CARD32 width; 2168 CARD32 height; 2169 CARD32 border; 2170 CARD32 imageSize; 2171 } 2172 2173 struct __GLXdispatchCompressedTexImageHeader 2174 { 2175 CARD32 target; 2176 CARD32 level; 2177 CARD32 internalFormat; 2178 CARD32 width; 2179 CARD32 height; 2180 CARD32 border; 2181 CARD32 imageSize; 2182 } 2183 2184 /** 2185 * Data that is specifi to a \c glCompressedTexSubImage1D or 2186 * \c glCompressedTexSubImage2D call. The data is sent in the following 2187 * order: 2188 * - Render or RenderLarge header 2189 * - CompressedTexSubImage header 2190 * 2191 * When a \c glCompressedTexSubImage1D call is made, the \c yoffset and 2192 * \c height fields are not examined by the server and are considered padding. 2193 */ 2194 2195 enum __GLX_COMPRESSED_TEXSUBIMAGE_HDR_SIZE = 32; 2196 2197 enum __GLX_COMPRESSED_TEXSUBIMAGE_CMD_HDR_SIZE = __GLX_RENDER_HDR_SIZE + __GLX_COMPRESSED_TEXSUBIMAGE_HDR_SIZE; 2198 2199 enum __GLX_COMPRESSED_TEXSUBIMAGE_DISPATCH_HDR_SIZE = __GLX_COMPRESSED_TEXSUBIMAGE_HDR_SIZE; 2200 2201 struct __GLXcompressedTexSubImageHeader 2202 { 2203 CARD16 length; 2204 CARD16 opcode; 2205 CARD32 target; 2206 CARD32 level; 2207 CARD32 xoffset; 2208 CARD32 yoffset; 2209 CARD32 width; 2210 CARD32 height; 2211 CARD32 format; 2212 CARD32 imageSize; 2213 } 2214 2215 struct __GLXcompressedTexSubImageLargeHeader 2216 { 2217 CARD32 length; 2218 CARD32 opcode; 2219 CARD32 target; 2220 CARD32 level; 2221 CARD32 xoffset; 2222 CARD32 yoffset; 2223 CARD32 width; 2224 CARD32 height; 2225 CARD32 format; 2226 CARD32 imageSize; 2227 } 2228 2229 struct __GLXdispatchCompressedTexSubImageHeader 2230 { 2231 CARD32 target; 2232 CARD32 level; 2233 CARD32 xoffset; 2234 CARD32 yoffset; 2235 CARD32 width; 2236 CARD32 height; 2237 CARD32 format; 2238 CARD32 imageSize; 2239 } 2240 2241 /** 2242 * Data that is specific to a \c glCompressedTexImage3D call. The data is 2243 * sent in the following order: 2244 * - Render or RenderLarge header 2245 * - CompressedTexImage3D header 2246 */ 2247 2248 enum __GLX_COMPRESSED_TEXIMAGE_3D_HDR_SIZE = 32; 2249 2250 enum __GLX_COMPRESSED_TEXIMAGE_3D_CMD_HDR_SIZE = __GLX_RENDER_HDR_SIZE + __GLX_COMPRESSED_TEXIMAGE_3D_HDR_SIZE; 2251 2252 enum __GLX_COMPRESSED_TEXIMAGE_3D_DISPATCH_HDR_SIZE = __GLX_COMPRESSED_TEXIMAGE_3D_HDR_SIZE; 2253 2254 struct __GLXcompressedTexImage3DHeader 2255 { 2256 CARD16 length; 2257 CARD16 opcode; 2258 CARD32 target; 2259 CARD32 level; 2260 CARD32 internalFormat; 2261 CARD32 width; 2262 CARD32 height; 2263 CARD32 depth; 2264 CARD32 border; 2265 CARD32 imageSize; 2266 } 2267 2268 struct __GLXcompressedTexImage3DLargeHeader 2269 { 2270 CARD32 length; 2271 CARD32 opcode; 2272 CARD32 target; 2273 CARD32 level; 2274 CARD32 internalFormat; 2275 CARD32 width; 2276 CARD32 height; 2277 CARD32 depth; 2278 CARD32 border; 2279 CARD32 imageSize; 2280 } 2281 2282 struct __GLXdispatchCompressedTexImage3DHeader 2283 { 2284 CARD32 target; 2285 CARD32 level; 2286 CARD32 internalFormat; 2287 CARD32 width; 2288 CARD32 height; 2289 CARD32 depth; 2290 CARD32 border; 2291 CARD32 imageSize; 2292 } 2293 2294 /** 2295 * Data that is specifi to a \c glCompressedTexSubImage3D call. The data is 2296 * sent in the following order: 2297 * - Render or RenderLarge header 2298 * - CompressedTexSubImage3D header 2299 */ 2300 2301 enum __GLX_COMPRESSED_TEXSUBIMAGE_3D_HDR_SIZE = 32; 2302 2303 enum __GLX_COMPRESSED_TEXSUBIMAGE_3D_CMD_HDR_SIZE = __GLX_RENDER_HDR_SIZE + __GLX_COMPRESSED_TEXSUBIMAGE_3D_HDR_SIZE; 2304 2305 enum __GLX_COMPRESSED_TEXSUBIMAGE_3D_DISPATCH_HDR_SIZE = __GLX_COMPRESSED_TEXSUBIMAGE_3D_HDR_SIZE; 2306 2307 struct __GLXcompressedTexSubImage3DHeader 2308 { 2309 CARD16 length; 2310 CARD16 opcode; 2311 CARD32 target; 2312 CARD32 level; 2313 CARD32 xoffset; 2314 CARD32 yoffset; 2315 CARD32 zoffset; 2316 CARD32 width; 2317 CARD32 height; 2318 CARD32 depth; 2319 CARD32 format; 2320 CARD32 imageSize; 2321 } 2322 2323 struct __GLXcompressedTexSubImage3DLargeHeader 2324 { 2325 CARD32 length; 2326 CARD32 opcode; 2327 CARD32 target; 2328 CARD32 level; 2329 CARD32 xoffset; 2330 CARD32 yoffset; 2331 CARD32 zoffset; 2332 CARD32 width; 2333 CARD32 height; 2334 CARD32 depth; 2335 CARD32 format; 2336 CARD32 imageSize; 2337 } 2338 2339 struct __GLXdispatchCompressedTexSubImage3DHeader 2340 { 2341 CARD32 target; 2342 CARD32 level; 2343 CARD32 xoffset; 2344 CARD32 yoffset; 2345 CARD32 zoffset; 2346 CARD32 width; 2347 CARD32 height; 2348 CARD32 depth; 2349 CARD32 format; 2350 CARD32 imageSize; 2351 } 2352 2353 /* 2354 ** Data that is specific to a glDrawPixels call. The data is sent in the 2355 ** following order: 2356 ** Render or RenderLarge header 2357 ** Pixel header 2358 ** DrawPixels header 2359 */ 2360 2361 enum __GLX_DRAWPIXELS_HDR_SIZE = 16; 2362 2363 enum __GLX_DRAWPIXELS_CMD_HDR_SIZE = __GLX_RENDER_HDR_SIZE + __GLX_PIXEL_HDR_SIZE + __GLX_DRAWPIXELS_HDR_SIZE; 2364 2365 enum __GLX_DRAWPIXELS_CMD_DISPATCH_HDR_SIZE = __GLX_PIXEL_HDR_SIZE + __GLX_DRAWPIXELS_HDR_SIZE; 2366 2367 struct __GLXdrawPixelsHeader 2368 { 2369 CARD16 length; 2370 CARD16 opcode; 2371 BOOL swapBytes; 2372 BOOL lsbFirst; 2373 CARD8 reserved0; 2374 CARD8 reserved1; 2375 CARD32 rowLength; 2376 CARD32 skipRows; 2377 CARD32 skipPixels; 2378 CARD32 alignment; 2379 CARD32 width; 2380 CARD32 height; 2381 CARD32 format; 2382 CARD32 type; 2383 } 2384 2385 struct __GLXdrawPixelsLargeHeader 2386 { 2387 CARD32 length; 2388 CARD32 opcode; 2389 BOOL swapBytes; 2390 BOOL lsbFirst; 2391 CARD8 reserved0; 2392 CARD8 reserved1; 2393 CARD32 rowLength; 2394 CARD32 skipRows; 2395 CARD32 skipPixels; 2396 CARD32 alignment; 2397 CARD32 width; 2398 CARD32 height; 2399 CARD32 format; 2400 CARD32 type; 2401 } 2402 2403 struct __GLXdispatchDrawPixelsHeader 2404 { 2405 BOOL swapBytes; 2406 BOOL lsbFirst; 2407 CARD8 reserved0; 2408 CARD8 reserved1; 2409 CARD32 rowLength; 2410 CARD32 skipRows; 2411 CARD32 skipPixels; 2412 CARD32 alignment; 2413 CARD32 width; 2414 CARD32 height; 2415 CARD32 format; 2416 CARD32 type; 2417 } 2418 2419 /* 2420 ** Data that is specific to a glConvolutionFilter1D or glConvolutionFilter2D 2421 ** call. The data is sent in the following order: 2422 ** Render or RenderLarge header 2423 ** Pixel header 2424 ** ConvolutionFilter header 2425 ** When a glConvolutionFilter1D call the height field is unexamined by the server. 2426 */ 2427 2428 enum __GLX_CONV_FILT_HDR_SIZE = 24; 2429 2430 enum __GLX_CONV_FILT_CMD_HDR_SIZE = __GLX_RENDER_HDR_SIZE + __GLX_PIXEL_HDR_SIZE + __GLX_CONV_FILT_HDR_SIZE; 2431 2432 enum __GLX_CONV_FILT_CMD_DISPATCH_HDR_SIZE = __GLX_PIXEL_HDR_SIZE + __GLX_CONV_FILT_HDR_SIZE; 2433 2434 struct __GLXConvolutionFilterHeader 2435 { 2436 CARD16 length; 2437 CARD16 opcode; 2438 BOOL swapBytes; 2439 BOOL lsbFirst; 2440 CARD8 reserved0; 2441 CARD8 reserved1; 2442 CARD32 rowLength; 2443 CARD32 skipRows; 2444 CARD32 skipPixels; 2445 CARD32 alignment; 2446 CARD32 target; 2447 CARD32 internalformat; 2448 CARD32 width; 2449 CARD32 height; 2450 CARD32 format; 2451 CARD32 type; 2452 } 2453 2454 struct __GLXConvolutionFilterLargeHeader 2455 { 2456 CARD32 length; 2457 CARD32 opcode; 2458 BOOL swapBytes; 2459 BOOL lsbFirst; 2460 CARD8 reserved0; 2461 CARD8 reserved1; 2462 CARD32 rowLength; 2463 CARD32 skipRows; 2464 CARD32 skipPixels; 2465 CARD32 alignment; 2466 CARD32 target; 2467 CARD32 internalformat; 2468 CARD32 width; 2469 CARD32 height; 2470 CARD32 format; 2471 CARD32 type; 2472 } 2473 2474 struct __GLXdispatchConvolutionFilterHeader 2475 { 2476 BOOL swapBytes; 2477 BOOL lsbFirst; 2478 CARD8 reserved0; 2479 CARD8 reserved1; 2480 CARD32 rowLength; 2481 CARD32 skipRows; 2482 CARD32 skipPixels; 2483 CARD32 alignment; 2484 CARD32 target; 2485 CARD32 internalformat; 2486 CARD32 width; 2487 CARD32 height; 2488 CARD32 format; 2489 CARD32 type; 2490 } 2491 2492 /* 2493 ** Data that is specific to a glDrawArraysEXT call. The data is sent in the 2494 ** following order: 2495 ** Render or RenderLarge header 2496 ** Draw Arrays header 2497 ** a variable number of Component headers 2498 ** vertex data for each component type 2499 */ 2500 2501 enum __GLX_DRAWARRAYS_HDR_SIZE = 12; 2502 2503 enum __GLX_DRAWARRAYS_CMD_HDR_SIZE = __GLX_RENDER_HDR_SIZE + __GLX_DRAWARRAYS_HDR_SIZE; 2504 2505 struct __GLXdrawArraysHeader 2506 { 2507 CARD16 length; 2508 CARD16 opcode; 2509 CARD32 numVertexes; 2510 CARD32 numComponents; 2511 CARD32 primType; 2512 } 2513 2514 struct __GLXdrawArraysLargeHeader 2515 { 2516 CARD32 length; 2517 CARD32 opcode; 2518 CARD32 numVertexes; 2519 CARD32 numComponents; 2520 CARD32 primType; 2521 } 2522 2523 struct __GLXdispatchDrawArraysHeader 2524 { 2525 CARD32 numVertexes; 2526 CARD32 numComponents; 2527 CARD32 primType; 2528 } 2529 2530 struct __GLXdispatchDrawArraysComponentHeader 2531 { 2532 CARD32 datatype; 2533 INT32 numVals; 2534 CARD32 component; 2535 } 2536 2537 enum __GLX_COMPONENT_HDR_SIZE = 12; 2538 2539 /* 2540 ** Data that is specific to a glColorTable call 2541 ** The data is sent in the following order: 2542 ** Render or RenderLarge header 2543 ** Pixel header 2544 ** ColorTable header 2545 */ 2546 2547 enum __GLX_COLOR_TABLE_HDR_SIZE = 20; 2548 2549 enum __GLX_COLOR_TABLE_CMD_HDR_SIZE = __GLX_RENDER_HDR_SIZE + __GLX_PIXEL_HDR_SIZE + __GLX_COLOR_TABLE_HDR_SIZE; 2550 2551 struct __GLXColorTableHeader 2552 { 2553 CARD16 length; 2554 CARD16 opcode; 2555 BOOL swapBytes; 2556 BOOL lsbFirst; 2557 CARD8 reserved0; 2558 CARD8 reserved1; 2559 CARD32 rowLength; 2560 CARD32 skipRows; 2561 CARD32 skipPixels; 2562 CARD32 alignment; 2563 CARD32 target; 2564 CARD32 internalformat; 2565 CARD32 width; 2566 CARD32 format; 2567 CARD32 type; 2568 } 2569 2570 struct __GLXColorTableLargeHeader 2571 { 2572 CARD32 length; 2573 CARD32 opcode; 2574 BOOL swapBytes; 2575 BOOL lsbFirst; 2576 CARD8 reserved0; 2577 CARD8 reserved1; 2578 CARD32 rowLength; 2579 CARD32 skipRows; 2580 CARD32 skipPixels; 2581 CARD32 alignment; 2582 CARD32 target; 2583 CARD32 internalformat; 2584 CARD32 width; 2585 CARD32 format; 2586 CARD32 type; 2587 } 2588 2589 struct __GLXdispatchColorTableHeader 2590 { 2591 BOOL swapBytes; 2592 BOOL lsbFirst; 2593 CARD8 reserved0; 2594 CARD8 reserved1; 2595 CARD32 rowLength; 2596 CARD32 skipRows; 2597 CARD32 skipPixels; 2598 CARD32 alignment; 2599 CARD32 target; 2600 CARD32 internalformat; 2601 CARD32 width; 2602 CARD32 format; 2603 CARD32 type; 2604 } 2605 2606 /* 2607 ** Data that is specific to a glColorSubTable call 2608 ** The data is sent in the following order: 2609 ** Render or RenderLarge header 2610 ** Pixel header 2611 ** ColorTable header 2612 */ 2613 2614 enum __GLX_COLOR_SUBTABLE_HDR_SIZE = 20; 2615 2616 enum __GLX_COLOR_SUBTABLE_CMD_HDR_SIZE = __GLX_RENDER_HDR_SIZE + __GLX_PIXEL_HDR_SIZE + __GLX_COLOR_SUBTABLE_HDR_SIZE; 2617 2618 struct __GLXColorSubTableHeader 2619 { 2620 CARD16 length; 2621 CARD16 opcode; 2622 BOOL swapBytes; 2623 BOOL lsbFirst; 2624 CARD8 reserved0; 2625 CARD8 reserved1; 2626 CARD32 rowLength; 2627 CARD32 skipRows; 2628 CARD32 skipPixels; 2629 CARD32 alignment; 2630 CARD32 target; 2631 CARD32 start; 2632 CARD32 count; 2633 CARD32 format; 2634 CARD32 type; 2635 } 2636 2637 struct __GLXColorSubTableLargeHeader 2638 { 2639 CARD32 length; 2640 CARD32 opcode; 2641 BOOL swapBytes; 2642 BOOL lsbFirst; 2643 CARD8 reserved0; 2644 CARD8 reserved1; 2645 CARD32 rowLength; 2646 CARD32 skipRows; 2647 CARD32 skipPixels; 2648 CARD32 alignment; 2649 CARD32 target; 2650 CARD32 start; 2651 CARD32 count; 2652 CARD32 format; 2653 CARD32 type; 2654 } 2655 2656 struct __GLXdispatchColorSubTableHeader 2657 { 2658 BOOL swapBytes; 2659 BOOL lsbFirst; 2660 CARD8 reserved0; 2661 CARD8 reserved1; 2662 CARD32 rowLength; 2663 CARD32 skipRows; 2664 CARD32 skipPixels; 2665 CARD32 alignment; 2666 CARD32 target; 2667 CARD32 start; 2668 CARD32 count; 2669 CARD32 format; 2670 CARD32 type; 2671 } 2672 2673 enum GLX_WINDOW_TYPE = 1; 2674 enum GLX_PIXMAP_TYPE = 2; 2675 enum GLX_VIDEO_SOURCE_TYPE = 3; 2676 enum GLX_PBUFFER_TYPE = 4; 2677 /* 5 is for DM_PBUFFER */ 2678 enum GLX_GLXWINDOW_TYPE = 6; 2679 2680 /*****************************************************************************/ 2681 2682 /* 2683 ** Restore these definitions back to the typedefs in glx.h 2684 */ 2685 2686 /* Opcodes for GLX commands */ 2687 2688 enum X_GLXRender = 1; 2689 enum X_GLXRenderLarge = 2; 2690 enum X_GLXCreateContext = 3; 2691 enum X_GLXDestroyContext = 4; 2692 enum X_GLXMakeCurrent = 5; 2693 enum X_GLXIsDirect = 6; 2694 enum X_GLXQueryVersion = 7; 2695 enum X_GLXWaitGL = 8; 2696 enum X_GLXWaitX = 9; 2697 enum X_GLXCopyContext = 10; 2698 enum X_GLXSwapBuffers = 11; 2699 enum X_GLXUseXFont = 12; 2700 enum X_GLXCreateGLXPixmap = 13; 2701 enum X_GLXGetVisualConfigs = 14; 2702 enum X_GLXDestroyGLXPixmap = 15; 2703 enum X_GLXVendorPrivate = 16; 2704 enum X_GLXVendorPrivateWithReply = 17; 2705 enum X_GLXQueryExtensionsString = 18; 2706 enum X_GLXQueryServerString = 19; 2707 enum X_GLXClientInfo = 20; 2708 enum X_GLXGetFBConfigs = 21; 2709 enum X_GLXCreatePixmap = 22; 2710 enum X_GLXDestroyPixmap = 23; 2711 enum X_GLXCreateNewContext = 24; 2712 enum X_GLXQueryContext = 25; 2713 enum X_GLXMakeContextCurrent = 26; 2714 enum X_GLXCreatePbuffer = 27; 2715 enum X_GLXDestroyPbuffer = 28; 2716 enum X_GLXGetDrawableAttributes = 29; 2717 enum X_GLXChangeDrawableAttributes = 30; 2718 enum X_GLXCreateWindow = 31; 2719 enum X_GLXDestroyWindow = 32; 2720 enum X_GLXSetClientInfoARB = 33; 2721 enum X_GLXCreateContextAttribsARB = 34; 2722 enum X_GLXSetClientInfo2ARB = 35; 2723 2724 /* typo compatibility with older headers */ 2725 enum X_GLXCreateContextAtrribsARB = 34; 2726 enum X_GLXSetConfigInfo2ARB = 35; 2727 2728 /* Opcodes for single commands (part of GLX command space) */ 2729 2730 enum X_GLsop_NewList = 101; 2731 enum X_GLsop_EndList = 102; 2732 enum X_GLsop_DeleteLists = 103; 2733 enum X_GLsop_GenLists = 104; 2734 enum X_GLsop_FeedbackBuffer = 105; 2735 enum X_GLsop_SelectBuffer = 106; 2736 enum X_GLsop_RenderMode = 107; 2737 enum X_GLsop_Finish = 108; 2738 enum X_GLsop_Flush = 142; 2739 enum X_GLsop_PixelStoref = 109; 2740 enum X_GLsop_PixelStorei = 110; 2741 enum X_GLsop_ReadPixels = 111; 2742 enum X_GLsop_GetBooleanv = 112; 2743 enum X_GLsop_GetClipPlane = 113; 2744 enum X_GLsop_GetDoublev = 114; 2745 enum X_GLsop_GetError = 115; 2746 enum X_GLsop_GetFloatv = 116; 2747 enum X_GLsop_GetIntegerv = 117; 2748 enum X_GLsop_GetLightfv = 118; 2749 enum X_GLsop_GetLightiv = 119; 2750 enum X_GLsop_GetMapdv = 120; 2751 enum X_GLsop_GetMapfv = 121; 2752 enum X_GLsop_GetMapiv = 122; 2753 enum X_GLsop_GetMaterialfv = 123; 2754 enum X_GLsop_GetMaterialiv = 124; 2755 enum X_GLsop_GetPixelMapfv = 125; 2756 enum X_GLsop_GetPixelMapuiv = 126; 2757 enum X_GLsop_GetPixelMapusv = 127; 2758 enum X_GLsop_GetPolygonStipple = 128; 2759 enum X_GLsop_GetString = 129; 2760 enum X_GLsop_GetTexEnvfv = 130; 2761 enum X_GLsop_GetTexEnviv = 131; 2762 enum X_GLsop_GetTexGendv = 132; 2763 enum X_GLsop_GetTexGenfv = 133; 2764 enum X_GLsop_GetTexGeniv = 134; 2765 enum X_GLsop_GetTexImage = 135; 2766 enum X_GLsop_GetTexParameterfv = 136; 2767 enum X_GLsop_GetTexParameteriv = 137; 2768 enum X_GLsop_GetTexLevelParameterfv = 138; 2769 enum X_GLsop_GetTexLevelParameteriv = 139; 2770 enum X_GLsop_IsEnabled = 140; 2771 enum X_GLsop_IsList = 141; 2772 enum X_GLsop_AreTexturesResident = 143; 2773 enum X_GLsop_DeleteTextures = 144; 2774 enum X_GLsop_GenTextures = 145; 2775 enum X_GLsop_IsTexture = 146; 2776 enum X_GLsop_GetColorTable = 147; 2777 enum X_GLsop_GetColorTableParameterfv = 148; 2778 enum X_GLsop_GetColorTableParameteriv = 149; 2779 enum X_GLsop_GetConvolutionFilter = 150; 2780 enum X_GLsop_GetConvolutionParameterfv = 151; 2781 enum X_GLsop_GetConvolutionParameteriv = 152; 2782 enum X_GLsop_GetSeparableFilter = 153; 2783 enum X_GLsop_GetHistogram = 154; 2784 enum X_GLsop_GetHistogramParameterfv = 155; 2785 enum X_GLsop_GetHistogramParameteriv = 156; 2786 enum X_GLsop_GetMinmax = 157; 2787 enum X_GLsop_GetMinmaxParameterfv = 158; 2788 enum X_GLsop_GetMinmaxParameteriv = 159; 2789 enum X_GLsop_GetCompressedTexImage = 160; 2790 2791 /* Opcodes for rendering commands */ 2792 2793 enum X_GLrop_CallList = 1; 2794 enum X_GLrop_CallLists = 2; 2795 enum X_GLrop_ListBase = 3; 2796 enum X_GLrop_Begin = 4; 2797 enum X_GLrop_Bitmap = 5; 2798 enum X_GLrop_Color3bv = 6; 2799 enum X_GLrop_Color3dv = 7; 2800 enum X_GLrop_Color3fv = 8; 2801 enum X_GLrop_Color3iv = 9; 2802 enum X_GLrop_Color3sv = 10; 2803 enum X_GLrop_Color3ubv = 11; 2804 enum X_GLrop_Color3uiv = 12; 2805 enum X_GLrop_Color3usv = 13; 2806 enum X_GLrop_Color4bv = 14; 2807 enum X_GLrop_Color4dv = 15; 2808 enum X_GLrop_Color4fv = 16; 2809 enum X_GLrop_Color4iv = 17; 2810 enum X_GLrop_Color4sv = 18; 2811 enum X_GLrop_Color4ubv = 19; 2812 enum X_GLrop_Color4uiv = 20; 2813 enum X_GLrop_Color4usv = 21; 2814 enum X_GLrop_EdgeFlagv = 22; 2815 enum X_GLrop_End = 23; 2816 enum X_GLrop_Indexdv = 24; 2817 enum X_GLrop_Indexfv = 25; 2818 enum X_GLrop_Indexiv = 26; 2819 enum X_GLrop_Indexsv = 27; 2820 enum X_GLrop_Normal3bv = 28; 2821 enum X_GLrop_Normal3dv = 29; 2822 enum X_GLrop_Normal3fv = 30; 2823 enum X_GLrop_Normal3iv = 31; 2824 enum X_GLrop_Normal3sv = 32; 2825 enum X_GLrop_RasterPos2dv = 33; 2826 enum X_GLrop_RasterPos2fv = 34; 2827 enum X_GLrop_RasterPos2iv = 35; 2828 enum X_GLrop_RasterPos2sv = 36; 2829 enum X_GLrop_RasterPos3dv = 37; 2830 enum X_GLrop_RasterPos3fv = 38; 2831 enum X_GLrop_RasterPos3iv = 39; 2832 enum X_GLrop_RasterPos3sv = 40; 2833 enum X_GLrop_RasterPos4dv = 41; 2834 enum X_GLrop_RasterPos4fv = 42; 2835 enum X_GLrop_RasterPos4iv = 43; 2836 enum X_GLrop_RasterPos4sv = 44; 2837 enum X_GLrop_Rectdv = 45; 2838 enum X_GLrop_Rectfv = 46; 2839 enum X_GLrop_Rectiv = 47; 2840 enum X_GLrop_Rectsv = 48; 2841 enum X_GLrop_TexCoord1dv = 49; 2842 enum X_GLrop_TexCoord1fv = 50; 2843 enum X_GLrop_TexCoord1iv = 51; 2844 enum X_GLrop_TexCoord1sv = 52; 2845 enum X_GLrop_TexCoord2dv = 53; 2846 enum X_GLrop_TexCoord2fv = 54; 2847 enum X_GLrop_TexCoord2iv = 55; 2848 enum X_GLrop_TexCoord2sv = 56; 2849 enum X_GLrop_TexCoord3dv = 57; 2850 enum X_GLrop_TexCoord3fv = 58; 2851 enum X_GLrop_TexCoord3iv = 59; 2852 enum X_GLrop_TexCoord3sv = 60; 2853 enum X_GLrop_TexCoord4dv = 61; 2854 enum X_GLrop_TexCoord4fv = 62; 2855 enum X_GLrop_TexCoord4iv = 63; 2856 enum X_GLrop_TexCoord4sv = 64; 2857 enum X_GLrop_Vertex2dv = 65; 2858 enum X_GLrop_Vertex2fv = 66; 2859 enum X_GLrop_Vertex2iv = 67; 2860 enum X_GLrop_Vertex2sv = 68; 2861 enum X_GLrop_Vertex3dv = 69; 2862 enum X_GLrop_Vertex3fv = 70; 2863 enum X_GLrop_Vertex3iv = 71; 2864 enum X_GLrop_Vertex3sv = 72; 2865 enum X_GLrop_Vertex4dv = 73; 2866 enum X_GLrop_Vertex4fv = 74; 2867 enum X_GLrop_Vertex4iv = 75; 2868 enum X_GLrop_Vertex4sv = 76; 2869 enum X_GLrop_ClipPlane = 77; 2870 enum X_GLrop_ColorMaterial = 78; 2871 enum X_GLrop_CullFace = 79; 2872 enum X_GLrop_Fogf = 80; 2873 enum X_GLrop_Fogfv = 81; 2874 enum X_GLrop_Fogi = 82; 2875 enum X_GLrop_Fogiv = 83; 2876 enum X_GLrop_FrontFace = 84; 2877 enum X_GLrop_Hint = 85; 2878 enum X_GLrop_Lightf = 86; 2879 enum X_GLrop_Lightfv = 87; 2880 enum X_GLrop_Lighti = 88; 2881 enum X_GLrop_Lightiv = 89; 2882 enum X_GLrop_LightModelf = 90; 2883 enum X_GLrop_LightModelfv = 91; 2884 enum X_GLrop_LightModeli = 92; 2885 enum X_GLrop_LightModeliv = 93; 2886 enum X_GLrop_LineStipple = 94; 2887 enum X_GLrop_LineWidth = 95; 2888 enum X_GLrop_Materialf = 96; 2889 enum X_GLrop_Materialfv = 97; 2890 enum X_GLrop_Materiali = 98; 2891 enum X_GLrop_Materialiv = 99; 2892 enum X_GLrop_PointSize = 100; 2893 enum X_GLrop_PolygonMode = 101; 2894 enum X_GLrop_PolygonStipple = 102; 2895 enum X_GLrop_Scissor = 103; 2896 enum X_GLrop_ShadeModel = 104; 2897 enum X_GLrop_TexParameterf = 105; 2898 enum X_GLrop_TexParameterfv = 106; 2899 enum X_GLrop_TexParameteri = 107; 2900 enum X_GLrop_TexParameteriv = 108; 2901 enum X_GLrop_TexImage1D = 109; 2902 enum X_GLrop_TexImage2D = 110; 2903 enum X_GLrop_TexEnvf = 111; 2904 enum X_GLrop_TexEnvfv = 112; 2905 enum X_GLrop_TexEnvi = 113; 2906 enum X_GLrop_TexEnviv = 114; 2907 enum X_GLrop_TexGend = 115; 2908 enum X_GLrop_TexGendv = 116; 2909 enum X_GLrop_TexGenf = 117; 2910 enum X_GLrop_TexGenfv = 118; 2911 enum X_GLrop_TexGeni = 119; 2912 enum X_GLrop_TexGeniv = 120; 2913 enum X_GLrop_InitNames = 121; 2914 enum X_GLrop_LoadName = 122; 2915 enum X_GLrop_PassThrough = 123; 2916 enum X_GLrop_PopName = 124; 2917 enum X_GLrop_PushName = 125; 2918 enum X_GLrop_DrawBuffer = 126; 2919 enum X_GLrop_Clear = 127; 2920 enum X_GLrop_ClearAccum = 128; 2921 enum X_GLrop_ClearIndex = 129; 2922 enum X_GLrop_ClearColor = 130; 2923 enum X_GLrop_ClearStencil = 131; 2924 enum X_GLrop_ClearDepth = 132; 2925 enum X_GLrop_StencilMask = 133; 2926 enum X_GLrop_ColorMask = 134; 2927 enum X_GLrop_DepthMask = 135; 2928 enum X_GLrop_IndexMask = 136; 2929 enum X_GLrop_Accum = 137; 2930 enum X_GLrop_Disable = 138; 2931 enum X_GLrop_Enable = 139; 2932 enum X_GLrop_PopAttrib = 141; 2933 enum X_GLrop_PushAttrib = 142; 2934 enum X_GLrop_Map1d = 143; 2935 enum X_GLrop_Map1f = 144; 2936 enum X_GLrop_Map2d = 145; 2937 enum X_GLrop_Map2f = 146; 2938 enum X_GLrop_MapGrid1d = 147; 2939 enum X_GLrop_MapGrid1f = 148; 2940 enum X_GLrop_MapGrid2d = 149; 2941 enum X_GLrop_MapGrid2f = 150; 2942 enum X_GLrop_EvalCoord1dv = 151; 2943 enum X_GLrop_EvalCoord1fv = 152; 2944 enum X_GLrop_EvalCoord2dv = 153; 2945 enum X_GLrop_EvalCoord2fv = 154; 2946 enum X_GLrop_EvalMesh1 = 155; 2947 enum X_GLrop_EvalPoint1 = 156; 2948 enum X_GLrop_EvalMesh2 = 157; 2949 enum X_GLrop_EvalPoint2 = 158; 2950 enum X_GLrop_AlphaFunc = 159; 2951 enum X_GLrop_BlendFunc = 160; 2952 enum X_GLrop_LogicOp = 161; 2953 enum X_GLrop_StencilFunc = 162; 2954 enum X_GLrop_StencilOp = 163; 2955 enum X_GLrop_DepthFunc = 164; 2956 enum X_GLrop_PixelZoom = 165; 2957 enum X_GLrop_PixelTransferf = 166; 2958 enum X_GLrop_PixelTransferi = 167; 2959 enum X_GLrop_PixelMapfv = 168; 2960 enum X_GLrop_PixelMapuiv = 169; 2961 enum X_GLrop_PixelMapusv = 170; 2962 enum X_GLrop_ReadBuffer = 171; 2963 enum X_GLrop_CopyPixels = 172; 2964 enum X_GLrop_DrawPixels = 173; 2965 enum X_GLrop_DepthRange = 174; 2966 enum X_GLrop_Frustum = 175; 2967 enum X_GLrop_LoadIdentity = 176; 2968 enum X_GLrop_LoadMatrixf = 177; 2969 enum X_GLrop_LoadMatrixd = 178; 2970 enum X_GLrop_MatrixMode = 179; 2971 enum X_GLrop_MultMatrixf = 180; 2972 enum X_GLrop_MultMatrixd = 181; 2973 enum X_GLrop_Ortho = 182; 2974 enum X_GLrop_PopMatrix = 183; 2975 enum X_GLrop_PushMatrix = 184; 2976 enum X_GLrop_Rotated = 185; 2977 enum X_GLrop_Rotatef = 186; 2978 enum X_GLrop_Scaled = 187; 2979 enum X_GLrop_Scalef = 188; 2980 enum X_GLrop_Translated = 189; 2981 enum X_GLrop_Translatef = 190; 2982 enum X_GLrop_Viewport = 191; 2983 enum X_GLrop_DrawArrays = 193; 2984 enum X_GLrop_PolygonOffset = 192; 2985 enum X_GLrop_CopyTexImage1D = 4119; 2986 enum X_GLrop_CopyTexImage2D = 4120; 2987 enum X_GLrop_CopyTexSubImage1D = 4121; 2988 enum X_GLrop_CopyTexSubImage2D = 4122; 2989 enum X_GLrop_TexSubImage1D = 4099; 2990 enum X_GLrop_TexSubImage2D = 4100; 2991 enum X_GLrop_BindTexture = 4117; 2992 enum X_GLrop_PrioritizeTextures = 4118; 2993 enum X_GLrop_Indexubv = 194; 2994 enum X_GLrop_BlendColor = 4096; 2995 enum X_GLrop_BlendEquation = 4097; 2996 enum X_GLrop_ColorTable = 2053; 2997 enum X_GLrop_ColorTableParameterfv = 2054; 2998 enum X_GLrop_ColorTableParameteriv = 2055; 2999 enum X_GLrop_CopyColorTable = 2056; 3000 enum X_GLrop_ColorSubTable = 195; 3001 enum X_GLrop_CopyColorSubTable = 196; 3002 enum X_GLrop_ConvolutionFilter1D = 4101; 3003 enum X_GLrop_ConvolutionFilter2D = 4102; 3004 enum X_GLrop_ConvolutionParameterf = 4103; 3005 enum X_GLrop_ConvolutionParameterfv = 4104; 3006 enum X_GLrop_ConvolutionParameteri = 4105; 3007 enum X_GLrop_ConvolutionParameteriv = 4106; 3008 enum X_GLrop_CopyConvolutionFilter1D = 4107; 3009 enum X_GLrop_CopyConvolutionFilter2D = 4108; 3010 enum X_GLrop_SeparableFilter2D = 4109; 3011 enum X_GLrop_Histogram = 4110; 3012 enum X_GLrop_Minmax = 4111; 3013 enum X_GLrop_ResetHistogram = 4112; 3014 enum X_GLrop_ResetMinmax = 4113; 3015 enum X_GLrop_TexImage3D = 4114; 3016 enum X_GLrop_TexSubImage3D = 4115; 3017 enum X_GLrop_CopyTexSubImage3D = 4123; 3018 enum X_GLrop_DrawArraysEXT = 4116; 3019 3020 /* Added for core GL version 1.3 */ 3021 3022 enum X_GLrop_ActiveTextureARB = 197; 3023 enum X_GLrop_MultiTexCoord1dvARB = 198; 3024 enum X_GLrop_MultiTexCoord1fvARB = 199; 3025 enum X_GLrop_MultiTexCoord1ivARB = 200; 3026 enum X_GLrop_MultiTexCoord1svARB = 201; 3027 enum X_GLrop_MultiTexCoord2dvARB = 202; 3028 enum X_GLrop_MultiTexCoord2fvARB = 203; 3029 enum X_GLrop_MultiTexCoord2ivARB = 204; 3030 enum X_GLrop_MultiTexCoord2svARB = 205; 3031 enum X_GLrop_MultiTexCoord3dvARB = 206; 3032 enum X_GLrop_MultiTexCoord3fvARB = 207; 3033 enum X_GLrop_MultiTexCoord3ivARB = 208; 3034 enum X_GLrop_MultiTexCoord3svARB = 209; 3035 enum X_GLrop_MultiTexCoord4dvARB = 210; 3036 enum X_GLrop_MultiTexCoord4fvARB = 211; 3037 enum X_GLrop_MultiTexCoord4ivARB = 212; 3038 enum X_GLrop_MultiTexCoord4svARB = 213; 3039 enum X_GLrop_CompressedTexImage1D = 214; 3040 enum X_GLrop_CompressedTexImage2D = 215; 3041 enum X_GLrop_CompressedTexImage3D = 216; 3042 enum X_GLrop_CompressedTexSubImage1D = 217; 3043 enum X_GLrop_CompressedTexSubImage2D = 218; 3044 enum X_GLrop_CompressedTexSubImage3D = 219; 3045 enum X_GLrop_SampleCoverageARB = 229; 3046 3047 /* Added for core GL version 1.4 */ 3048 3049 enum X_GLrop_WindowPos3fARB = 230; 3050 enum X_GLrop_FogCoordfv = 4124; 3051 enum X_GLrop_FogCoorddv = 4125; 3052 enum X_GLrop_PointParameterfARB = 2065; 3053 enum X_GLrop_PointParameterfvARB = 2066; 3054 enum X_GLrop_SecondaryColor3bv = 4126; 3055 enum X_GLrop_SecondaryColor3sv = 4127; 3056 enum X_GLrop_SecondaryColor3iv = 4128; 3057 enum X_GLrop_SecondaryColor3fv = 4129; 3058 enum X_GLrop_SecondaryColor3dv = 4130; 3059 enum X_GLrop_SecondaryColor3ubv = 4131; 3060 enum X_GLrop_SecondaryColor3usv = 4132; 3061 enum X_GLrop_SecondaryColor3uiv = 4133; 3062 enum X_GLrop_BlendFuncSeparate = 4134; 3063 enum X_GLrop_PointParameteri = 4221; 3064 enum X_GLrop_PointParameteriv = 4222; 3065 3066 /* Added for core GL version 1.5 */ 3067 /* XXX opcodes not defined in the spec */ 3068 3069 /* Opcodes for Vendor Private commands */ 3070 3071 enum X_GLvop_GetConvolutionFilterEXT = 1; 3072 enum X_GLvop_GetConvolutionParameterfvEXT = 2; 3073 enum X_GLvop_GetConvolutionParameterivEXT = 3; 3074 enum X_GLvop_GetSeparableFilterEXT = 4; 3075 enum X_GLvop_GetHistogramEXT = 5; 3076 enum X_GLvop_GetHistogramParameterfvEXT = 6; 3077 enum X_GLvop_GetHistogramParameterivEXT = 7; 3078 enum X_GLvop_GetMinmaxEXT = 8; 3079 enum X_GLvop_GetMinmaxParameterfvEXT = 9; 3080 enum X_GLvop_GetMinmaxParameterivEXT = 10; 3081 enum X_GLvop_AreTexturesResidentEXT = 11; 3082 enum X_GLvop_DeleteTexturesEXT = 12; 3083 enum X_GLvop_GenTexturesEXT = 13; 3084 enum X_GLvop_IsTextureEXT = 14; 3085 enum X_GLvop_GetCombinerInputParameterfvNV = 1270; 3086 enum X_GLvop_GetCombinerInputParameterivNV = 1271; 3087 enum X_GLvop_GetCombinerOutputParameterfvNV = 1272; 3088 enum X_GLvop_GetCombinerOutputParameterivNV = 1273; 3089 enum X_GLvop_GetFinalCombinerOutputParameterfvNV = 1274; 3090 enum X_GLvop_GetFinalCombinerOutputParameterivNV = 1275; 3091 enum X_GLvop_DeleteFenceNV = 1276; 3092 enum X_GLvop_GenFencesNV = 1277; 3093 enum X_GLvop_IsFenceNV = 1278; 3094 enum X_GLvop_TestFenceNV = 1279; 3095 enum X_GLvop_GetFenceivNV = 1280; 3096 enum X_GLvop_AreProgramsResidentNV = 1293; 3097 enum X_GLvop_DeleteProgramARB = 1294; 3098 enum X_GLvop_GenProgramsARB = 1295; 3099 enum X_GLvop_GetProgramEnvParameterfvARB = 1296; 3100 enum X_GLvop_GetProgramEnvParameterdvARB = 1297; 3101 enum X_GLvop_GetProgramEnvParameterivNV = 1298; 3102 enum X_GLvop_GetProgramStringNV = 1299; 3103 enum X_GLvop_GetTrackMatrixivNV = 1300; 3104 enum X_GLvop_GetVertexAttribdvARB = 1301; 3105 enum X_GLvop_GetVertexAttribfvARB = 1302; 3106 enum X_GLvop_GetVertexAttribivARB = 1303; 3107 enum X_GLvop_IsProgramARB = 1304; 3108 enum X_GLvop_GetProgramLocalParameterfvARB = 1305; 3109 enum X_GLvop_GetProgramLocalParameterdvARB = 1306; 3110 enum X_GLvop_GetProgramivARB = 1307; 3111 enum X_GLvop_GetProgramStringARB = 1308; 3112 enum X_GLvop_GetProgramNamedParameter4fvNV = 1310; 3113 enum X_GLvop_GetProgramNamedParameter4dvNV = 1311; 3114 enum X_GLvop_SampleMaskSGIS = 2048; 3115 enum X_GLvop_SamplePatternSGIS = 2049; 3116 enum X_GLvop_GetDetailTexFuncSGIS = 4096; 3117 enum X_GLvop_GetSharpenTexFuncSGIS = 4097; 3118 enum X_GLvop_GetColorTableSGI = 4098; 3119 enum X_GLvop_GetColorTableParameterfvSGI = 4099; 3120 enum X_GLvop_GetColorTableParameterivSGI = 4100; 3121 enum X_GLvop_GetTexFilterFuncSGIS = 4101; 3122 enum X_GLvop_GetInstrumentsSGIX = 4102; 3123 enum X_GLvop_InstrumentsBufferSGIX = 4103; 3124 enum X_GLvop_PollInstrumentsSGIX = 4104; 3125 enum X_GLvop_FlushRasterSGIX = 4105; 3126 3127 /* Opcodes for GLX vendor private commands */ 3128 3129 enum X_GLXvop_QueryContextInfoEXT = 1024; 3130 enum X_GLXvop_BindTexImageEXT = 1330; 3131 enum X_GLXvop_ReleaseTexImageEXT = 1331; 3132 enum X_GLXvop_SwapIntervalSGI = 65536; 3133 enum X_GLXvop_MakeCurrentReadSGI = 65537; 3134 enum X_GLXvop_CreateGLXVideoSourceSGIX = 65538; 3135 enum X_GLXvop_DestroyGLXVideoSourceSGIX = 65539; 3136 enum X_GLXvop_GetFBConfigsSGIX = 65540; 3137 enum X_GLXvop_CreateContextWithConfigSGIX = 65541; 3138 enum X_GLXvop_CreateGLXPixmapWithConfigSGIX = 65542; 3139 enum X_GLXvop_CreateGLXPbufferSGIX = 65543; 3140 enum X_GLXvop_DestroyGLXPbufferSGIX = 65544; 3141 enum X_GLXvop_ChangeDrawableAttributesSGIX = 65545; 3142 enum X_GLXvop_GetDrawableAttributesSGIX = 65546; 3143 enum X_GLXvop_JoinSwapGroupSGIX = 65547; 3144 enum X_GLXvop_BindSwapBarrierSGIX = 65548; 3145 enum X_GLXvop_QueryMaxSwapBarriersSGIX = 65549; 3146 enum X_GLXvop_QueryHyperpipeNetworkSGIX = 65550; 3147 enum X_GLXvop_QueryHyperpipeConfigSGIX = 65551; 3148 enum X_GLXvop_HyperpipeConfigSGIX = 65552; 3149 enum X_GLXvop_DestroyHyperpipeConfigSGIX = 65553; 3150 3151 /* ARB extension opcodes */ 3152 3153 /* 1. GL_ARB_multitexture - see GL 1.2 opcodes */ 3154 /* 5. GL_ARB_multisample - see GL 1.3 opcodes */ 3155 /* 12. GL_ARB_texture_compression - see GL 1.3 opcodes */ 3156 /* 14. GL_ARB_point_parameters - see GL 1.4 opcodees */ 3157 3158 /* 15. GL_ARB_vertex_blend */ 3159 enum X_GLrop_WeightbvARB = 220; 3160 enum X_GLrop_WeightubvARB = 221; 3161 enum X_GLrop_WeightsvARB = 222; 3162 enum X_GLrop_WeightusvARB = 223; 3163 enum X_GLrop_WeightivARB = 224; 3164 enum X_GLrop_WeightuivARB = 225; 3165 enum X_GLrop_VertexBlendARB = 226; 3166 enum X_GLrop_WeightfvARB = 227; 3167 enum X_GLrop_WeightdvARB = 228; 3168 3169 /* 16. GL_ARB_matrix_palette */ 3170 /* XXX opcodes not defined in the spec */ 3171 3172 /* 25. GL_ARB_window_pos - see GL 1.4 opcodes */ 3173 3174 /* 26. GL_ARB_vertex_program */ 3175 enum X_GLrop_BindProgramARB = 4180; 3176 enum X_GLrop_ProgramEnvParameter4fvARB = 4184; 3177 enum X_GLrop_ProgramEnvParameter4dvARB = 4185; 3178 enum X_GLrop_VertexAttrib1svARB = 4189; 3179 enum X_GLrop_VertexAttrib2svARB = 4190; 3180 enum X_GLrop_VertexAttrib3svARB = 4191; 3181 enum X_GLrop_VertexAttrib4svARB = 4192; 3182 enum X_GLrop_VertexAttrib1fvARB = 4193; 3183 enum X_GLrop_VertexAttrib2fvARB = 4194; 3184 enum X_GLrop_VertexAttrib3fvARB = 4195; 3185 enum X_GLrop_VertexAttrib4fvARB = 4196; 3186 enum X_GLrop_VertexAttrib1dvARB = 4197; 3187 enum X_GLrop_VertexAttrib2dvARB = 4198; 3188 enum X_GLrop_VertexAttrib3dvARB = 4199; 3189 enum X_GLrop_ProgramLocalParameter4fvARB = 4215; 3190 enum X_GLrop_ProgramLocalParameter4dvARB = 4216; 3191 enum X_GLrop_ProgramStringARB = 4217; 3192 enum X_GLrop_VertexAttrib4dvARB = 4200; 3193 enum X_GLrop_VertexAttrib4NubvARB = 4201; 3194 enum X_GLrop_VertexAttrib4bvARB = 4230; 3195 enum X_GLrop_VertexAttrib4ivARB = 4231; 3196 enum X_GLrop_VertexAttrib4ubvARB = 4232; 3197 enum X_GLrop_VertexAttrib4usvARB = 4233; 3198 enum X_GLrop_VertexAttrib4uivARB = 4234; 3199 enum X_GLrop_VertexAttrib4NbvARB = 4235; 3200 enum X_GLrop_VertexAttrib4NsvARB = 4236; 3201 enum X_GLrop_VertexAttrib4NivARB = 4237; 3202 enum X_GLrop_VertexAttrib4NusvARB = 4238; 3203 enum X_GLrop_VertexAttrib4NuivARB = 4239; 3204 3205 /* 27. GL_ARB_fragment_program - see GL_ARB_vertex_program opcodes */ 3206 3207 /* 29. GL_ARB_occlusion_query */ 3208 /* XXX opcodes not defined in the spec */ 3209 3210 /* New extension opcodes */ 3211 3212 /* 145. GL_EXT_secondary_color - see GL 1.4 opcodes */ 3213 3214 /* 188. GL_EXT_vertex_weighting */ 3215 enum X_GLrop_VertexWeightfvEXT = 4135; 3216 3217 /* 191. GL_NV_register_combiners */ 3218 enum X_GLrop_CombinerParameterfNV = 4136; 3219 enum X_GLrop_CombinerParameterfvNV = 4137; 3220 enum X_GLrop_CombinerParameteriNV = 4138; 3221 enum X_GLrop_CombinerParameterivNV = 4139; 3222 enum X_GLrop_CombinerInputNV = 4140; 3223 enum X_GLrop_CombinerOutputNV = 4141; 3224 enum X_GLrop_FinalCombinerInputNV = 4142; 3225 3226 /* 222. GL_NV_fence */ 3227 enum X_GLrop_SetFenceNV = 4143; 3228 enum X_GLrop_FinishFenceNV = 4144; 3229 3230 /* 227. GL_NV_register_combiners2 */ 3231 /* XXX opcodes not defined in the spec */ 3232 3233 /* 233. GL_NV_vertex_program - see also GL_ARB_vertex_program opcodes */ 3234 enum X_GLrop_ExecuteProgramNV = 4181; 3235 enum X_GLrop_RequestResidentProgramsNV = 4182; 3236 enum X_GLrop_LoadProgamNV = 4183; 3237 enum X_GLrop_ProgramParameters4fvNV = 4186; 3238 enum X_GLrop_ProgramParameters4dvNV = 4187; 3239 enum X_GLrop_TrackMatrixNV = 4188; 3240 enum X_GLrop_VertexAttribs1svNV = 4202; 3241 enum X_GLrop_VertexAttribs2svNV = 4203; 3242 enum X_GLrop_VertexAttribs3svNV = 4204; 3243 enum X_GLrop_VertexAttribs4svNV = 4205; 3244 enum X_GLrop_VertexAttribs1fvNV = 4206; 3245 enum X_GLrop_VertexAttribs2fvNV = 4207; 3246 enum X_GLrop_VertexAttribs3fvNV = 4208; 3247 enum X_GLrop_VertexAttribs4fvNV = 4209; 3248 enum X_GLrop_VertexAttribs1dvNV = 4210; 3249 enum X_GLrop_VertexAttribs2dvNV = 4211; 3250 enum X_GLrop_VertexAttribs3dvNV = 4212; 3251 enum X_GLrop_VertexAttribs4dvNV = 4213; 3252 enum X_GLrop_VertexAttribs4ubvNV = 4214; 3253 3254 /* 261. GL_NV_occlusion_query */ 3255 /* XXX opcodes not defined in the spec */ 3256 3257 /* 262. GL_NV_point_sprite - see GL 1.4 opcodes */ 3258 3259 /* 268. GL_EXT_stencil_two_side */ 3260 enum X_GLrop_ActiveStencilFaceEXT = 4220; 3261 3262 /* 282. GL_NV_fragment_program - see also GL_NV_vertex_program and GL_ARB_vertex_program opcodes */ 3263 enum X_GLrop_ProgramNamedParameter4fvNV = 4218; 3264 enum X_GLrop_ProgramNamedParameter4dvNV = 4219; 3265 3266 /* 285. GL_NV_primitive_restart */ 3267 /* XXX opcodes not defined in the spec */ 3268 3269 /* 297. GL_EXT_depth_bounds_test */ 3270 enum X_GLrop_DepthBoundsEXT = 4229; 3271 3272 /* 299. GL_EXT_blend_equation_separate */ 3273 enum X_GLrop_BlendEquationSeparateEXT = 4228; 3274 3275 /* 310. GL_EXT_framebuffer_object */ 3276 enum X_GLvop_IsRenderbufferEXT = 1422; 3277 enum X_GLvop_GenRenderbuffersEXT = 1423; 3278 enum X_GLvop_GetRenderbufferParameterivEXT = 1424; 3279 enum X_GLvop_IsFramebufferEXT = 1425; 3280 enum X_GLvop_GenFramebuffersEXT = 1426; 3281 enum X_GLvop_CheckFramebufferStatusEXT = 1427; 3282 enum X_GLvop_GetFramebufferAttachmentParameterivEXT = 1428; 3283 3284 /* _GLX_glxproto_h_ */