• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Mesa 3-D graphics library
3  * Version:  7.1
4  *
5  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
6  *
7  * Permission is hereby granted, free of charge, to any person obtaining a
8  * copy of this software and associated documentation files (the "Software"),
9  * to deal in the Software without restriction, including without limitation
10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11  * and/or sell copies of the Software, and to permit persons to whom the
12  * Software is furnished to do so, subject to the following conditions:
13  *
14  * The above copyright notice and this permission notice shall be included
15  * in all copies or substantial portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23  */
24 
25 
26 /*
27  * This is the GLX API dispatcher.  Calls to the glX* functions are
28  * either routed to the real GLX encoders or to Mesa's pseudo-GLX functions.
29  * See the glxapi.h file for more details.
30  */
31 
32 
33 #include <assert.h>
34 #include <stdlib.h>
35 #include <stdio.h>
36 #include <string.h>
37 #include "main/glheader.h"
38 #include "main/compiler.h"
39 #include "glapi/glapi.h"
40 #include "glxapi.h"
41 
42 
43 extern struct _glxapi_table *_real_GetGLXDispatchTable(void);
44 extern struct _glxapi_table *_mesa_GetGLXDispatchTable(void);
45 
46 
47 struct display_dispatch {
48    Display *Dpy;
49    struct _glxapi_table *Table;
50    struct display_dispatch *Next;
51 };
52 
53 
54 /**
55  * When GLX_INDIRECT_RENDERING is defined, some symbols are missing in
56  * libglapi.a.  We need to define them here.
57  */
58 #ifdef GLX_INDIRECT_RENDERING
59 
60 #include "glapi/glapitable.h"
61 
62 #define KEYWORD1 PUBLIC
63 
64 #if defined(USE_MGL_NAMESPACE)
65 #define NAME(func)  mgl##func
66 #else
67 #define NAME(func)  gl##func
68 #endif
69 
70 #define DISPATCH(FUNC, ARGS, MESSAGE)		\
71    GET_DISPATCH()->FUNC ARGS
72 
73 #define RETURN_DISPATCH(FUNC, ARGS, MESSAGE) 	\
74    return GET_DISPATCH()->FUNC ARGS
75 
76 /* skip normal ones */
77 #define _GLAPI_SKIP_NORMAL_ENTRY_POINTS
78 #include "glapi/glapitemp.h"
79 
80 #endif /* GLX_INDIRECT_RENDERING */
81 
82 
83 static struct display_dispatch *DispatchList = NULL;
84 
85 
86 /* Display -> Dispatch caching */
87 static Display *prevDisplay = NULL;
88 static struct _glxapi_table *prevTable = NULL;
89 
90 
91 static struct _glxapi_table *
get_dispatch(Display * dpy)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
SetCurrentContext(GLXContext c)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 *
glXChooseVisual(Display * dpy,int screen,int * list)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
glXCopyContext(Display * dpy,GLXContext src,GLXContext dst,unsigned long mask)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
glXCreateContext(Display * dpy,XVisualInfo * visinfo,GLXContext shareList,Bool direct)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
glXCreateGLXPixmap(Display * dpy,XVisualInfo * visinfo,Pixmap pixmap)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
glXDestroyContext(Display * dpy,GLXContext ctx)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
glXDestroyGLXPixmap(Display * dpy,GLXPixmap pixmap)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
glXGetConfig(Display * dpy,XVisualInfo * visinfo,int attrib,int * value)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
glXGetCurrentContext(void)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
glXGetCurrentDrawable(void)283 glXGetCurrentDrawable(void)
284 {
285    __GLXcontext *gc = (__GLXcontext *) glXGetCurrentContext();
286    return gc ? gc->currentDrawable : 0;
287 }
288 
289 
290 Bool PUBLIC
glXIsDirect(Display * dpy,GLXContext ctx)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
glXMakeCurrent(Display * dpy,GLXDrawable drawable,GLXContext ctx)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
glXQueryExtension(Display * dpy,int * errorb,int * event)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
glXQueryVersion(Display * dpy,int * maj,int * min)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
glXSwapBuffers(Display * dpy,GLXDrawable drawable)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
glXUseXFont(Font font,int first,int count,int listBase)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
glXWaitGL(void)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
glXWaitX(void)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 *
glXGetClientString(Display * dpy,int name)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 *
glXQueryExtensionsString(Display * dpy,int screen)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 *
glXQueryServerString(Display * dpy,int screen,int name)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 *
glXGetCurrentDisplay(void)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 *
glXChooseFBConfig(Display * dpy,int screen,const int * attribList,int * nitems)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
glXCreateNewContext(Display * dpy,GLXFBConfig config,int renderType,GLXContext shareList,Bool direct)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
glXCreatePbuffer(Display * dpy,GLXFBConfig config,const int * attribList)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
glXCreatePixmap(Display * dpy,GLXFBConfig config,Pixmap pixmap,const int * attribList)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
glXCreateWindow(Display * dpy,GLXFBConfig config,Window win,const int * attribList)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
glXDestroyPbuffer(Display * dpy,GLXPbuffer pbuf)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
glXDestroyPixmap(Display * dpy,GLXPixmap pixmap)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
glXDestroyWindow(Display * dpy,GLXWindow window)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
glXGetCurrentReadDrawable(void)527 glXGetCurrentReadDrawable(void)
528 {
529    __GLXcontext *gc = (__GLXcontext *) glXGetCurrentContext();
530    return gc ? gc->currentReadable : 0;
531 }
532 
533 
534 int PUBLIC
glXGetFBConfigAttrib(Display * dpy,GLXFBConfig config,int attribute,int * value)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 *
glXGetFBConfigs(Display * dpy,int screen,int * nelements)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
glXGetSelectedEvent(Display * dpy,GLXDrawable drawable,unsigned long * mask)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 *
glXGetVisualFromFBConfig(Display * dpy,GLXFBConfig config)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
glXMakeContextCurrent(Display * dpy,GLXDrawable draw,GLXDrawable read,GLXContext ctx)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
glXQueryContext(Display * dpy,GLXContext ctx,int attribute,int * value)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
glXQueryDrawable(Display * dpy,GLXDrawable draw,int attribute,unsigned int * value)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
glXSelectEvent(Display * dpy,GLXDrawable drawable,unsigned long mask)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
glXSwapIntervalSGI(int interval)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
glXGetVideoSyncSGI(unsigned int * count)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
glXWaitVideoSyncSGI(int divisor,int remainder,unsigned int * count)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
glXMakeCurrentReadSGI(Display * dpy,GLXDrawable draw,GLXDrawable read,GLXContext ctx)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
glXGetCurrentReadDrawableSGI(void)682 glXGetCurrentReadDrawableSGI(void)
683 {
684    return glXGetCurrentReadDrawable();
685 }
686 
687 
688 #if defined(_VL_H)
689 
690 GLXVideoSourceSGIX PUBLIC
glXCreateGLXVideoSourceSGIX(Display * dpy,int screen,VLServer server,VLPath path,int nodeClass,VLNode drainNode)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
glXDestroyGLXVideoSourceSGIX(Display * dpy,GLXVideoSourceSGIX src)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
glXFreeContextEXT(Display * dpy,GLXContext context)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
glXGetContextIDEXT(const GLXContext context)726 glXGetContextIDEXT(const GLXContext context)
727 {
728    return ((__GLXcontext *) context)->xid;
729 }
730 
731 Display PUBLIC *
glXGetCurrentDisplayEXT(void)732 glXGetCurrentDisplayEXT(void)
733 {
734    return glXGetCurrentDisplay();
735 }
736 
737 GLXContext PUBLIC
glXImportContextEXT(Display * dpy,GLXContextID contextID)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
glXQueryContextInfoEXT(Display * dpy,GLXContext context,int attribute,int * value)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
glXGetFBConfigAttribSGIX(Display * dpy,GLXFBConfigSGIX config,int attribute,int * value)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 *
glXChooseFBConfigSGIX(Display * dpy,int screen,int * attrib_list,int * nelements)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
glXCreateGLXPixmapWithConfigSGIX(Display * dpy,GLXFBConfigSGIX config,Pixmap pixmap)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
glXCreateContextWithConfigSGIX(Display * dpy,GLXFBConfigSGIX config,int render_type,GLXContext share_list,Bool direct)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 *
glXGetVisualFromFBConfigSGIX(Display * dpy,GLXFBConfigSGIX config)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
glXGetFBConfigFromVisualSGIX(Display * dpy,XVisualInfo * vis)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
glXCreateGLXPbufferSGIX(Display * dpy,GLXFBConfigSGIX config,unsigned int width,unsigned int height,int * attrib_list)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
glXDestroyGLXPbufferSGIX(Display * dpy,GLXPbufferSGIX pbuf)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
glXQueryGLXPbufferSGIX(Display * dpy,GLXPbufferSGIX pbuf,int attribute,unsigned int * value)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
glXSelectEventSGIX(Display * dpy,GLXDrawable drawable,unsigned long mask)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
glXGetSelectedEventSGIX(Display * dpy,GLXDrawable drawable,unsigned long * mask)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
glXCushionSGI(Display * dpy,Window win,float cushion)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
glXBindChannelToWindowSGIX(Display * dpy,int screen,int channel,Window window)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
glXChannelRectSGIX(Display * dpy,int screen,int channel,int x,int y,int w,int h)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
glXQueryChannelRectSGIX(Display * dpy,int screen,int channel,int * x,int * y,int * w,int * h)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
glXQueryChannelDeltasSGIX(Display * dpy,int screen,int channel,int * dx,int * dy,int * dw,int * dh)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
glXChannelRectSyncSGIX(Display * dpy,int screen,int channel,GLenum synctype)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
glXAssociateDMPbufferSGIX(Display * dpy,GLXPbufferSGIX pbuffer,DMparams * params,DMbuffer dmbuffer)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
glXJoinSwapGroupSGIX(Display * dpy,GLXDrawable drawable,GLXDrawable member)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
glXBindSwapBarrierSGIX(Display * dpy,GLXDrawable drawable,int barrier)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
glXQueryMaxSwapBarriersSGIX(Display * dpy,int screen,int * max)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
glXGetTransparentIndexSUN(Display * dpy,Window overlay,Window underlay,long * pTransparent)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
glXCopySubBufferMESA(Display * dpy,GLXDrawable drawable,int x,int y,int width,int height)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
glXReleaseBuffersMESA(Display * dpy,Window w)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
glXCreateGLXPixmapMESA(Display * dpy,XVisualInfo * visinfo,Pixmap pixmap,Colormap cmap)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
glXSet3DfxModeMESA(int mode)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 *
glXAllocateMemoryNV(GLsizei size,GLfloat readFrequency,GLfloat writeFrequency,GLfloat priority)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
glXFreeMemoryNV(GLvoid * pointer)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
glXGetAGPOffsetMESA(const GLvoid * pointer)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
glXBindTexImageEXT(Display * dpy,GLXDrawable drawable,int buffer,const int * attrib_list)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
glXReleaseTexImageEXT(Display * dpy,GLXDrawable drawable,int buffer)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 *
_glxapi_get_version(void)1141 _glxapi_get_version(void)
1142 {
1143    return "1.3";
1144 }
1145 
1146 
1147 /*
1148  * Return array of extension strings.
1149  */
1150 const char **
_glxapi_get_extensions(void)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
_glxapi_get_dispatch_table_size(void)1194 _glxapi_get_dispatch_table_size(void)
1195 {
1196    return sizeof(struct _glxapi_table) / sizeof(void *);
1197 }
1198 
1199 
1200 static int
generic_no_op_func(void)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
_glxapi_set_no_op_table(struct _glxapi_table * t)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
_glxapi_get_proc_address(const char * funcName)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
glXGetProcAddressARB(const GLubyte * procName)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
glXGetProcAddress(const GLubyte * procName)1415 (*glXGetProcAddress(const GLubyte *procName))()
1416 {
1417    return glXGetProcAddressARB(procName);
1418 }
1419