Added basic triangle functions

Added basic VB setup/managment
Added software fallbacks (RGBA spans and depth functions)
Fixed depth buffer initialization (depth buffer now works)

16 files changed, 1479 insertions, 68 deletions

diff --git a/xc/lib/GL/mesa/src/drv/r128/Imakefile b/xc/lib/GL/mesa/src/drv/r128/Imakefile
index 7611bb3dd..6ca57a376 100644
--- a/xc/lib/GL/mesa/src/drv/r128/Imakefile
+++ b/xc/lib/GL/mesa/src/drv/r128/Imakefile
@@ -25,10 +25,10 @@ MESA_INCLUDES = -I. -I.. -I../../include
      INCLUDES = -I$(XLIBSRC) -I$(EXTINCSRC) $(MESA_INCLUDES) $(DRI_INCLUDES)
       DRISRCS = r128_xmesa.c r128_cce.c r128_dd.c r128_state.c \
 		r128_span.c r128_depth.c r128_tex.c r128_clear.c \
-		r128_swap.c
+		r128_swap.c r128_tris.c r128_vb.c
       DRIOBJS = r128_xmesa.o r128_cce.o r128_dd.o r128_state.o \
 		r128_span.o r128_depth.o r128_tex.o r128_clear.o \
-		r128_swap.o
+		r128_swap.o r128_tris.o r128_vb.o
 
 	 SRCS = $(DRISRCS)
 	 OBJS = $(DRIOBJS)
diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_clear.c b/xc/lib/GL/mesa/src/drv/r128/r128_clear.c
index 96ca60c81..19aaaebfe 100644
--- a/xc/lib/GL/mesa/src/drv/r128/r128_clear.c
+++ b/xc/lib/GL/mesa/src/drv/r128/r128_clear.c
@@ -138,7 +138,7 @@ void r128ClearColorBuffer(r128ContextPtr r128ctx, GLboolean all,
 			  GLint x, GLint y, GLint width, GLint height)
 {
     unsigned char *R128MMIO = r128ctx->r128Screen->mmio;
-    int            dst_bpp, xoff, yoff;
+    int            dst_bpp;
 
     switch (r128ctx->r128Screen->bpp) {
     case 8:
@@ -157,19 +157,6 @@ void r128ClearColorBuffer(r128ContextPtr r128ctx, GLboolean all,
 	break;
     }
 
-    switch (r128ctx->glCtx->Color.DriverDrawBuffer) {
-    case GL_FRONT_LEFT:
-	xoff = r128ctx->r128Screen->fbX;
-	yoff = r128ctx->r128Screen->fbY;
-	break;
-    case GL_BACK_LEFT:
-	xoff = r128ctx->r128Screen->backX;
-	yoff = r128ctx->r128Screen->backY;
-	break;
-    default:
-	return;
-    }
-
     /* FIXME: use x, y, width, height */
     /* FIXME: use R128_GMC_DST_PITCH_OFFSET_CNTL to set to the back
        buffer when we should be draing to the back buffer? */
@@ -192,8 +179,8 @@ void r128ClearColorBuffer(r128ContextPtr r128ctx, GLboolean all,
 	    | R128_AUX_CLIP_DIS);           /* FIXME?? */
     R128CCE(r128ctx->ClearColor);
     /* FIXME: when not using the back buf, make sure clears go to front buf */
-    R128CCE(((r128ctx->driDrawable->x + xoff)<< 16)
-	    | (r128ctx->driDrawable->y + yoff));
+    R128CCE(((r128ctx->driDrawable->x + r128ctx->bufX)<< 16)
+	    | (r128ctx->driDrawable->y + r128ctx->bufY));
     R128CCE((r128ctx->driDrawable->w << 16) | r128ctx->driDrawable->h);
 
 #if 0
diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_context.h b/xc/lib/GL/mesa/src/drv/r128/r128_context.h
index 2a627e8cf..3127223ef 100644
--- a/xc/lib/GL/mesa/src/drv/r128/r128_context.h
+++ b/xc/lib/GL/mesa/src/drv/r128/r128_context.h
@@ -111,15 +111,21 @@ typedef struct {
     int                   dirty;
     int                   needClip;
 
+    int                   RenderIndex;
     points_func           PointsFunc;
     line_func             LineFunc;
     triangle_func         TriangleFunc;
     quad_func             QuadFunc;
 
+    CARD32                IndirectTriangles;
+    CARD32                Fallback;
+
+    r128ContextRegs       regs;
     CARD32                ClearColor;
     CARD32                ClearDepth;
 
-    r128ContextRegs       regs;
+    int                   bufX;
+    int                   bufY;
 
     Display              *display;
 
diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_dd.c b/xc/lib/GL/mesa/src/drv/r128/r128_dd.c
index 04850fd6c..04745d240 100644
--- a/xc/lib/GL/mesa/src/drv/r128/r128_dd.c
+++ b/xc/lib/GL/mesa/src/drv/r128/r128_dd.c
@@ -36,6 +36,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "r128_mesa.h"
 #include "r128_cce.h"
 #include "r128_clear.h"
+#include "r128_vb.h"
 #include "r128_dd.h"
 
 static GLbitfield r128DDClear(GLcontext *ctx, GLbitfield mask, GLboolean all,
@@ -129,4 +130,7 @@ void r128DDInitDriverFuncs(GLcontext *ctx)
 
     ctx->Driver.DrawPixels    = NULL;
     ctx->Driver.Bitmap        = NULL;
+
+    ctx->Driver.RegisterVB    = r128DDRegisterVB;
+    ctx->Driver.UnregisterVB  = r128DDUnregisterVB;
 }
diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_depth.c b/xc/lib/GL/mesa/src/drv/r128/r128_depth.c
index c61eaadca..0c4076058 100644
--- a/xc/lib/GL/mesa/src/drv/r128/r128_depth.c
+++ b/xc/lib/GL/mesa/src/drv/r128/r128_depth.c
@@ -34,37 +34,206 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include "r128_init.h"
 #include "r128_mesa.h"
+#include "r128_xmesa.h"
+#include "r128_context.h"
+#include "r128_lock.h"
+#include "r128_state.h"
+#include "r128_reg.h"
+#include "r128_cce.h"
 #include "r128_depth.h"
 
+/* FIXME: only handles 16bpp depth buffer for now */
+
+#define DEPTH_DECLS                                                         \
+    r128ContextPtr    r128ctx  = R128_CONTEXT(ctx);                         \
+    r128ScreenPtr     r128scrn = r128ctx->r128Screen;                       \
+    int               xoff     = (r128ctx->driDrawable->x +                 \
+				  r128scrn->depthX);                        \
+    int               yoff     = (r128ctx->driDrawable->y +                 \
+				  r128scrn->depthY);                        \
+    int               height   = r128ctx->driDrawable->h;                   \
+    unsigned char    *zbase    = (r128scrn->fb +                            \
+				  xoff * (r128scrn->bpp/8) +                \
+				  yoff * r128scrn->fbStride);               \
+    volatile GLdepth *zptr;                                                 \
+    int               i
+
+#define DEPTH_ADDR(base, _x, _y)                                            \
+    (GLdepth*)(zbase + _x * (r128scrn->bpp/8) +                             \
+	       (height - _y) * r128scrn->fbStride)
+
+#define DEPTH_TEST_SPAN(_op_)                                               \
+	if (ctx->Depth.Mask) {              /* Update Z buffer */           \
+	    for (i = 0; i < n; i++, zptr++, m++) {                          \
+		if (*m) {                                                   \
+		    if (z[i] _op_ *zptr) {  /* pass */                      \
+			*zptr = z[i];                                       \
+			passed++;                                           \
+		    } else {                /* fail */                      \
+			*m = 0;                                             \
+		    }                                                       \
+		}                                                           \
+	    }                                                               \
+	} else {                            /* Don't update Z buffer */     \
+	    for (i = 0; i < n; i++, zptr++, m++) {                          \
+		if (*m) {                                                   \
+		    if (z[i] _op_ *zptr) {  /* pass */                      \
+			passed++;                                           \
+		    } else {                /* fail */                      \
+			*m = 0;                                             \
+		    }                                                       \
+		}                                                           \
+	    }                                                               \
+	}
+     
+#define DEPTH_TEST_PIXELS(_op_)                                             \
+	if (ctx->Depth.Mask) {              /* Update Z buffer */           \
+	    for (i = 0; i < n; i++) {                                       \
+		if (mask[i]) {                                              \
+		    zptr = DEPTH_ADDR(zbase, x[i], y[i]);                   \
+		    if (z[i] _op_ *zptr) *zptr = z[i];                      \
+		    else                 mask[i] = 0;                       \
+		}                                                           \
+	    }                                                               \
+	} else {                            /* Don't update Z buffer */     \
+	    for (i = 0; i < n; i++, zptr++, m++) {                          \
+		if (mask[i]) {                                              \
+		    zptr = DEPTH_ADDR(zbase, x[i], y[i]);                   \
+		    if (z[i] _op_ *zptr) ;                                  \
+		    else                 mask[i] = 0;                       \
+		}                                                           \
+	    }                                                               \
+	}
+
 static void r128DDAllocDepthBuffer(GLcontext *ctx)
 {
 }
 
 static GLuint r128DDDepthTestSpan(GLcontext *ctx,
-				  GLuint n,
-				  GLint x, GLint y, const GLdepth z[],
+				  GLuint n, GLint x, GLint y,
+				  const GLdepth z[],
 				  GLubyte mask[])
 {
-    return 1;
+    DEPTH_DECLS;
+    GLubyte *m      = mask;
+    int      passed = 0;
+
+    zptr = DEPTH_ADDR(zbase, x, y);
+
+    LOCK_HARDWARE(r128ctx);
+    R128WaitForIdle(r128scrn);
+
+    switch (ctx->Depth.Func) {
+    case GL_LESS:     DEPTH_TEST_SPAN(<)  break;
+    case GL_LEQUAL:   DEPTH_TEST_SPAN(<=) break;
+    case GL_GEQUAL:   DEPTH_TEST_SPAN(>=) break;
+    case GL_GREATER:  DEPTH_TEST_SPAN(>)  break;
+    case GL_NOTEQUAL: DEPTH_TEST_SPAN(!=) break;
+    case GL_EQUAL:    DEPTH_TEST_SPAN(==) break;
+    case GL_ALWAYS:
+	if (ctx->Depth.Mask) {              /* Update Z buffer */
+	    for (i = 0; i < n; i++, zptr++, m++) {
+		if (*m) {
+		    *zptr = z[i];
+		    passed++;
+		}
+	    }
+	} else {                            /* Don't update Z buffer or mask */
+	    passed = n;
+	}
+	break;
+    case GL_NEVER:
+	for (i = 0; i < n; i++) mask[i] = 0;
+	break;
+    default:
+	break;
+    }
+
+    UNLOCK_HARDWARE(r128ctx);
+
+    return passed;
 }
 
 static void r128DDDepthTestPixels(GLcontext *ctx,
 				  GLuint n,
-				  const GLint x[], const GLint y[],
-				  const GLdepth z[], GLubyte mask[])
+				  const GLint x[],
+				  const GLint y[],
+				  const GLdepth z[],
+				  GLubyte mask[])
 {
+    DEPTH_DECLS;
+    GLubyte *m      = mask;
+
+    LOCK_HARDWARE(r128ctx);
+    R128WaitForIdle(r128scrn);
+
+    switch (ctx->Depth.Func) {
+    case GL_LESS:     DEPTH_TEST_PIXELS(<);  break;
+    case GL_LEQUAL:   DEPTH_TEST_PIXELS(<=); break;
+    case GL_GEQUAL:   DEPTH_TEST_PIXELS(>=); break;
+    case GL_GREATER:  DEPTH_TEST_PIXELS(>);  break;
+    case GL_NOTEQUAL: DEPTH_TEST_PIXELS(!=); break;
+    case GL_EQUAL:    DEPTH_TEST_PIXELS(==); break;
+    case GL_ALWAYS:
+	if (ctx->Depth.Mask) {              /* Update Z buffer */
+	    for (i = 0; i < n; i++) {
+		if (mask[i]) {
+		    zptr = DEPTH_ADDR(zbase, x[i], y[i]);
+		    *zptr = z[i];
+		}
+	    }
+	} else {                            /* Don't update Z buffer or mask */
+	}
+	break;
+    case GL_NEVER:
+	for (i = 0; i < n; i++) mask[i] = 0;
+	break;
+    default:
+	break;
+    }
+
+    UNLOCK_HARDWARE(r128ctx);
 }
 
 static void r128DDReadDepthSpanFloat(GLcontext *ctx,
 				     GLuint n,
 				     GLint x, GLint y, GLfloat depth[])
 {
+    DEPTH_DECLS;
+    GLfloat scale = 1.0f / DEPTH_SCALE;
+
+    zptr = DEPTH_ADDR(zbase, x, y);
+
+    LOCK_HARDWARE(r128ctx);
+    R128WaitForIdle(r128scrn);
+
+    if (ctx->Buffer->Depth) {
+	for (i = 0; i < n; i++) depth[i] = (GLfloat)zptr[i] * scale;
+    } else {
+	for (i = 0; i < n; i++) depth[i] = 0.0f;
+    }
+
+    UNLOCK_HARDWARE(r128ctx);
 }
 
 static void r128DDReadDepthSpanInt(GLcontext *ctx,
 				   GLuint n,
 				   GLint x, GLint y, GLdepth depth[])
 {
+    DEPTH_DECLS;
+
+    zptr = DEPTH_ADDR(zbase, x, y);
+
+    LOCK_HARDWARE(r128ctx);
+    R128WaitForIdle(r128scrn);
+
+    if (ctx->Buffer->Depth) {
+	MEMCPY(depth, zptr, n*sizeof(*depth));
+    } else {
+	for (i = 0; i < n; i++) depth[i] = 0;
+    }
+
+    UNLOCK_HARDWARE(r128ctx);
 }
 
 
diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_lock.h b/xc/lib/GL/mesa/src/drv/r128/r128_lock.h
index 893bb4d78..2d80b0bbe 100644
--- a/xc/lib/GL/mesa/src/drv/r128/r128_lock.h
+++ b/xc/lib/GL/mesa/src/drv/r128/r128_lock.h
@@ -117,12 +117,12 @@ extern int   prevLockLine;
 #define BEGIN_CLIP_LOOP(CC)                                             \
     do {                                                                \
 	__DRIdrawablePrivate *dPriv = CC->driDrawable;                  \
-	int _nc = dPriv->numClipRects;                                  \
+	int                   _nc   = dPriv->numClipRects;              \
                                                                         \
 	LOCK_HARDWARE(CC);                                              \
 	while (_nc--) {                                                 \
 	    if (CC->needClip) {                                         \
-		r128SetClipRects(&dPriv->pClipRects[_nc]);              \
+		r128SetClipRect(CC, &dPriv->pClipRects[_nc]);           \
 	    }
 
 #define END_CLIP_LOOP(CC)                                               \
diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_span.c b/xc/lib/GL/mesa/src/drv/r128/r128_span.c
index 3653fc2f6..f6452b1b5 100644
--- a/xc/lib/GL/mesa/src/drv/r128/r128_span.c
+++ b/xc/lib/GL/mesa/src/drv/r128/r128_span.c
@@ -34,6 +34,12 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include "r128_init.h"
 #include "r128_mesa.h"
+#include "r128_xmesa.h"
+#include "r128_context.h"
+#include "r128_lock.h"
+#include "r128_state.h"
+#include "r128_reg.h"
+#include "r128_cce.h"
 #include "r128_span.h"
 
 static void r128DDWriteRGBASpan(const GLcontext *ctx,
@@ -89,32 +95,98 @@ static void r128DDReadRGBAPixels(const GLcontext *ctx,
 {
 }
 
+/* 16bpp span routines */
+
+#define DBG 0
+
+#define HW_LOCK()                                                           \
+    r128ContextPtr r128ctx  = R128_CONTEXT(ctx);                            \
+    r128ScreenPtr  r128scrn = r128ctx->r128Screen;                          \
+    LOCK_HARDWARE(r128ctx);                                                 \
+    R128WaitForIdle(r128scrn);
+
+#define LOCAL_VARS                                                          \
+    __DRIdrawablePrivate *dPriv = r128ctx->driDrawable;                     \
+    GLuint pitch = r128scrn->fbStride;                                      \
+    GLuint height = dPriv->h;                                               \
+    char *buf = (char *)(r128scrn->fb +                                     \
+			 (r128ctx->bufX + dPriv->x) * (r128scrn->bpp/8) +   \
+			 (r128ctx->bufY + dPriv->y) * pitch)
+
+#define INIT_MONO_PIXEL(p)                                                  \
+    GLushort p = R128_CONTEXT(ctx)->regs.constant_color_c;
+
+#define CLIPPIXEL(_x,_y) (_x >= minx && _x <= maxx &&                       \
+			  _y >= miny && _y <= maxy)
+
+#define CLIPSPAN(_x,_y,_n,_x1,_n1,_i)                                       \
+    if (_y < miny || _y >= maxy) _n1 = 0, _x1 = x;                          \
+    else {                                                                  \
+	_n1 = _n;                                                           \
+	_x1 = _x;                                                           \
+	if (_x1 < minx) _i += (minx - _x1), _x1 = minx;                     \
+	if (_x1 + _n1 > maxx) n1 -= (_x1 + n1 - maxx);                      \
+    }
+
+#define HW_CLIPLOOP()                                                       \
+    do {                                                                    \
+	__DRIdrawablePrivate *dPriv = r128ctx->driDrawable;                 \
+	int _nc = dPriv->numClipRects;                                      \
+	while (_nc--) {                                                     \
+	    int minx = dPriv->pClipRects[_nc].x1 - dPriv->x;                \
+	    int miny = dPriv->pClipRects[_nc].y1 - dPriv->y;                \
+	    int maxx = dPriv->pClipRects[_nc].x2 - dPriv->x;                \
+	    int maxy = dPriv->pClipRects[_nc].y2 - dPriv->y;
+
+#define HW_ENDCLIPLOOP()                                                    \
+	}                                                                   \
+    } while (0)
+
+#define HW_UNLOCK()                                                         \
+    UNLOCK_HARDWARE(r128ctx);
+
+
+/* For 16 bit depth visuals */
+#define Y_FLIP(_y) (height - _y)
+#define WRITE_RGBA(_x, _y, r, g, b, a)                                      \
+    *(GLushort *)(buf + (_x)*2 + (_y)*pitch) = ((((int)r & 0xf8) << 8) |    \
+						(((int)g & 0xfc) << 3) |    \
+						(((int)b & 0xf8) >> 3))
+#define WRITE_PIXEL(_x, _y, p)                                              \
+    *(GLushort *)(buf + (_x)*2 + (_y)*pitch) = p
+
+#define READ_RGBA(rgba, _x, _y)                                             \
+    do {                                                                    \
+	GLushort p = *(GLushort *)(buf + (_x)*2 + (_y)*pitch);              \
+	rgba[0] = (p >> 8) & 0xf8;                                          \
+	rgba[1] = (p >> 3) & 0xfc;                                          \
+	rgba[2] = (p << 3) & 0xf8;                                          \
+	rgba[3] = 255; /* or 0? */                                          \
+    } while(0)
+
+#define TAG(x) r128DD##x##565
+#include "spantmp.h"
+
+
 void r128DDInitSpanFuncs(GLcontext *ctx)
 {
     r128ContextPtr r128ctx = R128_CONTEXT(ctx);
 
     switch (r128ctx->r128Screen->depth) {
     case 8: /* Color Index mode not supported */
-	ctx->Driver.WriteCI32Span       = NULL;
-	ctx->Driver.WriteCI8Span        = NULL;
-	ctx->Driver.WriteMonoCISpan     = NULL;
-	ctx->Driver.WriteCI32Pixels     = NULL;
-	ctx->Driver.WriteMonoCIPixels   = NULL;
-	ctx->Driver.ReadCI32Span        = NULL;
-	ctx->Driver.ReadCI32Pixels      = NULL;
 	break;
-    case 15: /* FIXME? */
     case 16:
-	ctx->Driver.WriteRGBASpan       = r128DDWriteRGBASpan;
-	ctx->Driver.WriteRGBSpan        = r128DDWriteRGBSpan;
-	ctx->Driver.WriteMonoRGBASpan   = r128DDWriteMonoRGBASpan;
-	ctx->Driver.WriteRGBAPixels     = r128DDWriteRGBAPixels;
-	ctx->Driver.WriteMonoRGBAPixels = r128DDWriteMonoRGBAPixels;
-	ctx->Driver.ReadRGBASpan        = r128DDReadRGBASpan;
-	ctx->Driver.ReadRGBAPixels      = r128DDReadRGBAPixels;
+	ctx->Driver.WriteRGBASpan       = r128DDWriteRGBASpan565;
+	ctx->Driver.WriteRGBSpan        = r128DDWriteRGBSpan565;
+	ctx->Driver.WriteMonoRGBASpan   = r128DDWriteMonoRGBASpan565;
+	ctx->Driver.WriteRGBAPixels     = r128DDWriteRGBAPixels565;
+	ctx->Driver.WriteMonoRGBAPixels = r128DDWriteMonoRGBAPixels565;
+	ctx->Driver.ReadRGBASpan        = r128DDReadRGBASpan565;
+	ctx->Driver.ReadRGBAPixels      = r128DDReadRGBAPixels565;
 	break;
-    case 24: /* FIXME? */
-    case 32:
+    case 15: /* FIXME */
+    case 24: /* FIXME */
+    case 32: /* FIXME */
 	ctx->Driver.WriteRGBASpan       = r128DDWriteRGBASpan;
 	ctx->Driver.WriteRGBSpan        = r128DDWriteRGBSpan;
 	ctx->Driver.WriteMonoRGBASpan   = r128DDWriteMonoRGBASpan;
@@ -124,4 +196,12 @@ void r128DDInitSpanFuncs(GLcontext *ctx)
 	ctx->Driver.ReadRGBAPixels      = r128DDReadRGBAPixels;
 	break;
     }
+
+    ctx->Driver.WriteCI32Span           = NULL;
+    ctx->Driver.WriteCI8Span            = NULL;
+    ctx->Driver.WriteMonoCISpan         = NULL;
+    ctx->Driver.WriteCI32Pixels         = NULL;
+    ctx->Driver.WriteMonoCIPixels       = NULL;
+    ctx->Driver.ReadCI32Span            = NULL;
+    ctx->Driver.ReadCI32Pixels          = NULL;
 }
diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_state.c b/xc/lib/GL/mesa/src/drv/r128/r128_state.c
index ec6f46929..8517960f9 100644
--- a/xc/lib/GL/mesa/src/drv/r128/r128_state.c
+++ b/xc/lib/GL/mesa/src/drv/r128/r128_state.c
@@ -40,8 +40,10 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "r128_state.h"
 #include "r128_reg.h"
 #include "r128_cce.h"
+#include "r128_tris.h"
+#include "r128_vb.h"
 
-#if 1
+#if 0
 /* FIXME: FOR TESTING A SIMPLE DRAWING FUNCTION */
 static void pfunc(GLcontext *ctx, GLuint first, GLuint last) {}
 static void lfunc(GLcontext *ctx, GLuint v1, GLuint v2, GLuint pv) {}
@@ -103,15 +105,33 @@ static void r128DDUpdateState(GLcontext *ctx)
     ctx->Driver.QuadFunc     = qfunc;
 }
 #else
+
+#define INTERESTED (~(NEW_MODELVIEW      | \
+		      NEW_PROJECTION     | \
+		      NEW_TEXTURE_MATRIX | \
+		      NEW_USER_CLIP      | \
+		      NEW_CLIENT_STATE   | \
+		      NEW_TEXTURE_ENABLE))
+
 static void r128DDUpdateState(GLcontext *ctx)
 {
     r128ContextPtr r128ctx = R128_CONTEXT(ctx);
 
-    ctx->Driver.PointsFunc   = r128ctx->PointsFunc;
-    ctx->Driver.LineFunc     = r128ctx->LineFunc;
-    ctx->Driver.TriangleFunc = r128ctx->TriangleFunc;
-    ctx->Driver.QuadFunc     = r128ctx->QuadFunc;
-    ctx->Driver.RectFunc     = NULL;
+    if (ctx->NewState & INTERESTED) {
+	r128ChooseRenderState(ctx);  
+	r128ChooseRasterSetupFunc(ctx);
+    }
+   
+    if (!r128ctx->Fallback) {
+	ctx->IndirectTriangles   &= ~DD_SW_RASTERIZE;
+	ctx->IndirectTriangles   |= r128ctx->IndirectTriangles;
+
+	ctx->Driver.PointsFunc    = r128ctx->PointsFunc;
+	ctx->Driver.LineFunc      = r128ctx->LineFunc;
+	ctx->Driver.TriangleFunc  = r128ctx->TriangleFunc;
+	ctx->Driver.QuadFunc      = r128ctx->QuadFunc;
+	ctx->Driver.RectFunc      = NULL;
+    }
 }
 #endif
 
@@ -140,10 +160,17 @@ static void r128DDColor(GLcontext *ctx,
 {
     r128ContextPtr r128ctx = R128_CONTEXT(ctx);
 
+#if 1
+    r128ctx->regs.constant_color_c = (((r >> 3) << 11) |
+				      ((g >> 2) << 5)  |
+				      ((b >> 3) << 0)  |
+				      ((a >> 8) << 16));
+#else
     r128ctx->regs.constant_color_c = (((r >> 0) << 16) |
 				      ((g >> 0) << 8)  |
 				      ((b >> 0) << 0)  |
 				      ((a >> 0) << 24));
+#endif
 }
 
 static GLboolean r128DDSetBuffer(GLcontext *ctx, GLenum mode )
@@ -155,19 +182,32 @@ static GLboolean r128DDSetBuffer(GLcontext *ctx, GLenum mode )
 
     switch (mode) {
     case GL_FRONT_LEFT:
-	x += r128ctx->r128Screen->fbX;
-	y += r128ctx->r128Screen->fbY;
+	r128ctx->bufX = r128ctx->r128Screen->fbX;
+	r128ctx->bufY = r128ctx->r128Screen->fbY;
 	found = GL_TRUE;
 	break;
     case GL_BACK_LEFT:
-	x += r128ctx->r128Screen->backX;
-	y += r128ctx->r128Screen->backY;
+	r128ctx->bufX = r128ctx->r128Screen->backX;
+	r128ctx->bufY = r128ctx->r128Screen->backY;
 	found = GL_TRUE;
 	break;
     }
 
+    x += r128ctx->bufX;
+    y += r128ctx->bufY;
+
     r128ctx->regs.window_xy_offset = ((y << R128_WINDOW_Y_SHIFT) |
 				      (x << R128_WINDOW_X_SHIFT));
+
+    /* Recalculate the Z buffer offset since we might be drawing to the
+       back buffer and window_xy_offset affects both color buffer and
+       depth drawing */
+    r128ctx->regs.z_offset_c        = ((r128ctx->r128Screen->depthX -
+					r128ctx->bufX) *
+				       (r128ctx->r128Screen->bpp/8) +
+				       (r128ctx->r128Screen->depthY -
+					r128ctx->bufY) *
+				       r128ctx->r128Screen->fbStride);
     return found;
 }
 
@@ -438,7 +478,7 @@ static void r128DDEnable(GLcontext *ctx, GLenum cap, GLboolean state)
 	}
 	break;
 
-#if 0
+#if 1
     case GL_DEPTH_TEST:
 	if (state) t |=  R128_Z_ENABLE;
 	else       t &= ~R128_Z_ENABLE;
@@ -618,6 +658,26 @@ void r128DDInitState(r128ContextPtr r128ctx)
 	break;
     }
 
