1/* DO NOT EDIT - This file generated automatically by glX_proto_recv.py (from Mesa) script */ 2 3/* 4 * (C) Copyright IBM Corporation 2005 5 * All Rights Reserved. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sub license, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice (including the next 15 * paragraph) shall be included in all copies or substantial portions of the 16 * Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 20 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL 21 * IBM, 22 * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF 24 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 25 * SOFTWARE. 26 */ 27 28#include <X11/Xmd.h> 29#include <GL/gl.h> 30#include <GL/glxproto.h> 31#include <inttypes.h> 32#include "indirect_size.h" 33#include "indirect_size_get.h" 34#include "indirect_dispatch.h" 35#include "glxserver.h" 36#include "glxbyteorder.h" 37#include "indirect_util.h" 38#include "singlesize.h" 39#include "glapi.h" 40#include "glapitable.h" 41#include "glthread.h" 42#include "dispatch.h" 43 44#define __GLX_PAD(x) (((x) + 3) & ~3) 45 46typedef struct { 47 __GLX_PIXEL_3D_HDR; 48} __GLXpixel3DHeader; 49 50extern GLboolean __glXErrorOccured( void ); 51extern void __glXClearErrorOccured( void ); 52 53static const unsigned dummy_answer[2] = {0, 0}; 54 55int __glXDisp_NewList(__GLXclientState *cl, GLbyte *pc) 56{ 57 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 58 int error; 59 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 60 61 pc += __GLX_SINGLE_HDR_SIZE; 62 if ( cx != NULL ) { 63 CALL_NewList( GET_DISPATCH(), ( 64 *(GLuint *)(pc + 0), 65 *(GLenum *)(pc + 4) 66 ) ); 67 error = Success; 68 } 69 70 return error; 71} 72 73int __glXDisp_EndList(__GLXclientState *cl, GLbyte *pc) 74{ 75 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 76 int error; 77 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 78 79 pc += __GLX_SINGLE_HDR_SIZE; 80 if ( cx != NULL ) { 81 CALL_EndList( GET_DISPATCH(), () ); 82 error = Success; 83 } 84 85 return error; 86} 87 88void __glXDisp_CallList(GLbyte * pc) 89{ 90 CALL_CallList( GET_DISPATCH(), ( 91 *(GLuint *)(pc + 0) 92 ) ); 93} 94 95void __glXDisp_CallLists(GLbyte * pc) 96{ 97 const GLsizei n = *(GLsizei *)(pc + 0); 98 const GLenum type = *(GLenum *)(pc + 4); 99 const GLvoid * lists = (const GLvoid *)(pc + 8); 100 101 CALL_CallLists( GET_DISPATCH(), ( 102 n, 103 type, 104 lists 105 ) ); 106} 107 108int __glXDisp_DeleteLists(__GLXclientState *cl, GLbyte *pc) 109{ 110 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 111 int error; 112 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 113 114 pc += __GLX_SINGLE_HDR_SIZE; 115 if ( cx != NULL ) { 116 CALL_DeleteLists( GET_DISPATCH(), ( 117 *(GLuint *)(pc + 0), 118 *(GLsizei *)(pc + 4) 119 ) ); 120 error = Success; 121 } 122 123 return error; 124} 125 126int __glXDisp_GenLists(__GLXclientState *cl, GLbyte *pc) 127{ 128 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 129 int error; 130 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 131 132 pc += __GLX_SINGLE_HDR_SIZE; 133 if ( cx != NULL ) { 134 GLuint retval; 135 retval = CALL_GenLists( GET_DISPATCH(), ( 136 *(GLsizei *)(pc + 0) 137 ) ); 138 __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); 139 error = Success; 140 } 141 142 return error; 143} 144 145void __glXDisp_ListBase(GLbyte * pc) 146{ 147 CALL_ListBase( GET_DISPATCH(), ( 148 *(GLuint *)(pc + 0) 149 ) ); 150} 151 152void __glXDisp_Begin(GLbyte * pc) 153{ 154 CALL_Begin( GET_DISPATCH(), ( 155 *(GLenum *)(pc + 0) 156 ) ); 157} 158 159void __glXDisp_Bitmap(GLbyte * pc) 160{ 161 const GLubyte * const bitmap = (const GLubyte *) (pc + 44); 162 __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); 163 164 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst) ); 165 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength) ); 166 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows) ); 167 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels) ); 168 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment) ); 169 170 CALL_Bitmap( GET_DISPATCH(), ( 171 *(GLsizei *)(pc + 20), 172 *(GLsizei *)(pc + 24), 173 *(GLfloat *)(pc + 28), 174 *(GLfloat *)(pc + 32), 175 *(GLfloat *)(pc + 36), 176 *(GLfloat *)(pc + 40), 177 bitmap 178 ) ); 179} 180 181void __glXDisp_Color3bv(GLbyte * pc) 182{ 183 CALL_Color3bv( GET_DISPATCH(), ( 184 (const GLbyte *)(pc + 0) 185 ) ); 186} 187 188void __glXDisp_Color3dv(GLbyte * pc) 189{ 190#ifdef __GLX_ALIGN64 191 if ((unsigned long)(pc) & 7) { 192 (void) memmove(pc-4, pc, 24); 193 pc -= 4; 194 } 195#endif 196 197 CALL_Color3dv( GET_DISPATCH(), ( 198 (const GLdouble *)(pc + 0) 199 ) ); 200} 201 202void __glXDisp_Color3fv(GLbyte * pc) 203{ 204 CALL_Color3fv( GET_DISPATCH(), ( 205 (const GLfloat *)(pc + 0) 206 ) ); 207} 208 209void __glXDisp_Color3iv(GLbyte * pc) 210{ 211 CALL_Color3iv( GET_DISPATCH(), ( 212 (const GLint *)(pc + 0) 213 ) ); 214} 215 216void __glXDisp_Color3sv(GLbyte * pc) 217{ 218 CALL_Color3sv( GET_DISPATCH(), ( 219 (const GLshort *)(pc + 0) 220 ) ); 221} 222 223void __glXDisp_Color3ubv(GLbyte * pc) 224{ 225 CALL_Color3ubv( GET_DISPATCH(), ( 226 (const GLubyte *)(pc + 0) 227 ) ); 228} 229 230void __glXDisp_Color3uiv(GLbyte * pc) 231{ 232 CALL_Color3uiv( GET_DISPATCH(), ( 233 (const GLuint *)(pc + 0) 234 ) ); 235} 236 237void __glXDisp_Color3usv(GLbyte * pc) 238{ 239 CALL_Color3usv( GET_DISPATCH(), ( 240 (const GLushort *)(pc + 0) 241 ) ); 242} 243 244void __glXDisp_Color4bv(GLbyte * pc) 245{ 246 CALL_Color4bv( GET_DISPATCH(), ( 247 (const GLbyte *)(pc + 0) 248 ) ); 249} 250 251void __glXDisp_Color4dv(GLbyte * pc) 252{ 253#ifdef __GLX_ALIGN64 254 if ((unsigned long)(pc) & 7) { 255 (void) memmove(pc-4, pc, 32); 256 pc -= 4; 257 } 258#endif 259 260 CALL_Color4dv( GET_DISPATCH(), ( 261 (const GLdouble *)(pc + 0) 262 ) ); 263} 264 265void __glXDisp_Color4fv(GLbyte * pc) 266{ 267 CALL_Color4fv( GET_DISPATCH(), ( 268 (const GLfloat *)(pc + 0) 269 ) ); 270} 271 272void __glXDisp_Color4iv(GLbyte * pc) 273{ 274 CALL_Color4iv( GET_DISPATCH(), ( 275 (const GLint *)(pc + 0) 276 ) ); 277} 278 279void __glXDisp_Color4sv(GLbyte * pc) 280{ 281 CALL_Color4sv( GET_DISPATCH(), ( 282 (const GLshort *)(pc + 0) 283 ) ); 284} 285 286void __glXDisp_Color4ubv(GLbyte * pc) 287{ 288 CALL_Color4ubv( GET_DISPATCH(), ( 289 (const GLubyte *)(pc + 0) 290 ) ); 291} 292 293void __glXDisp_Color4uiv(GLbyte * pc) 294{ 295 CALL_Color4uiv( GET_DISPATCH(), ( 296 (const GLuint *)(pc + 0) 297 ) ); 298} 299 300void __glXDisp_Color4usv(GLbyte * pc) 301{ 302 CALL_Color4usv( GET_DISPATCH(), ( 303 (const GLushort *)(pc + 0) 304 ) ); 305} 306 307void __glXDisp_EdgeFlagv(GLbyte * pc) 308{ 309 CALL_EdgeFlagv( GET_DISPATCH(), ( 310 (const GLboolean *)(pc + 0) 311 ) ); 312} 313 314void __glXDisp_End(GLbyte * pc) 315{ 316 CALL_End( GET_DISPATCH(), () ); 317} 318 319void __glXDisp_Indexdv(GLbyte * pc) 320{ 321#ifdef __GLX_ALIGN64 322 if ((unsigned long)(pc) & 7) { 323 (void) memmove(pc-4, pc, 8); 324 pc -= 4; 325 } 326#endif 327 328 CALL_Indexdv( GET_DISPATCH(), ( 329 (const GLdouble *)(pc + 0) 330 ) ); 331} 332 333void __glXDisp_Indexfv(GLbyte * pc) 334{ 335 CALL_Indexfv( GET_DISPATCH(), ( 336 (const GLfloat *)(pc + 0) 337 ) ); 338} 339 340void __glXDisp_Indexiv(GLbyte * pc) 341{ 342 CALL_Indexiv( GET_DISPATCH(), ( 343 (const GLint *)(pc + 0) 344 ) ); 345} 346 347void __glXDisp_Indexsv(GLbyte * pc) 348{ 349 CALL_Indexsv( GET_DISPATCH(), ( 350 (const GLshort *)(pc + 0) 351 ) ); 352} 353 354void __glXDisp_Normal3bv(GLbyte * pc) 355{ 356 CALL_Normal3bv( GET_DISPATCH(), ( 357 (const GLbyte *)(pc + 0) 358 ) ); 359} 360 361void __glXDisp_Normal3dv(GLbyte * pc) 362{ 363#ifdef __GLX_ALIGN64 364 if ((unsigned long)(pc) & 7) { 365 (void) memmove(pc-4, pc, 24); 366 pc -= 4; 367 } 368#endif 369 370 CALL_Normal3dv( GET_DISPATCH(), ( 371 (const GLdouble *)(pc + 0) 372 ) ); 373} 374 375void __glXDisp_Normal3fv(GLbyte * pc) 376{ 377 CALL_Normal3fv( GET_DISPATCH(), ( 378 (const GLfloat *)(pc + 0) 379 ) ); 380} 381 382void __glXDisp_Normal3iv(GLbyte * pc) 383{ 384 CALL_Normal3iv( GET_DISPATCH(), ( 385 (const GLint *)(pc + 0) 386 ) ); 387} 388 389void __glXDisp_Normal3sv(GLbyte * pc) 390{ 391 CALL_Normal3sv( GET_DISPATCH(), ( 392 (const GLshort *)(pc + 0) 393 ) ); 394} 395 396void __glXDisp_RasterPos2dv(GLbyte * pc) 397{ 398#ifdef __GLX_ALIGN64 399 if ((unsigned long)(pc) & 7) { 400 (void) memmove(pc-4, pc, 16); 401 pc -= 4; 402 } 403#endif 404 405 CALL_RasterPos2dv( GET_DISPATCH(), ( 406 (const GLdouble *)(pc + 0) 407 ) ); 408} 409 410void __glXDisp_RasterPos2fv(GLbyte * pc) 411{ 412 CALL_RasterPos2fv( GET_DISPATCH(), ( 413 (const GLfloat *)(pc + 0) 414 ) ); 415} 416 417void __glXDisp_RasterPos2iv(GLbyte * pc) 418{ 419 CALL_RasterPos2iv( GET_DISPATCH(), ( 420 (const GLint *)(pc + 0) 421 ) ); 422} 423 424void __glXDisp_RasterPos2sv(GLbyte * pc) 425{ 426 CALL_RasterPos2sv( GET_DISPATCH(), ( 427 (const GLshort *)(pc + 0) 428 ) ); 429} 430 431void __glXDisp_RasterPos3dv(GLbyte * pc) 432{ 433#ifdef __GLX_ALIGN64 434 if ((unsigned long)(pc) & 7) { 435 (void) memmove(pc-4, pc, 24); 436 pc -= 4; 437 } 438#endif 439 440 CALL_RasterPos3dv( GET_DISPATCH(), ( 441 (const GLdouble *)(pc + 0) 442 ) ); 443} 444 445void __glXDisp_RasterPos3fv(GLbyte * pc) 446{ 447 CALL_RasterPos3fv( GET_DISPATCH(), ( 448 (const GLfloat *)(pc + 0) 449 ) ); 450} 451 452void __glXDisp_RasterPos3iv(GLbyte * pc) 453{ 454 CALL_RasterPos3iv( GET_DISPATCH(), ( 455 (const GLint *)(pc + 0) 456 ) ); 457} 458 459void __glXDisp_RasterPos3sv(GLbyte * pc) 460{ 461 CALL_RasterPos3sv( GET_DISPATCH(), ( 462 (const GLshort *)(pc + 0) 463 ) ); 464} 465 466void __glXDisp_RasterPos4dv(GLbyte * pc) 467{ 468#ifdef __GLX_ALIGN64 469 if ((unsigned long)(pc) & 7) { 470 (void) memmove(pc-4, pc, 32); 471 pc -= 4; 472 } 473#endif 474 475 CALL_RasterPos4dv( GET_DISPATCH(), ( 476 (const GLdouble *)(pc + 0) 477 ) ); 478} 479 480void __glXDisp_RasterPos4fv(GLbyte * pc) 481{ 482 CALL_RasterPos4fv( GET_DISPATCH(), ( 483 (const GLfloat *)(pc + 0) 484 ) ); 485} 486 487void __glXDisp_RasterPos4iv(GLbyte * pc) 488{ 489 CALL_RasterPos4iv( GET_DISPATCH(), ( 490 (const GLint *)(pc + 0) 491 ) ); 492} 493 494void __glXDisp_RasterPos4sv(GLbyte * pc) 495{ 496 CALL_RasterPos4sv( GET_DISPATCH(), ( 497 (const GLshort *)(pc + 0) 498 ) ); 499} 500 501void __glXDisp_Rectdv(GLbyte * pc) 502{ 503#ifdef __GLX_ALIGN64 504 if ((unsigned long)(pc) & 7) { 505 (void) memmove(pc-4, pc, 32); 506 pc -= 4; 507 } 508#endif 509 510 CALL_Rectdv( GET_DISPATCH(), ( 511 (const GLdouble *)(pc + 0), 512 (const GLdouble *)(pc + 16) 513 ) ); 514} 515 516void __glXDisp_Rectfv(GLbyte * pc) 517{ 518 CALL_Rectfv( GET_DISPATCH(), ( 519 (const GLfloat *)(pc + 0), 520 (const GLfloat *)(pc + 8) 521 ) ); 522} 523 524void __glXDisp_Rectiv(GLbyte * pc) 525{ 526 CALL_Rectiv( GET_DISPATCH(), ( 527 (const GLint *)(pc + 0), 528 (const GLint *)(pc + 8) 529 ) ); 530} 531 532void __glXDisp_Rectsv(GLbyte * pc) 533{ 534 CALL_Rectsv( GET_DISPATCH(), ( 535 (const GLshort *)(pc + 0), 536 (const GLshort *)(pc + 4) 537 ) ); 538} 539 540void __glXDisp_TexCoord1dv(GLbyte * pc) 541{ 542#ifdef __GLX_ALIGN64 543 if ((unsigned long)(pc) & 7) { 544 (void) memmove(pc-4, pc, 8); 545 pc -= 4; 546 } 547#endif 548 549 CALL_TexCoord1dv( GET_DISPATCH(), ( 550 (const GLdouble *)(pc + 0) 551 ) ); 552} 553 554void __glXDisp_TexCoord1fv(GLbyte * pc) 555{ 556 CALL_TexCoord1fv( GET_DISPATCH(), ( 557 (const GLfloat *)(pc + 0) 558 ) ); 559} 560 561void __glXDisp_TexCoord1iv(GLbyte * pc) 562{ 563 CALL_TexCoord1iv( GET_DISPATCH(), ( 564 (const GLint *)(pc + 0) 565 ) ); 566} 567 568void __glXDisp_TexCoord1sv(GLbyte * pc) 569{ 570 CALL_TexCoord1sv( GET_DISPATCH(), ( 571 (const GLshort *)(pc + 0) 572 ) ); 573} 574 575void __glXDisp_TexCoord2dv(GLbyte * pc) 576{ 577#ifdef __GLX_ALIGN64 578 if ((unsigned long)(pc) & 7) { 579 (void) memmove(pc-4, pc, 16); 580 pc -= 4; 581 } 582#endif 583 584 CALL_TexCoord2dv( GET_DISPATCH(), ( 585 (const GLdouble *)(pc + 0) 586 ) ); 587} 588 589void __glXDisp_TexCoord2fv(GLbyte * pc) 590{ 591 CALL_TexCoord2fv( GET_DISPATCH(), ( 592 (const GLfloat *)(pc + 0) 593 ) ); 594} 595 596void __glXDisp_TexCoord2iv(GLbyte * pc) 597{ 598 CALL_TexCoord2iv( GET_DISPATCH(), ( 599 (const GLint *)(pc + 0) 600 ) ); 601} 602 603void __glXDisp_TexCoord2sv(GLbyte * pc) 604{ 605 CALL_TexCoord2sv( GET_DISPATCH(), ( 606 (const GLshort *)(pc + 0) 607 ) ); 608} 609 610void __glXDisp_TexCoord3dv(GLbyte * pc) 611{ 612#ifdef __GLX_ALIGN64 613 if ((unsigned long)(pc) & 7) { 614 (void) memmove(pc-4, pc, 24); 615 pc -= 4; 616 } 617#endif 618 619 CALL_TexCoord3dv( GET_DISPATCH(), ( 620 (const GLdouble *)(pc + 0) 621 ) ); 622} 623 624void __glXDisp_TexCoord3fv(GLbyte * pc) 625{ 626 CALL_TexCoord3fv( GET_DISPATCH(), ( 627 (const GLfloat *)(pc + 0) 628 ) ); 629} 630 631void __glXDisp_TexCoord3iv(GLbyte * pc) 632{ 633 CALL_TexCoord3iv( GET_DISPATCH(), ( 634 (const GLint *)(pc + 0) 635 ) ); 636} 637 638void __glXDisp_TexCoord3sv(GLbyte * pc) 639{ 640 CALL_TexCoord3sv( GET_DISPATCH(), ( 641 (const GLshort *)(pc + 0) 642 ) ); 643} 644 645void __glXDisp_TexCoord4dv(GLbyte * pc) 646{ 647#ifdef __GLX_ALIGN64 648 if ((unsigned long)(pc) & 7) { 649 (void) memmove(pc-4, pc, 32); 650 pc -= 4; 651 } 652#endif 653 654 CALL_TexCoord4dv( GET_DISPATCH(), ( 655 (const GLdouble *)(pc + 0) 656 ) ); 657} 658 659void __glXDisp_TexCoord4fv(GLbyte * pc) 660{ 661 CALL_TexCoord4fv( GET_DISPATCH(), ( 662 (const GLfloat *)(pc + 0) 663 ) ); 664} 665 666void __glXDisp_TexCoord4iv(GLbyte * pc) 667{ 668 CALL_TexCoord4iv( GET_DISPATCH(), ( 669 (const GLint *)(pc + 0) 670 ) ); 671} 672 673void __glXDisp_TexCoord4sv(GLbyte * pc) 674{ 675 CALL_TexCoord4sv( GET_DISPATCH(), ( 676 (const GLshort *)(pc + 0) 677 ) ); 678} 679 680void __glXDisp_Vertex2dv(GLbyte * pc) 681{ 682#ifdef __GLX_ALIGN64 683 if ((unsigned long)(pc) & 7) { 684 (void) memmove(pc-4, pc, 16); 685 pc -= 4; 686 } 687#endif 688 689 CALL_Vertex2dv( GET_DISPATCH(), ( 690 (const GLdouble *)(pc + 0) 691 ) ); 692} 693 694void __glXDisp_Vertex2fv(GLbyte * pc) 695{ 696 CALL_Vertex2fv( GET_DISPATCH(), ( 697 (const GLfloat *)(pc + 0) 698 ) ); 699} 700 701void __glXDisp_Vertex2iv(GLbyte * pc) 702{ 703 CALL_Vertex2iv( GET_DISPATCH(), ( 704 (const GLint *)(pc + 0) 705 ) ); 706} 707 708void __glXDisp_Vertex2sv(GLbyte * pc) 709{ 710 CALL_Vertex2sv( GET_DISPATCH(), ( 711 (const GLshort *)(pc + 0) 712 ) ); 713} 714 715void __glXDisp_Vertex3dv(GLbyte * pc) 716{ 717#ifdef __GLX_ALIGN64 718 if ((unsigned long)(pc) & 7) { 719 (void) memmove(pc-4, pc, 24); 720 pc -= 4; 721 } 722#endif 723 724 CALL_Vertex3dv( GET_DISPATCH(), ( 725 (const GLdouble *)(pc + 0) 726 ) ); 727} 728 729void __glXDisp_Vertex3fv(GLbyte * pc) 730{ 731 CALL_Vertex3fv( GET_DISPATCH(), ( 732 (const GLfloat *)(pc + 0) 733 ) ); 734} 735 736void __glXDisp_Vertex3iv(GLbyte * pc) 737{ 738 CALL_Vertex3iv( GET_DISPATCH(), ( 739 (const GLint *)(pc + 0) 740 ) ); 741} 742 743void __glXDisp_Vertex3sv(GLbyte * pc) 744{ 745 CALL_Vertex3sv( GET_DISPATCH(), ( 746 (const GLshort *)(pc + 0) 747 ) ); 748} 749 750void __glXDisp_Vertex4dv(GLbyte * pc) 751{ 752#ifdef __GLX_ALIGN64 753 if ((unsigned long)(pc) & 7) { 754 (void) memmove(pc-4, pc, 32); 755 pc -= 4; 756 } 757#endif 758 759 CALL_Vertex4dv( GET_DISPATCH(), ( 760 (const GLdouble *)(pc + 0) 761 ) ); 762} 763 764void __glXDisp_Vertex4fv(GLbyte * pc) 765{ 766 CALL_Vertex4fv( GET_DISPATCH(), ( 767 (const GLfloat *)(pc + 0) 768 ) ); 769} 770 771void __glXDisp_Vertex4iv(GLbyte * pc) 772{ 773 CALL_Vertex4iv( GET_DISPATCH(), ( 774 (const GLint *)(pc + 0) 775 ) ); 776} 777 778void __glXDisp_Vertex4sv(GLbyte * pc) 779{ 780 CALL_Vertex4sv( GET_DISPATCH(), ( 781 (const GLshort *)(pc + 0) 782 ) ); 783} 784 785void __glXDisp_ClipPlane(GLbyte * pc) 786{ 787#ifdef __GLX_ALIGN64 788 if ((unsigned long)(pc) & 7) { 789 (void) memmove(pc-4, pc, 36); 790 pc -= 4; 791 } 792#endif 793 794 CALL_ClipPlane( GET_DISPATCH(), ( 795 *(GLenum *)(pc + 32), 796 (const GLdouble *)(pc + 0) 797 ) ); 798} 799 800void __glXDisp_ColorMaterial(GLbyte * pc) 801{ 802 CALL_ColorMaterial( GET_DISPATCH(), ( 803 *(GLenum *)(pc + 0), 804 *(GLenum *)(pc + 4) 805 ) ); 806} 807 808void __glXDisp_CullFace(GLbyte * pc) 809{ 810 CALL_CullFace( GET_DISPATCH(), ( 811 *(GLenum *)(pc + 0) 812 ) ); 813} 814 815void __glXDisp_Fogf(GLbyte * pc) 816{ 817 CALL_Fogf( GET_DISPATCH(), ( 818 *(GLenum *)(pc + 0), 819 *(GLfloat *)(pc + 4) 820 ) ); 821} 822 823void __glXDisp_Fogfv(GLbyte * pc) 824{ 825 const GLenum pname = *(GLenum *)(pc + 0); 826 const GLfloat * params; 827 828 params = (const GLfloat *) (pc + 4); 829 830 CALL_Fogfv( GET_DISPATCH(), ( 831 pname, 832 params 833 ) ); 834} 835 836void __glXDisp_Fogi(GLbyte * pc) 837{ 838 CALL_Fogi( GET_DISPATCH(), ( 839 *(GLenum *)(pc + 0), 840 *(GLint *)(pc + 4) 841 ) ); 842} 843 844void __glXDisp_Fogiv(GLbyte * pc) 845{ 846 const GLenum pname = *(GLenum *)(pc + 0); 847 const GLint * params; 848 849 params = (const GLint *) (pc + 4); 850 851 CALL_Fogiv( GET_DISPATCH(), ( 852 pname, 853 params 854 ) ); 855} 856 857void __glXDisp_FrontFace(GLbyte * pc) 858{ 859 CALL_FrontFace( GET_DISPATCH(), ( 860 *(GLenum *)(pc + 0) 861 ) ); 862} 863 864void __glXDisp_Hint(GLbyte * pc) 865{ 866 CALL_Hint( GET_DISPATCH(), ( 867 *(GLenum *)(pc + 0), 868 *(GLenum *)(pc + 4) 869 ) ); 870} 871 872void __glXDisp_Lightf(GLbyte * pc) 873{ 874 CALL_Lightf( GET_DISPATCH(), ( 875 *(GLenum *)(pc + 0), 876 *(GLenum *)(pc + 4), 877 *(GLfloat *)(pc + 8) 878 ) ); 879} 880 881void __glXDisp_Lightfv(GLbyte * pc) 882{ 883 const GLenum pname = *(GLenum *)(pc + 4); 884 const GLfloat * params; 885 886 params = (const GLfloat *) (pc + 8); 887 888 CALL_Lightfv( GET_DISPATCH(), ( 889 *(GLenum *)(pc + 0), 890 pname, 891 params 892 ) ); 893} 894 895void __glXDisp_Lighti(GLbyte * pc) 896{ 897 CALL_Lighti( GET_DISPATCH(), ( 898 *(GLenum *)(pc + 0), 899 *(GLenum *)(pc + 4), 900 *(GLint *)(pc + 8) 901 ) ); 902} 903 904void __glXDisp_Lightiv(GLbyte * pc) 905{ 906 const GLenum pname = *(GLenum *)(pc + 4); 907 const GLint * params; 908 909 params = (const GLint *) (pc + 8); 910 911 CALL_Lightiv( GET_DISPATCH(), ( 912 *(GLenum *)(pc + 0), 913 pname, 914 params 915 ) ); 916} 917 918void __glXDisp_LightModelf(GLbyte * pc) 919{ 920 CALL_LightModelf( GET_DISPATCH(), ( 921 *(GLenum *)(pc + 0), 922 *(GLfloat *)(pc + 4) 923 ) ); 924} 925 926void __glXDisp_LightModelfv(GLbyte * pc) 927{ 928 const GLenum pname = *(GLenum *)(pc + 0); 929 const GLfloat * params; 930 931 params = (const GLfloat *) (pc + 4); 932 933 CALL_LightModelfv( GET_DISPATCH(), ( 934 pname, 935 params 936 ) ); 937} 938 939void __glXDisp_LightModeli(GLbyte * pc) 940{ 941 CALL_LightModeli( GET_DISPATCH(), ( 942 *(GLenum *)(pc + 0), 943 *(GLint *)(pc + 4) 944 ) ); 945} 946 947void __glXDisp_LightModeliv(GLbyte * pc) 948{ 949 const GLenum pname = *(GLenum *)(pc + 0); 950 const GLint * params; 951 952 params = (const GLint *) (pc + 4); 953 954 CALL_LightModeliv( GET_DISPATCH(), ( 955 pname, 956 params 957 ) ); 958} 959 960void __glXDisp_LineStipple(GLbyte * pc) 961{ 962 CALL_LineStipple( GET_DISPATCH(), ( 963 *(GLint *)(pc + 0), 964 *(GLushort *)(pc + 4) 965 ) ); 966} 967 968void __glXDisp_LineWidth(GLbyte * pc) 969{ 970 CALL_LineWidth( GET_DISPATCH(), ( 971 *(GLfloat *)(pc + 0) 972 ) ); 973} 974 975void __glXDisp_Materialf(GLbyte * pc) 976{ 977 CALL_Materialf( GET_DISPATCH(), ( 978 *(GLenum *)(pc + 0), 979 *(GLenum *)(pc + 4), 980 *(GLfloat *)(pc + 8) 981 ) ); 982} 983 984void __glXDisp_Materialfv(GLbyte * pc) 985{ 986 const GLenum pname = *(GLenum *)(pc + 4); 987 const GLfloat * params; 988 989 params = (const GLfloat *) (pc + 8); 990 991 CALL_Materialfv( GET_DISPATCH(), ( 992 *(GLenum *)(pc + 0), 993 pname, 994 params 995 ) ); 996} 997 998void __glXDisp_Materiali(GLbyte * pc) 999{ 1000 CALL_Materiali( GET_DISPATCH(), ( 1001 *(GLenum *)(pc + 0), 1002 *(GLenum *)(pc + 4), 1003 *(GLint *)(pc + 8) 1004 ) ); 1005} 1006 1007void __glXDisp_Materialiv(GLbyte * pc) 1008{ 1009 const GLenum pname = *(GLenum *)(pc + 4); 1010 const GLint * params; 1011 1012 params = (const GLint *) (pc + 8); 1013 1014 CALL_Materialiv( GET_DISPATCH(), ( 1015 *(GLenum *)(pc + 0), 1016 pname, 1017 params 1018 ) ); 1019} 1020 1021void __glXDisp_PointSize(GLbyte * pc) 1022{ 1023 CALL_PointSize( GET_DISPATCH(), ( 1024 *(GLfloat *)(pc + 0) 1025 ) ); 1026} 1027 1028void __glXDisp_PolygonMode(GLbyte * pc) 1029{ 1030 CALL_PolygonMode( GET_DISPATCH(), ( 1031 *(GLenum *)(pc + 0), 1032 *(GLenum *)(pc + 4) 1033 ) ); 1034} 1035 1036void __glXDisp_PolygonStipple(GLbyte * pc) 1037{ 1038 const GLubyte * const mask = (const GLubyte *) (pc + 20); 1039 __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); 1040 1041 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst) ); 1042 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength) ); 1043 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows) ); 1044 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels) ); 1045 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment) ); 1046 1047 CALL_PolygonStipple( GET_DISPATCH(), ( 1048 mask 1049 ) ); 1050} 1051 1052void __glXDisp_Scissor(GLbyte * pc) 1053{ 1054 CALL_Scissor( GET_DISPATCH(), ( 1055 *(GLint *)(pc + 0), 1056 *(GLint *)(pc + 4), 1057 *(GLsizei *)(pc + 8), 1058 *(GLsizei *)(pc + 12) 1059 ) ); 1060} 1061 1062void __glXDisp_ShadeModel(GLbyte * pc) 1063{ 1064 CALL_ShadeModel( GET_DISPATCH(), ( 1065 *(GLenum *)(pc + 0) 1066 ) ); 1067} 1068 1069void __glXDisp_TexParameterf(GLbyte * pc) 1070{ 1071 CALL_TexParameterf( GET_DISPATCH(), ( 1072 *(GLenum *)(pc + 0), 1073 *(GLenum *)(pc + 4), 1074 *(GLfloat *)(pc + 8) 1075 ) ); 1076} 1077 1078void __glXDisp_TexParameterfv(GLbyte * pc) 1079{ 1080 const GLenum pname = *(GLenum *)(pc + 4); 1081 const GLfloat * params; 1082 1083 params = (const GLfloat *) (pc + 8); 1084 1085 CALL_TexParameterfv( GET_DISPATCH(), ( 1086 *(GLenum *)(pc + 0), 1087 pname, 1088 params 1089 ) ); 1090} 1091 1092void __glXDisp_TexParameteri(GLbyte * pc) 1093{ 1094 CALL_TexParameteri( GET_DISPATCH(), ( 1095 *(GLenum *)(pc + 0), 1096 *(GLenum *)(pc + 4), 1097 *(GLint *)(pc + 8) 1098 ) ); 1099} 1100 1101void __glXDisp_TexParameteriv(GLbyte * pc) 1102{ 1103 const GLenum pname = *(GLenum *)(pc + 4); 1104 const GLint * params; 1105 1106 params = (const GLint *) (pc + 8); 1107 1108 CALL_TexParameteriv( GET_DISPATCH(), ( 1109 *(GLenum *)(pc + 0), 1110 pname, 1111 params 1112 ) ); 1113} 1114 1115void __glXDisp_TexImage1D(GLbyte * pc) 1116{ 1117 const GLvoid * const pixels = (const GLvoid *) (pc + 52); 1118 __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); 1119 1120 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes) ); 1121 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst) ); 1122 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength) ); 1123 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows) ); 1124 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels) ); 1125 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment) ); 1126 1127 CALL_TexImage1D( GET_DISPATCH(), ( 1128 *(GLenum *)(pc + 20), 1129 *(GLint *)(pc + 24), 1130 *(GLint *)(pc + 28), 1131 *(GLsizei *)(pc + 32), 1132 *(GLint *)(pc + 40), 1133 *(GLenum *)(pc + 44), 1134 *(GLenum *)(pc + 48), 1135 pixels 1136 ) ); 1137} 1138 1139void __glXDisp_TexImage2D(GLbyte * pc) 1140{ 1141 const GLvoid * const pixels = (const GLvoid *) (pc + 52); 1142 __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); 1143 1144 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes) ); 1145 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst) ); 1146 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength) ); 1147 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows) ); 1148 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels) ); 1149 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment) ); 1150 1151 CALL_TexImage2D( GET_DISPATCH(), ( 1152 *(GLenum *)(pc + 20), 1153 *(GLint *)(pc + 24), 1154 *(GLint *)(pc + 28), 1155 *(GLsizei *)(pc + 32), 1156 *(GLsizei *)(pc + 36), 1157 *(GLint *)(pc + 40), 1158 *(GLenum *)(pc + 44), 1159 *(GLenum *)(pc + 48), 1160 pixels 1161 ) ); 1162} 1163 1164void __glXDisp_TexEnvf(GLbyte * pc) 1165{ 1166 CALL_TexEnvf( GET_DISPATCH(), ( 1167 *(GLenum *)(pc + 0), 1168 *(GLenum *)(pc + 4), 1169 *(GLfloat *)(pc + 8) 1170 ) ); 1171} 1172 1173void __glXDisp_TexEnvfv(GLbyte * pc) 1174{ 1175 const GLenum pname = *(GLenum *)(pc + 4); 1176 const GLfloat * params; 1177 1178 params = (const GLfloat *) (pc + 8); 1179 1180 CALL_TexEnvfv( GET_DISPATCH(), ( 1181 *(GLenum *)(pc + 0), 1182 pname, 1183 params 1184 ) ); 1185} 1186 1187void __glXDisp_TexEnvi(GLbyte * pc) 1188{ 1189 CALL_TexEnvi( GET_DISPATCH(), ( 1190 *(GLenum *)(pc + 0), 1191 *(GLenum *)(pc + 4), 1192 *(GLint *)(pc + 8) 1193 ) ); 1194} 1195 1196void __glXDisp_TexEnviv(GLbyte * pc) 1197{ 1198 const GLenum pname = *(GLenum *)(pc + 4); 1199 const GLint * params; 1200 1201 params = (const GLint *) (pc + 8); 1202 1203 CALL_TexEnviv( GET_DISPATCH(), ( 1204 *(GLenum *)(pc + 0), 1205 pname, 1206 params 1207 ) ); 1208} 1209 1210void __glXDisp_TexGend(GLbyte * pc) 1211{ 1212#ifdef __GLX_ALIGN64 1213 if ((unsigned long)(pc) & 7) { 1214 (void) memmove(pc-4, pc, 16); 1215 pc -= 4; 1216 } 1217#endif 1218 1219 CALL_TexGend( GET_DISPATCH(), ( 1220 *(GLenum *)(pc + 8), 1221 *(GLenum *)(pc + 12), 1222 *(GLdouble *)(pc + 0) 1223 ) ); 1224} 1225 1226void __glXDisp_TexGendv(GLbyte * pc) 1227{ 1228 const GLenum pname = *(GLenum *)(pc + 4); 1229 const GLdouble * params; 1230 1231#ifdef __GLX_ALIGN64 1232 const GLuint compsize = __glTexGendv_size(pname); 1233 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8)) - 4; 1234 if ((unsigned long)(pc) & 7) { 1235 (void) memmove(pc-4, pc, cmdlen); 1236 pc -= 4; 1237 } 1238#endif 1239 1240 params = (const GLdouble *) (pc + 8); 1241 1242 CALL_TexGendv( GET_DISPATCH(), ( 1243 *(GLenum *)(pc + 0), 1244 pname, 1245 params 1246 ) ); 1247} 1248 1249void __glXDisp_TexGenf(GLbyte * pc) 1250{ 1251 CALL_TexGenf( GET_DISPATCH(), ( 1252 *(GLenum *)(pc + 0), 1253 *(GLenum *)(pc + 4), 1254 *(GLfloat *)(pc + 8) 1255 ) ); 1256} 1257 1258void __glXDisp_TexGenfv(GLbyte * pc) 1259{ 1260 const GLenum pname = *(GLenum *)(pc + 4); 1261 const GLfloat * params; 1262 1263 params = (const GLfloat *) (pc + 8); 1264 1265 CALL_TexGenfv( GET_DISPATCH(), ( 1266 *(GLenum *)(pc + 0), 1267 pname, 1268 params 1269 ) ); 1270} 1271 1272void __glXDisp_TexGeni(GLbyte * pc) 1273{ 1274 CALL_TexGeni( GET_DISPATCH(), ( 1275 *(GLenum *)(pc + 0), 1276 *(GLenum *)(pc + 4), 1277 *(GLint *)(pc + 8) 1278 ) ); 1279} 1280 1281void __glXDisp_TexGeniv(GLbyte * pc) 1282{ 1283 const GLenum pname = *(GLenum *)(pc + 4); 1284 const GLint * params; 1285 1286 params = (const GLint *) (pc + 8); 1287 1288 CALL_TexGeniv( GET_DISPATCH(), ( 1289 *(GLenum *)(pc + 0), 1290 pname, 1291 params 1292 ) ); 1293} 1294 1295void __glXDisp_InitNames(GLbyte * pc) 1296{ 1297 CALL_InitNames( GET_DISPATCH(), () ); 1298} 1299 1300void __glXDisp_LoadName(GLbyte * pc) 1301{ 1302 CALL_LoadName( GET_DISPATCH(), ( 1303 *(GLuint *)(pc + 0) 1304 ) ); 1305} 1306 1307void __glXDisp_PassThrough(GLbyte * pc) 1308{ 1309 CALL_PassThrough( GET_DISPATCH(), ( 1310 *(GLfloat *)(pc + 0) 1311 ) ); 1312} 1313 1314void __glXDisp_PopName(GLbyte * pc) 1315{ 1316 CALL_PopName( GET_DISPATCH(), () ); 1317} 1318 1319void __glXDisp_PushName(GLbyte * pc) 1320{ 1321 CALL_PushName( GET_DISPATCH(), ( 1322 *(GLuint *)(pc + 0) 1323 ) ); 1324} 1325 1326void __glXDisp_DrawBuffer(GLbyte * pc) 1327{ 1328 CALL_DrawBuffer( GET_DISPATCH(), ( 1329 *(GLenum *)(pc + 0) 1330 ) ); 1331} 1332 1333void __glXDisp_Clear(GLbyte * pc) 1334{ 1335 CALL_Clear( GET_DISPATCH(), ( 1336 *(GLbitfield *)(pc + 0) 1337 ) ); 1338} 1339 1340void __glXDisp_ClearAccum(GLbyte * pc) 1341{ 1342 CALL_ClearAccum( GET_DISPATCH(), ( 1343 *(GLfloat *)(pc + 0), 1344 *(GLfloat *)(pc + 4), 1345 *(GLfloat *)(pc + 8), 1346 *(GLfloat *)(pc + 12) 1347 ) ); 1348} 1349 1350void __glXDisp_ClearIndex(GLbyte * pc) 1351{ 1352 CALL_ClearIndex( GET_DISPATCH(), ( 1353 *(GLfloat *)(pc + 0) 1354 ) ); 1355} 1356 1357void __glXDisp_ClearColor(GLbyte * pc) 1358{ 1359 CALL_ClearColor( GET_DISPATCH(), ( 1360 *(GLclampf *)(pc + 0), 1361 *(GLclampf *)(pc + 4), 1362 *(GLclampf *)(pc + 8), 1363 *(GLclampf *)(pc + 12) 1364 ) ); 1365} 1366 1367void __glXDisp_ClearStencil(GLbyte * pc) 1368{ 1369 CALL_ClearStencil( GET_DISPATCH(), ( 1370 *(GLint *)(pc + 0) 1371 ) ); 1372} 1373 1374void __glXDisp_ClearDepth(GLbyte * pc) 1375{ 1376#ifdef __GLX_ALIGN64 1377 if ((unsigned long)(pc) & 7) { 1378 (void) memmove(pc-4, pc, 8); 1379 pc -= 4; 1380 } 1381#endif 1382 1383 CALL_ClearDepth( GET_DISPATCH(), ( 1384 *(GLclampd *)(pc + 0) 1385 ) ); 1386} 1387 1388void __glXDisp_StencilMask(GLbyte * pc) 1389{ 1390 CALL_StencilMask( GET_DISPATCH(), ( 1391 *(GLuint *)(pc + 0) 1392 ) ); 1393} 1394 1395void __glXDisp_ColorMask(GLbyte * pc) 1396{ 1397 CALL_ColorMask( GET_DISPATCH(), ( 1398 *(GLboolean *)(pc + 0), 1399 *(GLboolean *)(pc + 1), 1400 *(GLboolean *)(pc + 2), 1401 *(GLboolean *)(pc + 3) 1402 ) ); 1403} 1404 1405void __glXDisp_DepthMask(GLbyte * pc) 1406{ 1407 CALL_DepthMask( GET_DISPATCH(), ( 1408 *(GLboolean *)(pc + 0) 1409 ) ); 1410} 1411 1412void __glXDisp_IndexMask(GLbyte * pc) 1413{ 1414 CALL_IndexMask( GET_DISPATCH(), ( 1415 *(GLuint *)(pc + 0) 1416 ) ); 1417} 1418 1419void __glXDisp_Accum(GLbyte * pc) 1420{ 1421 CALL_Accum( GET_DISPATCH(), ( 1422 *(GLenum *)(pc + 0), 1423 *(GLfloat *)(pc + 4) 1424 ) ); 1425} 1426 1427void __glXDisp_Disable(GLbyte * pc) 1428{ 1429 CALL_Disable( GET_DISPATCH(), ( 1430 *(GLenum *)(pc + 0) 1431 ) ); 1432} 1433 1434void __glXDisp_Enable(GLbyte * pc) 1435{ 1436 CALL_Enable( GET_DISPATCH(), ( 1437 *(GLenum *)(pc + 0) 1438 ) ); 1439} 1440 1441void __glXDisp_PopAttrib(GLbyte * pc) 1442{ 1443 CALL_PopAttrib( GET_DISPATCH(), () ); 1444} 1445 1446void __glXDisp_PushAttrib(GLbyte * pc) 1447{ 1448 CALL_PushAttrib( GET_DISPATCH(), ( 1449 *(GLbitfield *)(pc + 0) 1450 ) ); 1451} 1452 1453void __glXDisp_MapGrid1d(GLbyte * pc) 1454{ 1455#ifdef __GLX_ALIGN64 1456 if ((unsigned long)(pc) & 7) { 1457 (void) memmove(pc-4, pc, 20); 1458 pc -= 4; 1459 } 1460#endif 1461 1462 CALL_MapGrid1d( GET_DISPATCH(), ( 1463 *(GLint *)(pc + 16), 1464 *(GLdouble *)(pc + 0), 1465 *(GLdouble *)(pc + 8) 1466 ) ); 1467} 1468 1469void __glXDisp_MapGrid1f(GLbyte * pc) 1470{ 1471 CALL_MapGrid1f( GET_DISPATCH(), ( 1472 *(GLint *)(pc + 0), 1473 *(GLfloat *)(pc + 4), 1474 *(GLfloat *)(pc + 8) 1475 ) ); 1476} 1477 1478void __glXDisp_MapGrid2d(GLbyte * pc) 1479{ 1480#ifdef __GLX_ALIGN64 1481 if ((unsigned long)(pc) & 7) { 1482 (void) memmove(pc-4, pc, 40); 1483 pc -= 4; 1484 } 1485#endif 1486 1487 CALL_MapGrid2d( GET_DISPATCH(), ( 1488 *(GLint *)(pc + 32), 1489 *(GLdouble *)(pc + 0), 1490 *(GLdouble *)(pc + 8), 1491 *(GLint *)(pc + 36), 1492 *(GLdouble *)(pc + 16), 1493 *(GLdouble *)(pc + 24) 1494 ) ); 1495} 1496 1497void __glXDisp_MapGrid2f(GLbyte * pc) 1498{ 1499 CALL_MapGrid2f( GET_DISPATCH(), ( 1500 *(GLint *)(pc + 0), 1501 *(GLfloat *)(pc + 4), 1502 *(GLfloat *)(pc + 8), 1503 *(GLint *)(pc + 12), 1504 *(GLfloat *)(pc + 16), 1505 *(GLfloat *)(pc + 20) 1506 ) ); 1507} 1508 1509void __glXDisp_EvalCoord1dv(GLbyte * pc) 1510{ 1511#ifdef __GLX_ALIGN64 1512 if ((unsigned long)(pc) & 7) { 1513 (void) memmove(pc-4, pc, 8); 1514 pc -= 4; 1515 } 1516#endif 1517 1518 CALL_EvalCoord1dv( GET_DISPATCH(), ( 1519 (const GLdouble *)(pc + 0) 1520 ) ); 1521} 1522 1523void __glXDisp_EvalCoord1fv(GLbyte * pc) 1524{ 1525 CALL_EvalCoord1fv( GET_DISPATCH(), ( 1526 (const GLfloat *)(pc + 0) 1527 ) ); 1528} 1529 1530void __glXDisp_EvalCoord2dv(GLbyte * pc) 1531{ 1532#ifdef __GLX_ALIGN64 1533 if ((unsigned long)(pc) & 7) { 1534 (void) memmove(pc-4, pc, 16); 1535 pc -= 4; 1536 } 1537#endif 1538 1539 CALL_EvalCoord2dv( GET_DISPATCH(), ( 1540 (const GLdouble *)(pc + 0) 1541 ) ); 1542} 1543 1544void __glXDisp_EvalCoord2fv(GLbyte * pc) 1545{ 1546 CALL_EvalCoord2fv( GET_DISPATCH(), ( 1547 (const GLfloat *)(pc + 0) 1548 ) ); 1549} 1550 1551void __glXDisp_EvalMesh1(GLbyte * pc) 1552{ 1553 CALL_EvalMesh1( GET_DISPATCH(), ( 1554 *(GLenum *)(pc + 0), 1555 *(GLint *)(pc + 4), 1556 *(GLint *)(pc + 8) 1557 ) ); 1558} 1559 1560void __glXDisp_EvalPoint1(GLbyte * pc) 1561{ 1562 CALL_EvalPoint1( GET_DISPATCH(), ( 1563 *(GLint *)(pc + 0) 1564 ) ); 1565} 1566 1567void __glXDisp_EvalMesh2(GLbyte * pc) 1568{ 1569 CALL_EvalMesh2( GET_DISPATCH(), ( 1570 *(GLenum *)(pc + 0), 1571 *(GLint *)(pc + 4), 1572 *(GLint *)(pc + 8), 1573 *(GLint *)(pc + 12), 1574 *(GLint *)(pc + 16) 1575 ) ); 1576} 1577 1578void __glXDisp_EvalPoint2(GLbyte * pc) 1579{ 1580 CALL_EvalPoint2( GET_DISPATCH(), ( 1581 *(GLint *)(pc + 0), 1582 *(GLint *)(pc + 4) 1583 ) ); 1584} 1585 1586void __glXDisp_AlphaFunc(GLbyte * pc) 1587{ 1588 CALL_AlphaFunc( GET_DISPATCH(), ( 1589 *(GLenum *)(pc + 0), 1590 *(GLclampf *)(pc + 4) 1591 ) ); 1592} 1593 1594void __glXDisp_BlendFunc(GLbyte * pc) 1595{ 1596 CALL_BlendFunc( GET_DISPATCH(), ( 1597 *(GLenum *)(pc + 0), 1598 *(GLenum *)(pc + 4) 1599 ) ); 1600} 1601 1602void __glXDisp_LogicOp(GLbyte * pc) 1603{ 1604 CALL_LogicOp( GET_DISPATCH(), ( 1605 *(GLenum *)(pc + 0) 1606 ) ); 1607} 1608 1609void __glXDisp_StencilFunc(GLbyte * pc) 1610{ 1611 CALL_StencilFunc( GET_DISPATCH(), ( 1612 *(GLenum *)(pc + 0), 1613 *(GLint *)(pc + 4), 1614 *(GLuint *)(pc + 8) 1615 ) ); 1616} 1617 1618void __glXDisp_StencilOp(GLbyte * pc) 1619{ 1620 CALL_StencilOp( GET_DISPATCH(), ( 1621 *(GLenum *)(pc + 0), 1622 *(GLenum *)(pc + 4), 1623 *(GLenum *)(pc + 8) 1624 ) ); 1625} 1626 1627void __glXDisp_DepthFunc(GLbyte * pc) 1628{ 1629 CALL_DepthFunc( GET_DISPATCH(), ( 1630 *(GLenum *)(pc + 0) 1631 ) ); 1632} 1633 1634void __glXDisp_PixelZoom(GLbyte * pc) 1635{ 1636 CALL_PixelZoom( GET_DISPATCH(), ( 1637 *(GLfloat *)(pc + 0), 1638 *(GLfloat *)(pc + 4) 1639 ) ); 1640} 1641 1642void __glXDisp_PixelTransferf(GLbyte * pc) 1643{ 1644 CALL_PixelTransferf( GET_DISPATCH(), ( 1645 *(GLenum *)(pc + 0), 1646 *(GLfloat *)(pc + 4) 1647 ) ); 1648} 1649 1650void __glXDisp_PixelTransferi(GLbyte * pc) 1651{ 1652 CALL_PixelTransferi( GET_DISPATCH(), ( 1653 *(GLenum *)(pc + 0), 1654 *(GLint *)(pc + 4) 1655 ) ); 1656} 1657 1658int __glXDisp_PixelStoref(__GLXclientState *cl, GLbyte *pc) 1659{ 1660 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 1661 int error; 1662 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 1663 1664 pc += __GLX_SINGLE_HDR_SIZE; 1665 if ( cx != NULL ) { 1666 CALL_PixelStoref( GET_DISPATCH(), ( 1667 *(GLenum *)(pc + 0), 1668 *(GLfloat *)(pc + 4) 1669 ) ); 1670 error = Success; 1671 } 1672 1673 return error; 1674} 1675 1676int __glXDisp_PixelStorei(__GLXclientState *cl, GLbyte *pc) 1677{ 1678 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 1679 int error; 1680 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 1681 1682 pc += __GLX_SINGLE_HDR_SIZE; 1683 if ( cx != NULL ) { 1684 CALL_PixelStorei( GET_DISPATCH(), ( 1685 *(GLenum *)(pc + 0), 1686 *(GLint *)(pc + 4) 1687 ) ); 1688 error = Success; 1689 } 1690 1691 return error; 1692} 1693 1694void __glXDisp_PixelMapfv(GLbyte * pc) 1695{ 1696 const GLsizei mapsize = *(GLsizei *)(pc + 4); 1697 1698 CALL_PixelMapfv( GET_DISPATCH(), ( 1699 *(GLenum *)(pc + 0), 1700 mapsize, 1701 (const GLfloat *)(pc + 8) 1702 ) ); 1703} 1704 1705void __glXDisp_PixelMapuiv(GLbyte * pc) 1706{ 1707 const GLsizei mapsize = *(GLsizei *)(pc + 4); 1708 1709 CALL_PixelMapuiv( GET_DISPATCH(), ( 1710 *(GLenum *)(pc + 0), 1711 mapsize, 1712 (const GLuint *)(pc + 8) 1713 ) ); 1714} 1715 1716void __glXDisp_PixelMapusv(GLbyte * pc) 1717{ 1718 const GLsizei mapsize = *(GLsizei *)(pc + 4); 1719 1720 CALL_PixelMapusv( GET_DISPATCH(), ( 1721 *(GLenum *)(pc + 0), 1722 mapsize, 1723 (const GLushort *)(pc + 8) 1724 ) ); 1725} 1726 1727void __glXDisp_ReadBuffer(GLbyte * pc) 1728{ 1729 CALL_ReadBuffer( GET_DISPATCH(), ( 1730 *(GLenum *)(pc + 0) 1731 ) ); 1732} 1733 1734void __glXDisp_CopyPixels(GLbyte * pc) 1735{ 1736 CALL_CopyPixels( GET_DISPATCH(), ( 1737 *(GLint *)(pc + 0), 1738 *(GLint *)(pc + 4), 1739 *(GLsizei *)(pc + 8), 1740 *(GLsizei *)(pc + 12), 1741 *(GLenum *)(pc + 16) 1742 ) ); 1743} 1744 1745void __glXDisp_DrawPixels(GLbyte * pc) 1746{ 1747 const GLvoid * const pixels = (const GLvoid *) (pc + 36); 1748 __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); 1749 1750 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes) ); 1751 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst) ); 1752 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength) ); 1753 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows) ); 1754 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels) ); 1755 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment) ); 1756 1757 CALL_DrawPixels( GET_DISPATCH(), ( 1758 *(GLsizei *)(pc + 20), 1759 *(GLsizei *)(pc + 24), 1760 *(GLenum *)(pc + 28), 1761 *(GLenum *)(pc + 32), 1762 pixels 1763 ) ); 1764} 1765 1766int __glXDisp_GetBooleanv(__GLXclientState *cl, GLbyte *pc) 1767{ 1768 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 1769 int error; 1770 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 1771 1772 pc += __GLX_SINGLE_HDR_SIZE; 1773 if ( cx != NULL ) { 1774 const GLenum pname = *(GLenum *)(pc + 0); 1775 1776 const GLuint compsize = __glGetBooleanv_size(pname); 1777 GLboolean answerBuffer[200]; 1778 GLboolean * params = __glXGetAnswerBuffer(cl, compsize, answerBuffer, sizeof(answerBuffer), 1); 1779 1780 if (params == NULL) return BadAlloc; 1781 __glXClearErrorOccured(); 1782 1783 CALL_GetBooleanv( GET_DISPATCH(), ( 1784 pname, 1785 params 1786 ) ); 1787 __glXSendReply(cl->client, params, compsize, 1, GL_FALSE, 0); 1788 error = Success; 1789 } 1790 1791 return error; 1792} 1793 1794int __glXDisp_GetClipPlane(__GLXclientState *cl, GLbyte *pc) 1795{ 1796 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 1797 int error; 1798 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 1799 1800 pc += __GLX_SINGLE_HDR_SIZE; 1801 if ( cx != NULL ) { 1802 GLdouble equation[4]; 1803 CALL_GetClipPlane( GET_DISPATCH(), ( 1804 *(GLenum *)(pc + 0), 1805 equation 1806 ) ); 1807 __glXSendReply(cl->client, equation, 4, 8, GL_TRUE, 0); 1808 error = Success; 1809 } 1810 1811 return error; 1812} 1813 1814int __glXDisp_GetDoublev(__GLXclientState *cl, GLbyte *pc) 1815{ 1816 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 1817 int error; 1818 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 1819 1820 pc += __GLX_SINGLE_HDR_SIZE; 1821 if ( cx != NULL ) { 1822 const GLenum pname = *(GLenum *)(pc + 0); 1823 1824 const GLuint compsize = __glGetDoublev_size(pname); 1825 GLdouble answerBuffer[200]; 1826 GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8); 1827 1828 if (params == NULL) return BadAlloc; 1829 __glXClearErrorOccured(); 1830 1831 CALL_GetDoublev( GET_DISPATCH(), ( 1832 pname, 1833 params 1834 ) ); 1835 __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0); 1836 error = Success; 1837 } 1838 1839 return error; 1840} 1841 1842int __glXDisp_GetError(__GLXclientState *cl, GLbyte *pc) 1843{ 1844 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 1845 int error; 1846 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 1847 1848 pc += __GLX_SINGLE_HDR_SIZE; 1849 if ( cx != NULL ) { 1850 GLenum retval; 1851 retval = CALL_GetError( GET_DISPATCH(), () ); 1852 __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); 1853 error = Success; 1854 } 1855 1856 return error; 1857} 1858 1859int __glXDisp_GetFloatv(__GLXclientState *cl, GLbyte *pc) 1860{ 1861 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 1862 int error; 1863 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 1864 1865 pc += __GLX_SINGLE_HDR_SIZE; 1866 if ( cx != NULL ) { 1867 const GLenum pname = *(GLenum *)(pc + 0); 1868 1869 const GLuint compsize = __glGetFloatv_size(pname); 1870 GLfloat answerBuffer[200]; 1871 GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 1872 1873 if (params == NULL) return BadAlloc; 1874 __glXClearErrorOccured(); 1875 1876 CALL_GetFloatv( GET_DISPATCH(), ( 1877 pname, 1878 params 1879 ) ); 1880 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 1881 error = Success; 1882 } 1883 1884 return error; 1885} 1886 1887int __glXDisp_GetIntegerv(__GLXclientState *cl, GLbyte *pc) 1888{ 1889 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 1890 int error; 1891 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 1892 1893 pc += __GLX_SINGLE_HDR_SIZE; 1894 if ( cx != NULL ) { 1895 const GLenum pname = *(GLenum *)(pc + 0); 1896 1897 const GLuint compsize = __glGetIntegerv_size(pname); 1898 GLint answerBuffer[200]; 1899 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 1900 1901 if (params == NULL) return BadAlloc; 1902 __glXClearErrorOccured(); 1903 1904 CALL_GetIntegerv( GET_DISPATCH(), ( 1905 pname, 1906 params 1907 ) ); 1908 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 1909 error = Success; 1910 } 1911 1912 return error; 1913} 1914 1915int __glXDisp_GetLightfv(__GLXclientState *cl, GLbyte *pc) 1916{ 1917 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 1918 int error; 1919 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 1920 1921 pc += __GLX_SINGLE_HDR_SIZE; 1922 if ( cx != NULL ) { 1923 const GLenum pname = *(GLenum *)(pc + 4); 1924 1925 const GLuint compsize = __glGetLightfv_size(pname); 1926 GLfloat answerBuffer[200]; 1927 GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 1928 1929 if (params == NULL) return BadAlloc; 1930 __glXClearErrorOccured(); 1931 1932 CALL_GetLightfv( GET_DISPATCH(), ( 1933 *(GLenum *)(pc + 0), 1934 pname, 1935 params 1936 ) ); 1937 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 1938 error = Success; 1939 } 1940 1941 return error; 1942} 1943 1944int __glXDisp_GetLightiv(__GLXclientState *cl, GLbyte *pc) 1945{ 1946 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 1947 int error; 1948 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 1949 1950 pc += __GLX_SINGLE_HDR_SIZE; 1951 if ( cx != NULL ) { 1952 const GLenum pname = *(GLenum *)(pc + 4); 1953 1954 const GLuint compsize = __glGetLightiv_size(pname); 1955 GLint answerBuffer[200]; 1956 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 1957 1958 if (params == NULL) return BadAlloc; 1959 __glXClearErrorOccured(); 1960 1961 CALL_GetLightiv( GET_DISPATCH(), ( 1962 *(GLenum *)(pc + 0), 1963 pname, 1964 params 1965 ) ); 1966 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 1967 error = Success; 1968 } 1969 1970 return error; 1971} 1972 1973int __glXDisp_GetMapdv(__GLXclientState *cl, GLbyte *pc) 1974{ 1975 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 1976 int error; 1977 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 1978 1979 pc += __GLX_SINGLE_HDR_SIZE; 1980 if ( cx != NULL ) { 1981 const GLenum target = *(GLenum *)(pc + 0); 1982 const GLenum query = *(GLenum *)(pc + 4); 1983 1984 const GLuint compsize = __glGetMapdv_size(target,query); 1985 GLdouble answerBuffer[200]; 1986 GLdouble * v = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8); 1987 1988 if (v == NULL) return BadAlloc; 1989 __glXClearErrorOccured(); 1990 1991 CALL_GetMapdv( GET_DISPATCH(), ( 1992 target, 1993 query, 1994 v 1995 ) ); 1996 __glXSendReply(cl->client, v, compsize, 8, GL_FALSE, 0); 1997 error = Success; 1998 } 1999 2000 return error; 2001} 2002 2003int __glXDisp_GetMapfv(__GLXclientState *cl, GLbyte *pc) 2004{ 2005 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2006 int error; 2007 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2008 2009 pc += __GLX_SINGLE_HDR_SIZE; 2010 if ( cx != NULL ) { 2011 const GLenum target = *(GLenum *)(pc + 0); 2012 const GLenum query = *(GLenum *)(pc + 4); 2013 2014 const GLuint compsize = __glGetMapfv_size(target,query); 2015 GLfloat answerBuffer[200]; 2016 GLfloat * v = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 2017 2018 if (v == NULL) return BadAlloc; 2019 __glXClearErrorOccured(); 2020 2021 CALL_GetMapfv( GET_DISPATCH(), ( 2022 target, 2023 query, 2024 v 2025 ) ); 2026 __glXSendReply(cl->client, v, compsize, 4, GL_FALSE, 0); 2027 error = Success; 2028 } 2029 2030 return error; 2031} 2032 2033int __glXDisp_GetMapiv(__GLXclientState *cl, GLbyte *pc) 2034{ 2035 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2036 int error; 2037 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2038 2039 pc += __GLX_SINGLE_HDR_SIZE; 2040 if ( cx != NULL ) { 2041 const GLenum target = *(GLenum *)(pc + 0); 2042 const GLenum query = *(GLenum *)(pc + 4); 2043 2044 const GLuint compsize = __glGetMapiv_size(target,query); 2045 GLint answerBuffer[200]; 2046 GLint * v = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 2047 2048 if (v == NULL) return BadAlloc; 2049 __glXClearErrorOccured(); 2050 2051 CALL_GetMapiv( GET_DISPATCH(), ( 2052 target, 2053 query, 2054 v 2055 ) ); 2056 __glXSendReply(cl->client, v, compsize, 4, GL_FALSE, 0); 2057 error = Success; 2058 } 2059 2060 return error; 2061} 2062 2063int __glXDisp_GetMaterialfv(__GLXclientState *cl, GLbyte *pc) 2064{ 2065 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2066 int error; 2067 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2068 2069 pc += __GLX_SINGLE_HDR_SIZE; 2070 if ( cx != NULL ) { 2071 const GLenum pname = *(GLenum *)(pc + 4); 2072 2073 const GLuint compsize = __glGetMaterialfv_size(pname); 2074 GLfloat answerBuffer[200]; 2075 GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 2076 2077 if (params == NULL) return BadAlloc; 2078 __glXClearErrorOccured(); 2079 2080 CALL_GetMaterialfv( GET_DISPATCH(), ( 2081 *(GLenum *)(pc + 0), 2082 pname, 2083 params 2084 ) ); 2085 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 2086 error = Success; 2087 } 2088 2089 return error; 2090} 2091 2092int __glXDisp_GetMaterialiv(__GLXclientState *cl, GLbyte *pc) 2093{ 2094 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2095 int error; 2096 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2097 2098 pc += __GLX_SINGLE_HDR_SIZE; 2099 if ( cx != NULL ) { 2100 const GLenum pname = *(GLenum *)(pc + 4); 2101 2102 const GLuint compsize = __glGetMaterialiv_size(pname); 2103 GLint answerBuffer[200]; 2104 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 2105 2106 if (params == NULL) return BadAlloc; 2107 __glXClearErrorOccured(); 2108 2109 CALL_GetMaterialiv( GET_DISPATCH(), ( 2110 *(GLenum *)(pc + 0), 2111 pname, 2112 params 2113 ) ); 2114 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 2115 error = Success; 2116 } 2117 2118 return error; 2119} 2120 2121int __glXDisp_GetPixelMapfv(__GLXclientState *cl, GLbyte *pc) 2122{ 2123 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2124 int error; 2125 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2126 2127 pc += __GLX_SINGLE_HDR_SIZE; 2128 if ( cx != NULL ) { 2129 const GLenum map = *(GLenum *)(pc + 0); 2130 2131 const GLuint compsize = __glGetPixelMapfv_size(map); 2132 GLfloat answerBuffer[200]; 2133 GLfloat * values = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 2134 2135 if (values == NULL) return BadAlloc; 2136 __glXClearErrorOccured(); 2137 2138 CALL_GetPixelMapfv( GET_DISPATCH(), ( 2139 map, 2140 values 2141 ) ); 2142 __glXSendReply(cl->client, values, compsize, 4, GL_FALSE, 0); 2143 error = Success; 2144 } 2145 2146 return error; 2147} 2148 2149int __glXDisp_GetPixelMapuiv(__GLXclientState *cl, GLbyte *pc) 2150{ 2151 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2152 int error; 2153 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2154 2155 pc += __GLX_SINGLE_HDR_SIZE; 2156 if ( cx != NULL ) { 2157 const GLenum map = *(GLenum *)(pc + 0); 2158 2159 const GLuint compsize = __glGetPixelMapuiv_size(map); 2160 GLuint answerBuffer[200]; 2161 GLuint * values = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 2162 2163 if (values == NULL) return BadAlloc; 2164 __glXClearErrorOccured(); 2165 2166 CALL_GetPixelMapuiv( GET_DISPATCH(), ( 2167 map, 2168 values 2169 ) ); 2170 __glXSendReply(cl->client, values, compsize, 4, GL_FALSE, 0); 2171 error = Success; 2172 } 2173 2174 return error; 2175} 2176 2177int __glXDisp_GetPixelMapusv(__GLXclientState *cl, GLbyte *pc) 2178{ 2179 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2180 int error; 2181 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2182 2183 pc += __GLX_SINGLE_HDR_SIZE; 2184 if ( cx != NULL ) { 2185 const GLenum map = *(GLenum *)(pc + 0); 2186 2187 const GLuint compsize = __glGetPixelMapusv_size(map); 2188 GLushort answerBuffer[200]; 2189 GLushort * values = __glXGetAnswerBuffer(cl, compsize * 2, answerBuffer, sizeof(answerBuffer), 2); 2190 2191 if (values == NULL) return BadAlloc; 2192 __glXClearErrorOccured(); 2193 2194 CALL_GetPixelMapusv( GET_DISPATCH(), ( 2195 map, 2196 values 2197 ) ); 2198 __glXSendReply(cl->client, values, compsize, 2, GL_FALSE, 0); 2199 error = Success; 2200 } 2201 2202 return error; 2203} 2204 2205int __glXDisp_GetTexEnvfv(__GLXclientState *cl, GLbyte *pc) 2206{ 2207 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2208 int error; 2209 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2210 2211 pc += __GLX_SINGLE_HDR_SIZE; 2212 if ( cx != NULL ) { 2213 const GLenum pname = *(GLenum *)(pc + 4); 2214 2215 const GLuint compsize = __glGetTexEnvfv_size(pname); 2216 GLfloat answerBuffer[200]; 2217 GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 2218 2219 if (params == NULL) return BadAlloc; 2220 __glXClearErrorOccured(); 2221 2222 CALL_GetTexEnvfv( GET_DISPATCH(), ( 2223 *(GLenum *)(pc + 0), 2224 pname, 2225 params 2226 ) ); 2227 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 2228 error = Success; 2229 } 2230 2231 return error; 2232} 2233 2234int __glXDisp_GetTexEnviv(__GLXclientState *cl, GLbyte *pc) 2235{ 2236 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2237 int error; 2238 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2239 2240 pc += __GLX_SINGLE_HDR_SIZE; 2241 if ( cx != NULL ) { 2242 const GLenum pname = *(GLenum *)(pc + 4); 2243 2244 const GLuint compsize = __glGetTexEnviv_size(pname); 2245 GLint answerBuffer[200]; 2246 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 2247 2248 if (params == NULL) return BadAlloc; 2249 __glXClearErrorOccured(); 2250 2251 CALL_GetTexEnviv( GET_DISPATCH(), ( 2252 *(GLenum *)(pc + 0), 2253 pname, 2254 params 2255 ) ); 2256 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 2257 error = Success; 2258 } 2259 2260 return error; 2261} 2262 2263int __glXDisp_GetTexGendv(__GLXclientState *cl, GLbyte *pc) 2264{ 2265 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2266 int error; 2267 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2268 2269 pc += __GLX_SINGLE_HDR_SIZE; 2270 if ( cx != NULL ) { 2271 const GLenum pname = *(GLenum *)(pc + 4); 2272 2273 const GLuint compsize = __glGetTexGendv_size(pname); 2274 GLdouble answerBuffer[200]; 2275 GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8); 2276 2277 if (params == NULL) return BadAlloc; 2278 __glXClearErrorOccured(); 2279 2280 CALL_GetTexGendv( GET_DISPATCH(), ( 2281 *(GLenum *)(pc + 0), 2282 pname, 2283 params 2284 ) ); 2285 __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0); 2286 error = Success; 2287 } 2288 2289 return error; 2290} 2291 2292int __glXDisp_GetTexGenfv(__GLXclientState *cl, GLbyte *pc) 2293{ 2294 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2295 int error; 2296 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2297 2298 pc += __GLX_SINGLE_HDR_SIZE; 2299 if ( cx != NULL ) { 2300 const GLenum pname = *(GLenum *)(pc + 4); 2301 2302 const GLuint compsize = __glGetTexGenfv_size(pname); 2303 GLfloat answerBuffer[200]; 2304 GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 2305 2306 if (params == NULL) return BadAlloc; 2307 __glXClearErrorOccured(); 2308 2309 CALL_GetTexGenfv( GET_DISPATCH(), ( 2310 *(GLenum *)(pc + 0), 2311 pname, 2312 params 2313 ) ); 2314 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 2315 error = Success; 2316 } 2317 2318 return error; 2319} 2320 2321int __glXDisp_GetTexGeniv(__GLXclientState *cl, GLbyte *pc) 2322{ 2323 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2324 int error; 2325 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2326 2327 pc += __GLX_SINGLE_HDR_SIZE; 2328 if ( cx != NULL ) { 2329 const GLenum pname = *(GLenum *)(pc + 4); 2330 2331 const GLuint compsize = __glGetTexGeniv_size(pname); 2332 GLint answerBuffer[200]; 2333 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 2334 2335 if (params == NULL) return BadAlloc; 2336 __glXClearErrorOccured(); 2337 2338 CALL_GetTexGeniv( GET_DISPATCH(), ( 2339 *(GLenum *)(pc + 0), 2340 pname, 2341 params 2342 ) ); 2343 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 2344 error = Success; 2345 } 2346 2347 return error; 2348} 2349 2350int __glXDisp_GetTexParameterfv(__GLXclientState *cl, GLbyte *pc) 2351{ 2352 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2353 int error; 2354 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2355 2356 pc += __GLX_SINGLE_HDR_SIZE; 2357 if ( cx != NULL ) { 2358 const GLenum pname = *(GLenum *)(pc + 4); 2359 2360 const GLuint compsize = __glGetTexParameterfv_size(pname); 2361 GLfloat answerBuffer[200]; 2362 GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 2363 2364 if (params == NULL) return BadAlloc; 2365 __glXClearErrorOccured(); 2366 2367 CALL_GetTexParameterfv( GET_DISPATCH(), ( 2368 *(GLenum *)(pc + 0), 2369 pname, 2370 params 2371 ) ); 2372 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 2373 error = Success; 2374 } 2375 2376 return error; 2377} 2378 2379int __glXDisp_GetTexParameteriv(__GLXclientState *cl, GLbyte *pc) 2380{ 2381 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2382 int error; 2383 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2384 2385 pc += __GLX_SINGLE_HDR_SIZE; 2386 if ( cx != NULL ) { 2387 const GLenum pname = *(GLenum *)(pc + 4); 2388 2389 const GLuint compsize = __glGetTexParameteriv_size(pname); 2390 GLint answerBuffer[200]; 2391 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 2392 2393 if (params == NULL) return BadAlloc; 2394 __glXClearErrorOccured(); 2395 2396 CALL_GetTexParameteriv( GET_DISPATCH(), ( 2397 *(GLenum *)(pc + 0), 2398 pname, 2399 params 2400 ) ); 2401 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 2402 error = Success; 2403 } 2404 2405 return error; 2406} 2407 2408int __glXDisp_GetTexLevelParameterfv(__GLXclientState *cl, GLbyte *pc) 2409{ 2410 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2411 int error; 2412 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2413 2414 pc += __GLX_SINGLE_HDR_SIZE; 2415 if ( cx != NULL ) { 2416 const GLenum pname = *(GLenum *)(pc + 8); 2417 2418 const GLuint compsize = __glGetTexLevelParameterfv_size(pname); 2419 GLfloat answerBuffer[200]; 2420 GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 2421 2422 if (params == NULL) return BadAlloc; 2423 __glXClearErrorOccured(); 2424 2425 CALL_GetTexLevelParameterfv( GET_DISPATCH(), ( 2426 *(GLenum *)(pc + 0), 2427 *(GLint *)(pc + 4), 2428 pname, 2429 params 2430 ) ); 2431 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 2432 error = Success; 2433 } 2434 2435 return error; 2436} 2437 2438int __glXDisp_GetTexLevelParameteriv(__GLXclientState *cl, GLbyte *pc) 2439{ 2440 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2441 int error; 2442 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2443 2444 pc += __GLX_SINGLE_HDR_SIZE; 2445 if ( cx != NULL ) { 2446 const GLenum pname = *(GLenum *)(pc + 8); 2447 2448 const GLuint compsize = __glGetTexLevelParameteriv_size(pname); 2449 GLint answerBuffer[200]; 2450 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 2451 2452 if (params == NULL) return BadAlloc; 2453 __glXClearErrorOccured(); 2454 2455 CALL_GetTexLevelParameteriv( GET_DISPATCH(), ( 2456 *(GLenum *)(pc + 0), 2457 *(GLint *)(pc + 4), 2458 pname, 2459 params 2460 ) ); 2461 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 2462 error = Success; 2463 } 2464 2465 return error; 2466} 2467 2468int __glXDisp_IsEnabled(__GLXclientState *cl, GLbyte *pc) 2469{ 2470 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2471 int error; 2472 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2473 2474 pc += __GLX_SINGLE_HDR_SIZE; 2475 if ( cx != NULL ) { 2476 GLboolean retval; 2477 retval = CALL_IsEnabled( GET_DISPATCH(), ( 2478 *(GLenum *)(pc + 0) 2479 ) ); 2480 __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); 2481 error = Success; 2482 } 2483 2484 return error; 2485} 2486 2487int __glXDisp_IsList(__GLXclientState *cl, GLbyte *pc) 2488{ 2489 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2490 int error; 2491 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2492 2493 pc += __GLX_SINGLE_HDR_SIZE; 2494 if ( cx != NULL ) { 2495 GLboolean retval; 2496 retval = CALL_IsList( GET_DISPATCH(), ( 2497 *(GLuint *)(pc + 0) 2498 ) ); 2499 __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); 2500 error = Success; 2501 } 2502 2503 return error; 2504} 2505 2506void __glXDisp_DepthRange(GLbyte * pc) 2507{ 2508#ifdef __GLX_ALIGN64 2509 if ((unsigned long)(pc) & 7) { 2510 (void) memmove(pc-4, pc, 16); 2511 pc -= 4; 2512 } 2513#endif 2514 2515 CALL_DepthRange( GET_DISPATCH(), ( 2516 *(GLclampd *)(pc + 0), 2517 *(GLclampd *)(pc + 8) 2518 ) ); 2519} 2520 2521void __glXDisp_Frustum(GLbyte * pc) 2522{ 2523#ifdef __GLX_ALIGN64 2524 if ((unsigned long)(pc) & 7) { 2525 (void) memmove(pc-4, pc, 48); 2526 pc -= 4; 2527 } 2528#endif 2529 2530 CALL_Frustum( GET_DISPATCH(), ( 2531 *(GLdouble *)(pc + 0), 2532 *(GLdouble *)(pc + 8), 2533 *(GLdouble *)(pc + 16), 2534 *(GLdouble *)(pc + 24), 2535 *(GLdouble *)(pc + 32), 2536 *(GLdouble *)(pc + 40) 2537 ) ); 2538} 2539 2540void __glXDisp_LoadIdentity(GLbyte * pc) 2541{ 2542 CALL_LoadIdentity( GET_DISPATCH(), () ); 2543} 2544 2545void __glXDisp_LoadMatrixf(GLbyte * pc) 2546{ 2547 CALL_LoadMatrixf( GET_DISPATCH(), ( 2548 (const GLfloat *)(pc + 0) 2549 ) ); 2550} 2551 2552void __glXDisp_LoadMatrixd(GLbyte * pc) 2553{ 2554#ifdef __GLX_ALIGN64 2555 if ((unsigned long)(pc) & 7) { 2556 (void) memmove(pc-4, pc, 128); 2557 pc -= 4; 2558 } 2559#endif 2560 2561 CALL_LoadMatrixd( GET_DISPATCH(), ( 2562 (const GLdouble *)(pc + 0) 2563 ) ); 2564} 2565 2566void __glXDisp_MatrixMode(GLbyte * pc) 2567{ 2568 CALL_MatrixMode( GET_DISPATCH(), ( 2569 *(GLenum *)(pc + 0) 2570 ) ); 2571} 2572 2573void __glXDisp_MultMatrixf(GLbyte * pc) 2574{ 2575 CALL_MultMatrixf( GET_DISPATCH(), ( 2576 (const GLfloat *)(pc + 0) 2577 ) ); 2578} 2579 2580void __glXDisp_MultMatrixd(GLbyte * pc) 2581{ 2582#ifdef __GLX_ALIGN64 2583 if ((unsigned long)(pc) & 7) { 2584 (void) memmove(pc-4, pc, 128); 2585 pc -= 4; 2586 } 2587#endif 2588 2589 CALL_MultMatrixd( GET_DISPATCH(), ( 2590 (const GLdouble *)(pc + 0) 2591 ) ); 2592} 2593 2594void __glXDisp_Ortho(GLbyte * pc) 2595{ 2596#ifdef __GLX_ALIGN64 2597 if ((unsigned long)(pc) & 7) { 2598 (void) memmove(pc-4, pc, 48); 2599 pc -= 4; 2600 } 2601#endif 2602 2603 CALL_Ortho( GET_DISPATCH(), ( 2604 *(GLdouble *)(pc + 0), 2605 *(GLdouble *)(pc + 8), 2606 *(GLdouble *)(pc + 16), 2607 *(GLdouble *)(pc + 24), 2608 *(GLdouble *)(pc + 32), 2609 *(GLdouble *)(pc + 40) 2610 ) ); 2611} 2612 2613void __glXDisp_PopMatrix(GLbyte * pc) 2614{ 2615 CALL_PopMatrix( GET_DISPATCH(), () ); 2616} 2617 2618void __glXDisp_PushMatrix(GLbyte * pc) 2619{ 2620 CALL_PushMatrix( GET_DISPATCH(), () ); 2621} 2622 2623void __glXDisp_Rotated(GLbyte * pc) 2624{ 2625#ifdef __GLX_ALIGN64 2626 if ((unsigned long)(pc) & 7) { 2627 (void) memmove(pc-4, pc, 32); 2628 pc -= 4; 2629 } 2630#endif 2631 2632 CALL_Rotated( GET_DISPATCH(), ( 2633 *(GLdouble *)(pc + 0), 2634 *(GLdouble *)(pc + 8), 2635 *(GLdouble *)(pc + 16), 2636 *(GLdouble *)(pc + 24) 2637 ) ); 2638} 2639 2640void __glXDisp_Rotatef(GLbyte * pc) 2641{ 2642 CALL_Rotatef( GET_DISPATCH(), ( 2643 *(GLfloat *)(pc + 0), 2644 *(GLfloat *)(pc + 4), 2645 *(GLfloat *)(pc + 8), 2646 *(GLfloat *)(pc + 12) 2647 ) ); 2648} 2649 2650void __glXDisp_Scaled(GLbyte * pc) 2651{ 2652#ifdef __GLX_ALIGN64 2653 if ((unsigned long)(pc) & 7) { 2654 (void) memmove(pc-4, pc, 24); 2655 pc -= 4; 2656 } 2657#endif 2658 2659 CALL_Scaled( GET_DISPATCH(), ( 2660 *(GLdouble *)(pc + 0), 2661 *(GLdouble *)(pc + 8), 2662 *(GLdouble *)(pc + 16) 2663 ) ); 2664} 2665 2666void __glXDisp_Scalef(GLbyte * pc) 2667{ 2668 CALL_Scalef( GET_DISPATCH(), ( 2669 *(GLfloat *)(pc + 0), 2670 *(GLfloat *)(pc + 4), 2671 *(GLfloat *)(pc + 8) 2672 ) ); 2673} 2674 2675void __glXDisp_Translated(GLbyte * pc) 2676{ 2677#ifdef __GLX_ALIGN64 2678 if ((unsigned long)(pc) & 7) { 2679 (void) memmove(pc-4, pc, 24); 2680 pc -= 4; 2681 } 2682#endif 2683 2684 CALL_Translated( GET_DISPATCH(), ( 2685 *(GLdouble *)(pc + 0), 2686 *(GLdouble *)(pc + 8), 2687 *(GLdouble *)(pc + 16) 2688 ) ); 2689} 2690 2691void __glXDisp_Translatef(GLbyte * pc) 2692{ 2693 CALL_Translatef( GET_DISPATCH(), ( 2694 *(GLfloat *)(pc + 0), 2695 *(GLfloat *)(pc + 4), 2696 *(GLfloat *)(pc + 8) 2697 ) ); 2698} 2699 2700void __glXDisp_Viewport(GLbyte * pc) 2701{ 2702 CALL_Viewport( GET_DISPATCH(), ( 2703 *(GLint *)(pc + 0), 2704 *(GLint *)(pc + 4), 2705 *(GLsizei *)(pc + 8), 2706 *(GLsizei *)(pc + 12) 2707 ) ); 2708} 2709 2710void __glXDisp_BindTexture(GLbyte * pc) 2711{ 2712 CALL_BindTexture( GET_DISPATCH(), ( 2713 *(GLenum *)(pc + 0), 2714 *(GLuint *)(pc + 4) 2715 ) ); 2716} 2717 2718void __glXDisp_Indexubv(GLbyte * pc) 2719{ 2720 CALL_Indexubv( GET_DISPATCH(), ( 2721 (const GLubyte *)(pc + 0) 2722 ) ); 2723} 2724 2725void __glXDisp_PolygonOffset(GLbyte * pc) 2726{ 2727 CALL_PolygonOffset( GET_DISPATCH(), ( 2728 *(GLfloat *)(pc + 0), 2729 *(GLfloat *)(pc + 4) 2730 ) ); 2731} 2732 2733int __glXDisp_AreTexturesResident(__GLXclientState *cl, GLbyte *pc) 2734{ 2735 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2736 int error; 2737 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2738 2739 pc += __GLX_SINGLE_HDR_SIZE; 2740 if ( cx != NULL ) { 2741 const GLsizei n = *(GLsizei *)(pc + 0); 2742 2743 GLboolean retval; 2744 GLboolean answerBuffer[200]; 2745 GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1); 2746 retval = CALL_AreTexturesResident( GET_DISPATCH(), ( 2747 n, 2748 (const GLuint *)(pc + 4), 2749 residences 2750 ) ); 2751 __glXSendReply(cl->client, residences, n, 1, GL_TRUE, retval); 2752 error = Success; 2753 } 2754 2755 return error; 2756} 2757 2758int __glXDisp_AreTexturesResidentEXT(__GLXclientState *cl, GLbyte *pc) 2759{ 2760 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 2761 int error; 2762 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2763 2764 pc += __GLX_VENDPRIV_HDR_SIZE; 2765 if ( cx != NULL ) { 2766 const GLsizei n = *(GLsizei *)(pc + 0); 2767 2768 GLboolean retval; 2769 GLboolean answerBuffer[200]; 2770 GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1); 2771 retval = CALL_AreTexturesResident( GET_DISPATCH(), ( 2772 n, 2773 (const GLuint *)(pc + 4), 2774 residences 2775 ) ); 2776 __glXSendReply(cl->client, residences, n, 1, GL_TRUE, retval); 2777 error = Success; 2778 } 2779 2780 return error; 2781} 2782 2783void __glXDisp_CopyTexImage1D(GLbyte * pc) 2784{ 2785 CALL_CopyTexImage1D( GET_DISPATCH(), ( 2786 *(GLenum *)(pc + 0), 2787 *(GLint *)(pc + 4), 2788 *(GLenum *)(pc + 8), 2789 *(GLint *)(pc + 12), 2790 *(GLint *)(pc + 16), 2791 *(GLsizei *)(pc + 20), 2792 *(GLint *)(pc + 24) 2793 ) ); 2794} 2795 2796void __glXDisp_CopyTexImage2D(GLbyte * pc) 2797{ 2798 CALL_CopyTexImage2D( GET_DISPATCH(), ( 2799 *(GLenum *)(pc + 0), 2800 *(GLint *)(pc + 4), 2801 *(GLenum *)(pc + 8), 2802 *(GLint *)(pc + 12), 2803 *(GLint *)(pc + 16), 2804 *(GLsizei *)(pc + 20), 2805 *(GLsizei *)(pc + 24), 2806 *(GLint *)(pc + 28) 2807 ) ); 2808} 2809 2810void __glXDisp_CopyTexSubImage1D(GLbyte * pc) 2811{ 2812 CALL_CopyTexSubImage1D( GET_DISPATCH(), ( 2813 *(GLenum *)(pc + 0), 2814 *(GLint *)(pc + 4), 2815 *(GLint *)(pc + 8), 2816 *(GLint *)(pc + 12), 2817 *(GLint *)(pc + 16), 2818 *(GLsizei *)(pc + 20) 2819 ) ); 2820} 2821 2822void __glXDisp_CopyTexSubImage2D(GLbyte * pc) 2823{ 2824 CALL_CopyTexSubImage2D( GET_DISPATCH(), ( 2825 *(GLenum *)(pc + 0), 2826 *(GLint *)(pc + 4), 2827 *(GLint *)(pc + 8), 2828 *(GLint *)(pc + 12), 2829 *(GLint *)(pc + 16), 2830 *(GLint *)(pc + 20), 2831 *(GLsizei *)(pc + 24), 2832 *(GLsizei *)(pc + 28) 2833 ) ); 2834} 2835 2836int __glXDisp_DeleteTextures(__GLXclientState *cl, GLbyte *pc) 2837{ 2838 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2839 int error; 2840 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2841 2842 pc += __GLX_SINGLE_HDR_SIZE; 2843 if ( cx != NULL ) { 2844 const GLsizei n = *(GLsizei *)(pc + 0); 2845 2846 CALL_DeleteTextures( GET_DISPATCH(), ( 2847 n, 2848 (const GLuint *)(pc + 4) 2849 ) ); 2850 error = Success; 2851 } 2852 2853 return error; 2854} 2855 2856int __glXDisp_DeleteTexturesEXT(__GLXclientState *cl, GLbyte *pc) 2857{ 2858 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 2859 int error; 2860 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2861 2862 pc += __GLX_VENDPRIV_HDR_SIZE; 2863 if ( cx != NULL ) { 2864 const GLsizei n = *(GLsizei *)(pc + 0); 2865 2866 CALL_DeleteTextures( GET_DISPATCH(), ( 2867 n, 2868 (const GLuint *)(pc + 4) 2869 ) ); 2870 error = Success; 2871 } 2872 2873 return error; 2874} 2875 2876int __glXDisp_GenTextures(__GLXclientState *cl, GLbyte *pc) 2877{ 2878 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2879 int error; 2880 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2881 2882 pc += __GLX_SINGLE_HDR_SIZE; 2883 if ( cx != NULL ) { 2884 const GLsizei n = *(GLsizei *)(pc + 0); 2885 2886 GLuint answerBuffer[200]; 2887 GLuint * textures = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4); 2888 CALL_GenTextures( GET_DISPATCH(), ( 2889 n, 2890 textures 2891 ) ); 2892 __glXSendReply(cl->client, textures, n, 4, GL_TRUE, 0); 2893 error = Success; 2894 } 2895 2896 return error; 2897} 2898 2899int __glXDisp_GenTexturesEXT(__GLXclientState *cl, GLbyte *pc) 2900{ 2901 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 2902 int error; 2903 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2904 2905 pc += __GLX_VENDPRIV_HDR_SIZE; 2906 if ( cx != NULL ) { 2907 const GLsizei n = *(GLsizei *)(pc + 0); 2908 2909 GLuint answerBuffer[200]; 2910 GLuint * textures = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4); 2911 CALL_GenTextures( GET_DISPATCH(), ( 2912 n, 2913 textures 2914 ) ); 2915 __glXSendReply(cl->client, textures, n, 4, GL_TRUE, 0); 2916 error = Success; 2917 } 2918 2919 return error; 2920} 2921 2922int __glXDisp_IsTexture(__GLXclientState *cl, GLbyte *pc) 2923{ 2924 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 2925 int error; 2926 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2927 2928 pc += __GLX_SINGLE_HDR_SIZE; 2929 if ( cx != NULL ) { 2930 GLboolean retval; 2931 retval = CALL_IsTexture( GET_DISPATCH(), ( 2932 *(GLuint *)(pc + 0) 2933 ) ); 2934 __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); 2935 error = Success; 2936 } 2937 2938 return error; 2939} 2940 2941int __glXDisp_IsTextureEXT(__GLXclientState *cl, GLbyte *pc) 2942{ 2943 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 2944 int error; 2945 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 2946 2947 pc += __GLX_VENDPRIV_HDR_SIZE; 2948 if ( cx != NULL ) { 2949 GLboolean retval; 2950 retval = CALL_IsTexture( GET_DISPATCH(), ( 2951 *(GLuint *)(pc + 0) 2952 ) ); 2953 __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); 2954 error = Success; 2955 } 2956 2957 return error; 2958} 2959 2960void __glXDisp_PrioritizeTextures(GLbyte * pc) 2961{ 2962 const GLsizei n = *(GLsizei *)(pc + 0); 2963 2964 CALL_PrioritizeTextures( GET_DISPATCH(), ( 2965 n, 2966 (const GLuint *)(pc + 4), 2967 (const GLclampf *)(pc + 4) 2968 ) ); 2969} 2970 2971void __glXDisp_TexSubImage1D(GLbyte * pc) 2972{ 2973 const GLvoid * const pixels = (const GLvoid *) (pc + 56); 2974 __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); 2975 2976 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes) ); 2977 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst) ); 2978 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength) ); 2979 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows) ); 2980 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels) ); 2981 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment) ); 2982 2983 CALL_TexSubImage1D( GET_DISPATCH(), ( 2984 *(GLenum *)(pc + 20), 2985 *(GLint *)(pc + 24), 2986 *(GLint *)(pc + 28), 2987 *(GLsizei *)(pc + 36), 2988 *(GLenum *)(pc + 44), 2989 *(GLenum *)(pc + 48), 2990 pixels 2991 ) ); 2992} 2993 2994void __glXDisp_TexSubImage2D(GLbyte * pc) 2995{ 2996 const GLvoid * const pixels = (const GLvoid *) (pc + 56); 2997 __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); 2998 2999 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes) ); 3000 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst) ); 3001 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength) ); 3002 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows) ); 3003 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels) ); 3004 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment) ); 3005 3006 CALL_TexSubImage2D( GET_DISPATCH(), ( 3007 *(GLenum *)(pc + 20), 3008 *(GLint *)(pc + 24), 3009 *(GLint *)(pc + 28), 3010 *(GLint *)(pc + 32), 3011 *(GLsizei *)(pc + 36), 3012 *(GLsizei *)(pc + 40), 3013 *(GLenum *)(pc + 44), 3014 *(GLenum *)(pc + 48), 3015 pixels 3016 ) ); 3017} 3018 3019void __glXDisp_BlendColor(GLbyte * pc) 3020{ 3021 CALL_BlendColor( GET_DISPATCH(), ( 3022 *(GLclampf *)(pc + 0), 3023 *(GLclampf *)(pc + 4), 3024 *(GLclampf *)(pc + 8), 3025 *(GLclampf *)(pc + 12) 3026 ) ); 3027} 3028 3029void __glXDisp_BlendEquation(GLbyte * pc) 3030{ 3031 CALL_BlendEquation( GET_DISPATCH(), ( 3032 *(GLenum *)(pc + 0) 3033 ) ); 3034} 3035 3036void __glXDisp_ColorTable(GLbyte * pc) 3037{ 3038 const GLvoid * const table = (const GLvoid *) (pc + 40); 3039 __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); 3040 3041 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes) ); 3042 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst) ); 3043 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength) ); 3044 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows) ); 3045 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels) ); 3046 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment) ); 3047 3048 CALL_ColorTable( GET_DISPATCH(), ( 3049 *(GLenum *)(pc + 20), 3050 *(GLenum *)(pc + 24), 3051 *(GLsizei *)(pc + 28), 3052 *(GLenum *)(pc + 32), 3053 *(GLenum *)(pc + 36), 3054 table 3055 ) ); 3056} 3057 3058void __glXDisp_ColorTableParameterfv(GLbyte * pc) 3059{ 3060 const GLenum pname = *(GLenum *)(pc + 4); 3061 const GLfloat * params; 3062 3063 params = (const GLfloat *) (pc + 8); 3064 3065 CALL_ColorTableParameterfv( GET_DISPATCH(), ( 3066 *(GLenum *)(pc + 0), 3067 pname, 3068 params 3069 ) ); 3070} 3071 3072void __glXDisp_ColorTableParameteriv(GLbyte * pc) 3073{ 3074 const GLenum pname = *(GLenum *)(pc + 4); 3075 const GLint * params; 3076 3077 params = (const GLint *) (pc + 8); 3078 3079 CALL_ColorTableParameteriv( GET_DISPATCH(), ( 3080 *(GLenum *)(pc + 0), 3081 pname, 3082 params 3083 ) ); 3084} 3085 3086void __glXDisp_CopyColorTable(GLbyte * pc) 3087{ 3088 CALL_CopyColorTable( GET_DISPATCH(), ( 3089 *(GLenum *)(pc + 0), 3090 *(GLenum *)(pc + 4), 3091 *(GLint *)(pc + 8), 3092 *(GLint *)(pc + 12), 3093 *(GLsizei *)(pc + 16) 3094 ) ); 3095} 3096 3097int __glXDisp_GetColorTableParameterfv(__GLXclientState *cl, GLbyte *pc) 3098{ 3099 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 3100 int error; 3101 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 3102 3103 pc += __GLX_SINGLE_HDR_SIZE; 3104 if ( cx != NULL ) { 3105 const GLenum pname = *(GLenum *)(pc + 4); 3106 3107 const GLuint compsize = __glGetColorTableParameterfv_size(pname); 3108 GLfloat answerBuffer[200]; 3109 GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 3110 3111 if (params == NULL) return BadAlloc; 3112 __glXClearErrorOccured(); 3113 3114 CALL_GetColorTableParameterfv( GET_DISPATCH(), ( 3115 *(GLenum *)(pc + 0), 3116 pname, 3117 params 3118 ) ); 3119 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 3120 error = Success; 3121 } 3122 3123 return error; 3124} 3125 3126int __glXDisp_GetColorTableParameterfvSGI(__GLXclientState *cl, GLbyte *pc) 3127{ 3128 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 3129 int error; 3130 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 3131 3132 pc += __GLX_VENDPRIV_HDR_SIZE; 3133 if ( cx != NULL ) { 3134 const GLenum pname = *(GLenum *)(pc + 4); 3135 3136 const GLuint compsize = __glGetColorTableParameterfv_size(pname); 3137 GLfloat answerBuffer[200]; 3138 GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 3139 3140 if (params == NULL) return BadAlloc; 3141 __glXClearErrorOccured(); 3142 3143 CALL_GetColorTableParameterfv( GET_DISPATCH(), ( 3144 *(GLenum *)(pc + 0), 3145 pname, 3146 params 3147 ) ); 3148 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 3149 error = Success; 3150 } 3151 3152 return error; 3153} 3154 3155int __glXDisp_GetColorTableParameteriv(__GLXclientState *cl, GLbyte *pc) 3156{ 3157 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 3158 int error; 3159 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 3160 3161 pc += __GLX_SINGLE_HDR_SIZE; 3162 if ( cx != NULL ) { 3163 const GLenum pname = *(GLenum *)(pc + 4); 3164 3165 const GLuint compsize = __glGetColorTableParameteriv_size(pname); 3166 GLint answerBuffer[200]; 3167 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 3168 3169 if (params == NULL) return BadAlloc; 3170 __glXClearErrorOccured(); 3171 3172 CALL_GetColorTableParameteriv( GET_DISPATCH(), ( 3173 *(GLenum *)(pc + 0), 3174 pname, 3175 params 3176 ) ); 3177 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 3178 error = Success; 3179 } 3180 3181 return error; 3182} 3183 3184int __glXDisp_GetColorTableParameterivSGI(__GLXclientState *cl, GLbyte *pc) 3185{ 3186 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 3187 int error; 3188 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 3189 3190 pc += __GLX_VENDPRIV_HDR_SIZE; 3191 if ( cx != NULL ) { 3192 const GLenum pname = *(GLenum *)(pc + 4); 3193 3194 const GLuint compsize = __glGetColorTableParameteriv_size(pname); 3195 GLint answerBuffer[200]; 3196 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 3197 3198 if (params == NULL) return BadAlloc; 3199 __glXClearErrorOccured(); 3200 3201 CALL_GetColorTableParameteriv( GET_DISPATCH(), ( 3202 *(GLenum *)(pc + 0), 3203 pname, 3204 params 3205 ) ); 3206 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 3207 error = Success; 3208 } 3209 3210 return error; 3211} 3212 3213void __glXDisp_ColorSubTable(GLbyte * pc) 3214{ 3215 const GLvoid * const data = (const GLvoid *) (pc + 40); 3216 __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); 3217 3218 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes) ); 3219 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst) ); 3220 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength) ); 3221 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows) ); 3222 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels) ); 3223 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment) ); 3224 3225 CALL_ColorSubTable( GET_DISPATCH(), ( 3226 *(GLenum *)(pc + 20), 3227 *(GLsizei *)(pc + 24), 3228 *(GLsizei *)(pc + 28), 3229 *(GLenum *)(pc + 32), 3230 *(GLenum *)(pc + 36), 3231 data 3232 ) ); 3233} 3234 3235void __glXDisp_CopyColorSubTable(GLbyte * pc) 3236{ 3237 CALL_CopyColorSubTable( GET_DISPATCH(), ( 3238 *(GLenum *)(pc + 0), 3239 *(GLsizei *)(pc + 4), 3240 *(GLint *)(pc + 8), 3241 *(GLint *)(pc + 12), 3242 *(GLsizei *)(pc + 16) 3243 ) ); 3244} 3245 3246void __glXDisp_ConvolutionFilter1D(GLbyte * pc) 3247{ 3248 const GLvoid * const image = (const GLvoid *) (pc + 44); 3249 __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); 3250 3251 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes) ); 3252 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst) ); 3253 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength) ); 3254 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows) ); 3255 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels) ); 3256 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment) ); 3257 3258 CALL_ConvolutionFilter1D( GET_DISPATCH(), ( 3259 *(GLenum *)(pc + 20), 3260 *(GLenum *)(pc + 24), 3261 *(GLsizei *)(pc + 28), 3262 *(GLenum *)(pc + 36), 3263 *(GLenum *)(pc + 40), 3264 image 3265 ) ); 3266} 3267 3268void __glXDisp_ConvolutionFilter2D(GLbyte * pc) 3269{ 3270 const GLvoid * const image = (const GLvoid *) (pc + 44); 3271 __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc); 3272 3273 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes) ); 3274 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst) ); 3275 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength) ); 3276 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows) ); 3277 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels) ); 3278 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment) ); 3279 3280 CALL_ConvolutionFilter2D( GET_DISPATCH(), ( 3281 *(GLenum *)(pc + 20), 3282 *(GLenum *)(pc + 24), 3283 *(GLsizei *)(pc + 28), 3284 *(GLsizei *)(pc + 32), 3285 *(GLenum *)(pc + 36), 3286 *(GLenum *)(pc + 40), 3287 image 3288 ) ); 3289} 3290 3291void __glXDisp_ConvolutionParameterf(GLbyte * pc) 3292{ 3293 CALL_ConvolutionParameterf( GET_DISPATCH(), ( 3294 *(GLenum *)(pc + 0), 3295 *(GLenum *)(pc + 4), 3296 *(GLfloat *)(pc + 8) 3297 ) ); 3298} 3299 3300void __glXDisp_ConvolutionParameterfv(GLbyte * pc) 3301{ 3302 const GLenum pname = *(GLenum *)(pc + 4); 3303 const GLfloat * params; 3304 3305 params = (const GLfloat *) (pc + 8); 3306 3307 CALL_ConvolutionParameterfv( GET_DISPATCH(), ( 3308 *(GLenum *)(pc + 0), 3309 pname, 3310 params 3311 ) ); 3312} 3313 3314void __glXDisp_ConvolutionParameteri(GLbyte * pc) 3315{ 3316 CALL_ConvolutionParameteri( GET_DISPATCH(), ( 3317 *(GLenum *)(pc + 0), 3318 *(GLenum *)(pc + 4), 3319 *(GLint *)(pc + 8) 3320 ) ); 3321} 3322 3323void __glXDisp_ConvolutionParameteriv(GLbyte * pc) 3324{ 3325 const GLenum pname = *(GLenum *)(pc + 4); 3326 const GLint * params; 3327 3328 params = (const GLint *) (pc + 8); 3329 3330 CALL_ConvolutionParameteriv( GET_DISPATCH(), ( 3331 *(GLenum *)(pc + 0), 3332 pname, 3333 params 3334 ) ); 3335} 3336 3337void __glXDisp_CopyConvolutionFilter1D(GLbyte * pc) 3338{ 3339 CALL_CopyConvolutionFilter1D( GET_DISPATCH(), ( 3340 *(GLenum *)(pc + 0), 3341 *(GLenum *)(pc + 4), 3342 *(GLint *)(pc + 8), 3343 *(GLint *)(pc + 12), 3344 *(GLsizei *)(pc + 16) 3345 ) ); 3346} 3347 3348void __glXDisp_CopyConvolutionFilter2D(GLbyte * pc) 3349{ 3350 CALL_CopyConvolutionFilter2D( GET_DISPATCH(), ( 3351 *(GLenum *)(pc + 0), 3352 *(GLenum *)(pc + 4), 3353 *(GLint *)(pc + 8), 3354 *(GLint *)(pc + 12), 3355 *(GLsizei *)(pc + 16), 3356 *(GLsizei *)(pc + 20) 3357 ) ); 3358} 3359 3360int __glXDisp_GetConvolutionParameterfv(__GLXclientState *cl, GLbyte *pc) 3361{ 3362 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 3363 int error; 3364 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 3365 3366 pc += __GLX_SINGLE_HDR_SIZE; 3367 if ( cx != NULL ) { 3368 const GLenum pname = *(GLenum *)(pc + 4); 3369 3370 const GLuint compsize = __glGetConvolutionParameterfv_size(pname); 3371 GLfloat answerBuffer[200]; 3372 GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 3373 3374 if (params == NULL) return BadAlloc; 3375 __glXClearErrorOccured(); 3376 3377 CALL_GetConvolutionParameterfv( GET_DISPATCH(), ( 3378 *(GLenum *)(pc + 0), 3379 pname, 3380 params 3381 ) ); 3382 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 3383 error = Success; 3384 } 3385 3386 return error; 3387} 3388 3389int __glXDisp_GetConvolutionParameterfvEXT(__GLXclientState *cl, GLbyte *pc) 3390{ 3391 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 3392 int error; 3393 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 3394 3395 pc += __GLX_VENDPRIV_HDR_SIZE; 3396 if ( cx != NULL ) { 3397 const GLenum pname = *(GLenum *)(pc + 4); 3398 3399 const GLuint compsize = __glGetConvolutionParameterfv_size(pname); 3400 GLfloat answerBuffer[200]; 3401 GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 3402 3403 if (params == NULL) return BadAlloc; 3404 __glXClearErrorOccured(); 3405 3406 CALL_GetConvolutionParameterfv( GET_DISPATCH(), ( 3407 *(GLenum *)(pc + 0), 3408 pname, 3409 params 3410 ) ); 3411 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 3412 error = Success; 3413 } 3414 3415 return error; 3416} 3417 3418int __glXDisp_GetConvolutionParameteriv(__GLXclientState *cl, GLbyte *pc) 3419{ 3420 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 3421 int error; 3422 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 3423 3424 pc += __GLX_SINGLE_HDR_SIZE; 3425 if ( cx != NULL ) { 3426 const GLenum pname = *(GLenum *)(pc + 4); 3427 3428 const GLuint compsize = __glGetConvolutionParameteriv_size(pname); 3429 GLint answerBuffer[200]; 3430 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 3431 3432 if (params == NULL) return BadAlloc; 3433 __glXClearErrorOccured(); 3434 3435 CALL_GetConvolutionParameteriv( GET_DISPATCH(), ( 3436 *(GLenum *)(pc + 0), 3437 pname, 3438 params 3439 ) ); 3440 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 3441 error = Success; 3442 } 3443 3444 return error; 3445} 3446 3447int __glXDisp_GetConvolutionParameterivEXT(__GLXclientState *cl, GLbyte *pc) 3448{ 3449 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 3450 int error; 3451 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 3452 3453 pc += __GLX_VENDPRIV_HDR_SIZE; 3454 if ( cx != NULL ) { 3455 const GLenum pname = *(GLenum *)(pc + 4); 3456 3457 const GLuint compsize = __glGetConvolutionParameteriv_size(pname); 3458 GLint answerBuffer[200]; 3459 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 3460 3461 if (params == NULL) return BadAlloc; 3462 __glXClearErrorOccured(); 3463 3464 CALL_GetConvolutionParameteriv( GET_DISPATCH(), ( 3465 *(GLenum *)(pc + 0), 3466 pname, 3467 params 3468 ) ); 3469 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 3470 error = Success; 3471 } 3472 3473 return error; 3474} 3475 3476int __glXDisp_GetHistogramParameterfv(__GLXclientState *cl, GLbyte *pc) 3477{ 3478 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 3479 int error; 3480 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 3481 3482 pc += __GLX_SINGLE_HDR_SIZE; 3483 if ( cx != NULL ) { 3484 const GLenum pname = *(GLenum *)(pc + 4); 3485 3486 const GLuint compsize = __glGetHistogramParameterfv_size(pname); 3487 GLfloat answerBuffer[200]; 3488 GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 3489 3490 if (params == NULL) return BadAlloc; 3491 __glXClearErrorOccured(); 3492 3493 CALL_GetHistogramParameterfv( GET_DISPATCH(), ( 3494 *(GLenum *)(pc + 0), 3495 pname, 3496 params 3497 ) ); 3498 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 3499 error = Success; 3500 } 3501 3502 return error; 3503} 3504 3505int __glXDisp_GetHistogramParameterfvEXT(__GLXclientState *cl, GLbyte *pc) 3506{ 3507 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 3508 int error; 3509 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 3510 3511 pc += __GLX_VENDPRIV_HDR_SIZE; 3512 if ( cx != NULL ) { 3513 const GLenum pname = *(GLenum *)(pc + 4); 3514 3515 const GLuint compsize = __glGetHistogramParameterfv_size(pname); 3516 GLfloat answerBuffer[200]; 3517 GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 3518 3519 if (params == NULL) return BadAlloc; 3520 __glXClearErrorOccured(); 3521 3522 CALL_GetHistogramParameterfv( GET_DISPATCH(), ( 3523 *(GLenum *)(pc + 0), 3524 pname, 3525 params 3526 ) ); 3527 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 3528 error = Success; 3529 } 3530 3531 return error; 3532} 3533 3534int __glXDisp_GetHistogramParameteriv(__GLXclientState *cl, GLbyte *pc) 3535{ 3536 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 3537 int error; 3538 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 3539 3540 pc += __GLX_SINGLE_HDR_SIZE; 3541 if ( cx != NULL ) { 3542 const GLenum pname = *(GLenum *)(pc + 4); 3543 3544 const GLuint compsize = __glGetHistogramParameteriv_size(pname); 3545 GLint answerBuffer[200]; 3546 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 3547 3548 if (params == NULL) return BadAlloc; 3549 __glXClearErrorOccured(); 3550 3551 CALL_GetHistogramParameteriv( GET_DISPATCH(), ( 3552 *(GLenum *)(pc + 0), 3553 pname, 3554 params 3555 ) ); 3556 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 3557 error = Success; 3558 } 3559 3560 return error; 3561} 3562 3563int __glXDisp_GetHistogramParameterivEXT(__GLXclientState *cl, GLbyte *pc) 3564{ 3565 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 3566 int error; 3567 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 3568 3569 pc += __GLX_VENDPRIV_HDR_SIZE; 3570 if ( cx != NULL ) { 3571 const GLenum pname = *(GLenum *)(pc + 4); 3572 3573 const GLuint compsize = __glGetHistogramParameteriv_size(pname); 3574 GLint answerBuffer[200]; 3575 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 3576 3577 if (params == NULL) return BadAlloc; 3578 __glXClearErrorOccured(); 3579 3580 CALL_GetHistogramParameteriv( GET_DISPATCH(), ( 3581 *(GLenum *)(pc + 0), 3582 pname, 3583 params 3584 ) ); 3585 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 3586 error = Success; 3587 } 3588 3589 return error; 3590} 3591 3592int __glXDisp_GetMinmaxParameterfv(__GLXclientState *cl, GLbyte *pc) 3593{ 3594 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 3595 int error; 3596 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 3597 3598 pc += __GLX_SINGLE_HDR_SIZE; 3599 if ( cx != NULL ) { 3600 const GLenum pname = *(GLenum *)(pc + 4); 3601 3602 const GLuint compsize = __glGetMinmaxParameterfv_size(pname); 3603 GLfloat answerBuffer[200]; 3604 GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 3605 3606 if (params == NULL) return BadAlloc; 3607 __glXClearErrorOccured(); 3608 3609 CALL_GetMinmaxParameterfv( GET_DISPATCH(), ( 3610 *(GLenum *)(pc + 0), 3611 pname, 3612 params 3613 ) ); 3614 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 3615 error = Success; 3616 } 3617 3618 return error; 3619} 3620 3621int __glXDisp_GetMinmaxParameterfvEXT(__GLXclientState *cl, GLbyte *pc) 3622{ 3623 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 3624 int error; 3625 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 3626 3627 pc += __GLX_VENDPRIV_HDR_SIZE; 3628 if ( cx != NULL ) { 3629 const GLenum pname = *(GLenum *)(pc + 4); 3630 3631 const GLuint compsize = __glGetMinmaxParameterfv_size(pname); 3632 GLfloat answerBuffer[200]; 3633 GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 3634 3635 if (params == NULL) return BadAlloc; 3636 __glXClearErrorOccured(); 3637 3638 CALL_GetMinmaxParameterfv( GET_DISPATCH(), ( 3639 *(GLenum *)(pc + 0), 3640 pname, 3641 params 3642 ) ); 3643 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 3644 error = Success; 3645 } 3646 3647 return error; 3648} 3649 3650int __glXDisp_GetMinmaxParameteriv(__GLXclientState *cl, GLbyte *pc) 3651{ 3652 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 3653 int error; 3654 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 3655 3656 pc += __GLX_SINGLE_HDR_SIZE; 3657 if ( cx != NULL ) { 3658 const GLenum pname = *(GLenum *)(pc + 4); 3659 3660 const GLuint compsize = __glGetMinmaxParameteriv_size(pname); 3661 GLint answerBuffer[200]; 3662 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 3663 3664 if (params == NULL) return BadAlloc; 3665 __glXClearErrorOccured(); 3666 3667 CALL_GetMinmaxParameteriv( GET_DISPATCH(), ( 3668 *(GLenum *)(pc + 0), 3669 pname, 3670 params 3671 ) ); 3672 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 3673 error = Success; 3674 } 3675 3676 return error; 3677} 3678 3679int __glXDisp_GetMinmaxParameterivEXT(__GLXclientState *cl, GLbyte *pc) 3680{ 3681 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 3682 int error; 3683 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 3684 3685 pc += __GLX_VENDPRIV_HDR_SIZE; 3686 if ( cx != NULL ) { 3687 const GLenum pname = *(GLenum *)(pc + 4); 3688 3689 const GLuint compsize = __glGetMinmaxParameteriv_size(pname); 3690 GLint answerBuffer[200]; 3691 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 3692 3693 if (params == NULL) return BadAlloc; 3694 __glXClearErrorOccured(); 3695 3696 CALL_GetMinmaxParameteriv( GET_DISPATCH(), ( 3697 *(GLenum *)(pc + 0), 3698 pname, 3699 params 3700 ) ); 3701 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 3702 error = Success; 3703 } 3704 3705 return error; 3706} 3707 3708void __glXDisp_Histogram(GLbyte * pc) 3709{ 3710 CALL_Histogram( GET_DISPATCH(), ( 3711 *(GLenum *)(pc + 0), 3712 *(GLsizei *)(pc + 4), 3713 *(GLenum *)(pc + 8), 3714 *(GLboolean *)(pc + 12) 3715 ) ); 3716} 3717 3718void __glXDisp_Minmax(GLbyte * pc) 3719{ 3720 CALL_Minmax( GET_DISPATCH(), ( 3721 *(GLenum *)(pc + 0), 3722 *(GLenum *)(pc + 4), 3723 *(GLboolean *)(pc + 8) 3724 ) ); 3725} 3726 3727void __glXDisp_ResetHistogram(GLbyte * pc) 3728{ 3729 CALL_ResetHistogram( GET_DISPATCH(), ( 3730 *(GLenum *)(pc + 0) 3731 ) ); 3732} 3733 3734void __glXDisp_ResetMinmax(GLbyte * pc) 3735{ 3736 CALL_ResetMinmax( GET_DISPATCH(), ( 3737 *(GLenum *)(pc + 0) 3738 ) ); 3739} 3740 3741void __glXDisp_TexImage3D(GLbyte * pc) 3742{ 3743 const CARD32 ptr_is_null = *(CARD32 *)(pc + 76); 3744 const GLvoid * const pixels = (const GLvoid *) ((ptr_is_null != 0) ? NULL : (pc + 80)); 3745 __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc); 3746 3747 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes) ); 3748 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst) ); 3749 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength) ); 3750 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_IMAGE_HEIGHT, (GLint) hdr->imageHeight) ); 3751 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows) ); 3752 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_IMAGES, (GLint) hdr->skipImages) ); 3753 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels) ); 3754 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment) ); 3755 3756 CALL_TexImage3D( GET_DISPATCH(), ( 3757 *(GLenum *)(pc + 36), 3758 *(GLint *)(pc + 40), 3759 *(GLint *)(pc + 44), 3760 *(GLsizei *)(pc + 48), 3761 *(GLsizei *)(pc + 52), 3762 *(GLsizei *)(pc + 56), 3763 *(GLint *)(pc + 64), 3764 *(GLenum *)(pc + 68), 3765 *(GLenum *)(pc + 72), 3766 pixels 3767 ) ); 3768} 3769 3770void __glXDisp_TexSubImage3D(GLbyte * pc) 3771{ 3772 const GLvoid * const pixels = (const GLvoid *) (pc + 88); 3773 __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc); 3774 3775 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes) ); 3776 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst) ); 3777 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength) ); 3778 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_IMAGE_HEIGHT, (GLint) hdr->imageHeight) ); 3779 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows) ); 3780 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_IMAGES, (GLint) hdr->skipImages) ); 3781 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels) ); 3782 CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment) ); 3783 3784 CALL_TexSubImage3D( GET_DISPATCH(), ( 3785 *(GLenum *)(pc + 36), 3786 *(GLint *)(pc + 40), 3787 *(GLint *)(pc + 44), 3788 *(GLint *)(pc + 48), 3789 *(GLint *)(pc + 52), 3790 *(GLsizei *)(pc + 60), 3791 *(GLsizei *)(pc + 64), 3792 *(GLsizei *)(pc + 68), 3793 *(GLenum *)(pc + 76), 3794 *(GLenum *)(pc + 80), 3795 pixels 3796 ) ); 3797} 3798 3799void __glXDisp_CopyTexSubImage3D(GLbyte * pc) 3800{ 3801 CALL_CopyTexSubImage3D( GET_DISPATCH(), ( 3802 *(GLenum *)(pc + 0), 3803 *(GLint *)(pc + 4), 3804 *(GLint *)(pc + 8), 3805 *(GLint *)(pc + 12), 3806 *(GLint *)(pc + 16), 3807 *(GLint *)(pc + 20), 3808 *(GLint *)(pc + 24), 3809 *(GLsizei *)(pc + 28), 3810 *(GLsizei *)(pc + 32) 3811 ) ); 3812} 3813 3814void __glXDisp_ActiveTextureARB(GLbyte * pc) 3815{ 3816 CALL_ActiveTextureARB( GET_DISPATCH(), ( 3817 *(GLenum *)(pc + 0) 3818 ) ); 3819} 3820 3821void __glXDisp_MultiTexCoord1dvARB(GLbyte * pc) 3822{ 3823#ifdef __GLX_ALIGN64 3824 if ((unsigned long)(pc) & 7) { 3825 (void) memmove(pc-4, pc, 12); 3826 pc -= 4; 3827 } 3828#endif 3829 3830 CALL_MultiTexCoord1dvARB( GET_DISPATCH(), ( 3831 *(GLenum *)(pc + 8), 3832 (const GLdouble *)(pc + 0) 3833 ) ); 3834} 3835 3836void __glXDisp_MultiTexCoord1fvARB(GLbyte * pc) 3837{ 3838 CALL_MultiTexCoord1fvARB( GET_DISPATCH(), ( 3839 *(GLenum *)(pc + 0), 3840 (const GLfloat *)(pc + 4) 3841 ) ); 3842} 3843 3844void __glXDisp_MultiTexCoord1ivARB(GLbyte * pc) 3845{ 3846 CALL_MultiTexCoord1ivARB( GET_DISPATCH(), ( 3847 *(GLenum *)(pc + 0), 3848 (const GLint *)(pc + 4) 3849 ) ); 3850} 3851 3852void __glXDisp_MultiTexCoord1svARB(GLbyte * pc) 3853{ 3854 CALL_MultiTexCoord1svARB( GET_DISPATCH(), ( 3855 *(GLenum *)(pc + 0), 3856 (const GLshort *)(pc + 4) 3857 ) ); 3858} 3859 3860void __glXDisp_MultiTexCoord2dvARB(GLbyte * pc) 3861{ 3862#ifdef __GLX_ALIGN64 3863 if ((unsigned long)(pc) & 7) { 3864 (void) memmove(pc-4, pc, 20); 3865 pc -= 4; 3866 } 3867#endif 3868 3869 CALL_MultiTexCoord2dvARB( GET_DISPATCH(), ( 3870 *(GLenum *)(pc + 16), 3871 (const GLdouble *)(pc + 0) 3872 ) ); 3873} 3874 3875void __glXDisp_MultiTexCoord2fvARB(GLbyte * pc) 3876{ 3877 CALL_MultiTexCoord2fvARB( GET_DISPATCH(), ( 3878 *(GLenum *)(pc + 0), 3879 (const GLfloat *)(pc + 4) 3880 ) ); 3881} 3882 3883void __glXDisp_MultiTexCoord2ivARB(GLbyte * pc) 3884{ 3885 CALL_MultiTexCoord2ivARB( GET_DISPATCH(), ( 3886 *(GLenum *)(pc + 0), 3887 (const GLint *)(pc + 4) 3888 ) ); 3889} 3890 3891void __glXDisp_MultiTexCoord2svARB(GLbyte * pc) 3892{ 3893 CALL_MultiTexCoord2svARB( GET_DISPATCH(), ( 3894 *(GLenum *)(pc + 0), 3895 (const GLshort *)(pc + 4) 3896 ) ); 3897} 3898 3899void __glXDisp_MultiTexCoord3dvARB(GLbyte * pc) 3900{ 3901#ifdef __GLX_ALIGN64 3902 if ((unsigned long)(pc) & 7) { 3903 (void) memmove(pc-4, pc, 28); 3904 pc -= 4; 3905 } 3906#endif 3907 3908 CALL_MultiTexCoord3dvARB( GET_DISPATCH(), ( 3909 *(GLenum *)(pc + 24), 3910 (const GLdouble *)(pc + 0) 3911 ) ); 3912} 3913 3914void __glXDisp_MultiTexCoord3fvARB(GLbyte * pc) 3915{ 3916 CALL_MultiTexCoord3fvARB( GET_DISPATCH(), ( 3917 *(GLenum *)(pc + 0), 3918 (const GLfloat *)(pc + 4) 3919 ) ); 3920} 3921 3922void __glXDisp_MultiTexCoord3ivARB(GLbyte * pc) 3923{ 3924 CALL_MultiTexCoord3ivARB( GET_DISPATCH(), ( 3925 *(GLenum *)(pc + 0), 3926 (const GLint *)(pc + 4) 3927 ) ); 3928} 3929 3930void __glXDisp_MultiTexCoord3svARB(GLbyte * pc) 3931{ 3932 CALL_MultiTexCoord3svARB( GET_DISPATCH(), ( 3933 *(GLenum *)(pc + 0), 3934 (const GLshort *)(pc + 4) 3935 ) ); 3936} 3937 3938void __glXDisp_MultiTexCoord4dvARB(GLbyte * pc) 3939{ 3940#ifdef __GLX_ALIGN64 3941 if ((unsigned long)(pc) & 7) { 3942 (void) memmove(pc-4, pc, 36); 3943 pc -= 4; 3944 } 3945#endif 3946 3947 CALL_MultiTexCoord4dvARB( GET_DISPATCH(), ( 3948 *(GLenum *)(pc + 32), 3949 (const GLdouble *)(pc + 0) 3950 ) ); 3951} 3952 3953void __glXDisp_MultiTexCoord4fvARB(GLbyte * pc) 3954{ 3955 CALL_MultiTexCoord4fvARB( GET_DISPATCH(), ( 3956 *(GLenum *)(pc + 0), 3957 (const GLfloat *)(pc + 4) 3958 ) ); 3959} 3960 3961void __glXDisp_MultiTexCoord4ivARB(GLbyte * pc) 3962{ 3963 CALL_MultiTexCoord4ivARB( GET_DISPATCH(), ( 3964 *(GLenum *)(pc + 0), 3965 (const GLint *)(pc + 4) 3966 ) ); 3967} 3968 3969void __glXDisp_MultiTexCoord4svARB(GLbyte * pc) 3970{ 3971 CALL_MultiTexCoord4svARB( GET_DISPATCH(), ( 3972 *(GLenum *)(pc + 0), 3973 (const GLshort *)(pc + 4) 3974 ) ); 3975} 3976 3977void __glXDisp_SampleCoverageARB(GLbyte * pc) 3978{ 3979 CALL_SampleCoverageARB( GET_DISPATCH(), ( 3980 *(GLclampf *)(pc + 0), 3981 *(GLboolean *)(pc + 4) 3982 ) ); 3983} 3984 3985void __glXDisp_CompressedTexImage1DARB(GLbyte * pc) 3986{ 3987 const GLsizei imageSize = *(GLsizei *)(pc + 20); 3988 3989 CALL_CompressedTexImage1DARB( GET_DISPATCH(), ( 3990 *(GLenum *)(pc + 0), 3991 *(GLint *)(pc + 4), 3992 *(GLenum *)(pc + 8), 3993 *(GLsizei *)(pc + 12), 3994 *(GLint *)(pc + 16), 3995 imageSize, 3996 (const GLvoid *)(pc + 24) 3997 ) ); 3998} 3999 4000void __glXDisp_CompressedTexImage2DARB(GLbyte * pc) 4001{ 4002 const GLsizei imageSize = *(GLsizei *)(pc + 24); 4003 4004 CALL_CompressedTexImage2DARB( GET_DISPATCH(), ( 4005 *(GLenum *)(pc + 0), 4006 *(GLint *)(pc + 4), 4007 *(GLenum *)(pc + 8), 4008 *(GLsizei *)(pc + 12), 4009 *(GLsizei *)(pc + 16), 4010 *(GLint *)(pc + 20), 4011 imageSize, 4012 (const GLvoid *)(pc + 28) 4013 ) ); 4014} 4015 4016void __glXDisp_CompressedTexImage3DARB(GLbyte * pc) 4017{ 4018 const GLsizei imageSize = *(GLsizei *)(pc + 28); 4019 4020 CALL_CompressedTexImage3DARB( GET_DISPATCH(), ( 4021 *(GLenum *)(pc + 0), 4022 *(GLint *)(pc + 4), 4023 *(GLenum *)(pc + 8), 4024 *(GLsizei *)(pc + 12), 4025 *(GLsizei *)(pc + 16), 4026 *(GLsizei *)(pc + 20), 4027 *(GLint *)(pc + 24), 4028 imageSize, 4029 (const GLvoid *)(pc + 32) 4030 ) ); 4031} 4032 4033void __glXDisp_CompressedTexSubImage1DARB(GLbyte * pc) 4034{ 4035 const GLsizei imageSize = *(GLsizei *)(pc + 20); 4036 4037 CALL_CompressedTexSubImage1DARB( GET_DISPATCH(), ( 4038 *(GLenum *)(pc + 0), 4039 *(GLint *)(pc + 4), 4040 *(GLint *)(pc + 8), 4041 *(GLsizei *)(pc + 12), 4042 *(GLenum *)(pc + 16), 4043 imageSize, 4044 (const GLvoid *)(pc + 24) 4045 ) ); 4046} 4047 4048void __glXDisp_CompressedTexSubImage2DARB(GLbyte * pc) 4049{ 4050 const GLsizei imageSize = *(GLsizei *)(pc + 28); 4051 4052 CALL_CompressedTexSubImage2DARB( GET_DISPATCH(), ( 4053 *(GLenum *)(pc + 0), 4054 *(GLint *)(pc + 4), 4055 *(GLint *)(pc + 8), 4056 *(GLint *)(pc + 12), 4057 *(GLsizei *)(pc + 16), 4058 *(GLsizei *)(pc + 20), 4059 *(GLenum *)(pc + 24), 4060 imageSize, 4061 (const GLvoid *)(pc + 32) 4062 ) ); 4063} 4064 4065void __glXDisp_CompressedTexSubImage3DARB(GLbyte * pc) 4066{ 4067 const GLsizei imageSize = *(GLsizei *)(pc + 36); 4068 4069 CALL_CompressedTexSubImage3DARB( GET_DISPATCH(), ( 4070 *(GLenum *)(pc + 0), 4071 *(GLint *)(pc + 4), 4072 *(GLint *)(pc + 8), 4073 *(GLint *)(pc + 12), 4074 *(GLint *)(pc + 16), 4075 *(GLsizei *)(pc + 20), 4076 *(GLsizei *)(pc + 24), 4077 *(GLsizei *)(pc + 28), 4078 *(GLenum *)(pc + 32), 4079 imageSize, 4080 (const GLvoid *)(pc + 40) 4081 ) ); 4082} 4083 4084int __glXDisp_GetProgramEnvParameterdvARB(__GLXclientState *cl, GLbyte *pc) 4085{ 4086 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 4087 int error; 4088 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 4089 4090 pc += __GLX_VENDPRIV_HDR_SIZE; 4091 if ( cx != NULL ) { 4092 GLdouble params[4]; 4093 CALL_GetProgramEnvParameterdvARB( GET_DISPATCH(), ( 4094 *(GLenum *)(pc + 0), 4095 *(GLuint *)(pc + 4), 4096 params 4097 ) ); 4098 __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0); 4099 error = Success; 4100 } 4101 4102 return error; 4103} 4104 4105int __glXDisp_GetProgramEnvParameterfvARB(__GLXclientState *cl, GLbyte *pc) 4106{ 4107 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 4108 int error; 4109 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 4110 4111 pc += __GLX_VENDPRIV_HDR_SIZE; 4112 if ( cx != NULL ) { 4113 GLfloat params[4]; 4114 CALL_GetProgramEnvParameterfvARB( GET_DISPATCH(), ( 4115 *(GLenum *)(pc + 0), 4116 *(GLuint *)(pc + 4), 4117 params 4118 ) ); 4119 __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0); 4120 error = Success; 4121 } 4122 4123 return error; 4124} 4125 4126int __glXDisp_GetProgramLocalParameterdvARB(__GLXclientState *cl, GLbyte *pc) 4127{ 4128 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 4129 int error; 4130 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 4131 4132 pc += __GLX_VENDPRIV_HDR_SIZE; 4133 if ( cx != NULL ) { 4134 GLdouble params[4]; 4135 CALL_GetProgramLocalParameterdvARB( GET_DISPATCH(), ( 4136 *(GLenum *)(pc + 0), 4137 *(GLuint *)(pc + 4), 4138 params 4139 ) ); 4140 __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0); 4141 error = Success; 4142 } 4143 4144 return error; 4145} 4146 4147int __glXDisp_GetProgramLocalParameterfvARB(__GLXclientState *cl, GLbyte *pc) 4148{ 4149 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 4150 int error; 4151 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 4152 4153 pc += __GLX_VENDPRIV_HDR_SIZE; 4154 if ( cx != NULL ) { 4155 GLfloat params[4]; 4156 CALL_GetProgramLocalParameterfvARB( GET_DISPATCH(), ( 4157 *(GLenum *)(pc + 0), 4158 *(GLuint *)(pc + 4), 4159 params 4160 ) ); 4161 __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0); 4162 error = Success; 4163 } 4164 4165 return error; 4166} 4167 4168int __glXDisp_GetProgramivARB(__GLXclientState *cl, GLbyte *pc) 4169{ 4170 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 4171 int error; 4172 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 4173 4174 pc += __GLX_VENDPRIV_HDR_SIZE; 4175 if ( cx != NULL ) { 4176 const GLenum pname = *(GLenum *)(pc + 4); 4177 4178 const GLuint compsize = __glGetProgramivARB_size(pname); 4179 GLint answerBuffer[200]; 4180 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 4181 4182 if (params == NULL) return BadAlloc; 4183 __glXClearErrorOccured(); 4184 4185 CALL_GetProgramivARB( GET_DISPATCH(), ( 4186 *(GLenum *)(pc + 0), 4187 pname, 4188 params 4189 ) ); 4190 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 4191 error = Success; 4192 } 4193 4194 return error; 4195} 4196 4197int __glXDisp_GetVertexAttribdvARB(__GLXclientState *cl, GLbyte *pc) 4198{ 4199 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 4200 int error; 4201 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 4202 4203 pc += __GLX_VENDPRIV_HDR_SIZE; 4204 if ( cx != NULL ) { 4205 const GLenum pname = *(GLenum *)(pc + 4); 4206 4207 const GLuint compsize = __glGetVertexAttribdvARB_size(pname); 4208 GLdouble answerBuffer[200]; 4209 GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8); 4210 4211 if (params == NULL) return BadAlloc; 4212 __glXClearErrorOccured(); 4213 4214 CALL_GetVertexAttribdvARB( GET_DISPATCH(), ( 4215 *(GLuint *)(pc + 0), 4216 pname, 4217 params 4218 ) ); 4219 __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0); 4220 error = Success; 4221 } 4222 4223 return error; 4224} 4225 4226int __glXDisp_GetVertexAttribfvARB(__GLXclientState *cl, GLbyte *pc) 4227{ 4228 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 4229 int error; 4230 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 4231 4232 pc += __GLX_VENDPRIV_HDR_SIZE; 4233 if ( cx != NULL ) { 4234 const GLenum pname = *(GLenum *)(pc + 4); 4235 4236 const GLuint compsize = __glGetVertexAttribfvARB_size(pname); 4237 GLfloat answerBuffer[200]; 4238 GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 4239 4240 if (params == NULL) return BadAlloc; 4241 __glXClearErrorOccured(); 4242 4243 CALL_GetVertexAttribfvARB( GET_DISPATCH(), ( 4244 *(GLuint *)(pc + 0), 4245 pname, 4246 params 4247 ) ); 4248 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 4249 error = Success; 4250 } 4251 4252 return error; 4253} 4254 4255int __glXDisp_GetVertexAttribivARB(__GLXclientState *cl, GLbyte *pc) 4256{ 4257 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 4258 int error; 4259 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 4260 4261 pc += __GLX_VENDPRIV_HDR_SIZE; 4262 if ( cx != NULL ) { 4263 const GLenum pname = *(GLenum *)(pc + 4); 4264 4265 const GLuint compsize = __glGetVertexAttribivARB_size(pname); 4266 GLint answerBuffer[200]; 4267 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 4268 4269 if (params == NULL) return BadAlloc; 4270 __glXClearErrorOccured(); 4271 4272 CALL_GetVertexAttribivARB( GET_DISPATCH(), ( 4273 *(GLuint *)(pc + 0), 4274 pname, 4275 params 4276 ) ); 4277 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 4278 error = Success; 4279 } 4280 4281 return error; 4282} 4283 4284void __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc) 4285{ 4286#ifdef __GLX_ALIGN64 4287 if ((unsigned long)(pc) & 7) { 4288 (void) memmove(pc-4, pc, 40); 4289 pc -= 4; 4290 } 4291#endif 4292 4293 CALL_ProgramEnvParameter4dvARB( GET_DISPATCH(), ( 4294 *(GLenum *)(pc + 0), 4295 *(GLuint *)(pc + 4), 4296 (const GLdouble *)(pc + 8) 4297 ) ); 4298} 4299 4300void __glXDisp_ProgramEnvParameter4fvARB(GLbyte * pc) 4301{ 4302 CALL_ProgramEnvParameter4fvARB( GET_DISPATCH(), ( 4303 *(GLenum *)(pc + 0), 4304 *(GLuint *)(pc + 4), 4305 (const GLfloat *)(pc + 8) 4306 ) ); 4307} 4308 4309void __glXDisp_ProgramLocalParameter4dvARB(GLbyte * pc) 4310{ 4311#ifdef __GLX_ALIGN64 4312 if ((unsigned long)(pc) & 7) { 4313 (void) memmove(pc-4, pc, 40); 4314 pc -= 4; 4315 } 4316#endif 4317 4318 CALL_ProgramLocalParameter4dvARB( GET_DISPATCH(), ( 4319 *(GLenum *)(pc + 0), 4320 *(GLuint *)(pc + 4), 4321 (const GLdouble *)(pc + 8) 4322 ) ); 4323} 4324 4325void __glXDisp_ProgramLocalParameter4fvARB(GLbyte * pc) 4326{ 4327 CALL_ProgramLocalParameter4fvARB( GET_DISPATCH(), ( 4328 *(GLenum *)(pc + 0), 4329 *(GLuint *)(pc + 4), 4330 (const GLfloat *)(pc + 8) 4331 ) ); 4332} 4333 4334void __glXDisp_ProgramStringARB(GLbyte * pc) 4335{ 4336 const GLsizei len = *(GLsizei *)(pc + 8); 4337 4338 CALL_ProgramStringARB( GET_DISPATCH(), ( 4339 *(GLenum *)(pc + 0), 4340 *(GLenum *)(pc + 4), 4341 len, 4342 (const GLvoid *)(pc + 12) 4343 ) ); 4344} 4345 4346void __glXDisp_VertexAttrib1dvARB(GLbyte * pc) 4347{ 4348#ifdef __GLX_ALIGN64 4349 if ((unsigned long)(pc) & 7) { 4350 (void) memmove(pc-4, pc, 12); 4351 pc -= 4; 4352 } 4353#endif 4354 4355 CALL_VertexAttrib1dvARB( GET_DISPATCH(), ( 4356 *(GLuint *)(pc + 0), 4357 (const GLdouble *)(pc + 4) 4358 ) ); 4359} 4360 4361void __glXDisp_VertexAttrib1fvARB(GLbyte * pc) 4362{ 4363 CALL_VertexAttrib1fvARB( GET_DISPATCH(), ( 4364 *(GLuint *)(pc + 0), 4365 (const GLfloat *)(pc + 4) 4366 ) ); 4367} 4368 4369void __glXDisp_VertexAttrib1svARB(GLbyte * pc) 4370{ 4371 CALL_VertexAttrib1svARB( GET_DISPATCH(), ( 4372 *(GLuint *)(pc + 0), 4373 (const GLshort *)(pc + 4) 4374 ) ); 4375} 4376 4377void __glXDisp_VertexAttrib2dvARB(GLbyte * pc) 4378{ 4379#ifdef __GLX_ALIGN64 4380 if ((unsigned long)(pc) & 7) { 4381 (void) memmove(pc-4, pc, 20); 4382 pc -= 4; 4383 } 4384#endif 4385 4386 CALL_VertexAttrib2dvARB( GET_DISPATCH(), ( 4387 *(GLuint *)(pc + 0), 4388 (const GLdouble *)(pc + 4) 4389 ) ); 4390} 4391 4392void __glXDisp_VertexAttrib2fvARB(GLbyte * pc) 4393{ 4394 CALL_VertexAttrib2fvARB( GET_DISPATCH(), ( 4395 *(GLuint *)(pc + 0), 4396 (const GLfloat *)(pc + 4) 4397 ) ); 4398} 4399 4400void __glXDisp_VertexAttrib2svARB(GLbyte * pc) 4401{ 4402 CALL_VertexAttrib2svARB( GET_DISPATCH(), ( 4403 *(GLuint *)(pc + 0), 4404 (const GLshort *)(pc + 4) 4405 ) ); 4406} 4407 4408void __glXDisp_VertexAttrib3dvARB(GLbyte * pc) 4409{ 4410#ifdef __GLX_ALIGN64 4411 if ((unsigned long)(pc) & 7) { 4412 (void) memmove(pc-4, pc, 28); 4413 pc -= 4; 4414 } 4415#endif 4416 4417 CALL_VertexAttrib3dvARB( GET_DISPATCH(), ( 4418 *(GLuint *)(pc + 0), 4419 (const GLdouble *)(pc + 4) 4420 ) ); 4421} 4422 4423void __glXDisp_VertexAttrib3fvARB(GLbyte * pc) 4424{ 4425 CALL_VertexAttrib3fvARB( GET_DISPATCH(), ( 4426 *(GLuint *)(pc + 0), 4427 (const GLfloat *)(pc + 4) 4428 ) ); 4429} 4430 4431void __glXDisp_VertexAttrib3svARB(GLbyte * pc) 4432{ 4433 CALL_VertexAttrib3svARB( GET_DISPATCH(), ( 4434 *(GLuint *)(pc + 0), 4435 (const GLshort *)(pc + 4) 4436 ) ); 4437} 4438 4439void __glXDisp_VertexAttrib4NbvARB(GLbyte * pc) 4440{ 4441 CALL_VertexAttrib4NbvARB( GET_DISPATCH(), ( 4442 *(GLuint *)(pc + 0), 4443 (const GLbyte *)(pc + 4) 4444 ) ); 4445} 4446 4447void __glXDisp_VertexAttrib4NivARB(GLbyte * pc) 4448{ 4449 CALL_VertexAttrib4NivARB( GET_DISPATCH(), ( 4450 *(GLuint *)(pc + 0), 4451 (const GLint *)(pc + 4) 4452 ) ); 4453} 4454 4455void __glXDisp_VertexAttrib4NsvARB(GLbyte * pc) 4456{ 4457 CALL_VertexAttrib4NsvARB( GET_DISPATCH(), ( 4458 *(GLuint *)(pc + 0), 4459 (const GLshort *)(pc + 4) 4460 ) ); 4461} 4462 4463void __glXDisp_VertexAttrib4NubvARB(GLbyte * pc) 4464{ 4465 CALL_VertexAttrib4NubvARB( GET_DISPATCH(), ( 4466 *(GLuint *)(pc + 0), 4467 (const GLubyte *)(pc + 4) 4468 ) ); 4469} 4470 4471void __glXDisp_VertexAttrib4NuivARB(GLbyte * pc) 4472{ 4473 CALL_VertexAttrib4NuivARB( GET_DISPATCH(), ( 4474 *(GLuint *)(pc + 0), 4475 (const GLuint *)(pc + 4) 4476 ) ); 4477} 4478 4479void __glXDisp_VertexAttrib4NusvARB(GLbyte * pc) 4480{ 4481 CALL_VertexAttrib4NusvARB( GET_DISPATCH(), ( 4482 *(GLuint *)(pc + 0), 4483 (const GLushort *)(pc + 4) 4484 ) ); 4485} 4486 4487void __glXDisp_VertexAttrib4bvARB(GLbyte * pc) 4488{ 4489 CALL_VertexAttrib4bvARB( GET_DISPATCH(), ( 4490 *(GLuint *)(pc + 0), 4491 (const GLbyte *)(pc + 4) 4492 ) ); 4493} 4494 4495void __glXDisp_VertexAttrib4dvARB(GLbyte * pc) 4496{ 4497#ifdef __GLX_ALIGN64 4498 if ((unsigned long)(pc) & 7) { 4499 (void) memmove(pc-4, pc, 36); 4500 pc -= 4; 4501 } 4502#endif 4503 4504 CALL_VertexAttrib4dvARB( GET_DISPATCH(), ( 4505 *(GLuint *)(pc + 0), 4506 (const GLdouble *)(pc + 4) 4507 ) ); 4508} 4509 4510void __glXDisp_VertexAttrib4fvARB(GLbyte * pc) 4511{ 4512 CALL_VertexAttrib4fvARB( GET_DISPATCH(), ( 4513 *(GLuint *)(pc + 0), 4514 (const GLfloat *)(pc + 4) 4515 ) ); 4516} 4517 4518void __glXDisp_VertexAttrib4ivARB(GLbyte * pc) 4519{ 4520 CALL_VertexAttrib4ivARB( GET_DISPATCH(), ( 4521 *(GLuint *)(pc + 0), 4522 (const GLint *)(pc + 4) 4523 ) ); 4524} 4525 4526void __glXDisp_VertexAttrib4svARB(GLbyte * pc) 4527{ 4528 CALL_VertexAttrib4svARB( GET_DISPATCH(), ( 4529 *(GLuint *)(pc + 0), 4530 (const GLshort *)(pc + 4) 4531 ) ); 4532} 4533 4534void __glXDisp_VertexAttrib4ubvARB(GLbyte * pc) 4535{ 4536 CALL_VertexAttrib4ubvARB( GET_DISPATCH(), ( 4537 *(GLuint *)(pc + 0), 4538 (const GLubyte *)(pc + 4) 4539 ) ); 4540} 4541 4542void __glXDisp_VertexAttrib4uivARB(GLbyte * pc) 4543{ 4544 CALL_VertexAttrib4uivARB( GET_DISPATCH(), ( 4545 *(GLuint *)(pc + 0), 4546 (const GLuint *)(pc + 4) 4547 ) ); 4548} 4549 4550void __glXDisp_VertexAttrib4usvARB(GLbyte * pc) 4551{ 4552 CALL_VertexAttrib4usvARB( GET_DISPATCH(), ( 4553 *(GLuint *)(pc + 0), 4554 (const GLushort *)(pc + 4) 4555 ) ); 4556} 4557 4558void __glXDisp_BeginQueryARB(GLbyte * pc) 4559{ 4560 CALL_BeginQueryARB( GET_DISPATCH(), ( 4561 *(GLenum *)(pc + 0), 4562 *(GLuint *)(pc + 4) 4563 ) ); 4564} 4565 4566int __glXDisp_DeleteQueriesARB(__GLXclientState *cl, GLbyte *pc) 4567{ 4568 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 4569 int error; 4570 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 4571 4572 pc += __GLX_SINGLE_HDR_SIZE; 4573 if ( cx != NULL ) { 4574 const GLsizei n = *(GLsizei *)(pc + 0); 4575 4576 CALL_DeleteQueriesARB( GET_DISPATCH(), ( 4577 n, 4578 (const GLuint *)(pc + 4) 4579 ) ); 4580 error = Success; 4581 } 4582 4583 return error; 4584} 4585 4586void __glXDisp_EndQueryARB(GLbyte * pc) 4587{ 4588 CALL_EndQueryARB( GET_DISPATCH(), ( 4589 *(GLenum *)(pc + 0) 4590 ) ); 4591} 4592 4593int __glXDisp_GenQueriesARB(__GLXclientState *cl, GLbyte *pc) 4594{ 4595 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 4596 int error; 4597 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 4598 4599 pc += __GLX_SINGLE_HDR_SIZE; 4600 if ( cx != NULL ) { 4601 const GLsizei n = *(GLsizei *)(pc + 0); 4602 4603 GLuint answerBuffer[200]; 4604 GLuint * ids = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4); 4605 CALL_GenQueriesARB( GET_DISPATCH(), ( 4606 n, 4607 ids 4608 ) ); 4609 __glXSendReply(cl->client, ids, n, 4, GL_TRUE, 0); 4610 error = Success; 4611 } 4612 4613 return error; 4614} 4615 4616int __glXDisp_GetQueryObjectivARB(__GLXclientState *cl, GLbyte *pc) 4617{ 4618 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 4619 int error; 4620 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 4621 4622 pc += __GLX_SINGLE_HDR_SIZE; 4623 if ( cx != NULL ) { 4624 const GLenum pname = *(GLenum *)(pc + 4); 4625 4626 const GLuint compsize = __glGetQueryObjectivARB_size(pname); 4627 GLint answerBuffer[200]; 4628 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 4629 4630 if (params == NULL) return BadAlloc; 4631 __glXClearErrorOccured(); 4632 4633 CALL_GetQueryObjectivARB( GET_DISPATCH(), ( 4634 *(GLuint *)(pc + 0), 4635 pname, 4636 params 4637 ) ); 4638 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 4639 error = Success; 4640 } 4641 4642 return error; 4643} 4644 4645int __glXDisp_GetQueryObjectuivARB(__GLXclientState *cl, GLbyte *pc) 4646{ 4647 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 4648 int error; 4649 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 4650 4651 pc += __GLX_SINGLE_HDR_SIZE; 4652 if ( cx != NULL ) { 4653 const GLenum pname = *(GLenum *)(pc + 4); 4654 4655 const GLuint compsize = __glGetQueryObjectuivARB_size(pname); 4656 GLuint answerBuffer[200]; 4657 GLuint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 4658 4659 if (params == NULL) return BadAlloc; 4660 __glXClearErrorOccured(); 4661 4662 CALL_GetQueryObjectuivARB( GET_DISPATCH(), ( 4663 *(GLuint *)(pc + 0), 4664 pname, 4665 params 4666 ) ); 4667 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 4668 error = Success; 4669 } 4670 4671 return error; 4672} 4673 4674int __glXDisp_GetQueryivARB(__GLXclientState *cl, GLbyte *pc) 4675{ 4676 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 4677 int error; 4678 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 4679 4680 pc += __GLX_SINGLE_HDR_SIZE; 4681 if ( cx != NULL ) { 4682 const GLenum pname = *(GLenum *)(pc + 4); 4683 4684 const GLuint compsize = __glGetQueryivARB_size(pname); 4685 GLint answerBuffer[200]; 4686 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 4687 4688 if (params == NULL) return BadAlloc; 4689 __glXClearErrorOccured(); 4690 4691 CALL_GetQueryivARB( GET_DISPATCH(), ( 4692 *(GLenum *)(pc + 0), 4693 pname, 4694 params 4695 ) ); 4696 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 4697 error = Success; 4698 } 4699 4700 return error; 4701} 4702 4703int __glXDisp_IsQueryARB(__GLXclientState *cl, GLbyte *pc) 4704{ 4705 xGLXSingleReq * const req = (xGLXSingleReq *) pc; 4706 int error; 4707 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 4708 4709 pc += __GLX_SINGLE_HDR_SIZE; 4710 if ( cx != NULL ) { 4711 GLboolean retval; 4712 retval = CALL_IsQueryARB( GET_DISPATCH(), ( 4713 *(GLuint *)(pc + 0) 4714 ) ); 4715 __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); 4716 error = Success; 4717 } 4718 4719 return error; 4720} 4721 4722void __glXDisp_DrawBuffersARB(GLbyte * pc) 4723{ 4724 const GLsizei n = *(GLsizei *)(pc + 0); 4725 4726 CALL_DrawBuffersARB( GET_DISPATCH(), ( 4727 n, 4728 (const GLenum *)(pc + 4) 4729 ) ); 4730} 4731 4732void __glXDisp_SampleMaskSGIS(GLbyte * pc) 4733{ 4734 CALL_SampleMaskSGIS( GET_DISPATCH(), ( 4735 *(GLclampf *)(pc + 0), 4736 *(GLboolean *)(pc + 4) 4737 ) ); 4738} 4739 4740void __glXDisp_SamplePatternSGIS(GLbyte * pc) 4741{ 4742 CALL_SamplePatternSGIS( GET_DISPATCH(), ( 4743 *(GLenum *)(pc + 0) 4744 ) ); 4745} 4746 4747void __glXDisp_PointParameterfEXT(GLbyte * pc) 4748{ 4749 CALL_PointParameterfEXT( GET_DISPATCH(), ( 4750 *(GLenum *)(pc + 0), 4751 *(GLfloat *)(pc + 4) 4752 ) ); 4753} 4754 4755void __glXDisp_PointParameterfvEXT(GLbyte * pc) 4756{ 4757 const GLenum pname = *(GLenum *)(pc + 0); 4758 const GLfloat * params; 4759 4760 params = (const GLfloat *) (pc + 4); 4761 4762 CALL_PointParameterfvEXT( GET_DISPATCH(), ( 4763 pname, 4764 params 4765 ) ); 4766} 4767 4768void __glXDisp_SecondaryColor3bvEXT(GLbyte * pc) 4769{ 4770 CALL_SecondaryColor3bvEXT( GET_DISPATCH(), ( 4771 (const GLbyte *)(pc + 0) 4772 ) ); 4773} 4774 4775void __glXDisp_SecondaryColor3dvEXT(GLbyte * pc) 4776{ 4777#ifdef __GLX_ALIGN64 4778 if ((unsigned long)(pc) & 7) { 4779 (void) memmove(pc-4, pc, 24); 4780 pc -= 4; 4781 } 4782#endif 4783 4784 CALL_SecondaryColor3dvEXT( GET_DISPATCH(), ( 4785 (const GLdouble *)(pc + 0) 4786 ) ); 4787} 4788 4789void __glXDisp_SecondaryColor3fvEXT(GLbyte * pc) 4790{ 4791 CALL_SecondaryColor3fvEXT( GET_DISPATCH(), ( 4792 (const GLfloat *)(pc + 0) 4793 ) ); 4794} 4795 4796void __glXDisp_SecondaryColor3ivEXT(GLbyte * pc) 4797{ 4798 CALL_SecondaryColor3ivEXT( GET_DISPATCH(), ( 4799 (const GLint *)(pc + 0) 4800 ) ); 4801} 4802 4803void __glXDisp_SecondaryColor3svEXT(GLbyte * pc) 4804{ 4805 CALL_SecondaryColor3svEXT( GET_DISPATCH(), ( 4806 (const GLshort *)(pc + 0) 4807 ) ); 4808} 4809 4810void __glXDisp_SecondaryColor3ubvEXT(GLbyte * pc) 4811{ 4812 CALL_SecondaryColor3ubvEXT( GET_DISPATCH(), ( 4813 (const GLubyte *)(pc + 0) 4814 ) ); 4815} 4816 4817void __glXDisp_SecondaryColor3uivEXT(GLbyte * pc) 4818{ 4819 CALL_SecondaryColor3uivEXT( GET_DISPATCH(), ( 4820 (const GLuint *)(pc + 0) 4821 ) ); 4822} 4823 4824void __glXDisp_SecondaryColor3usvEXT(GLbyte * pc) 4825{ 4826 CALL_SecondaryColor3usvEXT( GET_DISPATCH(), ( 4827 (const GLushort *)(pc + 0) 4828 ) ); 4829} 4830 4831void __glXDisp_FogCoorddvEXT(GLbyte * pc) 4832{ 4833#ifdef __GLX_ALIGN64 4834 if ((unsigned long)(pc) & 7) { 4835 (void) memmove(pc-4, pc, 8); 4836 pc -= 4; 4837 } 4838#endif 4839 4840 CALL_FogCoorddvEXT( GET_DISPATCH(), ( 4841 (const GLdouble *)(pc + 0) 4842 ) ); 4843} 4844 4845void __glXDisp_FogCoordfvEXT(GLbyte * pc) 4846{ 4847 CALL_FogCoordfvEXT( GET_DISPATCH(), ( 4848 (const GLfloat *)(pc + 0) 4849 ) ); 4850} 4851 4852void __glXDisp_BlendFuncSeparateEXT(GLbyte * pc) 4853{ 4854 CALL_BlendFuncSeparateEXT( GET_DISPATCH(), ( 4855 *(GLenum *)(pc + 0), 4856 *(GLenum *)(pc + 4), 4857 *(GLenum *)(pc + 8), 4858 *(GLenum *)(pc + 12) 4859 ) ); 4860} 4861 4862void __glXDisp_WindowPos3fvMESA(GLbyte * pc) 4863{ 4864 CALL_WindowPos3fvMESA( GET_DISPATCH(), ( 4865 (const GLfloat *)(pc + 0) 4866 ) ); 4867} 4868 4869int __glXDisp_AreProgramsResidentNV(__GLXclientState *cl, GLbyte *pc) 4870{ 4871 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 4872 int error; 4873 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 4874 4875 pc += __GLX_VENDPRIV_HDR_SIZE; 4876 if ( cx != NULL ) { 4877 const GLsizei n = *(GLsizei *)(pc + 0); 4878 4879 GLboolean retval; 4880 GLboolean answerBuffer[200]; 4881 GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1); 4882 retval = CALL_AreProgramsResidentNV( GET_DISPATCH(), ( 4883 n, 4884 (const GLuint *)(pc + 4), 4885 residences 4886 ) ); 4887 __glXSendReply(cl->client, residences, n, 1, GL_FALSE, retval); 4888 error = Success; 4889 } 4890 4891 return error; 4892} 4893 4894void __glXDisp_BindProgramNV(GLbyte * pc) 4895{ 4896 CALL_BindProgramNV( GET_DISPATCH(), ( 4897 *(GLenum *)(pc + 0), 4898 *(GLuint *)(pc + 4) 4899 ) ); 4900} 4901 4902int __glXDisp_DeleteProgramsNV(__GLXclientState *cl, GLbyte *pc) 4903{ 4904 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 4905 int error; 4906 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 4907 4908 pc += __GLX_VENDPRIV_HDR_SIZE; 4909 if ( cx != NULL ) { 4910 const GLsizei n = *(GLsizei *)(pc + 0); 4911 4912 CALL_DeleteProgramsNV( GET_DISPATCH(), ( 4913 n, 4914 (const GLuint *)(pc + 4) 4915 ) ); 4916 error = Success; 4917 } 4918 4919 return error; 4920} 4921 4922void __glXDisp_ExecuteProgramNV(GLbyte * pc) 4923{ 4924 CALL_ExecuteProgramNV( GET_DISPATCH(), ( 4925 *(GLenum *)(pc + 0), 4926 *(GLuint *)(pc + 4), 4927 (const GLfloat *)(pc + 8) 4928 ) ); 4929} 4930 4931int __glXDisp_GenProgramsNV(__GLXclientState *cl, GLbyte *pc) 4932{ 4933 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 4934 int error; 4935 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 4936 4937 pc += __GLX_VENDPRIV_HDR_SIZE; 4938 if ( cx != NULL ) { 4939 const GLsizei n = *(GLsizei *)(pc + 0); 4940 4941 GLuint answerBuffer[200]; 4942 GLuint * programs = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4); 4943 CALL_GenProgramsNV( GET_DISPATCH(), ( 4944 n, 4945 programs 4946 ) ); 4947 __glXSendReply(cl->client, programs, n, 4, GL_TRUE, 0); 4948 error = Success; 4949 } 4950 4951 return error; 4952} 4953 4954int __glXDisp_GetProgramParameterdvNV(__GLXclientState *cl, GLbyte *pc) 4955{ 4956 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 4957 int error; 4958 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 4959 4960 pc += __GLX_VENDPRIV_HDR_SIZE; 4961 if ( cx != NULL ) { 4962 GLdouble params[4]; 4963 CALL_GetProgramParameterdvNV( GET_DISPATCH(), ( 4964 *(GLenum *)(pc + 0), 4965 *(GLuint *)(pc + 4), 4966 *(GLenum *)(pc + 8), 4967 params 4968 ) ); 4969 __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0); 4970 error = Success; 4971 } 4972 4973 return error; 4974} 4975 4976int __glXDisp_GetProgramParameterfvNV(__GLXclientState *cl, GLbyte *pc) 4977{ 4978 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 4979 int error; 4980 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 4981 4982 pc += __GLX_VENDPRIV_HDR_SIZE; 4983 if ( cx != NULL ) { 4984 GLfloat params[4]; 4985 CALL_GetProgramParameterfvNV( GET_DISPATCH(), ( 4986 *(GLenum *)(pc + 0), 4987 *(GLuint *)(pc + 4), 4988 *(GLenum *)(pc + 8), 4989 params 4990 ) ); 4991 __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0); 4992 error = Success; 4993 } 4994 4995 return error; 4996} 4997 4998int __glXDisp_GetProgramivNV(__GLXclientState *cl, GLbyte *pc) 4999{ 5000 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 5001 int error; 5002 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 5003 5004 pc += __GLX_VENDPRIV_HDR_SIZE; 5005 if ( cx != NULL ) { 5006 const GLenum pname = *(GLenum *)(pc + 4); 5007 5008 const GLuint compsize = __glGetProgramivNV_size(pname); 5009 GLint answerBuffer[200]; 5010 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 5011 5012 if (params == NULL) return BadAlloc; 5013 __glXClearErrorOccured(); 5014 5015 CALL_GetProgramivNV( GET_DISPATCH(), ( 5016 *(GLuint *)(pc + 0), 5017 pname, 5018 params 5019 ) ); 5020 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 5021 error = Success; 5022 } 5023 5024 return error; 5025} 5026 5027int __glXDisp_GetTrackMatrixivNV(__GLXclientState *cl, GLbyte *pc) 5028{ 5029 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 5030 int error; 5031 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 5032 5033 pc += __GLX_VENDPRIV_HDR_SIZE; 5034 if ( cx != NULL ) { 5035 GLint params[1]; 5036 CALL_GetTrackMatrixivNV( GET_DISPATCH(), ( 5037 *(GLenum *)(pc + 0), 5038 *(GLuint *)(pc + 4), 5039 *(GLenum *)(pc + 8), 5040 params 5041 ) ); 5042 __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0); 5043 error = Success; 5044 } 5045 5046 return error; 5047} 5048 5049int __glXDisp_GetVertexAttribdvNV(__GLXclientState *cl, GLbyte *pc) 5050{ 5051 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 5052 int error; 5053 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 5054 5055 pc += __GLX_VENDPRIV_HDR_SIZE; 5056 if ( cx != NULL ) { 5057 const GLenum pname = *(GLenum *)(pc + 4); 5058 5059 const GLuint compsize = __glGetVertexAttribdvNV_size(pname); 5060 GLdouble answerBuffer[200]; 5061 GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8); 5062 5063 if (params == NULL) return BadAlloc; 5064 __glXClearErrorOccured(); 5065 5066 CALL_GetVertexAttribdvNV( GET_DISPATCH(), ( 5067 *(GLuint *)(pc + 0), 5068 pname, 5069 params 5070 ) ); 5071 __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0); 5072 error = Success; 5073 } 5074 5075 return error; 5076} 5077 5078int __glXDisp_GetVertexAttribfvNV(__GLXclientState *cl, GLbyte *pc) 5079{ 5080 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 5081 int error; 5082 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 5083 5084 pc += __GLX_VENDPRIV_HDR_SIZE; 5085 if ( cx != NULL ) { 5086 const GLenum pname = *(GLenum *)(pc + 4); 5087 5088 const GLuint compsize = __glGetVertexAttribfvNV_size(pname); 5089 GLfloat answerBuffer[200]; 5090 GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 5091 5092 if (params == NULL) return BadAlloc; 5093 __glXClearErrorOccured(); 5094 5095 CALL_GetVertexAttribfvNV( GET_DISPATCH(), ( 5096 *(GLuint *)(pc + 0), 5097 pname, 5098 params 5099 ) ); 5100 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 5101 error = Success; 5102 } 5103 5104 return error; 5105} 5106 5107int __glXDisp_GetVertexAttribivNV(__GLXclientState *cl, GLbyte *pc) 5108{ 5109 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 5110 int error; 5111 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 5112 5113 pc += __GLX_VENDPRIV_HDR_SIZE; 5114 if ( cx != NULL ) { 5115 const GLenum pname = *(GLenum *)(pc + 4); 5116 5117 const GLuint compsize = __glGetVertexAttribivNV_size(pname); 5118 GLint answerBuffer[200]; 5119 GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4); 5120 5121 if (params == NULL) return BadAlloc; 5122 __glXClearErrorOccured(); 5123 5124 CALL_GetVertexAttribivNV( GET_DISPATCH(), ( 5125 *(GLuint *)(pc + 0), 5126 pname, 5127 params 5128 ) ); 5129 __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0); 5130 error = Success; 5131 } 5132 5133 return error; 5134} 5135 5136int __glXDisp_IsProgramNV(__GLXclientState *cl, GLbyte *pc) 5137{ 5138 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 5139 int error; 5140 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 5141 5142 pc += __GLX_VENDPRIV_HDR_SIZE; 5143 if ( cx != NULL ) { 5144 GLboolean retval; 5145 retval = CALL_IsProgramNV( GET_DISPATCH(), ( 5146 *(GLuint *)(pc + 0) 5147 ) ); 5148 __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); 5149 error = Success; 5150 } 5151 5152 return error; 5153} 5154 5155void __glXDisp_LoadProgramNV(GLbyte * pc) 5156{ 5157 const GLsizei len = *(GLsizei *)(pc + 8); 5158 5159 CALL_LoadProgramNV( GET_DISPATCH(), ( 5160 *(GLenum *)(pc + 0), 5161 *(GLuint *)(pc + 4), 5162 len, 5163 (const GLubyte *)(pc + 12) 5164 ) ); 5165} 5166 5167void __glXDisp_ProgramParameters4dvNV(GLbyte * pc) 5168{ 5169 const GLuint num = *(GLuint *)(pc + 8); 5170 5171#ifdef __GLX_ALIGN64 5172 const GLuint cmdlen = 16 + __GLX_PAD((num * 32)) - 4; 5173 if ((unsigned long)(pc) & 7) { 5174 (void) memmove(pc-4, pc, cmdlen); 5175 pc -= 4; 5176 } 5177#endif 5178 5179 CALL_ProgramParameters4dvNV( GET_DISPATCH(), ( 5180 *(GLenum *)(pc + 0), 5181 *(GLuint *)(pc + 4), 5182 num, 5183 (const GLdouble *)(pc + 12) 5184 ) ); 5185} 5186 5187void __glXDisp_ProgramParameters4fvNV(GLbyte * pc) 5188{ 5189 const GLuint num = *(GLuint *)(pc + 8); 5190 5191 CALL_ProgramParameters4fvNV( GET_DISPATCH(), ( 5192 *(GLenum *)(pc + 0), 5193 *(GLuint *)(pc + 4), 5194 num, 5195 (const GLfloat *)(pc + 12) 5196 ) ); 5197} 5198 5199void __glXDisp_RequestResidentProgramsNV(GLbyte * pc) 5200{ 5201 const GLsizei n = *(GLsizei *)(pc + 0); 5202 5203 CALL_RequestResidentProgramsNV( GET_DISPATCH(), ( 5204 n, 5205 (const GLuint *)(pc + 4) 5206 ) ); 5207} 5208 5209void __glXDisp_TrackMatrixNV(GLbyte * pc) 5210{ 5211 CALL_TrackMatrixNV( GET_DISPATCH(), ( 5212 *(GLenum *)(pc + 0), 5213 *(GLuint *)(pc + 4), 5214 *(GLenum *)(pc + 8), 5215 *(GLenum *)(pc + 12) 5216 ) ); 5217} 5218 5219void __glXDisp_VertexAttrib1dvNV(GLbyte * pc) 5220{ 5221#ifdef __GLX_ALIGN64 5222 if ((unsigned long)(pc) & 7) { 5223 (void) memmove(pc-4, pc, 12); 5224 pc -= 4; 5225 } 5226#endif 5227 5228 CALL_VertexAttrib1dvNV( GET_DISPATCH(), ( 5229 *(GLuint *)(pc + 0), 5230 (const GLdouble *)(pc + 4) 5231 ) ); 5232} 5233 5234void __glXDisp_VertexAttrib1fvNV(GLbyte * pc) 5235{ 5236 CALL_VertexAttrib1fvNV( GET_DISPATCH(), ( 5237 *(GLuint *)(pc + 0), 5238 (const GLfloat *)(pc + 4) 5239 ) ); 5240} 5241 5242void __glXDisp_VertexAttrib1svNV(GLbyte * pc) 5243{ 5244 CALL_VertexAttrib1svNV( GET_DISPATCH(), ( 5245 *(GLuint *)(pc + 0), 5246 (const GLshort *)(pc + 4) 5247 ) ); 5248} 5249 5250void __glXDisp_VertexAttrib2dvNV(GLbyte * pc) 5251{ 5252#ifdef __GLX_ALIGN64 5253 if ((unsigned long)(pc) & 7) { 5254 (void) memmove(pc-4, pc, 20); 5255 pc -= 4; 5256 } 5257#endif 5258 5259 CALL_VertexAttrib2dvNV( GET_DISPATCH(), ( 5260 *(GLuint *)(pc + 0), 5261 (const GLdouble *)(pc + 4) 5262 ) ); 5263} 5264 5265void __glXDisp_VertexAttrib2fvNV(GLbyte * pc) 5266{ 5267 CALL_VertexAttrib2fvNV( GET_DISPATCH(), ( 5268 *(GLuint *)(pc + 0), 5269 (const GLfloat *)(pc + 4) 5270 ) ); 5271} 5272 5273void __glXDisp_VertexAttrib2svNV(GLbyte * pc) 5274{ 5275 CALL_VertexAttrib2svNV( GET_DISPATCH(), ( 5276 *(GLuint *)(pc + 0), 5277 (const GLshort *)(pc + 4) 5278 ) ); 5279} 5280 5281void __glXDisp_VertexAttrib3dvNV(GLbyte * pc) 5282{ 5283#ifdef __GLX_ALIGN64 5284 if ((unsigned long)(pc) & 7) { 5285 (void) memmove(pc-4, pc, 28); 5286 pc -= 4; 5287 } 5288#endif 5289 5290 CALL_VertexAttrib3dvNV( GET_DISPATCH(), ( 5291 *(GLuint *)(pc + 0), 5292 (const GLdouble *)(pc + 4) 5293 ) ); 5294} 5295 5296void __glXDisp_VertexAttrib3fvNV(GLbyte * pc) 5297{ 5298 CALL_VertexAttrib3fvNV( GET_DISPATCH(), ( 5299 *(GLuint *)(pc + 0), 5300 (const GLfloat *)(pc + 4) 5301 ) ); 5302} 5303 5304void __glXDisp_VertexAttrib3svNV(GLbyte * pc) 5305{ 5306 CALL_VertexAttrib3svNV( GET_DISPATCH(), ( 5307 *(GLuint *)(pc + 0), 5308 (const GLshort *)(pc + 4) 5309 ) ); 5310} 5311 5312void __glXDisp_VertexAttrib4dvNV(GLbyte * pc) 5313{ 5314#ifdef __GLX_ALIGN64 5315 if ((unsigned long)(pc) & 7) { 5316 (void) memmove(pc-4, pc, 36); 5317 pc -= 4; 5318 } 5319#endif 5320 5321 CALL_VertexAttrib4dvNV( GET_DISPATCH(), ( 5322 *(GLuint *)(pc + 0), 5323 (const GLdouble *)(pc + 4) 5324 ) ); 5325} 5326 5327void __glXDisp_VertexAttrib4fvNV(GLbyte * pc) 5328{ 5329 CALL_VertexAttrib4fvNV( GET_DISPATCH(), ( 5330 *(GLuint *)(pc + 0), 5331 (const GLfloat *)(pc + 4) 5332 ) ); 5333} 5334 5335void __glXDisp_VertexAttrib4svNV(GLbyte * pc) 5336{ 5337 CALL_VertexAttrib4svNV( GET_DISPATCH(), ( 5338 *(GLuint *)(pc + 0), 5339 (const GLshort *)(pc + 4) 5340 ) ); 5341} 5342 5343void __glXDisp_VertexAttrib4ubvNV(GLbyte * pc) 5344{ 5345 CALL_VertexAttrib4ubvNV( GET_DISPATCH(), ( 5346 *(GLuint *)(pc + 0), 5347 (const GLubyte *)(pc + 4) 5348 ) ); 5349} 5350 5351void __glXDisp_VertexAttribs1dvNV(GLbyte * pc) 5352{ 5353 const GLsizei n = *(GLsizei *)(pc + 4); 5354 5355#ifdef __GLX_ALIGN64 5356 const GLuint cmdlen = 12 + __GLX_PAD((n * 8)) - 4; 5357 if ((unsigned long)(pc) & 7) { 5358 (void) memmove(pc-4, pc, cmdlen); 5359 pc -= 4; 5360 } 5361#endif 5362 5363 CALL_VertexAttribs1dvNV( GET_DISPATCH(), ( 5364 *(GLuint *)(pc + 0), 5365 n, 5366 (const GLdouble *)(pc + 8) 5367 ) ); 5368} 5369 5370void __glXDisp_VertexAttribs1fvNV(GLbyte * pc) 5371{ 5372 const GLsizei n = *(GLsizei *)(pc + 4); 5373 5374 CALL_VertexAttribs1fvNV( GET_DISPATCH(), ( 5375 *(GLuint *)(pc + 0), 5376 n, 5377 (const GLfloat *)(pc + 8) 5378 ) ); 5379} 5380 5381void __glXDisp_VertexAttribs1svNV(GLbyte * pc) 5382{ 5383 const GLsizei n = *(GLsizei *)(pc + 4); 5384 5385 CALL_VertexAttribs1svNV( GET_DISPATCH(), ( 5386 *(GLuint *)(pc + 0), 5387 n, 5388 (const GLshort *)(pc + 8) 5389 ) ); 5390} 5391 5392void __glXDisp_VertexAttribs2dvNV(GLbyte * pc) 5393{ 5394 const GLsizei n = *(GLsizei *)(pc + 4); 5395 5396#ifdef __GLX_ALIGN64 5397 const GLuint cmdlen = 12 + __GLX_PAD((n * 16)) - 4; 5398 if ((unsigned long)(pc) & 7) { 5399 (void) memmove(pc-4, pc, cmdlen); 5400 pc -= 4; 5401 } 5402#endif 5403 5404 CALL_VertexAttribs2dvNV( GET_DISPATCH(), ( 5405 *(GLuint *)(pc + 0), 5406 n, 5407 (const GLdouble *)(pc + 8) 5408 ) ); 5409} 5410 5411void __glXDisp_VertexAttribs2fvNV(GLbyte * pc) 5412{ 5413 const GLsizei n = *(GLsizei *)(pc + 4); 5414 5415 CALL_VertexAttribs2fvNV( GET_DISPATCH(), ( 5416 *(GLuint *)(pc + 0), 5417 n, 5418 (const GLfloat *)(pc + 8) 5419 ) ); 5420} 5421 5422void __glXDisp_VertexAttribs2svNV(GLbyte * pc) 5423{ 5424 const GLsizei n = *(GLsizei *)(pc + 4); 5425 5426 CALL_VertexAttribs2svNV( GET_DISPATCH(), ( 5427 *(GLuint *)(pc + 0), 5428 n, 5429 (const GLshort *)(pc + 8) 5430 ) ); 5431} 5432 5433void __glXDisp_VertexAttribs3dvNV(GLbyte * pc) 5434{ 5435 const GLsizei n = *(GLsizei *)(pc + 4); 5436 5437#ifdef __GLX_ALIGN64 5438 const GLuint cmdlen = 12 + __GLX_PAD((n * 24)) - 4; 5439 if ((unsigned long)(pc) & 7) { 5440 (void) memmove(pc-4, pc, cmdlen); 5441 pc -= 4; 5442 } 5443#endif 5444 5445 CALL_VertexAttribs3dvNV( GET_DISPATCH(), ( 5446 *(GLuint *)(pc + 0), 5447 n, 5448 (const GLdouble *)(pc + 8) 5449 ) ); 5450} 5451 5452void __glXDisp_VertexAttribs3fvNV(GLbyte * pc) 5453{ 5454 const GLsizei n = *(GLsizei *)(pc + 4); 5455 5456 CALL_VertexAttribs3fvNV( GET_DISPATCH(), ( 5457 *(GLuint *)(pc + 0), 5458 n, 5459 (const GLfloat *)(pc + 8) 5460 ) ); 5461} 5462 5463void __glXDisp_VertexAttribs3svNV(GLbyte * pc) 5464{ 5465 const GLsizei n = *(GLsizei *)(pc + 4); 5466 5467 CALL_VertexAttribs3svNV( GET_DISPATCH(), ( 5468 *(GLuint *)(pc + 0), 5469 n, 5470 (const GLshort *)(pc + 8) 5471 ) ); 5472} 5473 5474void __glXDisp_VertexAttribs4dvNV(GLbyte * pc) 5475{ 5476 const GLsizei n = *(GLsizei *)(pc + 4); 5477 5478#ifdef __GLX_ALIGN64 5479 const GLuint cmdlen = 12 + __GLX_PAD((n * 32)) - 4; 5480 if ((unsigned long)(pc) & 7) { 5481 (void) memmove(pc-4, pc, cmdlen); 5482 pc -= 4; 5483 } 5484#endif 5485 5486 CALL_VertexAttribs4dvNV( GET_DISPATCH(), ( 5487 *(GLuint *)(pc + 0), 5488 n, 5489 (const GLdouble *)(pc + 8) 5490 ) ); 5491} 5492 5493void __glXDisp_VertexAttribs4fvNV(GLbyte * pc) 5494{ 5495 const GLsizei n = *(GLsizei *)(pc + 4); 5496 5497 CALL_VertexAttribs4fvNV( GET_DISPATCH(), ( 5498 *(GLuint *)(pc + 0), 5499 n, 5500 (const GLfloat *)(pc + 8) 5501 ) ); 5502} 5503 5504void __glXDisp_VertexAttribs4svNV(GLbyte * pc) 5505{ 5506 const GLsizei n = *(GLsizei *)(pc + 4); 5507 5508 CALL_VertexAttribs4svNV( GET_DISPATCH(), ( 5509 *(GLuint *)(pc + 0), 5510 n, 5511 (const GLshort *)(pc + 8) 5512 ) ); 5513} 5514 5515void __glXDisp_VertexAttribs4ubvNV(GLbyte * pc) 5516{ 5517 const GLsizei n = *(GLsizei *)(pc + 4); 5518 5519 CALL_VertexAttribs4ubvNV( GET_DISPATCH(), ( 5520 *(GLuint *)(pc + 0), 5521 n, 5522 (const GLubyte *)(pc + 8) 5523 ) ); 5524} 5525 5526void __glXDisp_PointParameteriNV(GLbyte * pc) 5527{ 5528 CALL_PointParameteriNV( GET_DISPATCH(), ( 5529 *(GLenum *)(pc + 0), 5530 *(GLint *)(pc + 4) 5531 ) ); 5532} 5533 5534void __glXDisp_PointParameterivNV(GLbyte * pc) 5535{ 5536 const GLenum pname = *(GLenum *)(pc + 0); 5537 const GLint * params; 5538 5539 params = (const GLint *) (pc + 4); 5540 5541 CALL_PointParameterivNV( GET_DISPATCH(), ( 5542 pname, 5543 params 5544 ) ); 5545} 5546 5547void __glXDisp_ActiveStencilFaceEXT(GLbyte * pc) 5548{ 5549 CALL_ActiveStencilFaceEXT( GET_DISPATCH(), ( 5550 *(GLenum *)(pc + 0) 5551 ) ); 5552} 5553 5554int __glXDisp_GetProgramNamedParameterdvNV(__GLXclientState *cl, GLbyte *pc) 5555{ 5556 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 5557 int error; 5558 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 5559 5560 pc += __GLX_VENDPRIV_HDR_SIZE; 5561 if ( cx != NULL ) { 5562 const GLsizei len = *(GLsizei *)(pc + 4); 5563 5564 GLdouble params[4]; 5565 CALL_GetProgramNamedParameterdvNV( GET_DISPATCH(), ( 5566 *(GLuint *)(pc + 0), 5567 len, 5568 (const GLubyte *)(pc + 8), 5569 params 5570 ) ); 5571 __glXSendReply(cl->client, params, 4, 8, GL_TRUE, 0); 5572 error = Success; 5573 } 5574 5575 return error; 5576} 5577 5578int __glXDisp_GetProgramNamedParameterfvNV(__GLXclientState *cl, GLbyte *pc) 5579{ 5580 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 5581 int error; 5582 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 5583 5584 pc += __GLX_VENDPRIV_HDR_SIZE; 5585 if ( cx != NULL ) { 5586 const GLsizei len = *(GLsizei *)(pc + 4); 5587 5588 GLfloat params[4]; 5589 CALL_GetProgramNamedParameterfvNV( GET_DISPATCH(), ( 5590 *(GLuint *)(pc + 0), 5591 len, 5592 (const GLubyte *)(pc + 8), 5593 params 5594 ) ); 5595 __glXSendReply(cl->client, params, 4, 4, GL_TRUE, 0); 5596 error = Success; 5597 } 5598 5599 return error; 5600} 5601 5602void __glXDisp_ProgramNamedParameter4dvNV(GLbyte * pc) 5603{ 5604 const GLsizei len = *(GLsizei *)(pc + 36); 5605 5606#ifdef __GLX_ALIGN64 5607 const GLuint cmdlen = 44 + __GLX_PAD(len) - 4; 5608 if ((unsigned long)(pc) & 7) { 5609 (void) memmove(pc-4, pc, cmdlen); 5610 pc -= 4; 5611 } 5612#endif 5613 5614 CALL_ProgramNamedParameter4dvNV( GET_DISPATCH(), ( 5615 *(GLuint *)(pc + 32), 5616 len, 5617 (const GLubyte *)(pc + 40), 5618 (const GLdouble *)(pc + 0) 5619 ) ); 5620} 5621 5622void __glXDisp_ProgramNamedParameter4fvNV(GLbyte * pc) 5623{ 5624 const GLsizei len = *(GLsizei *)(pc + 4); 5625 5626 CALL_ProgramNamedParameter4fvNV( GET_DISPATCH(), ( 5627 *(GLuint *)(pc + 0), 5628 len, 5629 (const GLubyte *)(pc + 24), 5630 (const GLfloat *)(pc + 8) 5631 ) ); 5632} 5633 5634void __glXDisp_BlendEquationSeparateEXT(GLbyte * pc) 5635{ 5636 CALL_BlendEquationSeparateEXT( GET_DISPATCH(), ( 5637 *(GLenum *)(pc + 0), 5638 *(GLenum *)(pc + 4) 5639 ) ); 5640} 5641 5642void __glXDisp_BindFramebufferEXT(GLbyte * pc) 5643{ 5644 CALL_BindFramebufferEXT( GET_DISPATCH(), ( 5645 *(GLenum *)(pc + 0), 5646 *(GLuint *)(pc + 4) 5647 ) ); 5648} 5649 5650void __glXDisp_BindRenderbufferEXT(GLbyte * pc) 5651{ 5652 CALL_BindRenderbufferEXT( GET_DISPATCH(), ( 5653 *(GLenum *)(pc + 0), 5654 *(GLuint *)(pc + 4) 5655 ) ); 5656} 5657 5658int __glXDisp_CheckFramebufferStatusEXT(__GLXclientState *cl, GLbyte *pc) 5659{ 5660 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 5661 int error; 5662 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 5663 5664 pc += __GLX_VENDPRIV_HDR_SIZE; 5665 if ( cx != NULL ) { 5666 GLenum retval; 5667 retval = CALL_CheckFramebufferStatusEXT( GET_DISPATCH(), ( 5668 *(GLenum *)(pc + 0) 5669 ) ); 5670 __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); 5671 error = Success; 5672 } 5673 5674 return error; 5675} 5676 5677void __glXDisp_DeleteFramebuffersEXT(GLbyte * pc) 5678{ 5679 const GLsizei n = *(GLsizei *)(pc + 0); 5680 5681 CALL_DeleteFramebuffersEXT( GET_DISPATCH(), ( 5682 n, 5683 (const GLuint *)(pc + 4) 5684 ) ); 5685} 5686 5687void __glXDisp_DeleteRenderbuffersEXT(GLbyte * pc) 5688{ 5689 const GLsizei n = *(GLsizei *)(pc + 0); 5690 5691 CALL_DeleteRenderbuffersEXT( GET_DISPATCH(), ( 5692 n, 5693 (const GLuint *)(pc + 4) 5694 ) ); 5695} 5696 5697void __glXDisp_FramebufferRenderbufferEXT(GLbyte * pc) 5698{ 5699 CALL_FramebufferRenderbufferEXT( GET_DISPATCH(), ( 5700 *(GLenum *)(pc + 0), 5701 *(GLenum *)(pc + 4), 5702 *(GLenum *)(pc + 8), 5703 *(GLuint *)(pc + 12) 5704 ) ); 5705} 5706 5707void __glXDisp_FramebufferTexture1DEXT(GLbyte * pc) 5708{ 5709 CALL_FramebufferTexture1DEXT( GET_DISPATCH(), ( 5710 *(GLenum *)(pc + 0), 5711 *(GLenum *)(pc + 4), 5712 *(GLenum *)(pc + 8), 5713 *(GLuint *)(pc + 12), 5714 *(GLint *)(pc + 16) 5715 ) ); 5716} 5717 5718void __glXDisp_FramebufferTexture2DEXT(GLbyte * pc) 5719{ 5720 CALL_FramebufferTexture2DEXT( GET_DISPATCH(), ( 5721 *(GLenum *)(pc + 0), 5722 *(GLenum *)(pc + 4), 5723 *(GLenum *)(pc + 8), 5724 *(GLuint *)(pc + 12), 5725 *(GLint *)(pc + 16) 5726 ) ); 5727} 5728 5729void __glXDisp_FramebufferTexture3DEXT(GLbyte * pc) 5730{ 5731 CALL_FramebufferTexture3DEXT( GET_DISPATCH(), ( 5732 *(GLenum *)(pc + 0), 5733 *(GLenum *)(pc + 4), 5734 *(GLenum *)(pc + 8), 5735 *(GLuint *)(pc + 12), 5736 *(GLint *)(pc + 16), 5737 *(GLint *)(pc + 20) 5738 ) ); 5739} 5740 5741int __glXDisp_GenFramebuffersEXT(__GLXclientState *cl, GLbyte *pc) 5742{ 5743 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 5744 int error; 5745 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 5746 5747 pc += __GLX_VENDPRIV_HDR_SIZE; 5748 if ( cx != NULL ) { 5749 const GLsizei n = *(GLsizei *)(pc + 0); 5750 5751 GLuint answerBuffer[200]; 5752 GLuint * framebuffers = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4); 5753 CALL_GenFramebuffersEXT( GET_DISPATCH(), ( 5754 n, 5755 framebuffers 5756 ) ); 5757 __glXSendReply(cl->client, framebuffers, n, 4, GL_TRUE, 0); 5758 error = Success; 5759 } 5760 5761 return error; 5762} 5763 5764int __glXDisp_GenRenderbuffersEXT(__GLXclientState *cl, GLbyte *pc) 5765{ 5766 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 5767 int error; 5768 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 5769 5770 pc += __GLX_VENDPRIV_HDR_SIZE; 5771 if ( cx != NULL ) { 5772 const GLsizei n = *(GLsizei *)(pc + 0); 5773 5774 GLuint answerBuffer[200]; 5775 GLuint * renderbuffers = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4); 5776 CALL_GenRenderbuffersEXT( GET_DISPATCH(), ( 5777 n, 5778 renderbuffers 5779 ) ); 5780 __glXSendReply(cl->client, renderbuffers, n, 4, GL_TRUE, 0); 5781 error = Success; 5782 } 5783 5784 return error; 5785} 5786 5787void __glXDisp_GenerateMipmapEXT(GLbyte * pc) 5788{ 5789 CALL_GenerateMipmapEXT( GET_DISPATCH(), ( 5790 *(GLenum *)(pc + 0) 5791 ) ); 5792} 5793 5794int __glXDisp_GetFramebufferAttachmentParameterivEXT(__GLXclientState *cl, GLbyte *pc) 5795{ 5796 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 5797 int error; 5798 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 5799 5800 pc += __GLX_VENDPRIV_HDR_SIZE; 5801 if ( cx != NULL ) { 5802 GLint params[1]; 5803 CALL_GetFramebufferAttachmentParameterivEXT( GET_DISPATCH(), ( 5804 *(GLenum *)(pc + 0), 5805 *(GLenum *)(pc + 4), 5806 *(GLenum *)(pc + 8), 5807 params 5808 ) ); 5809 __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0); 5810 error = Success; 5811 } 5812 5813 return error; 5814} 5815 5816int __glXDisp_GetRenderbufferParameterivEXT(__GLXclientState *cl, GLbyte *pc) 5817{ 5818 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 5819 int error; 5820 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 5821 5822 pc += __GLX_VENDPRIV_HDR_SIZE; 5823 if ( cx != NULL ) { 5824 GLint params[1]; 5825 CALL_GetRenderbufferParameterivEXT( GET_DISPATCH(), ( 5826 *(GLenum *)(pc + 0), 5827 *(GLenum *)(pc + 4), 5828 params 5829 ) ); 5830 __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0); 5831 error = Success; 5832 } 5833 5834 return error; 5835} 5836 5837int __glXDisp_IsFramebufferEXT(__GLXclientState *cl, GLbyte *pc) 5838{ 5839 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 5840 int error; 5841 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 5842 5843 pc += __GLX_VENDPRIV_HDR_SIZE; 5844 if ( cx != NULL ) { 5845 GLboolean retval; 5846 retval = CALL_IsFramebufferEXT( GET_DISPATCH(), ( 5847 *(GLuint *)(pc + 0) 5848 ) ); 5849 __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); 5850 error = Success; 5851 } 5852 5853 return error; 5854} 5855 5856int __glXDisp_IsRenderbufferEXT(__GLXclientState *cl, GLbyte *pc) 5857{ 5858 xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc; 5859 int error; 5860 __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error); 5861 5862 pc += __GLX_VENDPRIV_HDR_SIZE; 5863 if ( cx != NULL ) { 5864 GLboolean retval; 5865 retval = CALL_IsRenderbufferEXT( GET_DISPATCH(), ( 5866 *(GLuint *)(pc + 0) 5867 ) ); 5868 __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval); 5869 error = Success; 5870 } 5871 5872 return error; 5873} 5874 5875void __glXDisp_RenderbufferStorageEXT(GLbyte * pc) 5876{ 5877 CALL_RenderbufferStorageEXT( GET_DISPATCH(), ( 5878 *(GLenum *)(pc + 0), 5879 *(GLenum *)(pc + 4), 5880 *(GLsizei *)(pc + 8), 5881 *(GLsizei *)(pc + 12) 5882 ) ); 5883} 5884 5885