X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fdrivers%2Fx11%2Fxm_tri.c;h=8e8b8fc93889a72d395a33b366dd85d455ca204f;hb=57d882b6847128fe5f72575f61a2b2dace7ac46c;hp=a25d58092b8dfb2ed6c957f10018cd36202d327e;hpb=c19d783e0715ac01ad4d3fd0705500d2bf6f7039;p=mesa.git

diff --git a/src/mesa/drivers/x11/xm_tri.c b/src/mesa/drivers/x11/xm_tri.c
index a25d58092b8..8e8b8fc9388 100644
--- a/src/mesa/drivers/x11/xm_tri.c
+++ b/src/mesa/drivers/x11/xm_tri.c
@@ -1,21 +1,20 @@
-/* $Id: xm_tri.c,v 1.9 2000/11/14 17:40:15 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.5
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  5.1
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -35,8 +34,8 @@
 #include "glxheader.h"
 #include "depth.h"
 #include "macros.h"
-#include "vb.h"
-#include "types.h"
+#include "imports.h"
+#include "mtypes.h"
 #include "xmesaP.h"
 
 /* Internal swrast includes:
@@ -47,7 +46,6 @@
 
 
 
-
 /**********************************************************************/
 /***                   Triangle rendering                           ***/
 /**********************************************************************/
@@ -56,1555 +54,1385 @@
 /*
  * XImage, smooth, depth-buffered, PF_TRUECOLOR triangle.
  */
-static void smooth_TRUECOLOR_z_triangle( GLcontext *ctx,
-                                         SWvertex *v0,
-					 SWvertex *v1,
-					 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 INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer, Y);			\
-   GLint len = RIGHT-LEFT;						\
-   (void) fffog; 					        	\
-   for (i=0;i<len;i++,xx++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         unsigned long p;						\
-         PACK_TRUECOLOR(p, FixedToInt(ffr), FixedToInt(ffg), FixedToInt(ffb));\
-         XMesaPutPixel( img, xx, yy, p );				\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+
+#define RENDER_SPAN( span )					\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   GLuint i;							\
+   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);				\
+         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,
-					SWvertex *v0,
-					SWvertex *v1,
-					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 PIXEL_TYPE GLuint
 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, len = RIGHT-LEFT;						\
