src/mesa/drivers/x11/glxapi.c

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