X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fdrivers%2Fx11%2Fxm_tri.c;h=da26235ff045460042b2d7c22f26e9c9ed58dd32;hb=6a10dd08f4311c9d46231269fb35f7cf8cb124c7;hp=e017ed523fbade4cb59d1c86f6695571ea76fa95;hpb=9bf68ad963ba92b5d1e725f965979042495a5313;p=mesa.git

diff --git a/src/mesa/drivers/x11/xm_tri.c b/src/mesa/drivers/x11/xm_tri.c
index e017ed523fb..da26235ff04 100644
--- a/src/mesa/drivers/x11/xm_tri.c
+++ b/src/mesa/drivers/x11/xm_tri.c
@@ -1,10 +1,7 @@
-/* $Id: xm_tri.c,v 1.20 2001/05/14 16:23:04 brianp Exp $ */
-
 /*
  * Mesa 3-D graphics library
- * Version:  3.5
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * 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"),
@@ -19,9 +16,10 @@
  * 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  */
 
 
@@ -32,11 +30,11 @@
  */
 
 
+#include <stdio.h>
+#include "c99_math.h"
+#include "main/imports.h"
+#include "main/mtypes.h"
 #include "glxheader.h"
-#include "depth.h"
-#include "macros.h"
-#include "mmath.h"
-#include "mtypes.h"
 #include "xmesaP.h"
 
 /* Internal swrast includes:
@@ -44,362 +42,235 @@
 #include "swrast/s_context.h"
 #include "swrast/s_depth.h"
 #include "swrast/s_triangle.h"
-#include "swrast/s_trispan.h"
 
 
+#define GET_XRB(XRB)  struct xmesa_renderbuffer *XRB = \
+   xmesa_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0])
+
 
 /**********************************************************************/
 /***                   Triangle rendering                           ***/
 /**********************************************************************/
 
 
+#if CHAN_BITS == 8
+
 /*
  * XImage, smooth, depth-buffered, PF_TRUECOLOR triangle.
  */
-static void smooth_TRUECOLOR_z_triangle( GLcontext *ctx,
-                                         const SWvertex *v0,
-					 const SWvertex *v1,
-					 const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define NAME smooth_TRUECOLOR_z_triangle
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 #define INTERP_RGB 1
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   GET_XRB(xrb);
 
-#define RENDER_SPAN( span )					\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+#define RENDER_SPAN( span ) {					\
+   GLint x = span.x, y = YFLIP(xrb, span.y);			\
    GLuint i;							\
-   for (i = 0; i < span.count; i++, x++) {			\
+   for (i = 0; i < span.end; i++, x++) {			\
       const DEPTH_TYPE z = FixedToDepth(span.z);		\
       if (z < zRow[i]) {					\
          unsigned long p;					\
          PACK_TRUECOLOR(p, FixedToInt(span.red),		\
             FixedToInt(span.green), FixedToInt(span.blue));	\
-         XMesaPutPixel(img, x, y, p);				\
+         XMesaPutPixel(xrb->ximage, x, y, p);			\
          zRow[i] = z;						\
       }								\
       span.red += span.redStep;					\
       span.green += span.greenStep;				\
       span.blue += span.blueStep;				\
       span.z += span.zStep;					\
-   }
+   } }
 
 #include "swrast/s_tritemp.h"
-}
+
 
 
 
 /*
  * XImage, smooth, depth-buffered, PF_8A8B8G8R triangle.
  */
-static void smooth_8A8B8G8R_z_triangle( GLcontext *ctx,
-					const SWvertex *v0,
-					const SWvertex *v1,
-					const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME smooth_8A8B8G8R_z_triangle
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 #define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define INTERP_ALPHA 1
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
 #define PIXEL_TYPE GLuint
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-
-#define RENDER_SPAN( span )					\
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
+#define SETUP_CODE						\
+   GET_XRB(xrb);
+#define RENDER_SPAN( span ) {					\
    GLuint i;							\
-   for (i = 0; i < span.count; i++) {				\
+   for (i = 0; i < span.end; i++) {				\
       const DEPTH_TYPE z = FixedToDepth(span.z);		\
       if (z < zRow[i]) {					\
-         pRow[i] = PACK_8B8G8R(FixedToInt(span.red),		\
-            FixedToInt(span.green), FixedToInt(span.blue));	\
+         pRow[i] = PACK_8A8B8G8R(FixedToInt(span.red),		\
+            FixedToInt(span.green), FixedToInt(span.blue),	\
+            FixedToInt(span.alpha));				\
          zRow[i] = z;						\
       }								\
       span.red += span.redStep;					\
       span.green += span.greenStep;				\
       span.blue += span.blueStep;				\
+      span.alpha += span.alphaStep;				\
       span.z += span.zStep;					\
-   }
+   } }
 
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
- * XImage, smooth, depth-buffered, PF_8R8G8B triangle.
+ * XImage, smooth, depth-buffered, PF_8A8R8G8B triangle.
  */
-static void smooth_8R8G8B_z_triangle( GLcontext *ctx,
-				      const SWvertex *v0,
-				      const SWvertex *v1,
-				      const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME smooth_8A8R8G8B_z_triangle
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 #define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define INTERP_ALPHA 1
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
 #define PIXEL_TYPE GLuint
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
+#define SETUP_CODE						\
+   GET_XRB(xrb);
 
-#define RENDER_SPAN( span )					\
+#define RENDER_SPAN( span ) {					\
    GLuint i;							\
-   for (i = 0; i < span.count; i++) {				\
+   for (i = 0; i < span.end; i++) {				\
       const DEPTH_TYPE z = FixedToDepth(span.z);		\
       if (z < zRow[i]) {					\
-         pRow[i] = PACK_8R8G8B(FixedToInt(span.red),		\
-            FixedToInt(span.green), FixedToInt(span.blue));	\
+         pRow[i] = PACK_8A8R8G8B(FixedToInt(span.red),		\
+            FixedToInt(span.green), FixedToInt(span.blue),	\
+            FixedToInt(span.alpha));				\
          zRow[i] = z;						\
       }								\
       span.red += span.redStep;					\
       span.green += span.greenStep;				\
       span.blue += span.blueStep;				\
+      span.alpha += span.alphaStep;				\
       span.z += span.zStep;					\
-   }
+   } }
 
 #include "swrast/s_tritemp.h"
-}
-
-
-/*
- * XImage, smooth, depth-buffered, PF_8R8G8B24 triangle.
- */
-static void smooth_8R8G8B24_z_triangle( GLcontext *ctx,
-                                        const SWvertex *v0,
-					const SWvertex *v1,
-					const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE bgr_t
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-
-#define RENDER_SPAN( span ) 					\
-   GLuint i;							\
-   for (i = 0; i < span.count; i++) {				\
-      const DEPTH_TYPE z = FixedToDepth(span.z);		\
-      if (z < zRow[i]) {					\
-	 PIXEL_TYPE *ptr = pRow + i;				\
-         ptr->r = FixedToInt(span.red);				\
-         ptr->g = FixedToInt(span.green);			\
-         ptr->b = FixedToInt(span.blue);			\
-         zRow[i] = z;						\
-      }								\
-      span.red += span.redStep;					\
-      span.green += span.greenStep;				\
-      span.blue += span.blueStep;				\
-      span.z += span.zStep;					\
-   }
 
-#include "swrast/s_tritemp.h"
-}
 
 
 /*
- * XImage, smooth, depth-buffered, PF_TRUEDITHER triangle.
+ * XImage, smooth, depth-buffered, PF_8R8G8B triangle.
  */