-   (void) fffog; 					        	\
-   for (i=0;i<len;i++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         pRow[i] = PACK_8B8G8R( FixedToInt(ffr), FixedToInt(ffg),	\
-				 FixedToInt(ffb) );			\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+
+#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] = PACK_8B8G8R(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_8R8G8B triangle.
  */
-static void smooth_8R8G8B_z_triangle( GLcontext *ctx,
-				      SWvertex *v0,
-				      SWvertex *v1,
-				      SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#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) PIXELADDR4(xmesa->xm_buffer,X,Y)
 #define PIXEL_TYPE GLuint
 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, len = RIGHT-LEFT;						\
-   (void) fffog; 					        	\
-   for (i=0;i<len;i++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         pRow[i] = PACK_8R8G8B( FixedToInt(ffr), FixedToInt(ffg),	\
-				 FixedToInt(ffb) );			\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+
+#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] = PACK_8R8G8B(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_8R8G8B24 triangle.
  */
-static void smooth_8R8G8B24_z_triangle( GLcontext *ctx,
-                                        SWvertex *v0,
-					SWvertex *v1,
-					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) PIXELADDR3(xmesa->xm_buffer,X,Y)
 #define PIXEL_TYPE bgr_t
 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, len = RIGHT-LEFT;						\
-   (void) fffog; 					        	\
-   for (i=0;i<len;i++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-	 PIXEL_TYPE *ptr = pRow + i;					\
-         ptr->r = FixedToInt(ffr);					\
-         ptr->g = FixedToInt(ffg);					\
-         ptr->b = FixedToInt(ffb);					\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);
+#define RENDER_SPAN( span ) 					\
+   GLuint i;							\
+   for (i = 0; i < span.end; 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.
  */
-static void smooth_TRUEDITHER_z_triangle( GLcontext *ctx,
-					  SWvertex *v0,
-					  SWvertex *v1,
-					  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 INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT;	\
-   (void) fffog; 					        	\
-   for (i=0;i<len;i++,xx++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         unsigned long p;						\
-         PACK_TRUEDITHER( p, xx, yy, FixedToInt(ffr),			\
-                          FixedToInt(ffg), FixedToInt(ffb) );		\
-         XMesaPutPixel( img, xx, yy, p );				\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   for (i = 0; i < span.end; i++, x++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+         unsigned long p;					\
+         PACK_TRUEDITHER(p, x, y, 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,
-                                      SWvertex *v0,
-				      SWvertex *v1,
-				      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) PIXELADDR2(xmesa->xm_buffer,X,Y)
 #define PIXEL_TYPE GLushort
 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, len = RIGHT-LEFT;						\
-   (void) fffog; 					        	\
-   for (i=0;i<len;i++) {						\
-      DEPTH_TYPE z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         pRow[i] = PACK_5R6G5B( FixedToInt(ffr), FixedToInt(ffg),	\
-				 FixedToInt(ffb) );			\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);
+#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] = 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.
  */
-static void smooth_DITHER_5R6G5B_z_triangle( GLcontext *ctx,
-                                             SWvertex *v0,
-					     SWvertex *v1,
-					     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) PIXELADDR2(xmesa->xm_buffer,X,Y)
 #define PIXEL_TYPE GLushort
 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, len = RIGHT-LEFT;						\
-   (void) fffog; 					        	\
-   for (i=0;i<len;i++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         PACK_TRUEDITHER(pRow[i], LEFT+i, Y, FixedToInt(ffr),		\
-			 FixedToInt(ffg), FixedToInt(ffb) );		\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, 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, 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, 8-bit, PF_DITHER8 triangle.
  */
-static void smooth_DITHER8_z_triangle( GLcontext *ctx,
-                                       SWvertex *v0,
-				       SWvertex *v1,
-				       SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME smooth_DITHER8_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 INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT;	\
-   XDITHER_SETUP(yy);							\
-   (void) fffog; 					        	\
-   for (i=0;i<len;i++,xx++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         pRow[i] = (PIXEL_TYPE) XDITHER( xx, FixedToInt(ffr),		\
-			FixedToInt(ffg), FixedToInt(ffb) );		\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);
+#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.end; 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.
  */
-static void smooth_DITHER_z_triangle( GLcontext *ctx,
-				      SWvertex *v0,
-				      SWvertex *v1,
-				      SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define NAME smooth_DITHER_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 INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT;	\
-   XDITHER_SETUP(yy);							\
-   (void) fffog; 					        	\
-   for (i=0;i<len;i++,xx++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-	 unsigned long p = XDITHER( xx, FixedToInt(ffr),		\
-				 FixedToInt(ffg), FixedToInt(ffb) );	\
-	 XMesaPutPixel( img, xx, yy, p );			       	\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+#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.end; i++, x++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+         unsigned long p = XDITHER(x, 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, 8-bit PF_LOOKUP triangle.
  */
-static void smooth_LOOKUP8_z_triangle( GLcontext *ctx, 
-				       SWvertex *v0,
-				       SWvertex *v1,
-				       SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME smooth_LOOKUP8_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 INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, len = RIGHT-LEFT;						\
-   LOOKUP_SETUP;							\
-   (void) fffog; 					        	\
-   for (i=0;i<len;i++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         pRow[i] = LOOKUP( FixedToInt(ffr), FixedToInt(ffg),		\
-				 FixedToInt(ffb) );			\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   LOOKUP_SETUP;						\
+   for (i = 0; i < span.end; i++) {				\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+         pRow[i] = LOOKUP(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, 8-bit PF_HPCR triangle.
  */
-static void smooth_HPCR_z_triangle( GLcontext *ctx, 
-				    SWvertex *v0,
-				    SWvertex *v1,
-				    SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME smooth_HPCR_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 INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT;	\
-   (void) fffog; 					        	\
-   for (i=0;i<len;i++,xx++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         pRow[i] = DITHER_HPCR( xx, yy, FixedToInt(ffr),		\
-				 FixedToInt(ffg), FixedToInt(ffb) );	\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, 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) );	\
+         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,
-                        	       SWvertex *v0,
-				       SWvertex *v1,
-				       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);			\
+   XMesaImage *img = xmesa->xm_buffer->backimage;		\
    unsigned long pixel;						\
-   PACK_TRUECOLOR(pixel, v0->color[0], v0->color[1], v0->color[2]);
-
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT;	\
-   (void) fffog; 					        	\
-   for (i=0;i<len;i++,xx++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         XMesaPutPixel( img, xx, yy, pixel );				\
-         zRow[i] = z;							\
-      }									\
-      ffz += fdzdx;							\
-   }									\
-}
+   PACK_TRUECOLOR(pixel, 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);	\
+   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, 
-				      SWvertex *v0,
-				      SWvertex *v1,
-				      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_TYPE GLuint
 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
 #define SETUP_CODE					\
-   unsigned long p = PACK_8B8G8R( v0->color[0],	\
-		 v0->color[1], v0->color[2] );
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, len = RIGHT-LEFT;						\
-   (void) fffog; 					        	\
-   for (i=0;i<len;i++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-	 pRow[i] = (PIXEL_TYPE) p;					\
-         zRow[i] = z;							\
-      }									\
-      ffz += fdzdx;							\
-   }									\
-}
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);		\
+   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.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, 
-				    SWvertex *v0,
-				    SWvertex *v1,
-				    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_TYPE GLuint
 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
 #define SETUP_CODE					\
-   unsigned long p = PACK_8R8G8B( v0->color[0],	\
-		 v0->color[1], v0->color[2] );
-#define INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint i, len = RIGHT-LEFT;				\
-   (void) fffog; 					\
-   for (i=0;i<len;i++) {				\
-      GLdepth z = FixedToDepth(ffz);			\
-      if (z < zRow[i]) {				\
-	 pRow[i] = (PIXEL_TYPE) p;			\
-         zRow[i] = z;					\
-      }							\
-      ffz += fdzdx;					\
-   }							\
-}
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);		\
+   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++) {		\
+      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, 
-				      SWvertex *v0,
-				      SWvertex *v1,
-				      SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = v0->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_TYPE bgr_t
 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint i, len = RIGHT-LEFT;				\
-   (void) fffog; 					\
-   for (i=0;i<len;i++) {				\
-      GLdepth z = FixedToDepth(ffz);			\
+#define SETUP_CODE					\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);		\
+   const GLubyte *color = v2->color;
+#define RENDER_SPAN( span )				\
+   GLuint i;						\
+   for (i = 0; i < span.end; i++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);	\
       if (z < zRow[i]) {				\
-	 PIXEL_TYPE *ptr = pRow+i;			\
+	 PIXEL_TYPE *ptr = pRow + i;			\
          ptr->r = color[RCOMP];				\
          ptr->g = color[GCOMP];				\
          ptr->b = color[BCOMP];				\
          zRow[i] = z;					\
       }							\
-      ffz += fdzdx;					\
-   }							\
-}
+      span.z += span.zStep;				\
+   }
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
  * XImage, flat, depth-buffered, PF_TRUEDITHER triangle.
  */
-static void flat_TRUEDITHER_z_triangle( GLcontext *ctx, 
-					SWvertex *v0,
-					SWvertex *v1,
-					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 INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT;	\
-   (void) fffog; 					        	\
-   for (i=0;i<len;i++,xx++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         unsigned long p;						\
-         PACK_TRUEDITHER( p, xx, yy, v0->color[0],		\
-            v0->color[1], v0->color[2] );	\
-         XMesaPutPixel( img, xx, yy, p );				\
-         zRow[i] = z;							\
-      }									\
-      ffz += fdzdx;							\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   for (i = 0; i < span.end; i++, x++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+         unsigned long p;					\
+         PACK_TRUEDITHER(p, x, y, v2->color[0],			\
+            v2->color[1], v2->color[2]);			\
+         XMesaPutPixel(img, x, y, p);				\
+         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, 
-				    SWvertex *v0,
-				    SWvertex *v1,
-				    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_TYPE GLushort
 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE							\
-   unsigned long p = PACK_5R6G5B( v0->color[0],		\
-            v0->color[1], v0->color[2] );
-#define INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint i, len = RIGHT-LEFT;				\
-   (void) fffog; 					        	\
-   for (i=0;i<len;i++) {				\
-      DEPTH_TYPE z = FixedToDepth(ffz);			\
+#define SETUP_CODE					\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);		\
+   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.end; i++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);	\
       if (z < zRow[i]) {				\
 	 pRow[i] = (PIXEL_TYPE) p;			\
          zRow[i] = z;					\
       }							\
-      ffz += fdzdx;					\
-   }							\
-}
+      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, 
-					   SWvertex *v0,
-					   SWvertex *v1,
-					   SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = v0->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_TYPE GLushort
 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )				\
-{								\
-   GLint i, len = RIGHT-LEFT;					\
-   (void) fffog; 					        	\
-   for (i=0;i<len;i++) {					\
-      DEPTH_TYPE z = FixedToDepth(ffz);				\
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   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.end; i++, x++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
       if (z < zRow[i]) {					\
-	 PACK_TRUEDITHER(pRow[i], LEFT+i, Y, color[RCOMP],	\
+	 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP],		\
 			 color[GCOMP], color[BCOMP]);		\
          zRow[i] = z;						\
       }								\
-      ffz += fdzdx;						\
-   }								\
-}
+      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, 
-				     SWvertex *v0,
-				     SWvertex *v1,
-				     SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME flat_DITHER8_z_triangle
 #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( v0->color[0], v0->color[1], v0->color[2] );
-
-#define INNER_LOOP( LEFT, RIGHT, Y )				\
-{								\
-   GLint i, xx = LEFT, len = RIGHT-LEFT;			\
-   FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, Y));		\
-   (void) fffog; 					        	\
-   for (i=0;i<len;i++,xx++) {					\
-      GLdepth z = FixedToDepth(ffz);				\
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   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.end; i++, x++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
       if (z < zRow[i]) {					\
-	 pRow[i] = (PIXEL_TYPE) FLAT_DITHER(xx);		\
+	 pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x);			\
          zRow[i] = z;						\
       }								\
-      ffz += fdzdx;						\
-   }								\
-}
+      span.z += span.zStep;					\
+   }
 #include "swrast/s_tritemp.h"
