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/dispatch.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    CALL_ ## FUNC(GET_DISPATCH(), ARGS);
  72
  73 #define RETURN_DISPATCH(FUNC, ARGS, MESSAGE)    \
  74    return CALL_ ## FUNC(GET_DISPATCH(), 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_MESA_allocate_memory */
1114
1115 void *
1116 glXAllocateMemoryMESA(Display *dpy, int scrn, size_t size,
1117                       float readfreq, float writefreq, float priority)
1118 {
1119    /* dummy */
1120    return NULL;
1121 }
1122
1123 void
1124 glXFreeMemoryMESA(Display *dpy, int scrn, void *pointer)
1125 {
1126    /* dummy */
1127 }
1128
1129
1130 GLuint
1131 glXGetMemoryOffsetMESA(Display *dpy, int scrn, const void *pointer)
1132 {
1133    /* dummy */
1134    return 0;
1135 }
1136
1137
1138 /*** GLX_EXT_texture_from_pixmap */
1139
1140 void
1141 glXBindTexImageEXT(Display *dpy, GLXDrawable drawable, int buffer,
1142                    const int *attrib_list)
1143 {
1144    struct _glxapi_table *t;
1145    GET_DISPATCH(dpy, t);
1146    if (t)
1147       t->BindTexImageEXT(dpy, drawable, buffer, attrib_list);
1148 }
1149
1150 void
1151 glXReleaseTexImageEXT(Display *dpy, GLXDrawable drawable, int buffer)
1152 {
1153    struct _glxapi_table *t;
1154    GET_DISPATCH(dpy, t);
1155    if (t)
1156       t->ReleaseTexImageEXT(dpy, drawable, buffer);
1157 }
1158
1159
1160 /**********************************************************************/
1161 /* GLX API management functions                                       */
1162 /**********************************************************************/
1163
1164
1165 const char *
1166 _glxapi_get_version(void)
1167 {
1168    return "1.3";
1169 }
1170
1171
1172 /*
1173  * Return array of extension strings.
1174  */
1175 const char **
1176 _glxapi_get_extensions(void)
1177 {
1178    static const char *extensions[] = {
1179 #ifdef GLX_EXT_import_context
1180       "GLX_EXT_import_context",
1181 #endif
1182 #ifdef GLX_SGI_video_sync
1183       "GLX_SGI_video_sync",
1184 #endif
1185 #ifdef GLX_MESA_copy_sub_buffer
1186       "GLX_MESA_copy_sub_buffer",
1187 #endif
1188 #ifdef GLX_MESA_release_buffers
1189       "GLX_MESA_release_buffers",
1190 #endif
1191 #ifdef GLX_MESA_pixmap_colormap
1192       "GLX_MESA_pixmap_colormap",
1193 #endif
1194 #ifdef GLX_MESA_set_3dfx_mode
1195       "GLX_MESA_set_3dfx_mode",
1196 #endif
1197 #ifdef GLX_SGIX_fbconfig
1198       "GLX_SGIX_fbconfig",
1199 #endif
1200 #ifdef GLX_SGIX_pbuffer
1201       "GLX_SGIX_pbuffer",
1202 #endif
1203 #ifdef GLX_EXT_texture_from_pixmap
1204       "GLX_EXT_texture_from_pixmap",
1205 #endif
1206 #ifdef GLX_INTEL_swap_event
1207       "GLX_INTEL_swap_event",
1208 #endif
1209       NULL
1210    };
1211    return extensions;
1212 }
1213
1214
1215 /*
1216  * Return size of the GLX dispatch table, in entries, not bytes.
1217  */
1218 GLuint
1219 _glxapi_get_dispatch_table_size(void)
1220 {
1221    return sizeof(struct _glxapi_table) / sizeof(void *);
1222 }
1223
1224
1225 static int
1226 generic_no_op_func(void)
1227 {
1228    return 0;
1229 }
1230
1231
1232 /*
1233  * Initialize all functions in given dispatch table to be no-ops
1234  */
1235 void
1236 _glxapi_set_no_op_table(struct _glxapi_table *t)
1237 {
1238    typedef int (*nop_func)(void);
1239    nop_func *dispatch = (nop_func *) t;
1240    GLuint n = _glxapi_get_dispatch_table_size();
1241    GLuint i;
1242    for (i = 0; i < n; i++) {
1243       dispatch[i] = generic_no_op_func;
1244    }
1245 }
1246
1247
1248 struct name_address_pair {
1249    const char *Name;
1250    __GLXextFuncPtr Address;
1251 };
1252
1253 static struct name_address_pair GLX_functions[] = {
1254    /*** GLX_VERSION_1_0 ***/
1255    { "glXChooseVisual", (__GLXextFuncPtr) glXChooseVisual },
1256    { "glXCopyContext", (__GLXextFuncPtr) glXCopyContext },
1257    { "glXCreateContext", (__GLXextFuncPtr) glXCreateContext },
1258    { "glXCreateGLXPixmap", (__GLXextFuncPtr) glXCreateGLXPixmap },
1259    { "glXDestroyContext", (__GLXextFuncPtr) glXDestroyContext },
1260    { "glXDestroyGLXPixmap", (__GLXextFuncPtr) glXDestroyGLXPixmap },
1261    { "glXGetConfig", (__GLXextFuncPtr) glXGetConfig },
1262    { "glXGetCurrentContext", (__GLXextFuncPtr) glXGetCurrentContext },
1263    { "glXGetCurrentDrawable", (__GLXextFuncPtr) glXGetCurrentDrawable },
1264    { "glXIsDirect", (__GLXextFuncPtr) glXIsDirect },
1265    { "glXMakeCurrent", (__GLXextFuncPtr) glXMakeCurrent },
1266    { "glXQueryExtension", (__GLXextFuncPtr) glXQueryExtension },
1267    { "glXQueryVersion", (__GLXextFuncPtr) glXQueryVersion },
1268    { "glXSwapBuffers", (__GLXextFuncPtr) glXSwapBuffers },
1269    { "glXUseXFont", (__GLXextFuncPtr) glXUseXFont },
1270    { "glXWaitGL", (__GLXextFuncPtr) glXWaitGL },
1271    { "glXWaitX", (__GLXextFuncPtr) glXWaitX },
1272
1273    /*** GLX_VERSION_1_1 ***/
1274    { "glXGetClientString", (__GLXextFuncPtr) glXGetClientString },
1275    { "glXQueryExtensionsString", (__GLXextFuncPtr) glXQueryExtensionsString },
1276    { "glXQueryServerString", (__GLXextFuncPtr) glXQueryServerString },
1277
1278    /*** GLX_VERSION_1_2 ***/
1279    { "glXGetCurrentDisplay", (__GLXextFuncPtr) glXGetCurrentDisplay },
1280
1281    /*** GLX_VERSION_1_3 ***/
1282    { "glXChooseFBConfig", (__GLXextFuncPtr) glXChooseFBConfig },
1283    { "glXCreateNewContext", (__GLXextFuncPtr) glXCreateNewContext },
1284    { "glXCreatePbuffer", (__GLXextFuncPtr) glXCreatePbuffer },
1285    { "glXCreatePixmap", (__GLXextFuncPtr) glXCreatePixmap },
1286    { "glXCreateWindow", (__GLXextFuncPtr) glXCreateWindow },
1287    { "glXDestroyPbuffer", (__GLXextFuncPtr) glXDestroyPbuffer },
1288    { "glXDestroyPixmap", (__GLXextFuncPtr) glXDestroyPixmap },
1289    { "glXDestroyWindow", (__GLXextFuncPtr) glXDestroyWindow },
1290    { "glXGetCurrentReadDrawable", (__GLXextFuncPtr) glXGetCurrentReadDrawable },
1291    { "glXGetFBConfigAttrib", (__GLXextFuncPtr) glXGetFBConfigAttrib },
1292    { "glXGetFBConfigs", (__GLXextFuncPtr) glXGetFBConfigs },
1293    { "glXGetSelectedEvent", (__GLXextFuncPtr) glXGetSelectedEvent },
1294    { "glXGetVisualFromFBConfig", (__GLXextFuncPtr) glXGetVisualFromFBConfig },
1295    { "glXMakeContextCurrent", (__GLXextFuncPtr) glXMakeContextCurrent },
1296    { "glXQueryContext", (__GLXextFuncPtr) glXQueryContext },
1297    { "glXQueryDrawable", (__GLXextFuncPtr) glXQueryDrawable },
1298    { "glXSelectEvent", (__GLXextFuncPtr) glXSelectEvent },
1299
1300    /*** GLX_VERSION_1_4 ***/
1301    { "glXGetProcAddress", (__GLXextFuncPtr) glXGetProcAddress },
1302
1303    /*** GLX_SGI_swap_control ***/
1304    { "glXSwapIntervalSGI", (__GLXextFuncPtr) glXSwapIntervalSGI },
1305
1306    /*** GLX_SGI_video_sync ***/
1307    { "glXGetVideoSyncSGI", (__GLXextFuncPtr) glXGetVideoSyncSGI },
1308    { "glXWaitVideoSyncSGI", (__GLXextFuncPtr) glXWaitVideoSyncSGI },
1309
1310    /*** GLX_SGI_make_current_read ***/
1311    { "glXMakeCurrentReadSGI", (__GLXextFuncPtr) glXMakeCurrentReadSGI },
1312    { "glXGetCurrentReadDrawableSGI", (__GLXextFuncPtr) glXGetCurrentReadDrawableSGI },
1313
1314    /*** GLX_SGIX_video_source ***/
1315 #if defined(_VL_H)
1316    { "glXCreateGLXVideoSourceSGIX", (__GLXextFuncPtr) glXCreateGLXVideoSourceSGIX },
1317    { "glXDestroyGLXVideoSourceSGIX", (__GLXextFuncPtr) glXDestroyGLXVideoSourceSGIX },
1318 #endif
1319
1320    /*** GLX_EXT_import_context ***/
1321    { "glXFreeContextEXT", (__GLXextFuncPtr) glXFreeContextEXT },
1322    { "glXGetContextIDEXT", (__GLXextFuncPtr) glXGetContextIDEXT },
1323    { "glXGetCurrentDisplayEXT", (__GLXextFuncPtr) glXGetCurrentDisplayEXT },
1324    { "glXImportContextEXT", (__GLXextFuncPtr) glXImportContextEXT },
1325    { "glXQueryContextInfoEXT", (__GLXextFuncPtr) glXQueryContextInfoEXT },
1326
1327    /*** GLX_SGIX_fbconfig ***/
1328    { "glXGetFBConfigAttribSGIX", (__GLXextFuncPtr) glXGetFBConfigAttribSGIX },
1329    { "glXChooseFBConfigSGIX", (__GLXextFuncPtr) glXChooseFBConfigSGIX },
1330    { "glXCreateGLXPixmapWithConfigSGIX", (__GLXextFuncPtr) glXCreateGLXPixmapWithConfigSGIX },
1331    { "glXCreateContextWithConfigSGIX", (__GLXextFuncPtr) glXCreateContextWithConfigSGIX },
1332    { "glXGetVisualFromFBConfigSGIX", (__GLXextFuncPtr) glXGetVisualFromFBConfigSGIX },
1333    { "glXGetFBConfigFromVisualSGIX", (__GLXextFuncPtr) glXGetFBConfigFromVisualSGIX },
1334
1335    /*** GLX_SGIX_pbuffer ***/
1336    { "glXCreateGLXPbufferSGIX", (__GLXextFuncPtr) glXCreateGLXPbufferSGIX },
1337    { "glXDestroyGLXPbufferSGIX", (__GLXextFuncPtr) glXDestroyGLXPbufferSGIX },
1338    { "glXQueryGLXPbufferSGIX", (__GLXextFuncPtr) glXQueryGLXPbufferSGIX },
1339    { "glXSelectEventSGIX", (__GLXextFuncPtr) glXSelectEventSGIX },
1340    { "glXGetSelectedEventSGIX", (__GLXextFuncPtr) glXGetSelectedEventSGIX },
1341
1342    /*** GLX_SGI_cushion ***/
1343    { "glXCushionSGI", (__GLXextFuncPtr) glXCushionSGI },
1344
1345    /*** GLX_SGIX_video_resize ***/
1346    { "glXBindChannelToWindowSGIX", (__GLXextFuncPtr) glXBindChannelToWindowSGIX },
1347    { "glXChannelRectSGIX", (__GLXextFuncPtr) glXChannelRectSGIX },
1348    { "glXQueryChannelRectSGIX", (__GLXextFuncPtr) glXQueryChannelRectSGIX },
1349    { "glXQueryChannelDeltasSGIX", (__GLXextFuncPtr) glXQueryChannelDeltasSGIX },
1350    { "glXChannelRectSyncSGIX", (__GLXextFuncPtr) glXChannelRectSyncSGIX },
1351
1352    /*** GLX_SGIX_dmbuffer **/
1353 #if defined(_DM_BUFFER_H_)
1354    { "glXAssociateDMPbufferSGIX", (__GLXextFuncPtr) glXAssociateDMPbufferSGIX },
1355 #endif
1356
1357    /*** GLX_SGIX_swap_group ***/
1358    { "glXJoinSwapGroupSGIX", (__GLXextFuncPtr) glXJoinSwapGroupSGIX },
1359
1360    /*** GLX_SGIX_swap_barrier ***/
1361    { "glXBindSwapBarrierSGIX", (__GLXextFuncPtr) glXBindSwapBarrierSGIX },
1362    { "glXQueryMaxSwapBarriersSGIX", (__GLXextFuncPtr) glXQueryMaxSwapBarriersSGIX },
1363
1364    /*** GLX_SUN_get_transparent_index ***/
1365    { "glXGetTransparentIndexSUN", (__GLXextFuncPtr) glXGetTransparentIndexSUN },
1366
1367    /*** GLX_MESA_copy_sub_buffer ***/
1368    { "glXCopySubBufferMESA", (__GLXextFuncPtr) glXCopySubBufferMESA },
1369
1370    /*** GLX_MESA_pixmap_colormap ***/
1371    { "glXCreateGLXPixmapMESA", (__GLXextFuncPtr) glXCreateGLXPixmapMESA },
1372
1373    /*** GLX_MESA_release_buffers ***/
1374    { "glXReleaseBuffersMESA", (__GLXextFuncPtr) glXReleaseBuffersMESA },
1375
1376    /*** GLX_MESA_set_3dfx_mode ***/
1377    { "glXSet3DfxModeMESA", (__GLXextFuncPtr) glXSet3DfxModeMESA },
1378
1379    /*** GLX_ARB_get_proc_address ***/
1380    { "glXGetProcAddressARB", (__GLXextFuncPtr) glXGetProcAddressARB },
1381
1382    /*** GLX_NV_vertex_array_range ***/
1383    { "glXAllocateMemoryNV", (__GLXextFuncPtr) glXAllocateMemoryNV },
1384    { "glXFreeMemoryNV", (__GLXextFuncPtr) glXFreeMemoryNV },
1385
1386    /*** GLX_MESA_agp_offset ***/
1387    { "glXGetAGPOffsetMESA", (__GLXextFuncPtr) glXGetAGPOffsetMESA },
1388
1389    /*** GLX_MESA_allocate_memory ***/
1390    { "glXAllocateMemoryMESA", (__GLXextFuncPtr) glXAllocateMemoryMESA },
1391    { "glXFreeMemoryMESA", (__GLXextFuncPtr) glXFreeMemoryMESA },
1392    { "glXGetMemoryOffsetMESA", (__GLXextFuncPtr) glXGetMemoryOffsetMESA },
1393
1394    /*** GLX_EXT_texture_from_pixmap ***/
1395    { "glXBindTexImageEXT", (__GLXextFuncPtr) glXBindTexImageEXT },
1396    { "glXReleaseTexImageEXT", (__GLXextFuncPtr) glXReleaseTexImageEXT },
1397
1398    { NULL, NULL }   /* end of list */
1399 };
1400
1401
1402
1403 /*
1404  * Return address of named glX function, or NULL if not found.
1405  */
1406 __GLXextFuncPtr
1407 _glxapi_get_proc_address(const char *funcName)
1408 {
1409    GLuint i;
1410    for (i = 0; GLX_functions[i].Name; i++) {
1411 #ifdef MANGLE
1412       /* skip the "m" prefix on the name */
1413       if (strcmp(GLX_functions[i].Name, funcName+1) == 0)
1414 #else
1415       if (strcmp(GLX_functions[i].Name, funcName) == 0)
1416 #endif
1417          return GLX_functions[i].Address;
1418    }
1419    return NULL;
1420 }
1421
1422
1423
1424 /*
1425  * This function does not get dispatched through the dispatch table
1426  * since it's really a "meta" function.
1427  */
1428 __GLXextFuncPtr
1429 glXGetProcAddressARB(const GLubyte *procName)
1430 {
1431    __GLXextFuncPtr f;
1432
1433    f = _glxapi_get_proc_address((const char *) procName);
1434    if (f) {
1435       return f;
1436    }
1437
1438    f = (__GLXextFuncPtr) _glapi_get_proc_address((const char *) procName);
1439    return f;
1440 }
1441
1442
1443 /* GLX 1.4 */
1444 void (*glXGetProcAddress(const GLubyte *procName))()
1445 {
1446    return glXGetProcAddressARB(procName);
1447 }