Merge branch 'master' of git+ssh://[email protected]/git/mesa/mesa into 965-glsl

12 files changed, 858 insertions, 382 deletions

diff --git a/src/mesa/drivers/x11/fakeglx.c b/src/mesa/drivers/x11/fakeglx.c
index eecd52aa32b..1587df66bcd 100644
--- a/src/mesa/drivers/x11/fakeglx.c
+++ b/src/mesa/drivers/x11/fakeglx.c
@@ -1,8 +1,8 @@
 /*
  * Mesa 3-D graphics library
- * Version:  6.5.2
+ * Version:  7.1
  *
- * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -78,6 +78,7 @@
    "GLX_MESA_pixmap_colormap " \
    "GLX_MESA_release_buffers " \
    "GLX_ARB_get_proc_address " \
+   "GLX_EXT_texture_from_pixmap " \
    "GLX_EXT_visual_info " \
    "GLX_EXT_visual_rating " \
    /*"GLX_SGI_video_sync "*/ \
@@ -1223,6 +1224,30 @@ choose_visual( Display *dpy, int screen, const int *list, GLboolean fbConfig )
             /* ignore */
             break;
 
+#ifdef GLX_EXT_texture_from_pixmap
+         case GLX_BIND_TO_TEXTURE_RGB_EXT:
+            parselist++; /*skip*/
+            break;
+         case GLX_BIND_TO_TEXTURE_RGBA_EXT:
+            parselist++; /*skip*/
+            break;
+         case GLX_BIND_TO_MIPMAP_TEXTURE_EXT:
+            parselist++; /*skip*/
+            break;
+         case GLX_BIND_TO_TEXTURE_TARGETS_EXT:
+            parselist++;
+            if (*parselist & ~(GLX_TEXTURE_1D_BIT_EXT |
+                               GLX_TEXTURE_2D_BIT_EXT |
+                               GLX_TEXTURE_RECTANGLE_BIT_EXT)) {
+               /* invalid bit */
+               return NULL;
+            }
+            break;
+         case GLX_Y_INVERTED_EXT:
+            parselist++; /*skip*/
+            break;
+#endif
+
 	 case None:
             /* end of list */
 	    break;
@@ -1440,11 +1465,14 @@ Fake_glXMakeContextCurrent( Display *dpy, GLXDrawable draw,
       }
       if (!drawBuffer) {
          /* drawable must be a new window! */
-         drawBuffer = XMesaCreateWindowBuffer2( xmctx->xm_visual, draw, xmctx);
+         drawBuffer = XMesaCreateWindowBuffer( xmctx->xm_visual, draw );
          if (!drawBuffer) {
             /* Out of memory, or context/drawable depth mismatch */
             return False;
          }
+#ifdef FX
+         FXcreateContext( xmctx->xm_visual, draw, xmctx, drawBuffer );
+#endif
       }
 
       /* Find the XMesaBuffer which corresponds to the GLXDrawable 'read' */
@@ -1457,12 +1485,14 @@ Fake_glXMakeContextCurrent( Display *dpy, GLXDrawable draw,
       }
       if (!readBuffer) {
          /* drawable must be a new window! */
-         readBuffer = XMesaCreateWindowBuffer2(glxCtx->xmesaContext->xm_visual,
-                                               read, xmctx);
+         readBuffer = XMesaCreateWindowBuffer( xmctx->xm_visual, read );
          if (!readBuffer) {
             /* Out of memory, or context/drawable depth mismatch */
             return False;
          }
+#ifdef FX
+         FXcreateContext( xmctx->xm_visual, read, xmctx, readBuffer );
+#endif
       }
 
       MakeCurrent_PrevContext = ctx;
@@ -1873,6 +1903,27 @@ get_config( XMesaVisual xmvis, int attrib, int *value, GLboolean fbconfig )
          *value = xmvis->visinfo->visualid;
          break;
 
+#ifdef GLX_EXT_texture_from_pixmap
+      case GLX_BIND_TO_TEXTURE_RGB_EXT:
+         *value = True; /*XXX*/
+         break;
+      case GLX_BIND_TO_TEXTURE_RGBA_EXT:
+         /* XXX review */
+         *value = xmvis->mesa_visual.alphaBits > 0 ? True : False;
+         break;
+      case GLX_BIND_TO_MIPMAP_TEXTURE_EXT:
+         *value = True; /*XXX*/
+         break;
+      case GLX_BIND_TO_TEXTURE_TARGETS_EXT:
+         *value = (GLX_TEXTURE_1D_BIT_EXT |
+                   GLX_TEXTURE_2D_BIT_EXT |
+                   GLX_TEXTURE_RECTANGLE_BIT_EXT); /*XXX*/
+         break;
+      case GLX_Y_INVERTED_EXT:
+         *value = True; /*XXX*/
+         break;
+#endif
+
       default:
 	 return GLX_BAD_ATTRIBUTE;
    }
@@ -2107,10 +2158,15 @@ Fake_glXCreateWindow( Display *dpy, GLXFBConfig config, Window win,
    if (!xmvis)
       return 0;
 
-   xmbuf = XMesaCreateWindowBuffer2(xmvis, win, NULL);
+   xmbuf = XMesaCreateWindowBuffer(xmvis, win);
    if (!xmbuf)
       return 0;
 
+#ifdef FX
+   /* XXX this will segfault if actually called */
+   FXcreateContext(xmvis, win, NULL, xmbuf);
+#endif
+
    (void) dpy;
    (void) attribList;  /* Ignored in GLX 1.3 */
 
@@ -2135,16 +2191,102 @@ Fake_glXCreatePixmap( Display *dpy, GLXFBConfig config, Pixmap pixmap,
 {
    XMesaVisual v = (XMesaVisual) config;
    XMesaBuffer b;
-
-   (void) dpy;
-   (void) config;
-   (void) pixmap;
-   (void) attribList;  /* Ignored in GLX 1.3 */
+   const int *attr;
+   int target = 0, format = 0, mipmap = 0;
+   int value;
 
    if (!dpy || !config || !pixmap)
       return 0;
 
-   b = XMesaCreatePixmapBuffer( v, pixmap, 0 );
+   for (attr = attribList; *attr; attr++) {
+      switch (*attr) {
+      case GLX_TEXTURE_FORMAT_EXT:
+         attr++;
+         switch (*attr) {
+         case GLX_TEXTURE_FORMAT_NONE_EXT:
+         case GLX_TEXTURE_FORMAT_RGB_EXT:
+         case GLX_TEXTURE_FORMAT_RGBA_EXT:
+            format = *attr;
+            break;
+         default:
+            /* error */
+            return 0;
+         }
+         break;
+      case GLX_TEXTURE_TARGET_EXT:
+         attr++;
+         switch (*attr) {
+         case GLX_TEXTURE_1D_EXT:
+         case GLX_TEXTURE_2D_EXT:
+         case GLX_TEXTURE_RECTANGLE_EXT:
+            target = *attr;
+            break;
+         default:
+            /* error */
+            return 0;
+         }
+         break;
+      case GLX_MIPMAP_TEXTURE_EXT:
+         attr++;
+         if (*attr)
+            mipmap = 1;
+         break;
+      default:
+         /* error */
+         return 0;
+      }
+   }
+
+   if (format == GLX_TEXTURE_FORMAT_RGB_EXT) {
+      if (get_config(v, GLX_BIND_TO_TEXTURE_RGB_EXT,
+                     &value, GL_TRUE) != Success
+          || !value) {
+         return 0; /* error! */
+      }
+   }
+   else if (format == GLX_TEXTURE_FORMAT_RGBA_EXT) {
+      if (get_config(v, GLX_BIND_TO_TEXTURE_RGBA_EXT,
+                     &value, GL_TRUE) != Success
+          || !value) {
+         return 0; /* error! */
+      }
+   }
+   if (mipmap) {
+      if (get_config(v, GLX_BIND_TO_MIPMAP_TEXTURE_EXT,
+                     &value, GL_TRUE) != Success
+          || !value) {
+         return 0; /* error! */
+      }
+   }
+   if (target == GLX_TEXTURE_1D_EXT) {
+      if (get_config(v, GLX_BIND_TO_TEXTURE_TARGETS_EXT,
+                     &value, GL_TRUE) != Success
+          || (value & GLX_TEXTURE_1D_BIT_EXT) == 0) {
+         return 0; /* error! */
+      }
+   }
+   else if (target == GLX_TEXTURE_2D_EXT) {
+      if (get_config(v, GLX_BIND_TO_TEXTURE_TARGETS_EXT,
+                     &value, GL_TRUE) != Success
+          || (value & GLX_TEXTURE_2D_BIT_EXT) == 0) {
+         return 0; /* error! */
+      }
+   }
+   if (target == GLX_TEXTURE_RECTANGLE_EXT) {
+      if (get_config(v, GLX_BIND_TO_TEXTURE_TARGETS_EXT,
+                     &value, GL_TRUE) != Success
+          || (value & GLX_TEXTURE_RECTANGLE_BIT_EXT) == 0) {
+         return 0; /* error! */
+      }
+   }
+
+   if (format || target || mipmap) {
+      /* texture from pixmap */
+      b = XMesaCreatePixmapTextureBuffer(v, pixmap, 0, format, target, mipmap);
+   }
+   else {
+      b = XMesaCreatePixmapBuffer( v, pixmap, 0 );
+   }
    if (!b) {
       return 0;
    }
@@ -2250,8 +2392,20 @@ Fake_glXQueryDrawable( Display *dpy, GLXDrawable draw, int attribute,
       case GLX_FBCONFIG_ID:
          *value = xmbuf->xm_visual->visinfo->visualid;
          return;
+#ifdef GLX_EXT_texture_from_pixmap
+      case GLX_TEXTURE_FORMAT_EXT:
+         *value = xmbuf->TextureFormat;
+         break;
+      case GLX_TEXTURE_TARGET_EXT:
+         *value = xmbuf->TextureTarget;
+         break;
+      case GLX_MIPMAP_TEXTURE_EXT:
+         *value = xmbuf->TextureMipmap;
+         break;
+#endif
+
       default:
-         return;  /* GLX_BAD_ATTRIBUTE? */
+         return; /* raise BadValue error */
    }
 }
 
@@ -2844,6 +2998,26 @@ Fake_glXGetAGPOffsetMESA( const GLvoid *pointer )
 }
 
 
+/*** GLX_EXT_texture_from_pixmap ***/
+
+static void
+Fake_glXBindTexImageEXT(Display *dpy, GLXDrawable drawable, int buffer,
+                        const int *attrib_list)
+{
+   XMesaBuffer b = XMesaFindBuffer(dpy, drawable);
+   if (b)
+      XMesaBindTexImage(dpy, b, buffer, attrib_list);
+}
+
+static void
+Fake_glXReleaseTexImageEXT(Display *dpy, GLXDrawable drawable, int buffer)
+{
+   XMesaBuffer b = XMesaFindBuffer(dpy, drawable);
+   if (b)
+      XMesaReleaseTexImage(dpy, b, buffer);
+}
+
+
 /* silence warning */
 extern struct _glxapi_table *_mesa_GetGLXDispatchTable(void);
 
@@ -2999,5 +3173,9 @@ _mesa_GetGLXDispatchTable(void)
    /*** GLX_MESA_agp_offset ***/
    glx.GetAGPOffsetMESA = Fake_glXGetAGPOffsetMESA;
 
+   /*** GLX_EXT_texture_from_pixmap ***/
+   glx.BindTexImageEXT = Fake_glXBindTexImageEXT;
+   glx.ReleaseTexImageEXT = Fake_glXReleaseTexImageEXT;
+
    return &glx;
 }
