From 9fb911fe062fd4b75cb99b32144750da76746b7c Mon Sep 17 00:00:00 2001 From: David Reveman Date: Wed, 8 Mar 2006 18:32:32 +0000 Subject: [PATCH] Update to new GLX interface --- ChangeLog | 43 + GL/glx/Makefile.am | 37 +- GL/glx/g_disptab.h | 6 + GL/glx/global.c | 1 + GL/glx/glxcmds.c | 383 ++++---- GL/glx/glxcmdsswap.c | 58 +- GL/glx/glxcontext.h | 50 +- GL/glx/glxdrawable.h | 43 +- GL/glx/glxdri.c | 937 ++++++++++++++++++ GL/glx/glxext.c | 213 ++-- GL/glx/glximports.c | 4 + GL/glx/glxscreens.c | 194 ++-- GL/glx/glxscreens.h | 47 +- GL/glx/glxserver.h | 39 +- GL/glx/glxutil.c | 333 +------ GL/glx/glxutil.h | 27 +- GL/glx/glxvisuals.c | 529 ++++++++++ GL/glx/indirect_util.c | 2 + GL/glx/render2swap.c | 14 + GL/glx/single2.c | 4 + GL/include/GL/glx_ansic.h | 3 - GL/include/GL/xf86glx.h | 4 - GL/mesa/Makefile.am | 8 +- GL/mesa/X/Makefile.am | 4 +- GL/mesa/X/xf86glx.c | 1124 +++++----------------- GL/mesa/X/xf86glx_util.c | 2 + GL/mesa/X/xf86glxint.h | 67 -- GL/mesa/array_cache/Makefile.am | 2 +- GL/mesa/glapi/Makefile.am | 2 +- GL/mesa/main/Makefile.am | 4 +- GL/mesa/math/Makefile.am | 2 +- GL/mesa/shader/Makefile.am | 4 +- GL/mesa/shader/grammar/Makefile.am | 2 +- GL/mesa/shader/slang/Makefile.am | 10 +- GL/mesa/swrast/Makefile.am | 8 +- GL/mesa/swrast_setup/Makefile.am | 2 +- GL/mesa/tnl/Makefile.am | 2 +- GL/symlink-mesa.sh | 2 +- hw/xgl/glxext/module/Makefile.am | 12 +- hw/xgl/glxext/module/glcoremodule.c | 38 - hw/xgl/glxext/xglglxext.c | 1387 ++++++++++++--------------- hw/xgl/xglglx.c | 153 +-- hw/xgl/xglglx.h | 16 +- 43 files changed, 3074 insertions(+), 2748 deletions(-) create mode 100644 GL/glx/glxdri.c create mode 100644 GL/glx/glxvisuals.c delete mode 100644 hw/xgl/glxext/module/glcoremodule.c diff --git a/ChangeLog b/ChangeLog index ea8fe1cd0..f59034184 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,46 @@ +2006-03-08 David Reveman + + * GL/symlink-mesa.sh: + * GL/glx/Makefile.am: + * GL/glx/g_disptab.h: + * GL/glx/global.c: + * GL/glx/glxcmds.c: + * GL/glx/glxcmdsswap.c: + * GL/glx/glxcontext.h: + * GL/glx/glxdrawable.h: + * GL/glx/glxext.c: + * GL/glx/glximports.c: + * GL/glx/glxscreens.c: + * GL/glx/glxscreens.h: + * GL/glx/glxserver.h: + * GL/glx/glxutil.c: + * GL/glx/glxutil.h: + * GL/glx/indirect_util.c: + * GL/glx/render2swap.c: + * GL/glx/single2.c: + * GL/include/GL/glx_ansic.h: + * GL/include/GL/xf86glx.h: + * GL/mesa/Makefile.am: + * GL/mesa/X/Makefile.am: + * GL/mesa/X/xf86glx.c: + * GL/mesa/X/xf86glx_util.c: + * GL/mesa/X/xf86glxint.h: + * GL/mesa/array_cache/Makefile.am: + * GL/mesa/glapi/Makefile.am: + * GL/mesa/main/Makefile.am: + * GL/mesa/math/Makefile.am: + * GL/mesa/shader/Makefile.am: + * GL/mesa/shader/grammar/Makefile.am: + * GL/mesa/shader/slang/Makefile.am: + * GL/mesa/swrast/Makefile.am: + * GL/mesa/swrast_setup/Makefile.am: + * GL/mesa/tnl/Makefile.am: + * hw/xgl/xglglx.c: + * hw/xgl/xglglx.h: + * hw/xgl/glxext/xglglxext.c: + * hw/xgl/glxext/module/Makefile.am: + Update to new GLX interface. + 2006-03-06 David Reveman * GL/symlink-mesa.sh: Add s_blit.c. diff --git a/GL/glx/Makefile.am b/GL/glx/Makefile.am index cf8b055af..cd21b7df8 100644 --- a/GL/glx/Makefile.am +++ b/GL/glx/Makefile.am @@ -1,23 +1,41 @@ -noinst_LTLIBRARIES = libglx.la +if DRI +GLXDRI_LIBRARY=libglxdri.la +endif + +noinst_LTLIBRARIES = libglx.la $(GLXDRI_LIBRARY) AM_CFLAGS = \ + -I@MESA_SOURCE@/include \ @DIX_CFLAGS@ \ @GL_CFLAGS@ \ @XLIB_CFLAGS@ \ - -I@MESA_SOURCE@/include \ + @LIBDRM_CFLAGS@ \ + @DRIPROTO_CFLAGS@ \ -I@MESA_SOURCE@/src/mesa/glapi \ -I@MESA_SOURCE@/src/mesa/main \ @SERVER_DEFINES@ \ @MODULE_DEFINES@ \ - @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE + @LOADER_DEFINES@ \ + -DNO_LIBCWRAPPER \ + -DUSE_MGL_NAMESPACE # none yet #sdk_HEADERS = -INCLUDES = -I$(top_srcdir)/GL/include -I$(top_srcdir)/hw/xfree86/os-support +INCLUDES = \ + -I$(top_srcdir)/GL/include \ + -I$(top_srcdir)/hw/xfree86/os-support \ + -I$(top_srcdir)/hw/xfree86/os-support/bus \ + -I$(top_srcdir)/hw/xfree86/common \ + -I$(top_srcdir)/hw/xfree86/dri \ + -I$(top_srcdir)/mi + nodist_libglx_la_SOURCES = indirect_size.h +libglxdri_la_SOURCES = \ + glxdri.c + libglx_la_SOURCES = \ g_disptab.c \ g_disptab.h \ @@ -28,8 +46,6 @@ libglx_la_SOURCES = \ glcontextmodes.h \ global.c \ glthread.c \ - glxbuf.c \ - glxbuf.h \ glxcmds.c \ glxcmdsswap.c \ glxcontext.h \ @@ -37,14 +53,7 @@ libglx_la_SOURCES = \ glxerror.h \ glxext.c \ glxext.h \ - glxfb.c \ - glxfb.h \ - glximports.c \ - glximports.h \ - glxmem.c \ - glxmem.h \ - glxpix.c \ - glxpix.h \ + glxvisuals.c \ glxscreens.c \ glxscreens.h \ glxserver.h \ diff --git a/GL/glx/g_disptab.h b/GL/glx/g_disptab.h index 222c5164e..9ae901c1d 100644 --- a/GL/glx/g_disptab.h +++ b/GL/glx/g_disptab.h @@ -46,6 +46,9 @@ extern int __glXWaitGL(__GLXclientState*, GLbyte*); extern int __glXWaitX(__GLXclientState*, GLbyte*); extern int __glXCopyContext(__GLXclientState*, GLbyte*); extern int __glXSwapBuffers(__GLXclientState*, GLbyte*); +extern int __glXBindTexImageEXT(__GLXclientState *cl, GLbyte *pc); +extern int __glXReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc); +extern int __glXGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc); extern int __glXUseXFont(__GLXclientState*, GLbyte*); extern int __glXCreateGLXPixmap(__GLXclientState*, GLbyte*); extern int __glXGetVisualConfigs(__GLXclientState*, GLbyte*); @@ -71,6 +74,9 @@ extern int __glXSwapWaitGL(__GLXclientState*, GLbyte*); extern int __glXSwapWaitX(__GLXclientState*, GLbyte*); extern int __glXSwapCopyContext(__GLXclientState*, GLbyte*); extern int __glXSwapSwapBuffers(__GLXclientState*, GLbyte*); +extern int __glXSwapBindTexImageEXT(__GLXclientState *cl, GLbyte *pc); +extern int __glXSwapReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc); +extern int __glXSwapGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc); extern int __glXSwapUseXFont(__GLXclientState*, GLbyte*); extern int __glXSwapCreateGLXPixmap(__GLXclientState*, GLbyte*); extern int __glXSwapGetVisualConfigs(__GLXclientState*, GLbyte*); diff --git a/GL/glx/global.c b/GL/glx/global.c index 18cd5edc2..28030ec03 100644 --- a/GL/glx/global.c +++ b/GL/glx/global.c @@ -53,6 +53,7 @@ __GLXcontext *__glXLastContext; RESTYPE __glXContextRes; RESTYPE __glXClientRes; RESTYPE __glXPixmapRes; +RESTYPE __glXDrawableRes; RESTYPE __glXSwapBarrierRes; /* diff --git a/GL/glx/glxcmds.c b/GL/glx/glxcmds.c index 6b581f16c..e311566dc 100644 --- a/GL/glx/glxcmds.c +++ b/GL/glx/glxcmds.c @@ -40,6 +40,8 @@ #include #endif +#include + #include "glxserver.h" #include #include @@ -47,7 +49,6 @@ #include #include #include "g_disptab_EXT.h" -#include "glximports.h" #include "glxutil.h" #include "glxext.h" #include "GL/glx_ansic.h" @@ -57,31 +58,22 @@ #include "glthread.h" #include "dispatch.h" +#ifndef GLX_TEXTURE_TARGET_EXT +#define GLX_TEXTURE_TARGET_EXT 0x6001 +#define GLX_TEXTURE_2D_EXT 0x6002 +#define GLX_TEXTURE_RECTANGLE_EXT 0x6003 +#define GLX_NO_TEXTURE_EXT 0x6004 +#define GLX_Y_INVERTED_EXT 0x6006 +#endif + /************************************************************************/ -void GlxSetRenderTables (struct _glapi_table *table) +void +GlxSetRenderTables (struct _glapi_table *table) { - _glapi_set_dispatch(table); + _glapi_set_dispatch (table); } -static __GLimports imports = { - __glXImpMalloc, - __glXImpCalloc, - __glXImpRealloc, - __glXImpFree, - __glXImpWarning, - __glXImpFatal, - __glXImpGetenv, - __glXImpAtoi, - __glXImpSprintf, - __glXImpFopen, - __glXImpFclose, - __glXImpFprintf, - __glXImpGetDrawablePrivate, - __glXImpGetReadablePrivate, - NULL -}; - static int __glXGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc); static int __glXCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc); static int __glXCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc); @@ -97,6 +89,27 @@ static int __glxHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc); /************************************************************************/ +static void __glXdirectContextDestroy(__GLXcontext *context) +{ + __glXFree(context); +} + +static __GLXcontext *__glXdirectContextCreate(__GLXscreen *screen, + __GLcontextModes *modes, + __GLXcontext *shareContext) +{ + __GLXcontext *context; + + context = __glXMalloc (sizeof (__GLXcontext)); + if (context == NULL) + return NULL; + + memset(context, 0, sizeof *context); + context->destroy = __glXdirectContextDestroy; + + return context; +} + /** * Create a GL context with the given properties. This routine is used * to implement \c glXCreateContext, \c glXCreateNewContext, and @@ -114,8 +127,7 @@ int DoCreateContext(__GLXclientState *cl, GLXContextID gcId, ScreenPtr pScreen; __GLXcontext *glxc, *shareglxc; __GLcontextModes *modes; - __GLXscreenInfo *pGlxScreen; - __GLinterface *shareGC; + __GLXscreen *pGlxScreen; GLint i; LEGAL_NEW_RESOURCE(gcId, client); @@ -128,7 +140,7 @@ int DoCreateContext(__GLXclientState *cl, GLXContextID gcId, return BadValue; } pScreen = screenInfo.screens[screen]; - pGlxScreen = &__glXActiveScreens[screen]; + pGlxScreen = __glXActiveScreens[screen]; /* ** Check if the visual ID is valid for this screen. @@ -170,7 +182,7 @@ int DoCreateContext(__GLXclientState *cl, GLXContextID gcId, ** for multithreaded servers, we don't do this. */ if (shareList == None) { - shareGC = 0; + shareglxc = 0; } else { shareglxc = (__GLXcontext *) LookupIDByType(shareList, __glXContextRes); if (!shareglxc) { @@ -196,17 +208,18 @@ int DoCreateContext(__GLXclientState *cl, GLXContextID gcId, */ isDirect = GL_FALSE; } - shareGC = shareglxc->gc; } /* ** Allocate memory for the new context */ - glxc = (__GLXcontext *) __glXMalloc(sizeof(__GLXcontext)); + if (!isDirect) + glxc = pGlxScreen->createContext(pGlxScreen, modes, shareglxc); + else + glxc = __glXdirectContextCreate(pGlxScreen, modes, shareglxc); if (!glxc) { return BadAlloc; } - __glXMemset(glxc, 0, sizeof(__GLXcontext)); /* ** Initially, setup the part of the context that could be used by @@ -217,32 +230,11 @@ int DoCreateContext(__GLXclientState *cl, GLXContextID gcId, glxc->pVisual = pVisual; glxc->modes = modes; - if (!isDirect) { - - /* - ** Allocate a GL context - */ - imports.other = (void *)glxc; - glxc->gc = (*pGlxScreen->createContext)(&imports, glxc->modes, shareGC); - if (!glxc->gc) { - __glXFree(glxc); - client->errorValue = gcId; - return BadAlloc; - } - } else { - /* - ** Don't need local GL context for a direct context. - */ - glxc->gc = 0; - } /* ** Register this context as a resource. */ if (!AddResource(gcId, __glXContextRes, (pointer)glxc)) { - if (!isDirect) { - (*glxc->gc->exports.destroyContext)((__GLcontext *)glxc->gc); - } - __glXFree(glxc); + (*glxc->destroy)(glxc); client->errorValue = gcId; return BadAlloc; } @@ -523,9 +515,8 @@ int DoMakeCurrent( __GLXclientState *cl, __GLXpixmap *drawPixmap = NULL; __GLXpixmap *readPixmap = NULL; __GLXcontext *glxc, *prevglxc; - __GLinterface *gc, *prevgc; - __GLXdrawablePrivate *drawPriv = NULL; - __GLXdrawablePrivate *readPriv = NULL; + __GLXdrawable *drawPriv = NULL; + __GLXdrawable *readPriv = NULL; GLint error; GLuint mask; @@ -557,10 +548,8 @@ int DoMakeCurrent( __GLXclientState *cl, client->errorValue = prevglxc->id; return __glXBadContextState; } - prevgc = prevglxc->gc; } else { prevglxc = 0; - prevgc = 0; } /* @@ -578,8 +567,6 @@ int DoMakeCurrent( __GLXclientState *cl, /* Context is current to somebody else */ return BadAccess; } - gc = glxc->gc; - assert( drawId != None ); assert( readId != None ); @@ -603,14 +590,14 @@ int DoMakeCurrent( __GLXclientState *cl, /* FIXME: Finish refactoring this. - idr */ /* get the drawable private */ if (pDraw) { - drawPriv = __glXGetDrawablePrivate(pDraw, drawId, glxc->modes); + drawPriv = __glXGetDrawable(glxc, pDraw, drawId); if (drawPriv == NULL) { return __glXBadDrawable; } } if (pRead != pDraw) { - readPriv = __glXGetDrawablePrivate(pRead, readId, glxc->modes); + readPriv = __glXGetDrawable(glxc, pRead, readId); if (readPriv == NULL) { return __glXBadDrawable; } @@ -621,7 +608,6 @@ int DoMakeCurrent( __GLXclientState *cl, } else { /* Switching to no context. Ignore new drawable. */ glxc = 0; - gc = 0; pDraw = 0; pRead = 0; } @@ -643,7 +629,7 @@ int DoMakeCurrent( __GLXclientState *cl, /* ** Make the previous context not current. */ - if (!(*prevgc->exports.loseCurrent)((__GLcontext *)prevgc)) { + if (!(*prevglxc->loseCurrent)(prevglxc)) { return __glXBadContext; } __glXDeassociateContext(prevglxc); @@ -654,19 +640,18 @@ int DoMakeCurrent( __GLXclientState *cl, glxc->drawPriv = drawPriv; glxc->readPriv = readPriv; - __glXCacheDrawableSize(drawPriv); /* make the context current */ - if (!(*gc->exports.makeCurrent)((__GLcontext *)gc)) { + if (!(*glxc->makeCurrent)(glxc)) { glxc->drawPriv = NULL; glxc->readPriv = NULL; return __glXBadContext; } /* resize the buffers */ - if (!__glXResizeDrawableBuffers(drawPriv)) { + if (!(*drawPriv->resize)(drawPriv)) { /* could not do initial resize. make current failed */ - (*gc->exports.loseCurrent)((__GLcontext *)gc); + (*glxc->loseCurrent)(glxc); glxc->drawPriv = NULL; glxc->readPriv = NULL; return __glXBadContext; @@ -914,9 +899,7 @@ int __glXCopyContext(__GLXclientState *cl, GLbyte *pc) /* ** Issue copy. The only reason for failure is a bad mask. */ - if (!(*dst->gc->exports.copyContext)((__GLcontext *)dst->gc, - (__GLcontext *)src->gc, - mask)) { + if (!(*dst->copy)(dst, src, mask)) { client->errorValue = mask; return BadValue; } @@ -929,7 +912,7 @@ int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen, { ClientPtr client = cl->client; xGLXGetVisualConfigsReply reply; - __GLXscreenInfo *pGlxScreen; + __GLXscreen *pGlxScreen; __GLcontextModes *modes; CARD32 buf[__GLX_TOTAL_CONFIG]; int p; @@ -941,7 +924,7 @@ int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen, client->errorValue = screen; return BadValue; } - pGlxScreen = &__glXActiveScreens[screen]; + pGlxScreen = __glXActiveScreens[screen]; reply.numVisuals = pGlxScreen->numUsableVisuals; reply.numProps = __GLX_TOTAL_CONFIG; @@ -1020,6 +1003,68 @@ int __glXGetVisualConfigs(__GLXclientState *cl, GLbyte *pc) } +/* Composite adds a 32 bit ARGB visual after glxvisuals.c have created + * the context modes for the screens. This visual is useful for GLX + * pixmaps, so we create a single mode for this visual with no extra + * buffers. */ +static void +__glXCreateARGBConfig(__GLXscreen *screen) +{ + __GLcontextModes *modes; + VisualPtr visual; + int i; + + visual = NULL; + for (i = 0; i < screen->pScreen->numVisuals; i++) + if (screen->pScreen->visuals[i].nplanes == 32) { + visual = &screen->pScreen->visuals[i]; + break; + } + + if (visual == NULL || visual->class != TrueColor) + return; + + if (_gl_context_modes_find_visual (screen->modes, visual->vid)) + return; + + /* Stop now if we already added the mode. */ + modes = _gl_context_modes_create(1, sizeof(__GLcontextModes)); + if (modes == NULL) + return; + + modes->next = screen->modes; + screen->modes = modes; + screen->numUsableVisuals++; + screen->numVisuals++; + + modes->visualID = visual->vid; + modes->fbconfigID = visual->vid; + modes->visualType = GLX_TRUE_COLOR; + modes->drawableType = GLX_WINDOW_BIT | GLX_PIXMAP_BIT; + modes->renderType = GLX_RGBA_BIT; + modes->xRenderable = GL_TRUE; + modes->rgbMode = TRUE; + modes->colorIndexMode = FALSE; + modes->doubleBufferMode = FALSE; + modes->stereoMode = FALSE; + modes->haveAccumBuffer = FALSE; + + modes->redBits = visual->bitsPerRGBValue;; + modes->greenBits = visual->bitsPerRGBValue; + modes->blueBits = visual->bitsPerRGBValue; + modes->alphaBits = visual->bitsPerRGBValue; + + modes->rgbBits = 4 * visual->bitsPerRGBValue; + modes->indexBits = 0; + modes->level = 0; + modes->numAuxBuffers = 0; + + modes->haveDepthBuffer = FALSE; + modes->depthBits = 0; + modes->haveStencilBuffer = FALSE; + modes->stencilBits = 0; +} + #define __GLX_TOTAL_FBCONFIG_ATTRIBS (28) #define __GLX_FBCONFIG_ATTRIBS_LENGTH (__GLX_TOTAL_FBCONFIG_ATTRIBS * 2) @@ -1037,7 +1082,7 @@ int DoGetFBConfigs(__GLXclientState *cl, unsigned screen, GLboolean do_swap) { ClientPtr client = cl->client; xGLXGetFBConfigsReply reply; - __GLXscreenInfo *pGlxScreen; + __GLXscreen *pGlxScreen; CARD32 buf[__GLX_FBCONFIG_ATTRIBS_LENGTH]; int p; __GLcontextModes *modes; @@ -1050,7 +1095,9 @@ int DoGetFBConfigs(__GLXclientState *cl, unsigned screen, GLboolean do_swap) client->errorValue = screen; return BadValue; } - pGlxScreen = &__glXActiveScreens[screen]; + pGlxScreen = __glXActiveScreens[screen]; + + __glXCreateARGBConfig(pGlxScreen); reply.numFBConfigs = pGlxScreen->numUsableVisuals; reply.numAttribs = __GLX_TOTAL_FBCONFIG_ATTRIBS; @@ -1148,7 +1195,7 @@ int DoCreateGLXPixmap(__GLXclientState *cl, VisualID visual, ScreenPtr pScreen; VisualPtr pVisual; __GLXpixmap *pGlxPixmap; - __GLXscreenInfo *pGlxScreen; + __GLXscreen *pGlxScreen; __GLcontextModes *modes; int i; @@ -1191,7 +1238,7 @@ int DoCreateGLXPixmap(__GLXclientState *cl, VisualID visual, /* ** Get configuration of the visual. */ - pGlxScreen = &__glXActiveScreens[screenNum]; + pGlxScreen = __glXActiveScreens[screenNum]; modes = _gl_context_modes_find_visual( pGlxScreen->modes, visual ); if (modes == NULL) { /* @@ -1216,29 +1263,11 @@ int DoCreateGLXPixmap(__GLXclientState *cl, VisualID visual, pGlxPixmap->modes = modes; - /* - ** Allocate buffers. - */ - pGlxPixmap->glxPriv = __glXCreateDrawablePrivate (pDraw, glxpixmapId, - modes); - if (!pGlxPixmap->glxPriv) - { - FreeResource(glxpixmapId, FALSE); - return BadAlloc; - } - - __glXRefDrawablePrivate (pGlxPixmap->glxPriv); /* ** Bump the ref count on the X pixmap so it won't disappear. */ ((PixmapPtr) pDraw)->refcnt++; - /* - ** XXX: Reset refcnt. Ignores references to this pixmap made by - ** __glXCreateDrawablePrivate. Need to fix this. - */ - pGlxPixmap->refcnt = 0; - return Success; } @@ -1362,16 +1391,16 @@ int __glXSwapBuffers(__GLXclientState *cl, GLbyte *pc) } if (pDraw) { - __GLXdrawablePrivate *glxPriv; + __GLXdrawable *glxPriv; if (glxc) { - glxPriv = __glXGetDrawablePrivate(pDraw, drawId, glxc->modes); + glxPriv = __glXGetDrawable(glxc, pDraw, drawId); if (glxPriv == NULL) { return __glXBadDrawable; } } else { - glxPriv = __glXFindDrawablePrivate(drawId); + glxPriv = __glXFindDrawable(drawId); if (glxPriv == NULL) { /* This is a window we've never seen before, do nothing */ return Success; @@ -1434,55 +1463,13 @@ int __glXQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc) return Success; } -int __glXGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc) -{ - xGLXGetDrawableAttributesReply reply; - ClientPtr client = cl->client; - GLXDrawable drawId; - __GLXdrawablePrivate *glxPriv; - int numAttribs; - int sendBuf[2]; - - pc += __GLX_VENDPRIV_HDR_SIZE; - - drawId = *((GLXDrawable *) (pc)); - - glxPriv = __glXFindDrawablePrivate (drawId); - if (!glxPriv) - { - client->errorValue = drawId; - return __glXBadDrawable; - } - - numAttribs = 1; /* XXX: Only GLX_TEXTURE_TARGET_EXT right now */ - reply.length = numAttribs << 1; - reply.type = X_Reply; - reply.sequenceNumber = client->sequence; - reply.numAttribs = numAttribs; - - sendBuf[0] = GLX_TEXTURE_TARGET_EXT; - sendBuf[1] = (int) (glxPriv->texTarget); - - if (client->swapped) - { - __glXSwapGetDrawableAttributesReply (client, &reply, sendBuf); - } - else - { - WriteToClient (client, sz_xGLXGetDrawableAttributesReply, - (char *) &reply); - WriteToClient (client, sizeof (sendBuf), (char *) sendBuf); - } - - return Success; -} int __glXBindTexImageEXT(__GLXclientState *cl, GLbyte *pc) { xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc; ClientPtr client = cl->client; - __GLXdrawablePrivate *glxPriv; - __GLXcontext *cx; + __GLXpixmap *pGlxPixmap; + __GLXcontext *context; GLXDrawable drawId; int buffer; int error; @@ -1492,26 +1479,33 @@ int __glXBindTexImageEXT(__GLXclientState *cl, GLbyte *pc) drawId = *((CARD32 *) (pc)); buffer = *((INT32 *) (pc + 4)); - cx = __glXForceCurrent (cl, req->contextTag, &error); - if (!cx) + if (buffer != GLX_FRONT_LEFT_EXT) + return __glXBadPixmap; + + context = __glXForceCurrent (cl, req->contextTag, &error); + if (!context) return error; - glxPriv = __glXFindDrawablePrivate (drawId); - if (!glxPriv) - { + pGlxPixmap = (__GLXpixmap *)LookupIDByType(drawId, __glXPixmapRes); + if (!pGlxPixmap) { client->errorValue = drawId; - return __glXBadDrawable; + return __glXBadPixmap; } - - return (*glxPriv->bindBuffers) (glxPriv, buffer); + + if (!context->textureFromPixmap) + return __glXUnsupportedPrivateRequest; + + return context->textureFromPixmap->bindTexImage(context, + buffer, + pGlxPixmap); } int __glXReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc) { xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc; ClientPtr client = cl->client; - __GLXdrawablePrivate *glxPriv; - __GLXcontext *cx; + __GLXpixmap *pGlxPixmap; + __GLXcontext *context; GLXDrawable drawId; int buffer; int error; @@ -1521,20 +1515,85 @@ int __glXReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc) drawId = *((CARD32 *) (pc)); buffer = *((INT32 *) (pc + 4)); - cx = __glXForceCurrent (cl, req->contextTag, &error); - if (!cx) + context = __glXForceCurrent (cl, req->contextTag, &error); + if (!context) return error; - glxPriv = __glXFindDrawablePrivate (drawId); - if (!glxPriv) - { + pGlxPixmap = (__GLXpixmap *)LookupIDByType(drawId, __glXPixmapRes); + if (!pGlxPixmap) { client->errorValue = drawId; return __glXBadDrawable; } - - return (*glxPriv->releaseBuffers) (glxPriv, buffer); + + if (!context->textureFromPixmap) + return __glXUnsupportedPrivateRequest; + + return context->textureFromPixmap->releaseTexImage(context, + buffer, + pGlxPixmap); } +/* +** Get drawable attributes +*/ +static int +DoGetDrawableAttributes(__GLXclientState *cl, XID drawId) +{ + ClientPtr client = cl->client; + __GLXpixmap *glxPixmap; + __GLXscreen *glxScreen; + xGLXGetDrawableAttributesReply reply; + CARD32 attributes[4]; + int numAttribs; + + glxPixmap = (__GLXpixmap *)LookupIDByType(drawId, __glXPixmapRes); + if (!glxPixmap) { + client->errorValue = drawId; + return __glXBadPixmap; + } + + numAttribs = 2; + reply.length = numAttribs << 1; + reply.type = X_Reply; + reply.sequenceNumber = client->sequence; + reply.numAttribs = numAttribs; + + attributes[0] = GLX_TEXTURE_TARGET_EXT; + attributes[1] = GLX_NO_TEXTURE_EXT; + attributes[2] = GLX_Y_INVERTED_EXT; + attributes[3] = GL_FALSE; + + glxScreen = glxPixmap->pGlxScreen; + if (glxScreen->textureFromPixmap) + attributes[1] = + (*glxScreen->textureFromPixmap->getTexTarget) (glxScreen, + glxPixmap); + + if (client->swapped) { + __glXSwapGetDrawableAttributesReply(client, &reply, attributes); + } else { + WriteToClient(client, sz_xGLXGetDrawableAttributesReply, + (char *)&reply); + WriteToClient(client, reply.length * sizeof (CARD32), + (char *)attributes); + } + + return Success; +} + +int __glXGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc) +{ + xGLXVendorPrivateWithReplyReq *req = (xGLXVendorPrivateWithReplyReq *)pc; + CARD32 *data; + XID drawable; + + data = (CARD32 *) (req + 1); + drawable = data[0]; + + return DoGetDrawableAttributes(cl, drawable); +} + + /************************************************************************/ static int @@ -2298,9 +2357,9 @@ int __glXVendorPrivate(__GLXclientState *cl, GLbyte *pc) case X_GLXvop_BindSwapBarrierSGIX: return __glXBindSwapBarrierSGIX(cl, pc); case X_GLXvop_BindTexImageEXT: - return __glXBindTexImageEXT(cl, pc); + return __glXBindTexImageEXT(cl, pc); case X_GLXvop_ReleaseTexImageEXT: - return __glXReleaseTexImageEXT(cl, pc); + return __glXReleaseTexImageEXT(cl, pc); } #endif @@ -2396,7 +2455,7 @@ int __glXQueryExtensionsString(__GLXclientState *cl, GLbyte *pc) return BadValue; } - ptr = __glXActiveScreens[screen].GLXextensions; + ptr = __glXActiveScreens[screen]->GLXextensions; n = __glXStrlen(ptr) + 1; length = __GLX_PAD(n) >> 2; @@ -2443,13 +2502,13 @@ int __glXQueryServerString(__GLXclientState *cl, GLbyte *pc) } switch(name) { case GLX_VENDOR: - ptr = __glXActiveScreens[screen].GLXvendor; + ptr = __glXActiveScreens[screen]->GLXvendor; break; case GLX_VERSION: - ptr = __glXActiveScreens[screen].GLXversion; + ptr = __glXActiveScreens[screen]->GLXversion; break; case GLX_EXTENSIONS: - ptr = __glXActiveScreens[screen].GLXextensions; + ptr = __glXActiveScreens[screen]->GLXextensions; break; default: return BadValue; diff --git a/GL/glx/glxcmdsswap.c b/GL/glx/glxcmdsswap.c index 5c59f5983..2917a2534 100644 --- a/GL/glx/glxcmdsswap.c +++ b/GL/glx/glxcmdsswap.c @@ -40,6 +40,7 @@ #include #endif +#include #include "glxserver.h" #include "glxutil.h" #include @@ -389,36 +390,18 @@ int __glXSwapQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc) return __glXQueryContextInfoEXT(cl, pc); } -int __glXSwapGetDrawableAttributesSGIX(__GLXclientState *cl, char *pc) +int __glXSwapBindTexImageEXT(__GLXclientState *cl, GLbyte *pc) { xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc; GLXDrawable *drawId; + int *buffer; __GLX_DECLARE_SWAP_VARIABLES; pc += __GLX_VENDPRIV_HDR_SIZE; drawId = ((GLXDrawable *) (pc)); - - __GLX_SWAP_SHORT(&req->length); - __GLX_SWAP_INT(&req->contextTag); - __GLX_SWAP_INT(drawId); - - return __glXGetDrawableAttributesSGIX(cl, (GLbyte *)pc); -} - -int __glXSwapBindTexImageEXT(__GLXclientState *cl, GLchar *pc) -{ - xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc; - CARD32 *drawId; - INT32 *buffer; - - __GLX_DECLARE_SWAP_VARIABLES; - - pc += __GLX_VENDPRIV_HDR_SIZE; - - drawId = ((CARD32 *) (pc)); - buffer = ((INT32 *) (pc + 4)); + buffer = ((int *) (pc + 4)); __GLX_SWAP_SHORT(&req->length); __GLX_SWAP_INT(&req->contextTag); @@ -428,18 +411,18 @@ int __glXSwapBindTexImageEXT(__GLXclientState *cl, GLchar *pc) return __glXBindTexImageEXT(cl, (GLbyte *)pc); } -int __glXSwapReleaseTexImageEXT(__GLXclientState *cl, GLchar *pc) +int __glXSwapReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc) { xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc; - CARD32 *drawId; - INT32 *buffer; + GLXDrawable *drawId; + int *buffer; __GLX_DECLARE_SWAP_VARIABLES; pc += __GLX_VENDPRIV_HDR_SIZE; - drawId = ((CARD32 *) (pc)); - buffer = ((INT32 *) (pc + 4)); + drawId = ((GLXDrawable *) (pc)); + buffer = ((int *) (pc + 4)); __GLX_SWAP_SHORT(&req->length); __GLX_SWAP_INT(&req->contextTag); @@ -449,6 +432,22 @@ int __glXSwapReleaseTexImageEXT(__GLXclientState *cl, GLchar *pc) return __glXReleaseTexImageEXT(cl, (GLbyte *)pc); } +int __glXSwapGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc) +{ + xGLXVendorPrivateWithReplyReq *req = (xGLXVendorPrivateWithReplyReq *)pc; + CARD32 *data; + + __GLX_DECLARE_SWAP_VARIABLES; + + data = (CARD32 *) (req + 1); + __GLX_SWAP_SHORT(&req->length); + __GLX_SWAP_INT(&req->contextTag); + __GLX_SWAP_INT(data); + + return __glXGetDrawableAttributesSGIX(cl, (GLbyte *)pc); +} + + /************************************************************************/ /* @@ -523,7 +522,8 @@ void __glXSwapQueryContextInfoEXTReply(ClientPtr client, xGLXQueryContextInfoEXT WriteToClient(client, length << 2, (char *)buf); } -void __glXSwapGetDrawableAttributesReply(ClientPtr client, xGLXGetDrawableAttributesReply *reply, int *buf) +void __glXSwapGetDrawableAttributesReply(ClientPtr client, + xGLXGetDrawableAttributesReply *reply, CARD32 *buf) { int length = reply->length; __GLX_DECLARE_SWAP_VARIABLES; @@ -1124,8 +1124,8 @@ int __glXSwapVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc) return __glXSwapCreateContextWithConfigSGIX(cl, pc); case X_GLXvop_CreateGLXPixmapWithConfigSGIX: return __glXSwapCreateGLXPixmapWithConfigSGIX(cl, pc); - case X_GLXvop_GetDrawableAttributesSGIX: - return __glXGetDrawableAttributesSGIX(cl, pc); + case X_GLXvop_GetDrawableAttributesSGIX: + return __glXSwapGetDrawableAttributesSGIX(cl, pc); case X_GLvop_IsRenderbufferEXT: return __glXDispSwap_IsRenderbufferEXT(cl, pc); case X_GLvop_GenRenderbuffersEXT: diff --git a/GL/glx/glxcontext.h b/GL/glx/glxcontext.h index 18d8b44c2..51e0ba67a 100644 --- a/GL/glx/glxcontext.h +++ b/GL/glx/glxcontext.h @@ -41,32 +41,48 @@ ** */ -typedef struct __GLXcontextRec __GLXcontext; - /* XXX: should be defined somewhere globally */ #define CAPI #include "GL/internal/glcore.h" -struct __GLXcontextRec { +typedef struct __GLXtextureFromPixmapContext __GLXtextureFromPixmapContext; +struct __GLXtextureFromPixmapContext { + int (*bindTexImage) (__GLXcontext *baseContext, + int buffer, + __GLXpixmap *pixmap); + int (*releaseTexImage) (__GLXcontext *baseContext, + int buffer, + __GLXpixmap *pixmap); +}; + + +struct __GLXcontext { + void (*destroy) (__GLXcontext *context); + int (*makeCurrent) (__GLXcontext *context); + int (*loseCurrent) (__GLXcontext *context); + int (*copy) (__GLXcontext *dst, + __GLXcontext *src, + unsigned long mask); + int (*forceCurrent) (__GLXcontext *context); + + __GLXdrawable *(*createDrawable)(__GLXcontext *context, + DrawablePtr pDraw, + XID drawId); + + __GLXtextureFromPixmapContext *textureFromPixmap; + /* ** list of context structs */ - struct __GLXcontextRec *last; - struct __GLXcontextRec *next; + __GLXcontext *last; + __GLXcontext *next; /* ** list of contexts bound to the same drawable */ - struct __GLXcontextRec *nextDrawPriv; - struct __GLXcontextRec *nextReadPriv; - - /* - ** Opaque pointer the context object created by the GL that the - ** server is bound with. Never dereferenced by this code, but used - ** as a handle to feed to the routines in the screen info struct. - */ - __GLinterface *gc; + __GLXcontext *nextDrawPriv; + __GLXcontext *nextReadPriv; /* ** mode struct for this context @@ -78,7 +94,7 @@ struct __GLXcontextRec { ** when the context is created. */ ScreenPtr pScreen; - __GLXscreenInfo *pGlxScreen; + __GLXscreen *pGlxScreen; /* ** This context is created with respect to this visual. @@ -152,8 +168,8 @@ struct __GLXcontextRec { /* ** The drawable private this context is bound to */ - __GLXdrawablePrivate *drawPriv; - __GLXdrawablePrivate *readPriv; + __GLXdrawable *drawPriv; + __GLXdrawable *readPriv; }; /* pending state defines */ diff --git a/GL/glx/glxdrawable.h b/GL/glx/glxdrawable.h index 778cff4a3..2d5d07a79 100644 --- a/GL/glx/glxdrawable.h +++ b/GL/glx/glxdrawable.h @@ -45,20 +45,23 @@ typedef struct { DrawablePtr pDraw; __GLcontextModes *modes; - __GLXscreenInfo *pGlxScreen; + __GLXscreen *pGlxScreen; ScreenPtr pScreen; Bool idExists; - __GLXdrawablePrivate *glxPriv; int refcnt; } __GLXpixmap; -struct __GLXdrawablePrivateRec { +struct __GLXdrawable { + void (*destroy)(__GLXdrawable *private); + GLboolean (*resize)(__GLXdrawable *private); + GLboolean (*swapBuffers)(__GLXdrawable *); + /* ** list of drawable private structs */ - struct __GLXdrawablePrivateRec *last; - struct __GLXdrawablePrivateRec *next; + __GLXdrawable *last; + __GLXdrawable *next; DrawablePtr pDraw; XID drawId; @@ -76,40 +79,14 @@ struct __GLXdrawablePrivateRec { */ __GLcontextModes *modes; - /* - ** cached drawable size and origin - */ - - GLint xorigin, yorigin; - GLint width, height; - /* ** Lists of contexts bound to this drawable. There are two lists here. ** One list is of the contexts that have this drawable bound for drawing, ** and the other is the list of contexts that have this drawable bound ** for reading. */ - struct __GLXcontextRec *drawGlxc; - struct __GLXcontextRec *readGlxc; - - /* - ** "methods" that the drawble should be able to respond to. - */ - void (*freeBuffers)(struct __GLXdrawablePrivateRec *); - void (*updatePalette)(struct __GLXdrawablePrivateRec *); - GLboolean (*swapBuffers)(struct __GLXdrawablePrivateRec *); - int (*bindBuffers)(struct __GLXdrawablePrivateRec *, int); - int (*releaseBuffers)(struct __GLXdrawablePrivateRec *, int); - - /* - ** Used by EXT_render_texture. - */ - GLenum texTarget; - - /* - ** The GL drawable (information shared between GLX and the GL core) - */ - __GLdrawablePrivate glPriv; + __GLXcontext *drawGlxc; + __GLXcontext *readGlxc; /* ** reference count diff --git a/GL/glx/glxdri.c b/GL/glx/glxdri.c new file mode 100644 index 000000000..99e79ffa2 --- /dev/null +++ b/GL/glx/glxdri.c @@ -0,0 +1,937 @@ +/* + * Copyright © 2006 Red Hat, Inc + * + * Permission to use, copy, modify, distribute, and sell this software + * and its documentation for any purpose is hereby granted without + * fee, provided that the above copyright notice appear in all copies + * and that both that copyright notice and this permission notice + * appear in supporting documentation, and that the name of Red Hat, + * Inc not be used in advertising or publicity pertaining to + * distribution of the software without specific, written prior + * permission. Red Hat, Inc makes no representations about the + * suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * RED HAT, INC DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN + * NO EVENT SHALL RED HAT, INC BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS + * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifdef HAVE_DIX_CONFIG_H +#include +#endif + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include + +#define _XF86DRI_SERVER_ +#include +#include +#include +#include +#include +#include + +#define DRI_NEW_INTERFACE_ONLY +#include "glxserver.h" +#include "glxutil.h" +#include "glcontextmodes.h" + +#include "g_disptab.h" +#include "g_disptab_EXT.h" +#include "glapitable.h" +#include "glapi.h" +#include "glthread.h" +#include "dispatch.h" + + +#define STRINGIFY(macro_or_string) STRINGIFY_ARG (macro_or_string) +#define STRINGIFY_ARG(contents) #contents + +typedef struct __GLXDRIscreen __GLXDRIscreen; +typedef struct __GLXDRIcontext __GLXDRIcontext; +typedef struct __GLXDRIdrawable __GLXDRIdrawable; + +struct __GLXDRIscreen { + __GLXscreen base; + + __DRIscreen driScreen; + void *driver; +}; + +struct __GLXDRIcontext { + __GLXcontext base; + + __DRIcontext driContext; +}; + +struct __GLXDRIdrawable { + __GLXdrawable base; + + __DRIdrawable *driDrawable; +}; + +/* History: + * 20021121 - Initial version + * 20021128 - Added __glXWindowExists() function + * 20021207 - Added support for dynamic GLX extensions, + * GLX_SGI_swap_control, GLX_SGI_video_sync, + * GLX_OML_sync_control, and GLX_MESA_swap_control. + * Never officially released. Do NOT test against + * this version. Use 20030317 instead. + * 20030317 - Added support GLX_SGIX_fbconfig, + * GLX_MESA_swap_frame_usage, GLX_OML_swap_method, + * GLX_{ARB,SGIS}_multisample, and + * GLX_SGIX_visual_select_group. + * 20030606 - Added support for GLX_SGI_make_current_read. + * 20030813 - Made support for dynamic extensions multi-head aware. + * 20030818 - Added support for GLX_MESA_allocate_memory in place of the + * deprecated GLX_NV_vertex_array_range & GLX_MESA_agp_offset + * interfaces. + * 20031201 - Added support for the first round of DRI interface changes. + * Do NOT test against this version! It has binary + * compatibility bugs, use 20040317 instead. + * 20040317 - Added the 'mode' field to __DRIcontextRec. + * 20040415 - Added support for bindContext3 and unbindContext3. + * 20040602 - Add __glXGetDrawableInfo. I though that was there + * months ago. :( + * 20050727 - Gut all the old interfaces. This breaks compatability with + * any DRI driver built to any previous version. + */ +#define INTERNAL_VERSION 20050727 + +static const char CREATE_NEW_SCREEN_FUNC[] = + "__driCreateNewScreen_" STRINGIFY (INTERNAL_VERSION); + +static void +__glXDRIleaveServer(void) +{ + int i; + + for (i = 0; i < screenInfo.numScreens; i++) + DRIDoBlockHandler(i, NULL, NULL, NULL); +} + +static void +__glXDRIenterServer(void) +{ + int i; + + for (i = 0; i < screenInfo.numScreens; i++) + DRIDoWakeupHandler(i, NULL, 0, NULL); +} + +static void +__glXDRIdrawableDestroy(__GLXdrawable *private) +{ +#if 0 + (*glxPriv->driDrawable.destroyDrawable)(NULL, + glxPriv->driDrawable.private); +#endif + + __glXFree(private); +} + +static GLboolean +__glXDRIdrawableResize(__GLXdrawable *glxPriv) +{ + /* Nothing to do here, the DRI driver asks the server for drawable + * geometry when it sess the SAREA timestamps change.*/ + + return GL_TRUE; +} + +static GLboolean +__glXDRIdrawableSwapBuffers(__GLXdrawable *basePrivate) +{ + __GLXDRIdrawable *private = (__GLXDRIdrawable *) basePrivate; + __GLXDRIscreen *screen; + + /* FIXME: We're jumping through hoops here to get the DRIdrawable + * which the dri driver tries to keep to it self... cf. FIXME in + * createDrawable. */ + + screen = (__GLXDRIscreen *) __glXgetActiveScreen(private->base.pDraw->pScreen->myNum); + private->driDrawable = (screen->driScreen.getDrawable)(NULL, + private->base.drawId, + screen->driScreen.private); + + (*private->driDrawable->swapBuffers)(NULL, + private->driDrawable->private); + + return TRUE; +} + +static __GLXdrawable * +__glXDRIcontextCreateDrawable(__GLXcontext *context, + DrawablePtr pDraw, + XID drawId) +{ + __GLXDRIdrawable *private; + + private = __glXMalloc(sizeof *private); + if (private == NULL) + return NULL; + + memset(private, 0, sizeof *private); + + if (!__glXDrawableInit(&private->base, context, pDraw, drawId)) { + __glXFree(private); + return NULL; + } + + private->base.destroy = __glXDRIdrawableDestroy; + private->base.resize = __glXDRIdrawableResize; + private->base.swapBuffers = __glXDRIdrawableSwapBuffers; + +#if 0 + /* FIXME: It would only be natural that we called + * driScreen->createNewDrawable here but the DRI drivers manage + * them a little oddly. FIXME: describe this better.*/ + + /* The last argument is 'attrs', which is used with pbuffers which + * we currently don't support. */ + + glxPriv->driDrawable.private = + (pGlxScreen->driScreen.createNewDrawable)(NULL, modes, + drawId, + &glxPriv->driDrawable, + 0, + NULL); +#endif + + return &private->base; +} + + +static void +__glXDRIcontextDestroy(__GLXcontext *baseContext) +{ + __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext; + + context->driContext.destroyContext(NULL, + context->base.pScreen->myNum, + context->driContext.private); + __glXFree(context); +} + +static int +__glXDRIcontextMakeCurrent(__GLXcontext *baseContext) +{ + __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext; + + return (*context->driContext.bindContext)(NULL, + context->base.pScreen->myNum, + baseContext->drawPriv->drawId, + baseContext->readPriv->drawId, + &context->driContext); +} + +static int +__glXDRIcontextLoseCurrent(__GLXcontext *baseContext) +{ + __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext; + + return (*context->driContext.unbindContext)(NULL, + context->base.pScreen->myNum, + baseContext->drawPriv->drawId, + baseContext->readPriv->drawId, + &context->driContext); +} + +static int +__glXDRIcontextCopy(__GLXcontext *baseDst, __GLXcontext *baseSrc, + unsigned long mask) +{ + __GLXDRIcontext *dst = (__GLXDRIcontext *) baseDst; + __GLXDRIcontext *src = (__GLXDRIcontext *) baseSrc; + + /* FIXME: We will need to add DRIcontext::copyContext for this. */ + + (void) dst; + (void) src; + + return FALSE; +} + +static int +__glXDRIcontextForceCurrent(__GLXcontext *baseContext) +{ + __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext; + + return (*context->driContext.bindContext)(NULL, + context->base.pScreen->myNum, + baseContext->drawPriv->drawId, + baseContext->readPriv->drawId, + &context->driContext); +} + +static int +glxCountBits(int word) +{ + int ret = 0; + + while (word) { + ret += (word & 1); + word >>= 1; + } + + return ret; +} + +static void +glxFillAlphaChannel (PixmapPtr pixmap) +{ + int i, j; + CARD32 *pixels = (CARD32 *)pixmap->devPrivate.ptr; + CARD32 rowstride = pixmap->devKind / 4; + CARD32 x, y; + + x = pixmap->drawable.x; + y = pixmap->drawable.y; + + for (i = y; i < pixmap->drawable.height + y; ++i) + { + for (j = x; j < pixmap->drawable.width + x; ++j) + { + int index = i * rowstride + j; + + pixels[index] |= 0xFF000000; + } + } +} + +/* + * (sticking this here for lack of a better place) + * Known issues with the GLX_EXT_texture_from_pixmap implementation: + * - In general we ignore the fbconfig, lots of examples follow + * - No fbconfig handling for multiple mipmap levels + * - No fbconfig handling for 1D textures + * - No fbconfig handling for TEXTURE_TARGET + * - No fbconfig exposure of Y inversion state + * - No GenerateMipmapEXT support (due to no FBO support) + * - No damage tracking between binds + * - No support for anything but 16bpp and 32bpp-sparse pixmaps + */ + +static int +__glXDRIgetTexTarget (__GLXscreen *screen, + __GLXpixmap *pixmap) +{ + return GLX_TEXTURE_RECTANGLE_EXT; +} + +static __GLXtextureFromPixmapScreen __glXDRItextureFromPixmapScreen = { + __glXDRIgetTexTarget, +}; + +static int +__glXDRIbindTexImage(__GLXcontext *baseContext, + int buffer, + __GLXpixmap *glxPixmap) +{ + PixmapPtr pixmap; + int bpp; + Bool npot; + + pixmap = (PixmapPtr) glxPixmap->pDraw; + bpp = pixmap->drawable.depth >= 24 ? 4 : 2; /* XXX 24bpp packed, 8, etc */ + + CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, + pixmap->devKind / bpp) ); + CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, + pixmap->drawable.y) ); + CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, + pixmap->drawable.x) ); + + if (pixmap->drawable.depth == 24) + glxFillAlphaChannel(pixmap); + + npot = !(glxCountBits(pixmap->drawable.width) == 1 && + glxCountBits(pixmap->drawable.height) == 1) /* || + strstr(CALL_GetString(GL_EXTENSIONS, + "GL_ARB_texture_non_power_of_two")) */ ; + + CALL_TexImage2D( GET_DISPATCH(), + ( npot ? GL_TEXTURE_RECTANGLE_ARB : GL_TEXTURE_2D, + 0, + bpp == 4 ? 4 : 3, + pixmap->drawable.width, + pixmap->drawable.height, + 0, + bpp == 4 ? GL_BGRA : GL_RGB, + bpp == 4 ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT_5_6_5, + pixmap->devPrivate.ptr ) ); + + return Success; +} + +static int +__glXDRIreleaseTexImage(__GLXcontext *baseContext, + int buffer, + __GLXpixmap *pixmap) +{ + return Success; +} + +static __GLXtextureFromPixmapContext __glXDRItextureFromPixmapContext = { + __glXDRIbindTexImage, + __glXDRIreleaseTexImage +}; + +static void +__glXDRIscreenDestroy(__GLXscreen *baseScreen) +{ + __GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen; + + screen->driScreen.destroyScreen(NULL, + screen->base.pScreen->myNum, + screen->driScreen.private); + + dlclose(screen->driver); + + __glXScreenDestroy(baseScreen); + + __glXFree(screen); +} + +static __GLXcontext * +__glXDRIscreenCreateContext(__GLXscreen *baseScreen, + __GLcontextModes *modes, + __GLXcontext *baseShareContext) +{ + __GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen; + __GLXDRIcontext *context, *shareContext; + void *sharePrivate; + + shareContext = (__GLXDRIcontext *) baseShareContext; + if (shareContext) + sharePrivate = shareContext->driContext.private; + else + sharePrivate = NULL; + + context = __glXMalloc(sizeof *context); + if (context == NULL) + return NULL; + + memset(context, 0, sizeof *context); + context->base.destroy = __glXDRIcontextDestroy; + context->base.makeCurrent = __glXDRIcontextMakeCurrent; + context->base.loseCurrent = __glXDRIcontextLoseCurrent; + context->base.copy = __glXDRIcontextCopy; + context->base.forceCurrent = __glXDRIcontextForceCurrent; + context->base.createDrawable = __glXDRIcontextCreateDrawable; + + context->base.textureFromPixmap = &__glXDRItextureFromPixmapContext; + + context->driContext.private = + screen->driScreen.createNewContext(NULL, modes, + 0, /* render type */ + sharePrivate, + &context->driContext); + + context->driContext.mode = modes; + + return &context->base; +} + +static unsigned +filter_modes(__GLcontextModes **server_modes, + const __GLcontextModes *driver_modes) +{ + __GLcontextModes * m; + __GLcontextModes ** prev_next; + const __GLcontextModes * check; + unsigned modes_count = 0; + + if ( driver_modes == NULL ) { + fprintf(stderr, "libGL warning: 3D driver returned no fbconfigs.\n"); + return 0; + } + + /* For each mode in server_modes, check to see if a matching mode exists + * in driver_modes. If not, then the mode is not available. + */ + + prev_next = server_modes; + for ( m = *prev_next ; m != NULL ; m = *prev_next ) { + GLboolean do_delete = GL_TRUE; + + for ( check = driver_modes ; check != NULL ; check = check->next ) { + if ( _gl_context_modes_are_same( m, check ) ) { + do_delete = GL_FALSE; + break; + } + } + + /* The 3D has to support all the modes that match the GLX visuals + * sent from the X server. + */ + if ( do_delete && (m->visualID != 0) ) { + do_delete = GL_FALSE; + + fprintf(stderr, "libGL warning: 3D driver claims to not support " + "visual 0x%02x\n", m->visualID); + } + + if ( do_delete ) { + *prev_next = m->next; + + m->next = NULL; + _gl_context_modes_destroy( m ); + } + else { + modes_count++; + prev_next = & m->next; + } + } + + return modes_count; +} + + +static __DRIfuncPtr getProcAddress(const char *proc_name) +{ + return NULL; +} + +static __DRIscreen *findScreen(__DRInativeDisplay *dpy, int scrn) +{ + __GLXDRIscreen *screen = + (__GLXDRIscreen *) __glXgetActiveScreen(scrn); + + return &screen->driScreen; +} + +static GLboolean windowExists(__DRInativeDisplay *dpy, __DRIid draw) +{ + WindowPtr pWin = (WindowPtr) LookupIDByType(draw, RT_WINDOW); + + return pWin == NULL ? GL_FALSE : GL_TRUE; +} + +static GLboolean createContext(__DRInativeDisplay *dpy, int screen, + int configID, void *contextID, + drm_context_t *hw_context) +{ + XID fakeID; + VisualPtr visual; + int i; + ScreenPtr pScreen; + GLboolean retval; + + pScreen = screenInfo.screens[screen]; + + /* Find the requested X visual */ + visual = pScreen->visuals; + for (i = 0; i < pScreen->numVisuals; i++, visual++) + if (visual->vid == configID) + break; + if (i == pScreen->numVisuals) + return GL_FALSE; + + fakeID = FakeClientID(0); + *(XID *) contextID = fakeID; + + __glXDRIenterServer(); + retval = DRICreateContext(pScreen, visual, fakeID, hw_context); + __glXDRIleaveServer(); + return retval; +} + +static GLboolean destroyContext(__DRInativeDisplay *dpy, int screen, + __DRIid context) +{ + GLboolean retval; + + __glXDRIenterServer(); + retval = DRIDestroyContext(screenInfo.screens[screen], context); + __glXDRIleaveServer(); + return retval; +} + +static GLboolean +createDrawable(__DRInativeDisplay *dpy, int screen, + __DRIid drawable, drm_drawable_t *hHWDrawable) +{ + DrawablePtr pDrawable; + GLboolean retval; + + pDrawable = (DrawablePtr) LookupIDByClass(drawable, RC_DRAWABLE); + if (!pDrawable) + return GL_FALSE; + + __glXDRIenterServer(); + retval = DRICreateDrawable(screenInfo.screens[screen], + drawable, + pDrawable, + hHWDrawable); + __glXDRIleaveServer(); + return retval; +} + +static GLboolean +destroyDrawable(__DRInativeDisplay *dpy, int screen, __DRIid drawable) +{ + DrawablePtr pDrawable; + GLboolean retval; + + pDrawable = (DrawablePtr) LookupIDByClass(drawable, RC_DRAWABLE); + if (!pDrawable) + return GL_FALSE; + + __glXDRIenterServer(); + retval = DRIDestroyDrawable(screenInfo.screens[screen], + drawable, + pDrawable); + __glXDRIleaveServer(); + return retval; +} + +static GLboolean +getDrawableInfo(__DRInativeDisplay *dpy, int screen, + __DRIid drawable, unsigned int *index, unsigned int *stamp, + int *x, int *y, int *width, int *height, + int *numClipRects, drm_clip_rect_t **ppClipRects, + int *backX, int *backY, + int *numBackClipRects, drm_clip_rect_t **ppBackClipRects) +{ + DrawablePtr pDrawable; + drm_clip_rect_t *pClipRects, *pBackClipRects; + GLboolean retval; + size_t size; + + pDrawable = (DrawablePtr) LookupIDByClass(drawable, RC_DRAWABLE); + if (!pDrawable) { + ErrorF("getDrawableInfo failed to look up window\n"); + + *index = 0; + *stamp = 0; + *x = 0; + *y = 0; + *width = 0; + *height = 0; + *numClipRects = 0; + *ppClipRects = NULL; + *backX = 0; + *backY = 0; + *numBackClipRects = 0; + *ppBackClipRects = NULL; + + return GL_FALSE; + } + + __glXDRIenterServer(); + retval = DRIGetDrawableInfo(screenInfo.screens[screen], + pDrawable, index, stamp, + x, y, width, height, + numClipRects, &pClipRects, + backX, backY, + numBackClipRects, &pBackClipRects); + __glXDRIleaveServer(); + + if (*numClipRects > 0) { + size = sizeof (drm_clip_rect_t) * *numClipRects; + *ppClipRects = __glXMalloc (size); + if (*ppClipRects != NULL) + memcpy (*ppClipRects, pClipRects, size); + } + else { + *ppClipRects = NULL; + } + + if (*numBackClipRects > 0) { + size = sizeof (drm_clip_rect_t) * *numBackClipRects; + *ppBackClipRects = __glXMalloc (size); + if (*ppBackClipRects != NULL) + memcpy (*ppBackClipRects, pBackClipRects, size); + } + else { + *ppBackClipRects = NULL; + } + + return GL_TRUE; +} + +static int +getUST(int64_t *ust) +{ + struct timeval tv; + + if (ust == NULL) + return -EFAULT; + + if (gettimeofday(&tv, NULL) == 0) { + ust[0] = (tv.tv_sec * 1000000) + tv.tv_usec; + return 0; + } else { + return -errno; + } +} + +/* Table of functions that we export to the driver. */ +static const __DRIinterfaceMethods interface_methods = { + getProcAddress, + + _gl_context_modes_create, + _gl_context_modes_destroy, + + findScreen, + windowExists, + + createContext, + destroyContext, + + createDrawable, + destroyDrawable, + getDrawableInfo, + + getUST, + NULL, /* glXGetMscRateOML, */ +}; + +static const char dri_driver_path[] = DRI_DRIVER_PATH; + +static __GLXscreen * +__glXDRIscreenProbe(ScreenPtr pScreen) +{ + PFNCREATENEWSCREENFUNC createNewScreen; + drm_handle_t hSAREA; + drmAddress pSAREA = NULL; + char *BusID; + __DRIversion ddx_version; + __DRIversion dri_version; + __DRIversion drm_version; + __DRIframebuffer framebuffer; + int fd = -1; + int status; + const char *err_msg; + const char *err_extra = NULL; + int api_ver = INTERNAL_VERSION; + drm_magic_t magic; + drmVersionPtr version; + char *driverName; + drm_handle_t hFB; + int junk; + __GLcontextModes * driver_modes; + __GLXDRIscreen *screen; + void *dev_priv = NULL; + char filename[128]; + + screen = __glXMalloc(sizeof *screen); + if (screen == NULL) + return NULL; + memset(screen, 0, sizeof *screen); + + screen->base.destroy = __glXDRIscreenDestroy; + screen->base.createContext = __glXDRIscreenCreateContext; + screen->base.pScreen = pScreen; + + screen->base.textureFromPixmap = __glXDRItextureFromPixmapScreen; + + /* DRI protocol version. */ + dri_version.major = XF86DRI_MAJOR_VERSION; + dri_version.minor = XF86DRI_MINOR_VERSION; + dri_version.patch = XF86DRI_PATCH_VERSION; + + framebuffer.base = NULL; + framebuffer.dev_priv = NULL; + + if (!DRIOpenConnection(pScreen, &hSAREA, &BusID)) { + err_msg = "DRIOpenConnection"; + err_extra = NULL; + goto handle_error; + } + + fd = drmOpen(NULL, BusID); + + if (fd < 0) { + err_msg = "open DRM"; + err_extra = strerror( -fd ); + goto handle_error; + } + + if (drmGetMagic(fd, &magic)) { + err_msg = "drmGetMagic"; + goto handle_error; + } + + version = drmGetVersion(fd); + if (version) { + drm_version.major = version->version_major; + drm_version.minor = version->version_minor; + drm_version.patch = version->version_patchlevel; + drmFreeVersion(version); + } + else { + drm_version.major = -1; + drm_version.minor = -1; + drm_version.patch = -1; + } + + if (!DRIAuthConnection(pScreen, magic)) { + err_msg = "DRIAuthConnection"; + goto handle_error; + } + + /* Get device name (like "tdfx") and the ddx version numbers. + * We'll check the version in each DRI driver's "createNewScreen" + * function. */ + if (!DRIGetClientDriverName(pScreen, + &ddx_version.major, + &ddx_version.minor, + &ddx_version.patch, + &driverName)) { + err_msg = "DRIGetClientDriverName"; + goto handle_error; + } + + snprintf(filename, sizeof filename, "%s/%s_dri.so", + dri_driver_path, driverName); + + screen->driver = dlopen(filename, RTLD_LAZY | RTLD_LOCAL); + if (screen->driver == NULL) { + err_msg = "Loading driver"; + err_extra = filename; + goto handle_error; + } + + createNewScreen = dlsym(screen->driver, CREATE_NEW_SCREEN_FUNC); + if (createNewScreen == NULL) { + err_msg = "Driver entry point lookup"; + err_extra = CREATE_NEW_SCREEN_FUNC; + goto handle_error; + } + + /* + * Get device-specific info. pDevPriv will point to a struct + * (such as DRIRADEONRec in xfree86/driver/ati/radeon_dri.h) that + * has information about the screen size, depth, pitch, ancilliary + * buffers, DRM mmap handles, etc. + */ + if (!DRIGetDeviceInfo(pScreen, &hFB, &junk, + &framebuffer.size, &framebuffer.stride, + &framebuffer.dev_priv_size, &framebuffer.dev_priv)) { + err_msg = "XF86DRIGetDeviceInfo"; + goto handle_error; + } + + /* Sigh... the DRI interface is broken; the DRI driver will free + * the dev private pointer using _mesa_free() on screen destroy, + * but we can't use _mesa_malloc() here. In fact, the DRI driver + * shouldn't free data it didn't allocate itself, but what can you + * do... */ + dev_priv = __glXMalloc(framebuffer.dev_priv_size); + if (dev_priv == NULL) { + err_msg = "dev_priv allocation"; + goto handle_error; + } + memcpy(dev_priv, framebuffer.dev_priv, framebuffer.dev_priv_size); + framebuffer.dev_priv = dev_priv; + + framebuffer.width = pScreen->width; + framebuffer.height = pScreen->height; + + /* Map the framebuffer region. */ + status = drmMap(fd, hFB, framebuffer.size, + (drmAddressPtr)&framebuffer.base); + if (status != 0) { + err_msg = "drmMap of framebuffer"; + err_extra = strerror( -status ); + goto handle_error; + } + + /* Map the SAREA region. Further mmap regions may be setup in + * each DRI driver's "createNewScreen" function. + */ + status = drmMap(fd, hSAREA, SAREA_MAX, &pSAREA); + if (status != 0) { + err_msg = "drmMap of sarea"; + err_extra = strerror( -status ); + goto handle_error; + } + + __glXScreenInit(&screen->base, pScreen); + + driver_modes = NULL; + screen->driScreen.private = + (*createNewScreen)(NULL, pScreen->myNum, + &screen->driScreen, + screen->base.modes, + &ddx_version, + &dri_version, + &drm_version, + &framebuffer, + pSAREA, + fd, + api_ver, + &interface_methods, + &driver_modes); + + if (screen->driScreen.private == NULL) { + err_msg = "InitDriver"; + err_extra = NULL; + goto handle_error; + } + + filter_modes(&screen->base.modes, driver_modes); + _gl_context_modes_destroy(driver_modes); + + __glXsetEnterLeaveServerFuncs(__glXDRIenterServer, __glXDRIleaveServer); + + LogMessage(X_INFO, + "GLX-DRI: Loaded and initialized %s\n", filename); + + return &screen->base; + + handle_error: + if (pSAREA != NULL) + drmUnmap(pSAREA, SAREA_MAX); + + if (framebuffer.base != NULL) + drmUnmap((drmAddress)framebuffer.base, framebuffer.size); + + if (dev_priv != NULL) + __glXFree(dev_priv); + + if (fd >= 0) + drmClose(fd); + + DRICloseConnection(pScreen); + + if (screen->driver) + dlclose(screen->driver); + + xfree(screen); + + if (err_extra != NULL) + LogMessage(X_ERROR, + "GLX-DRI error: %s failed (%s)\n", err_msg, err_extra); + else + LogMessage(X_ERROR, "GLX-DRI error: %s failed\n", err_msg); + + ErrorF("GLX-DRI: reverting to software rendering\n"); + + return NULL; +} + +__GLXprovider __glXDRIProvider = { + __glXDRIscreenProbe, + "DRI", + NULL +}; diff --git a/GL/glx/glxext.c b/GL/glx/glxext.c index fa1382983..e4ad47803 100644 --- a/GL/glx/glxext.c +++ b/GL/glx/glxext.c @@ -23,6 +23,7 @@ #include #endif +#include #include "glxserver.h" #include #include @@ -31,19 +32,12 @@ #include "unpack.h" #include "glxutil.h" #include "glxext.h" -#include "micmap.h" - -void GlxWrapInitVisuals(miInitVisualsProcPtr *); -void GlxSetVisualConfigs(int nconfigs, - __GLXvisualConfig *configs, void **privates); - -static __GLXextensionInfo *__glXExt /* = &__glDDXExtensionInfo */; +static Bool inDispatch; /* ** Forward declarations. */ -static int __glXSwapDispatch(ClientPtr); static int __glXDispatch(ClientPtr); /* @@ -52,8 +46,7 @@ static int __glXDispatch(ClientPtr); static void ResetExtension(ExtensionEntry* extEntry) { __glXFlushContextCache(); - (*__glXExt->resetExtension)(); - __glXScreenReset(); + __glXResetScreens(); } /* @@ -158,6 +151,40 @@ static int PixmapGone(__GLXpixmap *pGlxPixmap, XID id) return True; } +/* +** Destroy routine that gets called when a drawable is freed. A drawable +** contains the ancillary buffers needed for rendering. +*/ +static Bool DrawableGone(__GLXdrawable *glxPriv, XID xid) +{ + __GLXcontext *cx, *cx1; + + /* + ** Use glxPriv->type to figure out what kind of drawable this is. Don't + ** use glxPriv->pDraw->type because by the time this routine is called, + ** the pDraw might already have been freed. + */ + if (glxPriv->type == DRAWABLE_WINDOW) { + /* + ** When a window is destroyed, notify all context bound to + ** it, that there are no longer bound to anything. + */ + for (cx = glxPriv->drawGlxc; cx; cx = cx1) { + cx1 = cx->nextDrawPriv; + cx->pendingState |= __GLX_PENDING_DESTROY; + } + + for (cx = glxPriv->readGlxc; cx; cx = cx1) { + cx1 = cx->nextReadPriv; + cx->pendingState |= __GLX_PENDING_DESTROY; + } + } + + __glXUnrefDrawable(glxPriv); + + return True; +} + /* ** Free a context. */ @@ -165,18 +192,24 @@ GLboolean __glXFreeContext(__GLXcontext *cx) { if (cx->idExists || cx->isCurrent) return GL_FALSE; - if (!cx->isDirect) { - if ((*cx->gc->exports.destroyContext)((__GLcontext *)cx->gc) == GL_FALSE) { - return GL_FALSE; - } - } if (cx->feedbackBuf) __glXFree(cx->feedbackBuf); if (cx->selectBuf) __glXFree(cx->selectBuf); - __glXFree(cx); if (cx == __glXLastContext) { __glXFlushContextCache(); } + /* We can get here through both regular dispatching from + * __glXDispatch() or as a callback from the resource manager. In + * the latter case we need to lift the DRI lock manually. */ + + if (!inDispatch) + __glXleaveServer(); + + cx->destroy(cx); + + if (!inDispatch) + __glXenterServer(); + return GL_TRUE; } @@ -240,13 +273,14 @@ void GlxExtensionInit(void) __glXContextRes = CreateNewResourceType((DeleteType)ContextGone); __glXClientRes = CreateNewResourceType((DeleteType)ClientGone); __glXPixmapRes = CreateNewResourceType((DeleteType)PixmapGone); + __glXDrawableRes = CreateNewResourceType((DeleteType)DrawableGone); /* ** Add extension to server extensions. */ extEntry = AddExtension(GLX_EXTENSION_NAME, __GLX_NUMBER_EVENTS, __GLX_NUMBER_ERRORS, __glXDispatch, - __glXSwapDispatch, ResetExtension, + __glXDispatch, ResetExtension, StandardMinorOpcode); if (!extEntry) { FatalError("__glXExtensionInit: AddExtensions failed\n"); @@ -280,53 +314,7 @@ void GlxExtensionInit(void) /* ** Initialize screen specific data. */ - __glXScreenInit(screenInfo.numScreens); -} - -/************************************************************************/ - -Bool __glXCoreType(void) -{ - return __glXExt->type; -} - -/************************************************************************/ - -void GlxSetVisualConfigs(int nconfigs, - __GLXvisualConfig *configs, void **privates) -{ - (*__glXExt->setVisualConfigs)(nconfigs, configs, privates); -} - -static miInitVisualsProcPtr saveInitVisualsProc; - -Bool GlxInitVisuals(VisualPtr *visualp, DepthPtr *depthp, - int *nvisualp, int *ndepthp, - int *rootDepthp, VisualID *defaultVisp, - unsigned long sizes, int bitsPerRGB, - int preferredVis) -{ - Bool ret; - - if (saveInitVisualsProc) { - ret = saveInitVisualsProc(visualp, depthp, nvisualp, ndepthp, - rootDepthp, defaultVisp, sizes, bitsPerRGB, - preferredVis); - if (!ret) - return False; - } - (*__glXExt->initVisuals)(visualp, depthp, nvisualp, ndepthp, rootDepthp, - defaultVisp, sizes, bitsPerRGB); - return True; -} - -void -GlxWrapInitVisuals(miInitVisualsProcPtr *initVisProc) -{ - saveInitVisualsProc = *initVisProc; - *initVisProc = GlxInitVisuals; - /* HACK: this shouldn't be done here but it's the earliest time */ - __glXExt = __glXglDDXExtensionInfo(); /* from GLcore */ + __glXInitScreens(); } /************************************************************************/ @@ -377,7 +365,7 @@ __GLXcontext *__glXForceCurrent(__GLXclientState *cl, GLXContextTag tag, /* Make this context the current one for the GL. */ if (!cx->isDirect) { - if (!(*cx->gc->exports.forceCurrent)((__GLcontext *)cx->gc)) { + if (!(*cx->forceCurrent)(cx)) { /* Bind failed, and set the error code. Bummer */ cl->client->errorValue = cx->id; *error = __glXBadContextState; @@ -390,6 +378,44 @@ __GLXcontext *__glXForceCurrent(__GLXclientState *cl, GLXContextTag tag, /************************************************************************/ +/* +** Top level dispatcher; all commands are executed from here down. +*/ + +/* I cried when I wrote this. Damn you XAA! */ + +static void +__glXnopEnterServer(void) +{ +} + +static void +__glXnopLeaveServer(void) +{ +} + +static void (*__glXenterServerFunc)(void) = __glXnopEnterServer; +static void (*__glXleaveServerFunc)(void) = __glXnopLeaveServer; + +void __glXsetEnterLeaveServerFuncs(void (*enter)(void), + void (*leave)(void)) +{ + __glXenterServerFunc = enter; + __glXleaveServerFunc = leave; +} + + +void __glXenterServer(void) +{ + (*__glXenterServerFunc)(); +} + +void __glXleaveServer(void) +{ + (*__glXleaveServerFunc)(); +} + + /* ** Top level dispatcher; all commands are executed from here down. */ @@ -399,6 +425,7 @@ static int __glXDispatch(ClientPtr client) CARD8 opcode; int (*proc)(__GLXclientState *cl, GLbyte *pc); __GLXclientState *cl; + int retval; opcode = stuff->glxCode; cl = __glXClients[client->index]; @@ -443,54 +470,22 @@ static int __glXDispatch(ClientPtr client) /* ** Use the opcode to index into the procedure table. */ - proc = __glXSingleTable[opcode]; - return (*proc)(cl, (GLbyte *) stuff); -} + if (client->swapped) + proc = __glXSwapSingleTable[opcode]; + else + proc = __glXSingleTable[opcode]; -static int __glXSwapDispatch(ClientPtr client) -{ - REQUEST(xGLXSingleReq); - CARD8 opcode; - int (*proc)(__GLXclientState *cl, GLbyte *pc); - __GLXclientState *cl; + __glXleaveServer(); - opcode = stuff->glxCode; - cl = __glXClients[client->index]; - if (!cl) { - cl = (__GLXclientState *) __glXMalloc(sizeof(__GLXclientState)); - __glXClients[client->index] = cl; - if (!cl) { - return BadAlloc; - } - __glXMemset(cl, 0, sizeof(__GLXclientState)); - } - - if (!cl->inUse) { - /* - ** This is first request from this client. Associate a resource - ** with the client so we will be notified when the client dies. - */ - XID xid = FakeClientID(client->index); - if (!AddResource( xid, __glXClientRes, (pointer)(long)client->index)) { - return BadAlloc; - } - ResetClientState(client->index); - cl->inUse = GL_TRUE; - cl->client = client; - } + inDispatch = True; - /* - ** Check for valid opcode. - */ - if (opcode >= __GLX_SINGLE_TABLE_SIZE) { - return BadRequest; - } + retval = proc(cl, (GLbyte *) stuff); - /* - ** Use the opcode to index into the procedure table. - */ - proc = __glXSwapSingleTable[opcode]; - return (*proc)(cl, (GLbyte *) stuff); + inDispatch = False; + + __glXenterServer(); + + return retval; } int __glXNoSuchSingleOpcode(__GLXclientState *cl, GLbyte *pc) diff --git a/GL/glx/glximports.c b/GL/glx/glximports.c index fae2346b9..a443495c4 100644 --- a/GL/glx/glximports.c +++ b/GL/glx/glximports.c @@ -38,6 +38,10 @@ #include #endif +#include +#include +#include + #include "glxserver.h" #include "glxcontext.h" #include "glximports.h" diff --git a/GL/glx/glxscreens.c b/GL/glx/glxscreens.c index b3d542acc..33bb0fe09 100644 --- a/GL/glx/glxscreens.c +++ b/GL/glx/glxscreens.c @@ -38,14 +38,9 @@ #include #endif -#ifdef IN_MODULE -#include -#else #include -#include -#endif - #include +#include #include "glxserver.h" #include "glxutil.h" @@ -135,6 +130,7 @@ static char GLXServerExtensions[] = "GLX_EXT_visual_info " "GLX_EXT_visual_rating " "GLX_EXT_import_context " + "GLX_EXT_texture_from_pixmap " "GLX_OML_swap_method " "GLX_SGI_make_current_read " #ifndef __DARWIN__ @@ -143,78 +139,19 @@ static char GLXServerExtensions[] = "GLX_SGIX_swap_barrier " #endif "GLX_SGIX_fbconfig " - "GLX_EXT_texture_from_pixmap " ; -/* - * __glDDXScreenInfo comes from GLcore, so we can't resolve this symbol at - * module open time. Leave a placeholder, and fill this in when we first - * need it (in __glXScreenInit). XXX Why make this an array? - */ -static __GLXscreenInfo *__glXScreens[] = { - NULL /* &__glDDXScreenInfo */ , -}; - -static GLint __glXNumStaticScreens = - (sizeof __glXScreens / sizeof __glXScreens[0]); - -__GLXscreenInfo *__glXActiveScreens; -GLint __glXNumActiveScreens; +__GLXscreen **__glXActiveScreens; __GLXSwapBarrierExtensionFuncs *__glXSwapBarrierFuncs = NULL; static int __glXNumSwapBarrierFuncs = 0; __GLXHyperpipeExtensionFuncs *__glXHyperpipeFuncs = NULL; static int __glXNumHyperpipeFuncs = 0; - -RESTYPE __glXDrawableRes; - -__GLXscreenInfo *__glXgetActiveScreen(int num) { - return &__glXActiveScreens[num]; +__GLXscreen *__glXgetActiveScreen(int num) { + return __glXActiveScreens[num]; } -/* -** Destroy routine that gets called when a drawable is freed. A drawable -** contains the ancillary buffers needed for rendering. -*/ -static Bool DrawableGone(__GLXdrawablePrivate *glxPriv, XID xid) -{ - __GLXcontext *cx, *cx1; - - /* - ** Use glxPriv->type to figure out what kind of drawable this is. Don't - ** use glxPriv->pDraw->type because by the time this routine is called, - ** the pDraw might already have been freed. - */ - if (glxPriv->type == DRAWABLE_WINDOW) { - /* - ** When a window is destroyed, notify all context bound to - ** it, that there are no longer bound to anything. - */ - for (cx = glxPriv->drawGlxc; cx; cx = cx1) { - cx1 = cx->nextDrawPriv; - cx->pendingState |= __GLX_PENDING_DESTROY; - } - - for (cx = glxPriv->readGlxc; cx; cx = cx1) { - cx1 = cx->nextReadPriv; - cx->pendingState |= __GLX_PENDING_DESTROY; - } - } - - /* - ** set the size to 0, so that context that may still be using this - ** drawable not do anything harmful - */ - glxPriv->xorigin = 0; - glxPriv->yorigin = 0; - glxPriv->width = 0; - glxPriv->height = 0; - - __glXUnrefDrawablePrivate(glxPriv); - - return True; -} /* ** This hook gets called when a window moves or changes size. @@ -223,7 +160,7 @@ static Bool PositionWindow(WindowPtr pWin, int x, int y) { ScreenPtr pScreen; __GLXcontext *glxc; - __GLXdrawablePrivate *glxPriv; + __GLXdrawable *glxPriv; Bool ret; /* @@ -231,7 +168,7 @@ static Bool PositionWindow(WindowPtr pWin, int x, int y) */ pScreen = pWin->drawable.pScreen; pScreen->PositionWindow = - __glXActiveScreens[pScreen->myNum].WrappedPositionWindow; + __glXActiveScreens[pScreen->myNum]->WrappedPositionWindow; ret = (*pScreen->PositionWindow)(pWin, x, y); pScreen->PositionWindow = PositionWindow; @@ -239,8 +176,8 @@ static Bool PositionWindow(WindowPtr pWin, int x, int y) ** Tell all contexts rendering into this window that the window size ** has changed. */ - glxPriv = (__GLXdrawablePrivate *) LookupIDByType(pWin->drawable.id, - __glXDrawableRes); + glxPriv = (__GLXdrawable *) LookupIDByType(pWin->drawable.id, + __glXDrawableRes); if (glxPriv == NULL) { /* ** This window is not being used by the OpenGL. @@ -252,7 +189,7 @@ static Bool PositionWindow(WindowPtr pWin, int x, int y) ** resize the drawable */ /* first change the drawable size */ - if (__glXResizeDrawableBuffers(glxPriv) == GL_FALSE) { + if (glxPriv->resize(glxPriv) == GL_FALSE) { /* resize failed! */ /* XXX: what can we possibly do here? */ ret = False; @@ -271,18 +208,6 @@ static Bool PositionWindow(WindowPtr pWin, int x, int y) return ret; } -/* -** Wrap our own PositionWindow routine around the server's, so we can -** be notified when a window changes size -*/ -static void wrapPositionWindow(int screen) -{ - ScreenPtr pScreen = screenInfo.screens[screen]; - - __glXActiveScreens[screen].WrappedPositionWindow = pScreen->PositionWindow; - pScreen->PositionWindow = PositionWindow; -} - /* * If your DDX driver wants to register support for swap barriers or hyperpipe * topology, it should call __glXHyperpipeInit() or __glXSwapBarrierInit() @@ -326,57 +251,80 @@ void __glXSwapBarrierInit(int screen, __GLXSwapBarrierExtensionFuncs *funcs) funcs->queryMaxSwapBarriersFunc; } -void __glXScreenInit(GLint numscreens) -{ - GLint i,j; +static __GLXprovider *__glXProviderStack; - __glXScreens[0] = __glXglDDXScreenInfo(); /* from GLcore */ +void GlxPushProvider(__GLXprovider *provider) +{ + provider->next = __glXProviderStack; + __glXProviderStack = provider; +} + +void __glXScreenInit(__GLXscreen *screen, ScreenPtr pScreen) +{ + screen->pScreen = pScreen; + screen->GLextensions = __glXStrdup(GLServerExtensions); + screen->GLXvendor = __glXStrdup(GLXServerVendorName); + screen->GLXversion = __glXStrdup(GLXServerVersion); + screen->GLXextensions = __glXStrdup(GLXServerExtensions); + + screen->WrappedPositionWindow = pScreen->PositionWindow; + pScreen->PositionWindow = PositionWindow; + + __glXScreenInitVisuals(screen); +} + +void +__glXScreenDestroy(__GLXscreen *screen) +{ + __glXFree(screen->GLXvendor); + __glXFree(screen->GLXversion); + __glXFree(screen->GLXextensions); + __glXFree(screen->GLextensions); +} + +void __glXInitScreens(void) +{ + GLint i; + ScreenPtr pScreen; + __GLXprovider *p; + size_t size; /* ** This alloc has to work or else the server might as well core dump. */ - __glXActiveScreens = - (__GLXscreenInfo *) __glXMalloc(sizeof(__GLXscreenInfo) * numscreens); + size = screenInfo.numScreens * sizeof(__GLXscreen *); + __glXActiveScreens =__glXMalloc(size); + __glXMemset(__glXActiveScreens, 0, size); - for (i=0; i < numscreens; i++) { - /* - ** Probe each static screen to see which exists. - */ - for (j=0; j < __glXNumStaticScreens; j++) { - if ((*__glXScreens[j]->screenProbe)(i)) { - __glXActiveScreens[i] = *__glXScreens[j]; + for (i = 0; i < screenInfo.numScreens; i++) { + pScreen = screenInfo.screens[i]; - __glXActiveScreens[i].numUsableVisuals = __glXActiveScreens[i].numVisuals; - __glXActiveScreens[i].GLextensions = __glXStrdup(GLServerExtensions); - __glXActiveScreens[i].GLXvendor = __glXStrdup(GLXServerVendorName); - __glXActiveScreens[i].GLXversion = __glXStrdup(GLXServerVersion); - __glXActiveScreens[i].GLXextensions = __glXStrdup(GLXServerExtensions); - - __glXDrawableRes = CreateNewResourceType((DeleteType)DrawableGone); - wrapPositionWindow(i); + for (p = __glXProviderStack; p != NULL; p = p->next) { + __glXActiveScreens[i] = p->screenProbe(pScreen); + if (__glXActiveScreens[i] != NULL) { + LogMessage(X_INFO, + "GLX: Initialized %s GL provider for screen %d\n", + p->name, i); + break; } } } - __glXNumActiveScreens = numscreens; } -void __glXScreenReset(void) +void __glXResetScreens(void) { int i; - for (i = 0; i < __glXNumActiveScreens; i++) { - __glXFree(__glXActiveScreens[i].GLXvendor); - __glXFree(__glXActiveScreens[i].GLXversion); - __glXFree(__glXActiveScreens[i].GLXextensions); - __glXFree(__glXActiveScreens[i].GLextensions); - } - xfree(__glXActiveScreens); - xfree(__glXHyperpipeFuncs); - xfree(__glXSwapBarrierFuncs); - __glXNumHyperpipeFuncs = 0; - __glXNumSwapBarrierFuncs = 0; - __glXHyperpipeFuncs = NULL; - __glXSwapBarrierFuncs = NULL; - __glXActiveScreens = NULL; - __glXNumActiveScreens = 0; + for (i = 0; i < screenInfo.numScreens; i++) + if (__glXActiveScreens[i]) + __glXActiveScreens[i]->destroy(__glXActiveScreens[i]); + + __glXFree(__glXActiveScreens); + __glXFree(__glXHyperpipeFuncs); + __glXFree(__glXSwapBarrierFuncs); + __glXNumHyperpipeFuncs = 0; + __glXNumSwapBarrierFuncs = 0; + __glXHyperpipeFuncs = NULL; + __glXSwapBarrierFuncs = NULL; + __glXActiveScreens = NULL; } diff --git a/GL/glx/glxscreens.h b/GL/glx/glxscreens.h index 2d68c8b60..019170f19 100644 --- a/GL/glx/glxscreens.h +++ b/GL/glx/glxscreens.h @@ -51,28 +51,25 @@ ** and DDX layers of the GLX server extension. The methods provide an ** interface for context management on a screen. */ -typedef struct { - /* - ** Probe the screen and see if it supports GL rendering. It will - ** return GL_FALSE if it doesn't, GL_TRUE otherwise. - */ - Bool (*screenProbe)(int screen); - /* - ** Create a context using configuration information from modes. - ** Use imports as callbacks back to the OS. Return an opaque handle - ** on the context (NULL if failure). - */ - __GLinterface *(*createContext)(__GLimports *imports, - __GLcontextModes *modes, - __GLinterface *shareGC); +typedef struct __GLXscreen __GLXscreen; +typedef struct __GLXtextureFromPixmapScreen __GLXtextureFromPixmapScreen; - /* - ** Create a buffer using information from glxPriv. This routine - ** sets up any wrappers necessary to resize, swap or destroy the - ** buffer. - */ - void (*createBuffer)(__GLXdrawablePrivate *glxPriv); +#include "glxdrawable.h" + +struct __GLXtextureFromPixmapScreen { + int (*getTexTarget) (__GLXscreen *screen, + __GLXpixmap *pixmap); +}; + +struct __GLXscreen { + void (*destroy)(__GLXscreen *screen); + + __GLXcontext *(*createContext)(__GLXscreen *screen, + __GLcontextModes *modes, + __GLXcontext *shareContext); + + ScreenPtr pScreen; /** * Linked list of valid context modes for this screen. @@ -94,10 +91,14 @@ typedef struct { */ Bool (*WrappedPositionWindow)(WindowPtr pWin, int x, int y); -} __GLXscreenInfo; + __GLXtextureFromPixmapScreen *textureFromPixmap; +}; -extern void __glXScreenInit(GLint); -extern void __glXScreenReset(void); +void __glXScreenInit(__GLXscreen *screen, ScreenPtr pScreen); +void __glXScreenDestroy(__GLXscreen *screen); + +void __glXInitScreens(void); +extern void __glXResetScreens(void); #endif /* !__GLX_screens_h__ */ diff --git a/GL/glx/glxserver.h b/GL/glx/glxserver.h index f6eec3864..485b448f3 100644 --- a/GL/glx/glxserver.h +++ b/GL/glx/glxserver.h @@ -53,7 +53,6 @@ #include #include "GL/glx_ansic.h" - /* ** The X header misc.h defines these math functions. */ @@ -65,17 +64,9 @@ #include #include -/* XXX: should go into glxext.h */ -#ifndef GLX_EXT_render_texture -#define GLX_TEXTURE_TARGET_EXT 0x6001 -#define GLX_TEXTURE_2D_EXT 0x6002 -#define GLX_TEXTURE_RECTANGLE_EXT 0x6003 -#define GLX_NO_TEXTURE_EXT 0x6004 -#define GLX_FRONT_LEFT_EXT 0x6005 -#endif - /* For glxscreens.h */ -typedef struct __GLXdrawablePrivateRec __GLXdrawablePrivate; +typedef struct __GLXdrawable __GLXdrawable; +typedef struct __GLXcontext __GLXcontext; #include "glxscreens.h" #include "glxdrawable.h" @@ -100,15 +91,19 @@ typedef XID GLXContextID; typedef XID GLXPixmap; typedef XID GLXDrawable; -typedef struct __GLXcontextRec *GLXContext; typedef struct __GLXclientStateRec __GLXclientState; -extern __GLXscreenInfo *__glXActiveScreens; +extern __GLXscreen **__glXActiveScreens; extern GLint __glXNumActiveScreens; -extern __GLXscreenInfo *__glXgetActiveScreen(int num); +extern __GLXscreen *__glXgetActiveScreen(int num); /************************************************************************/ +void GlxSetVisualConfigs(int nconfigs, + __GLXvisualConfig *configs, void **privates); + +void __glXScreenInitVisuals(__GLXscreen *screen); + /* ** The last context used (from the server's persective) is cached. */ @@ -125,6 +120,20 @@ extern __GLXcontext *__glXForceCurrent(__GLXclientState*, GLXContextTag, int*); /************************************************************************/ +typedef struct __GLXprovider __GLXprovider; +struct __GLXprovider { + __GLXscreen *(*screenProbe)(ScreenPtr pScreen); + const char *name; + __GLXprovider *next; +}; + +void GlxPushProvider(__GLXprovider *provider); + +void __glXsetEnterLeaveServerFuncs(void (*enter)(void), + void (*leave)(void)); +void __glXenterServer(void); +void __glXleaveServer(void); + /* ** State kept per client. */ @@ -230,6 +239,8 @@ extern void __glXSwapQueryVersionReply(ClientPtr client, extern void __glXSwapQueryContextInfoEXTReply(ClientPtr client, xGLXQueryContextInfoEXTReply *reply, int *buf); +extern void __glXSwapGetDrawableAttributesReply(ClientPtr client, + xGLXGetDrawableAttributesReply *reply, CARD32 *buf); extern void glxSwapQueryExtensionsStringReply(ClientPtr client, xGLXQueryExtensionsStringReply *reply, char *buf); extern void glxSwapQueryServerStringReply(ClientPtr client, diff --git a/GL/glx/glxutil.c b/GL/glx/glxutil.c index 32d1ad47d..36ffd27eb 100644 --- a/GL/glx/glxutil.c +++ b/GL/glx/glxutil.c @@ -40,13 +40,14 @@ #include #endif +#include + #include "glxserver.h" #include #include #include #include #include "glxutil.h" -#include "glxbuf.h" #include "GL/glx_ansic.h" #include "GL/internal/glcore.h" #include "GL/glxint.h" @@ -54,10 +55,6 @@ /************************************************************************/ -void __glXNop(void) {} - -/************************************************************************/ - /* Memory Allocation for GLX */ void * @@ -91,7 +88,7 @@ __glXCalloc(size_t numElements, size_t elementSize) /* XXX: handle out of memory error */ return NULL; } - __glXMemset(addr, 0, size); + memset(addr, 0, size); return addr; } @@ -142,13 +139,13 @@ __glXAssociateContext(__GLXcontext *glxc) glxc->nextDrawPriv = glxc->drawPriv->drawGlxc; glxc->drawPriv->drawGlxc = glxc; - __glXRefDrawablePrivate(glxc->drawPriv); + __glXRefDrawable(glxc->drawPriv); glxc->nextReadPriv = glxc->readPriv->readGlxc; glxc->readPriv->readGlxc = glxc; - __glXRefDrawablePrivate(glxc->readPriv); + __glXRefDrawable(glxc->readPriv); } /* @@ -171,7 +168,7 @@ __glXDeassociateContext(__GLXcontext *glxc) prev->nextDrawPriv = curr->nextDrawPriv; } curr->nextDrawPriv = NULL; - __glXUnrefDrawablePrivate(glxc->drawPriv); + __glXUnrefDrawable(glxc->drawPriv); break; } } @@ -189,330 +186,76 @@ __glXDeassociateContext(__GLXcontext *glxc) prev->nextReadPriv = curr->nextReadPriv; } curr->nextReadPriv = NULL; - __glXUnrefDrawablePrivate(glxc->readPriv); + __glXUnrefDrawable(glxc->readPriv); break; } } } -/************************************************************************/ - -void -__glXGetDrawableSize(__GLdrawablePrivate *glPriv, - GLint *x, GLint *y, GLuint *width, GLuint *height) -{ - __GLXdrawablePrivate *glxPriv = (__GLXdrawablePrivate *)glPriv->other; - - if (glxPriv) { - *x = glxPriv->xorigin; - *y = glxPriv->yorigin; - *width = glxPriv->width; - *height = glxPriv->height; - } else { - *x = *y = *width = *height = 0; - } -} - -GLboolean -__glXResizeDrawable(__GLdrawablePrivate *glPriv) -{ - /* nothing to be done here */ - return GL_TRUE; -} - - -/*****************************************************************************/ -/* accessing the drawable private */ - -static void -LockDP(__GLdrawablePrivate *glPriv, __GLcontext *gc) -{ - __GLinterface *glci = (__GLinterface *) gc; - __GLXcontext *glxc = (__GLXcontext *) glci->imports.other; - - /* quick exit test */ - if ((glxc->pendingState & - (__GLX_PENDING_RESIZE | - __GLX_PENDING_DESTROY | - __GLX_PENDING_SWAP)) == 0x0) - return; - - /* some pending state. Deal with it */ - if (glxc->pendingState & __GLX_PENDING_RESIZE) { - glxc->pendingState &= ~__GLX_PENDING_RESIZE; - - (*glci->exports.notifyResize)(gc); - assert((glxc->pendingState & __GLX_PENDING_RESIZE) == 0x0); - } - if (glxc->pendingState & __GLX_PENDING_DESTROY) { - glxc->pendingState &= ~__GLX_PENDING_DESTROY; - - assert(glxc->drawPriv->xorigin == 0); - assert(glxc->drawPriv->yorigin == 0); - assert(glxc->drawPriv->width == 0); - assert(glxc->drawPriv->height == 0); - assert(glxc->readPriv->xorigin == 0); - assert(glxc->readPriv->yorigin == 0); - assert(glxc->readPriv->width == 0); - assert(glxc->readPriv->height == 0); - (*glci->exports.notifyDestroy)(gc); - __glXDeassociateContext(glxc); - assert((glxc->pendingState & __GLX_PENDING_DESTROY) == 0x0); - } - if (glxc->pendingState & __GLX_PENDING_SWAP) { - - glxc->pendingState &= ~__GLX_PENDING_SWAP; - - (*glci->exports.notifySwapBuffers)(gc); - assert((glxc->pendingState & __GLX_PENDING_SWAP) == 0x0); - } -} - -static void -UnlockDP(__GLdrawablePrivate *glPriv) -{ -} - /*****************************************************************************/ /* Drawable private stuff */ void -__glXRefDrawablePrivate(__GLXdrawablePrivate *glxPriv) +__glXRefDrawable(__GLXdrawable *glxPriv) { glxPriv->refCount++; } void -__glXUnrefDrawablePrivate(__GLXdrawablePrivate *glxPriv) +__glXUnrefDrawable(__GLXdrawable *glxPriv) { glxPriv->refCount--; if (glxPriv->refCount == 0) { - __glXDestroyDrawablePrivate(glxPriv); + /* remove the drawable from the drawable list */ + FreeResourceByType(glxPriv->drawId, __glXDrawableRes, FALSE); + glxPriv->destroy(glxPriv); } } -__GLXdrawablePrivate * -__glXCreateDrawablePrivate(DrawablePtr pDraw, XID drawId, - __GLcontextModes *modes) -{ - __GLXdrawablePrivate *glxPriv; - __GLdrawablePrivate *glPriv; - __GLXscreenInfo *pGlxScreen; - - glxPriv = (__GLXdrawablePrivate *) __glXMalloc(sizeof(*glxPriv)); - __glXMemset(glxPriv, 0, sizeof(__GLXdrawablePrivate)); - - glxPriv->type = pDraw->type; - glxPriv->pDraw = pDraw; - glxPriv->drawId = drawId; - - /* if not a pixmap, lookup will fail, so pGlxPixmap will be NULL */ - glxPriv->pGlxPixmap = (__GLXpixmap *) - LookupIDByType(drawId, __glXPixmapRes); - /* since we are creating the drawablePrivate, drawId should be new */ - if (!AddResource(drawId, __glXDrawableRes, glxPriv)) { - /* oops! */ - __glXFree(glxPriv); - return NULL; - } - - /* fill up glPriv */ - glPriv = &glxPriv->glPriv; - glPriv->modes = (__GLcontextModes *) __glXMalloc(sizeof(__GLcontextModes)); - *glPriv->modes = *modes; - glPriv->malloc = __glXMalloc; - glPriv->calloc = __glXCalloc; - glPriv->realloc = __glXRealloc; - glPriv->free = __glXFree; - glPriv->addSwapRect = NULL; - glPriv->setClipRect = (void (*)(__GLdrawablePrivate *, GLint, GLint, GLsizei, GLsizei)) __glXNop; - glPriv->lockDP = LockDP; - glPriv->unlockDP = UnlockDP; - glPriv->getDrawableSize = __glXGetDrawableSize; - glPriv->resize = __glXResizeDrawable; - glPriv->other = glxPriv; - - /* allocate a one-rect ownership region */ - glPriv->ownershipRegion.rects = - (__GLregionRect *)__glXCalloc(1, sizeof(__GLregionRect)); - glPriv->ownershipRegion.numRects = 1; - - glxPriv->freeBuffers = __glXFreeBuffers; - glxPriv->updatePalette = (void (*)(__GLXdrawablePrivate *)) __glXNop; - - pGlxScreen = &__glXActiveScreens[pDraw->pScreen->myNum]; - - if (glxPriv->type == DRAWABLE_WINDOW) { - VisualID vid = wVisual((WindowPtr)pDraw); - - glxPriv->modes = _gl_context_modes_find_visual( pGlxScreen->modes, vid ); - __glXFBInitDrawable(glxPriv, modes); - } else { - glxPriv->modes = glxPriv->pGlxPixmap->modes; - __glXPixInitDrawable(glxPriv, modes); - } - - /* initialize the core's private buffer information */ - (*pGlxScreen->createBuffer)(glxPriv); - - return glxPriv; -} - GLboolean -__glXDestroyDrawablePrivate(__GLXdrawablePrivate *glxPriv) +__glXDrawableInit(__GLXdrawable *drawable, + __GLXcontext *ctx, DrawablePtr pDraw, XID drawId) { - __GLdrawablePrivate *glPriv = &glxPriv->glPriv; + drawable->type = pDraw->type; + drawable->pDraw = pDraw; + drawable->drawId = drawId; + drawable->refCount = 1; - /* remove the drawable from the drawable list */ - FreeResourceByType(glxPriv->drawId, __glXDrawableRes, FALSE); - - /* Have the core free any memory it may have attached to the drawable */ - if (glPriv->freePrivate) { - (*glPriv->freePrivate)(glPriv); - } - - /* Free any framebuffer memory attached to the drawable */ - if (glxPriv->freeBuffers) { - (*glxPriv->freeBuffers)(glxPriv); - } - - /* Free the drawable Private */ - __glXFree(glxPriv->glPriv.modes); - __glXFree(glxPriv->glPriv.ownershipRegion.rects); - __glXFree(glxPriv); + /* if not a pixmap, lookup will fail, so pGlxPixmap will be NULL */ + drawable->pGlxPixmap = (__GLXpixmap *) + LookupIDByType(drawId, __glXPixmapRes); return GL_TRUE; } -__GLXdrawablePrivate * -__glXFindDrawablePrivate(XID drawId) +__GLXdrawable * +__glXFindDrawable(XID drawId) { - __GLXdrawablePrivate *glxPriv; + __GLXdrawable *glxPriv; - glxPriv = (__GLXdrawablePrivate *)LookupIDByType(drawId, __glXDrawableRes); + glxPriv = (__GLXdrawable *)LookupIDByType(drawId, __glXDrawableRes); return glxPriv; } -__GLXdrawablePrivate * -__glXGetDrawablePrivate(DrawablePtr pDraw, XID drawId, - __GLcontextModes *modes) +__GLXdrawable * +__glXGetDrawable(__GLXcontext *ctx, DrawablePtr pDraw, XID drawId) { - __GLXdrawablePrivate *glxPriv; + __GLXdrawable *glxPriv; - glxPriv = __glXFindDrawablePrivate(drawId); + glxPriv = __glXFindDrawable(drawId); - if (glxPriv == NULL) { - glxPriv = __glXCreateDrawablePrivate(pDraw, drawId, modes); - if (glxPriv) { - __glXRefDrawablePrivate(glxPriv); + if (glxPriv == NULL) + { + glxPriv = ctx->createDrawable(ctx, pDraw, drawId); + + /* since we are creating the drawablePrivate, drawId should be new */ + if (!AddResource(drawId, __glXDrawableRes, glxPriv)) + { + glxPriv->destroy (glxPriv); + return NULL; } } return glxPriv; } - -void -__glXCacheDrawableSize(__GLXdrawablePrivate *glxPriv) -{ - if (glxPriv) { - if (glxPriv->pDraw) { - glxPriv->xorigin = glxPriv->pDraw->x; - glxPriv->yorigin = glxPriv->pDraw->y; - glxPriv->width = glxPriv->pDraw->width; - glxPriv->height = glxPriv->pDraw->height; - } - } -} - -/* -** resize/move the drawable. Called during the actual resize callback -** to update the drawable side of the buffers -*/ -GLboolean -__glXResizeDrawableBuffers(__GLXdrawablePrivate *glxPriv) -{ - __GLdrawablePrivate *glPriv = &glxPriv->glPriv; - GLint x, y; - GLuint w, h; -#if defined(__GL_ALIGNED_BUFFERS) - GLint xAlignment, yAlignment; - GLint xOffset, yOffset; - GLint xStart, xEnd; - GLint yStart, yEnd; - GLuint xAlignedMask, yAlignedMask; -#endif - GLboolean status = GL_TRUE; - - __glXCacheDrawableSize(glxPriv); - - w = glxPriv->width; - h = glxPriv->height; - x = glxPriv->xorigin; - y = glxPriv->yorigin; - -#if defined(__GL_ALIGNED_BUFFERS) - xAlignment = glPriv->xAlignment; - yAlignment = glPriv->yAlignment; - - xOffset = x & (xAlignment-1); - yOffset = y & (yAlignment-1); - - xAlignedMask = ~(xAlignment-1); - yAlignedMask = ~(yAlignment-1); - - xStart = x; xEnd = x+w; - yStart = y; yEnd = y+h; - - xStart &= xAlignedMask; - if (xEnd & ~xAlignedMask) { - xEnd = (xEnd&xAlignedMask) + xAlignment; - } - yStart &= yAlignedMask; - if (yEnd & ~yAlignedMask) { - yEnd = (yEnd&yAlignedMask) + yAlignment; - } - - x = xStart; y = yStart; - w = xEnd-xStart; h = yEnd-yStart; -#endif - - if ((x != glPriv->xOrigin) || - (y != glPriv->yOrigin) || -#if defined(__GL_ALIGNED_BUFFERS) - (xOffset != glPriv->xOffset) || - (yOffset != glPriv->yOffset) || -#endif - (w != glPriv->width) || - (h != glPriv->height) || - (!w && !h)) { - /* set up the glPriv info */ - glPriv->width = w; - glPriv->height = h; - glPriv->xOrigin = x; - glPriv->yOrigin = y; -#if defined(__GL_ALIGNED_BUFFERS) - glPriv->xOffset = xOffset; - glPriv->yOffset = yOffset; -#endif - - /* notify the buffers */ - status = __glXResizeBuffers(glPriv, x, y, w, h); - } - - return status; -} - -/************************************************************************/ - -GLuint __glFloorLog2(GLuint val) -{ - int c = 0; - - while (val > 1) { - c++; - val >>= 1; - } - return c; -} - diff --git a/GL/glx/glxutil.h b/GL/glx/glxutil.h index 2c3090a46..07384bf76 100644 --- a/GL/glx/glxutil.h +++ b/GL/glx/glxutil.h @@ -58,20 +58,23 @@ extern void __glXGetDrawableSize(__GLdrawablePrivate *glPriv, GLint *x, GLint *y, GLuint *width, GLuint *height); extern GLboolean __glXResizeDrawable(__GLdrawablePrivate *glPriv); -extern GLboolean __glXResizeDrawableBuffers(__GLXdrawablePrivate *glxPriv); +extern GLboolean __glXResizeDrawableBuffers(__GLXdrawable *glxPriv); /* drawable management */ -extern void __glXRefDrawablePrivate(__GLXdrawablePrivate *glxPriv); -extern void __glXUnrefDrawablePrivate(__GLXdrawablePrivate *glxPriv); -extern __GLXdrawablePrivate *__glXCreateDrawablePrivate(DrawablePtr pDraw, - XID glxpixmapId, - __GLcontextModes *modes); -extern GLboolean __glXDestroyDrawablePrivate(__GLXdrawablePrivate *glxPriv); -extern __GLXdrawablePrivate *__glXFindDrawablePrivate(XID glxpixmapId); -extern __GLXdrawablePrivate *__glXGetDrawablePrivate(DrawablePtr pDraw, - XID glxpixmapId, - __GLcontextModes *modes); -extern void __glXCacheDrawableSize(__GLXdrawablePrivate *glxPriv); +extern void __glXRefDrawable(__GLXdrawable *glxPriv); +extern void __glXUnrefDrawable(__GLXdrawable *glxPriv); + +extern __GLXdrawable *__glXCreateDrawable(__GLXcontext *ctx, + DrawablePtr pDraw, + XID glxpixmapId); +extern GLboolean __glXDrawableInit(__GLXdrawable *drawable, __GLXcontext *ctx, + DrawablePtr pDraw, XID drawID); +extern GLboolean __glXDestroyDrawable(__GLXdrawable *glxPriv); +extern __GLXdrawable *__glXFindDrawable(XID glxpixmapId); +extern __GLXdrawable *__glXGetDrawable(__GLXcontext *ctx, + DrawablePtr pDraw, + XID glxpixmapId); +extern void __glXCacheDrawableSize(__GLXdrawable *glxPriv); /* context helper routines */ extern __GLXcontext *__glXLookupContextByTag(__GLXclientState*, GLXContextTag); diff --git a/GL/glx/glxvisuals.c b/GL/glx/glxvisuals.c new file mode 100644 index 000000000..637ffaa62 --- /dev/null +++ b/GL/glx/glxvisuals.c @@ -0,0 +1,529 @@ +/* + * Copyright © 2006 Red Hat, Inc. + * (C) Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas. + * 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sub license, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * RED HAT, INC, OR PRECISION INSIGHT AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT + * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR + * THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/* + * Authors: + * Kevin E. Martin + * Brian Paul + * Kristian Høgsberg + * + */ + +#ifdef HAVE_DIX_CONFIG_H +#include +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +void GlxWrapInitVisuals(miInitVisualsProcPtr *); + +#include "glcontextmodes.h" + +struct ScreenVisualsRec { + int num_vis; + void *private; + __GLcontextModes *modes; +}; +typedef struct ScreenVisualsRec ScreenVisuals; + +static ScreenVisuals screenVisuals[MAXSCREENS]; + +static int numConfigs = 0; +static __GLXvisualConfig *visualConfigs = NULL; +static void **visualPrivates = NULL; + +static int count_bits(unsigned int n) +{ + int bits = 0; + + while (n > 0) { + if (n & 1) bits++; + n >>= 1; + } + return bits; +} + +/* + * In the case the driver defines no GLX visuals we'll use these. + * Note that for TrueColor and DirectColor visuals, bufferSize is the + * sum of redSize, greenSize, blueSize and alphaSize, which may be larger + * than the nplanes/rootDepth of the server's X11 visuals + */ +#define NUM_FALLBACK_CONFIGS 5 +static __GLXvisualConfig FallbackConfigs[NUM_FALLBACK_CONFIGS] = { + /* [0] = RGB, double buffered, Z */ + { + -1, /* vid */ + -1, /* class */ + True, /* rgba */ + -1, -1, -1, 0, /* rgba sizes */ + -1, -1, -1, 0, /* rgba masks */ + 0, 0, 0, 0, /* rgba accum sizes */ + True, /* doubleBuffer */ + False, /* stereo */ + -1, /* bufferSize */ + 16, /* depthSize */ + 0, /* stencilSize */ + 0, /* auxBuffers */ + 0, /* level */ + GLX_NONE, /* visualRating */ + GLX_NONE, /* transparentPixel */ + 0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */ + 0 /* transparentIndex */ + }, + /* [1] = RGB, double buffered, Z, stencil, accum */ + { + -1, /* vid */ + -1, /* class */ + True, /* rgba */ + -1, -1, -1, 0, /* rgba sizes */ + -1, -1, -1, 0, /* rgba masks */ + 16, 16, 16, 0, /* rgba accum sizes */ + True, /* doubleBuffer */ + False, /* stereo */ + -1, /* bufferSize */ + 16, /* depthSize */ + 8, /* stencilSize */ + 0, /* auxBuffers */ + 0, /* level */ + GLX_NONE, /* visualRating */ + GLX_NONE, /* transparentPixel */ + 0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */ + 0 /* transparentIndex */ + }, + /* [2] = RGB+Alpha, double buffered, Z, stencil, accum */ + { + -1, /* vid */ + -1, /* class */ + True, /* rgba */ + -1, -1, -1, 8, /* rgba sizes */ + -1, -1, -1, -1, /* rgba masks */ + 16, 16, 16, 16, /* rgba accum sizes */ + True, /* doubleBuffer */ + False, /* stereo */ + -1, /* bufferSize */ + 16, /* depthSize */ + 8, /* stencilSize */ + 0, /* auxBuffers */ + 0, /* level */ + GLX_NONE, /* visualRating */ + GLX_NONE, /* transparentPixel */ + 0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */ + 0 /* transparentIndex */ + }, + /* [3] = RGB+Alpha, single buffered, Z, stencil, accum */ + { + -1, /* vid */ + -1, /* class */ + True, /* rgba */ + -1, -1, -1, 8, /* rgba sizes */ + -1, -1, -1, -1, /* rgba masks */ + 16, 16, 16, 16, /* rgba accum sizes */ + False, /* doubleBuffer */ + False, /* stereo */ + -1, /* bufferSize */ + 16, /* depthSize */ + 8, /* stencilSize */ + 0, /* auxBuffers */ + 0, /* level */ + GLX_NONE, /* visualRating */ + GLX_NONE, /* transparentPixel */ + 0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */ + 0 /* transparentIndex */ + }, + /* [4] = CI, double buffered, Z */ + { + -1, /* vid */ + -1, /* class */ + False, /* rgba? (false = color index) */ + -1, -1, -1, 0, /* rgba sizes */ + -1, -1, -1, 0, /* rgba masks */ + 0, 0, 0, 0, /* rgba accum sizes */ + True, /* doubleBuffer */ + False, /* stereo */ + -1, /* bufferSize */ + 16, /* depthSize */ + 0, /* stencilSize */ + 0, /* auxBuffers */ + 0, /* level */ + GLX_NONE, /* visualRating */ + GLX_NONE, /* transparentPixel */ + 0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */ + 0 /* transparentIndex */ + }, +}; + + +static Bool init_visuals(int *nvisualp, VisualPtr *visualp, + VisualID *defaultVisp, + int ndepth, DepthPtr pdepth, + int rootDepth) +{ + int numRGBconfigs; + int numCIconfigs; + int numVisuals = *nvisualp; + int numNewVisuals; + int numNewConfigs; + VisualPtr pVisual = *visualp; + VisualPtr pVisualNew = NULL; + VisualID *orig_vid = NULL; + __GLcontextModes *modes; + __GLXvisualConfig *pNewVisualConfigs = NULL; + void **glXVisualPriv; + void **pNewVisualPriv; + int found_default; + int i, j, k; + + if (numConfigs > 0) + numNewConfigs = numConfigs; + else + numNewConfigs = NUM_FALLBACK_CONFIGS; + + /* Alloc space for the list of new GLX visuals */ + pNewVisualConfigs = (__GLXvisualConfig *) + __glXMalloc(numNewConfigs * sizeof(__GLXvisualConfig)); + if (!pNewVisualConfigs) { + return FALSE; + } + + /* Alloc space for the list of new GLX visual privates */ + pNewVisualPriv = (void **) __glXMalloc(numNewConfigs * sizeof(void *)); + if (!pNewVisualPriv) { + __glXFree(pNewVisualConfigs); + return FALSE; + } + + /* + ** If SetVisualConfigs was not called, then use default GLX + ** visual configs. + */ + if (numConfigs == 0) { + memcpy(pNewVisualConfigs, FallbackConfigs, + NUM_FALLBACK_CONFIGS * sizeof(__GLXvisualConfig)); + memset(pNewVisualPriv, 0, NUM_FALLBACK_CONFIGS * sizeof(void *)); + } + else { + /* copy driver's visual config info */ + for (i = 0; i < numConfigs; i++) { + pNewVisualConfigs[i] = visualConfigs[i]; + pNewVisualPriv[i] = visualPrivates[i]; + } + } + + /* Count the number of RGB and CI visual configs */ + numRGBconfigs = 0; + numCIconfigs = 0; + for (i = 0; i < numNewConfigs; i++) { + if (pNewVisualConfigs[i].rgba) + numRGBconfigs++; + else + numCIconfigs++; + } + + /* Count the total number of visuals to compute */ + numNewVisuals = 0; + for (i = 0; i < numVisuals; i++) { + numNewVisuals += + (pVisual[i].class == TrueColor || pVisual[i].class == DirectColor) + ? numRGBconfigs : numCIconfigs; + } + + /* Reset variables for use with the next screen/driver's visual configs */ + visualConfigs = NULL; + numConfigs = 0; + + /* Alloc temp space for the list of orig VisualIDs for each new visual */ + orig_vid = (VisualID *) __glXMalloc(numNewVisuals * sizeof(VisualID)); + if (!orig_vid) { + __glXFree(pNewVisualPriv); + __glXFree(pNewVisualConfigs); + return FALSE; + } + + /* Alloc space for the list of glXVisuals */ + modes = _gl_context_modes_create(numNewVisuals, sizeof(__GLcontextModes)); + if (modes == NULL) { + __glXFree(orig_vid); + __glXFree(pNewVisualPriv); + __glXFree(pNewVisualConfigs); + return FALSE; + } + + /* Alloc space for the list of glXVisualPrivates */ + glXVisualPriv = (void **)__glXMalloc(numNewVisuals * sizeof(void *)); + if (!glXVisualPriv) { + _gl_context_modes_destroy( modes ); + __glXFree(orig_vid); + __glXFree(pNewVisualPriv); + __glXFree(pNewVisualConfigs); + return FALSE; + } + + /* Alloc space for the new list of the X server's visuals */ + pVisualNew = (VisualPtr)__glXMalloc(numNewVisuals * sizeof(VisualRec)); + if (!pVisualNew) { + __glXFree(glXVisualPriv); + _gl_context_modes_destroy( modes ); + __glXFree(orig_vid); + __glXFree(pNewVisualPriv); + __glXFree(pNewVisualConfigs); + return FALSE; + } + + /* Initialize the new visuals */ + found_default = FALSE; + screenVisuals[screenInfo.numScreens-1].modes = modes; + for (i = j = 0; i < numVisuals; i++) { + int is_rgb = (pVisual[i].class == TrueColor || + pVisual[i].class == DirectColor); + + for (k = 0; k < numNewConfigs; k++) { + if (pNewVisualConfigs[k].rgba != is_rgb) + continue; + + assert( modes != NULL ); + + /* Initialize the new visual */ + pVisualNew[j] = pVisual[i]; + pVisualNew[j].vid = FakeClientID(0); + + /* Check for the default visual */ + if (!found_default && pVisual[i].vid == *defaultVisp) { + *defaultVisp = pVisualNew[j].vid; + found_default = TRUE; + } + + /* Save the old VisualID */ + orig_vid[j] = pVisual[i].vid; + + /* Initialize the glXVisual */ + _gl_copy_visual_to_context_mode( modes, & pNewVisualConfigs[k] ); + modes->visualID = pVisualNew[j].vid; + if (modes->fbconfigID == GLX_DONT_CARE) + modes->fbconfigID = modes->visualID; + + /* + * If the class is -1, then assume the X visual information + * is identical to what GLX needs, and take them from the X + * visual. NOTE: if class != -1, then all other fields MUST + * be initialized. + */ + if (modes->visualType == GLX_NONE) { + modes->visualType = _gl_convert_from_x_visual_type( pVisual[i].class ); + modes->redBits = count_bits(pVisual[i].redMask); + modes->greenBits = count_bits(pVisual[i].greenMask); + modes->blueBits = count_bits(pVisual[i].blueMask); + modes->alphaBits = modes->alphaBits; + modes->redMask = pVisual[i].redMask; + modes->greenMask = pVisual[i].greenMask; + modes->blueMask = pVisual[i].blueMask; + modes->alphaMask = modes->alphaMask; + modes->rgbBits = (is_rgb) + ? (modes->redBits + modes->greenBits + + modes->blueBits + modes->alphaBits) + : rootDepth; + +#ifdef COMPOSITE + if (pVisual[i].nplanes == 32) + modes->visualRating = GLX_NON_CONFORMANT_CONFIG; +#endif + + } + + /* Save the device-dependent private for this visual */ + glXVisualPriv[j] = pNewVisualPriv[k]; + + j++; + modes = modes->next; + } + } + + assert(j <= numNewVisuals); + + /* Save the GLX visuals in the screen structure */ + screenVisuals[screenInfo.numScreens-1].num_vis = numNewVisuals; + screenVisuals[screenInfo.numScreens-1].private = glXVisualPriv; + + /* Set up depth's VisualIDs */ + for (i = 0; i < ndepth; i++) { + int numVids = 0; + VisualID *pVids = NULL; + int k, n = 0; + + /* Count the new number of VisualIDs at this depth */ + for (j = 0; j < pdepth[i].numVids; j++) + for (k = 0; k < numNewVisuals; k++) + if (pdepth[i].vids[j] == orig_vid[k]) + numVids++; + + /* Allocate a new list of VisualIDs for this depth */ + pVids = (VisualID *)__glXMalloc(numVids * sizeof(VisualID)); + + /* Initialize the new list of VisualIDs for this depth */ + for (j = 0; j < pdepth[i].numVids; j++) + for (k = 0; k < numNewVisuals; k++) + if (pdepth[i].vids[j] == orig_vid[k]) + pVids[n++] = pVisualNew[k].vid; + + /* Update this depth's list of VisualIDs */ + __glXFree(pdepth[i].vids); + pdepth[i].vids = pVids; + pdepth[i].numVids = numVids; + } + + /* Update the X server's visuals */ + *nvisualp = numNewVisuals; + *visualp = pVisualNew; + + /* Free the old list of the X server's visuals */ + __glXFree(pVisual); + + /* Clean up temporary allocations */ + __glXFree(orig_vid); + __glXFree(pNewVisualPriv); + __glXFree(pNewVisualConfigs); + + /* Free the private list created by DDX HW driver */ + if (visualPrivates) + __glXFree(visualPrivates); + visualPrivates = NULL; + + return TRUE; +} + +void GlxSetVisualConfigs(int nconfigs, + __GLXvisualConfig *configs, void **privates) +{ + numConfigs = nconfigs; + visualConfigs = configs; + visualPrivates = privates; +} + +static miInitVisualsProcPtr saveInitVisualsProc; + +Bool GlxInitVisuals(VisualPtr *visualp, DepthPtr *depthp, + int *nvisualp, int *ndepthp, + int *rootDepthp, VisualID *defaultVisp, + unsigned long sizes, int bitsPerRGB, + int preferredVis) +{ + Bool ret; + + if (saveInitVisualsProc) { + ret = saveInitVisualsProc(visualp, depthp, nvisualp, ndepthp, + rootDepthp, defaultVisp, sizes, bitsPerRGB, + preferredVis); + if (!ret) + return False; + } + + /* + * Setup the visuals supported by this particular screen. + */ + init_visuals(nvisualp, visualp, defaultVisp, + *ndepthp, *depthp, *rootDepthp); + + + return True; +} + + +/************************************************************************/ + + +void +GlxWrapInitVisuals(miInitVisualsProcPtr *initVisProc) +{ + saveInitVisualsProc = *initVisProc; + *initVisProc = GlxInitVisuals; +} + +static void fixup_visuals(int screen) +{ + ScreenPtr pScreen = screenInfo.screens[screen]; + ScreenVisuals *psv = &screenVisuals[screen]; + int j; + __GLcontextModes *modes; + + for ( modes = psv->modes ; modes != NULL ; modes = modes->next ) { + const int vis_class = _gl_convert_to_x_visual_type( modes->visualType ); + const int nplanes = (modes->rgbBits - modes->alphaBits); + const VisualPtr pVis = pScreen->visuals; + + /* Find a visual that matches the GLX visual's class and size */ + for (j = 0; j < pScreen->numVisuals; j++) { + if (pVis[j].class == vis_class && + (pVis[j].nplanes == nplanes + +#ifdef COMPOSITE + || (pVis[j].nplanes == 32 && pVis[j].nplanes == modes->rgbBits) +#endif + + )) { + + /* Fixup the masks */ + modes->redMask = pVis[j].redMask; + modes->greenMask = pVis[j].greenMask; + modes->blueMask = pVis[j].blueMask; + + /* Recalc the sizes */ + modes->redBits = count_bits(modes->redMask); + modes->greenBits = count_bits(modes->greenMask); + modes->blueBits = count_bits(modes->blueMask); + } + } + } +} + +void __glXScreenInitVisuals(__GLXscreen *screen) +{ + int index = screen->pScreen->myNum; + + screen->modes = screenVisuals[index].modes; + screen->pVisualPriv = screenVisuals[index].private; + screen->numVisuals = screenVisuals[index].num_vis; + screen->numUsableVisuals = screenVisuals[index].num_vis; + + /* + * The ordering of the rgb compenents might have been changed by the + * driver after mi initialized them. + */ + fixup_visuals(index); +} diff --git a/GL/glx/indirect_util.c b/GL/glx/indirect_util.c index bf0ba66f2..706d43864 100644 --- a/GL/glx/indirect_util.c +++ b/GL/glx/indirect_util.c @@ -23,6 +23,8 @@ * SOFTWARE. */ +#include + #include #include #include diff --git a/GL/glx/render2swap.c b/GL/glx/render2swap.c index f8b57cb4c..81de81ff9 100644 --- a/GL/glx/render2swap.c +++ b/GL/glx/render2swap.c @@ -311,6 +311,10 @@ void __glXDispSwap_DrawArrays(GLbyte *pc) GLint numVals = compHeader[i].numVals; GLenum component = compHeader[i].component; + __GLX_SWAP_INT(&datatype); + __GLX_SWAP_INT(&numVals); + __GLX_SWAP_INT(&component); + swapArray(numVals, datatype, stride, numVertexes, pc); switch (component) { @@ -338,6 +342,14 @@ void __glXDispSwap_DrawArrays(GLbyte *pc) CALL_EnableClientState( GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY) ); CALL_EdgeFlagPointer( GET_DISPATCH(), (stride, (const GLboolean *)pc) ); break; + case GL_SECONDARY_COLOR_ARRAY: + CALL_EnableClientState( GET_DISPATCH(), (GL_SECONDARY_COLOR_ARRAY) ); + CALL_SecondaryColorPointerEXT( GET_DISPATCH(), (numVals, datatype, stride, pc) ); + break; + case GL_FOG_COORD_ARRAY: + CALL_EnableClientState( GET_DISPATCH(), (GL_FOG_COORD_ARRAY) ); + CALL_FogCoordPointerEXT( GET_DISPATCH(), (datatype, stride, pc) ); + break; default: break; } @@ -354,6 +366,8 @@ void __glXDispSwap_DrawArrays(GLbyte *pc) CALL_DisableClientState( GET_DISPATCH(), (GL_INDEX_ARRAY) ); CALL_DisableClientState( GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY) ); CALL_DisableClientState( GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY) ); + CALL_DisableClientState( GET_DISPATCH(), (GL_SECONDARY_COLOR_ARRAY) ); + CALL_DisableClientState( GET_DISPATCH(), (GL_FOG_COORD_ARRAY) ); } void __glXDispSwap_DrawArraysEXT(GLbyte *pc) diff --git a/GL/glx/single2.c b/GL/glx/single2.c index fc6cdf160..c44336af4 100644 --- a/GL/glx/single2.c +++ b/GL/glx/single2.c @@ -39,6 +39,10 @@ #include #endif +#include +#include +#include + #include "glxserver.h" #include "glxutil.h" #include "glxext.h" diff --git a/GL/include/GL/glx_ansic.h b/GL/include/GL/glx_ansic.h index c94393fd1..9085a08fe 100644 --- a/GL/include/GL/glx_ansic.h +++ b/GL/include/GL/glx_ansic.h @@ -56,9 +56,6 @@ #ifdef XFree86Server -#ifdef XFree86LOADER -#include "xf86_ansic.h" -#endif #ifndef assert #define assert(a) #endif diff --git a/GL/include/GL/xf86glx.h b/GL/include/GL/xf86glx.h index 66f096a98..5d018d72b 100644 --- a/GL/include/GL/xf86glx.h +++ b/GL/include/GL/xf86glx.h @@ -37,7 +37,3 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #endif #include "miscstruct.h" - -#ifdef XFree86LOADER -#include "xf86_ansic.h" -#endif diff --git a/GL/mesa/Makefile.am b/GL/mesa/Makefile.am index 63842dda3..72b699476 100644 --- a/GL/mesa/Makefile.am +++ b/GL/mesa/Makefile.am @@ -1,10 +1,7 @@ -SUBDIRS = main math array_cache swrast swrast_setup tnl shader X glapi +SUBDIRS = main math array_cache swrast swrast_setup tnl shader X noinst_LTLIBRARIES = libGLcore.la -libGLcore_la_CFLAGS = @DIX_CFLAGS@ -DUSE_MGL_NAMESPACE -UHAVE_CONFIG_H -DGLXEXT \ - -DXF86DRI -DGLX_DIRECT_RENDERING -DGLX_USE_DLOPEN -DGLX_USE_MESA - libGLcore_la_SOURCES = dummy.c libGLcore_la_LIBADD = main/libmain.la \ math/libmath.la \ @@ -15,5 +12,4 @@ libGLcore_la_LIBADD = main/libmain.la \ shader/libshader.la \ shader/grammar/libgrammar.la \ shader/slang/libslang.la \ - X/libX.la \ - glapi/libglapi.la + X/libX.la diff --git a/GL/mesa/X/Makefile.am b/GL/mesa/X/Makefile.am index 49cd753f9..17db13bac 100644 --- a/GL/mesa/X/Makefile.am +++ b/GL/mesa/X/Makefile.am @@ -18,8 +18,8 @@ INCLUDES = -I@MESA_SOURCE@/include \ # -DXFree86Server is required because the X11 driver in Mesa thinks that # symbol means "being built in the server" -AM_CFLAGS = @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ \ - -DXFree86Server -DUSE_MGL_NAMESPACE @DIX_CFLAGS@ +AM_CFLAGS = $(DIX_CFLAGS) @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ \ + -DXFree86Server -DUSE_MGL_NAMESPACE libX_la_SOURCES = xf86glx.c \ xf86glx_util.c \ diff --git a/GL/mesa/X/xf86glx.c b/GL/mesa/X/xf86glx.c index 7478f12db..ca8fa9377 100644 --- a/GL/mesa/X/xf86glx.c +++ b/GL/mesa/X/xf86glx.c @@ -36,13 +36,15 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #ifdef HAVE_DIX_CONFIG_H #include #endif -#define GL_GLEXT_PROTOTYPES + +#include #include #include #include #include #include #include +#include #include #include #include @@ -50,12 +52,14 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include #include #include -#include "xf86glxint.h" #include "context.h" #include "xmesaP.h" #include #include "context.h" +#include "glcontextmodes.h" +#include "os.h" + /* * This define is for the glcore.h header file. * If you add it here, then make sure you also add it in @@ -69,74 +73,243 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include #endif -#include "glcontextmodes.h" +typedef struct __GLXMESAscreen __GLXMESAscreen; +typedef struct __GLXMESAcontext __GLXMESAcontext; +typedef struct __GLXMESAdrawable __GLXMESAdrawable; -/* - * This structure is statically allocated in the __glXScreens[] - * structure. This struct is not used anywhere other than in - * __glXScreenInit to initialize each of the active screens - * (__glXActiveScreens[]). Several of the fields must be initialized by - * the screenProbe routine before they are copied to the active screens - * struct. In particular, the contextCreate, pGlxVisual, numVisuals, - * and numUsableVisuals fields must be initialized. - */ -static __GLXscreenInfo __glDDXScreenInfo = { - __MESA_screenProbe, /* Must be generic and handle all screens */ - __MESA_createContext, /* Substitute screen's createContext routine */ - __MESA_createBuffer, /* Substitute screen's createBuffer routine */ - NULL, /* Set up modes in probe */ - NULL, /* Set up pVisualPriv in probe */ - 0, /* Set up numVisuals in probe */ - 0, /* Set up numUsableVisuals in probe */ - NULL, /* GLextensions is overwritten by __glXScreenInit */ - "Vendor String", /* GLXvendor is overwritten by __glXScreenInit */ - "Version String", /* GLXversion is overwritten by __glXScreenInit */ - "Extensions String", /* GLXextensions is overwritten by __glXScreenInit */ - NULL /* WrappedPositionWindow is overwritten */ +struct __GLXMESAscreen { + __GLXscreen base; + int index; + XMesaVisual *xm_vis; }; -void *__glXglDDXScreenInfo(void) { - return &__glDDXScreenInfo; -} - -static __GLXextensionInfo __glDDXExtensionInfo = { - GL_CORE_MESA, - __MESA_resetExtension, - __MESA_initVisuals, - __MESA_setVisualConfigs +struct __GLXMESAcontext { + __GLXcontext base; + XMesaContext xmesa; }; -void *__glXglDDXExtensionInfo(void) { - return &__glDDXExtensionInfo; +struct __GLXMESAdrawable { + __GLXdrawable base; + XMesaBuffer xm_buf; +}; + +static XMesaVisual find_mesa_visual(__GLXscreen *screen, VisualID vid); + + +static void +__glXMesaDrawableDestroy(__GLXdrawable *base) +{ + __GLXMESAdrawable *glxPriv = (__GLXMESAdrawable *) base; + + XMesaDestroyBuffer(glxPriv->xm_buf); + xfree(glxPriv); } -static __MESA_screen MESAScreens[MAXSCREENS]; -static __GLcontext *MESA_CC = NULL; - -static int numConfigs = 0; -static __GLXvisualConfig *visualConfigs = NULL; -static void **visualPrivates = NULL; - - -static int count_bits(unsigned int n) +static GLboolean +__glXMesaDrawableResize(__GLXdrawable *base) { - int bits = 0; + __GLXMESAdrawable *glxPriv = (__GLXMESAdrawable *) base; - while (n > 0) { - if (n & 1) bits++; - n >>= 1; - } - return bits; + XMesaResizeBuffers(glxPriv->xm_buf); + + return GL_TRUE; +} + +static GLboolean +__glXMesaDrawableSwapBuffers(__GLXdrawable *base) +{ + __GLXMESAdrawable *glxPriv = (__GLXMESAdrawable *) base; + + /* This is terrifying: XMesaSwapBuffers() ends up calling CopyArea + * to do the buffer swap, but this assumes that the server holds + * the lock and has its context visible. If another screen uses a + * DRI driver, that will have installed the DRI enter/leave server + * functions, which lifts the lock during GLX dispatch. This is + * why we need to re-take the lock and swap in the server context + * before calling XMesaSwapBuffers() here. /me shakes head. */ + + __glXenterServer(); + + XMesaSwapBuffers(glxPriv->xm_buf); + + __glXleaveServer(); + + return GL_TRUE; } -static XMesaVisual find_mesa_visual(int screen, VisualID vid) +static __GLXdrawable * +__glXMesaContextCreateDrawable(__GLXcontext *context, + DrawablePtr pDraw, + XID drawId) { - __MESA_screen * const pMScr = &MESAScreens[screen]; + __GLXMESAdrawable *glxPriv; + __GLXscreen *pGlxScreen; + XMesaVisual xm_vis; + + glxPriv = xalloc(sizeof *glxPriv); + if (glxPriv == NULL) + return NULL; + + memset(glxPriv, 0, sizeof *glxPriv); + + if (!__glXDrawableInit(&glxPriv->base, context, pDraw, drawId)) { + xfree(glxPriv); + return NULL; + } + + glxPriv->base.destroy = __glXMesaDrawableDestroy; + glxPriv->base.resize = __glXMesaDrawableResize; + glxPriv->base.swapBuffers = __glXMesaDrawableSwapBuffers; + + pGlxScreen = __glXActiveScreens[pDraw->pScreen->myNum]; + + if (glxPriv->base.type == DRAWABLE_WINDOW) { + VisualID vid = wVisual((WindowPtr)pDraw); + + glxPriv->base.modes = _gl_context_modes_find_visual(pGlxScreen->modes, + vid); + } else { + glxPriv->base.modes = glxPriv->base.pGlxPixmap->modes; + } + + xm_vis = find_mesa_visual(pGlxScreen, glxPriv->base.modes->visualID); + if (xm_vis == NULL) { + ErrorF("find_mesa_visual returned NULL for visualID = 0x%04x\n", + glxPriv->base.modes->visualID); + xfree(glxPriv); + return NULL; + } + + if (glxPriv->base.type == DRAWABLE_WINDOW) { + glxPriv->xm_buf = XMesaCreateWindowBuffer(xm_vis, (WindowPtr)pDraw); + } else { + glxPriv->xm_buf = XMesaCreatePixmapBuffer(xm_vis, (PixmapPtr)pDraw, 0); + } + + return &glxPriv->base; +} + +static void +__glXMesaContextDestroy(__GLXcontext *baseContext) +{ + __GLXMESAcontext *context = (__GLXMESAcontext *) baseContext; + + XMesaDestroyContext(context->xmesa); + xfree(context); +} + +static int +__glXMesaContextMakeCurrent(__GLXcontext *baseContext) + +{ + __GLXMESAcontext *context = (__GLXMESAcontext *) baseContext; + __GLXMESAdrawable *drawPriv = (__GLXMESAdrawable *) context->base.drawPriv; + __GLXMESAdrawable *readPriv = (__GLXMESAdrawable *) context->base.readPriv; + + return XMesaMakeCurrent2(context->xmesa, + drawPriv->xm_buf, + readPriv->xm_buf); +} + +static int +__glXMesaContextLoseCurrent(__GLXcontext *baseContext) +{ + __GLXMESAcontext *context = (__GLXMESAcontext *) baseContext; + + return XMesaLoseCurrent(context->xmesa); +} + +static int +__glXMesaContextCopy(__GLXcontext *baseDst, + __GLXcontext *baseSrc, + unsigned long mask) +{ + __GLXMESAcontext *dst = (__GLXMESAcontext *) baseDst; + __GLXMESAcontext *src = (__GLXMESAcontext *) baseSrc; + + _mesa_copy_context(&src->xmesa->mesa, &dst->xmesa->mesa, mask); + return GL_TRUE; +} + +static int +__glXMesaContextForceCurrent(__GLXcontext *baseContext) +{ + __GLXMESAcontext *context = (__GLXMESAcontext *) baseContext; + + return XMesaForceCurrent(context->xmesa); +} + +static __GLXcontext * +__glXMesaScreenCreateContext(__GLXscreen *screen, + __GLcontextModes *modes, + __GLXcontext *baseShareContext) +{ + __GLXMESAcontext *context; + __GLXMESAcontext *shareContext = (__GLXMESAcontext *) baseShareContext; + XMesaVisual xm_vis; + XMesaContext xm_share; + + context = xalloc (sizeof (__GLXMESAcontext)); + if (context == NULL) + return NULL; + + memset(context, 0, sizeof *context); + + context->base.pGlxScreen = screen; + context->base.modes = modes; + + context->base.destroy = __glXMesaContextDestroy; + context->base.makeCurrent = __glXMesaContextMakeCurrent; + context->base.loseCurrent = __glXMesaContextLoseCurrent; + context->base.copy = __glXMesaContextCopy; + context->base.forceCurrent = __glXMesaContextForceCurrent; + context->base.createDrawable = __glXMesaContextCreateDrawable; + + xm_vis = find_mesa_visual(screen, modes->visualID); + if (!xm_vis) { + ErrorF("find_mesa_visual returned NULL for visualID = 0x%04x\n", + modes->visualID); + xfree(context); + return NULL; + } + + xm_share = shareContext ? shareContext->xmesa : NULL; + context->xmesa = XMesaCreateContext(xm_vis, xm_share); + if (!context->xmesa) { + xfree(context); + return NULL; + } + + return &context->base; +} + +static void +__glXMesaScreenDestroy(__GLXscreen *screen) +{ + __GLXMESAscreen *mesaScreen = (__GLXMESAscreen *) screen; + int i; + + for (i = 0; i < screen->numVisuals; i++) { + if (mesaScreen->xm_vis[i]) + XMesaDestroyVisual(mesaScreen->xm_vis[i]); + } + + xfree(mesaScreen->xm_vis); + + __glXScreenDestroy(screen); + + xfree(screen); +} + +static XMesaVisual +find_mesa_visual(__GLXscreen *screen, VisualID vid) +{ + __GLXMESAscreen *mesaScreen = (__GLXMESAscreen *) screen; const __GLcontextModes *modes; unsigned i = 0; - for ( modes = pMScr->modes ; modes != NULL ; modes = modes->next ) { + for ( modes = screen->modes ; modes != NULL ; modes = modes->next ) { if ( modes->visualID == vid ) { break; } @@ -144,499 +317,21 @@ static XMesaVisual find_mesa_visual(int screen, VisualID vid) i++; } - return (modes != NULL) ? pMScr->xm_vis[i] : NULL; + return (modes != NULL) ? mesaScreen->xm_vis[i] : NULL; } - -/* - * In the case the driver defines no GLX visuals we'll use these. - * Note that for TrueColor and DirectColor visuals, bufferSize is the - * sum of redSize, greenSize, blueSize and alphaSize, which may be larger - * than the nplanes/rootDepth of the server's X11 visuals - */ -#define NUM_FALLBACK_CONFIGS 5 -static __GLXvisualConfig FallbackConfigs[NUM_FALLBACK_CONFIGS] = { - /* [0] = RGB, double buffered, Z */ - { - -1, /* vid */ - -1, /* class */ - True, /* rgba */ - -1, -1, -1, 0, /* rgba sizes */ - -1, -1, -1, 0, /* rgba masks */ - 0, 0, 0, 0, /* rgba accum sizes */ - True, /* doubleBuffer */ - False, /* stereo */ - -1, /* bufferSize */ - 16, /* depthSize */ - 0, /* stencilSize */ - 0, /* auxBuffers */ - 0, /* level */ - GLX_NONE, /* visualRating */ - GLX_NONE, /* transparentPixel */ - 0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */ - 0 /* transparentIndex */ - }, - /* [1] = RGB, double buffered, Z, stencil, accum */ - { - -1, /* vid */ - -1, /* class */ - True, /* rgba */ - -1, -1, -1, 0, /* rgba sizes */ - -1, -1, -1, 0, /* rgba masks */ - 16, 16, 16, 0, /* rgba accum sizes */ - True, /* doubleBuffer */ - False, /* stereo */ - -1, /* bufferSize */ - 16, /* depthSize */ - 8, /* stencilSize */ - 0, /* auxBuffers */ - 0, /* level */ - GLX_NONE, /* visualRating */ - GLX_NONE, /* transparentPixel */ - 0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */ - 0 /* transparentIndex */ - }, - /* [2] = RGB+Alpha, double buffered, Z, stencil, accum */ - { - -1, /* vid */ - -1, /* class */ - True, /* rgba */ - -1, -1, -1, 8, /* rgba sizes */ - -1, -1, -1, -1, /* rgba masks */ - 16, 16, 16, 16, /* rgba accum sizes */ - True, /* doubleBuffer */ - False, /* stereo */ - -1, /* bufferSize */ - 16, /* depthSize */ - 8, /* stencilSize */ - 0, /* auxBuffers */ - 0, /* level */ - GLX_NONE, /* visualRating */ - GLX_NONE, /* transparentPixel */ - 0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */ - 0 /* transparentIndex */ - }, - /* [3] = RGB+Alpha, single buffered, Z, stencil, accum */ - { - -1, /* vid */ - -1, /* class */ - True, /* rgba */ - -1, -1, -1, 8, /* rgba sizes */ - -1, -1, -1, -1, /* rgba masks */ - 16, 16, 16, 16, /* rgba accum sizes */ - False, /* doubleBuffer */ - False, /* stereo */ - -1, /* bufferSize */ - 16, /* depthSize */ - 8, /* stencilSize */ - 0, /* auxBuffers */ - 0, /* level */ - GLX_NONE, /* visualRating */ - GLX_NONE, /* transparentPixel */ - 0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */ - 0 /* transparentIndex */ - }, - /* [4] = CI, double buffered, Z */ - { - -1, /* vid */ - -1, /* class */ - False, /* rgba? (false = color index) */ - -1, -1, -1, 0, /* rgba sizes */ - -1, -1, -1, 0, /* rgba masks */ - 0, 0, 0, 0, /* rgba accum sizes */ - True, /* doubleBuffer */ - False, /* stereo */ - -1, /* bufferSize */ - 16, /* depthSize */ - 0, /* stencilSize */ - 0, /* auxBuffers */ - 0, /* level */ - GLX_NONE, /* visualRating */ - GLX_NONE, /* transparentPixel */ - 0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */ - 0 /* transparentIndex */ - }, -}; - -void *__glXMalloc(size_t size) __attribute__((weak)); -void *__glXCalloc(size_t numElements, size_t elementSize) __attribute__((weak));void *__glXRealloc(void *addr, size_t newSize) __attribute__((weak)); -void __glXFree(void *addr) __attribute__((weak)); - -void * -__glXMalloc(size_t size) +static void init_screen_visuals(__GLXMESAscreen *screen) { - void *addr; - - if (size == 0) { - return NULL; - } - addr = (void *) xalloc(size); - if (addr == NULL) { - /* XXX: handle out of memory error */ - return NULL; - } - return addr; -} - -void * -__glXCalloc(size_t numElements, size_t elementSize) -{ - void *addr; - size_t size; - - if ((numElements == 0) || (elementSize == 0)) { - return NULL; - } - size = numElements * elementSize; - addr = (void *) xalloc(size); - if (addr == NULL) { - /* XXX: handle out of memory error */ - return NULL; - } - __glXMemset(addr, 0, size); - return addr; -} - -void * -__glXRealloc(void *addr, size_t newSize) -{ - void *newAddr; - - if (addr) { - if (newSize == 0) { - xfree(addr); - return NULL; - } else { - newAddr = xrealloc(addr, newSize); - } - } else { - if (newSize == 0) { - return NULL; - } else { - newAddr = xalloc(newSize); - } - } - if (newAddr == NULL) { - return NULL; /* XXX: out of memory */ - } - - return newAddr; -} - -void -__glXFree(void *addr) -{ - if (addr) { - xfree(addr); - } -} - - -static Bool init_visuals(int *nvisualp, VisualPtr *visualp, - VisualID *defaultVisp, - int ndepth, DepthPtr pdepth, - int rootDepth) -{ - int numRGBconfigs; - int numCIconfigs; - int numVisuals = *nvisualp; - int numNewVisuals; - int numNewConfigs; - VisualPtr pVisual = *visualp; - VisualPtr pVisualNew = NULL; - VisualID *orig_vid = NULL; - __GLcontextModes *modes; - __GLXvisualConfig *pNewVisualConfigs = NULL; - void **glXVisualPriv; - void **pNewVisualPriv; - int found_default; - int i, j, k; - - if (numConfigs > 0) - numNewConfigs = numConfigs; - else - numNewConfigs = NUM_FALLBACK_CONFIGS; - - /* Alloc space for the list of new GLX visuals */ - pNewVisualConfigs = (__GLXvisualConfig *) - __glXMalloc(numNewConfigs * sizeof(__GLXvisualConfig)); - if (!pNewVisualConfigs) { - return FALSE; - } - - /* Alloc space for the list of new GLX visual privates */ - pNewVisualPriv = (void **) __glXMalloc(numNewConfigs * sizeof(void *)); - if (!pNewVisualPriv) { - __glXFree(pNewVisualConfigs); - return FALSE; - } - - /* - ** If SetVisualConfigs was not called, then use default GLX - ** visual configs. - */ - if (numConfigs == 0) { - memcpy(pNewVisualConfigs, FallbackConfigs, - NUM_FALLBACK_CONFIGS * sizeof(__GLXvisualConfig)); - memset(pNewVisualPriv, 0, NUM_FALLBACK_CONFIGS * sizeof(void *)); - } - else { - /* copy driver's visual config info */ - for (i = 0; i < numConfigs; i++) { - pNewVisualConfigs[i] = visualConfigs[i]; - pNewVisualPriv[i] = visualPrivates[i]; - } - } - - /* Count the number of RGB and CI visual configs */ - numRGBconfigs = 0; - numCIconfigs = 0; - for (i = 0; i < numNewConfigs; i++) { - if (pNewVisualConfigs[i].rgba) - numRGBconfigs++; - else - numCIconfigs++; - } - - /* Count the total number of visuals to compute */ - numNewVisuals = 0; - for (i = 0; i < numVisuals; i++) { - numNewVisuals += - (pVisual[i].class == TrueColor || pVisual[i].class == DirectColor) - ? numRGBconfigs : numCIconfigs; - } - - /* Reset variables for use with the next screen/driver's visual configs */ - visualConfigs = NULL; - numConfigs = 0; - - /* Alloc temp space for the list of orig VisualIDs for each new visual */ - orig_vid = (VisualID *)__glXMalloc(numNewVisuals * sizeof(VisualID)); - if (!orig_vid) { - __glXFree(pNewVisualPriv); - __glXFree(pNewVisualConfigs); - return FALSE; - } - - /* Alloc space for the list of glXVisuals */ - modes = _gl_context_modes_create(numNewVisuals, sizeof(__GLcontextModes)); - if (modes == NULL) { - __glXFree(orig_vid); - __glXFree(pNewVisualPriv); - __glXFree(pNewVisualConfigs); - return FALSE; - } - - /* Alloc space for the list of glXVisualPrivates */ - glXVisualPriv = (void **)__glXMalloc(numNewVisuals * sizeof(void *)); - if (!glXVisualPriv) { - _gl_context_modes_destroy( modes ); - __glXFree(orig_vid); - __glXFree(pNewVisualPriv); - __glXFree(pNewVisualConfigs); - return FALSE; - } - - /* Alloc space for the new list of the X server's visuals */ - pVisualNew = (VisualPtr)__glXMalloc(numNewVisuals * sizeof(VisualRec)); - if (!pVisualNew) { - __glXFree(glXVisualPriv); - _gl_context_modes_destroy( modes ); - __glXFree(orig_vid); - __glXFree(pNewVisualPriv); - __glXFree(pNewVisualConfigs); - return FALSE; - } - - /* Initialize the new visuals */ - found_default = FALSE; - MESAScreens[screenInfo.numScreens-1].modes = modes; - for (i = j = 0; i < numVisuals; i++) { - int is_rgb = (pVisual[i].class == TrueColor || - pVisual[i].class == DirectColor); - - for (k = 0; k < numNewConfigs; k++) { - if (pNewVisualConfigs[k].rgba != is_rgb) - continue; - - assert( modes != NULL ); - - /* Initialize the new visual */ - pVisualNew[j] = pVisual[i]; - pVisualNew[j].vid = FakeClientID(0); - - /* Check for the default visual */ - if (!found_default && pVisual[i].vid == *defaultVisp) { - *defaultVisp = pVisualNew[j].vid; - found_default = TRUE; - } - - /* Save the old VisualID */ - orig_vid[j] = pVisual[i].vid; - - /* Initialize the glXVisual */ - _gl_copy_visual_to_context_mode( modes, & pNewVisualConfigs[k] ); - modes->visualID = pVisualNew[j].vid; - - /* - * If the class is -1, then assume the X visual information - * is identical to what GLX needs, and take them from the X - * visual. NOTE: if class != -1, then all other fields MUST - * be initialized. - */ - if (modes->visualType == GLX_NONE) { - modes->visualType = _gl_convert_from_x_visual_type( pVisual[i].class ); - modes->redBits = count_bits(pVisual[i].redMask); - modes->greenBits = count_bits(pVisual[i].greenMask); - modes->blueBits = count_bits(pVisual[i].blueMask); - modes->alphaBits = modes->alphaBits; - modes->redMask = pVisual[i].redMask; - modes->greenMask = pVisual[i].greenMask; - modes->blueMask = pVisual[i].blueMask; - modes->alphaMask = modes->alphaMask; - modes->rgbBits = (is_rgb) - ? (modes->redBits + modes->greenBits + - modes->blueBits + modes->alphaBits) - : rootDepth; - -#ifdef COMPOSITE - if (pVisual[i].nplanes == 32) - modes->visualRating = GLX_NON_CONFORMANT_CONFIG; -#endif - - } - - /* Save the device-dependent private for this visual */ - glXVisualPriv[j] = pNewVisualPriv[k]; - - j++; - modes = modes->next; - } - } - - assert(j <= numNewVisuals); - - /* Save the GLX visuals in the screen structure */ - MESAScreens[screenInfo.numScreens-1].num_vis = numNewVisuals; - MESAScreens[screenInfo.numScreens-1].private = glXVisualPriv; - - /* Set up depth's VisualIDs */ - for (i = 0; i < ndepth; i++) { - int numVids = 0; - VisualID *pVids = NULL; - int k, n = 0; - - /* Count the new number of VisualIDs at this depth */ - for (j = 0; j < pdepth[i].numVids; j++) - for (k = 0; k < numNewVisuals; k++) - if (pdepth[i].vids[j] == orig_vid[k]) - numVids++; - - /* Allocate a new list of VisualIDs for this depth */ - pVids = (VisualID *)__glXMalloc(numVids * sizeof(VisualID)); - - /* Initialize the new list of VisualIDs for this depth */ - for (j = 0; j < pdepth[i].numVids; j++) - for (k = 0; k < numNewVisuals; k++) - if (pdepth[i].vids[j] == orig_vid[k]) - pVids[n++] = pVisualNew[k].vid; - - /* Update this depth's list of VisualIDs */ - __glXFree(pdepth[i].vids); - pdepth[i].vids = pVids; - pdepth[i].numVids = numVids; - } - - /* Update the X server's visuals */ - *nvisualp = numNewVisuals; - *visualp = pVisualNew; - - /* Free the old list of the X server's visuals */ - __glXFree(pVisual); - - /* Clean up temporary allocations */ - __glXFree(orig_vid); - __glXFree(pNewVisualPriv); - __glXFree(pNewVisualConfigs); - - /* Free the private list created by DDX HW driver */ - if (visualPrivates) - xfree(visualPrivates); - visualPrivates = NULL; - - return TRUE; -} - -void __MESA_setVisualConfigs(int nconfigs, __GLXvisualConfig *configs, - void **privates) -{ - numConfigs = nconfigs; - visualConfigs = configs; - visualPrivates = privates; -} - -Bool __MESA_initVisuals(VisualPtr *visualp, DepthPtr *depthp, - int *nvisualp, int *ndepthp, int *rootDepthp, - VisualID *defaultVisp, unsigned long sizes, - int bitsPerRGB) -{ - /* - * Setup the visuals supported by this particular screen. - */ - return init_visuals(nvisualp, visualp, defaultVisp, - *ndepthp, *depthp, *rootDepthp); -} - -static void fixup_visuals(int screen) -{ - ScreenPtr pScreen = screenInfo.screens[screen]; - __MESA_screen *pMScr = &MESAScreens[screen]; - int j; - __GLcontextModes *modes; - - for ( modes = pMScr->modes ; modes != NULL ; modes = modes->next ) { - const int vis_class = _gl_convert_to_x_visual_type( modes->visualType ); - const int nplanes = (modes->rgbBits - modes->alphaBits); - const VisualPtr pVis = pScreen->visuals; - - /* Find a visual that matches the GLX visual's class and size */ - for (j = 0; j < pScreen->numVisuals; j++) { - if (pVis[j].class == vis_class && - (pVis[j].nplanes == nplanes - -#ifdef COMPOSITE - || (pVis[j].nplanes == 32 && pVis[j].nplanes == modes->rgbBits) -#endif - - )) { - - /* Fixup the masks */ - modes->redMask = pVis[j].redMask; - modes->greenMask = pVis[j].greenMask; - modes->blueMask = pVis[j].blueMask; - - /* Recalc the sizes */ - modes->redBits = count_bits(modes->redMask); - modes->greenBits = count_bits(modes->greenMask); - modes->blueBits = count_bits(modes->blueMask); - } - } - } -} - -static void init_screen_visuals(int screen) -{ - ScreenPtr pScreen = screenInfo.screens[screen]; + ScreenPtr pScreen = screen->base.pScreen; __GLcontextModes *modes; XMesaVisual *pXMesaVisual; int *used; - int i, j; + int i, j, size; /* Alloc space for the list of XMesa visuals */ - pXMesaVisual = (XMesaVisual *)__glXMalloc(MESAScreens[screen].num_vis * - sizeof(XMesaVisual)); - __glXMemset(pXMesaVisual, 0, - MESAScreens[screen].num_vis * sizeof(XMesaVisual)); + size = screen->base.numVisuals * sizeof(XMesaVisual); + pXMesaVisual = (XMesaVisual *) xalloc(size); + memset(pXMesaVisual, 0, size); /* FIXME: Change 'used' to be a array of bits (rather than of ints), * FIXME: create a stack array of 8 or 16 bytes. If 'numVisuals' is less @@ -644,20 +339,18 @@ static void init_screen_visuals(int screen) * FIXME: __glXMalloc / __glXFree. If nothing else, convert 'used' to * FIXME: array of bytes instead of ints! */ - used = (int *)__glXMalloc(pScreen->numVisuals * sizeof(int)); - __glXMemset(used, 0, pScreen->numVisuals * sizeof(int)); + used = (int *) xalloc(pScreen->numVisuals * sizeof(int)); + memset(used, 0, pScreen->numVisuals * sizeof(int)); i = 0; - for ( modes = MESAScreens[screen].modes - ; modes != NULL - ; modes = modes->next ) { + for ( modes = screen->base.modes; modes != NULL; modes = modes->next ) { const int vis_class = _gl_convert_to_x_visual_type( modes->visualType ); const int nplanes = (modes->rgbBits - modes->alphaBits); const VisualPtr pVis = pScreen->visuals; for (j = 0; j < pScreen->numVisuals; j++) { if (pVis[j].class == vis_class && - (pVis[j].nplanes == nplanes + (pVis[j].nplanes == nplanes #ifdef COMPOSITE || (pVis[j].nplanes == 32 && pVis[j].nplanes == modes->rgbBits) @@ -672,7 +365,7 @@ static void init_screen_visuals(int screen) /* Create the XMesa visual */ pXMesaVisual[i] = XMesaCreateVisual(pScreen, - &pVis[j], + pVis, modes->rgbMode, (modes->alphaBits > 0), modes->doubleBufferMode, @@ -712,30 +405,23 @@ static void init_screen_visuals(int screen) __glXFree(used); - MESAScreens[screen].xm_vis = pXMesaVisual; + screen->xm_vis = pXMesaVisual; } -Bool __MESA_screenProbe(int screen) +static __GLXscreen * +__glXMesaScreenProbe(ScreenPtr pScreen) { - /* - * Set up the current screen's visuals. - */ - __glDDXScreenInfo.modes = MESAScreens[screen].modes; - __glDDXScreenInfo.pVisualPriv = MESAScreens[screen].private; - __glDDXScreenInfo.numVisuals = - __glDDXScreenInfo.numUsableVisuals = MESAScreens[screen].num_vis; + __GLXMESAscreen *screen; - /* - * Set the current screen's createContext routine. This could be - * wrapped by a DDX GLX context creation routine. - */ - __glDDXScreenInfo.createContext = __MESA_createContext; + screen = xalloc(sizeof *screen); + if (screen == NULL) + return NULL; - /* - * The ordering of the rgb compenents might have been changed by the - * driver after mi initialized them. - */ - fixup_visuals(screen); + __glXScreenInit(&screen->base, pScreen); + + screen->base.destroy = __glXMesaScreenDestroy; + screen->base.createContext = __glXMesaScreenCreateContext; + screen->base.pScreen = pScreen; /* * Find the GLX visuals that are supported by this screen and create @@ -743,305 +429,17 @@ Bool __MESA_screenProbe(int screen) */ init_screen_visuals(screen); - return TRUE; + return &screen->base; } -extern void __MESA_resetExtension(void) +__GLXprovider __glXMesaProvider = { + __glXMesaScreenProbe, + "MESA", + NULL +}; + +__GLXprovider * +GlxGetMesaProvider (void) { - int i, j; - - XMesaReset(); - - for (i = 0; i < screenInfo.numScreens; i++) { - for (j = 0; j < MESAScreens[i].num_vis; j++) { - if (MESAScreens[i].xm_vis[j]) { - XMesaDestroyVisual(MESAScreens[i].xm_vis[j]); - MESAScreens[i].xm_vis[j] = NULL; - } - } - _gl_context_modes_destroy( MESAScreens[i].modes ); - MESAScreens[i].modes = NULL; - __glXFree(MESAScreens[i].private); - MESAScreens[i].private = NULL; - __glXFree(MESAScreens[i].xm_vis); - MESAScreens[i].xm_vis = NULL; - MESAScreens[i].num_vis = 0; - } - __glDDXScreenInfo.modes = NULL; - MESA_CC = NULL; + return &__glXMesaProvider; } - -void __MESA_createBuffer(__GLXdrawablePrivate *glxPriv) -{ - DrawablePtr pDraw = glxPriv->pDraw; - XMesaVisual xm_vis = find_mesa_visual(pDraw->pScreen->myNum, - glxPriv->modes->visualID); - __GLdrawablePrivate *glPriv = &glxPriv->glPriv; - __MESA_buffer buf; - - if (xm_vis == NULL) { - ErrorF("find_mesa_visual returned NULL for visualID = 0x%04x\n", - glxPriv->modes->visualID); - } - buf = (__MESA_buffer)__glXMalloc(sizeof(struct __MESA_bufferRec)); - buf->xm_buf = 0; - buf->pDraw = pDraw; - buf->xm_vis = xm_vis; - - /* Wrap the front buffer's resize routine */ - buf->fbresize = glPriv->frontBuffer.resize; - glPriv->frontBuffer.resize = __MESA_resizeBuffers; - - /* Wrap the swap buffers routine */ - buf->fbswap = glxPriv->swapBuffers; - glxPriv->swapBuffers = __MESA_swapBuffers; - - /* Wrap the render texture routines */ - buf->fbbind = glxPriv->bindBuffers; - glxPriv->bindBuffers = __MESA_bindBuffers; - buf->fbrelease = glxPriv->releaseBuffers; - glxPriv->releaseBuffers = __MESA_releaseBuffers; - - /* Mesa doesn't support render texture on its own */ - glxPriv->texTarget = GLX_NO_TEXTURE_EXT; - - /* Save Mesa's private buffer structure */ - glPriv->private = (void *)buf; - glPriv->freePrivate = __MESA_destroyBuffer; -} - -static void __MESA_allocateBuffer (__GLdrawablePrivate *glPriv) -{ - __MESA_buffer buf = glPriv->private; - - if (!buf->xm_buf) - { - /* Create Mesa's buffers */ - if (buf->pDraw->type == DRAWABLE_WINDOW) - { - buf->xm_buf = (void *) - XMesaCreateWindowBuffer (buf->xm_vis, (WindowPtr) buf->pDraw); - } - else - { - buf->xm_buf = (void *) - XMesaCreatePixmapBuffer (buf->xm_vis, (PixmapPtr) buf->pDraw, 0); - } - } -} - -GLboolean __MESA_resizeBuffers(__GLdrawableBuffer *buffer, - GLint x, GLint y, - GLuint width, GLuint height, - __GLdrawablePrivate *glPriv, - GLuint bufferMask) -{ - __MESA_buffer buf = (__MESA_buffer)glPriv->private; - - if (buf->xm_buf) - XMesaResizeBuffers(buf->xm_buf); - - return (*buf->fbresize)(buffer, x, y, width, height, glPriv, bufferMask); -} - -GLboolean __MESA_swapBuffers(__GLXdrawablePrivate *glxPriv) -{ - __MESA_buffer buf = (__MESA_buffer)glxPriv->glPriv.private; - - /* - ** Do not call the wrapped swap buffers routine since Mesa has - ** already done the swap. - */ - XMesaSwapBuffers(buf->xm_buf); - - return GL_TRUE; -} - -int __MESA_bindBuffers(__GLXdrawablePrivate *glxPriv, - int buffer) -{ - return FALSE; -} - -int __MESA_releaseBuffers(__GLXdrawablePrivate *glxPriv, - int buffer) -{ - return FALSE; -} - -void __MESA_destroyBuffer(__GLdrawablePrivate *glPriv) -{ - __MESA_buffer buf = (__MESA_buffer)glPriv->private; - __GLXdrawablePrivate *glxPriv = (__GLXdrawablePrivate *)glPriv->other; - - /* Destroy Mesa's buffers */ - if (buf->xm_buf) - XMesaDestroyBuffer(buf->xm_buf); - - /* Unwrap these routines */ - glxPriv->swapBuffers = buf->fbswap; - glPriv->frontBuffer.resize = buf->fbresize; - - __glXFree(glPriv->private); - glPriv->private = NULL; -} - -__GLinterface *__MESA_createContext(__GLimports *imports, - __GLcontextModes *modes, - __GLinterface *shareGC) -{ - __GLcontext *gl_ctx = NULL; - __GLcontext *m_share = NULL; - __GLXcontext *glxc = (__GLXcontext *)imports->other; - XMesaVisual xm_vis; - - if (shareGC) - m_share = (__GLcontext *)shareGC; - - xm_vis = find_mesa_visual(glxc->pScreen->myNum, glxc->modes->visualID); - if (xm_vis) { - XMesaContext xmshare = m_share ? m_share->DriverCtx : 0; - XMesaContext xmctx = XMesaCreateContext(xm_vis, xmshare); - gl_ctx = xmctx ? &xmctx->mesa : 0; - } - else { - ErrorF("find_mesa_visual returned NULL for visualID = 0x%04x\n", - glxc->modes->visualID); - } - - - if (!gl_ctx) - return NULL; - - gl_ctx->imports = *imports; - gl_ctx->exports.destroyContext = __MESA_destroyContext; - gl_ctx->exports.loseCurrent = __MESA_loseCurrent; - gl_ctx->exports.makeCurrent = __MESA_makeCurrent; - gl_ctx->exports.shareContext = __MESA_shareContext; - gl_ctx->exports.copyContext = __MESA_copyContext; - gl_ctx->exports.forceCurrent = __MESA_forceCurrent; - gl_ctx->exports.notifyResize = __MESA_notifyResize; - gl_ctx->exports.notifyDestroy = __MESA_notifyDestroy; - gl_ctx->exports.notifySwapBuffers = __MESA_notifySwapBuffers; - gl_ctx->exports.dispatchExec = __MESA_dispatchExec; - gl_ctx->exports.beginDispatchOverride = __MESA_beginDispatchOverride; - gl_ctx->exports.endDispatchOverride = __MESA_endDispatchOverride; - - return (__GLinterface *)gl_ctx; -} - -GLboolean __MESA_destroyContext(__GLcontext *gc) -{ - XMesaContext xmesa = (XMesaContext) gc->DriverCtx; - XMesaDestroyContext( xmesa ); - return GL_TRUE; -} - -GLboolean __MESA_loseCurrent(__GLcontext *gc) -{ - XMesaContext xmesa = (XMesaContext) gc->DriverCtx; - MESA_CC = NULL; - GlxFlushContextCache(); - return XMesaLoseCurrent(xmesa); -} - -GLboolean __MESA_makeCurrent(__GLcontext *gc) -{ - __GLdrawablePrivate *drawPriv = gc->imports.getDrawablePrivate( gc ); - __MESA_buffer drawBuf = (__MESA_buffer)drawPriv->private; - __GLdrawablePrivate *readPriv = gc->imports.getReadablePrivate( gc ); - __MESA_buffer readBuf = (__MESA_buffer)readPriv->private; - XMesaContext xmesa = (XMesaContext) gc->DriverCtx; - - if (!drawBuf->xm_buf) - __MESA_allocateBuffer (drawPriv); - - if (!readBuf->xm_buf) - __MESA_allocateBuffer (readPriv); - - MESA_CC = gc; - return XMesaMakeCurrent2(xmesa, drawBuf->xm_buf, readBuf->xm_buf); -} - -GLboolean __MESA_shareContext(__GLcontext *gc, __GLcontext *gcShare) -{ - /* NOT_DONE */ - /* XXX I don't see where/how this could ever be called */ - ErrorF("__MESA_shareContext\n"); - return GL_FALSE; -} - -GLboolean __MESA_copyContext(__GLcontext *dst, const __GLcontext *src, - GLuint mask) -{ - XMesaContext xm_dst = (XMesaContext) dst->DriverCtx; - const XMesaContext xm_src = (const XMesaContext) src->DriverCtx; - _mesa_copy_context(&xm_src->mesa, &xm_dst->mesa, mask); - return GL_TRUE; -} - -GLboolean __MESA_forceCurrent(__GLcontext *gc) -{ - XMesaContext xmesa = (XMesaContext) gc->DriverCtx; - MESA_CC = gc; - GlxSetRenderTables (gc->CurrentDispatch); - return XMesaForceCurrent(xmesa); -} - -GLboolean __MESA_notifyResize(__GLcontext *gc) -{ - /* NOT_DONE */ - ErrorF("__MESA_notifyResize\n"); - return GL_FALSE; -} - -void __MESA_notifyDestroy(__GLcontext *gc) -{ - /* NOT_DONE */ - ErrorF("__MESA_notifyDestroy\n"); - return; -} - -void __MESA_notifySwapBuffers(__GLcontext *gc) -{ - _mesa_notifySwapBuffers(gc); -} - -struct __GLdispatchStateRec *__MESA_dispatchExec(__GLcontext *gc) -{ - /* NOT_DONE */ - ErrorF("__MESA_dispatchExec\n"); - return NULL; -} - -void __MESA_beginDispatchOverride(__GLcontext *gc) -{ - /* NOT_DONE */ - ErrorF("__MESA_beginDispatchOverride\n"); - return; -} - -void __MESA_endDispatchOverride(__GLcontext *gc) -{ - /* NOT_DONE */ - ErrorF("__MESA_endDispatchOverride\n"); - return; -} - - -/* - * Server-side GLX uses these functions which are normally defined - * in the OpenGL SI. - */ - -GLuint __glFloorLog2(GLuint val) -{ - int c = 0; - - while (val > 1) { - c++; - val >>= 1; - } - return c; -} - diff --git a/GL/mesa/X/xf86glx_util.c b/GL/mesa/X/xf86glx_util.c index 6441a4b4f..d8afcbcb5 100644 --- a/GL/mesa/X/xf86glx_util.c +++ b/GL/mesa/X/xf86glx_util.c @@ -36,6 +36,8 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include #endif +#include + #include #include "pixmapstr.h" #include "xf86glx_util.h" diff --git a/GL/mesa/X/xf86glxint.h b/GL/mesa/X/xf86glxint.h index d58c0d29f..4e51215bc 100644 --- a/GL/mesa/X/xf86glxint.h +++ b/GL/mesa/X/xf86glxint.h @@ -43,71 +43,4 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include #include -typedef struct __MESA_screenRec __MESA_screen; -struct __MESA_screenRec { - int num_vis; - __GLcontextModes *modes; - XMesaVisual *xm_vis; - void **private; -}; - -typedef struct __MESA_bufferRec *__MESA_buffer; -struct __MESA_bufferRec { - XMesaBuffer xm_buf; - DrawablePtr pDraw; - XMesaVisual xm_vis; - GLboolean (*fbresize)(__GLdrawableBuffer *buf, - GLint x, GLint y, GLuint width, GLuint height, - __GLdrawablePrivate *glPriv, GLuint bufferMask); - GLboolean (*fbswap)(__GLXdrawablePrivate *glxPriv); - int (*fbbind)(__GLXdrawablePrivate *glxPriv, int buffer); - int (*fbrelease)(__GLXdrawablePrivate *glxPriv, int buffer); - int (*fbquery)(__GLXdrawablePrivate *glxPriv, int attribute, - unsigned int *value); - -}; - -extern void __MESA_setVisualConfigs(int nconfigs, __GLXvisualConfig *configs, - void **privates); -extern Bool __MESA_initVisuals(VisualPtr *visualp, DepthPtr *depthp, - int *nvisualp, int *ndepthp, int *rootDepthp, - VisualID *defaultVisp, unsigned long sizes, - int bitsPerRGB); -extern Bool __MESA_screenProbe(int screen); - -extern void __MESA_resetExtension(void); - -extern void __MESA_createBuffer(__GLXdrawablePrivate *glxPriv); -extern GLboolean __MESA_resizeBuffers(__GLdrawableBuffer *buf, - GLint x, GLint y, - GLuint width, GLuint height, - __GLdrawablePrivate *glPriv, - GLuint bufferMask); -extern GLboolean __MESA_swapBuffers(__GLXdrawablePrivate *glxPriv); -extern int __MESA_bindBuffers(__GLXdrawablePrivate *glxPriv, int buffer); -extern int __MESA_releaseBuffers(__GLXdrawablePrivate *glxPriv, int buffer); -extern int __MESA_queryBuffers(__GLXdrawablePrivate *glxPriv, int attribute, - unsigned int *value); -extern void __MESA_destroyBuffer(__GLdrawablePrivate *glPriv); - -extern __GLinterface *__MESA_createContext(__GLimports *imports, - __GLcontextModes *modes, - __GLinterface *shareGC); -extern GLboolean __MESA_destroyContext(__GLcontext *gc); -extern GLboolean __MESA_loseCurrent(__GLcontext *gc); -extern GLboolean __MESA_makeCurrent(__GLcontext *gc); -extern GLboolean __MESA_shareContext(__GLcontext *gc, __GLcontext *gcShare); -extern GLboolean __MESA_copyContext(__GLcontext *dst, const __GLcontext *src, - GLuint mask); -extern GLboolean __MESA_forceCurrent(__GLcontext *gc); - -extern GLboolean __MESA_notifyResize(__GLcontext *gc); -extern void __MESA_notifyDestroy(__GLcontext *gc); -extern void __MESA_notifySwapBuffers(__GLcontext *gc); -extern struct __GLdispatchStateRec *__MESA_dispatchExec(__GLcontext *gc); -extern void __MESA_beginDispatchOverride(__GLcontext *gc); -extern void __MESA_endDispatchOverride(__GLcontext *gc); - -extern GLuint __glFloorLog2(GLuint val); - #endif /* _XF86GLXINT_H_ */ diff --git a/GL/mesa/array_cache/Makefile.am b/GL/mesa/array_cache/Makefile.am index d87a04551..4ff6da199 100644 --- a/GL/mesa/array_cache/Makefile.am +++ b/GL/mesa/array_cache/Makefile.am @@ -1,6 +1,6 @@ noinst_LTLIBRARIES = libac.la -AM_CFLAGS = @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE @DIX_CFLAGS@ +AM_CFLAGS = $(DIX_CFLAGS) @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE INCLUDES = -I@MESA_SOURCE@/include \ -I../X \ diff --git a/GL/mesa/glapi/Makefile.am b/GL/mesa/glapi/Makefile.am index 3ee8cc7ba..5e960b647 100644 --- a/GL/mesa/glapi/Makefile.am +++ b/GL/mesa/glapi/Makefile.am @@ -1,6 +1,6 @@ noinst_LTLIBRARIES = libglapi.la -AM_CFLAGS = @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE @DIX_CFLAGS@ +AM_CFLAGS = $(DIX_CFLAGS) @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE INCLUDES = -I@MESA_SOURCE@/include \ -I../X \ diff --git a/GL/mesa/main/Makefile.am b/GL/mesa/main/Makefile.am index 2ddc87d8f..44a461301 100644 --- a/GL/mesa/main/Makefile.am +++ b/GL/mesa/main/Makefile.am @@ -1,6 +1,6 @@ noinst_LTLIBRARIES = libmain.la -AM_CFLAGS = @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE @DIX_CFLAGS@ +AM_CFLAGS = $(DIX_CFLAGS) @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE INCLUDES = -I@MESA_SOURCE@/include \ -I../X \ @@ -34,7 +34,7 @@ nodist_libmain_la_SOURCES = accum.c \ convolve.c \ debug.c \ depth.c \ - depthstencil.c \ + depthstencil.c \ dlist.c \ drawpix.c \ enable.c \ diff --git a/GL/mesa/math/Makefile.am b/GL/mesa/math/Makefile.am index 7604b626f..b966a585f 100644 --- a/GL/mesa/math/Makefile.am +++ b/GL/mesa/math/Makefile.am @@ -1,6 +1,6 @@ noinst_LTLIBRARIES = libmath.la -AM_CFLAGS = @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE @DIX_CFLAGS@ +AM_CFLAGS = $(DIX_CFLAGS) @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE INCLUDES = -I@MESA_SOURCE@/include \ -I../X \ diff --git a/GL/mesa/shader/Makefile.am b/GL/mesa/shader/Makefile.am index acca246cd..a01c977c4 100644 --- a/GL/mesa/shader/Makefile.am +++ b/GL/mesa/shader/Makefile.am @@ -2,7 +2,7 @@ SUBDIRS = grammar slang noinst_LTLIBRARIES = libshader.la -AM_CFLAGS = @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE @DIX_CFLAGS@ +AM_CFLAGS = $(DIX_CFLAGS) @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE INCLUDES = -I@MESA_SOURCE@/include \ -I../X \ @@ -26,7 +26,7 @@ nodist_libshader_la_SOURCES = \ nvfragparse.c \ nvprogram.c \ nvvertexec.c \ - nvvertparse.c \ + nvvertparse.c \ program.c \ shaderobjects.c \ shaderobjects_3dlabs.c diff --git a/GL/mesa/shader/grammar/Makefile.am b/GL/mesa/shader/grammar/Makefile.am index 77f97775a..3c569682e 100644 --- a/GL/mesa/shader/grammar/Makefile.am +++ b/GL/mesa/shader/grammar/Makefile.am @@ -1,6 +1,6 @@ noinst_LTLIBRARIES = libgrammar.la -AM_CFLAGS = @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE @DIX_CFLAGS@ +AM_CFLAGS = $(DIX_CFLAGS) @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE INCLUDES = -I@MESA_SOURCE@/include \ -I../../X \ diff --git a/GL/mesa/shader/slang/Makefile.am b/GL/mesa/shader/slang/Makefile.am index 50dc1c216..6890395e2 100644 --- a/GL/mesa/shader/slang/Makefile.am +++ b/GL/mesa/shader/slang/Makefile.am @@ -1,6 +1,6 @@ noinst_LTLIBRARIES = libslang.la -AM_CFLAGS = @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE @DIX_CFLAGS@ +AM_CFLAGS = $(DIX_CFLAGS) @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE INCLUDES = -I@MESA_SOURCE@/include \ -I../grammar \ @@ -22,10 +22,10 @@ nodist_libslang_la_SOURCES = slang_assemble_assignment.c \ slang_assemble_constructor.c \ slang_assemble_typeinfo.c \ slang_compile.c \ - slang_compile_function.c \ - slang_compile_operation.c \ - slang_compile_struct.c \ - slang_compile_variable.c \ + slang_compile_function.c \ + slang_compile_operation.c \ + slang_compile_struct.c \ + slang_compile_variable.c \ slang_execute.c \ slang_export.c \ slang_library_noise.c \ diff --git a/GL/mesa/swrast/Makefile.am b/GL/mesa/swrast/Makefile.am index 3de4ef158..6f9936c6e 100644 --- a/GL/mesa/swrast/Makefile.am +++ b/GL/mesa/swrast/Makefile.am @@ -1,6 +1,6 @@ noinst_LTLIBRARIES = libswrast.la -AM_CFLAGS = @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE @DIX_CFLAGS@ +AM_CFLAGS = $(DIX_CFLAGS) @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE INCLUDES = -I@MESA_SOURCE@/include \ -I../X \ @@ -9,7 +9,7 @@ INCLUDES = -I@MESA_SOURCE@/include \ -I../main \ -I../math \ -I../shader \ - -I../shader/slang \ + -I../shader/slang \ -I../swrast \ -I../swrast_setup \ -I../tnl \ @@ -41,8 +41,8 @@ nodist_libswrast_la_SOURCES = s_aaline.c \ s_readpix.c \ s_span.c \ s_stencil.c \ - s_texcombine.c \ - s_texfilter.c \ + s_texcombine.c \ + s_texfilter.c \ s_texstore.c \ s_triangle.c \ s_zoom.c diff --git a/GL/mesa/swrast_setup/Makefile.am b/GL/mesa/swrast_setup/Makefile.am index 4fcb6b4e3..b390ece64 100644 --- a/GL/mesa/swrast_setup/Makefile.am +++ b/GL/mesa/swrast_setup/Makefile.am @@ -1,6 +1,6 @@ noinst_LTLIBRARIES = libss.la -AM_CFLAGS = @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE @DIX_CFLAGS@ +AM_CFLAGS = $(DIX_CFLAGS) @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE INCLUDES = -I@MESA_SOURCE@/include \ -I../X \ diff --git a/GL/mesa/tnl/Makefile.am b/GL/mesa/tnl/Makefile.am index 0506a0c0a..a8b57bc4f 100644 --- a/GL/mesa/tnl/Makefile.am +++ b/GL/mesa/tnl/Makefile.am @@ -1,6 +1,6 @@ noinst_LTLIBRARIES = libtnl.la -AM_CFLAGS = @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE @DIX_CFLAGS@ +AM_CFLAGS = $(DIX_CFLAGS) @SERVER_DEFINES@ @MODULE_DEFINES@ @LOADER_DEFINES@ -DUSE_MGL_NAMESPACE INCLUDES = -I@MESA_SOURCE@/include \ -I../X \ diff --git a/GL/symlink-mesa.sh b/GL/symlink-mesa.sh index 7dc476085..0018e419e 100755 --- a/GL/symlink-mesa.sh +++ b/GL/symlink-mesa.sh @@ -63,8 +63,8 @@ symlink_mesa_glapi() { dst_dir mesa/glapi action dispatch.h - action glapi.h action glapi.c + action glapi.h action glapioffsets.h action glapitable.h action glapitemp.h diff --git a/hw/xgl/glxext/module/Makefile.am b/hw/xgl/glxext/module/Makefile.am index d459e3d08..38128b3e2 100644 --- a/hw/xgl/glxext/module/Makefile.am +++ b/hw/xgl/glxext/module/Makefile.am @@ -7,16 +7,10 @@ AM_CFLAGS = \ libglx_la_LDFLAGS = -avoid-version libglx_la_SOURCES = glxmodule.c -libglx_la_LIBADD = $(top_builddir)/GL/glx/libglx.la +libglx_la_LIBADD = $(top_builddir)/GL/glx/libglx.la \ + $(top_builddir)/GL/mesa/libGLcore.la libglx_modules = libglx.la -libglcore_la_LDFLAGS = -avoid-version -libglcore_la_SOURCES = glcoremodule.c -libglcore_la_LIBADD = $(top_builddir)/GL/mesa/libGLcore.la -libglcore_modules = libglcore.la - moduledir = @XGL_MODULE_PATH@ -module_LTLIBRARIES = \ - $(libglcore_modules) \ - $(libglx_modules) +module_LTLIBRARIES = $(libglx_modules) diff --git a/hw/xgl/glxext/module/glcoremodule.c b/hw/xgl/glxext/module/glcoremodule.c deleted file mode 100644 index 37aa9c658..000000000 --- a/hw/xgl/glxext/module/glcoremodule.c +++ /dev/null @@ -1,38 +0,0 @@ -/* - * Copyright © 2005 Novell, Inc. - * - * Permission to use, copy, modify, distribute, and sell this software - * and its documentation for any purpose is hereby granted without - * fee, provided that the above copyright notice appear in all copies - * and that both that copyright notice and this permission notice - * appear in supporting documentation, and that the name of - * Novell, Inc. not be used in advertising or publicity pertaining to - * distribution of the software without specific, written prior permission. - * Novell, Inc. makes no representations about the suitability of this - * software for any purpose. It is provided "as is" without express or - * implied warranty. - * - * NOVELL, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, - * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN - * NO EVENT SHALL NOVELL, INC. BE LIABLE FOR ANY SPECIAL, INDIRECT OR - * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS - * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, - * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION - * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - * - * Author: David Reveman - */ - -#include "xglmodule.h" - -char * -moduleVersion (void) -{ - return VERSION; -} - -Bool -moduleInit (const char *module) -{ - return TRUE; -} diff --git a/hw/xgl/glxext/xglglxext.c b/hw/xgl/glxext/xglglxext.c index 62d1f4dd1..756520872 100644 --- a/hw/xgl/glxext/xglglxext.c +++ b/hw/xgl/glxext/xglglxext.c @@ -41,6 +41,15 @@ #include "glxext.h" #include "micmap.h" +#ifndef GLX_TEXTURE_TARGET_EXT +#define GLX_TEXTURE_TARGET_EXT 0x6001 +#define GLX_TEXTURE_2D_EXT 0x6002 +#define GLX_TEXTURE_RECTANGLE_EXT 0x6003 +#define GLX_NO_TEXTURE_EXT 0x6004 +#define GLX_FRONT_LEFT_EXT 0x6005 +#define GLX_Y_INVERTED_EXT 0x6006 +#endif + #define XGL_MAX_TEXTURE_UNITS 8 #define XGL_MAX_ATTRIB_STACK_DEPTH 16 @@ -50,54 +59,29 @@ #define XGL_TEXTURE_RECTANGLE_BIT (1 << 3) #define XGL_TEXTURE_CUBE_MAP_BIT (1 << 4) -typedef Bool (*GLXScreenProbeProc) (int screen); -typedef __GLinterface *(*GLXCreateContextProc) (__GLimports *imports, - __GLcontextModes *modes, - __GLinterface *shareGC); -typedef void (*GLXCreateBufferProc) (__GLXdrawablePrivate *glxPriv); -typedef GLboolean (*GLXSwapBuffersProc) (__GLXdrawablePrivate *glxPriv); -typedef int (*GLXBindBuffersProc) (__GLXdrawablePrivate *glxPriv, - int buffer); -typedef int (*GLXReleaseBuffersProc) (__GLXdrawablePrivate *glxPriv, - int buffer); +extern __GLXprovider *__xglMesaProvider; -typedef struct _xglGLXScreenInfo { - GLXScreenProbeProc screenProbe; - GLXCreateContextProc createContext; - GLXCreateBufferProc createBuffer; -} xglGLXScreenInfoRec, *xglGLXScreenInfoPtr; - -extern __GLXscreenInfo *__xglScreenInfo; - -static xglGLXScreenInfoRec screenInfoPriv; - -typedef GLboolean (*GLResizeBuffersProc) (__GLdrawableBuffer *buffer, - GLint x, - GLint y, - GLuint width, - GLuint height, - __GLdrawablePrivate *glPriv, - GLuint bufferMask); -typedef void (*GLFreeBuffersProc) (__GLdrawablePrivate *glPriv); +typedef struct _xglGLScreen { + __GLXscreen base; + __GLXscreen *mesaScreen; +} xglGLScreenRec, *xglGLScreenPtr; typedef struct _xglGLBuffer { - GLXSwapBuffersProc swapBuffers; - GLXBindBuffersProc bindBuffers; - GLXReleaseBuffersProc releaseBuffers; - GLResizeBuffersProc resizeBuffers; - GLFreeBuffersProc freeBuffers; - ScreenPtr pScreen; - DrawablePtr pDrawable; - xglVisualPtr pVisual; - glitz_drawable_t *drawable; - glitz_surface_t *backSurface; - PixmapPtr pPixmap; - GCPtr pGC; - RegionRec damage; - void *private; - int screenX, screenY; - int xOff, yOff; - int yFlip; + __GLXdrawable base; + __GLXdrawable *mesaDrawable; + + ScreenPtr pScreen; + DrawablePtr pDrawable; + xglVisualPtr pVisual; + glitz_drawable_t *drawable; + glitz_surface_t *backSurface; + PixmapPtr pPixmap; + GCPtr pGC; + RegionRec damage; + void *private; + int screenX, screenY; + int xOff, yOff; + int yFlip; } xglGLBufferRec, *xglGLBufferPtr; typedef int xglGLXVisualConfigRec, *xglGLXVisualConfigPtr; @@ -263,12 +247,13 @@ typedef struct _xglGLAttributes { } xglGLAttributesRec, *xglGLAttributesPtr; typedef struct _xglGLContext { - __GLinterface iface; - __GLinterface *mIface; - int refcnt; - struct _xglGLContext *shared; - glitz_context_t *context; - struct _glapi_table glRenderTable; + __GLXcontext base; + __GLXcontext *mesaContext; + + int refcnt; + struct _xglGLContext *shared; + glitz_context_t *context; + struct _glapi_table glRenderTable; PFNGLACTIVETEXTUREARBPROC ActiveTextureARB; PFNGLWINDOWPOS3FMESAPROC WindowPos3fMESA; @@ -288,35 +273,33 @@ typedef struct _xglGLContext { GetFramebufferAttachmentParameterivEXT; PFNGLGENERATEMIPMAPEXTPROC GenerateMipmapEXT; - Bool needInit; - xglGLBufferPtr pDrawBuffer; - xglGLBufferPtr pReadBuffer; - int drawXoff, drawYoff; - __GLdrawablePrivate *readPriv; - __GLdrawablePrivate *drawPriv; - char *versionString; - GLenum errorValue; - GLboolean doubleBuffer; - GLint depthBits; - GLint stencilBits; - xglHashTablePtr texObjects; - xglHashTablePtr renderbufferObjects; - GLuint renderbuffer; - xglHashTablePtr framebufferObjects; - GLuint framebuffer; - xglHashTablePtr displayLists; - GLuint list; - GLenum listMode; - GLuint beginCnt; - xglDisplayListPtr pList; - GLuint groupList; - xglGLAttributesRec attrib; - xglGLAttributesRec attribStack[XGL_MAX_ATTRIB_STACK_DEPTH]; - int nAttribStack; - int activeTexUnit; - GLint maxTexUnits; - GLint maxListNesting; - GLint maxAttribStackDepth; + Bool needInit; + xglGLBufferPtr pDrawBuffer; + xglGLBufferPtr pReadBuffer; + int drawXoff, drawYoff; + char *versionString; + GLenum errorValue; + GLboolean doubleBuffer; + GLint depthBits; + GLint stencilBits; + xglHashTablePtr texObjects; + xglHashTablePtr renderbufferObjects; + GLuint renderbuffer; + xglHashTablePtr framebufferObjects; + GLuint framebuffer; + xglHashTablePtr displayLists; + GLuint list; + GLenum listMode; + GLuint beginCnt; + xglDisplayListPtr pList; + GLuint groupList; + xglGLAttributesRec attrib; + xglGLAttributesRec attribStack[XGL_MAX_ATTRIB_STACK_DEPTH]; + int nAttribStack; + int activeTexUnit; + GLint maxTexUnits; + GLint maxListNesting; + GLint maxAttribStackDepth; } xglGLContextRec, *xglGLContextPtr; static xglGLContextPtr cctx = NULL; @@ -1425,7 +1408,7 @@ xglSetupTextures (void) { if (i != activeTexUnit) { - cctx->ActiveTextureARB (GL_TEXTURE0_ARB + i); + (*cctx->ActiveTextureARB) (GL_TEXTURE0_ARB + i); activeTexUnit = i; } glitz_context_bind_texture (cctx->context, pTexObj[i]->object); @@ -1433,7 +1416,7 @@ xglSetupTextures (void) } if (activeTexUnit != cctx->activeTexUnit) - cctx->ActiveTextureARB (cctx->activeTexUnit); + (*cctx->ActiveTextureARB) (cctx->activeTexUnit); } static GLboolean @@ -4777,6 +4760,411 @@ xglInitExtensions (xglGLContextPtr pContext) } } +static GLboolean +xglResizeBuffer (xglGLBufferPtr pBufferPriv) +{ + DrawablePtr pDrawable = pBufferPriv->pDrawable; + + XGL_SCREEN_PRIV (pDrawable->pScreen); + XGL_DRAWABLE_PIXMAP (pBufferPriv->pDrawable); + + if (pPixmap != pScreenPriv->pScreenPixmap) + { + if (!xglCreatePixmapSurface (pPixmap)) + return FALSE; + + if (pBufferPriv->drawable == pScreenPriv->drawable) + { + if (pBufferPriv->backSurface) + glitz_surface_destroy (pBufferPriv->backSurface); + + glitz_drawable_destroy (pBufferPriv->drawable); + + pBufferPriv->drawable = NULL; + pBufferPriv->backSurface = NULL; + } + + if (pBufferPriv->drawable) + { + glitz_drawable_update_size (pBufferPriv->drawable, + pPixmap->drawable.width, + pPixmap->drawable.height); + } + else + { + glitz_drawable_format_t *format; + + format = pBufferPriv->pVisual->format.drawable; + if (pBufferPriv->pVisual->pbuffer) + { + pBufferPriv->drawable = + glitz_create_pbuffer_drawable (pScreenPriv->drawable, + format, + pPixmap->drawable.width, + pPixmap->drawable.height); + } + else + { + pBufferPriv->drawable = + glitz_create_drawable (pScreenPriv->drawable, format, + pPixmap->drawable.width, + pPixmap->drawable.height); + + if (!pBufferPriv->drawable) + return FALSE; + + if (format->doublebuffer) + { + glitz_format_t *backFormat; + + backFormat = pBufferPriv->pVisual->format.surface; + + pBufferPriv->backSurface = + glitz_surface_create (pScreenPriv->drawable, backFormat, + pPixmap->drawable.width, + pPixmap->drawable.height, + 0, NULL); + if (pBufferPriv->backSurface) + glitz_surface_attach (pBufferPriv->backSurface, + pBufferPriv->drawable, + GLITZ_DRAWABLE_BUFFER_BACK_COLOR); + } + } + } + } + else + { + glitz_drawable_reference (pScreenPriv->drawable); + + if (pBufferPriv->backSurface) + glitz_surface_destroy (pBufferPriv->backSurface); + + if (pBufferPriv->drawable) + glitz_drawable_destroy (pBufferPriv->drawable); + + pBufferPriv->drawable = pScreenPriv->drawable; + pBufferPriv->backSurface = NULL; + } + + ValidateGC (pDrawable, pBufferPriv->pGC); + + return TRUE; +} + +static GLboolean +xglSwapBuffers (__GLXdrawable *drawable) +{ + xglGLBufferPtr pBufferPriv = (xglGLBufferPtr) drawable; + __GLXdrawable *mesaDrawable = pBufferPriv->mesaDrawable; + DrawablePtr pDrawable = pBufferPriv->pDrawable; + GLboolean status = GL_TRUE; + + if (pDrawable) + { + glitz_surface_t *surface; + int xOff, yOff; + GCPtr pGC = pBufferPriv->pGC; + BoxPtr pBox = REGION_RECTS (pGC->pCompositeClip); + int nBox = REGION_NUM_RECTS (pGC->pCompositeClip); + + XGL_GET_DRAWABLE (pDrawable, surface, xOff, yOff); + + glitz_drawable_swap_buffer_region (pBufferPriv->drawable, + xOff, yOff, + (glitz_box_t *) pBox, nBox); + + xglAddBitDamage (pDrawable, pGC->pCompositeClip); + DamageDamageRegion (pDrawable, pGC->pCompositeClip); + REGION_EMPTY (pGC->pScreen, &pBufferPriv->damage); + } + else if (mesaDrawable) + { + status = (*mesaDrawable->swapBuffers) (mesaDrawable); + } + + return status; +} + +static GLboolean +xglResizeDrawable (__GLXdrawable *drawable) +{ + xglGLBufferPtr pBufferPriv = (xglGLBufferPtr) drawable; + __GLXdrawable *mesaDrawable = pBufferPriv->mesaDrawable; + DrawablePtr pDrawable = pBufferPriv->pDrawable; + GLboolean status = GL_TRUE; + + if (pDrawable) + { + if (!xglResizeBuffer (pBufferPriv)) + return GL_FALSE; + } + else if (mesaDrawable) + { + status = (*mesaDrawable->resize) (mesaDrawable); + } + + return status; +} + +static int +xglBindTexImage (__GLXcontext *context, + int buffer, + __GLXpixmap *pixmap) +{ + xglGLContextPtr pContext = (xglGLContextPtr) context; + __GLXcontext *mesaContext = pContext->mesaContext; + + if (cctx) + { + xglTexUnitPtr pTexUnit = &cctx->attrib.texUnits[cctx->activeTexUnit]; + ScreenPtr pScreen = pixmap->pDraw->pScreen; + + XGL_SCREEN_PRIV (pScreen); + XGL_DRAWABLE_PIXMAP (pixmap->pDraw); + + /* XXX: front left buffer is only supported so far */ + if (buffer != GLX_FRONT_LEFT_EXT) + return BadMatch; + + if (xglCreatePixmapSurface (pPixmap)) + { + glitz_texture_object_t *texture; + + XGL_PIXMAP_PRIV (pPixmap); + + texture = glitz_texture_object_create (pPixmapPriv->surface); + if (texture) + { + xglTexObjPtr pTexObj; + + switch (glitz_texture_object_get_target (texture)) { + case GLITZ_TEXTURE_TARGET_2D: + pTexObj = pTexUnit->p2D; + break; + case GLITZ_TEXTURE_TARGET_RECT: + pTexObj = pTexUnit->pRect; + default: + pTexObj = NULL; + break; + } + + if (pTexObj) + { + pPixmap->refcnt++; + + if (pTexObj->pPixmap) + (*pScreen->DestroyPixmap) (pTexObj->pPixmap); + + if (pTexObj->object) + glitz_texture_object_destroy (pTexObj->object); + + pTexObj->pPixmap = pPixmap; + pTexObj->object = texture; + } + else + glitz_texture_object_destroy (texture); + + return Success; + } + } + } + else + { + return (*mesaContext->textureFromPixmap->bindTexImage) (mesaContext, + buffer, + pixmap); + } + + return BadDrawable; +} + +static int +xglReleaseTexImage (__GLXcontext *context, + int buffer, + __GLXpixmap *pixmap) +{ + xglGLContextPtr pContext = (xglGLContextPtr) context; + __GLXcontext *mesaContext = pContext->mesaContext; + + if (cctx) + { + DrawablePtr pDrawable = pixmap->pDraw; + xglTexObjPtr pTexObj; + + XGL_DRAWABLE_PIXMAP (pDrawable); + + /* XXX: front left buffer is only supported so far */ + if (buffer != GLX_FRONT_LEFT_EXT) + return BadMatch; + + pTexObj = cctx->attrib.texUnits[cctx->activeTexUnit].p2D; + if (pTexObj && pTexObj->pPixmap == pPixmap) + { + (*pDrawable->pScreen->DestroyPixmap) (pTexObj->pPixmap); + pTexObj->pPixmap = NULL; + glitz_texture_object_destroy (pTexObj->object); + pTexObj->object = NULL; + + return Success; + } + else + { + pTexObj = cctx->attrib.texUnits[cctx->activeTexUnit].pRect; + if (pTexObj && pTexObj->pPixmap == pPixmap) + { + (*pDrawable->pScreen->DestroyPixmap) (pTexObj->pPixmap); + pTexObj->pPixmap = NULL; + glitz_texture_object_destroy (pTexObj->object); + pTexObj->object = NULL; + + return Success; + } + } + } + else + { + return (*mesaContext->textureFromPixmap->releaseTexImage) (mesaContext, + buffer, + pixmap); + } + + return BadDrawable; +} + +static __GLXtextureFromPixmapContext __xglTextureFromPixmapContext = { + xglBindTexImage, + xglReleaseTexImage +}; + +static void +xglDestroyDrawable (__GLXdrawable *drawable) +{ + xglGLBufferPtr pBufferPriv = (xglGLBufferPtr) drawable; + __GLXdrawable *mesaDrawable = pBufferPriv->mesaDrawable; + + if (mesaDrawable) + (*mesaDrawable->destroy) (mesaDrawable); + + if (pBufferPriv->pGC) + FreeGC (pBufferPriv->pGC, (GContext) 0); + + if (pBufferPriv->backSurface) + glitz_surface_destroy (pBufferPriv->backSurface); + + if (pBufferPriv->drawable) + glitz_drawable_destroy (pBufferPriv->drawable); + + xfree (pBufferPriv); +} + +static __GLXdrawable * +xglCreateDrawable (__GLXcontext *context, + DrawablePtr pDrawable, + XID drawId) +{ + xglGLContextPtr pContext = (xglGLContextPtr) context; + __GLXcontext *mesaContext = pContext->mesaContext; + ScreenPtr pScreen = pDrawable->pScreen; + xglGLBufferPtr pBufferPriv; + xglVisualPtr v; + + XGL_SCREEN_PRIV (pScreen); + XGL_DRAWABLE_PIXMAP (pDrawable); + + pBufferPriv = xalloc (sizeof (xglGLBufferRec)); + if (!pBufferPriv) + return NULL; + + memset (pBufferPriv, 0, sizeof (xglGLBufferRec)); + + if (!GlxDrawableInit (&pBufferPriv->base, context, pDrawable, drawId)) + { + xfree (pBufferPriv); + return NULL; + } + + pBufferPriv->mesaDrawable = NULL; + + pBufferPriv->pScreen = pScreen; + pBufferPriv->pDrawable = NULL; + pBufferPriv->pPixmap = NULL; + pBufferPriv->pGC = NULL; + + pBufferPriv->base.destroy = xglDestroyDrawable; + pBufferPriv->base.resize = xglResizeDrawable; + pBufferPriv->base.swapBuffers = xglSwapBuffers; + + pBufferPriv->drawable = NULL; + pBufferPriv->backSurface = NULL; + + REGION_INIT (pScreen, &pBufferPriv->damage, NullBox, 0); + + pBufferPriv->pVisual = 0; + + /* glx acceleration */ + if (pScreenPriv->accel.glx.enabled && + xglCheckPixmapSize (pPixmap, &pScreenPriv->accel.glx.size)) + { + for (v = pScreenPriv->pGlxVisual; v; v = v->next) + { + glitz_drawable_format_t *format; + + if (pScreenPriv->accel.glx.pbuffer != v->pbuffer) + continue; + + format = v->format.drawable; + if (!format) + continue; + + if (format->color.red_size != context->modes->redBits || + format->color.green_size != context->modes->greenBits || + format->color.blue_size != context->modes->blueBits) + continue; + + if (format->color.alpha_size < context->modes->alphaBits || + format->depth_size < context->modes->depthBits || + format->stencil_size < context->modes->stencilBits || + format->doublebuffer < context->modes->doubleBufferMode) + continue; + + /* this is good enought for pbuffers */ + if (v->pbuffer) + break; + + /* we want an exact match for non-pbuffer formats */ + if (format->color.alpha_size == context->modes->alphaBits && + format->depth_size == context->modes->depthBits && + format->stencil_size == context->modes->stencilBits && + format->doublebuffer == context->modes->doubleBufferMode) + break; + } + + pBufferPriv->pVisual = v; + } + + if ((pDrawable->type == DRAWABLE_WINDOW) + +#ifdef COMPOSITE + && (pBufferPriv->pVisual + + /* this is a root window, can't be redirected */ + || (!((WindowPtr) pDrawable)->parent)) +#endif + + ) + { + pBufferPriv->pDrawable = pDrawable; + } + else + { + pBufferPriv->mesaDrawable = (*mesaContext->createDrawable) (mesaContext, + pDrawable, + drawId); + } + + return &pBufferPriv->base; +} + static void xglSetCurrentContext (xglGLContextPtr pContext) { @@ -4907,46 +5295,41 @@ xglFreeContext (xglGLContextPtr pContext) xfree (pContext); } -static GLboolean -xglDestroyContext (__GLcontext *gc) +static void +xglDestroyContext (__GLXcontext *context) { - xglGLContextPtr pContext = (xglGLContextPtr) gc; - __GLinterface *iface = pContext->mIface; + xglGLContextPtr pContext = (xglGLContextPtr) context; + __GLXcontext *mesaContext = pContext->mesaContext; xglFreeContext (pContext); - if (!iface) - return GL_TRUE; - - return (*iface->exports.destroyContext) ((__GLcontext *) iface); + if (mesaContext) + (*mesaContext->destroy) (mesaContext); } -static GLboolean -xglLoseCurrent (__GLcontext *gc) +static int +xglLoseCurrent (__GLXcontext *context) { - xglGLContextPtr pContext = (xglGLContextPtr) gc; - __GLinterface *iface = pContext->mIface; + xglGLContextPtr pContext = (xglGLContextPtr) context; + __GLXcontext *mesaContext = pContext->mesaContext; GlxFlushContextCache (); GlxSetRenderTables (0); - if (!iface) - return GL_TRUE; + if (!mesaContext) + return TRUE; - return (*iface->exports.loseCurrent) ((__GLcontext *) iface); + return (*mesaContext->loseCurrent) (mesaContext); } -static GLboolean -xglMakeCurrent (__GLcontext *gc) +static int +xglMakeCurrent (__GLXcontext *context) { - xglGLContextPtr pContext = (xglGLContextPtr) gc; - __GLinterface *iface = &pContext->iface; - __GLinterface *mIface = pContext->mIface; - __GLdrawablePrivate *drawPriv = iface->imports.getDrawablePrivate (gc); - __GLdrawablePrivate *readPriv = iface->imports.getReadablePrivate (gc); - xglGLBufferPtr pDrawBufferPriv = drawPriv->private; - xglGLBufferPtr pReadBufferPriv = readPriv->private; - GLboolean status = GL_TRUE; + xglGLContextPtr pContext = (xglGLContextPtr) context; + __GLXcontext *mesaContext = pContext->mesaContext; + xglGLBufferPtr pDrawBufferPriv = (xglGLBufferPtr) context->drawPriv; + xglGLBufferPtr pReadBufferPriv = (xglGLBufferPtr) context->readPriv; + int status = TRUE; if (pReadBufferPriv->pDrawable && pDrawBufferPriv->pDrawable) { @@ -4964,11 +5347,11 @@ xglMakeCurrent (__GLcontext *gc) /* this happens if client previously used this context with a buffer not supported by the native GL stack */ if (!pContext->context) - return GL_FALSE; + return FALSE; /* XXX: GLX_SGI_make_current_read disabled for now */ if (pDrawBufferPriv != pReadBufferPriv) - return GL_FALSE; + return FALSE; if (!pReadBufferPriv->pGC) pReadBufferPriv->pGC = @@ -4992,30 +5375,24 @@ xglMakeCurrent (__GLcontext *gc) pContext->pReadBuffer = pReadBufferPriv; pContext->pDrawBuffer = pDrawBufferPriv; - pContext->readPriv = readPriv; - pContext->drawPriv = drawPriv; - /* from now on this context can only be used with native GL stack */ - if (mIface) + if (mesaContext) { - (*mIface->exports.destroyContext) ((__GLcontext *) mIface); - pContext->mIface = NULL; + (*mesaContext->destroy) (mesaContext); + pContext->mesaContext = NULL; } } else { /* this happens if client previously used this context with a buffer supported by the native GL stack */ - if (!mIface) + if (!mesaContext) return GL_FALSE; - drawPriv->private = pDrawBufferPriv->private; - readPriv->private = pReadBufferPriv->private; + mesaContext->drawPriv = pDrawBufferPriv->mesaDrawable; + mesaContext->readPriv = pDrawBufferPriv->mesaDrawable; - status = (*mIface->exports.makeCurrent) ((__GLcontext *) mIface); - - drawPriv->private = pDrawBufferPriv; - readPriv->private = pReadBufferPriv; + status = (*mesaContext->makeCurrent) (mesaContext); /* from now on this context can not be used with native GL stack */ if (status == GL_TRUE && pContext->context) @@ -5028,160 +5405,37 @@ xglMakeCurrent (__GLcontext *gc) return status; } -static GLboolean -xglShareContext (__GLcontext *gc, - __GLcontext *gcShare) +static int +xglCopyContext (__GLXcontext *dst, + __GLXcontext *src, + unsigned long mask) { - xglGLContextPtr pContext = (xglGLContextPtr) gc; - xglGLContextPtr pContextShare = (xglGLContextPtr) gcShare; - __GLinterface *iface = pContext->mIface; - __GLinterface *ifaceShare = pContextShare->mIface; - - if (!iface || !ifaceShare) - return GL_TRUE; - - return (*iface->exports.shareContext) ((__GLcontext *) iface, - (__GLcontext *) ifaceShare); -} - -static GLboolean -xglCopyContext (__GLcontext *dst, - const __GLcontext *src, - GLuint mask) -{ - xglGLContextPtr pDst = (xglGLContextPtr) dst; - xglGLContextPtr pSrc = (xglGLContextPtr) src; - const __GLcontext *srcCtx = (const __GLcontext *) pSrc->mIface; - __GLinterface *dstIface = (__GLinterface *) pDst->mIface; - GLboolean status = GL_TRUE; + xglGLContextPtr pDst = (xglGLContextPtr) dst; + xglGLContextPtr pSrc = (xglGLContextPtr) src; + __GLXcontext *mesaDst = pDst->mesaContext; + __GLXcontext *mesaSrc = pSrc->mesaContext; + int status = TRUE; if (pSrc->context && pDst->context) glitz_context_copy (pSrc->context, pDst->context, mask); else - status = GL_FALSE; + status = FALSE; - if (dstIface && srcCtx) - status = (*dstIface->exports.copyContext) ((__GLcontext *) dstIface, - srcCtx, - mask); + if (mesaDst && mesaSrc) + status = (*mesaDst->copy) (mesaDst, mesaSrc, mask); return status; } -static Bool -xglResizeBuffer (__GLdrawablePrivate *glPriv, - int x, - int y, - unsigned int width, - unsigned int height) +static int +xglForceCurrent (__GLXcontext *context) { - xglGLBufferPtr pBufferPriv = glPriv->private; - DrawablePtr pDrawable = pBufferPriv->pDrawable; - - XGL_SCREEN_PRIV (pDrawable->pScreen); - XGL_DRAWABLE_PIXMAP (pBufferPriv->pDrawable); - - if (pPixmap != pScreenPriv->pScreenPixmap) - { - if (!xglCreatePixmapSurface (pPixmap)) - return FALSE; - - if (pBufferPriv->drawable == pScreenPriv->drawable) - { - if (pBufferPriv->backSurface) - glitz_surface_destroy (pBufferPriv->backSurface); - - glitz_drawable_destroy (pBufferPriv->drawable); - - pBufferPriv->drawable = NULL; - pBufferPriv->backSurface = NULL; - } - - if (pBufferPriv->drawable) - { - glitz_drawable_update_size (pBufferPriv->drawable, - pPixmap->drawable.width, - pPixmap->drawable.height); - } - else - { - glitz_drawable_format_t *format; - - format = pBufferPriv->pVisual->format.drawable; - if (pBufferPriv->pVisual->pbuffer) - { - pBufferPriv->drawable = - glitz_create_pbuffer_drawable (pScreenPriv->drawable, - format, - pPixmap->drawable.width, - pPixmap->drawable.height); - } - else - { - pBufferPriv->drawable = - glitz_create_drawable (pScreenPriv->drawable, format, - pPixmap->drawable.width, - pPixmap->drawable.height); - - if (!pBufferPriv->drawable) - return FALSE; - - if (format->doublebuffer) - { - glitz_format_t *backFormat; - - backFormat = pBufferPriv->pVisual->format.surface; - - pBufferPriv->backSurface = - glitz_surface_create (pScreenPriv->drawable, backFormat, - pPixmap->drawable.width, - pPixmap->drawable.height, - 0, NULL); - if (pBufferPriv->backSurface) - glitz_surface_attach (pBufferPriv->backSurface, - pBufferPriv->drawable, - GLITZ_DRAWABLE_BUFFER_BACK_COLOR); - } - } - } - } - else - { - glitz_drawable_reference (pScreenPriv->drawable); - - if (pBufferPriv->backSurface) - glitz_surface_destroy (pBufferPriv->backSurface); - - if (pBufferPriv->drawable) - glitz_drawable_destroy (pBufferPriv->drawable); - - pBufferPriv->drawable = pScreenPriv->drawable; - pBufferPriv->backSurface = NULL; - } - - ValidateGC (pDrawable, pBufferPriv->pGC); - - return TRUE; -} - -static GLboolean -xglForceCurrent (__GLcontext *gc) -{ - xglGLContextPtr pContext = (xglGLContextPtr) gc; - __GLinterface *iface = pContext->mIface; - GLboolean status = GL_TRUE; + xglGLContextPtr pContext = (xglGLContextPtr) context; + __GLXcontext *mesaContext = pContext->mesaContext; + int status = TRUE; if (pContext && pContext->context) { - __GLdrawablePrivate *readPriv, *drawPriv; - - readPriv = pContext->readPriv; - drawPriv = pContext->drawPriv; - - drawPriv->lockDP (drawPriv, gc); - if (readPriv != drawPriv) - readPriv->lockDP (readPriv, gc); - cctx = pContext; if (cctx->pReadBuffer->pDrawable && cctx->pDrawBuffer->pDrawable) @@ -5236,44 +5490,18 @@ xglForceCurrent (__GLcontext *gc) if (cctx->pDrawBuffer->pPixmap != pDrawPixmap || cctx->pReadBuffer->pPixmap != pReadPixmap) { - if (!xglResizeBuffer (drawPriv, - pDrawable->x, - pDrawable->y, - pDrawable->width, - pDrawable->height)) - { - drawPriv->unlockDP (drawPriv); - if (readPriv != drawPriv) - readPriv->unlockDP (readPriv); - + if (!xglResizeBuffer (cctx->pDrawBuffer)) return FALSE; - } - - if (!xglResizeBuffer (readPriv, - cctx->pReadBuffer->pDrawable->x, - cctx->pReadBuffer->pDrawable->y, - cctx->pReadBuffer->pDrawable->width, - cctx->pReadBuffer->pDrawable->height)) - { - drawPriv->unlockDP (drawPriv); - if (readPriv != drawPriv) - readPriv->unlockDP (readPriv); + if (!xglResizeBuffer (cctx->pReadBuffer)) return FALSE; - } cctx->pReadBuffer->pPixmap = pReadPixmap; cctx->pDrawBuffer->pPixmap = pDrawPixmap; } if (!xglSyncSurface (pContext->pDrawBuffer->pDrawable)) - { - drawPriv->unlockDP (drawPriv); - if (readPriv != drawPriv) - readPriv->unlockDP (readPriv); - return FALSE; - } if (pDrawPixmap != pScreenPriv->pScreenPixmap) { @@ -5365,87 +5593,16 @@ xglForceCurrent (__GLcontext *gc) { xglSetCurrentContext (pContext); } - - drawPriv->unlockDP (drawPriv); - if (readPriv != drawPriv) - readPriv->unlockDP (readPriv); } else { cctx = NULL; - status = (*iface->exports.forceCurrent) ((__GLcontext *) iface); + status = (*mesaContext->forceCurrent) (mesaContext); } return status; } -static GLboolean -xglNotifyResize (__GLcontext *gc) -{ - xglGLContextPtr pContext = (xglGLContextPtr) gc; - __GLinterface *iface = pContext->mIface; - - if (!iface) - return GL_TRUE; - - return (*iface->exports.notifyResize) ((__GLcontext *) iface); -} - -static void -xglNotifyDestroy (__GLcontext *gc) -{ - xglGLContextPtr pContext = (xglGLContextPtr) gc; - __GLinterface *iface = pContext->mIface; - - pContext->pReadBuffer->pDrawable = 0; - pContext->pDrawBuffer->pDrawable = 0; - - if (iface) - (*iface->exports.notifyDestroy) ((__GLcontext *) iface); -} - -static void -xglNotifySwapBuffers (__GLcontext *gc) -{ - xglGLContextPtr pContext = (xglGLContextPtr) gc; - __GLinterface *iface = pContext->mIface; - - if (iface) - (*iface->exports.notifySwapBuffers) ((__GLcontext *) iface); -} - -static struct __GLdispatchStateRec * -xglDispatchExec (__GLcontext *gc) -{ - xglGLContextPtr pContext = (xglGLContextPtr) gc; - __GLinterface *iface = pContext->mIface; - - if (!iface) - return NULL; - - return (*iface->exports.dispatchExec) ((__GLcontext *) iface); -} - -static void -xglBeginDispatchOverride (__GLcontext *gc) -{ - xglGLContextPtr pContext = (xglGLContextPtr) gc; - __GLinterface *iface = pContext->mIface; - - if (iface) - (*iface->exports.beginDispatchOverride) ((__GLcontext *) iface); -} - -static void -xglEndDispatchOverride (__GLcontext *gc) -{ - xglGLContextPtr pContext = (xglGLContextPtr) gc; - __GLinterface *iface = pContext->mIface; - - if (iface) - (*iface->exports.endDispatchOverride) ((__GLcontext *) iface); -} - static void xglLoseCurrentContext (void *closure) { @@ -5462,24 +5619,26 @@ xglLoseCurrentContext (void *closure) } } -static __GLinterface * -xglCreateContext (__GLimports *imports, +static __GLXcontext * +xglCreateContext (__GLXscreen *screen, __GLcontextModes *modes, - __GLinterface *shareGC) + __GLXcontext *shareContext) { glitz_drawable_format_t *format; - xglGLContextPtr pShareContext = (xglGLContextPtr) shareGC; + xglGLScreenPtr pGLScreen = (xglGLScreenPtr) screen; + __GLXscreen *mesaScreen = pGLScreen->mesaScreen; + xglGLContextPtr pShareContext = (xglGLContextPtr) shareContext; xglGLContextPtr pContext; - __GLinterface *shareIface = NULL; - __GLinterface *iface; - __GLXcontext *glxCtx = (__GLXcontext *) imports->other; + __GLXcontext *shareMesaContext = NULL; - XGL_SCREEN_PRIV (glxCtx->pScreen); + XGL_SCREEN_PRIV (screen->pScreen); pContext = xalloc (sizeof (xglGLContextRec)); if (!pContext) return NULL; + memset (pContext, 0, sizeof (xglGLContextRec)); + format = glitz_drawable_get_format (pScreenPriv->drawable); pContext->context = glitz_context_create (pScreenPriv->drawable, format); glitz_context_set_user_data (pContext->context, pContext, @@ -5495,9 +5654,9 @@ xglCreateContext (__GLimports *imports, pContext->beginCnt = 0; pContext->nAttribStack = 0; pContext->refcnt = 1; - pContext->doubleBuffer = glxCtx->modes->doubleBufferMode; - pContext->depthBits = glxCtx->modes->depthBits; - pContext->stencilBits = glxCtx->modes->stencilBits; + pContext->doubleBuffer = modes->doubleBufferMode; + pContext->depthBits = modes->depthBits; + pContext->stencilBits = modes->stencilBits; pContext->drawXoff = 0; pContext->drawYoff = 0; pContext->maxTexUnits = 0; @@ -5517,7 +5676,7 @@ xglCreateContext (__GLimports *imports, pContext->attrib.scissorTest = GL_FALSE; - if (shareGC) + if (shareContext) { pContext->texObjects = NULL; pContext->renderbufferObjects = NULL; @@ -5525,7 +5684,7 @@ xglCreateContext (__GLimports *imports, pContext->displayLists = NULL; pContext->shared = pShareContext->shared; - shareIface = pShareContext->mIface; + shareMesaContext = pShareContext->mesaContext; } else { @@ -5562,417 +5721,79 @@ xglCreateContext (__GLimports *imports, pContext->shared->refcnt++; - iface = (*screenInfoPriv.createContext) (imports, modes, shareIface); - if (!iface) + pContext->base.destroy = xglDestroyContext; + pContext->base.makeCurrent = xglMakeCurrent; + pContext->base.loseCurrent = xglLoseCurrent; + pContext->base.copy = xglCopyContext; + pContext->base.forceCurrent = xglForceCurrent; + pContext->base.createDrawable = xglCreateDrawable; + + pContext->base.textureFromPixmap = &__xglTextureFromPixmapContext; + + pContext->mesaContext = (*mesaScreen->createContext) (mesaScreen, + modes, + shareMesaContext); + if (!pContext->mesaContext) { xglFreeContext (pContext); return NULL; } - pContext->mIface = iface; - pContext->iface.imports = *imports; - - pContext->iface.exports.destroyContext = xglDestroyContext; - pContext->iface.exports.loseCurrent = xglLoseCurrent; - pContext->iface.exports.makeCurrent = xglMakeCurrent; - pContext->iface.exports.shareContext = xglShareContext; - pContext->iface.exports.copyContext = xglCopyContext; - pContext->iface.exports.forceCurrent = xglForceCurrent; - pContext->iface.exports.notifyResize = xglNotifyResize; - pContext->iface.exports.notifyDestroy = xglNotifyDestroy; - pContext->iface.exports.notifySwapBuffers = xglNotifySwapBuffers; - pContext->iface.exports.dispatchExec = xglDispatchExec; - pContext->iface.exports.beginDispatchOverride = xglBeginDispatchOverride; - pContext->iface.exports.endDispatchOverride = xglEndDispatchOverride; - - return (__GLinterface *) pContext; -} - -static GLboolean -xglSwapBuffers (__GLXdrawablePrivate *glxPriv) -{ - __GLdrawablePrivate *glPriv = &glxPriv->glPriv; - xglGLBufferPtr pBufferPriv = glPriv->private; - DrawablePtr pDrawable = pBufferPriv->pDrawable; - GLboolean status = GL_TRUE; - - if (pDrawable) - { - if (glPriv->modes->doubleBufferMode) - { - glitz_surface_t *surface; - int xOff, yOff; - GCPtr pGC = pBufferPriv->pGC; - BoxPtr pBox = REGION_RECTS (pGC->pCompositeClip); - int nBox = REGION_NUM_RECTS (pGC->pCompositeClip); - - XGL_GET_DRAWABLE (pDrawable, surface, xOff, yOff); - - glitz_drawable_swap_buffer_region (pBufferPriv->drawable, - xOff, yOff, - (glitz_box_t *) pBox, nBox); - - xglAddBitDamage (pDrawable, pGC->pCompositeClip); - DamageDamageRegion (pDrawable, pGC->pCompositeClip); - REGION_EMPTY (pGC->pScreen, &pBufferPriv->damage); - } - } - else if (pBufferPriv->private) - { - glPriv->private = pBufferPriv->private; - status = (*pBufferPriv->swapBuffers) (glxPriv); - glPriv->private = pBufferPriv; - } - - return status; -} - -static GLboolean -xglResizeBuffers (__GLdrawableBuffer *buffer, - GLint x, - GLint y, - GLuint width, - GLuint height, - __GLdrawablePrivate *glPriv, - GLuint bufferMask) -{ - xglGLBufferPtr pBufferPriv = glPriv->private; - DrawablePtr pDrawable = pBufferPriv->pDrawable; - GLboolean status = GL_TRUE; - - if (pDrawable) - { - if (!xglResizeBuffer (glPriv, x, y, width, height)) - return GL_FALSE; - } - else if (pBufferPriv->private) - { - glPriv->private = pBufferPriv->private; - status = (*pBufferPriv->resizeBuffers) (buffer, - x, y, width, height, - glPriv, - bufferMask); - glPriv->private = pBufferPriv; - } - - return status; + return &pContext->base; } static int -xglBindBuffers (__GLXdrawablePrivate *glxPriv, - int buffer) +xglGetTexTarget (__GLXscreen *screen, + __GLXpixmap *pixmap) { - __GLdrawablePrivate *glPriv = &glxPriv->glPriv; - xglGLBufferPtr pBufferPriv = glPriv->private; + int target = GLX_NO_TEXTURE_EXT; - if (cctx) + XGL_DRAWABLE_PIXMAP (pixmap->pDraw); + + if (xglCreatePixmapSurface (pPixmap)) { - xglTexUnitPtr pTexUnit = &cctx->attrib.texUnits[cctx->activeTexUnit]; - xglTexObjPtr pTexObj = NULL; - DrawablePtr pDrawable; + glitz_texture_object_t *texture; - /* XXX: front left buffer is only supported so far */ - if (buffer != GLX_FRONT_LEFT_EXT) - return BadMatch; + XGL_PIXMAP_PRIV (pPixmap); - /* Must be a GLXpixmap */ - if (!glxPriv->pGlxPixmap) - return BadDrawable; - - pDrawable = glxPriv->pGlxPixmap->pDraw; - - switch (glxPriv->texTarget) { - case GLX_TEXTURE_RECTANGLE_EXT: - pTexObj = pTexUnit->pRect; - break; - case GLX_TEXTURE_2D_EXT: - pTexObj = pTexUnit->p2D; - break; - default: - break; - } - - if (pTexObj) + texture = glitz_texture_object_create (pPixmapPriv->surface); + if (texture) { - glitz_texture_object_t *object; - - XGL_SCREEN_PRIV (pDrawable->pScreen); - XGL_DRAWABLE_PIXMAP (pDrawable); - XGL_PIXMAP_PRIV (pPixmap); - - if (pPixmap == pScreenPriv->pScreenPixmap) - return BadDrawable; - - object = glitz_texture_object_create (pPixmapPriv->surface); - if (object) - { - pPixmap->refcnt++; - - if (pTexObj->pPixmap) - (*pDrawable->pScreen->DestroyPixmap) (pTexObj->pPixmap); - - if (pTexObj->object) - glitz_texture_object_destroy (pTexObj->object); - - pTexObj->pPixmap = pPixmap; - pTexObj->object = object; - - return Success; + switch (glitz_texture_object_get_target (texture)) { + case GLITZ_TEXTURE_TARGET_2D: + target = GLX_TEXTURE_2D_EXT; + break; + case GLITZ_TEXTURE_TARGET_RECT: + target = GLX_TEXTURE_RECTANGLE_EXT; + break; } + + glitz_texture_object_destroy (texture); } } - else if (pBufferPriv->private) - { - int status; - glPriv->private = pBufferPriv->private; - status = (*pBufferPriv->bindBuffers) (glxPriv, buffer); - glPriv->private = pBufferPriv; - - return status; - } - - return BadDrawable; + return target; } -static int -xglReleaseBuffers (__GLXdrawablePrivate *glxPriv, - int buffer) -{ - __GLdrawablePrivate *glPriv = &glxPriv->glPriv; - xglGLBufferPtr pBufferPriv = glPriv->private; - - if (cctx) - { - xglTexObjPtr pTexObj; - - /* XXX: front left buffer is only supported so far */ - if (buffer != GLX_FRONT_LEFT_EXT) - return BadMatch; - - /* Must be a GLXpixmap */ - if (glxPriv->pGlxPixmap) - { - DrawablePtr pDrawable = glxPriv->pGlxPixmap->pDraw; - - XGL_DRAWABLE_PIXMAP (pDrawable); - - pTexObj = cctx->attrib.texUnits[cctx->activeTexUnit].p2D; - if (pTexObj && pTexObj->pPixmap == pPixmap) - { - (*pDrawable->pScreen->DestroyPixmap) (pTexObj->pPixmap); - pTexObj->pPixmap = NULL; - glitz_texture_object_destroy (pTexObj->object); - pTexObj->object = NULL; - - return Success; - } - else - { - pTexObj = cctx->attrib.texUnits[cctx->activeTexUnit].pRect; - if (pTexObj && pTexObj->pPixmap == pPixmap) - { - (*pDrawable->pScreen->DestroyPixmap) (pTexObj->pPixmap); - pTexObj->pPixmap = NULL; - glitz_texture_object_destroy (pTexObj->object); - pTexObj->object = NULL; - - return Success; - } - } - } - } - else if (pBufferPriv->private) - { - int status; - - glPriv->private = pBufferPriv->private; - status = (*pBufferPriv->releaseBuffers) (glxPriv, buffer); - glPriv->private = pBufferPriv; - - return status; - } - - return BadDrawable; -} -static void -xglFreeBuffers (__GLdrawablePrivate *glPriv) -{ - xglGLBufferPtr pBufferPriv = glPriv->private; - - glPriv->private = pBufferPriv->private; - - if (pBufferPriv->freeBuffers) - (*pBufferPriv->freeBuffers) (glPriv); - - if (pBufferPriv->pGC) - FreeGC (pBufferPriv->pGC, (GContext) 0); - - if (pBufferPriv->backSurface) - glitz_surface_destroy (pBufferPriv->backSurface); - - if (pBufferPriv->drawable) - glitz_drawable_destroy (pBufferPriv->drawable); - - xfree (pBufferPriv); -} +static __GLXtextureFromPixmapScreen __xglTextureFromPixmapScreen = { + xglGetTexTarget, +}; static void -xglCreateBuffer (__GLXdrawablePrivate *glxPriv) +xglScreenDestroy (__GLXscreen *screen) { - __GLdrawablePrivate *glPriv = &glxPriv->glPriv; - DrawablePtr pDrawable = glxPriv->pDraw; - ScreenPtr pScreen = pDrawable->pScreen; - xglGLBufferPtr pBufferPriv; - xglVisualPtr v; + xglGLScreenPtr pScreen = (xglGLScreenPtr) screen; + __GLXscreen *mesaScreen = pScreen->mesaScreen; - XGL_SCREEN_PRIV (pScreen); - XGL_DRAWABLE_PIXMAP (pDrawable); + GlxScreenDestroy (screen); - pBufferPriv = xalloc (sizeof (xglGLBufferRec)); - if (!pBufferPriv) - FatalError ("xglCreateBuffer: No memory\n"); - - pBufferPriv->pScreen = pScreen; - pBufferPriv->pDrawable = NULL; - pBufferPriv->pPixmap = NULL; - pBufferPriv->pGC = NULL; - - pBufferPriv->swapBuffers = NULL; - - pBufferPriv->bindBuffers = NULL; - pBufferPriv->releaseBuffers = NULL; - - pBufferPriv->resizeBuffers = NULL; - pBufferPriv->private = NULL; - pBufferPriv->freeBuffers = NULL; - - pBufferPriv->drawable = NULL; - pBufferPriv->backSurface = NULL; - - REGION_INIT (pScreen, &pBufferPriv->damage, NullBox, 0); - - pBufferPriv->pVisual = 0; - - /* glx acceleration */ - if (pScreenPriv->accel.glx.enabled && - xglCheckPixmapSize (pPixmap, &pScreenPriv->accel.glx.size)) - { - for (v = pScreenPriv->pGlxVisual; v; v = v->next) - { - glitz_drawable_format_t *format; - - if (pScreenPriv->accel.glx.pbuffer != v->pbuffer) - continue; - - format = v->format.drawable; - if (!format) - continue; - - if (format->color.red_size != glxPriv->modes->redBits || - format->color.green_size != glxPriv->modes->greenBits || - format->color.blue_size != glxPriv->modes->blueBits) - continue; - - if (format->color.alpha_size < glxPriv->modes->alphaBits || - format->depth_size < glxPriv->modes->depthBits || - format->stencil_size < glxPriv->modes->stencilBits || - format->doublebuffer < glxPriv->modes->doubleBufferMode) - continue; - - /* this is good enought for pbuffers */ - if (v->pbuffer) - break; - - /* we want an exact match for non-pbuffer formats */ - if (format->color.alpha_size == glxPriv->modes->alphaBits && - format->depth_size == glxPriv->modes->depthBits && - format->stencil_size == glxPriv->modes->stencilBits && - format->doublebuffer == glxPriv->modes->doubleBufferMode) - break; - } - - pBufferPriv->pVisual = v; - } - - if ((pDrawable->type == DRAWABLE_WINDOW) - -#ifdef COMPOSITE - && (pBufferPriv->pVisual - - /* this is a root window, can't be redirected */ - || (!((WindowPtr) pDrawable)->parent)) -#endif - - ) - { - pBufferPriv->pDrawable = pDrawable; - } - else - { - (*screenInfoPriv.createBuffer) (glxPriv); - - /* Wrap the swap buffers routine */ - pBufferPriv->swapBuffers = glxPriv->swapBuffers; - - /* Wrap the render texture routines */ - pBufferPriv->bindBuffers = glxPriv->bindBuffers; - pBufferPriv->releaseBuffers = glxPriv->releaseBuffers; - - /* Wrap the front buffer's resize routine */ - pBufferPriv->resizeBuffers = glPriv->frontBuffer.resize; - - /* Save Xgl's private buffer structure */ - pBufferPriv->freeBuffers = glPriv->freePrivate; - pBufferPriv->private = glPriv->private; - } - - glxPriv->texTarget = GLX_NO_TEXTURE_EXT; - - /* We enable render texture for all GLXPixmaps right now. Eventually, this - should only be enabled when fbconfig attribute GLX_RENDER_TEXTURE_RGB or - GLX_RENDER_TEXTURE_RGBA is set to TRUE. */ - if (pDrawable->type != DRAWABLE_WINDOW) - { - XGL_DRAWABLE_PIXMAP (pDrawable); - - if (xglCreatePixmapSurface (pPixmap)) - { - glitz_texture_object_t *texture; - - XGL_PIXMAP_PRIV (pPixmap); - - texture = glitz_texture_object_create (pPixmapPriv->surface); - if (texture) - { - switch (glitz_texture_object_get_target (texture)) { - case GLITZ_TEXTURE_TARGET_2D: - glxPriv->texTarget = GLX_TEXTURE_2D_EXT; - break; - case GLITZ_TEXTURE_TARGET_RECT: - glxPriv->texTarget = GLX_TEXTURE_RECTANGLE_EXT; - break; - } - - glitz_texture_object_destroy (texture); - } - } - } - - glxPriv->swapBuffers = xglSwapBuffers; - - glxPriv->bindBuffers = xglBindBuffers; - glxPriv->releaseBuffers = xglReleaseBuffers; - glPriv->frontBuffer.resize = xglResizeBuffers; - - glPriv->private = (void *) pBufferPriv; - glPriv->freePrivate = xglFreeBuffers; + xfree (pScreen); } -static Bool -xglScreenProbe (int screen) +static __GLXscreen * +xglScreenProbe (ScreenPtr pScreen) { - ScreenPtr pScreen = screenInfo.screens[screen]; + xglGLScreenPtr screen; __GLcontextModes *modes; xglVisualPtr pVisual; Bool status; @@ -5980,12 +5801,26 @@ xglScreenProbe (int screen) XGL_SCREEN_PRIV (pScreen); - status = (*screenInfoPriv.screenProbe) (screen); + screen = (xglGLScreenPtr) xalloc (sizeof (xglGLScreenRec)); + if (!screen) + return NULL; - modes = __xglScreenInfo->modes; + memset (screen, 0, sizeof (xglGLScreenRec)); + + screen->base.destroy = xglScreenDestroy; + screen->base.createContext = xglCreateContext; + screen->base.pScreen = pScreen; + + screen->base.textureFromPixmap = &__xglTextureFromPixmapScreen; + + GlxScreenInit (&screen->base, pScreen); + + screen->mesaScreen = (*__xglMesaProvider->screenProbe) (pScreen); + + modes = screen->base.modes; /* Create Xgl GLX visuals */ - for (i = 0; i < __xglScreenInfo->numVisuals; i++) + for (i = 0; i < pScreen->numVisuals; i++) { pVisual = xglFindVisualWithId (pScreen, pScreen->visuals[i].vid); if (pVisual) @@ -6076,23 +5911,15 @@ xglScreenProbe (int screen) modes = modes->next; } - /* Wrap createBuffer */ - if (__xglScreenInfo->createBuffer != xglCreateBuffer) - { - screenInfoPriv.createBuffer = __xglScreenInfo->createBuffer; - __xglScreenInfo->createBuffer = xglCreateBuffer; - } - - /* Wrap createContext */ - if (__xglScreenInfo->createContext != xglCreateContext) - { - screenInfoPriv.createContext = __xglScreenInfo->createContext; - __xglScreenInfo->createContext = xglCreateContext; - } - - return status; + return &screen->base; } +__GLXprovider __glXXGLProvider = { + xglScreenProbe, + "XGL", + NULL +}; + Bool xglInitVisualConfigs (ScreenPtr pScreen) { @@ -6212,15 +6039,9 @@ xglInitVisualConfigs (ScreenPtr pScreen) pConfig[i].transparentIndex = 0; } + GlxPushProvider (&__glXXGLProvider); GlxSetVisualConfigs (numConfig, pConfig, (void **) ppConfigPriv); - /* Wrap screenProbe */ - if (__xglScreenInfo->screenProbe != xglScreenProbe) - { - screenInfoPriv.screenProbe = __xglScreenInfo->screenProbe; - __xglScreenInfo->screenProbe = xglScreenProbe; - } - visuals = pScreen->visuals; nvisuals = pScreen->numVisuals; depths = pScreen->allowedDepths; diff --git a/hw/xgl/xglglx.c b/hw/xgl/xglglx.c index 2bbe3306d..77acf9e43 100644 --- a/hw/xgl/xglglx.c +++ b/hw/xgl/xglglx.c @@ -38,36 +38,33 @@ FILE *__xglGLXLogFp; #endif static void *glXHandle = 0; -static void *glCoreHandle = 0; #define SYM(ptr, name) { (void **) &(ptr), (name) } -__GLXextensionInfo *__xglExtensionInfo; -__GLXscreenInfo *__xglScreenInfo; +__GLXprovider *__xglMesaProvider; -void *(*__glcore_DDXScreenInfo) (void); -void *(*__glcore_DDXExtensionInfo) (void); +void *(*__GlxGetMesaProvider) (void); void GlxSetVisualConfigs (int nconfigs, __GLXvisualConfig *configs, void **privates) { - if (glXHandle && glCoreHandle) + if (glXHandle) (*__xglGLXFunc.setVisualConfigs) (nconfigs, configs, privates); } void GlxExtensionInit (void) { - if (glXHandle && glCoreHandle) + if (glXHandle) (*__xglGLXFunc.extensionInit) (); } void GlxWrapInitVisuals (miInitVisualsProcPtr *initVisuals) { - if (glXHandle && glCoreHandle) + if (glXHandle) (*__xglGLXFunc.wrapInitVisuals) (initVisuals); } @@ -82,7 +79,7 @@ GlxInitVisuals (VisualPtr *visualp, int bitsPerRGB, int preferredVis) { - if (glXHandle && glCoreHandle) + if (glXHandle) return (*__xglGLXFunc.initVisuals) (visualp, depthp, nvisualp, ndepthp, rootDepthp, defaultVisp, sizes, bitsPerRGB, preferredVis); @@ -93,57 +90,49 @@ GlxInitVisuals (VisualPtr *visualp, void GlxFlushContextCache (void) { - (*__xglGLXFunc.flushContextCache) (); + if (glXHandle) + (*__xglGLXFunc.flushContextCache) (); } void GlxSetRenderTables (struct _glapi_table *table) { - (*__xglGLXFunc.setRenderTables) (table); -} - -void * -__glXglDDXScreenInfo (void) -{ - return __xglScreenInfo; -} - -void * -__glXglDDXExtensionInfo( void) -{ - return __xglExtensionInfo; + if (glXHandle) + (*__xglGLXFunc.setRenderTables) (table); } void -_gl_copy_visual_to_context_mode (__GLcontextModes *mode, - const __GLXvisualConfig *config) +GlxPushProvider (__GLXprovider *provider) { - (*__xglGLXFunc.copy_visual_to_context_mode) (mode, config); -} - -__GLcontextModes * -_gl_context_modes_create (unsigned count, - size_t minimumSize) -{ - return (*__xglGLXFunc.context_modes_create) (count, minimumSize); + if (glXHandle) + (*__xglGLXFunc.pushProvider) (provider); } void -_gl_context_modes_destroy (__GLcontextModes *modes) +GlxScreenInit (__GLXscreen *screen, + ScreenPtr pScreen) { - (*__xglGLXFunc.context_modes_destroy) (modes); + if (glXHandle) + (*__xglGLXFunc.screenInit) (screen, pScreen); } -GLint -_gl_convert_from_x_visual_type (int visualType) +void +GlxScreenDestroy (__GLXscreen *screen) { - return (*__xglGLXFunc.convert_from_x_visual_type) (visualType); + if (glXHandle) + (*__xglGLXFunc.screenDestroy) (screen); } -GLint -_gl_convert_to_x_visual_type (int visualType) +GLboolean +GlxDrawableInit (__GLXdrawable *drawable, + __GLXcontext *ctx, + DrawablePtr pDrawable, + XID drawId) { - return (*__xglGLXFunc.convert_to_x_visual_type) (visualType); + if (glXHandle) + return (*__xglGLXFunc.drawableInit) (drawable, ctx, pDrawable, drawId); + + return GL_FALSE; } Bool @@ -160,16 +149,12 @@ xglLoadGLXModules (void) SYM (__xglGLXFunc.initVisuals, "GlxInitVisuals"), SYM (__xglGLXFunc.flushContextCache, "__glXFlushContextCache"), SYM (__xglGLXFunc.setRenderTables, "GlxSetRenderTables"), - SYM (__xglGLXFunc.copy_visual_to_context_mode, - "_gl_copy_visual_to_context_mode"), - SYM (__xglGLXFunc.context_modes_create, - "_gl_context_modes_create"), - SYM (__xglGLXFunc.context_modes_destroy, - "_gl_context_modes_destroy"), - SYM (__xglGLXFunc.convert_from_x_visual_type, - "_gl_convert_from_x_visual_type"), - SYM (__xglGLXFunc.convert_to_x_visual_type, - "_gl_convert_to_x_visual_type") + SYM (__xglGLXFunc.pushProvider, "GlxPushProvider"), + SYM (__xglGLXFunc.screenInit, "__glXScreenInit"), + SYM (__xglGLXFunc.screenDestroy, "__glXScreenDestroy"), + SYM (__xglGLXFunc.drawableInit, "__glXDrawableInit"), + + SYM (__GlxGetMesaProvider, "GlxGetMesaProvider") }; glXHandle = xglLoadModule ("glx", RTLD_NOW | RTLD_LOCAL); @@ -183,65 +168,13 @@ xglLoadGLXModules (void) return FALSE; } - } - if (!glCoreHandle) - { - xglSymbolRec ddxSym[] = { - SYM (__glcore_DDXExtensionInfo, "__glXglDDXExtensionInfo"), - SYM (__glcore_DDXScreenInfo, "__glXglDDXScreenInfo") - }; + __xglMesaProvider = __GlxGetMesaProvider (); - glCoreHandle = xglLoadModule ("glcore", RTLD_NOW | RTLD_LOCAL); - if (!glCoreHandle) - return FALSE; - - if (!xglLookupSymbols (glCoreHandle, ddxSym, - sizeof (ddxSym) / sizeof(ddxSym[0]))) + if (!xglLoadHashFuncs (glXHandle)) { - xglUnloadModule (glCoreHandle); - glCoreHandle = 0; - - return FALSE; - } - - __xglScreenInfo = __glcore_DDXScreenInfo (); - __xglExtensionInfo = __glcore_DDXExtensionInfo (); - - if (__xglScreenInfo && __xglExtensionInfo) - { - xglSymbolRec sym[] = { - SYM (__xglScreenInfo->screenProbe, "__MESA_screenProbe"), - SYM (__xglScreenInfo->createContext, "__MESA_createContext"), - SYM (__xglScreenInfo->createBuffer, "__MESA_createBuffer"), - SYM (__xglExtensionInfo->resetExtension, - "__MESA_resetExtension"), - SYM (__xglExtensionInfo->initVisuals, "__MESA_initVisuals"), - SYM (__xglExtensionInfo->setVisualConfigs, - "__MESA_setVisualConfigs") - }; - - if (!xglLookupSymbols (glCoreHandle, sym, - sizeof (sym) / sizeof (sym[0]))) - { - xglUnloadModule (glCoreHandle); - glCoreHandle = 0; - - return FALSE; - } - } - else - { - xglUnloadModule (glCoreHandle); - glCoreHandle = 0; - - return FALSE; - } - - if (!xglLoadHashFuncs (glCoreHandle)) - { - xglUnloadModule (glCoreHandle); - glCoreHandle = 0; + xglUnloadModule (glXHandle); + glXHandle = 0; return FALSE; } @@ -264,12 +197,6 @@ xglUnloadGLXModules (void) xglUnloadModule (glXHandle); glXHandle = 0; } - - if (glCoreHandle) - { - xglUnloadModule (glCoreHandle); - glCoreHandle = 0; - } #endif } diff --git a/hw/xgl/xglglx.h b/hw/xgl/xglglx.h index c709f8c6e..0a8d3b58f 100644 --- a/hw/xgl/xglglx.h +++ b/hw/xgl/xglglx.h @@ -48,16 +48,14 @@ typedef struct _xglGLXFunc { int bitsPerRGB, int preferredVis); void (*flushContextCache) (void); - void *(*DDXExtensionInfo) (void); - void *(*DDXScreenInfo) (void); void (*setRenderTables) (struct _glapi_table *table); - void (*copy_visual_to_context_mode) (__GLcontextModes *mode, - const __GLXvisualConfig *config); - __GLcontextModes *(*context_modes_create) (unsigned count, - size_t minimumSize); - void (*context_modes_destroy) (__GLcontextModes *modes); - GLint (*convert_from_x_visual_type) (int visualType); - GLint (*convert_to_x_visual_type) (int visualType); + void (*pushProvider) (__GLXprovider *provider); + void (*screenInit) (__GLXscreen *screen, ScreenPtr pScreen); + void (*screenDestroy) (__GLXscreen *screen); + GLboolean (*drawableInit) (__GLXdrawable *drawable, + __GLXcontext *ctx, + DrawablePtr pDrawable, + XID drawId); } xglGLXFuncRec, *xglGLXFuncPtr; extern xglGLXFuncRec __xglGLXFunc;