-static void smooth_TRUEDITHER_z_triangle( GLcontext *ctx,
-					  const SWvertex *v0,
-					  const SWvertex *v1,
-					  const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define NAME smooth_8R8G8B_z_triangle
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 #define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
+#define SETUP_CODE						\
+   GET_XRB(xrb);
 
-#define RENDER_SPAN( span )					\
+#define RENDER_SPAN( span ) {					\
    GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   for (i = 0; i < span.count; i++, x++) {			\
+   for (i = 0; i < span.end; i++) {				\
       const DEPTH_TYPE z = FixedToDepth(span.z);		\
       if (z < zRow[i]) {					\
-         unsigned long p;					\
-         PACK_TRUEDITHER(p, x, y, FixedToInt(span.red),		\
+         pRow[i] = PACK_8R8G8B(FixedToInt(span.red),		\
             FixedToInt(span.green), FixedToInt(span.blue));	\
-         XMesaPutPixel(img, x, y, p);				\
          zRow[i] = z;						\
       }								\
       span.red += span.redStep;					\
       span.green += span.greenStep;				\
       span.blue += span.blueStep;				\
       span.z += span.zStep;					\
-   }
+   } }
 
 #include "swrast/s_tritemp.h"
-}
-
-
-/*
- * XImage, smooth, depth-buffered, PF_5R6G5B triangle.
- */
-static void smooth_5R6G5B_z_triangle( GLcontext *ctx,
-                                      const SWvertex *v0,
-				      const SWvertex *v1,
-				      const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLushort
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-
-#define RENDER_SPAN( span )					\
-   GLuint i;							\
-   for (i = 0; i < span.count; i++) {				\
-      const DEPTH_TYPE z = FixedToDepth(span.z);		\
-      if (z < zRow[i]) {					\
-         pRow[i] = PACK_5R6G5B(FixedToInt(span.red),		\
-            FixedToInt(span.green), FixedToInt(span.blue));	\
-         zRow[i] = z;						\
-      }								\
-      span.red += span.redStep;					\
-      span.green += span.greenStep;				\
-      span.blue += span.blueStep;				\
-      span.z += span.zStep;					\
-   }
 
-#include "swrast/s_tritemp.h"
-}
 
 
 /*
- * XImage, smooth, depth-buffered, PF_DITHER_5R6G5B triangle.
+ * XImage, smooth, depth-buffered, PF_8R8G8B24 triangle.
  */
-static void smooth_DITHER_5R6G5B_z_triangle( GLcontext *ctx,
-                                             const SWvertex *v0,
-					     const SWvertex *v1,
-					     const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME smooth_8R8G8B24_z_triangle
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 #define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLushort
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-
-#define RENDER_SPAN( span )					\
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
+#define PIXEL_TYPE bgr_t
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
+#define SETUP_CODE						\
+   GET_XRB(xrb);
+#define RENDER_SPAN( span ) {					\
    GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   for (i = 0; i < span.count; i++, x++) {			\
+   for (i = 0; i < span.end; i++) {				\
       const DEPTH_TYPE z = FixedToDepth(span.z);		\
       if (z < zRow[i]) {					\
-         PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red),	\
-            FixedToInt(span.green), FixedToInt(span.blue));	\
+	 PIXEL_TYPE *ptr = pRow + i;				\
+         ptr->r = FixedToInt(span.red);				\
+         ptr->g = FixedToInt(span.green);			\
+         ptr->b = FixedToInt(span.blue);			\
          zRow[i] = z;						\
       }								\
       span.red += span.redStep;					\
       span.green += span.greenStep;				\
       span.blue += span.blueStep;				\
       span.z += span.zStep;					\
-   }
-
+   } }
 #include "swrast/s_tritemp.h"
-}
-
-
-/*
- * XImage, smooth, depth-buffered, 8-bit, PF_DITHER8 triangle.
- */
-static void smooth_DITHER8_z_triangle( GLcontext *ctx,
-                                       const SWvertex *v0,
-				       const SWvertex *v1,
-				       const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-
-#define RENDER_SPAN( span )					\
-   GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   XDITHER_SETUP(y);						\
-   for (i = 0; i < span.count; i++, x++) {			\
-      const DEPTH_TYPE z = FixedToDepth(span.z);		\
-      if (z < zRow[i]) {					\
-         pRow[i] = (PIXEL_TYPE) XDITHER(x, FixedToInt(span.red),\
-            FixedToInt(span.green), FixedToInt(span.blue) );	\
-         zRow[i] = z;						\
-      }								\
-      span.red += span.redStep;					\
-      span.green += span.greenStep;				\
-      span.blue += span.blueStep;				\
-      span.z += span.zStep;					\
-   }
 
-#include "swrast/s_tritemp.h"
-}
 
 
 /*
- * XImage, smooth, depth-buffered, PF_DITHER triangle.
+ * XImage, smooth, depth-buffered, PF_TRUEDITHER triangle.
  */
-static void smooth_DITHER_z_triangle( GLcontext *ctx,
-				      const SWvertex *v0,
-				      const SWvertex *v1,
-				      const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define NAME smooth_TRUEDITHER_z_triangle
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 #define INTERP_RGB 1
-
-#define RENDER_SPAN( span )					\
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   GET_XRB(xrb);
+#define RENDER_SPAN( span ) {					\
    GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   XDITHER_SETUP(y);						\
-   for (i = 0; i < span.count; i++, x++) {			\
+   GLint x = span.x, y = YFLIP(xrb, span.y);			\
+   for (i = 0; i < span.end; i++, x++) {			\
       const DEPTH_TYPE z = FixedToDepth(span.z);		\
       if (z < zRow[i]) {					\
-         unsigned long p = XDITHER(x, FixedToInt(span.red),	\
+         unsigned long p;					\
+         PACK_TRUEDITHER(p, x, y, FixedToInt(span.red),		\
             FixedToInt(span.green), FixedToInt(span.blue));	\
-	 XMesaPutPixel(img, x, y, p);			       	\
+         XMesaPutPixel(xrb->ximage, x, y, p);			\
          zRow[i] = z;						\
       }								\
       span.red += span.redStep;					\
       span.green += span.greenStep;				\
       span.blue += span.blueStep;				\
       span.z += span.zStep;					\
-   }
-
+   } }
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
- * XImage, smooth, depth-buffered, 8-bit PF_LOOKUP triangle.
+ * XImage, smooth, depth-buffered, PF_5R6G5B triangle.
  */
-static void smooth_LOOKUP8_z_triangle( GLcontext *ctx,
-				       const SWvertex *v0,
-				       const SWvertex *v1,
-				       const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME smooth_5R6G5B_z_triangle
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 #define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-
-#define RENDER_SPAN( span )					\
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
+#define SETUP_CODE						\
+   GET_XRB(xrb);
+#define RENDER_SPAN( span ) {					\
    GLuint i;							\
-   LOOKUP_SETUP;						\
-   for (i = 0; i < span.count; i++) {				\
+   for (i = 0; i < span.end; i++) {				\
       const DEPTH_TYPE z = FixedToDepth(span.z);		\
       if (z < zRow[i]) {					\
-         pRow[i] = LOOKUP(FixedToInt(span.red),			\
+         pRow[i] = PACK_5R6G5B(FixedToInt(span.red),		\
             FixedToInt(span.green), FixedToInt(span.blue));	\
          zRow[i] = z;						\
       }								\
@@ -407,163 +278,166 @@ static void smooth_LOOKUP8_z_triangle( GLcontext *ctx,
       span.green += span.greenStep;				\
       span.blue += span.blueStep;				\
       span.z += span.zStep;					\
-   }
-
+   } }
 #include "swrast/s_tritemp.h"
-}
 
 
 
 /*
- * XImage, smooth, depth-buffered, 8-bit PF_HPCR triangle.
+ * XImage, smooth, depth-buffered, PF_DITHER_5R6G5B triangle.
  */
-static void smooth_HPCR_z_triangle( GLcontext *ctx,
-				    const SWvertex *v0,
-				    const SWvertex *v1,
-				    const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME smooth_DITHER_5R6G5B_z_triangle
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 #define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-
-#define RENDER_SPAN( span )					\
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   GET_XRB(xrb);
+#define RENDER_SPAN( span ) {					\
    GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   for (i = 0; i < span.count; i++, x++) {			\
+   GLint x = span.x, y = YFLIP(xrb, span.y);			\
+   for (i = 0; i < span.end; i++, x++) {			\
       const DEPTH_TYPE z = FixedToDepth(span.z);		\
       if (z < zRow[i]) {					\
-         pRow[i] = DITHER_HPCR(x, y, FixedToInt(span.red),	\
-            FixedToInt(span.green), FixedToInt(span.blue) );	\
+         PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red),	\
+            FixedToInt(span.green), FixedToInt(span.blue));	\
          zRow[i] = z;						\
       }								\
       span.red += span.redStep;					\
       span.green += span.greenStep;				\
       span.blue += span.blueStep;				\
       span.z += span.zStep;					\
-   }
-
+   } }
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
  * XImage, flat, depth-buffered, PF_TRUECOLOR triangle.
  */
