-/* $Id: glxapi.c,v 1.16 2000/04/10 21:13:19 brianp Exp $ */
+/* $Id: glxapi.c,v 1.22 2001/05/24 19:06:21 brianp Exp $ */
/*
* Mesa 3-D graphics library
- * Version: 3.3
+ * Version: 3.5
*
- * Copyright (C) 1999-2000 Brian Paul All Rights Reserved.
+ * Copyright (C) 1999-2001 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
#include <assert.h>
#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+/*#include <dlfcn.h>*/ /* XXX not portable? */
#include "glapi.h"
#include "glxapi.h"
/* Rather than include possibly non-existant headers... */
#ifdef USE_SGI_GLX
-extern struct _glxapi_table *_sgi_GetGLXDispatchtable(void);
+extern struct _glxapi_table *_sgi_GetGLXDispatchTable(void);
#endif
#ifdef USE_UTAH_GLX
extern struct _glxapi_table *_utah_GetGLXDispatchTable(void);
static struct display_dispatch *DispatchList = NULL;
+/* Display -> Dispatch caching */
+static Display *prevDisplay = NULL;
+static struct _glxapi_table *prevTable = NULL;
+
+
static struct _glxapi_table *
get_dispatch(Display *dpy)
{
- static Display *prevDisplay = NULL;
- static struct _glxapi_table *prevTable = NULL;
-
if (!dpy)
return NULL;
- /* try cached display */
- if (dpy == prevDisplay) {
- return prevTable;
- }
-
/* search list of display/dispatch pairs for this display */
{
const struct display_dispatch *d = DispatchList;
if (XQueryExtension( dpy, "GLX", &ignore, &ignore, &ignore )) {
/* the X server has the GLX extension */
#if defined(USE_SGI_GLX)
- t = _sgi_GetGLXDispatchtable();
+ t = _sgi_GetGLXDispatchTable();
#elif defined(USE_UTAH_GLX)
t = _utah_GetGLXDispatchTable();
#endif
}
+#define GET_DISPATCH(DPY, TABLE) \
+ if (DPY == prevDisplay) { \
+ TABLE = prevTable; \
+ } \
+ else if (!DPY) { \
+ TABLE = NULL; \
+ } \
+ else { \
+ TABLE = get_dispatch(DPY); \
+ }
+
+
+
/* Set by glXMakeCurrent() and glXMakeContextCurrent() only */
-static Display *CurrentDisplay = NULL;
+#ifndef GLX_BUILD_IN_XLIB_MESA
static GLXContext CurrentContext = 0;
-static GLXDrawable CurrentDrawable = 0;
-static GLXDrawable CurrentReadDrawable = 0;
-
+#define __glXGetCurrentContext() CurrentContext;
+#endif
/*
XVisualInfo *glXChooseVisual(Display *dpy, int screen, int *list)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return NULL;
return (t->ChooseVisual)(dpy, screen, list);
void glXCopyContext(Display *dpy, GLXContext src, GLXContext dst, unsigned long mask)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return;
(t->CopyContext)(dpy, src, dst, mask);
GLXContext glXCreateContext(Display *dpy, XVisualInfo *visinfo, GLXContext shareList, Bool direct)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return 0;
return (t->CreateContext)(dpy, visinfo, shareList, direct);
GLXPixmap glXCreateGLXPixmap(Display *dpy, XVisualInfo *visinfo, Pixmap pixmap)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return 0;
return (t->CreateGLXPixmap)(dpy, visinfo, pixmap);
void glXDestroyContext(Display *dpy, GLXContext ctx)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return;
(t->DestroyContext)(dpy, ctx);
void glXDestroyGLXPixmap(Display *dpy, GLXPixmap pixmap)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return;
(t->DestroyGLXPixmap)(dpy, pixmap);
int glXGetConfig(Display *dpy, XVisualInfo *visinfo, int attrib, int *value)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return GLX_NO_EXTENSION;
return (t->GetConfig)(dpy, visinfo, attrib, value);
}
+#ifdef GLX_BUILD_IN_XLIB_MESA
+/* Use real libGL's glXGetCurrentContext() function */
+#else
+/* stand-alone Mesa */
GLXContext glXGetCurrentContext(void)
{
return CurrentContext;
}
+#endif
GLXDrawable glXGetCurrentDrawable(void)
{
- return CurrentDrawable;
+ GLXContext gc = glXGetCurrentContext();
+ return gc ? gc->currentDrawable : 0;
}
Bool glXIsDirect(Display *dpy, GLXContext ctx)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return False;
return (t->IsDirect)(dpy, ctx);
Bool glXMakeCurrent(Display *dpy, GLXDrawable drawable, GLXContext ctx)
{
Bool b;
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return False;
b = (*t->MakeCurrent)(dpy, drawable, ctx);
+#ifndef GLX_BUILD_IN_XLIB_MESA
if (b) {
- CurrentDisplay = dpy;
CurrentContext = ctx;
- CurrentDrawable = drawable;
- CurrentReadDrawable = drawable;
}
+#endif
return b;
}
Bool glXQueryExtension(Display *dpy, int *errorb, int *event)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return False;
return (t->QueryExtension)(dpy, errorb, event);
Bool glXQueryVersion(Display *dpy, int *maj, int *min)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return False;
return (t->QueryVersion)(dpy, maj, min);
void glXSwapBuffers(Display *dpy, GLXDrawable drawable)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return;
(t->SwapBuffers)(dpy, drawable);
void glXUseXFont(Font font, int first, int count, int listBase)
{
- struct _glxapi_table *t = get_dispatch(CurrentDisplay);
+ struct _glxapi_table *t;
+ Display *dpy = glXGetCurrentDisplay();
+ GET_DISPATCH(dpy, t);
if (!t)
return;
(t->UseXFont)(font, first, count, listBase);
void glXWaitGL(void)
{
- struct _glxapi_table *t = get_dispatch(CurrentDisplay);
+ struct _glxapi_table *t;
+ Display *dpy = glXGetCurrentDisplay();
+ GET_DISPATCH(dpy, t);
if (!t)
return;
(t->WaitGL)();
void glXWaitX(void)
{
- struct _glxapi_table *t = get_dispatch(CurrentDisplay);
+ struct _glxapi_table *t;
+ Display *dpy = glXGetCurrentDisplay();
+ GET_DISPATCH(dpy, t);
if (!t)
return;
(t->WaitX)();
-#ifdef _GLXAPI_VERSION_1_1
+#ifdef GLX_VERSION_1_1
const char *glXGetClientString(Display *dpy, int name)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return NULL;
return (t->GetClientString)(dpy, name);
const char *glXQueryExtensionsString(Display *dpy, int screen)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return NULL;
return (t->QueryExtensionsString)(dpy, screen);
const char *glXQueryServerString(Display *dpy, int screen, int name)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return NULL;
return (t->QueryServerString)(dpy, screen, name);
-#ifdef _GLXAPI_VERSION_1_2
+#ifdef GLX_VERSION_1_2
Display *glXGetCurrentDisplay(void)
{
- return CurrentDisplay;
+ /* Same code as in libGL's glxext.c */
+ GLXContext gc = __glXGetCurrentContext();
+ if (NULL == gc) return NULL;
+ return gc->currentDpy;
}
#endif
-#ifdef _GLXAPI_VERSION_1_3
+#ifdef GLX_VERSION_1_3
GLXFBConfig *glXChooseFBConfig(Display *dpy, int screen, const int *attribList, int *nitems)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return 0;
return (t->ChooseFBConfig)(dpy, screen, attribList, nitems);
GLXContext glXCreateNewContext(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return 0;
return (t->CreateNewContext)(dpy, config, renderType, shareList, direct);
GLXPbuffer glXCreatePbuffer(Display *dpy, GLXFBConfig config, const int *attribList)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return 0;
return (t->CreatePbuffer)(dpy, config, attribList);
GLXPixmap glXCreatePixmap(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return 0;
return (t->CreatePixmap)(dpy, config, pixmap, attribList);
GLXWindow glXCreateWindow(Display *dpy, GLXFBConfig config, Window win, const int *attribList)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return 0;
return (t->CreateWindow)(dpy, config, win, attribList);
void glXDestroyPbuffer(Display *dpy, GLXPbuffer pbuf)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return;
(t->DestroyPbuffer)(dpy, pbuf);
void glXDestroyPixmap(Display *dpy, GLXPixmap pixmap)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return;
(t->DestroyPixmap)(dpy, pixmap);
void glXDestroyWindow(Display *dpy, GLXWindow window)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return;
(t->DestroyWindow)(dpy, window);
GLXDrawable glXGetCurrentReadDrawable(void)
{
- return CurrentReadDrawable;
+ GLXContext gc = glXGetCurrentContext();
+ return gc ? gc->currentReadable : 0;
}
int glXGetFBConfigAttrib(Display *dpy, GLXFBConfig config, int attribute, int *value)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return GLX_NO_EXTENSION;
return (t->GetFBConfigAttrib)(dpy, config, attribute, value);
GLXFBConfig *glXGetFBConfigs(Display *dpy, int screen, int *nelements)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return 0;
return (t->GetFBConfigs)(dpy, screen, nelements);
void glXGetSelectedEvent(Display *dpy, GLXDrawable drawable, unsigned long *mask)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return;
(t->GetSelectedEvent)(dpy, drawable, mask);
XVisualInfo *glXGetVisualFromFBConfig(Display *dpy, GLXFBConfig config)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return NULL;
return (t->GetVisualFromFBConfig)(dpy, config);
Bool glXMakeContextCurrent(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx)
{
- struct _glxapi_table *t = get_dispatch(dpy);
Bool b;
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return False;
b = (t->MakeContextCurrent)(dpy, draw, read, ctx);
+#ifndef GLX_BUILD_IN_XLIB_MESA
if (b) {
- CurrentDisplay = dpy;
CurrentContext = ctx;
- CurrentDrawable = draw;
- CurrentReadDrawable = read;
}
+#endif
return b;
}
int glXQueryContext(Display *dpy, GLXContext ctx, int attribute, int *value)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
assert(t);
if (!t)
return 0; /* XXX correct? */
void glXQueryDrawable(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return;
(t->QueryDrawable)(dpy, draw, attribute, value);
void glXSelectEvent(Display *dpy, GLXDrawable drawable, unsigned long mask)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return;
(t->SelectEvent)(dpy, drawable, mask);
}
-#endif /* _GLXAPI_VERSION_1_3 */
+#endif /* GLX_VERSION_1_3 */
-#ifdef _GLXAPI_EXT_import_context
+#ifdef GLX_SGI_swap_control
-void glXFreeContextEXT(Display *dpy, GLXContext context)
+int glXSwapIntervalSGI(int interval)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ Display *dpy = glXGetCurrentDisplay();
+ GET_DISPATCH(dpy, t);
if (!t)
- return;
- (t->FreeContextEXT)(dpy, context);
+ return 0;
+ return (t->SwapIntervalSGI)(interval);
}
+#endif
-GLXContextID glXGetContextIDEXT(const GLXContext context)
+
+#ifdef GLX_SGI_video_sync
+
+int glXGetVideoSyncSGI(unsigned int *count)
{
- /* XXX is this function right? */
- struct _glxapi_table *t = get_dispatch(CurrentDisplay);
+ struct _glxapi_table *t;
+ Display *dpy = glXGetCurrentDisplay();
+ GET_DISPATCH(dpy, t);
if (!t)
return 0;
- return (t->GetContextIDEXT)(context);
+ return (t->GetVideoSyncSGI)(count);
}
+int glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count)
+{
+ struct _glxapi_table *t;
+ Display *dpy = glXGetCurrentDisplay();
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return 0;
+ return (t->WaitVideoSyncSGI)(divisor, remainder, count);
+}
-Display *glXGetCurrentDisplayEXT(void)
+#endif
+
+
+#ifdef GLX_SGI_make_current_read
+
+Bool glXMakeCurrentReadSGI(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx)
{
- return CurrentDisplay;
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return 0;
+ return (t->MakeCurrentReadSGI)(dpy, draw, read, ctx);
}
+GLXDrawable glXGetCurrentReadDrawableSGI(void)
+{
+ return glXGetCurrentReadDrawable();
+}
+#endif
+
+
+#if defined(_VL_H) && defined(GLX_SGIX_video_source)
+
+GLXVideoSourceSGIX glXCreateGLXVideoSourceSGIX(Display *dpy, int screen, VLServer server, VLPath path, int nodeClass, VLNode drainNode)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return 0;
+ return (t->CreateGLXVideoSourceSGIX)(dpy, screen, server, path, nodeClass, drainNode);
+}
+
+void glXDestroyGLXVideoSourceSGIX(Display *dpy, GLXVideoSourceSGIX src)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return 0;
+ return (t->DestroyGLXVideoSourceSGIX)(dpy, src);
+}
+
+#endif
+
+
+#ifdef GLX_EXT_import_context
+
+void glXFreeContextEXT(Display *dpy, GLXContext context)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return;
+ (t->FreeContextEXT)(dpy, context);
+}
+
+#ifdef GLX_BUILD_IN_XLIB_MESA
+/* Use real libGL's glXGetContextIDEXT() function */
+#else
+/* stand-alone Mesa */
+GLXContextID glXGetContextIDEXT(const GLXContext context)
+{
+ return context->xid;
+}
+#endif
+
+Display *glXGetCurrentDisplayEXT(void)
+{
+ return glXGetCurrentDisplay();
+}
GLXContext glXImportContextEXT(Display *dpy, GLXContextID contextID)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return 0;
return (t->ImportContextEXT)(dpy, contextID);
int glXQueryContextInfoEXT(Display *dpy, GLXContext context, int attribute,int *value)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return 0; /* XXX ok? */
return (t->QueryContextInfoEXT)(dpy, context, attribute, value);
#endif
-#ifdef _GLXAPI_SGI_video_sync
+#ifdef GLX_SGIX_fbconfig
-int glXGetVideoSyncSGI(unsigned int *count)
+int glXGetFBConfigAttribSGIX(Display *dpy, GLXFBConfigSGIX config, int attribute, int *value)
{
- struct _glxapi_table *t = get_dispatch(CurrentDisplay);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return 0;
- return (t->GetVideoSyncSGI)(count);
+ return (t->GetFBConfigAttribSGIX)(dpy, config, attribute, value);
}
+GLXFBConfigSGIX *glXChooseFBConfigSGIX(Display *dpy, int screen, int *attrib_list, int *nelements)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return 0;
+ return (t->ChooseFBConfigSGIX)(dpy, screen, attrib_list, nelements);
+}
-int glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count)
+GLXPixmap glXCreateGLXPixmapWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, Pixmap pixmap)
{
- struct _glxapi_table *t = get_dispatch(CurrentDisplay);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return 0;
- return (t->WaitVideoSyncSGI)(divisor, remainder, count);
+ return (t->CreateGLXPixmapWithConfigSGIX)(dpy, config, pixmap);
+}
+
+GLXContext glXCreateContextWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return 0;
+ return (t->CreateContextWithConfigSGIX)(dpy, config, render_type, share_list, direct);
+}
+
+XVisualInfo * glXGetVisualFromFBConfigSGIX(Display *dpy, GLXFBConfigSGIX config)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return 0;
+ return (t->GetVisualFromFBConfigSGIX)(dpy, config);
+}
+
+GLXFBConfigSGIX glXGetFBConfigFromVisualSGIX(Display *dpy, XVisualInfo *vis)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return 0;
+ return (t->GetFBConfigFromVisualSGIX)(dpy, vis);
+}
+
+#endif
+
+
+#ifdef GLX_SGIX_pbuffer
+
+GLXPbufferSGIX glXCreateGLXPbufferSGIX(Display *dpy, GLXFBConfigSGIX config, unsigned int width, unsigned int height, int *attrib_list)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return 0;
+ return (t->CreateGLXPbufferSGIX)(dpy, config, width, height, attrib_list);
+}
+
+void glXDestroyGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return;
+ (t->DestroyGLXPbufferSGIX)(dpy, pbuf);
+}
+
+int glXQueryGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf, int attribute, unsigned int *value)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return 0;
+ return (t->QueryGLXPbufferSGIX)(dpy, pbuf, attribute, value);
+}
+
+void glXSelectEventSGIX(Display *dpy, GLXDrawable drawable, unsigned long mask)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return;
+ (t->SelectEventSGIX)(dpy, drawable, mask);
+}
+
+void glXGetSelectedEventSGIX(Display *dpy, GLXDrawable drawable, unsigned long *mask)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return;
+ (t->GetSelectedEventSGIX)(dpy, drawable, mask);
+}
+
+#endif
+
+
+#ifdef GLX_SGI_cushion
+
+void glXCushionSGI(Display *dpy, Window win, float cushion)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return;
+ (t->CushionSGI)(dpy, win, cushion);
}
#endif
-#ifdef _GLXAPI_MESA_copy_sub_buffer
+#ifdef GLX_SGIX_video_resize
+
+int glXBindChannelToWindowSGIX(Display *dpy, int screen, int channel , Window window)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return 0;
+ return (t->BindChannelToWindowSGIX)(dpy, screen, channel, window);
+}
+
+int glXChannelRectSGIX(Display *dpy, int screen, int channel, int x, int y, int w, int h)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return 0;
+ return (t->ChannelRectSGIX)(dpy, screen, channel, x, y, w, h);
+}
+
+int glXQueryChannelRectSGIX(Display *dpy, int screen, int channel, int *x, int *y, int *w, int *h)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return 0;
+ return (t->QueryChannelRectSGIX)(dpy, screen, channel, x, y, w, h);
+}
+
+int glXQueryChannelDeltasSGIX(Display *dpy, int screen, int channel, int *dx, int *dy, int *dw, int *dh)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return 0;
+ return (t->QueryChannelDeltasSGIX)(dpy, screen, channel, dx, dy, dw, dh);
+}
+
+int glXChannelRectSyncSGIX(Display *dpy, int screen, int channel, GLenum synctype)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return 0;
+ return (t->ChannelRectSyncSGIX)(dpy, screen, channel, synctype);
+}
+
+#endif
+
+
+#if defined(_DM_BUFFER_H_) && defined(GLX_SGIX_dmbuffer)
+
+Bool glXAssociateDMPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuffer, DMparams *params, DMbuffer dmbuffer)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return False;
+ return (t->AssociateDMPbufferSGIX)(dpy, pbuffer, params, dmbuffer);
+}
+
+#endif
+
+
+#ifdef GLX_SGIX_swap_group
+
+void glXJoinSwapGroupSGIX(Display *dpy, GLXDrawable drawable, GLXDrawable member)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return;
+ (*t->JoinSwapGroupSGIX)(dpy, drawable, member);
+}
+
+#endif
+
+
+#ifdef GLX_SGIX_swap_barrier
+
+void glXBindSwapBarrierSGIX(Display *dpy, GLXDrawable drawable, int barrier)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return;
+ (*t->BindSwapBarrierSGIX)(dpy, drawable, barrier);
+}
+
+Bool glXQueryMaxSwapBarriersSGIX(Display *dpy, int screen, int *max)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return False;
+ return (*t->QueryMaxSwapBarriersSGIX)(dpy, screen, max);
+}
+
+#endif
+
+
+#ifdef GLX_SUN_get_transparent_index
+
+Status glXGetTransparentIndexSUN(Display *dpy, Window overlay, Window underlay, long *pTransparent)
+{
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
+ if (!t)
+ return False;
+ return (*t->GetTransparentIndexSUN)(dpy, overlay, underlay, pTransparent);
+}
+
+#endif
+
+
+#ifdef GLX_MESA_copy_sub_buffer
void glXCopySubBufferMESA(Display *dpy, GLXDrawable drawable, int x, int y, int width, int height)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return;
(t->CopySubBufferMESA)(dpy, drawable, x, y, width, height);
#endif
-#ifdef _GLXAPI_MESA_release_buffers
+#ifdef GLX_MESA_release_buffers
Bool glXReleaseBuffersMESA(Display *dpy, Window w)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return False;
return (t->ReleaseBuffersMESA)(dpy, w);
#endif
-#ifdef _GLXAPI_MESA_pixmap_colormap
+#ifdef GLX_MESA_pixmap_colormap
GLXPixmap glXCreateGLXPixmapMESA(Display *dpy, XVisualInfo *visinfo, Pixmap pixmap, Colormap cmap)
{
- struct _glxapi_table *t = get_dispatch(dpy);
+ struct _glxapi_table *t;
+ GET_DISPATCH(dpy, t);
if (!t)
return 0;
return (t->CreateGLXPixmapMESA)(dpy, visinfo, pixmap, cmap);
#endif
-#ifdef _GLXAPI_MESA_set_3dfx_mode
+#ifdef GLX_MESA_set_3dfx_mode
-GLboolean glXSet3DfxModeMESA(GLint mode)
+Bool glXSet3DfxModeMESA(int mode)
{
- struct _glxapi_table *t = get_dispatch(CurrentDisplay);
+ struct _glxapi_table *t;
+ Display *dpy = glXGetCurrentDisplay();
+ GET_DISPATCH(dpy, t);
if (!t)
return False;
return (t->Set3DfxModeMESA)(mode);
_glxapi_get_extensions(void)
{
static const char *extensions[] = {
-#ifdef _GLXAPI_EXT_import_context
+#ifdef GLX_EXT_import_context
"GLX_EXT_import_context",
#endif
-#ifdef _GLXAPI_SGI_video_sync
+#ifdef GLX_SGI_video_sync
"GLX_SGI_video_sync",
#endif
-#ifdef _GLXAPI_MESA_copy_sub_buffer
+#ifdef GLX_MESA_copy_sub_buffer
"GLX_MESA_copy_sub_buffer",
#endif
-#ifdef _GLXAPI_MESA_release_buffers
+#ifdef GLX_MESA_release_buffers
"GLX_MESA_release_buffers",
#endif
-#ifdef _GLXAPI_MESA_pixmap_colormap
+#ifdef GLX_MESA_pixmap_colormap
"GLX_MESA_pixmap_colormap",
#endif
-#ifdef _GLXAPI_MESA_set_3dfx_mode
+#ifdef GLX_MESA_set_3dfx_mode
"GLX_MESA_set_3dfx_mode",
#endif
NULL
}
+#if 00
+/*
+ * Open the named library and use dlsym() to populate the given dispatch
+ * table with GLX function pointers.
+ * Return: true = all OK
+ * false = can't open libName or can't get required GLX function
+ */
+GLboolean
+_glxapi_load_library_table(const char *libName, struct _glxapi_table *t)
+{
+ void *libHandle;
+ void **entry; /* used to avoid a lot of cast/type warnings */
+
+ libHandle = dlopen(libName, 0);
+ if (!libHandle) {
+ return GL_FALSE;
+ }
+
+#define GET_REQ_FUNCTION(ENTRY, NAME) \
+ entry = (void **) &(t->ENTRY); \
+ *entry = dlsym(libHandle, NAME); \
+ if (!*entry) { \
+ fprintf(stderr, "libGL Error: couldn't load %s from %s\n", \
+ NAME, libName); \
+ dlclose(libHandle); \
+ return GL_FALSE; \
+ }
+
+ /* 1.0 and 1.1 functions */
+ GET_REQ_FUNCTION(ChooseVisual, "glXChooseVisual");
+ GET_REQ_FUNCTION(CopyContext, "glXCopyContext");
+ GET_REQ_FUNCTION(CreateContext, "glXCreateContext");
+ GET_REQ_FUNCTION(CreateGLXPixmap, "glXCreateGLXPixmap");
+ GET_REQ_FUNCTION(DestroyContext, "glXDestroyContext");
+ GET_REQ_FUNCTION(GetConfig, "glXGetConfig");
+ GET_REQ_FUNCTION(IsDirect, "glXIsDirect");
+ GET_REQ_FUNCTION(MakeCurrent, "glXMakeCurrent");
+ GET_REQ_FUNCTION(QueryExtension, "glXQueryExtension");
+ GET_REQ_FUNCTION(QueryVersion, "glXQueryVersion");
+ GET_REQ_FUNCTION(SwapBuffers, "glXSwapBuffers");
+ GET_REQ_FUNCTION(UseXFont, "glXUseXFont");
+ GET_REQ_FUNCTION(WaitGL, "glXWaitGL");
+ GET_REQ_FUNCTION(WaitX, "glXWaitX");
+ GET_REQ_FUNCTION(GetClientString, "glXGetClientString");
+ GET_REQ_FUNCTION(QueryExtensionsString, "glXQueryExtensionsString");
+ GET_REQ_FUNCTION(QueryServerString, "glXQueryServerString");
+
+#define GET_OPT_FUNCTION(ENTRY, NAME) \
+ entry = (void **) &(t->ENTRY); \
+ *entry = dlsym(libHandle, NAME); \
+ if (!*entry) { \
+ *entry = (void *) generic_no_op_func; \
+ }
+
+ /* 1.2, 1.3 and extensions */
+ GET_OPT_FUNCTION(ChooseFBConfig, "glXChooseFBConfig");
+ GET_OPT_FUNCTION(CreateNewContext, "glXCreateNewContext");
+ GET_OPT_FUNCTION(CreatePbuffer, "glXCreatePbuffer");
+ GET_OPT_FUNCTION(CreatePixmap, "glXCreatePixmap");
+ GET_OPT_FUNCTION(CreateWindow, "glXCreateWindow");
+ GET_OPT_FUNCTION(DestroyPbuffer, "glXDestroyPbuffer");
+ GET_OPT_FUNCTION(DestroyPixmap, "glXDestroyPixmap");
+ GET_OPT_FUNCTION(DestroyWindow, "glXDestroyWindow");
+ GET_OPT_FUNCTION(GetFBConfigAttrib, "glXGetFBConfigAttrib");
+ GET_OPT_FUNCTION(GetFBConfigs, "glXGetFBConfigs");
+ GET_OPT_FUNCTION(GetSelectedEvent, "glXGetSelectedEvent");
+ GET_OPT_FUNCTION(GetVisualFromFBConfig, "glXGetVisualFromFBConfig");
+ GET_OPT_FUNCTION(MakeContextCurrent, "glXMakeContextCurrent");
+ GET_OPT_FUNCTION(QueryContext, "glXQueryContext");
+ GET_OPT_FUNCTION(QueryDrawable, "glXQueryDrawable");
+ GET_OPT_FUNCTION(SelectEvent, "glXSelectEvent");
+#ifdef GLX_SGI_swap_control
+ GET_OPT_FUNCTION(SwapIntervalSGI, "glXSwapIntervalSGI");
+#endif
+#ifdef GLX_SGI_video_sync
+ GET_OPT_FUNCTION(GetVideoSyncSGI, "glXGetVideoSyncSGI");
+ GET_OPT_FUNCTION(WaitVideoSyncSGI, "glXWaitVideoSyncSGI");
+#endif
+#ifdef GLX_SGI_make_current_read
+ GET_OPT_FUNCTION(MakeCurrentReadSGI, "glXMakeCurrentReadSGI");
+ GET_OPT_FUNCTION(GetCurrentReadDrawableSGI, "glXGetCurrentReadDrawableSGI");
+#endif
+#if defined(_VL_H) && defined(GLX_SGIX_video_source)
+ GET_OPT_FUNCTION(CreateGLXVideoSourceSGIX, "glXCreateGLXVideoSourceSGIX");
+ GET_OPT_FUNCTION(DestroyGLXVideoSourceSGIX, "glXDestroyGLXVideoSourceSGIX");
+#endif
+#ifdef GLX_EXT_import_context
+ GET_OPT_FUNCTION(FreeContextEXT, "glXFreeContextEXT");
+ GET_OPT_FUNCTION(GetContextIDEXT, "glXGetContextIDEXT");
+ GET_OPT_FUNCTION(GetCurrentDisplayEXT, "glXGetCurrentDisplayEXT");
+ GET_OPT_FUNCTION(ImportContextEXT, "glXImportContextEXT");
+ GET_OPT_FUNCTION(QueryContextInfoEXT, "glXQueryContextInfoEXT");
+#endif
+#ifdef GLX_SGIX_fbconfig
+ GET_OPT_FUNCTION(GetFBConfigAttribSGIX, "glXGetFBConfigAttribSGIX");
+ GET_OPT_FUNCTION(ChooseFBConfigSGIX, "glXChooseFBConfigSGIX");
+ GET_OPT_FUNCTION(CreateGLXPixmapWithConfigSGIX, "glXCreateGLXPixmapWithConfigSGIX");
+ GET_OPT_FUNCTION(CreateContextWithConfigSGIX, "glXCreateContextWithConfigSGIX");
+ GET_OPT_FUNCTION(GetVisualFromFBConfigSGIX, "glXGetVisualFromFBConfigSGIX");
+ GET_OPT_FUNCTION(GetFBConfigFromVisualSGIX, "glXGetFBConfigFromVisualSGIX");
+#endif
+#ifdef GLX_SGIX_pbuffer
+ GET_OPT_FUNCTION(CreateGLXPbufferSGIX, "glXCreateGLXPbufferSGIX");
+ GET_OPT_FUNCTION(DestroyGLXPbufferSGIX, "glXDestroyGLXPbufferSGIX");
+ GET_OPT_FUNCTION(QueryGLXPbufferSGIX, "glXQueryGLXPbufferSGIX");
+ GET_OPT_FUNCTION(SelectEventSGIX, "glXSelectEventSGIX");
+ GET_OPT_FUNCTION(GetSelectedEventSGIX, "glXGetSelectedEventSGIX");
+#endif
+#ifdef GLX_SGI_cushion
+ GET_OPT_FUNCTION(CushionSGI, "glXCushionSGI");
+#endif
+#ifdef GLX_SGIX_video_resize
+ GET_OPT_FUNCTION(BindChannelToWindowSGIX, "glXBindChannelToWindowSGIX");
+ GET_OPT_FUNCTION(ChannelRectSGIX, "glXChannelRectSGIX");
+ GET_OPT_FUNCTION(QueryChannelRectSGIX, "glXQueryChannelRectSGIX");
+ GET_OPT_FUNCTION(QueryChannelDeltasSGIX, "glXQueryChannelDeltasSGIX");
+ GET_OPT_FUNCTION(ChannelRectSyncSGIX, "glXChannelRectSyncSGIX");
+#endif
+#if defined (_DM_BUFFER_H_) && defined(GLX_SGIX_dmbuffer)
+ GET_OPT_FUNCTION(AssociateDMPbufferSGIX, "glXAssociateDMPbufferSGIX");
+#endif
+#ifdef GLX_SGIX_swap_group
+ GET_OPT_FUNCTION(JoinSwapGroupSGIX, "glXJoinSwapGroupSGIX");
+#endif
+#ifdef GLX_SGIX_swap_barrier
+ GET_OPT_FUNCTION(BindSwapBarrierSGIX, "glXBindSwapBarrierSGIX");
+ GET_OPT_FUNCTION(QueryMaxSwapBarriersSGIX, "glXQueryMaxSwapBarriersSGIX");
+#endif
+#ifdef GLX_SUN_get_transparent_index
+ GET_OPT_FUNCTION(GetTransparentIndexSUN, "glXGetTransparentIndexSUN");
+#endif
+#ifdef GLX_MESA_copy_sub_buffer
+ GET_OPT_FUNCTION(CopySubBufferMESA, "glXCopySubBufferMESA");
+#endif
+#ifdef GLX_MESA_release_buffers
+ GET_OPT_FUNCTION(ReleaseBuffersMESA, "glXReleaseBuffersMESA");
+#endif
+#ifdef GLX_MESA_pixmap_colormap
+ GET_OPT_FUNCTION(CreateGLXPixmapMESA, "glXCreateGLXPixmapMESA");
+#endif
+#ifdef GLX_MESA_set_3dfx_mode
+ GET_OPT_FUNCTION(Set3DfxModeMESA, "glXSet3DfxModeMESA");
+#endif
+
+ return GL_TRUE;
+}
+#endif
+
+
struct name_address_pair {
const char *Name;
{ "glXWaitGL", (GLvoid *) glXWaitGL },
{ "glXWaitX", (GLvoid *) glXWaitX },
-#ifdef _GLXAPI_VERSION_1_1
+#ifdef GLX_VERSION_1_1
{ "glXGetClientString", (GLvoid *) glXGetClientString },
{ "glXQueryExtensionsString", (GLvoid *) glXQueryExtensionsString },
{ "glXQueryServerString", (GLvoid *) glXQueryServerString },
#endif
-#ifdef _GLXAPI_VERSION_1_2
+#ifdef GLX_VERSION_1_2
{ "glXGetCurrentDisplay", (GLvoid *) glXGetCurrentDisplay },
#endif
-#ifdef _GLXAPI_VERSION_1_3
+#ifdef GLX_VERSION_1_3
{ "glXChooseFBConfig", (GLvoid *) glXChooseFBConfig },
{ "glXCreateNewContext", (GLvoid *) glXCreateNewContext },
{ "glXCreatePbuffer", (GLvoid *) glXCreatePbuffer },
{ "glXSelectEvent", (GLvoid *) glXSelectEvent },
#endif
-#ifdef _GLXAPI_SGI_video_sync
+#ifdef GLX_SGI_video_sync
{ "glXGetVideoSyncSGI", (GLvoid *) glXGetVideoSyncSGI },
{ "glXWaitVideoSyncSGI", (GLvoid *) glXWaitVideoSyncSGI },
#endif
-#ifdef _GLXAPI_MESA_copy_sub_buffer
+#ifdef GLX_MESA_copy_sub_buffer
{ "glXCopySubBufferMESA", (GLvoid *) glXCopySubBufferMESA },
#endif
-#ifdef _GLXAPI_MESA_release_buffers
+#ifdef GLX_MESA_release_buffers
{ "glXReleaseBuffersMESA", (GLvoid *) glXReleaseBuffersMESA },
#endif
-#ifdef _GLXAPI_MESA_pixmap_colormap
+#ifdef GLX_MESA_pixmap_colormap
{ "glXCreateGLXPixmapMESA", (GLvoid *) glXCreateGLXPixmapMESA },
#endif
-#ifdef _GLXAPI_MESA_set_3dfx_mode
+#ifdef GLX_MESA_set_3dfx_mode
{ "glXSet3DfxModeMESA", (GLvoid *) glXSet3DfxModeMESA },
#endif
projects / mesa.git / blobdiff