-}
+
 
 
 /*
  * XImage, flat, depth-buffered, PF_DITHER triangle.
  */
-static void flat_DITHER_z_triangle( GLcontext *ctx, 
-				    SWvertex *v0,
-				    SWvertex *v1,
-				    SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define NAME flat_DITHER_z_triangle
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define SETUP_CODE	\
-   FLAT_DITHER_SETUP( v0->color[0], v0->color[1], v0->color[2] );
-
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT;	\
-   FLAT_DITHER_ROW_SETUP(yy);						\
-   (void) fffog; 					        	\
-   for (i=0;i<len;i++,xx++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         unsigned long p = FLAT_DITHER(xx);				\
-	 XMesaPutPixel( img, xx, yy, p );				\
-         zRow[i] = z;							\
-      }									\
-      ffz += fdzdx;							\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   XMesaImage *img = xmesa->xm_buffer->backimage;		\
+   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.end; 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, 
-				  SWvertex *v0,
-				  SWvertex *v1,
-				  SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME flat_HPCR_z_triangle
 #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 = v0->color[0];	\
-   GLubyte g = v0->color[1];	\
-   GLubyte b = v0->color[2];
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT;	\
-   (void) fffog; 					        	\
-   for (i=0;i<len;i++,xx++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-	 pRow[i] = (PIXEL_TYPE) DITHER_HPCR( xx, yy, r, g, b );		\
-         zRow[i] = z;							\
-      }									\
-      ffz += fdzdx;							\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   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.end; 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, 
-				     SWvertex *v0,
-				     SWvertex *v1,
-				     SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME flat_LOOKUP8_z_triangle
 #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 = v0->color[0];	\
-   GLubyte g = v0->color[1];	\
-   GLubyte b = v0->color[2];	\
+#define SETUP_CODE					\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);		\
+   LOOKUP_SETUP;					\
+   GLubyte r = v2->color[0];				\
+   GLubyte g = v2->color[1];				\
+   GLubyte b = v2->color[2];				\
    GLubyte p = LOOKUP(r,g,b);
-#define INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint i, len = RIGHT-LEFT;				\
-   (void) fffog; 					        	\
-   for (i=0;i<len;i++) {				\
-      GLdepth z = FixedToDepth(ffz);			\
+#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] = p;					\
          zRow[i] = z;					\
       }							\
-      ffz += fdzdx;					\
-   }							\
-}
+      span.z += span.zStep;				\
+   }
 #include "swrast/s_tritemp.h"
-}
 
 
 
 /*
  * XImage, smooth, NON-depth-buffered, PF_TRUECOLOR triangle.
  */
-static void smooth_TRUECOLOR_triangle( GLcontext *ctx, 
-				       SWvertex *v0,
-				       SWvertex *v1,
-				       SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define NAME smooth_TRUECOLOR_triangle
 #define INTERP_RGB 1
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx, yy = FLIP(xmesa->xm_buffer, Y);				\
-   for (xx=LEFT;xx<RIGHT;xx++) {					\
-      unsigned long p;							\
-      PACK_TRUECOLOR(p, FixedToInt(ffr), FixedToInt(ffg), FixedToInt(ffb));\
-      XMesaPutPixel( img, xx, yy, p );					\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, 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));	\
+      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, PF_8A8B8G8R triangle.
  */