diff --git a/src/mesa/drivers/x11/glxapi.c b/src/mesa/drivers/x11/glxapi.c
index 973f3940451..309a0008d76 100644
--- a/src/mesa/drivers/x11/glxapi.c
+++ b/src/mesa/drivers/x11/glxapi.c
@@ -1,8 +1,8 @@
 /*
  * Mesa 3-D graphics library
- * Version:  6.5
+ * Version:  7.1
  * 
- * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -141,7 +141,7 @@ static void
 SetCurrentContext(GLXContext c)
 {
 #if defined(GLX_USE_TLS)
-   CurrentContext = context;
+   CurrentContext = c;
 #elif defined(THREADS)
    _glthread_SetTSD(&ContextTSD, c);
 #else
@@ -1104,6 +1104,27 @@ glXGetMemoryOffsetMESA(Display *dpy, int scrn, const void *pointer)
 }
 
 
+/*** GLX_EXT_texture_from_pixmap */
+
+void
+glXBindTexImageEXT(Display *dpy, GLXDrawable drawable, int buffer,
+                   const int *attrib_list)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (t)
+      t->BindTexImageEXT(dpy, drawable, buffer, attrib_list);
+}
+
+void
+glXReleaseTexImageEXT(Display *dpy, GLXDrawable drawable, int buffer)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (t)
+      t->ReleaseTexImageEXT(dpy, drawable, buffer);
+}
+
 
 /**********************************************************************/
 /* GLX API management functions                                       */
@@ -1148,6 +1169,9 @@ _glxapi_get_extensions(void)
 #ifdef GLX_SGIX_pbuffer
       "GLX_SGIX_pbuffer",
 #endif
+#ifdef GLX_EXT_texture_from_pixmap
+      "GLX_EXT_texture_from_pixmap",
+#endif
       NULL
    };
    return extensions;
@@ -1333,6 +1357,10 @@ static struct name_address_pair GLX_functions[] = {
    { "glXFreeMemoryMESA", (__GLXextFuncPtr) glXFreeMemoryMESA },
    { "glXGetMemoryOffsetMESA", (__GLXextFuncPtr) glXGetMemoryOffsetMESA },
 
+   /*** GLX_EXT_texture_from_pixmap ***/
+   { "glXBindTexImageEXT", (__GLXextFuncPtr) glXBindTexImageEXT },
+   { "glXReleaseTexImageEXT", (__GLXextFuncPtr) glXReleaseTexImageEXT },
+
    { NULL, NULL }   /* end of list */
 };
 
diff --git a/src/mesa/drivers/x11/glxapi.h b/src/mesa/drivers/x11/glxapi.h
index 3187534c9a3..37de81e55ac 100644
--- a/src/mesa/drivers/x11/glxapi.h
+++ b/src/mesa/drivers/x11/glxapi.h
@@ -196,6 +196,11 @@ struct _glxapi_table {
 
    /*** GLX_MESA_agp_offset ***/
    GLuint (*GetAGPOffsetMESA)( const GLvoid *pointer );
+
+   /*** GLX_EXT_texture_from_pixmap ***/
+   void (*BindTexImageEXT)(Display *dpy, GLXDrawable drawable, int buffer,
+                           const int *attrib_list);
+   void (*ReleaseTexImageEXT)(Display *dpy, GLXDrawable drawable, int buffer);
 };
 
 
diff --git a/src/mesa/drivers/x11/xm_api.c b/src/mesa/drivers/x11/xm_api.c
index 24028a44ba7..eaa277db4ad 100644
--- a/src/mesa/drivers/x11/xm_api.c
+++ b/src/mesa/drivers/x11/xm_api.c
@@ -1,8 +1,8 @@
 /*
  * Mesa 3-D graphics library
- * Version:  6.5.2
+ * Version:  7.1
  *
- * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -72,6 +72,7 @@
 #include "imports.h"
 #include "macros.h"
 #include "renderbuffer.h"
+#include "teximage.h"
 #include "swrast/swrast.h"
 #include "swrast_setup/swrast_setup.h"
 #include "vbo/vbo.h"
@@ -292,8 +293,20 @@ static GLboolean window_exists( XMesaDisplay *dpy, Window win )
    XSetErrorHandler(old_handler);
    return WindowExistsFlag;
 }
-#endif
 
+static Status
+get_drawable_size( XMesaDisplay *dpy, Drawable d, GLuint *width, GLuint *height )
+{
+   Window root;
+   Status stat;
+   int xpos, ypos;
+   unsigned int w, h, bw, depth;
+   stat = XGetGeometry(dpy, d, &root, &xpos, &ypos, &w, &h, &bw, &depth);
+   *width = w;
+   *height = h;
+   return stat;
+}
+#endif
 
 
 /**
@@ -310,22 +323,14 @@ xmesa_get_window_size(XMesaDisplay *dpy, XMesaBuffer b,
    *width = MIN2(b->frontxrb->drawable->width, MAX_WIDTH);
    *height = MIN2(b->frontxrb->drawable->height, MAX_HEIGHT);
 #else
-   Window root;
    Status stat;
-   int xpos, ypos;
-   unsigned int w, h, bw, depth;
 
    _glthread_LOCK_MUTEX(_xmesa_lock);
    XSync(b->xm_visual->display, 0); /* added for Chromium */
-   stat = XGetGeometry(dpy, b->frontxrb->pixmap, &root, &xpos, &ypos,
-                       &w, &h, &bw, &depth);
+   stat = get_drawable_size(dpy, b->frontxrb->pixmap, width, height);
    _glthread_UNLOCK_MUTEX(_xmesa_lock);
 