-static void flat_TRUECOLOR_z_triangle( GLcontext *ctx,
-                        	       const SWvertex *v0,
-				       const SWvertex *v1,
-				       const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define NAME flat_TRUECOLOR_z_triangle
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 #define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   GET_XRB(xrb);						\
+   XMesaImage *img = xrb->ximage;				\
    unsigned long pixel;						\
    PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]);
-
-#define RENDER_SPAN( span )					\
+#define RENDER_SPAN( span ) {					\
    GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   for (i = 0; i < span.count; i++, x++) {			\
+   GLint x = span.x, y = YFLIP(xrb, span.y);			\
+   for (i = 0; i < span.end; i++, x++) {			\
       const DEPTH_TYPE z = FixedToDepth(span.z);		\
       if (z < zRow[i]) {					\
          XMesaPutPixel(img, x, y, pixel);			\
          zRow[i] = z;						\
       }								\
       span.z += span.zStep;					\
-   }
-
+   } }
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
  * XImage, flat, depth-buffered, PF_8A8B8G8R triangle.
  */
-static void flat_8A8B8G8R_z_triangle( GLcontext *ctx,
-				      const SWvertex *v0,
-				      const SWvertex *v1,
-				      const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME flat_8A8B8G8R_z_triangle
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
 #define PIXEL_TYPE GLuint
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 #define SETUP_CODE					\
-   unsigned long p = PACK_8B8G8R( v2->color[0],	\
-		 v2->color[1], v2->color[2] );
-#define RENDER_SPAN( span )				\
+   GET_XRB(xrb);					\
+   GLuint p = PACK_8A8B8G8R( v2->color[0], v2->color[1],\
+                             v2->color[2], v2->color[3]);
+#define RENDER_SPAN( span ) {				\
    GLuint i;						\
-   for (i = 0; i < span.count; i++) {			\
+   for (i = 0; i < span.end; i++) {			\
       const DEPTH_TYPE z = FixedToDepth(span.z);	\
       if (z < zRow[i]) {				\
 	 pRow[i] = (PIXEL_TYPE) p;			\
          zRow[i] = z;					\
       }							\
       span.z += span.zStep;				\
-   }
+   } }
+#include "swrast/s_tritemp.h"
+
 
+
+/*
+ * XImage, flat, depth-buffered, PF_8A8R8G8B triangle.
+ */
+#define NAME flat_8A8R8G8B_z_triangle
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
+#define SETUP_CODE					\
+   GET_XRB(xrb);					\
+   GLuint p = PACK_8A8R8G8B(v2->color[0], v2->color[1],	\
+                            v2->color[2], v2->color[3]);
+#define RENDER_SPAN( span ) {				\
+   GLuint i;						\
+   for (i = 0; i < span.end; i++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);	\
+      if (z < zRow[i]) {				\
+	 pRow[i] = (PIXEL_TYPE) p;			\
+         zRow[i] = z;					\
+      }							\
+      span.z += span.zStep;				\
+   } }
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
  * XImage, flat, depth-buffered, PF_8R8G8B triangle.
  */
-static void flat_8R8G8B_z_triangle( GLcontext *ctx,
-				    const SWvertex *v0,
-				    const SWvertex *v1,
-				    const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME flat_8R8G8B_z_triangle
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
 #define PIXEL_TYPE GLuint
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE				\
-   unsigned long p = PACK_8R8G8B( v2->color[0],	\
-		 v2->color[1], v2->color[2] );
-#define RENDER_SPAN( span )			\
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
+#define SETUP_CODE					\
+   GET_XRB(xrb);					\
+   GLuint p = PACK_8R8G8B( v2->color[0], v2->color[1], v2->color[2] );
+#define RENDER_SPAN( span ) {			\
    GLuint i;					\
-   for (i = 0; i < span.count; i++) {		\
+   for (i = 0; i < span.end; i++) {		\
       DEPTH_TYPE z = FixedToDepth(span.z);	\
       if (z < zRow[i]) {			\
 	 pRow[i] = (PIXEL_TYPE) p;		\
          zRow[i] = z;				\
       }						\
       span.z += span.zStep;			\
-   }
+   } }
 
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
  * XImage, flat, depth-buffered, PF_8R8G8B24 triangle.
  */