-static void smooth_8A8B8G8R_triangle( GLcontext *ctx, 
-				      SWvertex *v0,
-				      SWvertex *v1,
-				      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 PIXEL_TYPE GLuint
 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx;								\
-   PIXEL_TYPE *pixel = pRow;						\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {				\
-      *pixel = PACK_8B8G8R( FixedToInt(ffr), FixedToInt(ffg),		\
-				FixedToInt(ffb) );			\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   for (i = 0; i < span.end; i++) {				\
+      pRow[i] = PACK_8B8G8R(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_8R8G8B_triangle( GLcontext *ctx, 
-				    SWvertex *v0,
-				    SWvertex *v1,
-				    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_TYPE GLuint
 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx;								\
-   PIXEL_TYPE *pixel = pRow;						\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {				\
-      *pixel = PACK_8R8G8B( FixedToInt(ffr), FixedToInt(ffg),		\
-				FixedToInt(ffb) );			\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);
+#define RENDER_SPAN( span )					\
+   GLuint 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, 
-				      SWvertex *v0,
-				      SWvertex *v1,
-				      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_TYPE bgr_t
 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )				\
-{								\
-   GLint xx;							\
-   PIXEL_TYPE *pixel = pRow;					\
-   for (xx=LEFT;xx<RIGHT;xx++) {				\
-      pixel->r = FixedToInt(ffr);				\
-      pixel->g = FixedToInt(ffg);				\
-      pixel->b = FixedToInt(ffb);				\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;		\
-      pixel++;							\
-   }								\
-}
+#define SETUP_CODE					\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);
+#define RENDER_SPAN( span )				\
+   GLuint i;						\
+   PIXEL_TYPE *pixel = pRow;				\
+   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, 
-					SWvertex *v0,
-					SWvertex *v1,
-					SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define NAME smooth_TRUEDITHER_triangle
 #define INTERP_RGB 1
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx, yy = FLIP(xmesa->xm_buffer, Y);				\
-   for (xx=LEFT;xx<RIGHT;xx++) {					\
-      unsigned long p;							\
-      PACK_TRUEDITHER( p, xx, yy, FixedToInt(ffr), FixedToInt(ffg),	\
-				FixedToInt(ffb) );			\
-      XMesaPutPixel( img, xx, yy, p );					\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, 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));	\
+      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, PF_5R6G5B triangle.
  */
-static void smooth_5R6G5B_triangle( GLcontext *ctx, 
-				    SWvertex *v0,
-				    SWvertex *v1,
-				    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_TYPE GLushort
 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx;								\
-   PIXEL_TYPE *pixel = pRow;						\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {				\
-      *pixel = (PIXEL_TYPE) PACK_5R6G5B( FixedToInt(ffr),		\
-				 FixedToInt(ffg), FixedToInt(ffb) );	\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);
+#define RENDER_SPAN( span )					\
+   GLuint 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, 
-					   SWvertex *v0,
-					   SWvertex *v1,
-					   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_TYPE GLushort
 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx;								\
-   PIXEL_TYPE *pixel = pRow;						\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {				\
-      PACK_TRUEDITHER(*pixel, xx, Y, FixedToInt(ffr),			\
-				 FixedToInt(ffg), FixedToInt(ffb) );	\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, 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, 
-				     SWvertex *v0,
-				     SWvertex *v1,
-				     SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME smooth_DITHER8_triangle
 #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 INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx, yy = FLIP(xmesa->xm_buffer, Y);				\
-   PIXEL_TYPE *pixel = pRow;						\
-   XDITHER_SETUP(yy);							\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {				\
-      *pixel = (PIXEL_TYPE) XDITHER( xx, FixedToInt(ffr),		\
-				 FixedToInt(ffg), FixedToInt(ffb) );	\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);
+#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.end; 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, 
-				    SWvertex *v0,
-				    SWvertex *v1,
-				    SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-
+#define NAME smooth_DITHER_triangle
 #define INTERP_RGB 1
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx, yy = FLIP(xmesa->xm_buffer, Y);				\
-   XDITHER_SETUP(yy);							\
-   for (xx=LEFT;xx<RIGHT;xx++) {					\
-      unsigned long p = XDITHER( xx, FixedToInt(ffr),			\
-				FixedToInt(ffg), FixedToInt(ffb) );	\
-      XMesaPutPixel( img, xx, yy, p );					\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+#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.end; 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, 
-				     SWvertex *v0,
-				     SWvertex *v1,
-				     SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-
+#define NAME smooth_LOOKUP8_triangle
 #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 INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx;								\
-   PIXEL_TYPE *pixel = pRow;						\
-   LOOKUP_SETUP;							\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {				\
-      *pixel = LOOKUP( FixedToInt(ffr), FixedToInt(ffg),		\
-			FixedToInt(ffb) );				\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   LOOKUP_SETUP;						\
+   for (i = 0; i < span.end; 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, 
-				  SWvertex *v0,
-				  SWvertex *v1,
-				  SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-
+#define NAME smooth_HPCR_triangle
 #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 INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx, yy = FLIP(xmesa->xm_buffer, Y);				\
-   PIXEL_TYPE *pixel = pRow;						\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {				\
-      *pixel = DITHER_HPCR( xx, yy, FixedToInt(ffr),			\
-				FixedToInt(ffg), FixedToInt(ffb) );	\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-   }									\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   for (i = 0; i < span.end; 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, 
-				     SWvertex *v0,
-				     SWvertex *v1,
-				     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);			\
+   XMesaImage *img = xmesa->xm_buffer->backimage;		\
    unsigned long pixel;						\
-   PACK_TRUECOLOR(pixel, v0->color[0], v0->color[1], v0->color[2]);
-
-#define INNER_LOOP( LEFT, RIGHT, Y )				\
-{								\
-   GLint xx, yy = FLIP(xmesa->xm_buffer, Y);			\
-   for (xx=LEFT;xx<RIGHT;xx++) {				\
-      XMesaPutPixel( img, xx, yy, pixel );			\
-   }								\
-}
+   PACK_TRUECOLOR(pixel, 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);	\
+   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, 
-				    SWvertex *v0,
-				    SWvertex *v1,
-				    SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME flat_8A8B8G8R_triangle
 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
 #define PIXEL_TYPE GLuint
 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
 #define SETUP_CODE					\
-   unsigned long p = PACK_8B8G8R( v0->color[0],	\
-		 v0->color[1], v0->color[2] );
-#define INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint xx;						\
-   PIXEL_TYPE *pixel = pRow;				\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {		\
-      *pixel = (PIXEL_TYPE) p;				\
-   }							\
-}
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);		\
+   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.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, 
-				  SWvertex *v0,
-				  SWvertex *v1,
-				  SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME flat_8R8G8B_triangle
 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,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( v0->color[0],	\
-		 v0->color[1], v0->color[2] );
-#define INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint xx;						\
-   PIXEL_TYPE *pixel = pRow;				\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {		\
-      *pixel = (PIXEL_TYPE) p;				\
-   }							\
-}
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);		\
+   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_8R8G8B24 triangle.
  */
-static void flat_8R8G8B24_triangle( GLcontext *ctx, 
-				    SWvertex *v0,
-				    SWvertex *v1,
-				    SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = v0->color;
+#define NAME flat_8R8G8B24_triangle
 #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 INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint xx;						\
+#define SETUP_CODE					\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);		\
+   const GLubyte *color = v2->color;
+#define RENDER_SPAN( span )				\
+   GLuint i;						\
    PIXEL_TYPE *pixel = pRow;				\
-   for (xx=LEFT;xx<RIGHT;xx++) {			\
+   for (i = 0; i < span.end; i++, pixel++) {		\
       pixel->r = color[RCOMP];				\
       pixel->g = color[GCOMP];				\
       pixel->b = color[BCOMP];				\
-      pixel++;						\
-   }							\
-}
+   }
 #include "swrast/s_tritemp.h"
-}
+
+
 
 /*
  * XImage, flat, NON-depth-buffered, PF_TRUEDITHER triangle.
  */
-static void flat_TRUEDITHER_triangle( GLcontext *ctx, 
-				      SWvertex *v0,
-				      SWvertex *v1,
-				      SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME flat_TRUEDITHER_triangle
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
    XMesaImage *img = xmesa->xm_buffer->backimage;
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx, yy = FLIP(xmesa->xm_buffer, Y);				\
-   for (xx=LEFT;xx<RIGHT;xx++) {					\
-      unsigned long p;							\
-      PACK_TRUEDITHER( p, xx, yy, v0->color[0],		\
-               v0->color[1], v0->color[2] );	\
-      XMesaPutPixel( img, xx, yy, p );					\
-   }									\
-}
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, 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, 
-				  SWvertex *v0,
-				  SWvertex *v1,
-				  SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME flat_5R6G5B_triangle
 #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 SETUP_CODE					\
-   unsigned long p = PACK_5R6G5B( v0->color[0],	\
-		 v0->color[1], v0->color[2] );
-#define INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint xx;						\
-   PIXEL_TYPE *pixel = pRow;				\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {		\
-      *pixel = (PIXEL_TYPE) p;				\
-   }							\
-}
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);		\
+   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.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, 
-					 SWvertex *v0,
-					 SWvertex *v1,
-					 SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = v0->color;
+#define NAME flat_DITHER_5R6G5B_triangle
 #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 INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint xx;						\
-   PIXEL_TYPE *pixel = pRow;				\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {		\
-      PACK_TRUEDITHER(*pixel, xx, Y, color[RCOMP],	\
-                     color[GCOMP], color[BCOMP]);	\
-   }							\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   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.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, 
-				   SWvertex *v0,
-				   SWvertex *v1,
-				   SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME flat_DITHER8_triangle
 #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( v0->color[0], v0->color[1], v0->color[2] );
-
-#define INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint xx;						\
-   PIXEL_TYPE *pixel = pRow;				\
-   FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, Y));	\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {		\
-      *pixel = (PIXEL_TYPE) FLAT_DITHER(xx);		\
-   }							\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   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.end; 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, 
-				  SWvertex *v0,
-				  SWvertex *v1,
-				  SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-#define SETUP_CODE	\
-   FLAT_DITHER_SETUP( v0->color[0], v0->color[1], v0->color[2] );
-
-#define INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint xx, yy = FLIP(xmesa->xm_buffer, Y);		\
-   FLAT_DITHER_ROW_SETUP(yy);				\
-   for (xx=LEFT;xx<RIGHT;xx++) {			\
-      unsigned long p = FLAT_DITHER(xx);		\
-      XMesaPutPixel( img, xx, yy, p );			\
-   }							\
-}
+#define NAME flat_DITHER_triangle
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   XMesaImage *img = xmesa->xm_buffer->backimage;		\
+   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.end; 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, 
-				SWvertex *v0,
-				SWvertex *v1,
-				SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME flat_HPCR_triangle
 #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 = v0->color[0];	\