+    r128ctx->dirty             = R128_CLEAN;
+    r128ctx->needClip          = GL_FALSE;
+
+    r128ctx->RenderIndex       = 0;
+    r128ctx->PointsFunc        = NULL;
+    r128ctx->LineFunc          = NULL;
+    r128ctx->TriangleFunc      = NULL;
+    r128ctx->QuadFunc          = NULL;
+
+    r128ctx->IndirectTriangles = 0;
+    r128ctx->Fallback          = 0;
+
+    if (r128ctx->glCtx->Visual->DBflag) {
+	r128ctx->bufX          = r128ctx->r128Screen->backX;
+	r128ctx->bufY          = r128ctx->r128Screen->backY;
+    } else {
+	r128ctx->bufX          = r128ctx->r128Screen->fbX;
+	r128ctx->bufY          = r128ctx->r128Screen->fbY;
+    }
+
     r128ctx->ClearColor = 0x00000000;
     r128ctx->ClearDepth = 0x0000ffff; /* FIXME: init to requested depth */
 
@@ -654,7 +714,8 @@ void r128DDInitState(r128ContextPtr r128ctx)
 
     r128ctx->regs.sc_top_left_c     = 0x00000000;
     r128ctx->regs.sc_bottom_right_c = 0x1fff1fff;