-static void flat_8R8G8B24_z_triangle( GLcontext *ctx,
-				      const SWvertex *v0,
-				      const SWvertex *v1,
-				      const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = v2->color;
+#define NAME flat_8R8G8B24_z_triangle
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
 #define PIXEL_TYPE bgr_t
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define RENDER_SPAN( span )				\
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
+#define SETUP_CODE					\
+   GET_XRB(xrb);					\
+   const GLubyte *color = v2->color;
+#define RENDER_SPAN( span ) {				\
    GLuint i;						\
-   for (i = 0; i < span.count; i++) {			\
+   for (i = 0; i < span.end; i++) {			\
       const DEPTH_TYPE z = FixedToDepth(span.z);	\
       if (z < zRow[i]) {				\
 	 PIXEL_TYPE *ptr = pRow + i;			\
@@ -573,28 +447,25 @@ static void flat_8R8G8B24_z_triangle( GLcontext *ctx,
          zRow[i] = z;					\
       }							\
       span.z += span.zStep;				\
-   }
-
+   } }
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
  * XImage, flat, depth-buffered, PF_TRUEDITHER triangle.
  */
-static void flat_TRUEDITHER_z_triangle( GLcontext *ctx,
-					const SWvertex *v0,
-					const SWvertex *v1,
-					const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define NAME flat_TRUEDITHER_z_triangle
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define RENDER_SPAN( span )					\
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   GET_XRB(xrb);						\
+   XMesaImage *img = xrb->ximage;
+#define RENDER_SPAN( span ) {					\
    GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   for (i = 0; i < span.count; i++, x++) {			\
+   GLint x = span.x, y = YFLIP(xrb, span.y);			\
+   for (i = 0; i < span.end; i++, x++) {			\
       const DEPTH_TYPE z = FixedToDepth(span.z);		\
       if (z < zRow[i]) {					\
          unsigned long p;					\
@@ -604,63 +475,54 @@ static void flat_TRUEDITHER_z_triangle( GLcontext *ctx,
          zRow[i] = z;						\
       }								\
       span.z += span.zStep;					\
-   }
-
+   } }
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
  * XImage, flat, depth-buffered, PF_5R6G5B triangle.
  */
-static void flat_5R6G5B_z_triangle( GLcontext *ctx,
-				    const SWvertex *v0,
-				    const SWvertex *v1,
-				    const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME flat_5R6G5B_z_triangle
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
 #define PIXEL_TYPE GLushort
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 #define SETUP_CODE					\
-   unsigned long p = PACK_5R6G5B( v2->color[0],		\
-            v2->color[1], v2->color[2] );
-#define RENDER_SPAN( span )				\
+   GET_XRB(xrb);					\
+   GLushort p = PACK_5R6G5B( v2->color[0], v2->color[1], v2->color[2] );
+#define RENDER_SPAN( span ) {				\
    GLuint i;						\
-   for (i = 0; i < span.count; i++) {			\
+   for (i = 0; i < span.end; i++) {			\
       const DEPTH_TYPE z = FixedToDepth(span.z);	\
       if (z < zRow[i]) {				\
 	 pRow[i] = (PIXEL_TYPE) p;			\
          zRow[i] = z;					\
       }							\
       span.z += span.zStep;				\
-   }
-
+   } }
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
  * XImage, flat, depth-buffered, PF_DITHER_5R6G5B triangle.
  */
-static void flat_DITHER_5R6G5B_z_triangle( GLcontext *ctx,
-					   const SWvertex *v0,
-					   const SWvertex *v1,
-					   const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = v2->color;
+#define NAME flat_DITHER_5R6G5B_z_triangle
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
 #define PIXEL_TYPE GLushort
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define RENDER_SPAN( span )					\
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   GET_XRB(xrb);						\
+   const GLubyte *color = v2->color;
+#define RENDER_SPAN( span ) {					\
    GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   for (i = 0; i < span.count; i++, x++) {			\
+   GLint x = span.x, y = YFLIP(xrb, span.y);			\
+   for (i = 0; i < span.end; i++, x++) {			\
       const DEPTH_TYPE z = FixedToDepth(span.z);		\
       if (z < zRow[i]) {					\
 	 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP],		\
@@ -668,164 +530,23 @@ static void flat_DITHER_5R6G5B_z_triangle( GLcontext *ctx,
          zRow[i] = z;						\
       }								\
       span.z += span.zStep;					\
-   }
-
-#include "swrast/s_tritemp.h"
-}
-
-
-/*
- * XImage, flat, depth-buffered, 8-bit PF_DITHER triangle.
- */
-static void flat_DITHER8_z_triangle( GLcontext *ctx,
-				     const SWvertex *v0,
-				     const SWvertex *v1,
-				     const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE	\
-   FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
-
-#define RENDER_SPAN( span )					\
-   GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, y));		\
-   for (i = 0; i < span.count; i++, x++) {			\
-      const DEPTH_TYPE z = FixedToDepth(span.z);		\
-      if (z < zRow[i]) {					\
-	 pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x);			\
-         zRow[i] = z;						\
-      }								\
-      span.z += span.zStep;					\
-   }
-
-#include "swrast/s_tritemp.h"
-}
-
-
-/*
- * XImage, flat, depth-buffered, PF_DITHER triangle.
- */
-static void flat_DITHER_z_triangle( GLcontext *ctx,
-				    const SWvertex *v0,
-				    const SWvertex *v1,
-				    const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define SETUP_CODE	\
-   FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
-
-#define RENDER_SPAN( span )					\
-   GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   FLAT_DITHER_ROW_SETUP(y);					\
-   for (i = 0; i < span.count; i++, x++) {			\
-      const DEPTH_TYPE z = FixedToDepth(span.z);		\
-      if (z < zRow[i]) {					\
-         unsigned long p = FLAT_DITHER(x);			\
-	 XMesaPutPixel(img, x, y, p);				\
-         zRow[i] = z;						\
-      }								\
-      span.z += span.zStep;					\
-   }
-
-#include "swrast/s_tritemp.h"
-}
-
-
-/*
- * XImage, flat, depth-buffered, 8-bit PF_HPCR triangle.
- */
-static void flat_HPCR_z_triangle( GLcontext *ctx,
-				  const SWvertex *v0,
-				  const SWvertex *v1,
-				  const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE		\
-   GLubyte r = v2->color[0];	\
-   GLubyte g = v2->color[1];	\
-   GLubyte b = v2->color[2];
-#define RENDER_SPAN( span )					\
-   GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   for (i = 0; i < span.count; i++, x++) {			\
-      const DEPTH_TYPE z = FixedToDepth(span.z);		\
-      if (z < zRow[i]) {					\
-	 pRow[i] = (PIXEL_TYPE) DITHER_HPCR(x, y, r, g, b);	\
-         zRow[i] = z;						\
-      }								\
-      span.z += span.zStep;					\
-   }
-
-#include "swrast/s_tritemp.h"
-}
-
-
-/*
- * XImage, flat, depth-buffered, 8-bit PF_LOOKUP triangle.
- */
-static void flat_LOOKUP8_z_triangle( GLcontext *ctx,
-				     const SWvertex *v0,
-				     const SWvertex *v1,
-				     const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE				\
-   LOOKUP_SETUP;				\
-   GLubyte r = v2->color[0];	\
-   GLubyte g = v2->color[1];	\
-   GLubyte b = v2->color[2];	\
-   GLubyte p = LOOKUP(r,g,b);
-#define RENDER_SPAN( span )				\
-   GLuint i;						\
-   for (i = 0; i < span.count; i++) {			\
-      const DEPTH_TYPE z = FixedToDepth(span.z);	\
-      if (z < zRow[i]) {				\
-	 pRow[i] = p;					\
-         zRow[i] = z;					\
-      }							\
-      span.z += span.zStep;				\
-   }
-
+   } }
 #include "swrast/s_tritemp.h"
-}
-
 
 
 /*
  * XImage, smooth, NON-depth-buffered, PF_TRUECOLOR triangle.
  */
-static void smooth_TRUECOLOR_triangle( GLcontext *ctx,
-				       const SWvertex *v0,
-				       const SWvertex *v1,
-				       const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define NAME smooth_TRUECOLOR_triangle
 #define INTERP_RGB 1
-#define RENDER_SPAN( span )					\
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   GET_XRB(xrb);						\
+   XMesaImage *img = xrb->ximage;
+#define RENDER_SPAN( span ) {					\
    GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   for (i = 0; i < span.count; i++, x++) {			\
+   GLint x = span.x, y = YFLIP(xrb, span.y);	\
+   for (i = 0; i < span.end; i++, x++) {			\
       unsigned long p;						\
       PACK_TRUECOLOR(p, FixedToInt(span.red),			\
          FixedToInt(span.green), FixedToInt(span.blue));	\
@@ -833,110 +554,124 @@ static void smooth_TRUECOLOR_triangle( GLcontext *ctx,
       span.red += span.redStep;					\
       span.green += span.greenStep;				\
       span.blue += span.blueStep;				\
-   }
-
+   } }
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
  * XImage, smooth, NON-depth-buffered, PF_8A8B8G8R triangle.
  */
-static void smooth_8A8B8G8R_triangle( GLcontext *ctx,
-				      const SWvertex *v0,
-				      const SWvertex *v1,
-				      const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME smooth_8A8B8G8R_triangle
 #define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define INTERP_ALPHA 1
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
 #define PIXEL_TYPE GLuint
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define RENDER_SPAN( span )					\
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
+#define SETUP_CODE						\
+   GET_XRB(xrb);
+#define RENDER_SPAN( span ) {					\
    GLuint i;							\
-   for (i = 0; i < span.count; i++) {				\
-      pRow[i] = PACK_8B8G8R(FixedToInt(span.red),		\
-         FixedToInt(span.green), FixedToInt(span.blue) );	\
+   for (i = 0; i < span.end; i++) {				\
+      pRow[i] = PACK_8A8B8G8R(FixedToInt(span.red),		\
+         FixedToInt(span.green), FixedToInt(span.blue),		\
+         FixedToInt(span.alpha));				\
       span.red += span.redStep;					\
       span.green += span.greenStep;				\
       span.blue += span.blueStep;				\
-   }								\
+      span.alpha += span.alphaStep;				\
+   } }
+#include "swrast/s_tritemp.h"
+
+
 
+/*
+ * XImage, smooth, NON-depth-buffered, PF_8A8R8G8B triangle.
+ */
+#define NAME smooth_8A8R8G8B_triangle
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
+#define SETUP_CODE						\
+   GET_XRB(xrb);
+#define RENDER_SPAN( span ) {					\
+   GLuint i;							\
+   for (i = 0; i < span.end; i++) {				\
+      pRow[i] = PACK_8A8R8G8B(FixedToInt(span.red),		\
+         FixedToInt(span.green), FixedToInt(span.blue),		\
+         FixedToInt(span.alpha));				\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+      span.alpha += span.alphaStep;				\
+   } }
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
  * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
  */
-static void smooth_8R8G8B_triangle( GLcontext *ctx,
-				    const SWvertex *v0,
-				    const SWvertex *v1,
-				    const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME smooth_8R8G8B_triangle
 #define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
 #define PIXEL_TYPE GLuint
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define RENDER_SPAN( span )					\
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
+#define SETUP_CODE						\
+   GET_XRB(xrb);
+#define RENDER_SPAN( span ) {					\
    GLuint i;							\
-   for (i = 0; i < span.count; i++) {				\
+   for (i = 0; i < span.end; i++) {				\
       pRow[i] = PACK_8R8G8B(FixedToInt(span.red),		\
          FixedToInt(span.green), FixedToInt(span.blue) );	\
       span.red += span.redStep;					\
       span.green += span.greenStep;				\
       span.blue += span.blueStep;				\
-   }
-
+   } }
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
  * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
  */