-   GLubyte g = v0->color[1];	\
-   GLubyte b = v0->color[2];
-#define INNER_LOOP( LEFT, RIGHT, Y )				\
-{								\
-   GLint xx, yy = FLIP(xmesa->xm_buffer, Y);			\
-   PIXEL_TYPE *pixel = pRow;					\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {			\
-      *pixel = (PIXEL_TYPE) DITHER_HPCR( xx, yy, r, g, b );	\
-   }								\
-}
+#define SETUP_CODE						\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
+   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.end; 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, 
-				   SWvertex *v0,
-				   SWvertex *v1,
-				   SWvertex *v2 )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define NAME flat_LOOKUP8_triangle
 #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 = v0->color[0];		\
-   GLubyte g = v0->color[1];		\
-   GLubyte b = v0->color[2];		\
+#define SETUP_CODE					\
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);		\
+   LOOKUP_SETUP;					\
+   GLubyte r = v2->color[0];				\
+   GLubyte g = v2->color[1];				\
+   GLubyte b = v2->color[2];				\
    GLubyte p = LOOKUP(r,g,b);
-#define INNER_LOOP( LEFT, RIGHT, Y )		\
-{						\
-   GLint xx;					\
-   PIXEL_TYPE *pixel = pRow;			\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {	\
-      *pixel = p;				\
-   }						\
-}
+#define RENDER_SPAN( span )         	 		\
+   GLuint i;						\
+   for (i = 0; i < span.end; i++) {			\
+      pRow[i] = (PIXEL_TYPE) p;				\
+   }
 #include "swrast/s_tritemp.h"
