src/mesa/drivers/x11/glxapi.c

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