1 /* 2 * Mesa 3-D graphics library 3 * 4 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the "Software"), 8 * to deal in the Software without restriction, including without limitation 9 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 10 * and/or sell copies of the Software, and to permit persons to whom the 11 * Software is furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included 14 * in all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 * OTHER DEALINGS IN THE SOFTWARE. 23 */ 24 25 26 /* 27 * This is the GLX API dispatcher. It uses a dispatch table but that's 28 * not really needed anymore since the table always points to the "fake" 29 * GLX functions. 30 */ 31 32 33 #include <assert.h> 34 #include <stdlib.h> 35 #include <stdio.h> 36 #include <string.h> 37 #include "main/glheader.h" 38 #include "main/compiler.h" 39 #include "glapi/glapi.h" 40 #include "glxapi.h" 41 42 43 extern struct _glxapi_table *_mesa_GetGLXDispatchTable(void); 44 45 46 struct display_dispatch { 47 Display *Dpy; 48 struct _glxapi_table *Table; 49 struct display_dispatch *Next; 50 }; 51 52 53 /** 54 * When GLX_INDIRECT_RENDERING is defined, some symbols are missing in 55 * libglapi.a. We need to define them here. 56 */ 57 #ifdef GLX_INDIRECT_RENDERING 58 59 #include "glapi/glapitable.h" 60 61 #define KEYWORD1 PUBLIC 62 63 #if defined(USE_MGL_NAMESPACE) 64 #define NAME(func) mgl##func 65 #else 66 #define NAME(func) gl##func 67 #endif 68 69 #define DISPATCH(FUNC, ARGS, MESSAGE) \ 70 GET_DISPATCH()->FUNC ARGS 71 72 #define RETURN_DISPATCH(FUNC, ARGS, MESSAGE) \ 73 return GET_DISPATCH()->FUNC ARGS 74 75 /* skip normal ones */ 76 #define _GLAPI_SKIP_NORMAL_ENTRY_POINTS 77 #include "glapi/glapitemp.h" 78 79 #endif /* GLX_INDIRECT_RENDERING */ 80 81 82 static struct display_dispatch *DispatchList = NULL; 83 84 85 /* Display -> Dispatch caching */ 86 static Display *prevDisplay = NULL; 87 static struct _glxapi_table *prevTable = NULL; 88 89 90 static struct _glxapi_table * 91 get_dispatch(Display *dpy) 92 { 93 if (!dpy) 94 return NULL; 95 96 /* search list of display/dispatch pairs for this display */ 97 { 98 const struct display_dispatch *d = DispatchList; 99 while (d) { 100 if (d->Dpy == dpy) { 101 prevDisplay = dpy; 102 prevTable = d->Table; 103 return d->Table; /* done! */ 104 } 105 d = d->Next; 106 } 107 } 108 109 /* Setup the dispatch table */ 110 { 111 struct _glxapi_table *t = _mesa_GetGLXDispatchTable(); 112 113 if (t) { 114 struct display_dispatch *d; 115 d = malloc(sizeof(struct display_dispatch)); 116 if (d) { 117 d->Dpy = dpy; 118 d->Table = t; 119 /* insert at head of list */ 120 d->Next = DispatchList; 121 DispatchList = d; 122 /* update cache */ 123 prevDisplay = dpy; 124 prevTable = t; 125 return t; 126 } 127 } 128 } 129 130 return NULL; 131 } 132 133 134 /* Don't use the GET_DISPATCH macro */ 135 #undef GET_DISPATCH 136 137 #define GET_DISPATCH(DPY, TABLE) \ 138 if (DPY == prevDisplay) { \ 139 TABLE = prevTable; \ 140 } \ 141 else if (!DPY) { \ 142 TABLE = NULL; \ 143 } \ 144 else { \ 145 TABLE = get_dispatch(DPY); \ 146 } 147 148 149 /* 150 * GLX API entrypoints 151 */ 152 153 /*** GLX_VERSION_1_0 ***/ 154 155 XVisualInfo PUBLIC * 156 glXChooseVisual(Display *dpy, int screen, int *list) 157 { 158 struct _glxapi_table *t; 159 GET_DISPATCH(dpy, t); 160 if (!t) 161 return NULL; 162 return t->ChooseVisual(dpy, screen, list); 163 } 164 165 166 void PUBLIC 167 glXCopyContext(Display *dpy, GLXContext src, GLXContext dst, unsigned long mask) 168 { 169 struct _glxapi_table *t; 170 GET_DISPATCH(dpy, t); 171 if (!t) 172 return; 173 t->CopyContext(dpy, src, dst, mask); 174 } 175 176 177 GLXContext PUBLIC 178 glXCreateContext(Display *dpy, XVisualInfo *visinfo, GLXContext shareList, Bool direct) 179 { 180 struct _glxapi_table *t; 181 GET_DISPATCH(dpy, t); 182 if (!t) 183 return 0; 184 return t->CreateContext(dpy, visinfo, shareList, direct); 185 } 186 187 188 GLXPixmap PUBLIC 189 glXCreateGLXPixmap(Display *dpy, XVisualInfo *visinfo, Pixmap pixmap) 190 { 191 struct _glxapi_table *t; 192 GET_DISPATCH(dpy, t); 193 if (!t) 194 return 0; 195 return t->CreateGLXPixmap(dpy, visinfo, pixmap); 196 } 197 198 199 void PUBLIC 200 glXDestroyContext(Display *dpy, GLXContext ctx) 201 { 202 struct _glxapi_table *t; 203 GET_DISPATCH(dpy, t); 204 if (!t) 205 return; 206 t->DestroyContext(dpy, ctx); 207 } 208 209 210 void PUBLIC 211 glXDestroyGLXPixmap(Display *dpy, GLXPixmap pixmap) 212 { 213 struct _glxapi_table *t; 214 GET_DISPATCH(dpy, t); 215 if (!t) 216 return; 217 t->DestroyGLXPixmap(dpy, pixmap); 218 } 219 220 221 int PUBLIC 222 glXGetConfig(Display *dpy, XVisualInfo *visinfo, int attrib, int *value) 223 { 224 struct _glxapi_table *t; 225 GET_DISPATCH(dpy, t); 226 if (!t) 227 return GLX_NO_EXTENSION; 228 return t->GetConfig(dpy, visinfo, attrib, value); 229 } 230 231 232 /* declare here to avoid including xmesa.h */ 233 extern void *XMesaGetCurrentContext(void); 234 235 GLXContext PUBLIC 236 glXGetCurrentContext(void) 237 { 238 return (GLXContext) XMesaGetCurrentContext(); 239 } 240 241 242 GLXDrawable PUBLIC 243 glXGetCurrentDrawable(void) 244 { 245 __GLXcontext *gc = (__GLXcontext *) glXGetCurrentContext(); 246 return gc ? gc->currentDrawable : 0; 247 } 248 249 250 Bool PUBLIC 251 glXIsDirect(Display *dpy, GLXContext ctx) 252 { 253 struct _glxapi_table *t; 254 GET_DISPATCH(dpy, t); 255 if (!t) 256 return False; 257 return t->IsDirect(dpy, ctx); 258 } 259 260 261 Bool PUBLIC 262 glXMakeCurrent(Display *dpy, GLXDrawable drawable, GLXContext ctx) 263 { 264 Bool b; 265 struct _glxapi_table *t; 266 GET_DISPATCH(dpy, t); 267 if (!t) { 268 return False; 269 } 270 b = t->MakeCurrent(dpy, drawable, ctx); 271 return b; 272 } 273 274 275 Bool PUBLIC 276 glXQueryExtension(Display *dpy, int *errorb, int *event) 277 { 278 struct _glxapi_table *t; 279 GET_DISPATCH(dpy, t); 280 if (!t) 281 return False; 282 return t->QueryExtension(dpy, errorb, event); 283 } 284 285 286 Bool PUBLIC 287 glXQueryVersion(Display *dpy, int *maj, int *min) 288 { 289 struct _glxapi_table *t; 290 GET_DISPATCH(dpy, t); 291 if (!t) 292 return False; 293 return t->QueryVersion(dpy, maj, min); 294 } 295 296 297 void PUBLIC 298 glXSwapBuffers(Display *dpy, GLXDrawable drawable) 299 { 300 struct _glxapi_table *t; 301 GET_DISPATCH(dpy, t); 302 if (!t) 303 return; 304 t->SwapBuffers(dpy, drawable); 305 } 306 307 308 void PUBLIC 309 glXUseXFont(Font font, int first, int count, int listBase) 310 { 311 struct _glxapi_table *t; 312 Display *dpy = glXGetCurrentDisplay(); 313 GET_DISPATCH(dpy, t); 314 if (!t) 315 return; 316 t->UseXFont(font, first, count, listBase); 317 } 318 319 320 void PUBLIC 321 glXWaitGL(void) 322 { 323 struct _glxapi_table *t; 324 Display *dpy = glXGetCurrentDisplay(); 325 GET_DISPATCH(dpy, t); 326 if (!t) 327 return; 328 t->WaitGL(); 329 } 330 331 332 void PUBLIC 333 glXWaitX(void) 334 { 335 struct _glxapi_table *t; 336 Display *dpy = glXGetCurrentDisplay(); 337 GET_DISPATCH(dpy, t); 338 if (!t) 339 return; 340 t->WaitX(); 341 } 342 343 344 345 /*** GLX_VERSION_1_1 ***/ 346 347 const char PUBLIC * 348 glXGetClientString(Display *dpy, int name) 349 { 350 struct _glxapi_table *t; 351 GET_DISPATCH(dpy, t); 352 if (!t) 353 return NULL; 354 return t->GetClientString(dpy, name); 355 } 356 357 358 const char PUBLIC * 359 glXQueryExtensionsString(Display *dpy, int screen) 360 { 361 struct _glxapi_table *t; 362 GET_DISPATCH(dpy, t); 363 if (!t) 364 return NULL; 365 return t->QueryExtensionsString(dpy, screen); 366 } 367 368 369 const char PUBLIC * 370 glXQueryServerString(Display *dpy, int screen, int name) 371 { 372 struct _glxapi_table *t; 373 GET_DISPATCH(dpy, t); 374 if (!t) 375 return NULL; 376 return t->QueryServerString(dpy, screen, name); 377 } 378 379 380 /*** GLX_VERSION_1_2 ***/ 381 382 Display PUBLIC * 383 glXGetCurrentDisplay(void) 384 { 385 /* Same code as in libGL's glxext.c */ 386 __GLXcontext *gc = (__GLXcontext *) glXGetCurrentContext(); 387 if (NULL == gc) return NULL; 388 return gc->currentDpy; 389 } 390 391 392 393 /*** GLX_VERSION_1_3 ***/ 394 395 GLXFBConfig PUBLIC * 396 glXChooseFBConfig(Display *dpy, int screen, const int *attribList, int *nitems) 397 { 398 struct _glxapi_table *t; 399 GET_DISPATCH(dpy, t); 400 if (!t) 401 return 0; 402 return t->ChooseFBConfig(dpy, screen, attribList, nitems); 403 } 404 405 406 GLXContext PUBLIC 407 glXCreateNewContext(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct) 408 { 409 struct _glxapi_table *t; 410 GET_DISPATCH(dpy, t); 411 if (!t) 412 return 0; 413 return t->CreateNewContext(dpy, config, renderType, shareList, direct); 414 } 415 416 417 GLXPbuffer PUBLIC 418 glXCreatePbuffer(Display *dpy, GLXFBConfig config, const int *attribList) 419 { 420 struct _glxapi_table *t; 421 GET_DISPATCH(dpy, t); 422 if (!t) 423 return 0; 424 return t->CreatePbuffer(dpy, config, attribList); 425 } 426 427 428 GLXPixmap PUBLIC 429 glXCreatePixmap(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList) 430 { 431 struct _glxapi_table *t; 432 GET_DISPATCH(dpy, t); 433 if (!t) 434 return 0; 435 return t->CreatePixmap(dpy, config, pixmap, attribList); 436 } 437 438 439 GLXWindow PUBLIC 440 glXCreateWindow(Display *dpy, GLXFBConfig config, Window win, const int *attribList) 441 { 442 struct _glxapi_table *t; 443 GET_DISPATCH(dpy, t); 444 if (!t) 445 return 0; 446 return t->CreateWindow(dpy, config, win, attribList); 447 } 448 449 450 void PUBLIC 451 glXDestroyPbuffer(Display *dpy, GLXPbuffer pbuf) 452 { 453 struct _glxapi_table *t; 454 GET_DISPATCH(dpy, t); 455 if (!t) 456 return; 457 t->DestroyPbuffer(dpy, pbuf); 458 } 459 460 461 void PUBLIC 462 glXDestroyPixmap(Display *dpy, GLXPixmap pixmap) 463 { 464 struct _glxapi_table *t; 465 GET_DISPATCH(dpy, t); 466 if (!t) 467 return; 468 t->DestroyPixmap(dpy, pixmap); 469 } 470 471 472 void PUBLIC 473 glXDestroyWindow(Display *dpy, GLXWindow window) 474 { 475 struct _glxapi_table *t; 476 GET_DISPATCH(dpy, t); 477 if (!t) 478 return; 479 t->DestroyWindow(dpy, window); 480 } 481 482 483 GLXDrawable PUBLIC 484 glXGetCurrentReadDrawable(void) 485 { 486 __GLXcontext *gc = (__GLXcontext *) glXGetCurrentContext(); 487 return gc ? gc->currentReadable : 0; 488 } 489 490 491 int PUBLIC 492 glXGetFBConfigAttrib(Display *dpy, GLXFBConfig config, int attribute, int *value) 493 { 494 struct _glxapi_table *t; 495 GET_DISPATCH(dpy, t); 496 if (!t) 497 return GLX_NO_EXTENSION; 498 return t->GetFBConfigAttrib(dpy, config, attribute, value); 499 } 500 501 502 GLXFBConfig PUBLIC * 503 glXGetFBConfigs(Display *dpy, int screen, int *nelements) 504 { 505 struct _glxapi_table *t; 506 GET_DISPATCH(dpy, t); 507 if (!t) 508 return 0; 509 return t->GetFBConfigs(dpy, screen, nelements); 510 } 511 512 void PUBLIC 513 glXGetSelectedEvent(Display *dpy, GLXDrawable drawable, unsigned long *mask) 514 { 515 struct _glxapi_table *t; 516 GET_DISPATCH(dpy, t); 517 if (!t) 518 return; 519 t->GetSelectedEvent(dpy, drawable, mask); 520 } 521 522 523 XVisualInfo PUBLIC * 524 glXGetVisualFromFBConfig(Display *dpy, GLXFBConfig config) 525 { 526 struct _glxapi_table *t; 527 GET_DISPATCH(dpy, t); 528 if (!t) 529 return NULL; 530 return t->GetVisualFromFBConfig(dpy, config); 531 } 532 533 534 Bool PUBLIC 535 glXMakeContextCurrent(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx) 536 { 537 Bool b; 538 struct _glxapi_table *t; 539 GET_DISPATCH(dpy, t); 540 if (!t) 541 return False; 542 b = t->MakeContextCurrent(dpy, draw, read, ctx); 543 return b; 544 } 545 546 547 int PUBLIC 548 glXQueryContext(Display *dpy, GLXContext ctx, int attribute, int *value) 549 { 550 struct _glxapi_table *t; 551 GET_DISPATCH(dpy, t); 552 assert(t); 553 if (!t) 554 return 0; /* XXX correct? */ 555 return t->QueryContext(dpy, ctx, attribute, value); 556 } 557 558 559 void PUBLIC 560 glXQueryDrawable(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value) 561 { 562 struct _glxapi_table *t; 563 GET_DISPATCH(dpy, t); 564 if (!t) 565 return; 566 t->QueryDrawable(dpy, draw, attribute, value); 567 } 568 569 570 void PUBLIC 571 glXSelectEvent(Display *dpy, GLXDrawable drawable, unsigned long mask) 572 { 573 struct _glxapi_table *t; 574 GET_DISPATCH(dpy, t); 575 if (!t) 576 return; 577 t->SelectEvent(dpy, drawable, mask); 578 } 579 580 581 582 /*** GLX_SGI_swap_control ***/ 583 584 int PUBLIC 585 glXSwapIntervalSGI(int interval) 586 { 587 struct _glxapi_table *t; 588 Display *dpy = glXGetCurrentDisplay(); 589 GET_DISPATCH(dpy, t); 590 if (!t) 591 return 0; 592 return t->SwapIntervalSGI(interval); 593 } 594 595 596 597 /*** GLX_SGI_video_sync ***/ 598 599 int PUBLIC 600 glXGetVideoSyncSGI(unsigned int *count) 601 { 602 struct _glxapi_table *t; 603 Display *dpy = glXGetCurrentDisplay(); 604 GET_DISPATCH(dpy, t); 605 if (!t || !glXGetCurrentContext()) 606 return GLX_BAD_CONTEXT; 607 return t->GetVideoSyncSGI(count); 608 } 609 610 int PUBLIC 611 glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count) 612 { 613 struct _glxapi_table *t; 614 Display *dpy = glXGetCurrentDisplay(); 615 GET_DISPATCH(dpy, t); 616 if (!t || !glXGetCurrentContext()) 617 return GLX_BAD_CONTEXT; 618 return t->WaitVideoSyncSGI(divisor, remainder, count); 619 } 620 621 622 623 /*** GLX_SGI_make_current_read ***/ 624 625 Bool PUBLIC 626 glXMakeCurrentReadSGI(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx) 627 { 628 struct _glxapi_table *t; 629 GET_DISPATCH(dpy, t); 630 if (!t) 631 return False; 632 return t->MakeCurrentReadSGI(dpy, draw, read, ctx); 633 } 634 635 GLXDrawable PUBLIC 636 glXGetCurrentReadDrawableSGI(void) 637 { 638 return glXGetCurrentReadDrawable(); 639 } 640 641 642 #if defined(_VL_H) 643 644 GLXVideoSourceSGIX PUBLIC 645 glXCreateGLXVideoSourceSGIX(Display *dpy, int screen, VLServer server, VLPath path, int nodeClass, VLNode drainNode) 646 { 647 struct _glxapi_table *t; 648 GET_DISPATCH(dpy, t); 649 if (!t) 650 return 0; 651 return t->CreateGLXVideoSourceSGIX(dpy, screen, server, path, nodeClass, drainNode); 652 } 653 654 void PUBLIC 655 glXDestroyGLXVideoSourceSGIX(Display *dpy, GLXVideoSourceSGIX src) 656 { 657 struct _glxapi_table *t; 658 GET_DISPATCH(dpy, t); 659 if (!t) 660 return 0; 661 return t->DestroyGLXVideoSourceSGIX(dpy, src); 662 } 663 664 #endif 665 666 667 /*** GLX_EXT_import_context ***/ 668 669 void PUBLIC 670 glXFreeContextEXT(Display *dpy, GLXContext context) 671 { 672 struct _glxapi_table *t; 673 GET_DISPATCH(dpy, t); 674 if (!t) 675 return; 676 t->FreeContextEXT(dpy, context); 677 } 678 679 GLXContextID PUBLIC 680 glXGetContextIDEXT(const GLXContext context) 681 { 682 return ((__GLXcontext *) context)->xid; 683 } 684 685 Display PUBLIC * 686 glXGetCurrentDisplayEXT(void) 687 { 688 return glXGetCurrentDisplay(); 689 } 690 691 GLXContext PUBLIC 692 glXImportContextEXT(Display *dpy, GLXContextID contextID) 693 { 694 struct _glxapi_table *t; 695 GET_DISPATCH(dpy, t); 696 if (!t) 697 return 0; 698 return t->ImportContextEXT(dpy, contextID); 699 } 700 701 int PUBLIC 702 glXQueryContextInfoEXT(Display *dpy, GLXContext context, int attribute,int *value) 703 { 704 struct _glxapi_table *t; 705 GET_DISPATCH(dpy, t); 706 if (!t) 707 return 0; /* XXX ok? */ 708 return t->QueryContextInfoEXT(dpy, context, attribute, value); 709 } 710 711 712 713 /*** GLX_SGIX_fbconfig ***/ 714 715 int PUBLIC 716 glXGetFBConfigAttribSGIX(Display *dpy, GLXFBConfigSGIX config, int attribute, int *value) 717 { 718 struct _glxapi_table *t; 719 GET_DISPATCH(dpy, t); 720 if (!t) 721 return 0; 722 return t->GetFBConfigAttribSGIX(dpy, config, attribute, value); 723 } 724 725 GLXFBConfigSGIX PUBLIC * 726 glXChooseFBConfigSGIX(Display *dpy, int screen, int *attrib_list, int *nelements) 727 { 728 struct _glxapi_table *t; 729 GET_DISPATCH(dpy, t); 730 if (!t) 731 return 0; 732 return t->ChooseFBConfigSGIX(dpy, screen, attrib_list, nelements); 733 } 734 735 GLXPixmap PUBLIC 736 glXCreateGLXPixmapWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, Pixmap pixmap) 737 { 738 struct _glxapi_table *t; 739 GET_DISPATCH(dpy, t); 740 if (!t) 741 return 0; 742 return t->CreateGLXPixmapWithConfigSGIX(dpy, config, pixmap); 743 } 744 745 GLXContext PUBLIC 746 glXCreateContextWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct) 747 { 748 struct _glxapi_table *t; 749 GET_DISPATCH(dpy, t); 750 if (!t) 751 return 0; 752 return t->CreateContextWithConfigSGIX(dpy, config, render_type, share_list, direct); 753 } 754 755 XVisualInfo PUBLIC * 756 glXGetVisualFromFBConfigSGIX(Display *dpy, GLXFBConfigSGIX config) 757 { 758 struct _glxapi_table *t; 759 GET_DISPATCH(dpy, t); 760 if (!t) 761 return 0; 762 return t->GetVisualFromFBConfigSGIX(dpy, config); 763 } 764 765 GLXFBConfigSGIX PUBLIC 766 glXGetFBConfigFromVisualSGIX(Display *dpy, XVisualInfo *vis) 767 { 768 struct _glxapi_table *t; 769 GET_DISPATCH(dpy, t); 770 if (!t) 771 return 0; 772 return t->GetFBConfigFromVisualSGIX(dpy, vis); 773 } 774 775 776 777 /*** GLX_SGIX_pbuffer ***/ 778 779 GLXPbufferSGIX PUBLIC 780 glXCreateGLXPbufferSGIX(Display *dpy, GLXFBConfigSGIX config, unsigned int width, unsigned int height, int *attrib_list) 781 { 782 struct _glxapi_table *t; 783 GET_DISPATCH(dpy, t); 784 if (!t) 785 return 0; 786 return t->CreateGLXPbufferSGIX(dpy, config, width, height, attrib_list); 787 } 788 789 void PUBLIC 790 glXDestroyGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf) 791 { 792 struct _glxapi_table *t; 793 GET_DISPATCH(dpy, t); 794 if (!t) 795 return; 796 t->DestroyGLXPbufferSGIX(dpy, pbuf); 797 } 798 799 int PUBLIC 800 glXQueryGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf, int attribute, unsigned int *value) 801 { 802 struct _glxapi_table *t; 803 GET_DISPATCH(dpy, t); 804 if (!t) 805 return 0; 806 return t->QueryGLXPbufferSGIX(dpy, pbuf, attribute, value); 807 } 808 809 void PUBLIC 810 glXSelectEventSGIX(Display *dpy, GLXDrawable drawable, unsigned long mask) 811 { 812 struct _glxapi_table *t; 813 GET_DISPATCH(dpy, t); 814 if (!t) 815 return; 816 t->SelectEventSGIX(dpy, drawable, mask); 817 } 818 819 void PUBLIC 820 glXGetSelectedEventSGIX(Display *dpy, GLXDrawable drawable, unsigned long *mask) 821 { 822 struct _glxapi_table *t; 823 GET_DISPATCH(dpy, t); 824 if (!t) 825 return; 826 t->GetSelectedEventSGIX(dpy, drawable, mask); 827 } 828 829 830 831 /*** GLX_SGI_cushion ***/ 832 833 void PUBLIC 834 glXCushionSGI(Display *dpy, Window win, float cushion) 835 { 836 struct _glxapi_table *t; 837 GET_DISPATCH(dpy, t); 838 if (!t) 839 return; 840 t->CushionSGI(dpy, win, cushion); 841 } 842 843 844 845 /*** GLX_SGIX_video_resize ***/ 846 847 int PUBLIC 848 glXBindChannelToWindowSGIX(Display *dpy, int screen, int channel , Window window) 849 { 850 struct _glxapi_table *t; 851 GET_DISPATCH(dpy, t); 852 if (!t) 853 return 0; 854 return t->BindChannelToWindowSGIX(dpy, screen, channel, window); 855 } 856 857 int PUBLIC 858 glXChannelRectSGIX(Display *dpy, int screen, int channel, int x, int y, int w, int h) 859 { 860 struct _glxapi_table *t; 861 GET_DISPATCH(dpy, t); 862 if (!t) 863 return 0; 864 return t->ChannelRectSGIX(dpy, screen, channel, x, y, w, h); 865 } 866 867 int PUBLIC 868 glXQueryChannelRectSGIX(Display *dpy, int screen, int channel, int *x, int *y, int *w, int *h) 869 { 870 struct _glxapi_table *t; 871 GET_DISPATCH(dpy, t); 872 if (!t) 873 return 0; 874 return t->QueryChannelRectSGIX(dpy, screen, channel, x, y, w, h); 875 } 876 877 int PUBLIC 878 glXQueryChannelDeltasSGIX(Display *dpy, int screen, int channel, int *dx, int *dy, int *dw, int *dh) 879 { 880 struct _glxapi_table *t; 881 GET_DISPATCH(dpy, t); 882 if (!t) 883 return 0; 884 return t->QueryChannelDeltasSGIX(dpy, screen, channel, dx, dy, dw, dh); 885 } 886 887 int PUBLIC 888 glXChannelRectSyncSGIX(Display *dpy, int screen, int channel, GLenum synctype) 889 { 890 struct _glxapi_table *t; 891 GET_DISPATCH(dpy, t); 892 if (!t) 893 return 0; 894 return t->ChannelRectSyncSGIX(dpy, screen, channel, synctype); 895 } 896 897 898 899 #if defined(_DM_BUFFER_H_) 900 901 Bool PUBLIC 902 glXAssociateDMPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuffer, DMparams *params, DMbuffer dmbuffer) 903 { 904 struct _glxapi_table *t; 905 GET_DISPATCH(dpy, t); 906 if (!t) 907 return False; 908 return t->AssociateDMPbufferSGIX(dpy, pbuffer, params, dmbuffer); 909 } 910 911 #endif 912 913 914 /*** GLX_SGIX_swap_group ***/ 915 916 void PUBLIC 917 glXJoinSwapGroupSGIX(Display *dpy, GLXDrawable drawable, GLXDrawable member) 918 { 919 struct _glxapi_table *t; 920 GET_DISPATCH(dpy, t); 921 if (!t) 922 return; 923 t->JoinSwapGroupSGIX(dpy, drawable, member); 924 } 925 926 927 /*** GLX_SGIX_swap_barrier ***/ 928 929 void PUBLIC 930 glXBindSwapBarrierSGIX(Display *dpy, GLXDrawable drawable, int barrier) 931 { 932 struct _glxapi_table *t; 933 GET_DISPATCH(dpy, t); 934 if (!t) 935 return; 936 t->BindSwapBarrierSGIX(dpy, drawable, barrier); 937 } 938 939 Bool PUBLIC 940 glXQueryMaxSwapBarriersSGIX(Display *dpy, int screen, int *max) 941 { 942 struct _glxapi_table *t; 943 GET_DISPATCH(dpy, t); 944 if (!t) 945 return False; 946 return t->QueryMaxSwapBarriersSGIX(dpy, screen, max); 947 } 948 949 950 951 /*** GLX_SUN_get_transparent_index ***/ 952 953 Status PUBLIC 954 glXGetTransparentIndexSUN(Display *dpy, Window overlay, Window underlay, long *pTransparent) 955 { 956 struct _glxapi_table *t; 957 GET_DISPATCH(dpy, t); 958 if (!t) 959 return False; 960 return t->GetTransparentIndexSUN(dpy, overlay, underlay, pTransparent); 961 } 962 963 964 965 /*** GLX_MESA_copy_sub_buffer ***/ 966 967 void PUBLIC 968 glXCopySubBufferMESA(Display *dpy, GLXDrawable drawable, int x, int y, int width, int height) 969 { 970 struct _glxapi_table *t; 971 GET_DISPATCH(dpy, t); 972 if (!t) 973 return; 974 t->CopySubBufferMESA(dpy, drawable, x, y, width, height); 975 } 976 977 978 979 /*** GLX_MESA_release_buffers ***/ 980 981 Bool PUBLIC 982 glXReleaseBuffersMESA(Display *dpy, Window w) 983 { 984 struct _glxapi_table *t; 985 GET_DISPATCH(dpy, t); 986 if (!t) 987 return False; 988 return t->ReleaseBuffersMESA(dpy, w); 989 } 990 991 992 993 /*** GLX_MESA_pixmap_colormap ***/ 994 995 GLXPixmap PUBLIC 996 glXCreateGLXPixmapMESA(Display *dpy, XVisualInfo *visinfo, Pixmap pixmap, Colormap cmap) 997 { 998 struct _glxapi_table *t; 999 GET_DISPATCH(dpy, t); 1000 if (!t) 1001 return 0; 1002 return t->CreateGLXPixmapMESA(dpy, visinfo, pixmap, cmap); 1003 } 1004 1005 1006 1007 /*** GLX_MESA_set_3dfx_mode ***/ 1008 1009 Bool PUBLIC 1010 glXSet3DfxModeMESA(int mode) 1011 { 1012 struct _glxapi_table *t; 1013 Display *dpy = glXGetCurrentDisplay(); 1014 GET_DISPATCH(dpy, t); 1015 if (!t) 1016 return False; 1017 return t->Set3DfxModeMESA(mode); 1018 } 1019 1020 1021 1022 /*** GLX_NV_vertex_array_range ***/ 1023 1024 void PUBLIC * 1025 glXAllocateMemoryNV( GLsizei size, 1026 GLfloat readFrequency, 1027 GLfloat writeFrequency, 1028 GLfloat priority ) 1029 { 1030 struct _glxapi_table *t; 1031 Display *dpy = glXGetCurrentDisplay(); 1032 GET_DISPATCH(dpy, t); 1033 if (!t) 1034 return NULL; 1035 return t->AllocateMemoryNV(size, readFrequency, writeFrequency, priority); 1036 } 1037 1038 1039 void PUBLIC 1040 glXFreeMemoryNV( GLvoid *pointer ) 1041 { 1042 struct _glxapi_table *t; 1043 Display *dpy = glXGetCurrentDisplay(); 1044 GET_DISPATCH(dpy, t); 1045 if (!t) 1046 return; 1047 t->FreeMemoryNV(pointer); 1048 } 1049 1050 1051 1052 1053 /*** GLX_MESA_agp_offset */ 1054 1055 GLuint PUBLIC 1056 glXGetAGPOffsetMESA( const GLvoid *pointer ) 1057 { 1058 struct _glxapi_table *t; 1059 Display *dpy = glXGetCurrentDisplay(); 1060 GET_DISPATCH(dpy, t); 1061 if (!t) 1062 return ~0; 1063 return t->GetAGPOffsetMESA(pointer); 1064 } 1065 1066 1067 /*** GLX_EXT_texture_from_pixmap */ 1068 1069 void PUBLIC 1070 glXBindTexImageEXT(Display *dpy, GLXDrawable drawable, int buffer, 1071 const int *attrib_list) 1072 { 1073 struct _glxapi_table *t; 1074 GET_DISPATCH(dpy, t); 1075 if (t) 1076 t->BindTexImageEXT(dpy, drawable, buffer, attrib_list); 1077 } 1078 1079 void PUBLIC 1080 glXReleaseTexImageEXT(Display *dpy, GLXDrawable drawable, int buffer) 1081 { 1082 struct _glxapi_table *t; 1083 GET_DISPATCH(dpy, t); 1084 if (t) 1085 t->ReleaseTexImageEXT(dpy, drawable, buffer); 1086 } 1087 1088 1089 /**********************************************************************/ 1090 /* GLX API management functions */ 1091 /**********************************************************************/ 1092 1093 1094 const char * 1095 _glxapi_get_version(void) 1096 { 1097 return "1.3"; 1098 } 1099 1100 1101 /* 1102 * Return array of extension strings. 1103 */ 1104 const char ** 1105 _glxapi_get_extensions(void) 1106 { 1107 static const char *extensions[] = { 1108 #ifdef GLX_EXT_import_context 1109 "GLX_EXT_import_context", 1110 #endif 1111 #ifdef GLX_SGI_video_sync 1112 "GLX_SGI_video_sync", 1113 #endif 1114 #ifdef GLX_MESA_copy_sub_buffer 1115 "GLX_MESA_copy_sub_buffer", 1116 #endif 1117 #ifdef GLX_MESA_release_buffers 1118 "GLX_MESA_release_buffers", 1119 #endif 1120 #ifdef GLX_MESA_pixmap_colormap 1121 "GLX_MESA_pixmap_colormap", 1122 #endif 1123 #ifdef GLX_MESA_set_3dfx_mode 1124 "GLX_MESA_set_3dfx_mode", 1125 #endif 1126 #ifdef GLX_SGIX_fbconfig 1127 "GLX_SGIX_fbconfig", 1128 #endif 1129 #ifdef GLX_SGIX_pbuffer 1130 "GLX_SGIX_pbuffer", 1131 #endif 1132 #ifdef GLX_EXT_texture_from_pixmap 1133 "GLX_EXT_texture_from_pixmap", 1134 #endif 1135 #ifdef GLX_INTEL_swap_event 1136 "GLX_INTEL_swap_event", 1137 #endif 1138 NULL 1139 }; 1140 return extensions; 1141 } 1142 1143 1144 /* 1145 * Return size of the GLX dispatch table, in entries, not bytes. 1146 */ 1147 GLuint 1148 _glxapi_get_dispatch_table_size(void) 1149 { 1150 return sizeof(struct _glxapi_table) / sizeof(void *); 1151 } 1152 1153 1154 static int 1155 generic_no_op_func(void) 1156 { 1157 return 0; 1158 } 1159 1160 1161 /* 1162 * Initialize all functions in given dispatch table to be no-ops 1163 */ 1164 void 1165 _glxapi_set_no_op_table(struct _glxapi_table *t) 1166 { 1167 typedef int (*nop_func)(void); 1168 nop_func *dispatch = (nop_func *) t; 1169 GLuint n = _glxapi_get_dispatch_table_size(); 1170 GLuint i; 1171 for (i = 0; i < n; i++) { 1172 dispatch[i] = generic_no_op_func; 1173 } 1174 } 1175 1176 1177 struct name_address_pair { 1178 const char *Name; 1179 __GLXextFuncPtr Address; 1180 }; 1181 1182 static struct name_address_pair GLX_functions[] = { 1183 /*** GLX_VERSION_1_0 ***/ 1184 { "glXChooseVisual", (__GLXextFuncPtr) glXChooseVisual }, 1185 { "glXCopyContext", (__GLXextFuncPtr) glXCopyContext }, 1186 { "glXCreateContext", (__GLXextFuncPtr) glXCreateContext }, 1187 { "glXCreateGLXPixmap", (__GLXextFuncPtr) glXCreateGLXPixmap }, 1188 { "glXDestroyContext", (__GLXextFuncPtr) glXDestroyContext }, 1189 { "glXDestroyGLXPixmap", (__GLXextFuncPtr) glXDestroyGLXPixmap }, 1190 { "glXGetConfig", (__GLXextFuncPtr) glXGetConfig }, 1191 { "glXGetCurrentContext", (__GLXextFuncPtr) glXGetCurrentContext }, 1192 { "glXGetCurrentDrawable", (__GLXextFuncPtr) glXGetCurrentDrawable }, 1193 { "glXIsDirect", (__GLXextFuncPtr) glXIsDirect }, 1194 { "glXMakeCurrent", (__GLXextFuncPtr) glXMakeCurrent }, 1195 { "glXQueryExtension", (__GLXextFuncPtr) glXQueryExtension }, 1196 { "glXQueryVersion", (__GLXextFuncPtr) glXQueryVersion }, 1197 { "glXSwapBuffers", (__GLXextFuncPtr) glXSwapBuffers }, 1198 { "glXUseXFont", (__GLXextFuncPtr) glXUseXFont }, 1199 { "glXWaitGL", (__GLXextFuncPtr) glXWaitGL }, 1200 { "glXWaitX", (__GLXextFuncPtr) glXWaitX }, 1201 1202 /*** GLX_VERSION_1_1 ***/ 1203 { "glXGetClientString", (__GLXextFuncPtr) glXGetClientString }, 1204 { "glXQueryExtensionsString", (__GLXextFuncPtr) glXQueryExtensionsString }, 1205 { "glXQueryServerString", (__GLXextFuncPtr) glXQueryServerString }, 1206 1207 /*** GLX_VERSION_1_2 ***/ 1208 { "glXGetCurrentDisplay", (__GLXextFuncPtr) glXGetCurrentDisplay }, 1209 1210 /*** GLX_VERSION_1_3 ***/ 1211 { "glXChooseFBConfig", (__GLXextFuncPtr) glXChooseFBConfig }, 1212 { "glXCreateNewContext", (__GLXextFuncPtr) glXCreateNewContext }, 1213 { "glXCreatePbuffer", (__GLXextFuncPtr) glXCreatePbuffer }, 1214 { "glXCreatePixmap", (__GLXextFuncPtr) glXCreatePixmap }, 1215 { "glXCreateWindow", (__GLXextFuncPtr) glXCreateWindow }, 1216 { "glXDestroyPbuffer", (__GLXextFuncPtr) glXDestroyPbuffer }, 1217 { "glXDestroyPixmap", (__GLXextFuncPtr) glXDestroyPixmap }, 1218 { "glXDestroyWindow", (__GLXextFuncPtr) glXDestroyWindow }, 1219 { "glXGetCurrentReadDrawable", (__GLXextFuncPtr) glXGetCurrentReadDrawable }, 1220 { "glXGetFBConfigAttrib", (__GLXextFuncPtr) glXGetFBConfigAttrib }, 1221 { "glXGetFBConfigs", (__GLXextFuncPtr) glXGetFBConfigs }, 1222 { "glXGetSelectedEvent", (__GLXextFuncPtr) glXGetSelectedEvent }, 1223 { "glXGetVisualFromFBConfig", (__GLXextFuncPtr) glXGetVisualFromFBConfig }, 1224 { "glXMakeContextCurrent", (__GLXextFuncPtr) glXMakeContextCurrent }, 1225 { "glXQueryContext", (__GLXextFuncPtr) glXQueryContext }, 1226 { "glXQueryDrawable", (__GLXextFuncPtr) glXQueryDrawable }, 1227 { "glXSelectEvent", (__GLXextFuncPtr) glXSelectEvent }, 1228 1229 /*** GLX_VERSION_1_4 ***/ 1230 { "glXGetProcAddress", (__GLXextFuncPtr) glXGetProcAddress }, 1231 1232 /*** GLX_SGI_swap_control ***/ 1233 { "glXSwapIntervalSGI", (__GLXextFuncPtr) glXSwapIntervalSGI }, 1234 1235 /*** GLX_SGI_video_sync ***/ 1236 { "glXGetVideoSyncSGI", (__GLXextFuncPtr) glXGetVideoSyncSGI }, 1237 { "glXWaitVideoSyncSGI", (__GLXextFuncPtr) glXWaitVideoSyncSGI }, 1238 1239 /*** GLX_SGI_make_current_read ***/ 1240 { "glXMakeCurrentReadSGI", (__GLXextFuncPtr) glXMakeCurrentReadSGI }, 1241 { "glXGetCurrentReadDrawableSGI", (__GLXextFuncPtr) glXGetCurrentReadDrawableSGI }, 1242 1243 /*** GLX_SGIX_video_source ***/ 1244 #if defined(_VL_H) 1245 { "glXCreateGLXVideoSourceSGIX", (__GLXextFuncPtr) glXCreateGLXVideoSourceSGIX }, 1246 { "glXDestroyGLXVideoSourceSGIX", (__GLXextFuncPtr) glXDestroyGLXVideoSourceSGIX }, 1247 #endif 1248 1249 /*** GLX_EXT_import_context ***/ 1250 { "glXFreeContextEXT", (__GLXextFuncPtr) glXFreeContextEXT }, 1251 { "glXGetContextIDEXT", (__GLXextFuncPtr) glXGetContextIDEXT }, 1252 { "glXGetCurrentDisplayEXT", (__GLXextFuncPtr) glXGetCurrentDisplayEXT }, 1253 { "glXImportContextEXT", (__GLXextFuncPtr) glXImportContextEXT }, 1254 { "glXQueryContextInfoEXT", (__GLXextFuncPtr) glXQueryContextInfoEXT }, 1255 1256 /*** GLX_SGIX_fbconfig ***/ 1257 { "glXGetFBConfigAttribSGIX", (__GLXextFuncPtr) glXGetFBConfigAttribSGIX }, 1258 { "glXChooseFBConfigSGIX", (__GLXextFuncPtr) glXChooseFBConfigSGIX }, 1259 { "glXCreateGLXPixmapWithConfigSGIX", (__GLXextFuncPtr) glXCreateGLXPixmapWithConfigSGIX }, 1260 { "glXCreateContextWithConfigSGIX", (__GLXextFuncPtr) glXCreateContextWithConfigSGIX }, 1261 { "glXGetVisualFromFBConfigSGIX", (__GLXextFuncPtr) glXGetVisualFromFBConfigSGIX }, 1262 { "glXGetFBConfigFromVisualSGIX", (__GLXextFuncPtr) glXGetFBConfigFromVisualSGIX }, 1263 1264 /*** GLX_SGIX_pbuffer ***/ 1265 { "glXCreateGLXPbufferSGIX", (__GLXextFuncPtr) glXCreateGLXPbufferSGIX }, 1266 { "glXDestroyGLXPbufferSGIX", (__GLXextFuncPtr) glXDestroyGLXPbufferSGIX }, 1267 { "glXQueryGLXPbufferSGIX", (__GLXextFuncPtr) glXQueryGLXPbufferSGIX }, 1268 { "glXSelectEventSGIX", (__GLXextFuncPtr) glXSelectEventSGIX }, 1269 { "glXGetSelectedEventSGIX", (__GLXextFuncPtr) glXGetSelectedEventSGIX }, 1270 1271 /*** GLX_SGI_cushion ***/ 1272 { "glXCushionSGI", (__GLXextFuncPtr) glXCushionSGI }, 1273 1274 /*** GLX_SGIX_video_resize ***/ 1275 { "glXBindChannelToWindowSGIX", (__GLXextFuncPtr) glXBindChannelToWindowSGIX }, 1276 { "glXChannelRectSGIX", (__GLXextFuncPtr) glXChannelRectSGIX }, 1277 { "glXQueryChannelRectSGIX", (__GLXextFuncPtr) glXQueryChannelRectSGIX }, 1278 { "glXQueryChannelDeltasSGIX", (__GLXextFuncPtr) glXQueryChannelDeltasSGIX }, 1279 { "glXChannelRectSyncSGIX", (__GLXextFuncPtr) glXChannelRectSyncSGIX }, 1280 1281 /*** GLX_SGIX_dmbuffer **/ 1282 #if defined(_DM_BUFFER_H_) 1283 { "glXAssociateDMPbufferSGIX", (__GLXextFuncPtr) glXAssociateDMPbufferSGIX }, 1284 #endif 1285 1286 /*** GLX_SGIX_swap_group ***/ 1287 { "glXJoinSwapGroupSGIX", (__GLXextFuncPtr) glXJoinSwapGroupSGIX }, 1288 1289 /*** GLX_SGIX_swap_barrier ***/ 1290 { "glXBindSwapBarrierSGIX", (__GLXextFuncPtr) glXBindSwapBarrierSGIX }, 1291 { "glXQueryMaxSwapBarriersSGIX", (__GLXextFuncPtr) glXQueryMaxSwapBarriersSGIX }, 1292 1293 /*** GLX_SUN_get_transparent_index ***/ 1294 { "glXGetTransparentIndexSUN", (__GLXextFuncPtr) glXGetTransparentIndexSUN }, 1295 1296 /*** GLX_MESA_copy_sub_buffer ***/ 1297 { "glXCopySubBufferMESA", (__GLXextFuncPtr) glXCopySubBufferMESA }, 1298 1299 /*** GLX_MESA_pixmap_colormap ***/ 1300 { "glXCreateGLXPixmapMESA", (__GLXextFuncPtr) glXCreateGLXPixmapMESA }, 1301 1302 /*** GLX_MESA_release_buffers ***/ 1303 { "glXReleaseBuffersMESA", (__GLXextFuncPtr) glXReleaseBuffersMESA }, 1304 1305 /*** GLX_MESA_set_3dfx_mode ***/ 1306 { "glXSet3DfxModeMESA", (__GLXextFuncPtr) glXSet3DfxModeMESA }, 1307 1308 /*** GLX_ARB_get_proc_address ***/ 1309 { "glXGetProcAddressARB", (__GLXextFuncPtr) glXGetProcAddressARB }, 1310 1311 /*** GLX_NV_vertex_array_range ***/ 1312 { "glXAllocateMemoryNV", (__GLXextFuncPtr) glXAllocateMemoryNV }, 1313 { "glXFreeMemoryNV", (__GLXextFuncPtr) glXFreeMemoryNV }, 1314 1315 /*** GLX_MESA_agp_offset ***/ 1316 { "glXGetAGPOffsetMESA", (__GLXextFuncPtr) glXGetAGPOffsetMESA }, 1317 1318 /*** GLX_EXT_texture_from_pixmap ***/ 1319 { "glXBindTexImageEXT", (__GLXextFuncPtr) glXBindTexImageEXT }, 1320 { "glXReleaseTexImageEXT", (__GLXextFuncPtr) glXReleaseTexImageEXT }, 1321 1322 /*** GLX_ARB_create_context ***/ 1323 { "glXCreateContextAttribsARB", (__GLXextFuncPtr) glXCreateContextAttribsARB }, 1324 1325 { NULL, NULL } /* end of list */ 1326 }; 1327 1328 1329 1330 /* 1331 * Return address of named glX function, or NULL if not found. 1332 */ 1333 __GLXextFuncPtr 1334 _glxapi_get_proc_address(const char *funcName) 1335 { 1336 GLuint i; 1337 for (i = 0; GLX_functions[i].Name; i++) { 1338 #ifdef MANGLE 1339 /* skip the "m" prefix on the name */ 1340 if (strcmp(GLX_functions[i].Name, funcName+1) == 0) 1341 #else 1342 if (strcmp(GLX_functions[i].Name, funcName) == 0) 1343 #endif 1344 return GLX_functions[i].Address; 1345 } 1346 return NULL; 1347 } 1348 1349 1350 1351 /* 1352 * This function does not get dispatched through the dispatch table 1353 * since it's really a "meta" function. 1354 */ 1355 __GLXextFuncPtr PUBLIC 1356 glXGetProcAddressARB(const GLubyte *procName) 1357 { 1358 __GLXextFuncPtr f; 1359 1360 f = _glxapi_get_proc_address((const char *) procName); 1361 if (f) { 1362 return f; 1363 } 1364 1365 f = (__GLXextFuncPtr) _glapi_get_proc_address((const char *) procName); 1366 return f; 1367 } 1368 1369 1370 /* GLX 1.4 */ 1371 void PUBLIC 1372 (*glXGetProcAddress(const GLubyte *procName))() 1373 { 1374 return glXGetProcAddressARB(procName); 1375 } 1376 1377 1378 /** 1379 * Added in GLX_ARB_create_context. 1380 */ 1381 GLXContext PUBLIC 1382 glXCreateContextAttribsARB(Display *dpy, GLXFBConfig config, 1383 GLXContext share_context, Bool direct, 1384 const int *attrib_list) 1385 { 1386 struct _glxapi_table *t; 1387 GET_DISPATCH(dpy, t); 1388 if (!t) 1389 return 0; 1390 return t->CreateContextAttribs(dpy, config, share_context, direct, 1391 attrib_list); 1392 } 1393