-    r128ctx->regs.z_offset_c        = (r128ctx->r128Screen->depthX +
+    r128ctx->regs.z_offset_c        = (r128ctx->r128Screen->depthX *
+				       (r128ctx->r128Screen->bpp/8) +
 				       r128ctx->r128Screen->depthY *
 				       r128ctx->r128Screen->fbStride);
     r128ctx->regs.z_pitch_c         = pitch;
@@ -874,24 +935,27 @@ static void r128LoadContext(r128ContextPtr r128ctx)
 }
 
 /* This is only called when we have the lock */
-static void r128LoadCliprects(r128ContextPtr r128ctx)
+void r128SetClipRect(r128ContextPtr r128ctx, XF86DRIClipRectPtr pc)
 {
-    int x = r128ctx->driDrawable->x;
-    int y = r128ctx->driDrawable->y;
+}
 
-    switch (r128ctx->glCtx->Color.DriverDrawBuffer) {
-    case GL_FRONT_LEFT:
-	x += r128ctx->r128Screen->fbX;
-	y += r128ctx->r128Screen->fbY;
-	break;
-    case GL_BACK_LEFT:
-	x += r128ctx->r128Screen->backX;
-	y += r128ctx->r128Screen->backY;
-	break;
-    }
+static void r128LoadCliprects(r128ContextPtr r128ctx)
+{
+    int x = r128ctx->driDrawable->x + r128ctx->bufX;
+    int y = r128ctx->driDrawable->y + r128ctx->bufY;
 
     r128ctx->regs.window_xy_offset = ((y << R128_WINDOW_Y_SHIFT) |
 				      (x << R128_WINDOW_X_SHIFT));
+
+    /* Recalculate the Z buffer offset since we might be drawing to the
+       back buffer and window_xy_offset affects both color buffer and
+       depth drawing */
+    r128ctx->regs.z_offset_c        = ((r128ctx->r128Screen->depthX -
+					r128ctx->bufX) *
+				       (r128ctx->r128Screen->bpp/8) +
+				       (r128ctx->r128Screen->depthY -
+					r128ctx->bufY) *
+				       r128ctx->r128Screen->fbStride);
 }
 
 void r128UpdateState(r128ContextPtr r128ctx)
diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_state.h b/xc/lib/GL/mesa/src/drv/r128/r128_state.h
index 925c791dc..f604f6ca8 100644
--- a/xc/lib/GL/mesa/src/drv/r128/r128_state.h
+++ b/xc/lib/GL/mesa/src/drv/r128/r128_state.h
@@ -43,5 +43,7 @@ extern void r128DDInitStateFuncs(GLcontext *ctx);
 extern void r128UpdateState(r128ContextPtr r128ctx);
 extern void r128UpdateStateLocked(r128ContextPtr r128ctx);
 
+extern void r128SetClipRect(r128ContextPtr r128ctx, XF86DRIClipRectPtr pc);
+
 #endif
 #endif /* _R128_STATE_H_ */
diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_tris.c b/xc/lib/GL/mesa/src/drv/r128/r128_tris.c
new file mode 100644
index 000000000..58e2b5980
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/r128/r128_tris.c
@@ -0,0 +1,158 @@
+/* $XFree86$ */
+/**************************************************************************
+
+Copyright 1999, 2000 ATI Technologies Inc. and 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
+on 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
+ATI, 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 <kevin@precisioninsight.com>
+ *
+ */
+
+#include "r128_init.h"
+#include "r128_mesa.h"
+#include "r128_xmesa.h"
+#include "r128_context.h"
+#include "r128_lock.h"
+#include "r128_reg.h"
+#include "r128_cce.h"
+#include "r128_vb.h"
+#include "r128_tris.h"
+#include "r128_state.h"
+
+static triangle_func tri_tab[0x40];    /* only 0x20 actually used */
+static quad_func     quad_tab[0x40];   /* only 0x20 actually used */
+static line_func     line_tab[0x40];   /* less than 0x20 used */
+static points_func   points_tab[0x40]; /* less than 0x20 used */
+
+static void r128DrawTriangle(r128ContextPtr r128ctx,
+			     r128_vertex *v0,
+			     r128_vertex *v1,
+			     r128_vertex *v2)
+{
+}
+
+static void r128DrawLine(r128ContextPtr r128ctx,
+			 r128_vertex *tmp0, r128_vertex *tmp1,
+			 float width)
+{
+}
+
+static void r128DrawPoint(r128ContextPtr r128ctx,
+			  r128_vertex *tmp, float sz)
+{
+}
+
+#define IND (0)
+#define TAG(x) x
+#include "r128_tritmp.h"
+
+#define IND (R128_FLAT_BIT)
+#define TAG(x) x##_flat
+#include "r128_tritmp.h"
+
+void r128TriangleFuncsInit(void)
+{
+    init();
+    init_flat();
+}
+
+void r128ChooseRenderState(GLcontext *ctx)
+{
+    r128ContextPtr r128ctx = R128_CONTEXT(ctx);
+    GLuint         flags   = ctx->TriangleCaps;
+
+    r128ctx->IndirectTriangles = 0;
+
+    if (flags) {
+	CARD32 index    = 0;
+	CARD32 shared   = 0;
+	CARD32 fallback = R128_FALLBACK_BIT;
+
+#if 0
+	shared = fallback; /* Make everything a fallback */
+#endif
+
+#if 0
+	fallback = 0; /* Turn off all fallbacks */
+#endif
+
+	if (flags & DD_FLATSHADE)               shared |= R128_FLAT_BIT;
+	if (flags & DD_MULTIDRAW)               shared |= fallback;
+	if (flags & DD_SELECT)                  shared |= R128_FALLBACK_BIT;
+	if (flags & DD_FEEDBACK)                shared |= R128_FALLBACK_BIT;
+
+	index = shared;
+#if 1
+	if (flags & DD_POINT_SMOOTH)            index  |= fallback;
+#else
+	if (flags & DD_POINT_SMOOTH)            index  |= R128_ANTIALIAS_BIT;
+#endif
+	if (flags & DD_POINT_ATTEN)             index  |= fallback;
+
+	r128ctx->RenderIndex = index;
+	r128ctx->PointsFunc  = points_tab[index];
+	if (index & R128_FALLBACK_BIT)
+	    r128ctx->IndirectTriangles |= DD_POINT_SW_RASTERIZE;
+
+	index = shared;
+#if 1
+	if (flags & DD_LINE_SMOOTH)             index  |= fallback;
+#else
+	if (flags & DD_LINE_SMOOTH)             index  |= R128_ANTIALIAS_BIT;
+#endif
+	if (flags & DD_LINE_STIPPLE)            index  |= fallback;
+
+	r128ctx->RenderIndex |= index;
+	r128ctx->LineFunc     = line_tab[index];
+	if (index & R128_FALLBACK_BIT)
+	    r128ctx->IndirectTriangles |= DD_LINE_SW_RASTERIZE;
+
+	index = shared;
+#if 1
+	if (flags & DD_TRI_SMOOTH)              index  |= fallback;
+#else
+	if (flags & DD_TRI_SMOOTH)              index  |= R128_ANTIALIAS_BIT;
+#endif
+	if (flags & DD_TRI_OFFSET)              index  |= R128_OFFSET_BIT;
+	if (flags & DD_TRI_LIGHT_TWOSIDE)       index  |= R128_TWOSIDE_BIT;
+	if (flags & DD_TRI_UNFILLED)            index  |= fallback;
+	if (flags & DD_TRI_STIPPLE)             index  |= fallback;
+
+	r128ctx->RenderIndex  |= index;
+	r128ctx->TriangleFunc  = tri_tab[index];
+	r128ctx->QuadFunc      = quad_tab[index];
+	if (index & R128_FALLBACK_BIT)
+	    r128ctx->IndirectTriangles |= (DD_TRI_SW_RASTERIZE |
+					   DD_QUAD_SW_RASTERIZE);
+    } else if (r128ctx->RenderIndex) {
+	r128ctx->RenderIndex  = 0;
+	r128ctx->PointsFunc   = points_tab[0];
+	r128ctx->LineFunc     = line_tab[0];
+	r128ctx->TriangleFunc = tri_tab[0];
+	r128ctx->QuadFunc     = quad_tab[0];
+    }
+}
diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_tris.h b/xc/lib/GL/mesa/src/drv/r128/r128_tris.h
new file mode 100644
index 000000000..ba98eb3e7
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/r128/r128_tris.h
@@ -0,0 +1,54 @@
+/* $XFree86$ */
+/**************************************************************************
+
+Copyright 1999, 2000 ATI Technologies Inc. and 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
+on 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
+ATI, 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 <kevin@precisioninsight.com>
+ *
+ */
+
+#ifndef _R128_TRIS_H_
+#define _R128_TRIS_H_
+
+#ifdef GLX_DIRECT_RENDERING
+
+#define R128_ANTIALIAS_BIT   0x00   /* ignored for now, no fallback */
+#define R128_FLAT_BIT        0x01
+#define R128_OFFSET_BIT      0x02
+#define R128_TWOSIDE_BIT     0x04
+#define R128_NODRAW_BIT      0x08
+#define R128_FALLBACK_BIT    0x10
+#define R128_FEEDBACK_BIT    0x20
+#define R128_SELECT_BIT      0x40
+#define R128_POINT_PARAM_BIT 0x80   /* not needed? */
+
+extern void r128ChooseRenderState(GLcontext *ctx);
+extern void r128TriangleFuncsInit(void);
+
+#endif
+#endif /* _R128_TRIS_H_ */
diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_tritmp.h b/xc/lib/GL/mesa/src/drv/r128/r128_tritmp.h
new file mode 100644
index 000000000..ff0804c4e
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/r128/r128_tritmp.h
@@ -0,0 +1,232 @@
+/* $XFree86$ */
+/**************************************************************************
+
+Copyright 1999, 2000 ATI Technologies Inc. and 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
+on 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
+ATI, 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 <kevin@precisioninsight.com>
+ *
+ */
+
+#if !defined(TAG) || !defined(IND)
+    this is an error;
+#endif
+
+static void TAG(triangle)(GLcontext *ctx,
+			  GLuint e0, GLuint e1, GLuint e2,
+			  GLuint pv)
+{
+    r128ContextPtr        r128ctx   = R128_CONTEXT(ctx);
+    unsigned char        *R128MMIO  = r128ctx->r128Screen->mmio;
+    struct vertex_buffer *VB        = ctx->VB;
+    r128VertexPtr         r128verts = R128_DRIVER_DATA(VB)->verts;
+    const r128_vertex    *v0        = &r128verts[e0].v;  
+    const r128_vertex    *v1        = &r128verts[e1].v;  
+    const r128_vertex    *v2        = &r128verts[e2].v;  
+
+#if (IND & R128_OFFSET_BIT)
+    GLfloat offset = ctx->Polygon.OffsetUnits * 1.0/0x10000;
+#endif
+
+#if (IND & (R128_FLAT_BIT | R128_TWOSIDE_BIT))
+    int c0 = *(int *)&r128verts[pv].v.dif_argb; 
+    int c1 = c0;
+    int c2 = c0;
+#endif
+
+#if (IND & (R128_TWOSIDE_BIT | R128_OFFSET_BIT)) 
+    {
+	GLfloat ex = v0->x - v2->x;
+	GLfloat ey = v0->y - v2->y;
+	GLfloat fx = v1->x - v2->x;
+	GLfloat fy = v1->y - v2->y;
+	GLfloat c  = ex*fy - ey*fx;
+         
+#if (IND & R128_TWOSIDE_BIT) 
+	{
+	    GLuint  facing        = (c > 0.0) ^ ctx->Polygon.FrontBit;
+	    GLubyte (*vbcolor)[4] = VB->Color[facing]->data;
+	    if (IND & R128_FLAT_BIT) {
+		R128_COLOR((char *)&c0, vbcolor[pv]);
+		c2 = c1 = c0;
+	    } else {
+		R128_COLOR((char *)&c0, vbcolor[e0]);
+		R128_COLOR((char *)&c1, vbcolor[e1]);
+		R128_COLOR((char *)&c2, vbcolor[e2]);
+	    }
+	}
+#endif
+      
+#if (IND & R128_OFFSET_BIT) 
+	{
+	    if (c * c > 1e-16) {
+		GLfloat factor = ctx->Polygon.OffsetFactor;
+		GLfloat ez     = v0->z - v2->z;
+		GLfloat fz     = v1->z - v2->z;
+		GLfloat a      = ey*fz - ez*fy;
+		GLfloat b      = ez*fx - ex*fz;
+		GLfloat ic     = 1.0 / c;
+		GLfloat ac     = a * ic;
+		GLfloat bc     = b * ic;
+		if (ac < 0.0f) ac = -ac;
+		if (bc < 0.0f) bc = -bc;
+		offset += MAX2(ac, bc) * factor;
+	    }
+	}
+#endif
+    }
+#endif  
+
+    BEGIN_CLIP_LOOP(r128ctx);
+
+    R128CCE_BEGIN_LOCKED(15);
+    R128CCE3(R128_CCE_PACKET3_3D_RNDR_GEN_PRIM, 13);
+    R128CCE(R128_CCE_VC_FRMT_DIFFUSE_ARGB);
+    R128CCE(R128_CCE_VC_CNTL_PRIM_TYPE_TRI_LIST |
+	    R128_CCE_VC_CNTL_PRIM_WALK_RING |
+	    (3 << R128_CCE_VC_CNTL_NUM_SHIFT));
+
+    R128CCEF(v0->x);
+    R128CCEF(v0->y);
+#if (IND & R128_OFFSET_BIT)
+    R128CCEF(v0->z + offset);
+#else
+    R128CCEF(v0->z);
+#endif
+
+#if (IND & (R128_FLAT_BIT | R128_TWOSIDE_BIT))
+    R128CCE(c0);
+#else
+    R128CCE(*(int *)&v0->dif_argb);
+#endif
+
+    R128CCEF(v1->x);
+    R128CCEF(v1->y);
+#if (IND & R128_OFFSET_BIT)
+    R128CCEF(v1->z + offset);
+#else
+    R128CCEF(v1->z);
+#endif
+
+#if (IND & (R128_FLAT_BIT | R128_TWOSIDE_BIT))
+    R128CCE(c1);
+#else
+    R128CCE(*(int *)&v1->dif_argb);
+#endif
+
+    R128CCEF(v2->x);
+    R128CCEF(v2->y);
+#if (IND & R128_OFFSET_BIT)
+    R128CCEF(v2->z + offset);
+#else
+    R128CCEF(v2->z);
+#endif
+
+#if (IND & (R128_FLAT_BIT | R128_TWOSIDE_BIT))
+    R128CCE(c2);
+#else
+    R128CCE(*(int *)&v2->dif_argb);
+#endif
+
+    R128CCE_END_LOCKED();
+
+    END_CLIP_LOOP(r128ctx);
+}
+
+static void TAG(quad)(GLcontext *ctx,
+		      GLuint v0, GLuint v1, GLuint v2, GLuint v3,
+		      GLuint pv)
+{
+    TAG(triangle)(ctx, v0, v1, v3, pv);
+    TAG(triangle)(ctx, v1, v2, v3, pv);
+}
+
+#if ((IND & ~R128_FLAT_BIT) == 0)
+
+static void TAG(line)(GLcontext *ctx,
+		      GLuint v0, GLuint v1,
+		      GLuint pv)
+{
+    r128ContextPtr r128ctx   = R128_CONTEXT(ctx);
+    r128VertexPtr  r128verts = R128_DRIVER_DATA(ctx->VB)->verts;
+    r128_vertex    tmp0      = r128verts[v0].v;
+    r128_vertex    tmp1      = r128verts[v1].v;
+    float          width     = ctx->Line.Width;
+
+    if (IND & R128_FLAT_BIT) {
+	*(int *)&tmp1.dif_argb =
+	    *(int *)&tmp0.dif_argb = 
+	    *(int *)&r128verts[pv].v.dif_argb;
+    }
+
+    BEGIN_CLIP_LOOP(r128ctx);
+
+    r128DrawLine(r128ctx, &tmp0, &tmp1, width);
+
+    END_CLIP_LOOP(r128ctx);
+}
+
+static void TAG(points)(GLcontext *ctx,
+			GLuint first, GLuint last)
+{
+    r128ContextPtr        r128ctx   = R128_CONTEXT(ctx);
+    struct vertex_buffer *VB        = ctx->VB;
+    r128VertexPtr         r128verts = R128_DRIVER_DATA(VB)->verts;
+    GLfloat               sz        = ctx->Point.Size * 0.5;
+    int                   i;
+
+    /* Culling is disabled automatically via. the
+     * ctx->Driver.ReducedPrimitiveChange() callback.  
+     */
+   
+    BEGIN_CLIP_LOOP(r128ctx);
+
+    for(i = first; i <= last; i++) {
+	if(VB->ClipMask[i] == 0) {
+            r128_vertex *tmp = &r128verts[i].v;
+            r128DrawPoint(r128ctx, tmp, sz);
+	}
+    }
+
+    END_CLIP_LOOP(r128ctx);
+}
+
+#endif
+
+static void TAG(init)(void)
+{
+    tri_tab[IND]    = TAG(triangle);
+    quad_tab[IND]   = TAG(quad);
+
+#if ((IND & ~R128_FLAT_BIT) == 0)
+    line_tab[IND]   = TAG(line);
+    points_tab[IND] = TAG(points);
+#endif
+}
+
+#undef IND
+#undef TAG
diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_vb.c b/xc/lib/GL/mesa/src/drv/r128/r128_vb.c
new file mode 100644
index 000000000..e3062a603
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/r128/r128_vb.c
@@ -0,0 +1,320 @@
+/* $XFree86$ */
+/**************************************************************************
+
+Copyright 1999, 2000 ATI Technologies Inc. and 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
+on 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
+ATI, 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 <kevin@precisioninsight.com>
+ *
+ */
+
+#include "r128_init.h"
+#include "r128_mesa.h"
+#include "r128_xmesa.h"
+#include "r128_context.h"
+#include "r128_vb.h"
+
+#include "stages.h"
+
+#define TEX0                                                            \
+do {                                                                    \
+    v->v.tu1 = tc0[i][0];                                               \
+    v->v.tv1 = tc0[i][1];                                               \
+} while (0)
+
+#define TEX1                                                            \
+do {                                                                    \
+    v->v.tu2 = tc1[i][0];                                               \
+    v->v.tv2 = tc1[i][1];                                               \
+} while (0)
+
+#define SPC                                                             \
+do {                                                                    \
+    GLubyte *spec = &(VB->Spec[0][i][0]);                               \
+    v->v.spec_frgb.r = spec[0];                                         \
+    v->v.spec_frgb.g = spec[1];                                         \
+    v->v.spec_frgb.b = spec[2];                                         \
+} while (0)
+
+#define FOG                                                             \
+do {                                                                    \
+    GLubyte *spec = &(VB->Spec[0][i][0]);                               \
+    v->v.spec_frgb.a = spec[3];                                         \
+} while (0)
+
+#define COL                                                             \
+do {                                                                    \
+    GLubyte *col = &(VB->Color[0]->data[i][0]);                         \
+    v->v.dif_argb.a = col[3];                                           \
+    v->v.dif_argb.r = col[0];                                           \
+    v->v.dif_argb.g = col[1];                                           \
+    v->v.dif_argb.b = col[2];                                           \
+} while (0)
+
+#define TEX0_4                                                          \
+do {                                                                    \
+    if (VB->TexCoordPtr[0]->size == 4) {                                \
+	GLfloat (*tc)[4] = VB->TexCoordPtr[0]->data;                    \
+	v = &(R128_DRIVER_DATA(VB)->verts[start]);                      \
+	for (i = start; i < end; i++, v++)   {                          \
+	    float oow = 1.0 / tc[i][3];                                 \
+	    v->v.rhw *= tc[i][3];                                       \
+	    v->v.tu1 *= oow;                                            \
+	    v->v.tv1 *= oow;                                            \
+	}                                                               \
+    }                                                                   \
+    if (VB->TexCoordPtr[1]->size == 4) {                                \
+	GLfloat (*tc)[4] = VB->TexCoordPtr[1]->data;                    \
+	v = &(R128_DRIVER_DATA(VB)->verts[start]);                      \
+	for (i = start; i < end; i++, v++)   {                          \
+	    float oow = 1.0 / tc[i][3];                                 \
+	    v->v.rhw2 *= tc[i][3];                                      \
+	    v->v.tu2  *= oow;                                           \
+	    v->v.tv2  *= oow;                                           \
+	}                                                               \
+    }                                                                   \
+} while (0)
+
+#define COORD                                                           \
+do {                                                                    \
+    GLfloat *win = VB->Win.data[i];                                     \
+    v->v.x =                 win[0];                                    \
+    v->v.y =    r128height - win[1];                                    \
+    v->v.z = (1.0/0x10000) * win[2];                                    \
+    v->v.rhw = v->v.rhw2 =   win[3];                                    \
+} while (0)
+
+#define NOP
+
+#define SETUPFUNC(name,win,col,tex0,tex1,tex0_4,spec,fog)               \
+static void name(struct vertex_buffer *VB, GLuint start, GLuint end)    \
+{                                                                       \
+    r128ContextPtr        r128ctx    = R128_CONTEXT(VB->ctx);           \
+    __DRIdrawablePrivate *dPriv      = r128ctx->driDrawable;            \
+    r128VertexPtr         v;                                            \
+    GLfloat               (*tc0)[4];                                    \
+    GLfloat               (*tc1)[4];                                    \
+    GLfloat               r128height = dPriv->h;                        \
+    int                   i;                                            \
+                                                                        \
+    (void) r128height; (void) r128ctx;                                  \
+                                                                        \
+    gl_import_client_data(VB, VB->ctx->RenderFlags,                     \
+			  (VB->ClipOrMask                               \
+			   ? VEC_WRITABLE | VEC_GOOD_STRIDE             \
+			   : VEC_GOOD_STRIDE));                         \
+                                                                        \
+    tc0 = VB->TexCoordPtr[0]->data;                                     \
+    tc1 = VB->TexCoordPtr[1]->data;                                     \
+                                                                        \
+    v = &(R128_DRIVER_DATA(VB)->verts[start]);                          \
+                                                                        \
+    if (VB->ClipOrMask == 0)                                            \
+	for (i = start; i < end; i++, v++) {                            \
+	    win;                                                        \
+	    col;                                                        \
+	    spec;                                                       \
+	    fog;                                                        \
+	    tex0;                                                       \
+	    tex1;                                                       \
+	}                                                               \
+    else                                                                \
+	for (i = start; i < end; i++, v++) {                            \
+	    if (VB->ClipMask[i] == 0) {                                 \
+		win;                                                    \
+		spec;                                                   \
+		fog;                                                    \
+		tex0;                                                   \
+		tex1;                                                   \
+	    }                                                           \
+	    col;                                                        \
+	}                                                               \
+    tex0_4;                                                             \
+}
+
+
+SETUPFUNC(rs_wt0,       COORD, NOP, TEX0, NOP,  TEX0_4, NOP, NOP)
+SETUPFUNC(rs_wt0t1,     COORD, NOP, TEX0, TEX1, TEX0_4, NOP, NOP)
+SETUPFUNC(rs_wft0,      COORD, NOP, TEX0, NOP,  TEX0_4, NOP, FOG)
+SETUPFUNC(rs_wft0t1,    COORD, NOP, TEX0, TEX1, TEX0_4, NOP, FOG)
+SETUPFUNC(rs_wg,        COORD, COL, NOP,  NOP,  NOP,    NOP, NOP)
+SETUPFUNC(rs_wgs,       COORD, COL, NOP,  NOP,  NOP,    SPC, NOP)
+SETUPFUNC(rs_wgt0,      COORD, COL, TEX0, NOP,  TEX0_4, NOP, NOP)
+SETUPFUNC(rs_wgt0t1,    COORD, COL, TEX0, TEX1, TEX0_4, NOP, NOP)
+SETUPFUNC(rs_wgst0,     COORD, COL, TEX0, NOP,  TEX0_4, SPC, NOP)
+SETUPFUNC(rs_wgst0t1,   COORD, COL, TEX0, TEX1, TEX0_4, SPC, NOP)
+SETUPFUNC(rs_wgf,       COORD, COL, NOP,  NOP,  NOP,    NOP, FOG)
+SETUPFUNC(rs_wgfs,      COORD, COL, NOP,  NOP,  NOP,    SPC, FOG)
+SETUPFUNC(rs_wgft0,     COORD, COL, TEX0, NOP,  TEX0_4, NOP, FOG)
+SETUPFUNC(rs_wgft0t1,   COORD, COL, TEX0, TEX1, TEX0_4, NOP, FOG)
+SETUPFUNC(rs_wgfst0,    COORD, COL, TEX0, NOP,  TEX0_4, SPC, FOG)
+SETUPFUNC(rs_wgfst0t1,  COORD, COL, TEX0, TEX1, TEX0_4, SPC, FOG)
+
+SETUPFUNC(rs_t0,        NOP,   NOP, TEX0, NOP,  TEX0_4, NOP, NOP)
+SETUPFUNC(rs_t0t1,      NOP,   NOP, TEX0, TEX1, TEX0_4, NOP, NOP)
+SETUPFUNC(rs_f,         NOP,   NOP, NOP,  NOP,  NOP,    NOP, FOG)
+SETUPFUNC(rs_ft0,       NOP,   NOP, TEX0, NOP,  TEX0_4, NOP, FOG)
+SETUPFUNC(rs_ft0t1,     NOP,   NOP, TEX0, TEX1, TEX0_4, NOP, FOG)
+SETUPFUNC(rs_g,         NOP,   COL, NOP,  NOP,  NOP,    NOP, NOP)
+SETUPFUNC(rs_gs,        NOP,   COL, NOP,  NOP,  NOP,    SPC, NOP)
+SETUPFUNC(rs_gt0,       NOP,   COL, TEX0, NOP,  TEX0_4, NOP, NOP)
+SETUPFUNC(rs_gt0t1,     NOP,   COL, TEX0, TEX1, TEX0_4, NOP, NOP)
+SETUPFUNC(rs_gst0,      NOP,   COL, TEX0, NOP,  TEX0_4, SPC, NOP)
+SETUPFUNC(rs_gst0t1,    NOP,   COL, TEX0, TEX1, TEX0_4, SPC, NOP)
+SETUPFUNC(rs_gf,        NOP,   COL, NOP,  NOP,  NOP,    NOP, FOG)
+SETUPFUNC(rs_gfs,       NOP,   COL, NOP,  NOP,  NOP,    SPC, FOG)
+SETUPFUNC(rs_gft0,      NOP,   COL, TEX0, NOP,  TEX0_4, NOP, FOG)
+SETUPFUNC(rs_gft0t1,    NOP,   COL, TEX0, TEX1, TEX0_4, NOP, FOG)
+SETUPFUNC(rs_gfst0,     NOP,   COL, TEX0, NOP,  TEX0_4, SPC, FOG)
+SETUPFUNC(rs_gfst0t1,   NOP,   COL, TEX0, TEX1, TEX0_4, SPC, FOG)
+
+static void rs_invalid(struct vertex_buffer *VB, GLuint start, GLuint end)
+{
+    R128_DEBUG(("r128RasterSetup(): invalid setup function\n"));
+}
+
+typedef void (*setupFunc)(struct vertex_buffer *, GLuint, GLuint);
+static setupFunc setup_func[0x80];
+
+void r128SetupInit(void)
+{
+    int i;
+
+    for (i = 0; i < 0x80; i++) setup_func[i] = rs_invalid;
+
+    /* Funcs to build vertices from scratch */
+    setup_func[R128_WIN_BIT|R128_TEX0_BIT] = rs_wt0;
+    setup_func[R128_WIN_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_wt0t1;
+    setup_func[R128_WIN_BIT|R128_FOG_BIT|R128_TEX0_BIT] = rs_wft0;
+    setup_func[R128_WIN_BIT|R128_FOG_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_wft0t1;
+    setup_func[R128_WIN_BIT|R128_RGBA_BIT] = rs_wg;
+    setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_SPEC_BIT] = rs_wgs;
+    setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_TEX0_BIT] = rs_wgt0;
+    setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_wgt0t1;
+    setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_SPEC_BIT|R128_TEX0_BIT] = rs_wgst0;
+    setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_SPEC_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_wgst0t1;
+    setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_FOG_BIT] = rs_wgf;
+    setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_FOG_BIT|R128_SPEC_BIT] = rs_wgfs;
+    setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_FOG_BIT|R128_TEX0_BIT] = rs_wgft0;
+    setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_FOG_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_wgft0t1;
+    setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_FOG_BIT|R128_SPEC_BIT|R128_TEX0_BIT] = rs_wgfst0;
+    setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_FOG_BIT|R128_SPEC_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_wgfst0t1;
+
+    /* Funcs to repair vertices */
+    setup_func[R128_TEX0_BIT] = rs_t0;
+    setup_func[R128_TEX0_BIT|R128_TEX1_BIT] = rs_t0t1;
+    setup_func[R128_FOG_BIT] = rs_f;
+    setup_func[R128_FOG_BIT|R128_TEX0_BIT] = rs_ft0;
+    setup_func[R128_FOG_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_ft0t1;
+    setup_func[R128_RGBA_BIT] = rs_g;
+    setup_func[R128_RGBA_BIT|R128_SPEC_BIT] = rs_gs;
+    setup_func[R128_RGBA_BIT|R128_TEX0_BIT] = rs_gt0;
+    setup_func[R128_RGBA_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_gt0t1;
+    setup_func[R128_RGBA_BIT|R128_SPEC_BIT|R128_TEX0_BIT] = rs_gst0;
+    setup_func[R128_RGBA_BIT|R128_SPEC_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_gst0t1;
+    setup_func[R128_RGBA_BIT|R128_FOG_BIT] = rs_gf;
+    setup_func[R128_RGBA_BIT|R128_FOG_BIT|R128_SPEC_BIT] = rs_gfs;
+    setup_func[R128_RGBA_BIT|R128_FOG_BIT|R128_TEX0_BIT] = rs_gft0;
+    setup_func[R128_RGBA_BIT|R128_FOG_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_gft0t1;
+    setup_func[R128_RGBA_BIT|R128_FOG_BIT|R128_SPEC_BIT|R128_TEX0_BIT] = rs_gfst0;
+    setup_func[R128_RGBA_BIT|R128_FOG_BIT|R128_SPEC_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_gfst0t1;
+}
+
+void r128ChooseRasterSetupFunc(GLcontext *ctx)
+{
+    int funcindex = R128_WIN_BIT | R128_RGBA_BIT;
+
+    if (ctx->Texture.Enabled & 0xf) {
+	if (ctx->Texture.Unit[0].EnvMode == GL_REPLACE)
+	    funcindex &= ~R128_RGBA_BIT;
+	funcindex |= R128_TEX0_BIT;
+    }
+
+    if (ctx->Texture.Enabled & 0xf0)
+	funcindex |= R128_TEX1_BIT;
+
+    if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
+	funcindex |= R128_SPEC_BIT;
+
+    if (ctx->FogMode == FOG_FRAGMENT)
+	funcindex |= R128_FOG_BIT;
+    
+    ctx->Driver.RasterSetup = setup_func[funcindex];
+}
+
+void r128DDRegisterVB(struct vertex_buffer *VB)
+{
+    r128VertexBufferPtr r128vb;
+
+    r128vb = (r128VertexBufferPtr)calloc(1, sizeof(*r128vb));
+
+    r128vb->size = VB->Size * 2;
+    r128vb->vert_store = malloc(sizeof(r128Vertex) * r128vb->size + 31);
+    if (!r128vb->vert_store) {
+	fprintf(stderr, "Cannot allocate vertex store!  Exiting...\n");
+	exit(1);
+    }
+   
+    r128vb->verts = (r128VertexPtr)(((CARD32)r128vb->vert_store + 31) & ~31);
+
+    gl_vector1ui_alloc(&r128vb->clipped_elements,
+		       VEC_WRITABLE, r128vb->size, 32);
+    if (!r128vb->clipped_elements.start) {
+	fprintf(stderr, "Cannot allocate clipped elements!  Exiting...\n");
+	exit(1);
+    }
+      
+    free(VB->ClipMask);
+    VB->ClipMask = (GLubyte *)malloc(sizeof(GLubyte) * r128vb->size);
+    if (!VB->ClipMask) {
+	fprintf(stderr, "Cannot allocate clipmask!  Exiting...\n");
+	exit(1);
+    }
+
+    r128vb->primitive = (GLuint *)malloc(sizeof(GLuint) * r128vb->size);
+    r128vb->next_primitive = (GLuint *)malloc(sizeof(GLuint) * r128vb->size);
+    if (!r128vb->primitive || !r128vb->next_primitive) {
+	fprintf(stderr, "Cannot allocate primitive list!  Exiting...\n");
+	exit(1);
+    }
+
+    VB->driver_data = r128vb;
+}
+
+void r128DDUnregisterVB(struct vertex_buffer *VB)
+{
+    r128VertexBufferPtr r128vb = R128_DRIVER_DATA(VB);
+   
+    if (r128vb) {
+	if (r128vb->vert_store)     free(r128vb->vert_store);
+	if (r128vb->primitive)      free(r128vb->primitive);
+	if (r128vb->next_primitive) free(r128vb->next_primitive);
+	gl_vector1ui_free(&r128vb->clipped_elements);
+	free(r128vb);
+	VB->driver_data = 0;
+    }
+}
diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_vb.h b/xc/lib/GL/mesa/src/drv/r128/r128_vb.h
new file mode 100644
index 000000000..96a560411
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/r128/r128_vb.h
@@ -0,0 +1,90 @@
+/* $XFree86$ */
+/**************************************************************************
+
+Copyright 1999, 2000 ATI Technologies Inc. and 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
+on 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
+ATI, 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 <kevin@precisioninsight.com>
+ *
+ */
+
+#ifndef _R128_VB_H_
+#define _R128_VB_H_
+
+#ifdef GLX_DIRECT_RENDERING
+
+typedef struct {
+    GLubyte b;
+    GLubyte g;
+    GLubyte r;
+    GLubyte a;
+} r128Color;
+
+typedef struct {
+    GLfloat   x, y, z;
+    GLfloat   rhw;
+    r128Color dif_argb;
+    r128Color spec_frgb;
+    GLfloat   tu1;
+    GLfloat   tv1;
+    GLfloat   tu2;
+    GLfloat   tv2;
+    GLfloat   rhw2;
+} r128_vertex;
+
+typedef union {
+    r128_vertex v;
+    float       f[16];
+} r128Vertex, *r128VertexPtr;
+
+typedef struct {
+   GLvector1ui    clipped_elements;
+   r128VertexPtr  verts;
+   int            last_vert;
+   GLuint        *primitive;
+   GLuint        *next_primitive;
+   void          *vert_store;
+   GLuint         size;
+} *r128VertexBufferPtr;
+
+#define R128_DRIVER_DATA(vb) ((r128VertexBufferPtr)((vb)->driver_data))
+
+#define R128_SPEC_BIT       0x01
+#define R128_FOG_BIT        0x02
+#define R128_ALPHA_BIT      0x04 /* GL_BLEND, not used */
+#define R128_TEX1_BIT       0x08
+#define R128_TEX0_BIT       0x10        
+#define R128_RGBA_BIT       0x20
+#define R128_WIN_BIT        0x40
+
+extern void r128SetupInit(void);
+extern void r128ChooseRasterSetupFunc(GLcontext *ctx);
+extern void r128DDRegisterVB(struct vertex_buffer *VB);
+extern void r128DDUnregisterVB(struct vertex_buffer *VB);
+
+#endif
+#endif /* _R128_VB_H_ */
diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_xmesa.c b/xc/lib/GL/mesa/src/drv/r128/r128_xmesa.c
index 6db5af3fa..c0d1697c6 100644
--- a/xc/lib/GL/mesa/src/drv/r128/r128_xmesa.c
+++ b/xc/lib/GL/mesa/src/drv/r128/r128_xmesa.c
@@ -48,6 +48,8 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "r128_depth.h"
 #include "r128_tex.h"
 #include "r128_swap.h"
+#include "r128_tris.h"
+#include "r128_vb.h"
 
 /* Mesa src includes */
 #include "context.h"
@@ -151,6 +153,9 @@ GLboolean XMesaInitDriver(__DRIscreenPrivate *sPriv)
 
     sPriv->private = (void *)r128Screen;
 
+    r128TriangleFuncsInit();
+    r128SetupInit();
+
     return GL_TRUE;
 }
 
@@ -280,12 +285,16 @@ XMesaContext XMesaCreateContext(XMesaVisual v, XMesaContext share_list,
     r128DDInitDepthFuncs(glCtx);
     r128DDInitTextureFuncs(glCtx);
 
+#if 1
     /* FIXME: Move to r128_tris.c */
     glCtx->Driver.TriangleCaps = (DD_TRI_CULL
 				  | DD_TRI_LIGHT_TWOSIDE
 				  | DD_TRI_OFFSET);
     glCtx->TriangleCaps |= DD_CLIP_FOG_COORD;
 
+    if (glCtx->VB) r128DDRegisterVB(glCtx->VB);
+#endif
+
     r128DDInitState(r128ctx);
 
     return c;
diff --git a/xc/lib/GL/mesa/src/drv/r128/spantmp.h b/xc/lib/GL/mesa/src/drv/r128/spantmp.h
new file mode 100644
index 000000000..6a1b15c88
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/r128/spantmp.h
@@ -0,0 +1,236 @@
+#ifndef DBG
+#define DBG 0
+#endif
+
+static void TAG(WriteRGBASpan)( const GLcontext *ctx, 
+				GLuint n, GLint x, GLint y, 
+				const GLubyte rgba[][4], 
+				const GLubyte mask[] )
+{
+   HW_LOCK()
+      {
+	 GLint x1;
+	 GLint n1;
+	 LOCAL_VARS;
+	 
+	 y = Y_FLIP(y);
+
+
+	 HW_CLIPLOOP() 
+	    {
+	       GLint i = 0;
+	       CLIPSPAN(x,y,n,x1,n1,i);
+
+	       if (DBG) fprintf(stderr, "WriteRGBASpan %d..%d (x1 %d)\n",
+				(int)i, (int)n1, (int)x1);
+
+	       if (mask)
+	       {
+		  for (;i<n1;i++,x1++)
+		     if (mask[i])
+			WRITE_RGBA( x1, y, 
+				    rgba[i][0], rgba[i][1], 
+				    rgba[i][2], rgba[i][3] );
+	       }
+	       else
+	       {
+		  for (;i<n1;i++,x1++)
+		     WRITE_RGBA( x1, y, 
+				 rgba[i][0], rgba[i][1], 
+				 rgba[i][2], rgba[i][3] );
+	       }
+	    }
+	 HW_ENDCLIPLOOP();
+      }
+   HW_UNLOCK();
+}
+
+static void TAG(WriteRGBSpan)( const GLcontext *ctx,
+			       GLuint n, GLint x, GLint y,
+			       const GLubyte rgb[][3], 
+			       const GLubyte mask[] )
+{
+   HW_LOCK()
+      {
+	 GLint x1;
+	 GLint n1;
+	 LOCAL_VARS;
+
+	 y = Y_FLIP(y);
+
+	 HW_CLIPLOOP() 
+	    {
+	       GLint i = 0;
+	       CLIPSPAN(x,y,n,x1,n1,i);
+
+	       if (DBG) fprintf(stderr, "WriteRGBSpan %d..%d (x1 %d)\n",
+				(int)i, (int)n1, (int)x1);
+
+	       if (mask)
+	       {
+		  for (;i<n1;i++,x1++)
+		     if (mask[i])
+			WRITE_RGBA( x1, y, rgb[i][0], rgb[i][1], rgb[i][2], 0 );
+	       }
+	       else
+	       {
+		  for (;i<n1;i++,x1++)
+		     WRITE_RGBA( x1, y, rgb[i][0], rgb[i][1], rgb[i][2], 0 );
+	       }
+	    }
+	 HW_ENDCLIPLOOP();
+      }
+   HW_UNLOCK();
+}
+
+static void TAG(WriteRGBAPixels)( const GLcontext *ctx,
+			       GLuint n, 
+			       const GLint x[], 
+			       const GLint y[],
+			       const GLubyte rgba[][4], 
+			       const GLubyte mask[] )
+{
+   HW_LOCK()
+      {
+	 GLint i;
+	 LOCAL_VARS;
+
+	 if (DBG) fprintf(stderr, "WriteRGBAPixels\n");
+
+	 HW_CLIPLOOP()
+	    {
+	       for (i=0;i<n;i++)
+	       {
+		  if (mask[i]) {
+		     const int fy = Y_FLIP(y[i]);
+		     if (CLIPPIXEL(x[i],fy))
+			WRITE_RGBA( x[i], fy, 
+				    rgba[i][0], rgba[i][1], 
+				    rgba[i][2], rgba[i][3] );
+		  }
+	       }
+	    }
+	 HW_ENDCLIPLOOP();
+      }
+   HW_UNLOCK();
+}
+
+
+static void TAG(WriteMonoRGBASpan)( const GLcontext *ctx,	
+				    GLuint n, GLint x, GLint y, 
+				    const GLubyte mask[] )
+{
+   HW_LOCK()
+      {
+	 GLint x1;
+	 GLint n1;
+	 LOCAL_VARS;
+	 INIT_MONO_PIXEL(p);
+
+	 y = Y_FLIP( y );
+
+	 if (DBG) fprintf(stderr, "WriteMonoRGBASpan\n");
+
+	 HW_CLIPLOOP() 
+	    {
+	       GLint i = 0;
+	       CLIPSPAN(x,y,n,x1,n1,i);
+	       for (;i<n1;i++,x1++)
+		  if (mask[i])
+		     WRITE_PIXEL( x1, y, p );
+	    }
+	 HW_ENDCLIPLOOP();
+      }
+   HW_UNLOCK();
+}
+
+
+static void TAG(WriteMonoRGBAPixels)( const GLcontext *ctx,
+				      GLuint n, 
+				      const GLint x[], const GLint y[],
+				      const GLubyte mask[] ) 
+{
+   HW_LOCK()
+      {
+   GLint i;
+   LOCAL_VARS;
+   INIT_MONO_PIXEL(p);
+
+   if (DBG) fprintf(stderr, "WriteMonoRGBAPixels\n");
+
+   HW_CLIPLOOP()
+      {
+	 for (i=0;i<n;i++)
+	    if (mask[i]) {
+	       int fy = Y_FLIP(y[i]);
+	       if (CLIPPIXEL( x[i], fy ))
+		  WRITE_PIXEL( x[i], fy, p );
+	    }
+      }
+   HW_ENDCLIPLOOP();
+      } 
+   HW_UNLOCK();
+}
+
+
+
+/*
+ * Read a horizontal span of color pixels.
+ */
+static void TAG(ReadRGBASpan)( const GLcontext *ctx,
+			       GLuint n, GLint x, GLint y,
+			       GLubyte rgba[][4])
+{
+   HW_LOCK()
+      {
+	 GLint x1,n1;
+	 LOCAL_VARS;
+
+	 y = Y_FLIP(y);
+
+	 if (DBG) fprintf(stderr, "ReadRGBASpan\n");
+
+	 HW_CLIPLOOP() 
+	    {
+	       GLint i = 0;
+	       CLIPSPAN(x,y,n,x1,n1,i);
+	       for (;i<n1;i++)
+		  READ_RGBA( rgba[i], x1+i, y );
+	    }
+	 HW_ENDCLIPLOOP();
+      }
+   HW_UNLOCK();
+}
+
+static void TAG(ReadRGBAPixels)( const GLcontext *ctx,
+				 GLuint n, const GLint x[], const GLint y[],
+				 GLubyte rgba[][4], const GLubyte mask[] )
+{
+   HW_LOCK()
+      {
+	 GLint i;
+	 LOCAL_VARS;
+
+	 if (DBG) fprintf(stderr, "ReadRGBAPixels\n");
+ 
+	 HW_CLIPLOOP()
+	    {
+	       for (i=0;i<n;i++)
+		  if (mask[i]) {
+		     int fy = Y_FLIP( y[i] );
+		     if (CLIPPIXEL( x[i], fy ))
+			READ_RGBA( rgba[i], x[i], fy );
+		  }
+	    }
+	 HW_ENDCLIPLOOP();
+      }
+   HW_UNLOCK();
+}
+
+
+
+
+#undef WRITE_PIXEL
+#undef WRITE_RGBA
+#undef READ_RGBA
+#undef TAG