-}
+
 
 
 #ifdef DEBUG
-void
-_xmesa_print_triangle_func( swrast_tri_func triFunc )
+extern void _xmesa_print_triangle_func( swrast_tri_func triFunc );
+void _xmesa_print_triangle_func( swrast_tri_func triFunc )
 {
-   printf("XMesa tri func = ");
+   _mesa_printf("XMesa tri func = ");
    if (triFunc ==smooth_TRUECOLOR_z_triangle)
-      printf("smooth_TRUECOLOR_z_triangle\n");
+      _mesa_printf("smooth_TRUECOLOR_z_triangle\n");
    else if (triFunc ==smooth_8A8B8G8R_z_triangle)
-      printf("smooth_8A8B8G8R_z_triangle\n");
+      _mesa_printf("smooth_8A8B8G8R_z_triangle\n");
    else if (triFunc ==smooth_8R8G8B_z_triangle)
-      printf("smooth_8R8G8B_z_triangle\n");
+      _mesa_printf("smooth_8R8G8B_z_triangle\n");
    else if (triFunc ==smooth_8R8G8B24_z_triangle)
-      printf("smooth_8R8G8B24_z_triangle\n");
+      _mesa_printf("smooth_8R8G8B24_z_triangle\n");
    else if (triFunc ==smooth_TRUEDITHER_z_triangle)
-      printf("smooth_TRUEDITHER_z_triangle\n");
+      _mesa_printf("smooth_TRUEDITHER_z_triangle\n");
    else if (triFunc ==smooth_5R6G5B_z_triangle)
-      printf("smooth_5R6G5B_z_triangle\n");
+      _mesa_printf("smooth_5R6G5B_z_triangle\n");
    else if (triFunc ==smooth_DITHER_5R6G5B_z_triangle)
-      printf("smooth_DITHER_5R6G5B_z_triangle\n");
+      _mesa_printf("smooth_DITHER_5R6G5B_z_triangle\n");
    else if (triFunc ==smooth_HPCR_z_triangle)
-      printf("smooth_HPCR_z_triangle\n");
+      _mesa_printf("smooth_HPCR_z_triangle\n");
    else if (triFunc ==smooth_DITHER8_z_triangle)
-      printf("smooth_DITHER8_z_triangle\n");
+      _mesa_printf("smooth_DITHER8_z_triangle\n");
    else if (triFunc ==smooth_LOOKUP8_z_triangle)
-      printf("smooth_LOOKUP8_z_triangle\n");
+      _mesa_printf("smooth_LOOKUP8_z_triangle\n");
    else if (triFunc ==flat_TRUECOLOR_z_triangle)
-      printf("flat_TRUECOLOR_z_triangle\n");
+      _mesa_printf("flat_TRUECOLOR_z_triangle\n");
    else if (triFunc ==flat_8A8B8G8R_z_triangle)
-      printf("flat_8A8B8G8R_z_triangle\n");
+      _mesa_printf("flat_8A8B8G8R_z_triangle\n");
    else if (triFunc ==flat_8R8G8B_z_triangle)
-      printf("flat_8R8G8B_z_triangle\n");
+      _mesa_printf("flat_8R8G8B_z_triangle\n");
    else if (triFunc ==flat_8R8G8B24_z_triangle)
-      printf("flat_8R8G8B24_z_triangle\n");
+      _mesa_printf("flat_8R8G8B24_z_triangle\n");
    else if (triFunc ==flat_TRUEDITHER_z_triangle)
-      printf("flat_TRUEDITHER_z_triangle\n");
+      _mesa_printf("flat_TRUEDITHER_z_triangle\n");
    else if (triFunc ==flat_5R6G5B_z_triangle)
-      printf("flat_5R6G5B_z_triangle\n");
+      _mesa_printf("flat_5R6G5B_z_triangle\n");
    else if (triFunc ==flat_DITHER_5R6G5B_z_triangle)
-      printf("flat_DITHER_5R6G5B_z_triangle\n");
+      _mesa_printf("flat_DITHER_5R6G5B_z_triangle\n");
    else if (triFunc ==flat_HPCR_z_triangle)
-      printf("flat_HPCR_z_triangle\n");
+      _mesa_printf("flat_HPCR_z_triangle\n");
    else if (triFunc ==flat_DITHER8_z_triangle)
-      printf("flat_DITHER8_z_triangle\n");
+      _mesa_printf("flat_DITHER8_z_triangle\n");
    else if (triFunc ==flat_LOOKUP8_z_triangle)
-      printf("flat_LOOKUP8_z_triangle\n");
+      _mesa_printf("flat_LOOKUP8_z_triangle\n");
    else if (triFunc ==smooth_TRUECOLOR_triangle)
-      printf("smooth_TRUECOLOR_triangle\n");
+      _mesa_printf("smooth_TRUECOLOR_triangle\n");
    else if (triFunc ==smooth_8A8B8G8R_triangle)
-      printf("smooth_8A8B8G8R_triangle\n");
+      _mesa_printf("smooth_8A8B8G8R_triangle\n");
    else if (triFunc ==smooth_8R8G8B_triangle)
-      printf("smooth_8R8G8B_triangle\n");
+      _mesa_printf("smooth_8R8G8B_triangle\n");
    else if (triFunc ==smooth_8R8G8B24_triangle)
-      printf("smooth_8R8G8B24_triangle\n");
+      _mesa_printf("smooth_8R8G8B24_triangle\n");
    else if (triFunc ==smooth_TRUEDITHER_triangle)
-      printf("smooth_TRUEDITHER_triangle\n");
+      _mesa_printf("smooth_TRUEDITHER_triangle\n");
    else if (triFunc ==smooth_5R6G5B_triangle)
-      printf("smooth_5R6G5B_triangle\n");
+      _mesa_printf("smooth_5R6G5B_triangle\n");
    else if (triFunc ==smooth_DITHER_5R6G5B_triangle)
-      printf("smooth_DITHER_5R6G5B_triangle\n");
+      _mesa_printf("smooth_DITHER_5R6G5B_triangle\n");
    else if (triFunc ==smooth_HPCR_triangle)
-      printf("smooth_HPCR_triangle\n");
+      _mesa_printf("smooth_HPCR_triangle\n");
    else if (triFunc ==smooth_DITHER8_triangle)
-      printf("smooth_DITHER8_triangle\n");
+      _mesa_printf("smooth_DITHER8_triangle\n");
    else if (triFunc ==smooth_LOOKUP8_triangle)
-      printf("smooth_LOOKUP8_triangle\n");
+      _mesa_printf("smooth_LOOKUP8_triangle\n");
    else if (triFunc ==flat_TRUECOLOR_triangle)
-      printf("flat_TRUECOLOR_triangle\n");
+      _mesa_printf("flat_TRUECOLOR_triangle\n");
    else if (triFunc ==flat_TRUEDITHER_triangle)
-      printf("flat_TRUEDITHER_triangle\n");
+      _mesa_printf("flat_TRUEDITHER_triangle\n");
    else if (triFunc ==flat_8A8B8G8R_triangle)
-      printf("flat_8A8B8G8R_triangle\n");
+      _mesa_printf("flat_8A8B8G8R_triangle\n");
    else if (triFunc ==flat_8R8G8B_triangle)
-      printf("flat_8R8G8B_triangle\n");
+      _mesa_printf("flat_8R8G8B_triangle\n");
    else if (triFunc ==flat_8R8G8B24_triangle)
-      printf("flat_8R8G8B24_triangle\n");
+      _mesa_printf("flat_8R8G8B24_triangle\n");
    else if (triFunc ==flat_5R6G5B_triangle)
-      printf("flat_5R6G5B_triangle\n");
+      _mesa_printf("flat_5R6G5B_triangle\n");
    else if (triFunc ==flat_DITHER_5R6G5B_triangle)
-      printf("flat_DITHER_5R6G5B_triangle\n");
+      _mesa_printf("flat_DITHER_5R6G5B_triangle\n");
    else if (triFunc ==flat_HPCR_triangle)
-      printf("flat_HPCR_triangle\n");
+      _mesa_printf("flat_HPCR_triangle\n");
    else if (triFunc ==flat_DITHER8_triangle)
-      printf("flat_DITHER8_triangle\n");
+      _mesa_printf("flat_DITHER8_triangle\n");
    else if (triFunc ==flat_LOOKUP8_triangle)
-      printf("flat_LOOKUP8_triangle\n");
+      _mesa_printf("flat_LOOKUP8_triangle\n");
    else
-      printf("???\n");
+      _mesa_printf("???\n");
 }
 #endif
 
 