-static void smooth_8R8G8B24_triangle( GLcontext *ctx,
-				      const SWvertex *v0,
-				      const SWvertex *v1,
-				      const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME smooth_8R8G8B24_triangle
 #define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
 #define PIXEL_TYPE bgr_t
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define RENDER_SPAN( span )				\
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
+#define SETUP_CODE					\
+   GET_XRB(xrb);
+#define RENDER_SPAN( span ) {				\
    GLuint i;						\
    PIXEL_TYPE *pixel = pRow;				\
-   for (i = 0; i < span.count; i++, pixel++) {		\
+   for (i = 0; i < span.end; i++, pixel++) {		\
       pixel->r = FixedToInt(span.red);			\
       pixel->g = FixedToInt(span.green);		\
       pixel->b = FixedToInt(span.blue);			\
       span.red += span.redStep;				\
       span.green += span.greenStep;			\
       span.blue += span.blueStep;			\
-   }
-
+   } }
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
  * XImage, smooth, NON-depth-buffered, PF_TRUEDITHER triangle.
  */
-static void smooth_TRUEDITHER_triangle( GLcontext *ctx,
-					const SWvertex *v0,
-					const SWvertex *v1,
-					const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define NAME smooth_TRUEDITHER_triangle
 #define INTERP_RGB 1
-#define RENDER_SPAN( span )					\
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   GET_XRB(xrb);						\
+   XMesaImage *img = xrb->ximage;
+#define RENDER_SPAN( span ) {					\
    GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   for (i = 0; i < span.count; i++, x++) {			\
+   GLint x = span.x, y = YFLIP(xrb, span.y);	\
+   for (i = 0; i < span.end; i++, x++) {			\
       unsigned long p;						\
       PACK_TRUEDITHER(p, x, y, FixedToInt(span.red),		\
          FixedToInt(span.green), FixedToInt(span.blue));	\
@@ -944,469 +679,228 @@ static void smooth_TRUEDITHER_triangle( GLcontext *ctx,
       span.red += span.redStep;					\
       span.green += span.greenStep;				\
       span.blue += span.blueStep;				\
-   }
-
+   } }
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
  * XImage, smooth, NON-depth-buffered, PF_5R6G5B triangle.
  */
-static void smooth_5R6G5B_triangle( GLcontext *ctx,
-				    const SWvertex *v0,
-				    const SWvertex *v1,
-				    const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME smooth_5R6G5B_triangle
 #define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
 #define PIXEL_TYPE GLushort
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define RENDER_SPAN( span )					\
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
+#define SETUP_CODE						\
+   GET_XRB(xrb);
+#define RENDER_SPAN( span ) {					\
    GLuint i;							\
-   for (i = 0; i < span.count; i++) {				\
+   for (i = 0; i < span.end; i++) {				\
       pRow[i] = (PIXEL_TYPE) PACK_5R6G5B(FixedToInt(span.red),	\
          FixedToInt(span.green), FixedToInt(span.blue));	\
       span.red += span.redStep;					\
       span.green += span.greenStep;				\
       span.blue += span.blueStep;				\
-   }
-
+   } }
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
  * XImage, smooth, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
  */
-static void smooth_DITHER_5R6G5B_triangle( GLcontext *ctx,
-					   const SWvertex *v0,
-					   const SWvertex *v1,
-					   const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME smooth_DITHER_5R6G5B_triangle
 #define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
 #define PIXEL_TYPE GLushort
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define RENDER_SPAN( span )					\
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   GET_XRB(xrb);
+#define RENDER_SPAN( span ) {					\
    GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   for (i = 0; i < span.count; i++, x++) {			\
+   GLint x = span.x, y = YFLIP(xrb, span.y);	\
+   for (i = 0; i < span.end; i++, x++) {			\
       PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red),	\
          FixedToInt(span.green), FixedToInt(span.blue));	\
       span.red += span.redStep;					\
       span.green += span.greenStep;				\
       span.blue += span.blueStep;				\
-   }
-
-#include "swrast/s_tritemp.h"
-}
-
-
-/*
- * XImage, smooth, NON-depth-buffered, 8-bit PF_DITHER triangle.
- */
-static void smooth_DITHER8_triangle( GLcontext *ctx,
-				     const SWvertex *v0,
-				     const SWvertex *v1,
-				     const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define RENDER_SPAN( span )					\
-   GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   XDITHER_SETUP(y);						\
-   for (i = 0; i < span.count; i++, x++) {			\
-      pRow[i] = (PIXEL_TYPE) XDITHER(x, FixedToInt(span.red),	\
-         FixedToInt(span.green), FixedToInt(span.blue) );	\
-      span.red += span.redStep;					\
-      span.green += span.greenStep;				\
-      span.blue += span.blueStep;				\
-   }
-
-#include "swrast/s_tritemp.h"
-}
-
-
-/*
- * XImage, smooth, NON-depth-buffered, PF_DITHER triangle.
- */
-static void smooth_DITHER_triangle( GLcontext *ctx,
-				    const SWvertex *v0,
-				    const SWvertex *v1,
-				    const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-
-#define INTERP_RGB 1
-#define RENDER_SPAN( span )					\
-   GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   XDITHER_SETUP(y);						\
-   for (i = 0; i < span.count; i++, x++) {			\
-      unsigned long p = XDITHER(x, FixedToInt(span.red),	\
-         FixedToInt(span.green), FixedToInt(span.blue) );	\
-      XMesaPutPixel(img, x, y, p);				\
-      span.red += span.redStep;					\
-      span.green += span.greenStep;				\
-      span.blue += span.blueStep;				\
-   }
-
-#include "swrast/s_tritemp.h"
-}
-
-
-/*
- * XImage, smooth, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
- */
-static void smooth_LOOKUP8_triangle( GLcontext *ctx,
-				     const SWvertex *v0,
-				     const SWvertex *v1,
-				     const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define RENDER_SPAN( span )				\
-   GLuint i;						\
-   LOOKUP_SETUP;					\
-   for (i = 0; i < span.count; i++) {			\
-      pRow[i] = LOOKUP(FixedToInt(span.red),		\
-         FixedToInt(span.green), FixedToInt(span.blue));\
-      span.red += span.redStep;				\
-      span.green += span.greenStep;			\
-      span.blue += span.blueStep;			\
-   }
-
+   } }
 #include "swrast/s_tritemp.h"
-}
-
 
 
-/*
- * XImage, smooth, NON-depth-buffered, 8-bit PF_HPCR triangle.
- */
-static void smooth_HPCR_triangle( GLcontext *ctx,
-				  const SWvertex *v0,
-				  const SWvertex *v1,
-				  const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define RENDER_SPAN( span )					\
-   GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   for (i = 0; i < span.count; i++, x++) {			\
-      pRow[i] = DITHER_HPCR(x, y, FixedToInt(span.red),		\
-         FixedToInt(span.green), FixedToInt(span.blue));	\
-      span.red += span.redStep;					\
-      span.green += span.greenStep;				\
-      span.blue += span.blueStep;				\
-   }
-
-#include "swrast/s_tritemp.h"
-}
-
 
 /*
  * XImage, flat, NON-depth-buffered, PF_TRUECOLOR triangle.
  */
-static void flat_TRUECOLOR_triangle( GLcontext *ctx,
-				     const SWvertex *v0,
-				     const SWvertex *v1,
-				     const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define NAME flat_TRUECOLOR_triangle
 #define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   GET_XRB(xrb);						\
+   XMesaImage *img = xrb->ximage;				\
    unsigned long pixel;						\
    PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]);
-
-#define RENDER_SPAN( span )					\
+#define RENDER_SPAN( span ) {					\
    GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   for (i = 0; i < span.count; i++, x++) {			\
+   GLint x = span.x, y = YFLIP(xrb, span.y);	\
+   for (i = 0; i < span.end; i++, x++) {			\
       XMesaPutPixel(img, x, y, pixel);				\
-   }
-
+   } }
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
  * XImage, flat, NON-depth-buffered, PF_8A8B8G8R triangle.
  */