-   if (stat) {
-      *width = w;
-      *height = h;
-   }
-   else {
+   if (!stat) {
       /* probably querying a window that's recently been destroyed */
       _mesa_warning(NULL, "XGetGeometry failed!\n");
       *width = *height = 1;
@@ -431,6 +436,11 @@ create_xmesa_buffer(XMesaDrawable d, BufferType type,
                                 b->swAlpha,
                                 vis->mesa_visual.numAuxBuffers > 0 );
 
+   /* GLX_EXT_texture_from_pixmap */
+   b->TextureTarget = 0;
+   b->TextureFormat = GLX_TEXTURE_FORMAT_NONE_EXT;
+   b->TextureMipmap = 0;
+
    /* insert buffer into linked list */
    b->Next = XMesaBufferList;
    XMesaBufferList = b;
@@ -1036,10 +1046,16 @@ setup_monochrome( XMesaVisual v, XMesaBuffer b )
  * \return GL_TRUE=success, GL_FALSE=failure
  */
 static GLboolean
-initialize_visual_and_buffer(int client, XMesaVisual v, XMesaBuffer b,
+initialize_visual_and_buffer(XMesaVisual v, XMesaBuffer b,
                              GLboolean rgb_flag, XMesaDrawable window,
                              XMesaColormap cmap)
 {
+   int client = 0;
+
+#ifdef XFree86Server
+   client = (window) ? CLIENT_ID(window->id) : 0;
+#endif
+
    ASSERT(!b || b->xm_visual == v);
 
    /* Save true bits/pixel */
@@ -1103,6 +1119,8 @@ initialize_visual_and_buffer(int client, XMesaVisual v, XMesaBuffer b,
    }
 
    if (b && window) {
+      char *data;
+
       /* Do window-specific initializations */
 
       /* these should have been set in create_xmesa_buffer */
@@ -1170,15 +1188,15 @@ initialize_visual_and_buffer(int client, XMesaVisual v, XMesaBuffer b,
       }
 
       /* Initialize the row buffer XImage for use in write_color_span() */
+      data = (char*) MALLOC(MAX_WIDTH*4);
 #ifdef XFree86Server
-      b->rowimage = XMesaCreateImage(GET_VISUAL_DEPTH(v), MAX_WIDTH, 1,
-				     (char *)MALLOC(MAX_WIDTH*4));
+      b->rowimage = XMesaCreateImage(GET_VISUAL_DEPTH(v), MAX_WIDTH, 1, data);
 #else
       b->rowimage = XCreateImage( v->display,
                                   v->visinfo->visual,
                                   v->visinfo->depth,
                                   ZPixmap, 0,           /*format, offset*/
-                                  (char*) MALLOC(MAX_WIDTH*4),  /*data*/
+                                  data,                 /*data*/
                                   MAX_WIDTH, 1,         /*width, height*/
                                   32,                   /*bitmap_pad*/
                                   0                     /*bytes_per_line*/ );
@@ -1308,6 +1326,7 @@ xmesa_convert_from_x_visual_type( int visualType )
  *         visualCaveat - ala the GLX extension, usually GLX_NONE
  * Return;  a new XMesaVisual or 0 if error.
  */
+PUBLIC
 XMesaVisual XMesaCreateVisual( XMesaDisplay *display,
                                XMesaVisualInfo visinfo,
                                GLboolean rgb_flag,
@@ -1409,7 +1428,7 @@ XMesaVisual XMesaCreateVisual( XMesaDisplay *display,
    if (alpha_flag)
       v->mesa_visual.alphaBits = 8;
 
-   (void) initialize_visual_and_buffer( 0, v, NULL, rgb_flag, 0, 0 );
+   (void) initialize_visual_and_buffer( v, NULL, rgb_flag, 0, 0 );
 
    {
       const int xclass = v->mesa_visual.visualType;
@@ -1450,6 +1469,7 @@ XMesaVisual XMesaCreateVisual( XMesaDisplay *display,
 }
 
 
+PUBLIC
 void XMesaDestroyVisual( XMesaVisual v )
 {
 #ifndef XFree86Server
@@ -1467,6 +1487,7 @@ void XMesaDestroyVisual( XMesaVisual v )
  *                    lists or NULL if no sharing is wanted.
  * \return an XMesaContext or NULL if error.
  */
+PUBLIC
 XMesaContext XMesaCreateContext( XMesaVisual v, XMesaContext share_list )
 {
    static GLboolean firstTime = GL_TRUE;
@@ -1550,15 +1571,15 @@ XMesaContext XMesaCreateContext( XMesaVisual v, XMesaContext share_list )
 
 
 
+PUBLIC
 void XMesaDestroyContext( XMesaContext c )
 {
    GLcontext *mesaCtx = &c->mesa;
-#ifdef FX
-   XMesaBuffer xmbuf = XMESA_BUFFER(mesaCtx->DrawBuffer);
 
-   if (xmbuf && xmbuf->FXctx)
-      fxMesaDestroyContext(xmbuf->FXctx);
+#ifdef FX
+   FXdestroyContext( XMESA_BUFFER(mesaCtx->DrawBuffer) );
 #endif
+
    _swsetup_DestroyContext( mesaCtx );
    _swrast_DestroyContext( mesaCtx );
    _tnl_DestroyContext( mesaCtx );
@@ -1574,44 +1595,33 @@ void XMesaDestroyContext( XMesaContext c )
  * X window or pixmap.
  * \param v  the window's XMesaVisual
  * \param w  the window we're wrapping
- * \param c  context used to initialize the buffer if 3Dfx mode in use.
  * \return  new XMesaBuffer or NULL if error
  */
-XMesaBuffer
-XMesaCreateWindowBuffer2(XMesaVisual v, XMesaWindow w, XMesaContext c)
+PUBLIC XMesaBuffer
+XMesaCreateWindowBuffer(XMesaVisual v, XMesaWindow w)
 {
 #ifndef XFree86Server
    XWindowAttributes attr;
 #endif
-#ifdef FX
-   char *fxEnvVar;
-#endif
-   int client = 0;
    XMesaBuffer b;
    XMesaColormap cmap;
+   int depth;
 
    assert(v);
    assert(w);
-   (void) c;
 
    /* Check that window depth matches visual depth */
 #ifdef XFree86Server
-   client = CLIENT_ID(((XMesaDrawable)w)->id);
-
-   if (GET_VISUAL_DEPTH(v) != ((XMesaDrawable)w)->depth) {
-      _mesa_warning(NULL, "XMesaCreateWindowBuffer: depth mismatch between visual (%d) and window (%d)!\n",
-                    GET_VISUAL_DEPTH(v), ((XMesaDrawable) w)->depth);
-      return NULL;
-   }
+   depth = ((XMesaDrawable)w)->depth;
 #else
    XGetWindowAttributes( v->display, w, &attr );
-
-   if (GET_VISUAL_DEPTH(v) != attr.depth) {
+   depth = attr.depth;
+#endif
+   if (GET_VISUAL_DEPTH(v) != depth) {
       _mesa_warning(NULL, "XMesaCreateWindowBuffer: depth mismatch between visual (%d) and window (%d)!\n",
-                    GET_VISUAL_DEPTH(v), attr.depth);
+                    GET_VISUAL_DEPTH(v), depth);
       return NULL;
    }
-#endif
 
    /* Find colormap */
 #ifdef XFree86Server
@@ -1632,101 +1642,16 @@ XMesaCreateWindowBuffer2(XMesaVisual v, XMesaWindow w, XMesaContext c)
    if (!b)
       return NULL;
 
-   if (!initialize_visual_and_buffer( client, v, b, v->mesa_visual.rgbMode,
+   if (!initialize_visual_and_buffer( v, b, v->mesa_visual.rgbMode,
                                       (XMesaDrawable) w, cmap )) {
       xmesa_free_buffer(b);
       return NULL;
    }
 
-#ifdef FX
-   fxEnvVar = _mesa_getenv("MESA_GLX_FX");
-   if (fxEnvVar) {
-     if (fxEnvVar[0]!='d') {
-       int attribs[100];
-       int numAttribs = 0;
-       int hw;
-       if (v->mesa_visual.depthBits > 0) {
-	 attribs[numAttribs++] = FXMESA_DEPTH_SIZE;
-	 attribs[numAttribs++] = v->mesa_visual.depthBits;
-       }
-       if (v->mesa_visual.doubleBufferMode) {
-	 attribs[numAttribs++] = FXMESA_DOUBLEBUFFER;
-       }
-       if (v->mesa_visual.accumRedBits > 0) {
-	 attribs[numAttribs++] = FXMESA_ACCUM_SIZE;
-	 attribs[numAttribs++] = v->mesa_visual.accumRedBits;
-       }
-       if (v->mesa_visual.stencilBits > 0) {
-         attribs[numAttribs++] = FXMESA_STENCIL_SIZE;
-         attribs[numAttribs++] = v->mesa_visual.stencilBits;
-       }
-       if (v->mesa_visual.alphaBits > 0) {
-         attribs[numAttribs++] = FXMESA_ALPHA_SIZE;
-         attribs[numAttribs++] = v->mesa_visual.alphaBits;
-       }
-       if (1) {
-         attribs[numAttribs++] = FXMESA_SHARE_CONTEXT;
-         attribs[numAttribs++] = (int) &(c->mesa);
-       }
-       attribs[numAttribs++] = FXMESA_NONE;
-
-       /* [dBorca] we should take an envvar for `fxMesaSelectCurrentBoard'!!! */
-       hw = fxMesaSelectCurrentBoard(0);
-
-       /* if these fail, there's a new bug somewhere */
-       ASSERT(b->mesa_buffer.Width > 0);
-       ASSERT(b->mesa_buffer.Height > 0);
-
-       if ((hw == GR_SSTTYPE_VOODOO) || (hw == GR_SSTTYPE_Voodoo2)) {
-         b->FXctx = fxMesaCreateBestContext(0, b->mesa_buffer.Width,
-                                            b->mesa_buffer.Height, attribs);
-         if ((v->undithered_pf!=PF_Index) && (b->backxrb->ximage)) {
-	   b->FXisHackUsable = b->FXctx ? GL_TRUE : GL_FALSE;
-	   if (b->FXctx && (fxEnvVar[0]=='w' || fxEnvVar[0]=='W')) {
-	     b->FXwindowHack = GL_TRUE;
-	     FX_grSstControl(GR_CONTROL_DEACTIVATE);
-	   }
-           else {
-	     b->FXwindowHack = GL_FALSE;
-	   }
-         }
-       }
-       else {
-         if (fxEnvVar[0]=='w' || fxEnvVar[0]=='W')
-	   b->FXctx = fxMesaCreateContext(w, GR_RESOLUTION_NONE,
-					  GR_REFRESH_75Hz, attribs);
-         else
-	   b->FXctx = fxMesaCreateBestContext(0, b->mesa_buffer.Width,
-                                              b->mesa_buffer.Height, attribs);
-         b->FXisHackUsable = GL_FALSE;
-         b->FXwindowHack = GL_FALSE;
-       }
-       /*
-       fprintf(stderr,
-               "voodoo %d, wid %d height %d hack: usable %d active %d\n",
-               hw, b->mesa_buffer.Width, b->mesa_buffer.Height,
-	       b->FXisHackUsable, b->FXwindowHack);
-       */
-     }
-   }
-   else {
-      _mesa_warning(NULL, "WARNING: This Mesa Library includes the Glide driver but\n");
-      _mesa_warning(NULL, "         you have not defined the MESA_GLX_FX env. var.\n");
-      _mesa_warning(NULL, "         (check the README.3DFX file for more information).\n\n");
-      _mesa_warning(NULL, "         you can disable this message with a 'export MESA_GLX_FX=disable'.\n");
-   }
-#endif
-
    return b;
 }
 
 
-XMesaBuffer
-XMesaCreateWindowBuffer(XMesaVisual v, XMesaWindow w)
-{
-   return XMesaCreateWindowBuffer2( v, w, NULL );
-}
-
 
 /**
  * Create a new XMesaBuffer from an X pixmap.
@@ -1737,10 +1662,9 @@ XMesaCreateWindowBuffer(XMesaVisual v, XMesaWindow w)
  *             \c GLX_DIRECT_COLOR visual for the pixmap
  * \returns new XMesaBuffer or NULL if error
  */
-XMesaBuffer
+PUBLIC XMesaBuffer
 XMesaCreatePixmapBuffer(XMesaVisual v, XMesaPixmap p, XMesaColormap cmap)
 {
-   int client = 0;
    XMesaBuffer b;
 
    assert(v);
@@ -1749,11 +1673,68 @@ XMesaCreatePixmapBuffer(XMesaVisual v, XMesaPixmap p, XMesaColormap cmap)
    if (!b)
       return NULL;
 
-#ifdef XFree86Server
-   client = CLIENT_ID(((XMesaDrawable)p)->id);
-#endif
+   if (!initialize_visual_and_buffer(v, b, v->mesa_visual.rgbMode,
+				     (XMesaDrawable) p, cmap)) {
+      xmesa_free_buffer(b);
+      return NULL;
+   }
+
+   return b;
+}
+
+
+/**
+ * For GLX_EXT_texture_from_pixmap
+ */
+XMesaBuffer
+XMesaCreatePixmapTextureBuffer(XMesaVisual v, XMesaPixmap p,
+                               XMesaColormap cmap,
+                               int format, int target, int mipmap)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   XMesaBuffer b;
+   GLuint width, height;
+
+   assert(v);
+
+   b = create_xmesa_buffer((XMesaDrawable) p, PIXMAP, v, cmap);
+   if (!b)
+      return NULL;
+
+   /* get pixmap size, update framebuffer/renderbuffer dims */
+   xmesa_get_window_size(v->display, b, &width, &height);
+   _mesa_resize_framebuffer(NULL, &(b->mesa_buffer), width, height);
+
+   if (target == 0) {
+      /* examine dims */
+      if (ctx->Extensions.ARB_texture_non_power_of_two) {
+         target = GLX_TEXTURE_2D_EXT;
+      }
+      else if (   _mesa_bitcount(width)  == 1
+               && _mesa_bitcount(height) == 1) {
+         /* power of two size */
+         if (height == 1) {
+            target = GLX_TEXTURE_1D_EXT;
+         }
+         else {
+            target = GLX_TEXTURE_2D_EXT;
+         }
+      }
+      else if (ctx->Extensions.NV_texture_rectangle) {
+         target = GLX_TEXTURE_RECTANGLE_EXT;
+      }
+      else {
+         /* non power of two textures not supported */
+         XMesaDestroyBuffer(b);
+         return 0;
+      }
+   }
+
+   b->TextureTarget = target;
+   b->TextureFormat = format;
+   b->TextureMipmap = mipmap;
 
-   if (!initialize_visual_and_buffer(client, v, b, v->mesa_visual.rgbMode,
+   if (!initialize_visual_and_buffer(v, b, v->mesa_visual.rgbMode,
 				     (XMesaDrawable) p, cmap)) {
       xmesa_free_buffer(b);
       return NULL;
@@ -1768,10 +1749,7 @@ XMesaBuffer
 XMesaCreatePBuffer(XMesaVisual v, XMesaColormap cmap,
                    unsigned int width, unsigned int height)
 {
-#ifdef XFree86Server
-   return 0;
-#else
-   int client = 0;
+#ifndef XFree86Server
    XMesaWindow root;
    XMesaDrawable drawable;  /* X Pixmap Drawable */
    XMesaBuffer b;
@@ -1787,13 +1765,15 @@ XMesaCreatePBuffer(XMesaVisual v, XMesaColormap cmap,
    if (!b)
       return NULL;
 
-   if (!initialize_visual_and_buffer(client, v, b, v->mesa_visual.rgbMode,
+   if (!initialize_visual_and_buffer(v, b, v->mesa_visual.rgbMode,
 				     drawable, cmap)) {
       xmesa_free_buffer(b);
       return NULL;
    }
 
    return b;
+#else
+   return 0;
 #endif
 }
 
@@ -1802,7 +1782,7 @@ XMesaCreatePBuffer(XMesaVisual v, XMesaColormap cmap,
 /*
  * Deallocate an XMesaBuffer structure and all related info.
  */
-void
+PUBLIC void
 XMesaDestroyBuffer(XMesaBuffer b)
 {
    xmesa_free_buffer(b);
@@ -1845,6 +1825,7 @@ GLboolean XMesaMakeCurrent( XMesaContext c, XMesaBuffer b )
 /*
  * Bind buffer b to context c and make c the current rendering context.
  */
+PUBLIC
 GLboolean XMesaMakeCurrent2( XMesaContext c, XMesaBuffer drawBuffer,
                              XMesaBuffer readBuffer )
 {
@@ -1852,15 +1833,6 @@ GLboolean XMesaMakeCurrent2( XMesaContext c, XMesaBuffer drawBuffer,
       if (!drawBuffer || !readBuffer)
          return GL_FALSE;  /* must specify buffers! */
 
-#ifdef FX
-      if (drawBuffer->FXctx) {
-         fxMesaMakeCurrent(drawBuffer->FXctx);
-
-         c->xm_buffer = drawBuffer;
-
-         return GL_TRUE;
-      }
-#endif
       if (&(c->mesa) == _mesa_get_current_context()
           && c->mesa.DrawBuffer == &drawBuffer->mesa_buffer
           && c->mesa.ReadBuffer == &readBuffer->mesa_buffer
@@ -1871,6 +1843,11 @@ GLboolean XMesaMakeCurrent2( XMesaContext c, XMesaBuffer drawBuffer,
 
       c->xm_buffer = drawBuffer;
 
+#ifdef FX
+      if (FXmakeCurrent( drawBuffer ))
+         return GL_TRUE;
+#endif
+
       /* Call this periodically to detect when the user has begun using
        * GL rendering from multiple threads.
        */
@@ -1958,12 +1935,12 @@ XMesaBuffer XMesaGetCurrentReadBuffer( void )
 }
 
 
+#ifdef XFree86Server
+PUBLIC
 GLboolean XMesaForceCurrent(XMesaContext c)
 {
    if (c) {
-#ifdef XGLServer
       _glapi_set_dispatch(c->mesa.CurrentDispatch);
-#endif
 
       if (&(c->mesa) != _mesa_get_current_context()) {
 	 _mesa_make_current(&c->mesa, c->mesa.DrawBuffer, c->mesa.ReadBuffer);
@@ -1976,6 +1953,7 @@ GLboolean XMesaForceCurrent(XMesaContext c)
 }
 
 
+PUBLIC
 GLboolean XMesaLoseCurrent(XMesaContext c)
 {
    (void) c;
@@ -1984,157 +1962,30 @@ GLboolean XMesaLoseCurrent(XMesaContext c)
 }
 
 
+PUBLIC
 GLboolean XMesaCopyContext( XMesaContext xm_src, XMesaContext xm_dst, GLuint mask )
 {
    _mesa_copy_context(&xm_src->mesa, &xm_dst->mesa, mask);
    return GL_TRUE;
 }
+#endif /* XFree86Server */
 
 
-/*
- * Switch 3Dfx support hack between window and full-screen mode.
- */
+#ifndef FX
 GLboolean XMesaSetFXmode( GLint mode )
 {
-#ifdef FX
-   const char *fx = _mesa_getenv("MESA_GLX_FX");
-   if (fx && fx[0] != 'd') {
-      GET_CURRENT_CONTEXT(ctx);
-      GrHwConfiguration hw;
-      if (!FX_grSstQueryHardware(&hw)) {
-         /*fprintf(stderr, "!grSstQueryHardware\n");*/
-         return GL_FALSE;
-      }
-      if (hw.num_sst < 1) {
-         /*fprintf(stderr, "hw.num_sst < 1\n");*/
-         return GL_FALSE;
-      }
-      if (ctx) {
-         /* [dBorca] Hack alert: 
-	  * oh, this is sooo wrong: ctx above is
-	  * really an fxMesaContext, not an XMesaContext
-	  */
-         XMesaBuffer xmbuf = XMESA_BUFFER(ctx->DrawBuffer);
-         if (mode == XMESA_FX_WINDOW) {
-	    if (xmbuf->FXisHackUsable) {
-	       FX_grSstControl(GR_CONTROL_DEACTIVATE);
-	       xmbuf->FXwindowHack = GL_TRUE;
-	       return GL_TRUE;
-	    }
-	 }
-	 else if (mode == XMESA_FX_FULLSCREEN) {
-	    FX_grSstControl(GR_CONTROL_ACTIVATE);
-	    xmbuf->FXwindowHack = GL_FALSE;
-	    return GL_TRUE;
-	 }
-	 else {
-	    /* Error: Bad mode value */
-	 }
-      }
-   }
-   /*fprintf(stderr, "fallthrough\n");*/
-#else
    (void) mode;
-#endif
    return GL_FALSE;
 }
-
-
-
-#ifdef FX
-/*
- * Read image from VooDoo frame buffer into X/Mesa's back XImage.
- */
-static void FXgetImage( XMesaBuffer b )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   static unsigned short pixbuf[MAX_WIDTH];
-   GLuint x, y;
-   GLuint width, height;
-   XMesaContext xmesa = XMESA_CONTEXT(ctx);
-
-#ifdef XFree86Server
-   x = b->frontxrb->pixmap->x;
-   y = b->frontxrb->pixmap->y;
-   width = b->frontxrb->pixmap->width;
-   height = b->frontxrb->pixmap->height;
-   depth = b->frontxrb->pixmap->depth;
-#else
-   xmesa_get_window_size(b->display, b, &width, &height);
-   x = y = 0;
-#endif
-   if (b->mesa_buffer.Width != width || b->mesa_buffer.Height != height) {
-      b->mesa_buffer.Width = MIN2((int)width, b->FXctx->width);
-      b->mesa_buffer.Height = MIN2((int)height, b->FXctx->height);
-      if (b->mesa_buffer.Width & 1)
-         b->mesa_buffer.Width--;  /* prevent odd width */
-   }
-
-   /* [dBorca] we're always in the right GR_COLORFORMAT... aren't we? */
-   /* grLfbWriteColorFormat(GR_COLORFORMAT_ARGB); */
-   if (b->xm_visual->undithered_pf==PF_5R6G5B) {
-      /* Special case: 16bpp RGB */
-      grLfbReadRegion( GR_BUFFER_FRONTBUFFER,       /* src buffer */
-                       0, b->FXctx->height - b->mesa_buffer.Height,  /*pos*/
-                       b->mesa_buffer.Width, b->mesa_buffer.Height,  /* size */
-                       b->mesa_buffer.Width * sizeof(GLushort), /* stride */
-                       b->backxrb->ximage->data);         /* dest buffer */
-   }
-   else if (b->xm_visual->dithered_pf==PF_Dither
-	    && GET_VISUAL_DEPTH(b->xm_visual)==8) {
-      /* Special case: 8bpp RGB */
-      for (y=0;y<b->mesa_buffer.Height;y++) {
-         GLubyte *ptr = (GLubyte*) b->backxrb->ximage->data
-                        + b->backxrb->ximage->bytes_per_line * y;
-         XDITHER_SETUP(y);
-
-         /* read row from 3Dfx frame buffer */
-         grLfbReadRegion( GR_BUFFER_FRONTBUFFER,
-                          0, b->FXctx->height-(b->mesa_buffer.Height-y),
-                          b->mesa_buffer.Width, 1,
-                          0,
-                          pixbuf );
-
-         /* write to XImage back buffer */
-         for (x=0;x<b->mesa_buffer.Width;x++) {
-            GLubyte r = (pixbuf[x] & 0xf800) >> 8;
-            GLubyte g = (pixbuf[x] & 0x07e0) >> 3;
-            GLubyte b = (pixbuf[x] & 0x001f) << 3;
-            *ptr++ = XDITHER( x, r, g, b);
-         }
-      }
-   }
-   else {
-      /* General case: slow! */
-      for (y=0;y<b->mesa_buffer.Height;y++) {
-         /* read row from 3Dfx frame buffer */
-         grLfbReadRegion( GR_BUFFER_FRONTBUFFER,
-                          0, b->FXctx->height-(b->mesa_buffer.Height-y),
-                          b->mesa_buffer.Width, 1,
-                          0,
-                          pixbuf );
-
-         /* write to XImage back buffer */
-         for (x=0;x<b->mesa_buffer.Width;x++) {
-            XMesaPutPixel(b->backxrb->ximage,x,y,
-			  xmesa_color_to_pixel(ctx,
-					       (pixbuf[x] & 0xf800) >> 8,
-					       (pixbuf[x] & 0x07e0) >> 3,
-					       (pixbuf[x] & 0x001f) << 3,
-					       0xff,
-                                               b->xm_visual->undithered_pf));
-         }
-      }
-   }
-   /* grLfbWriteColorFormat(GR_COLORFORMAT_ABGR); */
-}
 #endif
 
 
+
 /*
  * Copy the back buffer to the front buffer.  If there's no back buffer
  * this is a no-op.
  */
+PUBLIC
 void XMesaSwapBuffers( XMesaBuffer b )
 {
    GET_CURRENT_CONTEXT(ctx);
@@ -2152,16 +2003,10 @@ void XMesaSwapBuffers( XMesaBuffer b )
 
    if (b->db_mode) {
 #ifdef FX
-      if (b->FXctx) {
-         fxMesaSwapBuffers();
-
-         if (b->FXwindowHack)
-            FXgetImage(b);
-         else
-            return;
-      }
+      if (FXswapBuffers(b))
+         return;
 #endif
-     if (b->backxrb->ximage) {
+      if (b->backxrb->ximage) {
 	 /* Copy Ximage (back buf) from client memory to server window */
 #if defined(USE_XSHM) && !defined(XFree86Server)
 	 if (b->shm) {
@@ -2228,13 +2073,8 @@ void XMesaCopySubBuffer( XMesaBuffer b, int x, int y, int width, int height )
    if (b->db_mode) {
       int yTop = b->mesa_buffer.Height - y - height;
 #ifdef FX
-      if (b->FXctx) {
-         fxMesaSwapBuffers();
-         if (b->FXwindowHack)
-            FXgetImage(b);
-         else
-            return;
-      }
+      if (FXswapBuffers(b))
+         return;
 #endif
       if (b->backxrb->ximage) {
          /* Copy Ximage from host's memory to server's window */
@@ -2475,7 +2315,7 @@ unsigned long XMesaDitherColor( XMesaContext xmesa, GLint x, GLint y,
  * This is typically called when the window size changes and we need
  * to reallocate the buffer's back/depth/stencil/accum buffers.
  */
-void
+PUBLIC void
 XMesaResizeBuffers( XMesaBuffer b )
 {
    GET_CURRENT_CONTEXT(ctx);
@@ -2485,3 +2325,154 @@ XMesaResizeBuffers( XMesaBuffer b )
    xmesa_check_and_update_buffer_size(xmctx, b);
 }
 
+
+static GLint
+xbuffer_to_renderbuffer(int buffer)
+{
+   assert(MAX_AUX_BUFFERS <= 4);
+
+   switch (buffer) {
+   case GLX_FRONT_LEFT_EXT:
+      return BUFFER_FRONT_LEFT;
+   case GLX_FRONT_RIGHT_EXT:
+      return BUFFER_FRONT_RIGHT;
+   case GLX_BACK_LEFT_EXT:
+      return BUFFER_BACK_LEFT;
+   case GLX_BACK_RIGHT_EXT:
+      return BUFFER_BACK_RIGHT;
+   case GLX_AUX0_EXT:
+      return BUFFER_AUX0;
+   case GLX_AUX1_EXT:
+      return BUFFER_AUX1;
+   case GLX_AUX2_EXT:
+      return BUFFER_AUX2;
+   case GLX_AUX3_EXT:
+      return BUFFER_AUX3;
+   case GLX_AUX4_EXT:
+   case GLX_AUX5_EXT:
+   case GLX_AUX6_EXT:
+   case GLX_AUX7_EXT:
+   case GLX_AUX8_EXT:
+   case GLX_AUX9_EXT:
+   default:
+      /* BadValue error */
+      return -1;
+   }
+}
+
+
+PUBLIC void
+XMesaBindTexImage(XMesaDisplay *dpy, XMesaBuffer drawable, int buffer,
+                  const int *attrib_list)
+{
+#if 0
+   GET_CURRENT_CONTEXT(ctx);
+   const GLuint unit = ctx->Texture.CurrentUnit;
+   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
+   struct gl_texture_object *texObj;
+#endif
+   struct gl_renderbuffer *rb;
+   struct xmesa_renderbuffer *xrb;
+   GLint b;
+   XMesaImage *img = NULL;
+   GLboolean freeImg = GL_FALSE;
+
+   b = xbuffer_to_renderbuffer(buffer);
+   if (b < 0)
+      return;
+
+   if (drawable->TextureFormat == GLX_TEXTURE_FORMAT_NONE_EXT)
+      return; /* BadMatch error */
+
+   rb = drawable->mesa_buffer.Attachment[b].Renderbuffer;
+   if (!rb) {
+      /* invalid buffer */
+      return;
+   }
+   xrb = xmesa_renderbuffer(rb);
+
+#if 0
+   switch (drawable->TextureTarget) {
+   case GLX_TEXTURE_1D_EXT:
+      texObj = texUnit->Current1D;
+      break;
+   case GLX_TEXTURE_2D_EXT:
+      texObj = texUnit->Current2D;
+      break;
+   case GLX_TEXTURE_RECTANGLE_EXT:
+      texObj = texUnit->CurrentRect;
+      break;
+   default:
+      return; /* BadMatch error */
+   }
+#endif
+
+   /*
+    * The following is a quick and simple way to implement
+    * BindTexImage.  The better way is to write some new FetchTexel()
+    * functions which would extract texels from XImages.  We'd still
+    * need to use GetImage when texturing from a Pixmap (front buffer)
+    * but texturing from a back buffer (XImage) would avoid an image
+    * copy.
+    */
+
+   /* get XImage */
+   if (xrb->pixmap) {
+      img = XMesaGetImage(dpy, xrb->pixmap, 0, 0, rb->Width, rb->Height, ~0L,
+			  ZPixmap);
+      freeImg = GL_TRUE;
+   }
+   else if (xrb->ximage) {
+      img = xrb->ximage;
+   }
+
+   /* store the XImage as a new texture image */
+   if (img) {
+      GLenum format, type, intFormat;
+      if (img->bits_per_pixel == 32) {
+         format = GL_BGRA;
+         type = GL_UNSIGNED_BYTE;
+         intFormat = GL_RGBA;
+      }
+      else if (img->bits_per_pixel == 24) {
+         format = GL_BGR;
+         type = GL_UNSIGNED_BYTE;
+         intFormat = GL_RGB;
+      }
+      else if (img->bits_per_pixel == 16) {
+         format = GL_BGR;
+         type = GL_UNSIGNED_SHORT_5_6_5;
+         intFormat = GL_RGB;
+      }
+      else {
+         _mesa_problem(NULL, "Unexpected XImage format in XMesaBindTexImage");
+         return;
+      }
+      if (drawable->TextureFormat == GLX_TEXTURE_FORMAT_RGBA_EXT) {
+         intFormat = GL_RGBA;
+      }
+      else if (drawable->TextureFormat == GLX_TEXTURE_FORMAT_RGB_EXT) {
+         intFormat = GL_RGB;
+      }
+
+      _mesa_TexImage2D(GL_TEXTURE_2D, 0, intFormat, rb->Width, rb->Height, 0,
+                       format, type, img->data);
+
+      if (freeImg) {
+	 XMesaDestroyImage(img);
+      }
+   }
+}
+
+
+
+PUBLIC void
+XMesaReleaseTexImage(XMesaDisplay *dpy, XMesaBuffer drawable, int buffer)
+{
+   const GLint b = xbuffer_to_renderbuffer(buffer);
+   if (b < 0)
+      return;
+
+   /* no-op for now */
+}
+
diff --git a/src/mesa/drivers/x11/xm_buffer.c b/src/mesa/drivers/x11/xm_buffer.c
index 10621cb7a15..51d183bb435 100644
--- a/src/mesa/drivers/x11/xm_buffer.c
+++ b/src/mesa/drivers/x11/xm_buffer.c
@@ -383,18 +383,18 @@ xmesa_delete_framebuffer(struct gl_framebuffer *fb)
    }
 
    if (b->gc)
-      XMesaFreeGC(b->xm_visual->display, b->gc);
+      XMesaFreeGC(b->display, b->gc);
    if (b->cleargc)
-      XMesaFreeGC(b->xm_visual->display, b->cleargc);
+      XMesaFreeGC(b->display, b->cleargc);
    if (b->swapgc)
-      XMesaFreeGC(b->xm_visual->display, b->swapgc);
+      XMesaFreeGC(b->display, b->swapgc);
 
-   if (b->xm_visual->mesa_visual.doubleBufferMode) {
+   if (fb->Visual.doubleBufferMode) {
       /* free back ximage/pixmap/shmregion */
       if (b->backxrb->ximage) {
 #if defined(USE_XSHM) && !defined(XFree86Server)
          if (b->shm) {
-            XShmDetach( b->xm_visual->display, &b->shminfo );
+            XShmDetach( b->display, &b->shminfo );
             XDestroyImage( b->backxrb->ximage );
             shmdt( b->shminfo.shmaddr );
          }
@@ -404,9 +404,9 @@ xmesa_delete_framebuffer(struct gl_framebuffer *fb)
          b->backxrb->ximage = NULL;
       }
       if (b->backxrb->pixmap) {
-         XMesaFreePixmap( b->xm_visual->display, b->backxrb->pixmap );
+         XMesaFreePixmap( b->display, b->backxrb->pixmap );
          if (b->xm_visual->hpcr_clear_flag) {
-            XMesaFreePixmap( b->xm_visual->display,
+            XMesaFreePixmap( b->display,
                              b->xm_visual->hpcr_clear_pixmap );
             XMesaDestroyImage( b->xm_visual->hpcr_clear_ximage );
          }
diff --git a/src/mesa/drivers/x11/xm_dd.c b/src/mesa/drivers/x11/xm_dd.c
index 543ff69c411..c8546236fbf 100644
--- a/src/mesa/drivers/x11/xm_dd.c
+++ b/src/mesa/drivers/x11/xm_dd.c
@@ -438,7 +438,7 @@ xmesa_DrawPixels_8R8G8B( GLcontext *ctx,
 {
    const SWcontext *swrast = SWRAST_CONTEXT( ctx );
    struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0][0];
-   struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb->Wrapped;
+   struct xmesa_renderbuffer *xrb = xmesa_renderbuffer(rb->Wrapped);
 
    if (swrast->NewState)
       _swrast_validate_derived( ctx );
@@ -546,7 +546,7 @@ xmesa_DrawPixels_5R6G5B( GLcontext *ctx,
                          const GLvoid *pixels )
 {
    struct xmesa_renderbuffer *xrb
-      = (struct xmesa_renderbuffer *) ctx->DrawBuffer->_ColorDrawBuffers[0][0];
+      = xmesa_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0][0]->Wrapped);
    const XMesaContext xmesa = XMESA_CONTEXT(ctx);
    const SWcontext *swrast = SWRAST_CONTEXT( ctx );
    XMesaDisplay *dpy = xmesa->xm_visual->display;
@@ -652,10 +652,10 @@ xmesa_CopyPixels( GLcontext *ctx,
    const SWcontext *swrast = SWRAST_CONTEXT( ctx );
    XMesaDisplay *dpy = xmesa->xm_visual->display;
    const XMesaGC gc = ((XMesaBuffer) ctx->DrawBuffer)->gc;
-   struct xmesa_renderbuffer *srcXrb = (struct xmesa_renderbuffer *)
-      ctx->ReadBuffer->_ColorReadBuffer;
-   struct xmesa_renderbuffer *dstXrb = (struct xmesa_renderbuffer *)
-      ctx->DrawBuffer->_ColorDrawBuffers[0][0];
+   struct xmesa_renderbuffer *srcXrb
+      = xmesa_renderbuffer(ctx->ReadBuffer->_ColorReadBuffer->Wrapped);
+   struct xmesa_renderbuffer *dstXrb
+      = xmesa_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0][0]->Wrapped);
 
    ASSERT(dpy);
    ASSERT(gc);
diff --git a/src/mesa/drivers/x11/xm_glide.c b/src/mesa/drivers/x11/xm_glide.c
new file mode 100644
index 00000000000..ae4f4282dbb
--- /dev/null
+++ b/src/mesa/drivers/x11/xm_glide.c
@@ -0,0 +1,276 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  6.5
+ *
+ * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glxheader.h"
+#include "xmesaP.h"
+
+#ifdef FX
+#include "../glide/fxdrv.h"
+
+void
+FXcreateContext(XMesaVisual v, XMesaWindow w, XMesaContext c, XMesaBuffer b)
+{
+   char *fxEnvVar = _mesa_getenv("MESA_GLX_FX");
+   if (fxEnvVar) {
+     if (fxEnvVar[0]!='d') {
+       int attribs[100];
+       int numAttribs = 0;
+       int hw;
+       if (v->mesa_visual.depthBits > 0) {
+	 attribs[numAttribs++] = FXMESA_DEPTH_SIZE;
+	 attribs[numAttribs++] = v->mesa_visual.depthBits;
+       }
+       if (v->mesa_visual.doubleBufferMode) {
+	 attribs[numAttribs++] = FXMESA_DOUBLEBUFFER;
+       }
+       if (v->mesa_visual.accumRedBits > 0) {
+	 attribs[numAttribs++] = FXMESA_ACCUM_SIZE;
+	 attribs[numAttribs++] = v->mesa_visual.accumRedBits;
+       }
+       if (v->mesa_visual.stencilBits > 0) {
+         attribs[numAttribs++] = FXMESA_STENCIL_SIZE;
+         attribs[numAttribs++] = v->mesa_visual.stencilBits;
+       }
+       if (v->mesa_visual.alphaBits > 0) {
+         attribs[numAttribs++] = FXMESA_ALPHA_SIZE;
+         attribs[numAttribs++] = v->mesa_visual.alphaBits;
+       }
+       if (1) {
+         attribs[numAttribs++] = FXMESA_SHARE_CONTEXT;
+         attribs[numAttribs++] = (int) &(c->mesa);
+       }
+       attribs[numAttribs++] = FXMESA_NONE;
+
+       /* [dBorca] we should take an envvar for `fxMesaSelectCurrentBoard'!!! */
+       hw = fxMesaSelectCurrentBoard(0);
+
+       /* if these fail, there's a new bug somewhere */
+       ASSERT(b->mesa_buffer.Width > 0);
+       ASSERT(b->mesa_buffer.Height > 0);
+
+       if ((hw == GR_SSTTYPE_VOODOO) || (hw == GR_SSTTYPE_Voodoo2)) {
+         b->FXctx = fxMesaCreateBestContext(0, b->mesa_buffer.Width,
+                                            b->mesa_buffer.Height, attribs);
+         if ((v->undithered_pf!=PF_Index) && (b->backxrb->ximage)) {
+	   b->FXisHackUsable = b->FXctx ? GL_TRUE : GL_FALSE;
+	   if (b->FXctx && (fxEnvVar[0]=='w' || fxEnvVar[0]=='W')) {
+	     b->FXwindowHack = GL_TRUE;
+	     FX_grSstControl(GR_CONTROL_DEACTIVATE);
+	   }
+           else {
+	     b->FXwindowHack = GL_FALSE;
+	   }
+         }
+       }
+       else {
+         if (fxEnvVar[0]=='w' || fxEnvVar[0]=='W')
+	   b->FXctx = fxMesaCreateContext(w, GR_RESOLUTION_NONE,
+					  GR_REFRESH_75Hz, attribs);
+         else
+	   b->FXctx = fxMesaCreateBestContext(0, b->mesa_buffer.Width,
+                                              b->mesa_buffer.Height, attribs);
+         b->FXisHackUsable = GL_FALSE;
+         b->FXwindowHack = GL_FALSE;
+       }
+       /*
+       fprintf(stderr,
+               "voodoo %d, wid %d height %d hack: usable %d active %d\n",
+               hw, b->mesa_buffer.Width, b->mesa_buffer.Height,
+	       b->FXisHackUsable, b->FXwindowHack);
+       */
+     }
+   }
+   else {
+      _mesa_warning(NULL, "WARNING: This Mesa Library includes the Glide driver but\n");
+      _mesa_warning(NULL, "         you have not defined the MESA_GLX_FX env. var.\n");
+      _mesa_warning(NULL, "         (check the README.3DFX file for more information).\n\n");
+      _mesa_warning(NULL, "         you can disable this message with a 'export MESA_GLX_FX=disable'.\n");
+   }
+}
+
+
+void FXdestroyContext( XMesaBuffer b )
+{
+   if (b && b->FXctx)
+      fxMesaDestroyContext(b->FXctx);
+}
+
+
+GLboolean FXmakeCurrent( XMesaBuffer b )
+{
+   if (b->FXctx) {
+      fxMesaMakeCurrent(b->FXctx);
+
+      return GL_TRUE;
+   }
+   return GL_FALSE;
+}
+
+
+/*
+ * Read image from VooDoo frame buffer into X/Mesa's back XImage.
+ */
+static void FXgetImage( XMesaBuffer b )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   static unsigned short pixbuf[MAX_WIDTH];
+   GLuint x, y;
+   GLuint width, height;
+
+#ifdef XFree86Server
+   x = b->frontxrb->pixmap->x;
+   y = b->frontxrb->pixmap->y;
+   width = b->frontxrb->pixmap->width;
+   height = b->frontxrb->pixmap->height;
+   depth = b->frontxrb->pixmap->depth;
+#else
+   xmesa_get_window_size(b->display, b, &width, &height);
+   x = y = 0;
+#endif
+   if (b->mesa_buffer.Width != width || b->mesa_buffer.Height != height) {
+      b->mesa_buffer.Width = MIN2((int)width, b->FXctx->width);
+      b->mesa_buffer.Height = MIN2((int)height, b->FXctx->height);
+      if (b->mesa_buffer.Width & 1)
+         b->mesa_buffer.Width--;  /* prevent odd width */
+   }
+
+   /* [dBorca] we're always in the right GR_COLORFORMAT... aren't we? */
+   /* grLfbWriteColorFormat(GR_COLORFORMAT_ARGB); */
+   if (b->xm_visual->undithered_pf==PF_5R6G5B) {
+      /* Special case: 16bpp RGB */
+      grLfbReadRegion( GR_BUFFER_FRONTBUFFER,       /* src buffer */
+                       0, b->FXctx->height - b->mesa_buffer.Height,  /*pos*/
+                       b->mesa_buffer.Width, b->mesa_buffer.Height,  /* size */
+                       b->mesa_buffer.Width * sizeof(GLushort), /* stride */
+                       b->backxrb->ximage->data);         /* dest buffer */
+   }
+   else if (b->xm_visual->dithered_pf==PF_Dither
+	    && GET_VISUAL_DEPTH(b->xm_visual)==8) {
+      /* Special case: 8bpp RGB */
+      for (y=0;y<b->mesa_buffer.Height;y++) {
+         GLubyte *ptr = (GLubyte*) b->backxrb->ximage->data
+                        + b->backxrb->ximage->bytes_per_line * y;
+         XDITHER_SETUP(y);
+
+         /* read row from 3Dfx frame buffer */
+         grLfbReadRegion( GR_BUFFER_FRONTBUFFER,
+                          0, b->FXctx->height-(b->mesa_buffer.Height-y),
+                          b->mesa_buffer.Width, 1,
+                          0,
+                          pixbuf );
+
+         /* write to XImage back buffer */
+         for (x=0;x<b->mesa_buffer.Width;x++) {
+            GLubyte r = (pixbuf[x] & 0xf800) >> 8;
+            GLubyte g = (pixbuf[x] & 0x07e0) >> 3;
+            GLubyte b = (pixbuf[x] & 0x001f) << 3;
+            *ptr++ = XDITHER( x, r, g, b);
+         }
+      }
+   }
+   else {
+      /* General case: slow! */
+      for (y=0;y<b->mesa_buffer.Height;y++) {
+         /* read row from 3Dfx frame buffer */
+         grLfbReadRegion( GR_BUFFER_FRONTBUFFER,
+                          0, b->FXctx->height-(b->mesa_buffer.Height-y),
+                          b->mesa_buffer.Width, 1,
+                          0,
+                          pixbuf );
+
+         /* write to XImage back buffer */
+         for (x=0;x<b->mesa_buffer.Width;x++) {
+            XMesaPutPixel(b->backxrb->ximage,x,y,
+			  xmesa_color_to_pixel(ctx,
+					       (pixbuf[x] & 0xf800) >> 8,
+					       (pixbuf[x] & 0x07e0) >> 3,
+					       (pixbuf[x] & 0x001f) << 3,
+					       0xff,
+                                               b->xm_visual->undithered_pf));
+         }
+      }
+   }
+   /* grLfbWriteColorFormat(GR_COLORFORMAT_ABGR); */
+}
+
+
+GLboolean FXswapBuffers( XMesaBuffer b )
+{
+   if (b->FXctx) {
+      fxMesaSwapBuffers();
+
+      if (!b->FXwindowHack)
+         return GL_TRUE;
+
+      FXgetImage(b);
+   }
+   return GL_FALSE;
+}
+
+
+/*
+ * Switch 3Dfx support hack between window and full-screen mode.
+ */
+GLboolean XMesaSetFXmode( GLint mode )
+{
+   const char *fx = _mesa_getenv("MESA_GLX_FX");
+   if (fx && fx[0] != 'd') {
+      GET_CURRENT_CONTEXT(ctx);
+      GrHwConfiguration hw;
+      if (!FX_grSstQueryHardware(&hw)) {
+         /*fprintf(stderr, "!grSstQueryHardware\n");*/
+         return GL_FALSE;
+      }
+      if (hw.num_sst < 1) {
+         /*fprintf(stderr, "hw.num_sst < 1\n");*/
+         return GL_FALSE;
+      }
+      if (ctx) {
+         /* [dBorca] Hack alert: 
+	  * oh, this is sooo wrong: ctx above is
+	  * really an fxMesaContext, not an XMesaContext
+	  */
+         XMesaBuffer xmbuf = XMESA_BUFFER(ctx->DrawBuffer);
+         if (mode == XMESA_FX_WINDOW) {
+	    if (xmbuf->FXisHackUsable) {
+	       FX_grSstControl(GR_CONTROL_DEACTIVATE);
+	       xmbuf->FXwindowHack = GL_TRUE;
+	       return GL_TRUE;
+	    }
+	 }
+	 else if (mode == XMESA_FX_FULLSCREEN) {
+	    FX_grSstControl(GR_CONTROL_ACTIVATE);
+	    xmbuf->FXwindowHack = GL_FALSE;
+	    return GL_TRUE;
+	 }
+	 else {
+	    /* Error: Bad mode value */
+	 }
+      }
+   }
+   /*fprintf(stderr, "fallthrough\n");*/
+   return GL_FALSE;
+}
+#endif
diff --git a/src/mesa/drivers/x11/xm_glide.h b/src/mesa/drivers/x11/xm_glide.h
new file mode 100644
index 00000000000..f7d0316524d
--- /dev/null
+++ b/src/mesa/drivers/x11/xm_glide.h
@@ -0,0 +1,40 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  6.5
+ *
+ * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef _XM_GLIDE_H_
+#define _XM_GLIDE_H_
+
+extern void FXcreateContext( XMesaVisual v,
+                             XMesaWindow w,
+                             XMesaContext c,
+                             XMesaBuffer b );
+
+extern void FXdestroyContext( XMesaBuffer b );
+
+extern GLboolean FXmakeCurrent( XMesaBuffer b );
+
+extern GLboolean FXswapBuffers( XMesaBuffer b );
+
+#endif /* _XM_GLIDE_H_ */
diff --git a/src/mesa/drivers/x11/xm_image.c b/src/mesa/drivers/x11/xm_image.c
index b91d5679f9b..087b4e4c3a7 100644
--- a/src/mesa/drivers/x11/xm_image.c
+++ b/src/mesa/drivers/x11/xm_image.c
@@ -130,21 +130,4 @@ void XMesaPutPixel(XMesaImage *image, int x, int y, unsigned long pixel)
 }
 #endif
 
-void XMesaPutImageHelper(ScreenPtr display,
-			 DrawablePtr d, GCPtr gc,
-			 XMesaImage *image,
-			 int src_x, int src_y,
-			 int dest_x, int dest_y,
-			 unsigned int width, unsigned int height)
-{
-    /* NOT_DONE: Verify that the following works for all depths */
-    char *src = (image->data +
-		 src_y * image->bytes_per_line +
-		 ((src_x * image->bits_per_pixel) >> 3));
-
-    ValidateGC(d, gc);
-    (*gc->ops->PutImage)(d, gc, d->depth, dest_x, dest_y, width, height,
-			 0, ZPixmap, src);
-}
-
 #endif /* XFree86Server */
diff --git a/src/mesa/drivers/x11/xm_image.h b/src/mesa/drivers/x11/xm_image.h
index c91ab3935eb..2a5e0f37779 100644
--- a/src/mesa/drivers/x11/xm_image.h
+++ b/src/mesa/drivers/x11/xm_image.h
@@ -36,13 +36,6 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #define XMESA_USE_PUTPIXEL_MACRO
 
-struct _XMesaImageRec {
-    int width, height;
-    char *data;
-    int bytes_per_line; /* Padded to 32 bits */
-    int bits_per_pixel;
-};
-
 extern XMesaImage *XMesaCreateImage(int bitsPerPixel, int width, int height,
 				    char *data);
 extern void XMesaDestroyImage(XMesaImage *image);
@@ -81,11 +74,4 @@ extern void XMesaPutPixel(XMesaImage *image, int x, int y,
 			  unsigned long pixel);
 #endif
 
-extern void XMesaPutImageHelper(ScreenPtr display,
-				DrawablePtr d, GCPtr gc,
-				XMesaImage *image,
-				int src_x, int src_y,
-				int dest_x, int dest_y,
-				unsigned int width, unsigned int height);
-
 #endif /* _XM_IMAGE_H_ */
diff --git a/src/mesa/drivers/x11/xm_line.c b/src/mesa/drivers/x11/xm_line.c
index 8537256d2e2..deeae5019c4 100644
--- a/src/mesa/drivers/x11/xm_line.c
+++ b/src/mesa/drivers/x11/xm_line.c
@@ -556,10 +556,10 @@ xor_line(GLcontext *ctx, const SWvertex *vert0, const SWvertex *vert1)
                                               vert1->color[0], vert1->color[1],
                                               vert1->color[2], vert1->color[3],
                                               xmesa->pixelformat);
-   int x0 = (int) vert0->win[0];
-   int y0 = YFLIP(xrb, (GLint) vert0->win[1]);
-   int x1 = (int) vert1->win[0];
-   int y1 = YFLIP(xrb, (GLint) vert1->win[1]);
+   int x0 =            (GLint) vert0->attrib[FRAG_ATTRIB_WPOS][0];
+   int y0 = YFLIP(xrb, (GLint) vert0->attrib[FRAG_ATTRIB_WPOS][1]);
+   int x1 =            (GLint) vert1->attrib[FRAG_ATTRIB_WPOS][0];
+   int y1 = YFLIP(xrb, (GLint) vert1->attrib[FRAG_ATTRIB_WPOS][1]);
    XMesaSetForeground(dpy, gc, pixel);
    XMesaSetFunction(dpy, gc, GXxor);
    XSetLineAttributes(dpy, gc, (int) ctx->Line.Width,
diff --git a/src/mesa/drivers/x11/xmesaP.h b/src/mesa/drivers/x11/xmesaP.h
index bd5dce14172..e3d7cf381f7 100644
--- a/src/mesa/drivers/x11/xmesaP.h
+++ b/src/mesa/drivers/x11/xmesaP.h
@@ -1,8 +1,8 @@
 /*
  * Mesa 3-D graphics library
- * Version:  6.5
+ * Version:  7.1
  *
- * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -31,7 +31,7 @@
 #include "mtypes.h"
 #if defined(FX)
 #include "GL/fxmesa.h"
-#include "../glide/fxdrv.h"
+#include "xm_glide.h"
 #endif
 #ifdef XFree86Server
 #include "xm_image.h"
@@ -267,6 +267,11 @@ struct xmesa_buffer {
    fxMesaContext FXctx;
 #endif
 
+   /* GLX_EXT_texture_from_pixmap */
+   GLint TextureTarget; /** GLX_TEXTURE_1D_EXT, for example */
+   GLint TextureFormat; /** GLX_TEXTURE_FORMAT_RGB_EXT, for example */
+   GLint TextureMipmap; /** 0 or 1 */
+
    struct xmesa_buffer *Next;	/* Linked list pointer: */
 };
 
@@ -568,22 +573,6 @@ extern void xmesa_register_swrast_functions( GLcontext *ctx );
 
 
 
-/* XXX this is a hack to implement shared display lists with 3Dfx */
-extern XMesaBuffer XMesaCreateWindowBuffer2( XMesaVisual v,
-					     XMesaWindow w,
-					     XMesaContext c );
-
-/*
- * These are the extra routines required for integration with XFree86.
- * None of these routines should be user visible. -KEM
- */
-extern GLboolean XMesaForceCurrent(XMesaContext c);
-extern GLboolean XMesaLoseCurrent(XMesaContext c);
-extern GLboolean XMesaCopyContext( XMesaContext src,
-				   XMesaContext dst,
-				   GLuint mask );
-
-
 #define ENABLE_EXT_texure_compression_s3tc 0 /* SW texture compression */
 
 #ifdef XFree86Server