1/* 2 * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) 3 * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved. 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 * and/or sell copies of the Software, and to permit persons to whom the 10 * Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice including the dates of first publication and 13 * either this permission notice or a reference to 14 * http://oss.sgi.com/projects/FreeB/ 15 * shall be included in all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 21 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF 22 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 23 * SOFTWARE. 24 * 25 * Except as contained in this notice, the name of Silicon Graphics, Inc. 26 * shall not be used in advertising or otherwise to promote the sale, use or 27 * other dealings in this Software without prior written authorization from 28 * Silicon Graphics, Inc. 29 */ 30 31#include "glxserver.h" 32#include "glxext.h" 33#include "g_disptab.h" 34#include "unpack.h" 35#include "compsize.h" 36 37void __glXDispSwap_CallList(GLbyte *pc) 38{ 39 __GLX_DECLARE_SWAP_VARIABLES; 40 41 __GLX_SWAP_INT(pc + 0); 42 43} 44 45void __glXDispSwap_ListBase(GLbyte *pc) 46{ 47 __GLX_DECLARE_SWAP_VARIABLES; 48 49 __GLX_SWAP_INT(pc + 0); 50 51} 52 53void __glXDispSwap_Begin(GLbyte *pc) 54{ 55 __GLX_DECLARE_SWAP_VARIABLES; 56 57 __GLX_SWAP_INT(pc + 0); 58 59} 60 61void __glXDispSwap_Color3bv(GLbyte *pc) 62{ 63} 64 65void __glXDispSwap_Color3dv(GLbyte *pc) 66{ 67 __GLX_DECLARE_SWAP_VARIABLES; 68 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 69 70 71#ifdef __GLX_ALIGN64 72 if ((unsigned long)(pc) & 7) { 73 __GLX_MEM_COPY(pc-4, pc, 24); 74 pc -= 4; 75 } 76#endif 77 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3); 78 79} 80 81void __glXDispSwap_Color3fv(GLbyte *pc) 82{ 83 __GLX_DECLARE_SWAP_VARIABLES; 84 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 85 86 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 3); 87} 88 89void __glXDispSwap_Color3iv(GLbyte *pc) 90{ 91 __GLX_DECLARE_SWAP_VARIABLES; 92 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 93 94 __GLX_SWAP_INT_ARRAY(pc + 0, 3); 95 96} 97 98void __glXDispSwap_Color3sv(GLbyte *pc) 99{ 100 __GLX_DECLARE_SWAP_VARIABLES; 101 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 102 103 __GLX_SWAP_SHORT_ARRAY(pc + 0, 3); 104 105} 106 107void __glXDispSwap_Color3ubv(GLbyte *pc) 108{ 109} 110 111void __glXDispSwap_Color3uiv(GLbyte *pc) 112{ 113 __GLX_DECLARE_SWAP_VARIABLES; 114 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 115 116 __GLX_SWAP_INT_ARRAY(pc + 0, 3); 117} 118 119void __glXDispSwap_Color3usv(GLbyte *pc) 120{ 121 __GLX_DECLARE_SWAP_VARIABLES; 122 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 123 124 __GLX_SWAP_SHORT_ARRAY(pc + 0, 3); 125} 126 127void __glXDispSwap_Color4bv(GLbyte *pc) 128{ 129} 130 131void __glXDispSwap_Color4dv(GLbyte *pc) 132{ 133 __GLX_DECLARE_SWAP_VARIABLES; 134 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 135 136 137#ifdef __GLX_ALIGN64 138 if ((unsigned long)(pc) & 7) { 139 __GLX_MEM_COPY(pc-4, pc, 32); 140 pc -= 4; 141 } 142#endif 143 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4); 144} 145 146void __glXDispSwap_Color4fv(GLbyte *pc) 147{ 148 __GLX_DECLARE_SWAP_VARIABLES; 149 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 150 151 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 4); 152 153} 154 155void __glXDispSwap_Color4iv(GLbyte *pc) 156{ 157 __GLX_DECLARE_SWAP_VARIABLES; 158 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 159 160 __GLX_SWAP_INT_ARRAY(pc + 0, 4); 161 162} 163 164void __glXDispSwap_Color4sv(GLbyte *pc) 165{ 166 __GLX_DECLARE_SWAP_VARIABLES; 167 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 168 169 __GLX_SWAP_SHORT_ARRAY(pc + 0, 4); 170 171} 172 173void __glXDispSwap_Color4ubv(GLbyte *pc) 174{ 175 176} 177 178void __glXDispSwap_Color4uiv(GLbyte *pc) 179{ 180 __GLX_DECLARE_SWAP_VARIABLES; 181 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 182 183 __GLX_SWAP_INT_ARRAY(pc + 0, 4); 184 185} 186 187void __glXDispSwap_Color4usv(GLbyte *pc) 188{ 189 __GLX_DECLARE_SWAP_VARIABLES; 190 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 191 192 __GLX_SWAP_SHORT_ARRAY(pc + 0, 4); 193 194} 195 196void __glXDispSwap_EdgeFlagv(GLbyte *pc) 197{ 198} 199 200void __glXDispSwap_End(GLbyte *pc) 201{ 202} 203 204void __glXDispSwap_Indexdv(GLbyte *pc) 205{ 206 __GLX_DECLARE_SWAP_VARIABLES; 207 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 208 209 210#ifdef __GLX_ALIGN64 211 if ((unsigned long)(pc) & 7) { 212 __GLX_MEM_COPY(pc-4, pc, 8); 213 pc -= 4; 214 } 215#endif 216 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1); 217 218} 219 220void __glXDispSwap_Indexfv(GLbyte *pc) 221{ 222 __GLX_DECLARE_SWAP_VARIABLES; 223 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 224 225 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 1); 226 227} 228 229void __glXDispSwap_Indexiv(GLbyte *pc) 230{ 231 __GLX_DECLARE_SWAP_VARIABLES; 232 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 233 234 __GLX_SWAP_INT_ARRAY(pc + 0, 1); 235 236} 237 238void __glXDispSwap_Indexsv(GLbyte *pc) 239{ 240 __GLX_DECLARE_SWAP_VARIABLES; 241 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 242 243 __GLX_SWAP_SHORT_ARRAY(pc + 0, 1); 244 245} 246 247void __glXDispSwap_Normal3bv(GLbyte *pc) 248{ 249} 250 251void __glXDispSwap_Normal3dv(GLbyte *pc) 252{ 253 __GLX_DECLARE_SWAP_VARIABLES; 254 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 255 256 257#ifdef __GLX_ALIGN64 258 if ((unsigned long)(pc) & 7) { 259 __GLX_MEM_COPY(pc-4, pc, 24); 260 pc -= 4; 261 } 262#endif 263 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3); 264 265} 266 267void __glXDispSwap_Normal3fv(GLbyte *pc) 268{ 269 __GLX_DECLARE_SWAP_VARIABLES; 270 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 271 272 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 3); 273 274} 275 276void __glXDispSwap_Normal3iv(GLbyte *pc) 277{ 278 __GLX_DECLARE_SWAP_VARIABLES; 279 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 280 281 __GLX_SWAP_INT_ARRAY(pc + 0, 3); 282 283} 284 285void __glXDispSwap_Normal3sv(GLbyte *pc) 286{ 287 __GLX_DECLARE_SWAP_VARIABLES; 288 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 289 290 __GLX_SWAP_SHORT_ARRAY(pc + 0, 3); 291 292} 293 294void __glXDispSwap_RasterPos2dv(GLbyte *pc) 295{ 296 __GLX_DECLARE_SWAP_VARIABLES; 297 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 298 299 300#ifdef __GLX_ALIGN64 301 if ((unsigned long)(pc) & 7) { 302 __GLX_MEM_COPY(pc-4, pc, 16); 303 pc -= 4; 304 } 305#endif 306 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2); 307 308} 309 310void __glXDispSwap_RasterPos2fv(GLbyte *pc) 311{ 312 __GLX_DECLARE_SWAP_VARIABLES; 313 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 314 315 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 2); 316 317} 318 319void __glXDispSwap_RasterPos2iv(GLbyte *pc) 320{ 321 __GLX_DECLARE_SWAP_VARIABLES; 322 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 323 324 __GLX_SWAP_INT_ARRAY(pc + 0, 2); 325 326} 327 328void __glXDispSwap_RasterPos2sv(GLbyte *pc) 329{ 330 __GLX_DECLARE_SWAP_VARIABLES; 331 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 332 333 __GLX_SWAP_SHORT_ARRAY(pc + 0, 2); 334 335} 336 337void __glXDispSwap_RasterPos3dv(GLbyte *pc) 338{ 339 __GLX_DECLARE_SWAP_VARIABLES; 340 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 341 342 343#ifdef __GLX_ALIGN64 344 if ((unsigned long)(pc) & 7) { 345 __GLX_MEM_COPY(pc-4, pc, 24); 346 pc -= 4; 347 } 348#endif 349 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3); 350 351} 352 353void __glXDispSwap_RasterPos3fv(GLbyte *pc) 354{ 355 __GLX_DECLARE_SWAP_VARIABLES; 356 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 357 358 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 3); 359 360} 361 362void __glXDispSwap_RasterPos3iv(GLbyte *pc) 363{ 364 __GLX_DECLARE_SWAP_VARIABLES; 365 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 366 367 __GLX_SWAP_INT_ARRAY(pc + 0, 3); 368 369} 370 371void __glXDispSwap_RasterPos3sv(GLbyte *pc) 372{ 373 __GLX_DECLARE_SWAP_VARIABLES; 374 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 375 376 __GLX_SWAP_SHORT_ARRAY(pc + 0, 3); 377 378} 379 380void __glXDispSwap_RasterPos4dv(GLbyte *pc) 381{ 382 __GLX_DECLARE_SWAP_VARIABLES; 383 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 384 385 386#ifdef __GLX_ALIGN64 387 if ((unsigned long)(pc) & 7) { 388 __GLX_MEM_COPY(pc-4, pc, 32); 389 pc -= 4; 390 } 391#endif 392 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4); 393 394} 395 396void __glXDispSwap_RasterPos4fv(GLbyte *pc) 397{ 398 __GLX_DECLARE_SWAP_VARIABLES; 399 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 400 401 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 4); 402 403} 404 405void __glXDispSwap_RasterPos4iv(GLbyte *pc) 406{ 407 __GLX_DECLARE_SWAP_VARIABLES; 408 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 409 410 __GLX_SWAP_INT_ARRAY(pc + 0, 4); 411 412} 413 414void __glXDispSwap_RasterPos4sv(GLbyte *pc) 415{ 416 __GLX_DECLARE_SWAP_VARIABLES; 417 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 418 419 __GLX_SWAP_SHORT_ARRAY(pc + 0, 4); 420 421} 422 423void __glXDispSwap_Rectdv(GLbyte *pc) 424{ 425 __GLX_DECLARE_SWAP_VARIABLES; 426 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 427 428 429#ifdef __GLX_ALIGN64 430 if ((unsigned long)(pc) & 7) { 431 __GLX_MEM_COPY(pc-4, pc, 32); 432 pc -= 4; 433 } 434#endif 435 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2); 436 __GLX_SWAP_DOUBLE_ARRAY(pc + 16, 2); 437 438} 439 440void __glXDispSwap_Rectfv(GLbyte *pc) 441{ 442 __GLX_DECLARE_SWAP_VARIABLES; 443 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 444 445 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 2); 446 __GLX_SWAP_FLOAT_ARRAY(pc + 8, 2); 447 448} 449 450void __glXDispSwap_Rectiv(GLbyte *pc) 451{ 452 __GLX_DECLARE_SWAP_VARIABLES; 453 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 454 455 __GLX_SWAP_INT_ARRAY(pc + 0, 2); 456 __GLX_SWAP_INT_ARRAY(pc + 8, 2); 457 458} 459 460void __glXDispSwap_Rectsv(GLbyte *pc) 461{ 462 __GLX_DECLARE_SWAP_VARIABLES; 463 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 464 465 __GLX_SWAP_SHORT_ARRAY(pc + 0, 2); 466 __GLX_SWAP_SHORT_ARRAY(pc + 4, 2); 467 468} 469 470void __glXDispSwap_TexCoord1dv(GLbyte *pc) 471{ 472 __GLX_DECLARE_SWAP_VARIABLES; 473 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 474 475 476#ifdef __GLX_ALIGN64 477 if ((unsigned long)(pc) & 7) { 478 __GLX_MEM_COPY(pc-4, pc, 8); 479 pc -= 4; 480 } 481#endif 482 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1); 483 484} 485 486void __glXDispSwap_TexCoord1fv(GLbyte *pc) 487{ 488 __GLX_DECLARE_SWAP_VARIABLES; 489 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 490 491 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 1); 492 493} 494 495void __glXDispSwap_TexCoord1iv(GLbyte *pc) 496{ 497 __GLX_DECLARE_SWAP_VARIABLES; 498 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 499 500 __GLX_SWAP_INT_ARRAY(pc + 0, 1); 501 502} 503 504void __glXDispSwap_TexCoord1sv(GLbyte *pc) 505{ 506 __GLX_DECLARE_SWAP_VARIABLES; 507 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 508 509 __GLX_SWAP_SHORT_ARRAY(pc + 0, 1); 510 511} 512 513void __glXDispSwap_TexCoord2dv(GLbyte *pc) 514{ 515 __GLX_DECLARE_SWAP_VARIABLES; 516 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 517 518 519#ifdef __GLX_ALIGN64 520 if ((unsigned long)(pc) & 7) { 521 __GLX_MEM_COPY(pc-4, pc, 16); 522 pc -= 4; 523 } 524#endif 525 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2); 526 527} 528 529void __glXDispSwap_TexCoord2fv(GLbyte *pc) 530{ 531 __GLX_DECLARE_SWAP_VARIABLES; 532 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 533 534 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 2); 535 536} 537 538void __glXDispSwap_TexCoord2iv(GLbyte *pc) 539{ 540 __GLX_DECLARE_SWAP_VARIABLES; 541 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 542 543 __GLX_SWAP_INT_ARRAY(pc + 0, 2); 544 545} 546 547void __glXDispSwap_TexCoord2sv(GLbyte *pc) 548{ 549 __GLX_DECLARE_SWAP_VARIABLES; 550 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 551 552 __GLX_SWAP_SHORT_ARRAY(pc + 0, 2); 553 554} 555 556void __glXDispSwap_TexCoord3dv(GLbyte *pc) 557{ 558 __GLX_DECLARE_SWAP_VARIABLES; 559 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 560 561 562#ifdef __GLX_ALIGN64 563 if ((unsigned long)(pc) & 7) { 564 __GLX_MEM_COPY(pc-4, pc, 24); 565 pc -= 4; 566 } 567#endif 568 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3); 569 570} 571 572void __glXDispSwap_TexCoord3fv(GLbyte *pc) 573{ 574 __GLX_DECLARE_SWAP_VARIABLES; 575 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 576 577 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 3); 578 579} 580 581void __glXDispSwap_TexCoord3iv(GLbyte *pc) 582{ 583 __GLX_DECLARE_SWAP_VARIABLES; 584 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 585 586 __GLX_SWAP_INT_ARRAY(pc + 0, 3); 587 588} 589 590void __glXDispSwap_TexCoord3sv(GLbyte *pc) 591{ 592 __GLX_DECLARE_SWAP_VARIABLES; 593 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 594 595 __GLX_SWAP_SHORT_ARRAY(pc + 0, 3); 596 597} 598 599void __glXDispSwap_TexCoord4dv(GLbyte *pc) 600{ 601 __GLX_DECLARE_SWAP_VARIABLES; 602 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 603 604 605#ifdef __GLX_ALIGN64 606 if ((unsigned long)(pc) & 7) { 607 __GLX_MEM_COPY(pc-4, pc, 32); 608 pc -= 4; 609 } 610#endif 611 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4); 612 613} 614 615void __glXDispSwap_TexCoord4fv(GLbyte *pc) 616{ 617 __GLX_DECLARE_SWAP_VARIABLES; 618 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 619 620 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 4); 621 622} 623 624void __glXDispSwap_TexCoord4iv(GLbyte *pc) 625{ 626 __GLX_DECLARE_SWAP_VARIABLES; 627 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 628 629 __GLX_SWAP_INT_ARRAY(pc + 0, 4); 630 631} 632 633void __glXDispSwap_TexCoord4sv(GLbyte *pc) 634{ 635 __GLX_DECLARE_SWAP_VARIABLES; 636 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 637 638 __GLX_SWAP_SHORT_ARRAY(pc + 0, 4); 639 640} 641 642void __glXDispSwap_Vertex2dv(GLbyte *pc) 643{ 644 __GLX_DECLARE_SWAP_VARIABLES; 645 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 646 647 648#ifdef __GLX_ALIGN64 649 if ((unsigned long)(pc) & 7) { 650 __GLX_MEM_COPY(pc-4, pc, 16); 651 pc -= 4; 652 } 653#endif 654 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2); 655 656} 657 658void __glXDispSwap_Vertex2fv(GLbyte *pc) 659{ 660 __GLX_DECLARE_SWAP_VARIABLES; 661 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 662 663 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 2); 664 665} 666 667void __glXDispSwap_Vertex2iv(GLbyte *pc) 668{ 669 __GLX_DECLARE_SWAP_VARIABLES; 670 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 671 672 __GLX_SWAP_INT_ARRAY(pc + 0, 2); 673 674} 675 676void __glXDispSwap_Vertex2sv(GLbyte *pc) 677{ 678 __GLX_DECLARE_SWAP_VARIABLES; 679 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 680 681 __GLX_SWAP_SHORT_ARRAY(pc + 0, 2); 682 683} 684 685void __glXDispSwap_Vertex3dv(GLbyte *pc) 686{ 687 __GLX_DECLARE_SWAP_VARIABLES; 688 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 689 690 691#ifdef __GLX_ALIGN64 692 if ((unsigned long)(pc) & 7) { 693 __GLX_MEM_COPY(pc-4, pc, 24); 694 pc -= 4; 695 } 696#endif 697 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3); 698 699} 700 701void __glXDispSwap_Vertex3fv(GLbyte *pc) 702{ 703 __GLX_DECLARE_SWAP_VARIABLES; 704 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 705 706 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 3); 707 708} 709 710void __glXDispSwap_Vertex3iv(GLbyte *pc) 711{ 712 __GLX_DECLARE_SWAP_VARIABLES; 713 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 714 715 __GLX_SWAP_INT_ARRAY(pc + 0, 3); 716 717} 718 719void __glXDispSwap_Vertex3sv(GLbyte *pc) 720{ 721 __GLX_DECLARE_SWAP_VARIABLES; 722 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 723 724 __GLX_SWAP_SHORT_ARRAY(pc + 0, 3); 725 726} 727 728void __glXDispSwap_Vertex4dv(GLbyte *pc) 729{ 730 __GLX_DECLARE_SWAP_VARIABLES; 731 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 732 733 734#ifdef __GLX_ALIGN64 735 if ((unsigned long)(pc) & 7) { 736 __GLX_MEM_COPY(pc-4, pc, 32); 737 pc -= 4; 738 } 739#endif 740 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4); 741 742} 743 744void __glXDispSwap_Vertex4fv(GLbyte *pc) 745{ 746 __GLX_DECLARE_SWAP_VARIABLES; 747 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 748 749 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 4); 750 751} 752 753void __glXDispSwap_Vertex4iv(GLbyte *pc) 754{ 755 __GLX_DECLARE_SWAP_VARIABLES; 756 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 757 758 __GLX_SWAP_INT_ARRAY(pc + 0, 4); 759 760} 761 762void __glXDispSwap_Vertex4sv(GLbyte *pc) 763{ 764 __GLX_DECLARE_SWAP_VARIABLES; 765 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 766 767 __GLX_SWAP_SHORT_ARRAY(pc + 0, 4); 768 769} 770 771void __glXDispSwap_ClipPlane(GLbyte *pc) 772{ 773 __GLX_DECLARE_SWAP_VARIABLES; 774 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 775 776 777#ifdef __GLX_ALIGN64 778 if ((unsigned long)(pc) & 7) { 779 __GLX_MEM_COPY(pc-4, pc, 36); 780 pc -= 4; 781 } 782#endif 783 __GLX_SWAP_INT(pc + 32); 784 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4); 785 786} 787 788void __glXDispSwap_ColorMaterial(GLbyte *pc) 789{ 790 __GLX_DECLARE_SWAP_VARIABLES; 791 792 __GLX_SWAP_INT(pc + 0); 793 __GLX_SWAP_INT(pc + 4); 794 795} 796 797void __glXDispSwap_CullFace(GLbyte *pc) 798{ 799 __GLX_DECLARE_SWAP_VARIABLES; 800 801 __GLX_SWAP_INT(pc + 0); 802 803} 804 805void __glXDispSwap_Fogf(GLbyte *pc) 806{ 807 __GLX_DECLARE_SWAP_VARIABLES; 808 809 __GLX_SWAP_INT(pc + 0); 810 __GLX_SWAP_FLOAT(pc + 4); 811 812} 813 814void __glXDispSwap_Fogfv(GLbyte *pc) 815{ 816 GLenum pname; 817 GLint compsize; 818 __GLX_DECLARE_SWAP_VARIABLES; 819 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 820 821 __GLX_SWAP_INT(pc + 0); 822 pname = *(GLenum *)(pc + 0); 823 compsize = __glFogfv_size(pname); 824 if (compsize < 0) compsize = 0; 825 __GLX_SWAP_FLOAT_ARRAY(pc + 4, compsize); 826 827} 828 829void __glXDispSwap_Fogi(GLbyte *pc) 830{ 831 __GLX_DECLARE_SWAP_VARIABLES; 832 833 __GLX_SWAP_INT(pc + 0); 834 __GLX_SWAP_INT(pc + 4); 835 836} 837 838void __glXDispSwap_Fogiv(GLbyte *pc) 839{ 840 GLenum pname; 841 GLint compsize; 842 __GLX_DECLARE_SWAP_VARIABLES; 843 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 844 845 __GLX_SWAP_INT(pc + 0); 846 pname = *(GLenum *)(pc + 0); 847 compsize = __glFogiv_size(pname); 848 if (compsize < 0) compsize = 0; 849 __GLX_SWAP_INT_ARRAY(pc + 4, compsize); 850 851} 852 853void __glXDispSwap_FrontFace(GLbyte *pc) 854{ 855 __GLX_DECLARE_SWAP_VARIABLES; 856 857 __GLX_SWAP_INT(pc + 0); 858 859} 860 861void __glXDispSwap_Hint(GLbyte *pc) 862{ 863 __GLX_DECLARE_SWAP_VARIABLES; 864 865 __GLX_SWAP_INT(pc + 0); 866 __GLX_SWAP_INT(pc + 4); 867 868} 869 870void __glXDispSwap_Lightf(GLbyte *pc) 871{ 872 __GLX_DECLARE_SWAP_VARIABLES; 873 874 __GLX_SWAP_INT(pc + 0); 875 __GLX_SWAP_INT(pc + 4); 876 __GLX_SWAP_FLOAT(pc + 8); 877 878} 879 880void __glXDispSwap_Lightfv(GLbyte *pc) 881{ 882 GLenum pname; 883 GLint compsize; 884 __GLX_DECLARE_SWAP_VARIABLES; 885 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 886 887 __GLX_SWAP_INT(pc + 4); 888 pname = *(GLenum *)(pc + 4); 889 compsize = __glLightfv_size(pname); 890 if (compsize < 0) compsize = 0; 891 __GLX_SWAP_INT(pc + 0); 892 __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize); 893 894} 895 896void __glXDispSwap_Lighti(GLbyte *pc) 897{ 898 __GLX_DECLARE_SWAP_VARIABLES; 899 900 __GLX_SWAP_INT(pc + 0); 901 __GLX_SWAP_INT(pc + 4); 902 __GLX_SWAP_INT(pc + 8); 903 904} 905 906void __glXDispSwap_Lightiv(GLbyte *pc) 907{ 908 GLenum pname; 909 GLint compsize; 910 __GLX_DECLARE_SWAP_VARIABLES; 911 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 912 913 __GLX_SWAP_INT(pc + 4); 914 pname = *(GLenum *)(pc + 4); 915 compsize = __glLightiv_size(pname); 916 if (compsize < 0) compsize = 0; 917 __GLX_SWAP_INT(pc + 0); 918 __GLX_SWAP_INT_ARRAY(pc + 8, compsize); 919 920} 921 922void __glXDispSwap_LightModelf(GLbyte *pc) 923{ 924 __GLX_DECLARE_SWAP_VARIABLES; 925 926 __GLX_SWAP_INT(pc + 0); 927 __GLX_SWAP_FLOAT(pc + 4); 928 929} 930 931void __glXDispSwap_LightModelfv(GLbyte *pc) 932{ 933 GLenum pname; 934 GLint compsize; 935 __GLX_DECLARE_SWAP_VARIABLES; 936 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 937 938 __GLX_SWAP_INT(pc + 0); 939 pname = *(GLenum *)(pc + 0); 940 compsize = __glLightModelfv_size(pname); 941 if (compsize < 0) compsize = 0; 942 __GLX_SWAP_FLOAT_ARRAY(pc + 4, compsize); 943 944} 945 946void __glXDispSwap_LightModeli(GLbyte *pc) 947{ 948 __GLX_DECLARE_SWAP_VARIABLES; 949 950 __GLX_SWAP_INT(pc + 0); 951 __GLX_SWAP_INT(pc + 4); 952 953} 954 955void __glXDispSwap_LightModeliv(GLbyte *pc) 956{ 957 GLenum pname; 958 GLint compsize; 959 __GLX_DECLARE_SWAP_VARIABLES; 960 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 961 962 __GLX_SWAP_INT(pc + 0); 963 pname = *(GLenum *)(pc + 0); 964 compsize = __glLightModeliv_size(pname); 965 if (compsize < 0) compsize = 0; 966 __GLX_SWAP_INT_ARRAY(pc + 4, compsize); 967 968} 969 970void __glXDispSwap_LineStipple(GLbyte *pc) 971{ 972 __GLX_DECLARE_SWAP_VARIABLES; 973 974 __GLX_SWAP_INT(pc + 0); 975 __GLX_SWAP_SHORT(pc + 4); 976 977} 978 979void __glXDispSwap_LineWidth(GLbyte *pc) 980{ 981 __GLX_DECLARE_SWAP_VARIABLES; 982 983 __GLX_SWAP_FLOAT(pc + 0); 984 985} 986 987void __glXDispSwap_Materialf(GLbyte *pc) 988{ 989 __GLX_DECLARE_SWAP_VARIABLES; 990 991 __GLX_SWAP_INT(pc + 0); 992 __GLX_SWAP_INT(pc + 4); 993 __GLX_SWAP_FLOAT(pc + 8); 994 995} 996 997void __glXDispSwap_Materialfv(GLbyte *pc) 998{ 999 GLenum pname; 1000 GLint compsize; 1001 __GLX_DECLARE_SWAP_VARIABLES; 1002 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 1003 1004 __GLX_SWAP_INT(pc + 4); 1005 pname = *(GLenum *)(pc + 4); 1006 compsize = __glMaterialfv_size(pname); 1007 if (compsize < 0) compsize = 0; 1008 __GLX_SWAP_INT(pc + 0); 1009 __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize); 1010 1011} 1012 1013void __glXDispSwap_Materiali(GLbyte *pc) 1014{ 1015 __GLX_DECLARE_SWAP_VARIABLES; 1016 1017 __GLX_SWAP_INT(pc + 0); 1018 __GLX_SWAP_INT(pc + 4); 1019 __GLX_SWAP_INT(pc + 8); 1020 1021} 1022 1023void __glXDispSwap_Materialiv(GLbyte *pc) 1024{ 1025 GLenum pname; 1026 GLint compsize; 1027 __GLX_DECLARE_SWAP_VARIABLES; 1028 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 1029 1030 __GLX_SWAP_INT(pc + 4); 1031 pname = *(GLenum *)(pc + 4); 1032 compsize = __glMaterialiv_size(pname); 1033 if (compsize < 0) compsize = 0; 1034 __GLX_SWAP_INT(pc + 0); 1035 __GLX_SWAP_INT_ARRAY(pc + 8, compsize); 1036 1037} 1038 1039void __glXDispSwap_PointSize(GLbyte *pc) 1040{ 1041 __GLX_DECLARE_SWAP_VARIABLES; 1042 1043 __GLX_SWAP_FLOAT(pc + 0); 1044 1045} 1046 1047void __glXDispSwap_PolygonMode(GLbyte *pc) 1048{ 1049 __GLX_DECLARE_SWAP_VARIABLES; 1050 1051 __GLX_SWAP_INT(pc + 0); 1052 __GLX_SWAP_INT(pc + 4); 1053 1054} 1055 1056void __glXDispSwap_Scissor(GLbyte *pc) 1057{ 1058 __GLX_DECLARE_SWAP_VARIABLES; 1059 1060 __GLX_SWAP_INT(pc + 0); 1061 __GLX_SWAP_INT(pc + 4); 1062 __GLX_SWAP_INT(pc + 8); 1063 __GLX_SWAP_INT(pc + 12); 1064 1065} 1066 1067void __glXDispSwap_ShadeModel(GLbyte *pc) 1068{ 1069 __GLX_DECLARE_SWAP_VARIABLES; 1070 1071 __GLX_SWAP_INT(pc + 0); 1072 1073} 1074 1075void __glXDispSwap_TexParameterf(GLbyte *pc) 1076{ 1077 __GLX_DECLARE_SWAP_VARIABLES; 1078 1079 __GLX_SWAP_INT(pc + 0); 1080 __GLX_SWAP_INT(pc + 4); 1081 __GLX_SWAP_FLOAT(pc + 8); 1082 1083} 1084 1085void __glXDispSwap_TexParameterfv(GLbyte *pc) 1086{ 1087 GLenum pname; 1088 GLint compsize; 1089 __GLX_DECLARE_SWAP_VARIABLES; 1090 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 1091 1092 __GLX_SWAP_INT(pc + 4); 1093 pname = *(GLenum *)(pc + 4); 1094 compsize = __glTexParameterfv_size(pname); 1095 if (compsize < 0) compsize = 0; 1096 __GLX_SWAP_INT(pc + 0); 1097 __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize); 1098 1099} 1100 1101void __glXDispSwap_TexParameteri(GLbyte *pc) 1102{ 1103 __GLX_DECLARE_SWAP_VARIABLES; 1104 1105 __GLX_SWAP_INT(pc + 0); 1106 __GLX_SWAP_INT(pc + 4); 1107 __GLX_SWAP_INT(pc + 8); 1108 1109} 1110 1111void __glXDispSwap_TexParameteriv(GLbyte *pc) 1112{ 1113 GLenum pname; 1114 GLint compsize; 1115 __GLX_DECLARE_SWAP_VARIABLES; 1116 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 1117 1118 __GLX_SWAP_INT(pc + 4); 1119 pname = *(GLenum *)(pc + 4); 1120 compsize = __glTexParameteriv_size(pname); 1121 if (compsize < 0) compsize = 0; 1122 __GLX_SWAP_INT(pc + 0); 1123 __GLX_SWAP_INT_ARRAY(pc + 8, compsize); 1124 1125} 1126 1127void __glXDispSwap_TexEnvf(GLbyte *pc) 1128{ 1129 __GLX_DECLARE_SWAP_VARIABLES; 1130 1131 __GLX_SWAP_INT(pc + 0); 1132 __GLX_SWAP_INT(pc + 4); 1133 __GLX_SWAP_FLOAT(pc + 8); 1134 1135} 1136 1137void __glXDispSwap_TexEnvfv(GLbyte *pc) 1138{ 1139 GLenum pname; 1140 GLint compsize; 1141 __GLX_DECLARE_SWAP_VARIABLES; 1142 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 1143 1144 __GLX_SWAP_INT(pc + 4); 1145 pname = *(GLenum *)(pc + 4); 1146 compsize = __glTexEnvfv_size(pname); 1147 if (compsize < 0) compsize = 0; 1148 __GLX_SWAP_INT(pc + 0); 1149 __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize); 1150 1151} 1152 1153void __glXDispSwap_TexEnvi(GLbyte *pc) 1154{ 1155 __GLX_DECLARE_SWAP_VARIABLES; 1156 1157 __GLX_SWAP_INT(pc + 0); 1158 __GLX_SWAP_INT(pc + 4); 1159 __GLX_SWAP_INT(pc + 8); 1160 1161} 1162 1163void __glXDispSwap_TexEnviv(GLbyte *pc) 1164{ 1165 GLenum pname; 1166 GLint compsize; 1167 __GLX_DECLARE_SWAP_VARIABLES; 1168 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 1169 1170 __GLX_SWAP_INT(pc + 4); 1171 pname = *(GLenum *)(pc + 4); 1172 compsize = __glTexEnviv_size(pname); 1173 if (compsize < 0) compsize = 0; 1174 __GLX_SWAP_INT(pc + 0); 1175 __GLX_SWAP_INT_ARRAY(pc + 8, compsize); 1176 1177} 1178 1179void __glXDispSwap_TexGend(GLbyte *pc) 1180{ 1181 __GLX_DECLARE_SWAP_VARIABLES; 1182 1183 1184#ifdef __GLX_ALIGN64 1185 if ((unsigned long)(pc) & 7) { 1186 __GLX_MEM_COPY(pc-4, pc, 16); 1187 pc -= 4; 1188 } 1189#endif 1190 __GLX_SWAP_INT(pc + 8); 1191 __GLX_SWAP_INT(pc + 12); 1192 __GLX_SWAP_DOUBLE(pc + 0); 1193 1194} 1195 1196void __glXDispSwap_TexGendv(GLbyte *pc) 1197{ 1198 GLenum pname; 1199 GLint cmdlen; 1200 GLint compsize; 1201 __GLX_DECLARE_SWAP_VARIABLES; 1202 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 1203 1204 __GLX_SWAP_INT(pc + 4); 1205 pname = *(GLenum *)(pc + 4); 1206 compsize = __glTexGendv_size(pname); 1207 if (compsize < 0) compsize = 0; 1208 cmdlen = __GLX_PAD(8+compsize*8); 1209 1210#ifdef __GLX_ALIGN64 1211 if ((unsigned long)(pc) & 7) { 1212 __GLX_MEM_COPY(pc-4, pc, cmdlen); 1213 pc -= 4; 1214 } 1215#endif 1216 __GLX_SWAP_INT(pc + 0); 1217 __GLX_SWAP_DOUBLE_ARRAY(pc + 8, compsize); 1218 1219} 1220 1221void __glXDispSwap_TexGenf(GLbyte *pc) 1222{ 1223 __GLX_DECLARE_SWAP_VARIABLES; 1224 1225 __GLX_SWAP_INT(pc + 0); 1226 __GLX_SWAP_INT(pc + 4); 1227 __GLX_SWAP_FLOAT(pc + 8); 1228 1229} 1230 1231void __glXDispSwap_TexGenfv(GLbyte *pc) 1232{ 1233 GLenum pname; 1234 GLint compsize; 1235 __GLX_DECLARE_SWAP_VARIABLES; 1236 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 1237 1238 __GLX_SWAP_INT(pc + 4); 1239 pname = *(GLenum *)(pc + 4); 1240 compsize = __glTexGenfv_size(pname); 1241 if (compsize < 0) compsize = 0; 1242 __GLX_SWAP_INT(pc + 0); 1243 __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize); 1244 1245} 1246 1247void __glXDispSwap_TexGeni(GLbyte *pc) 1248{ 1249 __GLX_DECLARE_SWAP_VARIABLES; 1250 1251 __GLX_SWAP_INT(pc + 0); 1252 __GLX_SWAP_INT(pc + 4); 1253 __GLX_SWAP_INT(pc + 8); 1254 1255} 1256 1257void __glXDispSwap_TexGeniv(GLbyte *pc) 1258{ 1259 GLenum pname; 1260 GLint compsize; 1261 __GLX_DECLARE_SWAP_VARIABLES; 1262 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 1263 1264 __GLX_SWAP_INT(pc + 4); 1265 pname = *(GLenum *)(pc + 4); 1266 compsize = __glTexGeniv_size(pname); 1267 if (compsize < 0) compsize = 0; 1268 __GLX_SWAP_INT(pc + 0); 1269 __GLX_SWAP_INT_ARRAY(pc + 8, compsize); 1270 1271} 1272 1273void __glXDispSwap_InitNames(GLbyte *pc) 1274{ 1275} 1276 1277void __glXDispSwap_LoadName(GLbyte *pc) 1278{ 1279 __GLX_DECLARE_SWAP_VARIABLES; 1280 1281 __GLX_SWAP_INT(pc + 0); 1282 1283} 1284 1285void __glXDispSwap_PassThrough(GLbyte *pc) 1286{ 1287 __GLX_DECLARE_SWAP_VARIABLES; 1288 1289 __GLX_SWAP_FLOAT(pc + 0); 1290 1291} 1292 1293void __glXDispSwap_PopName(GLbyte *pc) 1294{ 1295} 1296 1297void __glXDispSwap_PushName(GLbyte *pc) 1298{ 1299 __GLX_DECLARE_SWAP_VARIABLES; 1300 1301 __GLX_SWAP_INT(pc + 0); 1302 1303} 1304 1305void __glXDispSwap_DrawBuffer(GLbyte *pc) 1306{ 1307 __GLX_DECLARE_SWAP_VARIABLES; 1308 1309 __GLX_SWAP_INT(pc + 0); 1310 1311} 1312 1313void __glXDispSwap_Clear(GLbyte *pc) 1314{ 1315 __GLX_DECLARE_SWAP_VARIABLES; 1316 1317 __GLX_SWAP_INT(pc + 0); 1318 1319} 1320 1321void __glXDispSwap_ClearAccum(GLbyte *pc) 1322{ 1323 __GLX_DECLARE_SWAP_VARIABLES; 1324 1325 __GLX_SWAP_FLOAT(pc + 0); 1326 __GLX_SWAP_FLOAT(pc + 4); 1327 __GLX_SWAP_FLOAT(pc + 8); 1328 __GLX_SWAP_FLOAT(pc + 12); 1329 1330} 1331 1332void __glXDispSwap_ClearIndex(GLbyte *pc) 1333{ 1334 __GLX_DECLARE_SWAP_VARIABLES; 1335 1336 __GLX_SWAP_FLOAT(pc + 0); 1337 1338} 1339 1340void __glXDispSwap_ClearColor(GLbyte *pc) 1341{ 1342 __GLX_DECLARE_SWAP_VARIABLES; 1343 1344 __GLX_SWAP_FLOAT(pc + 0); 1345 __GLX_SWAP_FLOAT(pc + 4); 1346 __GLX_SWAP_FLOAT(pc + 8); 1347 __GLX_SWAP_FLOAT(pc + 12); 1348 1349} 1350 1351void __glXDispSwap_ClearStencil(GLbyte *pc) 1352{ 1353 __GLX_DECLARE_SWAP_VARIABLES; 1354 1355 __GLX_SWAP_INT(pc + 0); 1356 1357} 1358 1359void __glXDispSwap_ClearDepth(GLbyte *pc) 1360{ 1361 __GLX_DECLARE_SWAP_VARIABLES; 1362 1363 1364#ifdef __GLX_ALIGN64 1365 if ((unsigned long)(pc) & 7) { 1366 __GLX_MEM_COPY(pc-4, pc, 8); 1367 pc -= 4; 1368 } 1369#endif 1370 __GLX_SWAP_DOUBLE(pc + 0); 1371 1372} 1373 1374void __glXDispSwap_StencilMask(GLbyte *pc) 1375{ 1376 __GLX_DECLARE_SWAP_VARIABLES; 1377 1378 __GLX_SWAP_INT(pc + 0); 1379 1380} 1381 1382void __glXDispSwap_ColorMask(GLbyte *pc) 1383{ 1384} 1385 1386void __glXDispSwap_DepthMask(GLbyte *pc) 1387{ 1388} 1389 1390void __glXDispSwap_IndexMask(GLbyte *pc) 1391{ 1392 __GLX_DECLARE_SWAP_VARIABLES; 1393 1394 __GLX_SWAP_INT(pc + 0); 1395 1396} 1397 1398void __glXDispSwap_Accum(GLbyte *pc) 1399{ 1400 __GLX_DECLARE_SWAP_VARIABLES; 1401 1402 __GLX_SWAP_INT(pc + 0); 1403 __GLX_SWAP_FLOAT(pc + 4); 1404 1405} 1406 1407void __glXDispSwap_Disable(GLbyte *pc) 1408{ 1409 __GLX_DECLARE_SWAP_VARIABLES; 1410 1411 __GLX_SWAP_INT(pc + 0); 1412 1413} 1414 1415void __glXDispSwap_Enable(GLbyte *pc) 1416{ 1417 __GLX_DECLARE_SWAP_VARIABLES; 1418 1419 __GLX_SWAP_INT(pc + 0); 1420 1421} 1422 1423void __glXDispSwap_PopAttrib(GLbyte *pc) 1424{ 1425} 1426 1427void __glXDispSwap_PushAttrib(GLbyte *pc) 1428{ 1429 __GLX_DECLARE_SWAP_VARIABLES; 1430 1431 __GLX_SWAP_INT(pc + 0); 1432 1433} 1434 1435void __glXDispSwap_MapGrid1d(GLbyte *pc) 1436{ 1437 __GLX_DECLARE_SWAP_VARIABLES; 1438 1439 1440#ifdef __GLX_ALIGN64 1441 if ((unsigned long)(pc) & 7) { 1442 __GLX_MEM_COPY(pc-4, pc, 20); 1443 pc -= 4; 1444 } 1445#endif 1446 __GLX_SWAP_INT(pc + 16); 1447 __GLX_SWAP_DOUBLE(pc + 0); 1448 __GLX_SWAP_DOUBLE(pc + 8); 1449 1450} 1451 1452void __glXDispSwap_MapGrid1f(GLbyte *pc) 1453{ 1454 __GLX_DECLARE_SWAP_VARIABLES; 1455 1456 __GLX_SWAP_INT(pc + 0); 1457 __GLX_SWAP_FLOAT(pc + 4); 1458 __GLX_SWAP_FLOAT(pc + 8); 1459 1460} 1461 1462void __glXDispSwap_MapGrid2d(GLbyte *pc) 1463{ 1464 __GLX_DECLARE_SWAP_VARIABLES; 1465 1466 1467#ifdef __GLX_ALIGN64 1468 if ((unsigned long)(pc) & 7) { 1469 __GLX_MEM_COPY(pc-4, pc, 40); 1470 pc -= 4; 1471 } 1472#endif 1473 __GLX_SWAP_INT(pc + 32); 1474 __GLX_SWAP_DOUBLE(pc + 0); 1475 __GLX_SWAP_DOUBLE(pc + 8); 1476 __GLX_SWAP_INT(pc + 36); 1477 __GLX_SWAP_DOUBLE(pc + 16); 1478 __GLX_SWAP_DOUBLE(pc + 24); 1479 1480} 1481 1482void __glXDispSwap_MapGrid2f(GLbyte *pc) 1483{ 1484 __GLX_DECLARE_SWAP_VARIABLES; 1485 1486 __GLX_SWAP_INT(pc + 0); 1487 __GLX_SWAP_FLOAT(pc + 4); 1488 __GLX_SWAP_FLOAT(pc + 8); 1489 __GLX_SWAP_INT(pc + 12); 1490 __GLX_SWAP_FLOAT(pc + 16); 1491 __GLX_SWAP_FLOAT(pc + 20); 1492 1493} 1494 1495void __glXDispSwap_EvalCoord1dv(GLbyte *pc) 1496{ 1497 __GLX_DECLARE_SWAP_VARIABLES; 1498 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 1499 1500 1501#ifdef __GLX_ALIGN64 1502 if ((unsigned long)(pc) & 7) { 1503 __GLX_MEM_COPY(pc-4, pc, 8); 1504 pc -= 4; 1505 } 1506#endif 1507 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1); 1508 1509} 1510 1511void __glXDispSwap_EvalCoord1fv(GLbyte *pc) 1512{ 1513 __GLX_DECLARE_SWAP_VARIABLES; 1514 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 1515 1516 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 1); 1517 1518} 1519 1520void __glXDispSwap_EvalCoord2dv(GLbyte *pc) 1521{ 1522 __GLX_DECLARE_SWAP_VARIABLES; 1523 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 1524 1525 1526#ifdef __GLX_ALIGN64 1527 if ((unsigned long)(pc) & 7) { 1528 __GLX_MEM_COPY(pc-4, pc, 16); 1529 pc -= 4; 1530 } 1531#endif 1532 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2); 1533 1534} 1535 1536void __glXDispSwap_EvalCoord2fv(GLbyte *pc) 1537{ 1538 __GLX_DECLARE_SWAP_VARIABLES; 1539 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 1540 1541 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 2); 1542 1543} 1544 1545void __glXDispSwap_EvalMesh1(GLbyte *pc) 1546{ 1547 __GLX_DECLARE_SWAP_VARIABLES; 1548 1549 __GLX_SWAP_INT(pc + 0); 1550 __GLX_SWAP_INT(pc + 4); 1551 __GLX_SWAP_INT(pc + 8); 1552 1553} 1554 1555void __glXDispSwap_EvalPoint1(GLbyte *pc) 1556{ 1557 __GLX_DECLARE_SWAP_VARIABLES; 1558 1559 __GLX_SWAP_INT(pc + 0); 1560 1561} 1562 1563void __glXDispSwap_EvalMesh2(GLbyte *pc) 1564{ 1565 __GLX_DECLARE_SWAP_VARIABLES; 1566 1567 __GLX_SWAP_INT(pc + 0); 1568 __GLX_SWAP_INT(pc + 4); 1569 __GLX_SWAP_INT(pc + 8); 1570 __GLX_SWAP_INT(pc + 12); 1571 __GLX_SWAP_INT(pc + 16); 1572 1573} 1574 1575void __glXDispSwap_EvalPoint2(GLbyte *pc) 1576{ 1577 __GLX_DECLARE_SWAP_VARIABLES; 1578 1579 __GLX_SWAP_INT(pc + 0); 1580 __GLX_SWAP_INT(pc + 4); 1581 1582} 1583 1584void __glXDispSwap_AlphaFunc(GLbyte *pc) 1585{ 1586 __GLX_DECLARE_SWAP_VARIABLES; 1587 1588 __GLX_SWAP_INT(pc + 0); 1589 __GLX_SWAP_FLOAT(pc + 4); 1590 1591} 1592 1593void __glXDispSwap_BlendFunc(GLbyte *pc) 1594{ 1595 __GLX_DECLARE_SWAP_VARIABLES; 1596 1597 __GLX_SWAP_INT(pc + 0); 1598 __GLX_SWAP_INT(pc + 4); 1599 1600} 1601 1602void __glXDispSwap_LogicOp(GLbyte *pc) 1603{ 1604 __GLX_DECLARE_SWAP_VARIABLES; 1605 1606 __GLX_SWAP_INT(pc + 0); 1607 1608} 1609 1610void __glXDispSwap_StencilFunc(GLbyte *pc) 1611{ 1612 __GLX_DECLARE_SWAP_VARIABLES; 1613 1614 __GLX_SWAP_INT(pc + 0); 1615 __GLX_SWAP_INT(pc + 4); 1616 __GLX_SWAP_INT(pc + 8); 1617 1618} 1619 1620void __glXDispSwap_StencilOp(GLbyte *pc) 1621{ 1622 __GLX_DECLARE_SWAP_VARIABLES; 1623 1624 __GLX_SWAP_INT(pc + 0); 1625 __GLX_SWAP_INT(pc + 4); 1626 __GLX_SWAP_INT(pc + 8); 1627 1628} 1629 1630void __glXDispSwap_DepthFunc(GLbyte *pc) 1631{ 1632 __GLX_DECLARE_SWAP_VARIABLES; 1633 1634 __GLX_SWAP_INT(pc + 0); 1635 1636} 1637 1638void __glXDispSwap_PixelZoom(GLbyte *pc) 1639{ 1640 __GLX_DECLARE_SWAP_VARIABLES; 1641 1642 __GLX_SWAP_FLOAT(pc + 0); 1643 __GLX_SWAP_FLOAT(pc + 4); 1644 1645} 1646 1647void __glXDispSwap_PixelTransferf(GLbyte *pc) 1648{ 1649 __GLX_DECLARE_SWAP_VARIABLES; 1650 1651 __GLX_SWAP_INT(pc + 0); 1652 __GLX_SWAP_FLOAT(pc + 4); 1653 1654} 1655 1656void __glXDispSwap_PixelTransferi(GLbyte *pc) 1657{ 1658 __GLX_DECLARE_SWAP_VARIABLES; 1659 1660 __GLX_SWAP_INT(pc + 0); 1661 __GLX_SWAP_INT(pc + 4); 1662 1663} 1664 1665void __glXDispSwap_PixelMapfv(GLbyte *pc) 1666{ 1667 GLint mapsize; 1668 __GLX_DECLARE_SWAP_VARIABLES; 1669 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 1670 1671 __GLX_SWAP_INT(pc + 4); 1672 mapsize = *(GLint *)(pc + 4); 1673 __GLX_SWAP_INT(pc + 0); 1674 __GLX_SWAP_FLOAT_ARRAY(pc + 8, mapsize); 1675 1676} 1677 1678void __glXDispSwap_PixelMapuiv(GLbyte *pc) 1679{ 1680 GLint mapsize; 1681 __GLX_DECLARE_SWAP_VARIABLES; 1682 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 1683 1684 __GLX_SWAP_INT(pc + 4); 1685 mapsize = *(GLint *)(pc + 4); 1686 __GLX_SWAP_INT(pc + 0); 1687 __GLX_SWAP_INT_ARRAY(pc + 8, mapsize); 1688 1689} 1690 1691void __glXDispSwap_PixelMapusv(GLbyte *pc) 1692{ 1693 GLint mapsize; 1694 __GLX_DECLARE_SWAP_VARIABLES; 1695 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 1696 1697 __GLX_SWAP_INT(pc + 4); 1698 mapsize = *(GLint *)(pc + 4); 1699 __GLX_SWAP_INT(pc + 0); 1700 __GLX_SWAP_SHORT_ARRAY(pc + 8, mapsize); 1701 1702} 1703 1704void __glXDispSwap_ReadBuffer(GLbyte *pc) 1705{ 1706 __GLX_DECLARE_SWAP_VARIABLES; 1707 1708 __GLX_SWAP_INT(pc + 0); 1709 1710} 1711 1712void __glXDispSwap_CopyPixels(GLbyte *pc) 1713{ 1714 __GLX_DECLARE_SWAP_VARIABLES; 1715 1716 __GLX_SWAP_INT(pc + 0); 1717 __GLX_SWAP_INT(pc + 4); 1718 __GLX_SWAP_INT(pc + 8); 1719 __GLX_SWAP_INT(pc + 12); 1720 __GLX_SWAP_INT(pc + 16); 1721 1722} 1723 1724void __glXDispSwap_DepthRange(GLbyte *pc) 1725{ 1726 __GLX_DECLARE_SWAP_VARIABLES; 1727 1728 1729#ifdef __GLX_ALIGN64 1730 if ((unsigned long)(pc) & 7) { 1731 __GLX_MEM_COPY(pc-4, pc, 16); 1732 pc -= 4; 1733 } 1734#endif 1735 __GLX_SWAP_DOUBLE(pc + 0); 1736 __GLX_SWAP_DOUBLE(pc + 8); 1737 1738} 1739 1740void __glXDispSwap_Frustum(GLbyte *pc) 1741{ 1742 __GLX_DECLARE_SWAP_VARIABLES; 1743 1744 1745#ifdef __GLX_ALIGN64 1746 if ((unsigned long)(pc) & 7) { 1747 __GLX_MEM_COPY(pc-4, pc, 48); 1748 pc -= 4; 1749 } 1750#endif 1751 __GLX_SWAP_DOUBLE(pc + 0); 1752 __GLX_SWAP_DOUBLE(pc + 8); 1753 __GLX_SWAP_DOUBLE(pc + 16); 1754 __GLX_SWAP_DOUBLE(pc + 24); 1755 __GLX_SWAP_DOUBLE(pc + 32); 1756 __GLX_SWAP_DOUBLE(pc + 40); 1757 1758} 1759 1760void __glXDispSwap_LoadIdentity(GLbyte *pc) 1761{ 1762} 1763 1764void __glXDispSwap_LoadMatrixf(GLbyte *pc) 1765{ 1766 __GLX_DECLARE_SWAP_VARIABLES; 1767 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 1768 1769 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 16); 1770 1771} 1772 1773void __glXDispSwap_LoadMatrixd(GLbyte *pc) 1774{ 1775 __GLX_DECLARE_SWAP_VARIABLES; 1776 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 1777 1778 1779#ifdef __GLX_ALIGN64 1780 if ((unsigned long)(pc) & 7) { 1781 __GLX_MEM_COPY(pc-4, pc, 128); 1782 pc -= 4; 1783 } 1784#endif 1785 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 16); 1786 1787} 1788 1789void __glXDispSwap_MatrixMode(GLbyte *pc) 1790{ 1791 __GLX_DECLARE_SWAP_VARIABLES; 1792 1793 __GLX_SWAP_INT(pc + 0); 1794 1795} 1796 1797void __glXDispSwap_MultMatrixf(GLbyte *pc) 1798{ 1799 __GLX_DECLARE_SWAP_VARIABLES; 1800 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 1801 1802 __GLX_SWAP_FLOAT_ARRAY(pc + 0, 16); 1803 1804} 1805 1806void __glXDispSwap_MultMatrixd(GLbyte *pc) 1807{ 1808 __GLX_DECLARE_SWAP_VARIABLES; 1809 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 1810 1811 1812#ifdef __GLX_ALIGN64 1813 if ((unsigned long)(pc) & 7) { 1814 __GLX_MEM_COPY(pc-4, pc, 128); 1815 pc -= 4; 1816 } 1817#endif 1818 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 16); 1819 1820} 1821 1822void __glXDispSwap_Ortho(GLbyte *pc) 1823{ 1824 __GLX_DECLARE_SWAP_VARIABLES; 1825 1826 1827#ifdef __GLX_ALIGN64 1828 if ((unsigned long)(pc) & 7) { 1829 __GLX_MEM_COPY(pc-4, pc, 48); 1830 pc -= 4; 1831 } 1832#endif 1833 __GLX_SWAP_DOUBLE(pc + 0); 1834 __GLX_SWAP_DOUBLE(pc + 8); 1835 __GLX_SWAP_DOUBLE(pc + 16); 1836 __GLX_SWAP_DOUBLE(pc + 24); 1837 __GLX_SWAP_DOUBLE(pc + 32); 1838 __GLX_SWAP_DOUBLE(pc + 40); 1839 1840} 1841 1842void __glXDispSwap_PopMatrix(GLbyte *pc) 1843{ 1844} 1845 1846void __glXDispSwap_PushMatrix(GLbyte *pc) 1847{ 1848} 1849 1850void __glXDispSwap_Rotated(GLbyte *pc) 1851{ 1852 __GLX_DECLARE_SWAP_VARIABLES; 1853 1854 1855#ifdef __GLX_ALIGN64 1856 if ((unsigned long)(pc) & 7) { 1857 __GLX_MEM_COPY(pc-4, pc, 32); 1858 pc -= 4; 1859 } 1860#endif 1861 __GLX_SWAP_DOUBLE(pc + 0); 1862 __GLX_SWAP_DOUBLE(pc + 8); 1863 __GLX_SWAP_DOUBLE(pc + 16); 1864 __GLX_SWAP_DOUBLE(pc + 24); 1865 1866} 1867 1868void __glXDispSwap_Rotatef(GLbyte *pc) 1869{ 1870 __GLX_DECLARE_SWAP_VARIABLES; 1871 1872 __GLX_SWAP_FLOAT(pc + 0); 1873 __GLX_SWAP_FLOAT(pc + 4); 1874 __GLX_SWAP_FLOAT(pc + 8); 1875 __GLX_SWAP_FLOAT(pc + 12); 1876 1877} 1878 1879void __glXDispSwap_Scaled(GLbyte *pc) 1880{ 1881 __GLX_DECLARE_SWAP_VARIABLES; 1882 1883 1884#ifdef __GLX_ALIGN64 1885 if ((unsigned long)(pc) & 7) { 1886 __GLX_MEM_COPY(pc-4, pc, 24); 1887 pc -= 4; 1888 } 1889#endif 1890 __GLX_SWAP_DOUBLE(pc + 0); 1891 __GLX_SWAP_DOUBLE(pc + 8); 1892 __GLX_SWAP_DOUBLE(pc + 16); 1893 1894} 1895 1896void __glXDispSwap_Scalef(GLbyte *pc) 1897{ 1898 __GLX_DECLARE_SWAP_VARIABLES; 1899 1900 __GLX_SWAP_FLOAT(pc + 0); 1901 __GLX_SWAP_FLOAT(pc + 4); 1902 __GLX_SWAP_FLOAT(pc + 8); 1903 1904} 1905 1906void __glXDispSwap_Translated(GLbyte *pc) 1907{ 1908 __GLX_DECLARE_SWAP_VARIABLES; 1909 1910 1911#ifdef __GLX_ALIGN64 1912 if ((unsigned long)(pc) & 7) { 1913 __GLX_MEM_COPY(pc-4, pc, 24); 1914 pc -= 4; 1915 } 1916#endif 1917 __GLX_SWAP_DOUBLE(pc + 0); 1918 __GLX_SWAP_DOUBLE(pc + 8); 1919 __GLX_SWAP_DOUBLE(pc + 16); 1920 1921} 1922 1923void __glXDispSwap_Translatef(GLbyte *pc) 1924{ 1925 __GLX_DECLARE_SWAP_VARIABLES; 1926 1927 __GLX_SWAP_FLOAT(pc + 0); 1928 __GLX_SWAP_FLOAT(pc + 4); 1929 __GLX_SWAP_FLOAT(pc + 8); 1930 1931} 1932 1933void __glXDispSwap_Viewport(GLbyte *pc) 1934{ 1935 __GLX_DECLARE_SWAP_VARIABLES; 1936 1937 __GLX_SWAP_INT(pc + 0); 1938 __GLX_SWAP_INT(pc + 4); 1939 __GLX_SWAP_INT(pc + 8); 1940 __GLX_SWAP_INT(pc + 12); 1941 1942} 1943 1944void __glXDispSwap_PolygonOffset(GLbyte *pc) 1945{ 1946 __GLX_DECLARE_SWAP_VARIABLES; 1947 1948 __GLX_SWAP_FLOAT(pc + 0); 1949 __GLX_SWAP_FLOAT(pc + 4); 1950 1951} 1952 1953void __glXDispSwap_CopyTexImage1D(GLbyte *pc) 1954{ 1955 __GLX_DECLARE_SWAP_VARIABLES; 1956 1957 __GLX_SWAP_INT(pc + 0); 1958 __GLX_SWAP_INT(pc + 4); 1959 __GLX_SWAP_INT(pc + 8); 1960 __GLX_SWAP_INT(pc + 12); 1961 __GLX_SWAP_INT(pc + 16); 1962 __GLX_SWAP_INT(pc + 20); 1963 __GLX_SWAP_INT(pc + 24); 1964 1965} 1966 1967void __glXDispSwap_CopyTexImage2D(GLbyte *pc) 1968{ 1969 __GLX_DECLARE_SWAP_VARIABLES; 1970 1971 __GLX_SWAP_INT(pc + 0); 1972 __GLX_SWAP_INT(pc + 4); 1973 __GLX_SWAP_INT(pc + 8); 1974 __GLX_SWAP_INT(pc + 12); 1975 __GLX_SWAP_INT(pc + 16); 1976 __GLX_SWAP_INT(pc + 20); 1977 __GLX_SWAP_INT(pc + 24); 1978 __GLX_SWAP_INT(pc + 28); 1979 1980} 1981 1982void __glXDispSwap_CopyTexSubImage1D(GLbyte *pc) 1983{ 1984 __GLX_DECLARE_SWAP_VARIABLES; 1985 1986 __GLX_SWAP_INT(pc + 0); 1987 __GLX_SWAP_INT(pc + 4); 1988 __GLX_SWAP_INT(pc + 8); 1989 __GLX_SWAP_INT(pc + 12); 1990 __GLX_SWAP_INT(pc + 16); 1991 __GLX_SWAP_INT(pc + 20); 1992 1993} 1994 1995void __glXDispSwap_CopyTexSubImage2D(GLbyte *pc) 1996{ 1997 __GLX_DECLARE_SWAP_VARIABLES; 1998 1999 __GLX_SWAP_INT(pc + 0); 2000 __GLX_SWAP_INT(pc + 4); 2001 __GLX_SWAP_INT(pc + 8); 2002 __GLX_SWAP_INT(pc + 12); 2003 __GLX_SWAP_INT(pc + 16); 2004 __GLX_SWAP_INT(pc + 20); 2005 __GLX_SWAP_INT(pc + 24); 2006 __GLX_SWAP_INT(pc + 28); 2007 2008} 2009 2010void __glXDispSwap_BindTexture(GLbyte *pc) 2011{ 2012 __GLX_DECLARE_SWAP_VARIABLES; 2013 2014 __GLX_SWAP_INT(pc + 0); 2015 __GLX_SWAP_INT(pc + 4); 2016 2017} 2018 2019void __glXDispSwap_PrioritizeTextures(GLbyte *pc) 2020{ 2021 GLsizei n; 2022 __GLX_DECLARE_SWAP_VARIABLES; 2023 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2024 2025 __GLX_SWAP_INT(pc + 0); 2026 n = *(GLsizei *)(pc + 0); 2027 __GLX_SWAP_INT_ARRAY(pc + 4, n); 2028 __GLX_SWAP_FLOAT_ARRAY(pc + 4+n*4, n); 2029 2030} 2031 2032void __glXDispSwap_Indexubv(GLbyte *pc) 2033{ 2034} 2035 2036void __glXDispSwap_BlendColor(GLbyte *pc) 2037{ 2038 __GLX_DECLARE_SWAP_VARIABLES; 2039 2040 __GLX_SWAP_FLOAT(pc + 0); 2041 __GLX_SWAP_FLOAT(pc + 4); 2042 __GLX_SWAP_FLOAT(pc + 8); 2043 __GLX_SWAP_FLOAT(pc + 12); 2044 2045} 2046 2047void __glXDispSwap_BlendEquation(GLbyte *pc) 2048{ 2049 __GLX_DECLARE_SWAP_VARIABLES; 2050 2051 __GLX_SWAP_INT(pc + 0); 2052 2053} 2054 2055void __glXDispSwap_ColorTableParameterfv(GLbyte *pc) 2056{ 2057 GLenum pname; 2058 GLint compsize; 2059 __GLX_DECLARE_SWAP_VARIABLES; 2060 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2061 2062 __GLX_SWAP_INT(pc + 4); 2063 pname = *(GLenum *)(pc + 4); 2064 compsize = __glColorTableParameterfv_size(pname); 2065 if (compsize < 0) compsize = 0; 2066 __GLX_SWAP_INT(pc + 0); 2067 __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize); 2068 2069} 2070 2071void __glXDispSwap_ColorTableParameteriv(GLbyte *pc) 2072{ 2073 GLenum pname; 2074 GLint compsize; 2075 __GLX_DECLARE_SWAP_VARIABLES; 2076 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2077 2078 __GLX_SWAP_INT(pc + 4); 2079 pname = *(GLenum *)(pc + 4); 2080 compsize = __glColorTableParameteriv_size(pname); 2081 if (compsize < 0) compsize = 0; 2082 __GLX_SWAP_INT(pc + 0); 2083 __GLX_SWAP_INT_ARRAY(pc + 8, compsize); 2084 2085} 2086 2087void __glXDispSwap_CopyColorTable(GLbyte *pc) 2088{ 2089 __GLX_DECLARE_SWAP_VARIABLES; 2090 2091 __GLX_SWAP_INT(pc + 0); 2092 __GLX_SWAP_INT(pc + 4); 2093 __GLX_SWAP_INT(pc + 8); 2094 __GLX_SWAP_INT(pc + 12); 2095 __GLX_SWAP_INT(pc + 16); 2096 2097} 2098 2099void __glXDispSwap_CopyColorSubTable(GLbyte *pc) 2100{ 2101 __GLX_DECLARE_SWAP_VARIABLES; 2102 2103 __GLX_SWAP_INT(pc + 0); 2104 __GLX_SWAP_INT(pc + 4); 2105 __GLX_SWAP_INT(pc + 8); 2106 __GLX_SWAP_INT(pc + 12); 2107 __GLX_SWAP_INT(pc + 16); 2108 2109} 2110 2111void __glXDispSwap_ConvolutionParameterf(GLbyte *pc) 2112{ 2113 __GLX_DECLARE_SWAP_VARIABLES; 2114 2115 __GLX_SWAP_INT(pc + 0); 2116 __GLX_SWAP_INT(pc + 4); 2117 __GLX_SWAP_FLOAT(pc + 8); 2118 2119} 2120 2121void __glXDispSwap_ConvolutionParameterfv(GLbyte *pc) 2122{ 2123 GLenum pname; 2124 GLint compsize; 2125 __GLX_DECLARE_SWAP_VARIABLES; 2126 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2127 2128 __GLX_SWAP_INT(pc + 4); 2129 pname = *(GLenum *)(pc + 4); 2130 compsize = __glConvolutionParameterfv_size(pname); 2131 if (compsize < 0) compsize = 0; 2132 __GLX_SWAP_INT(pc + 0); 2133 __GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize); 2134 2135} 2136 2137void __glXDispSwap_ConvolutionParameteri(GLbyte *pc) 2138{ 2139 __GLX_DECLARE_SWAP_VARIABLES; 2140 2141 __GLX_SWAP_INT(pc + 0); 2142 __GLX_SWAP_INT(pc + 4); 2143 __GLX_SWAP_INT(pc + 8); 2144 2145} 2146 2147void __glXDispSwap_ConvolutionParameteriv(GLbyte *pc) 2148{ 2149 GLenum pname; 2150 GLint compsize; 2151 __GLX_DECLARE_SWAP_VARIABLES; 2152 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2153 2154 __GLX_SWAP_INT(pc + 4); 2155 pname = *(GLenum *)(pc + 4); 2156 compsize = __glConvolutionParameteriv_size(pname); 2157 if (compsize < 0) compsize = 0; 2158 __GLX_SWAP_INT(pc + 0); 2159 __GLX_SWAP_INT_ARRAY(pc + 8, compsize); 2160 2161} 2162 2163void __glXDispSwap_CopyConvolutionFilter1D(GLbyte *pc) 2164{ 2165 __GLX_DECLARE_SWAP_VARIABLES; 2166 2167 __GLX_SWAP_INT(pc + 0); 2168 __GLX_SWAP_INT(pc + 4); 2169 __GLX_SWAP_INT(pc + 8); 2170 __GLX_SWAP_INT(pc + 12); 2171 __GLX_SWAP_INT(pc + 16); 2172 2173} 2174 2175void __glXDispSwap_CopyConvolutionFilter2D(GLbyte *pc) 2176{ 2177 __GLX_DECLARE_SWAP_VARIABLES; 2178 2179 __GLX_SWAP_INT(pc + 0); 2180 __GLX_SWAP_INT(pc + 4); 2181 __GLX_SWAP_INT(pc + 8); 2182 __GLX_SWAP_INT(pc + 12); 2183 __GLX_SWAP_INT(pc + 16); 2184 __GLX_SWAP_INT(pc + 20); 2185 2186} 2187 2188void __glXDispSwap_Histogram(GLbyte *pc) 2189{ 2190 __GLX_DECLARE_SWAP_VARIABLES; 2191 2192 __GLX_SWAP_INT(pc + 0); 2193 __GLX_SWAP_INT(pc + 4); 2194 __GLX_SWAP_INT(pc + 8); 2195 2196} 2197 2198void __glXDispSwap_Minmax(GLbyte *pc) 2199{ 2200 __GLX_DECLARE_SWAP_VARIABLES; 2201 2202 __GLX_SWAP_INT(pc + 0); 2203 __GLX_SWAP_INT(pc + 4); 2204 2205} 2206 2207void __glXDispSwap_ResetHistogram(GLbyte *pc) 2208{ 2209 __GLX_DECLARE_SWAP_VARIABLES; 2210 2211 __GLX_SWAP_INT(pc + 0); 2212 2213} 2214 2215void __glXDispSwap_ResetMinmax(GLbyte *pc) 2216{ 2217 __GLX_DECLARE_SWAP_VARIABLES; 2218 2219 __GLX_SWAP_INT(pc + 0); 2220 2221} 2222 2223void __glXDispSwap_CopyTexSubImage3D(GLbyte *pc) 2224{ 2225 __GLX_DECLARE_SWAP_VARIABLES; 2226 2227 __GLX_SWAP_INT(pc + 0); 2228 __GLX_SWAP_INT(pc + 4); 2229 __GLX_SWAP_INT(pc + 8); 2230 __GLX_SWAP_INT(pc + 12); 2231 __GLX_SWAP_INT(pc + 16); 2232 __GLX_SWAP_INT(pc + 20); 2233 __GLX_SWAP_INT(pc + 24); 2234 __GLX_SWAP_INT(pc + 28); 2235 __GLX_SWAP_INT(pc + 32); 2236 2237} 2238 2239void __glXDispSwap_ActiveTextureARB(GLbyte *pc) 2240{ 2241 __GLX_DECLARE_SWAP_VARIABLES; 2242 2243 __GLX_SWAP_INT(pc + 0); 2244 2245} 2246 2247void __glXDispSwap_MultiTexCoord1dvARB(GLbyte *pc) 2248{ 2249 __GLX_DECLARE_SWAP_VARIABLES; 2250 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2251 2252 2253#ifdef __GLX_ALIGN64 2254 if ((unsigned long)(pc) & 7) { 2255 __GLX_MEM_COPY(pc-4, pc, 12); 2256 pc -= 4; 2257 } 2258#endif 2259 __GLX_SWAP_INT(pc + 8); 2260 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1); 2261 2262} 2263 2264void __glXDispSwap_MultiTexCoord1fvARB(GLbyte *pc) 2265{ 2266 __GLX_DECLARE_SWAP_VARIABLES; 2267 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2268 2269 __GLX_SWAP_INT(pc + 0); 2270 __GLX_SWAP_FLOAT_ARRAY(pc + 4, 1); 2271 2272} 2273 2274void __glXDispSwap_MultiTexCoord1ivARB(GLbyte *pc) 2275{ 2276 __GLX_DECLARE_SWAP_VARIABLES; 2277 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2278 2279 __GLX_SWAP_INT(pc + 0); 2280 __GLX_SWAP_INT_ARRAY(pc + 4, 1); 2281 2282} 2283 2284void __glXDispSwap_MultiTexCoord1svARB(GLbyte *pc) 2285{ 2286 __GLX_DECLARE_SWAP_VARIABLES; 2287 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2288 2289 __GLX_SWAP_INT(pc + 0); 2290 __GLX_SWAP_SHORT_ARRAY(pc + 4, 1); 2291 2292} 2293 2294void __glXDispSwap_MultiTexCoord2dvARB(GLbyte *pc) 2295{ 2296 __GLX_DECLARE_SWAP_VARIABLES; 2297 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2298 2299 2300#ifdef __GLX_ALIGN64 2301 if ((unsigned long)(pc) & 7) { 2302 __GLX_MEM_COPY(pc-4, pc, 20); 2303 pc -= 4; 2304 } 2305#endif 2306 __GLX_SWAP_INT(pc + 16); 2307 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2); 2308 2309} 2310 2311void __glXDispSwap_MultiTexCoord2fvARB(GLbyte *pc) 2312{ 2313 __GLX_DECLARE_SWAP_VARIABLES; 2314 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2315 2316 __GLX_SWAP_INT(pc + 0); 2317 __GLX_SWAP_FLOAT_ARRAY(pc + 4, 2); 2318 2319} 2320 2321void __glXDispSwap_MultiTexCoord2ivARB(GLbyte *pc) 2322{ 2323 __GLX_DECLARE_SWAP_VARIABLES; 2324 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2325 2326 __GLX_SWAP_INT(pc + 0); 2327 __GLX_SWAP_INT_ARRAY(pc + 4, 2); 2328 2329} 2330 2331void __glXDispSwap_MultiTexCoord2svARB(GLbyte *pc) 2332{ 2333 __GLX_DECLARE_SWAP_VARIABLES; 2334 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2335 2336 __GLX_SWAP_INT(pc + 0); 2337 __GLX_SWAP_SHORT_ARRAY(pc + 4, 2); 2338 2339} 2340 2341void __glXDispSwap_MultiTexCoord3dvARB(GLbyte *pc) 2342{ 2343 __GLX_DECLARE_SWAP_VARIABLES; 2344 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2345 2346 2347#ifdef __GLX_ALIGN64 2348 if ((unsigned long)(pc) & 7) { 2349 __GLX_MEM_COPY(pc-4, pc, 28); 2350 pc -= 4; 2351 } 2352#endif 2353 __GLX_SWAP_INT(pc + 24); 2354 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3); 2355 2356} 2357 2358void __glXDispSwap_MultiTexCoord3fvARB(GLbyte *pc) 2359{ 2360 __GLX_DECLARE_SWAP_VARIABLES; 2361 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2362 2363 __GLX_SWAP_INT(pc + 0); 2364 __GLX_SWAP_FLOAT_ARRAY(pc + 4, 3); 2365 2366} 2367 2368void __glXDispSwap_MultiTexCoord3ivARB(GLbyte *pc) 2369{ 2370 __GLX_DECLARE_SWAP_VARIABLES; 2371 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2372 2373 __GLX_SWAP_INT(pc + 0); 2374 __GLX_SWAP_INT_ARRAY(pc + 4, 3); 2375 2376} 2377 2378void __glXDispSwap_MultiTexCoord3svARB(GLbyte *pc) 2379{ 2380 __GLX_DECLARE_SWAP_VARIABLES; 2381 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2382 2383 __GLX_SWAP_INT(pc + 0); 2384 __GLX_SWAP_SHORT_ARRAY(pc + 4, 3); 2385 2386} 2387 2388void __glXDispSwap_MultiTexCoord4dvARB(GLbyte *pc) 2389{ 2390 __GLX_DECLARE_SWAP_VARIABLES; 2391 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2392 2393 2394#ifdef __GLX_ALIGN64 2395 if ((unsigned long)(pc) & 7) { 2396 __GLX_MEM_COPY(pc-4, pc, 36); 2397 pc -= 4; 2398 } 2399#endif 2400 __GLX_SWAP_INT(pc + 32); 2401 __GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4); 2402 2403} 2404 2405void __glXDispSwap_MultiTexCoord4fvARB(GLbyte *pc) 2406{ 2407 __GLX_DECLARE_SWAP_VARIABLES; 2408 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2409 2410 __GLX_SWAP_INT(pc + 0); 2411 __GLX_SWAP_FLOAT_ARRAY(pc + 4, 4); 2412 2413} 2414 2415void __glXDispSwap_MultiTexCoord4ivARB(GLbyte *pc) 2416{ 2417 __GLX_DECLARE_SWAP_VARIABLES; 2418 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2419 2420 __GLX_SWAP_INT(pc + 0); 2421 __GLX_SWAP_INT_ARRAY(pc + 4, 4); 2422 2423} 2424 2425void __glXDispSwap_MultiTexCoord4svARB(GLbyte *pc) 2426{ 2427 __GLX_DECLARE_SWAP_VARIABLES; 2428 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 2429 2430 __GLX_SWAP_INT(pc + 0); 2431 __GLX_SWAP_SHORT_ARRAY(pc + 4, 4); 2432 2433} 2434 2435