-static void flat_8A8B8G8R_triangle( GLcontext *ctx,
-				    const SWvertex *v0,
-				    const SWvertex *v1,
-				    const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define NAME flat_8A8B8G8R_triangle
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
 #define PIXEL_TYPE GLuint
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 #define SETUP_CODE					\
+   GET_XRB(xrb);					\
    unsigned long p = PACK_8B8G8R( v2->color[0],		\
 		 v2->color[1], v2->color[2] );
-#define RENDER_SPAN( span )			\
-   GLuint i;					\
-   for (i = 0; i < span.count; i++) {		\
-      pRow[i] = (PIXEL_TYPE) p;			\
-   }
+#define RENDER_SPAN( span ) {				\
+   GLuint i;						\
+   for (i = 0; i < span.end; i++) {			\
+      pRow[i] = (PIXEL_TYPE) p;				\
+   } }
+#include "swrast/s_tritemp.h"
+
+
 
+/*
+ * XImage, flat, NON-depth-buffered, PF_8A8R8G8B triangle.
+ */
+#define NAME flat_8A8R8G8B_triangle
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
+#define SETUP_CODE					\
+   GET_XRB(xrb);					\
+   unsigned long p = PACK_8R8G8B( v2->color[0],		\
+		 v2->color[1], v2->color[2] );
+#define RENDER_SPAN( span ) {				\
+   GLuint i;						\
+   for (i = 0; i < span.end; i++) {			\
+      pRow[i] = (PIXEL_TYPE) p;				\
+   } }
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
  * XImage, flat, NON-depth-buffered, PF_8R8G8B triangle.
  */
-static void flat_8R8G8B_triangle( GLcontext *ctx,
-				  const SWvertex *v0,
-				  const SWvertex *v1,
-				  const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define NAME flat_8R8G8B_triangle
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
 #define PIXEL_TYPE GLuint
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE				\
-   unsigned long p = PACK_8R8G8B( v2->color[0],	\
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
+#define SETUP_CODE					\
+   GET_XRB(xrb);					\
+   unsigned long p = PACK_8R8G8B( v2->color[0],		\
 		 v2->color[1], v2->color[2] );
-#define RENDER_SPAN( span )			\
-   GLuint i;					\
-   for (i = 0; i < span.count; i++) {		\
-      pRow[i] = (PIXEL_TYPE) p;			\
-   }
-
+#define RENDER_SPAN( span ) {				\
+   GLuint i;						\
+   for (i = 0; i < span.end; i++) {			\
+      pRow[i] = (PIXEL_TYPE) p;				\
+   } }
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
  * XImage, flat, NON-depth-buffered, PF_8R8G8B24 triangle.
  */
-static void flat_8R8G8B24_triangle( GLcontext *ctx,
-				    const SWvertex *v0,
-				    const SWvertex *v1,
-				    const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = v2->color;
-#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
+#define NAME flat_8R8G8B24_triangle
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
 #define PIXEL_TYPE bgr_t
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define RENDER_SPAN( span )				\
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
+#define SETUP_CODE					\
+   GET_XRB(xrb);					\
+   const GLubyte *color = v2->color;
+#define RENDER_SPAN( span ) {				\
    GLuint i;						\
    PIXEL_TYPE *pixel = pRow;				\
-   for (i = 0; i < span.count; i++, pixel++) {		\
+   for (i = 0; i < span.end; i++, pixel++) {		\
       pixel->r = color[RCOMP];				\
       pixel->g = color[GCOMP];				\
       pixel->b = color[BCOMP];				\
-   }
-
+   } }
 #include "swrast/s_tritemp.h"
-}
+
+
 
 /*
  * XImage, flat, NON-depth-buffered, PF_TRUEDITHER triangle.
  */
-static void flat_TRUEDITHER_triangle( GLcontext *ctx,
-				      const SWvertex *v0,
-				      const SWvertex *v1,
-				      const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-
-#define RENDER_SPAN( span )					\
+#define NAME flat_TRUEDITHER_triangle
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   GET_XRB(xrb);						\
+   XMesaImage *img = xrb->ximage;
+#define RENDER_SPAN( span ) {					\
    GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   for (i = 0; i < span.count; i++, x++) {			\
+   GLint x = span.x, y = YFLIP(xrb, span.y);	\
+   for (i = 0; i < span.end; i++, x++) {			\
       unsigned long p;						\
       PACK_TRUEDITHER(p, x, y, v2->color[0],			\
                v2->color[1], v2->color[2] );			\
       XMesaPutPixel(img, x, y, p);				\
-   }
-
+   } }
 #include "swrast/s_tritemp.h"
-}
 
 
 
 /*
  * XImage, flat, NON-depth-buffered, PF_5R6G5B triangle.
  */
-static void flat_5R6G5B_triangle( GLcontext *ctx,
-				  const SWvertex *v0,
-				  const SWvertex *v1,
-				  const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define NAME flat_5R6G5B_triangle
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
 #define PIXEL_TYPE GLushort
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 #define SETUP_CODE					\
-   unsigned long p = PACK_5R6G5B( v2->color[0],	\
+   GET_XRB(xrb);					\
+   unsigned long p = PACK_5R6G5B( v2->color[0],		\
 		 v2->color[1], v2->color[2] );
-#define RENDER_SPAN( span )			\
-   GLuint i;					\
-   for (i = 0; i < span.count; i++) {		\
-      pRow[i] = (PIXEL_TYPE) p;			\
-   }
-
+#define RENDER_SPAN( span ) {				\
+   GLuint i;						\
+   for (i = 0; i < span.end; i++) {			\
+      pRow[i] = (PIXEL_TYPE) p;				\
+   } }
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
  * XImage, flat, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
  */
-static void flat_DITHER_5R6G5B_triangle( GLcontext *ctx,
-					 const SWvertex *v0,
-					 const SWvertex *v1,
-					 const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = v2->color;
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define NAME flat_DITHER_5R6G5B_triangle
+#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
 #define PIXEL_TYPE GLushort
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define RENDER_SPAN( span )					\
+#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   GET_XRB(xrb);						\
+   const GLubyte *color = v2->color;
+#define RENDER_SPAN( span ) {					\
    GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   for (i = 0; i < span.count; i++, x++) {			\
+   GLint x = span.x, y = YFLIP(xrb, span.y);	\
+   for (i = 0; i < span.end; i++, x++) {			\
       PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP],		\
          color[GCOMP], color[BCOMP]);				\
-   }
-
-#include "swrast/s_tritemp.h"
-}
-
-
-/*
- * XImage, flat, NON-depth-buffered, 8-bit PF_DITHER triangle.
- */
-static void flat_DITHER8_triangle( GLcontext *ctx,
-				   const SWvertex *v0,
-				   const SWvertex *v1,
-				   const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE	\
-   FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
-
-#define RENDER_SPAN( span )					\
-   GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, y));		\
-   for (i = 0; i < span.count; i++, x++) {			\
-      pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x);			\
-   }
-
-#include "swrast/s_tritemp.h"
-}
-
-
-/*
- * XImage, flat, NON-depth-buffered, PF_DITHER triangle.
- */
-static void flat_DITHER_triangle( GLcontext *ctx,
-				  const SWvertex *v0,
-				  const SWvertex *v1,
-				  const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-#define SETUP_CODE	\
-   FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
-
-#define RENDER_SPAN( span )					\
-   GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   FLAT_DITHER_ROW_SETUP(y);					\
-   for (i = 0; i < span.count; i++, x++) {			\
-      unsigned long p = FLAT_DITHER(x);				\
-      XMesaPutPixel(img, x, y, p );				\
-   }
-
-#include "swrast/s_tritemp.h"
-}
-
-
-/*
- * XImage, flat, NON-depth-buffered, 8-bit PF_HPCR triangle.
- */
-static void flat_HPCR_triangle( GLcontext *ctx,
-				const SWvertex *v0,
-				const SWvertex *v1,
-				const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE				\
-   GLubyte r = v2->color[0];	\
-   GLubyte g = v2->color[1];	\
-   GLubyte b = v2->color[2];
-#define RENDER_SPAN( span )				\
-   GLuint i;							\
-   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
-   for (i = 0; i < span.count; i++, x++) {			\
-      pRow[i] = (PIXEL_TYPE) DITHER_HPCR(x, y, r, g, b);	\
-   }
-
+   } }
 #include "swrast/s_tritemp.h"
