Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  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.  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 = 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. }
  1419.