+#ifdef DEBUG
+
+/* record the current triangle function name */
+static const char *triFuncName = NULL;
+
+#define USE(triFunc)                   \
+do {                                   \
+    triFuncName = #triFunc;            \
+    return triFunc;                    \
+} while (0)
+
+#else
+
+#define USE(triFunc)  return triFunc
+
+#endif
+
+
 static swrast_tri_func get_triangle_func( GLcontext *ctx )
 {
    SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaContext xmesa = XMESA_CONTEXT(ctx);
    int depth = GET_VISUAL_DEPTH(xmesa->xm_visual);
 
    (void) kernel1;
 
+#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;
+   if (ctx->Texture._EnabledUnits)    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;
 
    if (xmesa->xm_buffer->buffer==XIMAGE) {
       if (   ctx->Light.ShadeModel==GL_SMOOTH
           && swrast->_RasterMask==DEPTH_BIT
           && ctx->Depth.Func==GL_LESS
           && ctx->Depth.Mask==GL_TRUE
-          && ctx->Visual.DepthBits == DEFAULT_SOFTWARE_DEPTH_BITS
+          && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
           && ctx->Polygon.StippleFlag==GL_FALSE) {
          switch (xmesa->pixelformat) {
-            case PF_TRUECOLOR:
-	       return smooth_TRUECOLOR_z_triangle;
+            case PF_Truecolor:
+	       USE(smooth_TRUECOLOR_z_triangle);
             case PF_8A8B8G8R:
-               return smooth_8A8B8G8R_z_triangle;
+               USE(smooth_8A8B8G8R_z_triangle);
             case PF_8R8G8B:
-               return smooth_8R8G8B_z_triangle;
+               USE(smooth_8R8G8B_z_triangle);
             case PF_8R8G8B24:
-               return smooth_8R8G8B24_z_triangle;
-            case PF_TRUEDITHER:
-               return smooth_TRUEDITHER_z_triangle;
+               USE(smooth_8R8G8B24_z_triangle);
+            case PF_Dither_True:
+               USE(smooth_TRUEDITHER_z_triangle);
             case PF_5R6G5B:
-               return smooth_5R6G5B_z_triangle;
-            case PF_DITHER_5R6G5B:
-               return smooth_DITHER_5R6G5B_z_triangle;
+               USE(smooth_5R6G5B_z_triangle);
+            case PF_Dither_5R6G5B:
+               USE(smooth_DITHER_5R6G5B_z_triangle);
             case PF_HPCR:
-	       return smooth_HPCR_z_triangle;
-            case PF_DITHER:
-               return (depth==8) ? smooth_DITHER8_z_triangle
-                                        : smooth_DITHER_z_triangle;
-            case PF_LOOKUP:
-               return (depth==8) ? smooth_LOOKUP8_z_triangle : (swrast_tri_func)NULL;
+	       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;
+               return (swrast_tri_func) NULL;
          }
       }
       if (   ctx->Light.ShadeModel==GL_FLAT
           && swrast->_RasterMask==DEPTH_BIT
           && ctx->Depth.Func==GL_LESS
           && ctx->Depth.Mask==GL_TRUE
-          && ctx->Visual.DepthBits == DEFAULT_SOFTWARE_DEPTH_BITS
+          && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
           && ctx->Polygon.StippleFlag==GL_FALSE) {
          switch (xmesa->pixelformat) {
-            case PF_TRUECOLOR:
-	       return flat_TRUECOLOR_z_triangle;
+            case PF_Truecolor:
+	       USE(flat_TRUECOLOR_z_triangle);
             case PF_8A8B8G8R:
-               return flat_8A8B8G8R_z_triangle;
+               USE(flat_8A8B8G8R_z_triangle);
             case PF_8R8G8B:
-               return flat_8R8G8B_z_triangle;
+               USE(flat_8R8G8B_z_triangle);
             case PF_8R8G8B24:
-               return flat_8R8G8B24_z_triangle;
-            case PF_TRUEDITHER:
-               return flat_TRUEDITHER_z_triangle;
+               USE(flat_8R8G8B24_z_triangle);
+            case PF_Dither_True:
+               USE(flat_TRUEDITHER_z_triangle);
             case PF_5R6G5B:
-               return flat_5R6G5B_z_triangle;
-            case PF_DITHER_5R6G5B:
-               return flat_DITHER_5R6G5B_z_triangle;
+               USE(flat_5R6G5B_z_triangle);
+            case PF_Dither_5R6G5B:
+               USE(flat_DITHER_5R6G5B_z_triangle);
             case PF_HPCR:
-	       return flat_HPCR_z_triangle;
-            case PF_DITHER:
-               return (depth==8) ? flat_DITHER8_z_triangle
-                                        : flat_DITHER_z_triangle;
-            case PF_LOOKUP:
-               return (depth==8) ? flat_LOOKUP8_z_triangle : (swrast_tri_func)NULL;
+	       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;
+               return (swrast_tri_func) NULL;
          }
       }
       if (   swrast->_RasterMask==0   /* no depth test */
           && ctx->Light.ShadeModel==GL_SMOOTH
           && ctx->Polygon.StippleFlag==GL_FALSE) {
          switch (xmesa->pixelformat) {
-            case PF_TRUECOLOR:
-	       return smooth_TRUECOLOR_triangle;
+            case PF_Truecolor:
+	       USE(smooth_TRUECOLOR_triangle);
             case PF_8A8B8G8R:
-               return smooth_8A8B8G8R_triangle;
+               USE(smooth_8A8B8G8R_triangle);
             case PF_8R8G8B:
-               return smooth_8R8G8B_triangle;
+               USE(smooth_8R8G8B_triangle);
             case PF_8R8G8B24:
-               return smooth_8R8G8B24_triangle;
-            case PF_TRUEDITHER:
-               return smooth_TRUEDITHER_triangle;
+               USE(smooth_8R8G8B24_triangle);
+            case PF_Dither_True:
+               USE(smooth_TRUEDITHER_triangle);
             case PF_5R6G5B:
-               return smooth_5R6G5B_triangle;
-            case PF_DITHER_5R6G5B:
-               return smooth_DITHER_5R6G5B_triangle;
+               USE(smooth_5R6G5B_triangle);
+            case PF_Dither_5R6G5B:
+               USE(smooth_DITHER_5R6G5B_triangle);
             case PF_HPCR:
-	       return smooth_HPCR_triangle;
-            case PF_DITHER:
-               return (depth==8) ? smooth_DITHER8_triangle
-                                        : smooth_DITHER_triangle;
-            case PF_LOOKUP:
-               return (depth==8) ? smooth_LOOKUP8_triangle : (swrast_tri_func)NULL;
+	       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;
+               return (swrast_tri_func) NULL;
          }
       }
 
@@ -1612,33 +1440,39 @@ 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:
-	       return flat_TRUECOLOR_triangle;
-            case PF_TRUEDITHER:
-	       return flat_TRUEDITHER_triangle;
+            case PF_Truecolor:
+	       USE(flat_TRUECOLOR_triangle);
+            case PF_Dither_True:
+	       USE(flat_TRUEDITHER_triangle);
             case PF_8A8B8G8R:
-               return flat_8A8B8G8R_triangle;
+               USE(flat_8A8B8G8R_triangle);
             case PF_8R8G8B:
-               return flat_8R8G8B_triangle;
+               USE(flat_8R8G8B_triangle);
             case PF_8R8G8B24:
-               return flat_8R8G8B24_triangle;
+               USE(flat_8R8G8B24_triangle);
             case PF_5R6G5B:
-               return flat_5R6G5B_triangle;
-            case PF_DITHER_5R6G5B:
-               return flat_DITHER_5R6G5B_triangle;
+               USE(flat_5R6G5B_triangle);
+            case PF_Dither_5R6G5B:
+               USE(flat_DITHER_5R6G5B_triangle);
             case PF_HPCR:
-	       return flat_HPCR_triangle;
-            case PF_DITHER:
-               return (depth==8) ? flat_DITHER8_triangle
-                                        : flat_DITHER_triangle;
-            case PF_LOOKUP:
-               return (depth==8) ? flat_LOOKUP8_triangle : (swrast_tri_func)NULL;
+	       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;
          }
       }
 
-      return (swrast_tri_func)NULL;
+      return (swrast_tri_func) NULL;
    }
    else {
       /* draw to pixmap */
@@ -1649,7 +1483,7 @@ static swrast_tri_func get_triangle_func( GLcontext *ctx )
 
 /* Override for the swrast tri-selection function.  Try to use one
  * of our internal tri functions, otherwise fall back to the
- * standard swrast functions.  
+ * standard swrast functions.
  */
 void xmesa_choose_triangle( GLcontext *ctx )
 {