-}
 
 
-/*
- * XImage, flat, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
- */
-static void flat_LOOKUP8_triangle( GLcontext *ctx,
-				   const SWvertex *v0,
-				   const SWvertex *v1,
-				   const SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE				\
-   LOOKUP_SETUP;				\
-   GLubyte r = v2->color[0];			\
-   GLubyte g = v2->color[1];			\
-   GLubyte b = v2->color[2];			\
-   GLubyte p = LOOKUP(r,g,b);
-#define RENDER_SPAN( span )          		\
-   GLuint i;					\
-   for (i = 0; i < span.count; i++) {		\
-      pRow[i] = (PIXEL_TYPE) p;			\
-   }
 
-#include "swrast/s_tritemp.h"
-}
+#endif /* CHAN_BITS == 8 */
 
 
-#ifdef DEBUG
+#if defined(DEBUG) && CHAN_BITS == 8
 extern void _xmesa_print_triangle_func( swrast_tri_func triFunc );
 void _xmesa_print_triangle_func( swrast_tri_func triFunc )
 {
@@ -1415,6 +909,8 @@ void _xmesa_print_triangle_func( swrast_tri_func triFunc )
       printf("smooth_TRUECOLOR_z_triangle\n");
    else if (triFunc ==smooth_8A8B8G8R_z_triangle)
       printf("smooth_8A8B8G8R_z_triangle\n");
+   else if (triFunc ==smooth_8A8R8G8B_z_triangle)
+      printf("smooth_8A8R8G8B_z_triangle\n");
    else if (triFunc ==smooth_8R8G8B_z_triangle)
       printf("smooth_8R8G8B_z_triangle\n");
    else if (triFunc ==smooth_8R8G8B24_z_triangle)
@@ -1425,16 +921,12 @@ void _xmesa_print_triangle_func( swrast_tri_func triFunc )
       printf("smooth_5R6G5B_z_triangle\n");
    else if (triFunc ==smooth_DITHER_5R6G5B_z_triangle)
       printf("smooth_DITHER_5R6G5B_z_triangle\n");
-   else if (triFunc ==smooth_HPCR_z_triangle)
-      printf("smooth_HPCR_z_triangle\n");
-   else if (triFunc ==smooth_DITHER8_z_triangle)
-      printf("smooth_DITHER8_z_triangle\n");
-   else if (triFunc ==smooth_LOOKUP8_z_triangle)
-      printf("smooth_LOOKUP8_z_triangle\n");
    else if (triFunc ==flat_TRUECOLOR_z_triangle)
       printf("flat_TRUECOLOR_z_triangle\n");
    else if (triFunc ==flat_8A8B8G8R_z_triangle)
       printf("flat_8A8B8G8R_z_triangle\n");
+   else if (triFunc ==flat_8A8R8G8B_z_triangle)
+      printf("flat_8A8R8G8B_z_triangle\n");
    else if (triFunc ==flat_8R8G8B_z_triangle)
       printf("flat_8R8G8B_z_triangle\n");
    else if (triFunc ==flat_8R8G8B24_z_triangle)
@@ -1445,16 +937,12 @@ void _xmesa_print_triangle_func( swrast_tri_func triFunc )
       printf("flat_5R6G5B_z_triangle\n");
    else if (triFunc ==flat_DITHER_5R6G5B_z_triangle)
       printf("flat_DITHER_5R6G5B_z_triangle\n");
-   else if (triFunc ==flat_HPCR_z_triangle)
-      printf("flat_HPCR_z_triangle\n");
-   else if (triFunc ==flat_DITHER8_z_triangle)
-      printf("flat_DITHER8_z_triangle\n");
-   else if (triFunc ==flat_LOOKUP8_z_triangle)
-      printf("flat_LOOKUP8_z_triangle\n");
    else if (triFunc ==smooth_TRUECOLOR_triangle)
       printf("smooth_TRUECOLOR_triangle\n");
    else if (triFunc ==smooth_8A8B8G8R_triangle)
       printf("smooth_8A8B8G8R_triangle\n");
+   else if (triFunc ==smooth_8A8R8G8B_triangle)
+      printf("smooth_8A8R8G8B_triangle\n");
    else if (triFunc ==smooth_8R8G8B_triangle)
       printf("smooth_8R8G8B_triangle\n");
    else if (triFunc ==smooth_8R8G8B24_triangle)
@@ -1465,18 +953,14 @@ void _xmesa_print_triangle_func( swrast_tri_func triFunc )
       printf("smooth_5R6G5B_triangle\n");
    else if (triFunc ==smooth_DITHER_5R6G5B_triangle)
       printf("smooth_DITHER_5R6G5B_triangle\n");
-   else if (triFunc ==smooth_HPCR_triangle)
-      printf("smooth_HPCR_triangle\n");
-   else if (triFunc ==smooth_DITHER8_triangle)
-      printf("smooth_DITHER8_triangle\n");
-   else if (triFunc ==smooth_LOOKUP8_triangle)
-      printf("smooth_LOOKUP8_triangle\n");
    else if (triFunc ==flat_TRUECOLOR_triangle)
       printf("flat_TRUECOLOR_triangle\n");
    else if (triFunc ==flat_TRUEDITHER_triangle)
       printf("flat_TRUEDITHER_triangle\n");
    else if (triFunc ==flat_8A8B8G8R_triangle)
       printf("flat_8A8B8G8R_triangle\n");
+   else if (triFunc ==flat_8A8R8G8B_triangle)
+      printf("flat_8A8R8G8B_triangle\n");
    else if (triFunc ==flat_8R8G8B_triangle)
       printf("flat_8R8G8B_triangle\n");
    else if (triFunc ==flat_8R8G8B24_triangle)
@@ -1485,12 +969,6 @@ void _xmesa_print_triangle_func( swrast_tri_func triFunc )
       printf("flat_5R6G5B_triangle\n");
    else if (triFunc ==flat_DITHER_5R6G5B_triangle)
       printf("flat_DITHER_5R6G5B_triangle\n");
-   else if (triFunc ==flat_HPCR_triangle)
-      printf("flat_HPCR_triangle\n");
-   else if (triFunc ==flat_DITHER8_triangle)
-      printf("flat_DITHER8_triangle\n");
-   else if (triFunc ==flat_LOOKUP8_triangle)
-      printf("flat_LOOKUP8_triangle\n");
    else
       printf("???\n");
 }
@@ -1505,7 +983,6 @@ static const char *triFuncName = NULL;
 #define USE(triFunc)                   \
 do {                                   \
     triFuncName = #triFunc;            \
-    /*printf("%s\n", triFuncName);*/   \
     return triFunc;                    \
 } while (0)
 
@@ -1516,23 +993,41 @@ do {                                   \
 #endif
 
 
-static swrast_tri_func get_triangle_func( GLcontext *ctx )
+/**
+ * Return pointer to line drawing function, or NULL if we should use a
+ * swrast fallback.
+ */
+static swrast_tri_func
+get_triangle_func(struct gl_context *ctx)
 {
+#if CHAN_BITS == 8
    SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   int depth = GET_VISUAL_DEPTH(xmesa->xm_visual);
-
-   (void) kernel1;
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);
+   const struct xmesa_renderbuffer *xrb;
 
 #ifdef DEBUG
    triFuncName = NULL;
 #endif
 
-   if (ctx->RenderMode != GL_RENDER)  return (swrast_tri_func) NULL;
-   if (ctx->Polygon.SmoothFlag)       return (swrast_tri_func) NULL;
-   if (ctx->Texture._ReallyEnabled)   return (swrast_tri_func) NULL;
+   /* trivial fallback tests */
+   if ((ctx->DrawBuffer->_ColorDrawBufferIndexes[0] != BUFFER_BIT_FRONT_LEFT) &&
+       (ctx->DrawBuffer->_ColorDrawBufferIndexes[0] != BUFFER_BIT_BACK_LEFT))
+      return (swrast_tri_func) NULL;
+   if (ctx->RenderMode != GL_RENDER)
+      return (swrast_tri_func) NULL;
+   if (ctx->Polygon.SmoothFlag)
+      return (swrast_tri_func) NULL;
+   if (ctx->Texture._MaxEnabledTexImageUnit != -1)
+      return (swrast_tri_func) NULL;
+   if (swrast->_RasterMask & MULTI_DRAW_BIT)
+      return (swrast_tri_func) NULL;
+   if (ctx->Polygon.CullFlag && 
+       ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)
+      return (swrast_tri_func) NULL;
+
+   xrb = xmesa_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0]);
 
-   if (xmesa->xm_buffer->buffer==XIMAGE) {
+   if (xrb->ximage) {
       if (   ctx->Light.ShadeModel==GL_SMOOTH
           && swrast->_RasterMask==DEPTH_BIT
           && ctx->Depth.Func==GL_LESS
@@ -1540,33 +1035,22 @@ static swrast_tri_func get_triangle_func( GLcontext *ctx )
           && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
           && ctx->Polygon.StippleFlag==GL_FALSE) {
          switch (xmesa->pixelformat) {
-            case PF_TRUECOLOR:
+            case PF_Truecolor:
 	       USE(smooth_TRUECOLOR_z_triangle);
             case PF_8A8B8G8R:
                USE(smooth_8A8B8G8R_z_triangle);
+            case PF_8A8R8G8B:
+               USE(smooth_8A8R8G8B_z_triangle);
             case PF_8R8G8B:
                USE(smooth_8R8G8B_z_triangle);
             case PF_8R8G8B24:
                USE(smooth_8R8G8B24_z_triangle);
-            case PF_TRUEDITHER:
+            case PF_Dither_True:
                USE(smooth_TRUEDITHER_z_triangle);
             case PF_5R6G5B:
                USE(smooth_5R6G5B_z_triangle);
-            case PF_DITHER_5R6G5B:
+            case PF_Dither_5R6G5B:
                USE(smooth_DITHER_5R6G5B_z_triangle);
-            case PF_HPCR:
-	       USE(smooth_HPCR_z_triangle);
-            case PF_DITHER:
-               if (depth == 8)
-                  USE(smooth_DITHER8_z_triangle);
-               else
-                  USE(smooth_DITHER_z_triangle);
-               break;
-            case PF_LOOKUP:
-               if (depth == 8)
-                  USE(smooth_LOOKUP8_z_triangle);
-               else
-                  return (swrast_tri_func) NULL;
             default:
                return (swrast_tri_func) NULL;
          }
@@ -1578,33 +1062,22 @@ static swrast_tri_func get_triangle_func( GLcontext *ctx )
           && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
           && ctx->Polygon.StippleFlag==GL_FALSE) {
          switch (xmesa->pixelformat) {
-            case PF_TRUECOLOR:
+            case PF_Truecolor:
 	       USE(flat_TRUECOLOR_z_triangle);
             case PF_8A8B8G8R:
                USE(flat_8A8B8G8R_z_triangle);
+            case PF_8A8R8G8B:
+               USE(flat_8A8R8G8B_z_triangle);
             case PF_8R8G8B:
                USE(flat_8R8G8B_z_triangle);
             case PF_8R8G8B24:
                USE(flat_8R8G8B24_z_triangle);
-            case PF_TRUEDITHER:
+            case PF_Dither_True:
                USE(flat_TRUEDITHER_z_triangle);
             case PF_5R6G5B:
                USE(flat_5R6G5B_z_triangle);
-            case PF_DITHER_5R6G5B:
+            case PF_Dither_5R6G5B:
                USE(flat_DITHER_5R6G5B_z_triangle);
-            case PF_HPCR:
-	       USE(flat_HPCR_z_triangle);
-            case PF_DITHER:
-               if (depth == 8)
-                  USE(flat_DITHER8_z_triangle);
-               else
-                  USE(flat_DITHER_z_triangle);
-               break;
-            case PF_LOOKUP:
-               if (depth == 8)
-                  USE(flat_LOOKUP8_z_triangle);
-               else
-                  return (swrast_tri_func) NULL;
             default:
                return (swrast_tri_func) NULL;
          }
@@ -1613,33 +1086,22 @@ static swrast_tri_func get_triangle_func( GLcontext *ctx )
           && ctx->Light.ShadeModel==GL_SMOOTH
           && ctx->Polygon.StippleFlag==GL_FALSE) {
          switch (xmesa->pixelformat) {
-            case PF_TRUECOLOR:
+            case PF_Truecolor:
 	       USE(smooth_TRUECOLOR_triangle);
             case PF_8A8B8G8R:
                USE(smooth_8A8B8G8R_triangle);
+            case PF_8A8R8G8B:
+               USE(smooth_8A8R8G8B_triangle);
             case PF_8R8G8B:
                USE(smooth_8R8G8B_triangle);
             case PF_8R8G8B24:
                USE(smooth_8R8G8B24_triangle);
-            case PF_TRUEDITHER:
+            case PF_Dither_True:
                USE(smooth_TRUEDITHER_triangle);
             case PF_5R6G5B:
                USE(smooth_5R6G5B_triangle);
-            case PF_DITHER_5R6G5B:
+            case PF_Dither_5R6G5B:
                USE(smooth_DITHER_5R6G5B_triangle);
-            case PF_HPCR:
-	       USE(smooth_HPCR_triangle);
-            case PF_DITHER:
-               if (depth == 8)
-                  USE(smooth_DITHER8_triangle);
-               else
-                  USE(smooth_DITHER_triangle);
-               break;
-            case PF_LOOKUP:
-               if (depth == 8)
-                  USE(smooth_LOOKUP8_triangle);
-               else
-                  return (swrast_tri_func) NULL;
             default:
                return (swrast_tri_func) NULL;
          }
@@ -1649,44 +1111,30 @@ static swrast_tri_func get_triangle_func( GLcontext *ctx )
           && ctx->Light.ShadeModel==GL_FLAT
           && ctx->Polygon.StippleFlag==GL_FALSE) {
          switch (xmesa->pixelformat) {
-            case PF_TRUECOLOR:
+            case PF_Truecolor:
 	       USE(flat_TRUECOLOR_triangle);
-            case PF_TRUEDITHER:
+            case PF_Dither_True:
 	       USE(flat_TRUEDITHER_triangle);
             case PF_8A8B8G8R:
                USE(flat_8A8B8G8R_triangle);
+            case PF_8A8R8G8B:
+               USE(flat_8A8R8G8B_triangle);
             case PF_8R8G8B:
                USE(flat_8R8G8B_triangle);
             case PF_8R8G8B24:
                USE(flat_8R8G8B24_triangle);
             case PF_5R6G5B:
                USE(flat_5R6G5B_triangle);
-            case PF_DITHER_5R6G5B:
+            case PF_Dither_5R6G5B:
                USE(flat_DITHER_5R6G5B_triangle);
-            case PF_HPCR:
-	       USE(flat_HPCR_triangle);
-            case PF_DITHER:
-               if (depth == 8)
-                  USE(flat_DITHER8_triangle);
-               else
-                  USE(flat_DITHER_triangle);
-               break;
-            case PF_LOOKUP:
-               if (depth == 8)
-                  USE(flat_LOOKUP8_triangle);
-               else
-                  return (swrast_tri_func) NULL;
             default:
                return (swrast_tri_func) NULL;
          }
       }
-
-      return (swrast_tri_func) NULL;
-   }
-   else {
-      /* draw to pixmap */
-      return (swrast_tri_func) NULL;
    }
+#endif /* CHAN_BITS == 8 */
+
+   return (swrast_tri_func) NULL;
 }
 
 
@@ -1694,7 +1142,7 @@ static swrast_tri_func get_triangle_func( GLcontext *ctx )
  * of our internal tri functions, otherwise fall back to the
  * standard swrast functions.
  */
-void xmesa_choose_triangle( GLcontext *ctx )
+void xmesa_choose_triangle( struct gl_context *ctx )
 {
    SWcontext *swrast = SWRAST_CONTEXT(ctx);