From 693f81be4c16bcec4e017e9b3189f518d157d85f Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Thu, 7 Sep 2000 15:40:30 +0000
Subject: newly organized Xlib driver files

---
 src/mesa/drivers/x11/xm_tri.c | 1690 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1690 insertions(+)
 create mode 100644 src/mesa/drivers/x11/xm_tri.c

(limited to 'src/mesa/drivers/x11/xm_tri.c')

diff --git a/src/mesa/drivers/x11/xm_tri.c b/src/mesa/drivers/x11/xm_tri.c
new file mode 100644
index 0000000000..02b186a0b5
--- /dev/null
+++ b/src/mesa/drivers/x11/xm_tri.c
@@ -0,0 +1,1690 @@
+/* $Id: xm_tri.c,v 1.1 2000/09/07 15:40:30 brianp Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.3
+ * 
+ * Copyright (C) 1999  Brian Paul   All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+/*
+ * This file contains "accelerated" triangle functions.  It should be
+ * fairly easy to write new special-purpose triangle functions and hook
+ * them into this module.
+ */
+
+
+#include "glxheader.h"
+#include "depth.h"
+#include "macros.h"
+#include "vb.h"
+#include "types.h"
+#include "xmesaP.h"
+
+
+
+
+/**********************************************************************/
+/***                   Triangle rendering                           ***/
+/**********************************************************************/
+
+
+#if 0
+/*
+ * Render a triangle into a pixmap, any pixel format, flat shaded and
+ * no raster ops.
+ */
+static void flat_pixmap_triangle( GLcontext *ctx,
+				  GLuint v0, GLuint v1, GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   struct vertex_buffer *VB = ctx->VB;
+   XMesaPoint p[3];
+   XMesaGC gc;
+
+   if (0 /*VB->MonoColor*/) {
+      gc = xmesa->xm_buffer->gc1;  /* use current color */
+   }
+   else {
+      unsigned long pixel;
+      if (xmesa->xm_visual->gl_visual->RGBAflag) {
+         pixel = xmesa_color_to_pixel( xmesa,
+                         VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1],
+                         VB->ColorPtr->data[pv][2], VB->ColorPtr->data[pv][3],
+                         xmesa->pixelformat );
+      }
+      else {
+         pixel = VB->IndexPtr->data[pv];
+      }
+      gc = xmesa->xm_buffer->gc2;
+      XMesaSetForeground( xmesa->display, gc, pixel );
+   }
+   p[0].x =                         (GLint) (VB->Win.data[v0][0] + 0.5f);
+   p[0].y = FLIP( xmesa->xm_buffer, (GLint) (VB->Win.data[v0][1] - 0.5f) );
+   p[1].x =                         (GLint) (VB->Win.data[v1][0] + 0.5f);
+   p[1].y = FLIP( xmesa->xm_buffer, (GLint) (VB->Win.data[v1][1] - 0.5f) );
+   p[2].x =                         (GLint) (VB->Win.data[v2][0] + 0.5f);
+   p[2].y = FLIP( xmesa->xm_buffer, (GLint) (VB->Win.data[v2][1] - 0.5f) );
+   XMesaFillPolygon( xmesa->display, xmesa->xm_buffer->buffer, gc,
+		     p, 3, Convex, CoordModeOrigin );
+}
+#endif
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_TRUECOLOR triangle.
+ */
+static void smooth_TRUECOLOR_z_triangle( GLcontext *ctx,
+                                         GLuint v0, GLuint v1, GLuint v2,
+                                         GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   (void) pv;
+#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;						\
+   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;							\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_8A8B8G8R triangle.
+ */
+static void smooth_8A8B8G8R_z_triangle( GLcontext *ctx,
+                                         GLuint v0, GLuint v1, GLuint v2,
+                                         GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   (void) pv;
+#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;						\
+   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;							\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_8R8G8B triangle.
+ */
+static void smooth_8R8G8B_z_triangle( GLcontext *ctx,
+                                         GLuint v0, GLuint v1, GLuint v2,
+                                         GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   (void) pv;
+#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;						\
+   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;							\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_8R8G8B24 triangle.
+ */
+static void smooth_8R8G8B24_z_triangle( GLcontext *ctx,
+                                        GLuint v0, GLuint v1, GLuint v2,
+                                        GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   (void) pv;
+#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;						\
+   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;							\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_TRUEDITHER triangle.
+ */
+static void smooth_TRUEDITHER_z_triangle( GLcontext *ctx,
+                                         GLuint v0, GLuint v1, GLuint v2,
+                                         GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   (void) pv;
+#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;	\
+   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;							\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_5R6G5B triangle.
+ */
+static void smooth_5R6G5B_z_triangle( GLcontext *ctx,
+                                      GLuint v0, GLuint v1, GLuint v2,
+                                      GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   (void) pv;
+#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;						\
+   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;							\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_DITHER_5R6G5B triangle.
+ */
+static void smooth_DITHER_5R6G5B_z_triangle( GLcontext *ctx,
+                                             GLuint v0, GLuint v1, GLuint v2,
+                                             GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   (void) pv;
+#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;						\
+   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;							\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, 8-bit, PF_DITHER8 triangle.
+ */
+static void smooth_DITHER8_z_triangle( GLcontext *ctx,
+                                       GLuint v0, GLuint v1, GLuint v2,
+                                       GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   (void) pv;
+#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);							\
+   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;							\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_DITHER triangle.
+ */
+static void smooth_DITHER_z_triangle( GLcontext *ctx,
+                                       GLuint v0, GLuint v1, GLuint v2,
+                                       GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   (void) pv;
+#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);							\
+   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;							\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, 8-bit PF_LOOKUP triangle.
+ */
+static void smooth_LOOKUP8_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                       GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   (void) pv;
+#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;							\
+   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;							\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+
+/*
+ * XImage, smooth, depth-buffered, 8-bit PF_HPCR triangle.
+ */
+static void smooth_HPCR_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                    GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   (void) pv;
+#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;	\
+   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;							\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_TRUECOLOR triangle.
+ */
+static void flat_TRUECOLOR_z_triangle( GLcontext *ctx,
+                        	       GLuint v0, GLuint v1, GLuint v2,
+                                       GLuint pv )
+{
+   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						\
+   unsigned long pixel;						\
+   PACK_TRUECOLOR(pixel, VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2]);
+
+#define INNER_LOOP( LEFT, RIGHT, Y )					\
+{									\
+   GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT;	\
+   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;							\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_8A8B8G8R triangle.
+ */
+static void flat_8A8B8G8R_z_triangle( GLcontext *ctx, GLuint v0,
+                        	      GLuint v1, GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#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( VB->ColorPtr->data[pv][0],	\
+		 VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y )					\
+{									\
+   GLint i, len = RIGHT-LEFT;						\
+   for (i=0;i<len;i++) {						\
+      GLdepth z = FixedToDepth(ffz);					\
+      if (z < zRow[i]) {						\
+	 pRow[i] = (PIXEL_TYPE) p;					\
+         zRow[i] = z;							\
+      }									\
+      ffz += fdzdx;							\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_8R8G8B triangle.
+ */
+static void flat_8R8G8B_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                    GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#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( VB->ColorPtr->data[pv][0],	\
+		 VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y )			\
+{							\
+   GLint i, len = RIGHT-LEFT;				\
+   for (i=0;i<len;i++) {				\
+      GLdepth z = FixedToDepth(ffz);			\
+      if (z < zRow[i]) {				\
+	 pRow[i] = (PIXEL_TYPE) p;			\
+         zRow[i] = z;					\
+      }							\
+      ffz += fdzdx;					\
+   }							\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_8R8G8B24 triangle.
+ */
+static void flat_8R8G8B24_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                      GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+#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;				\
+   for (i=0;i<len;i++) {				\
+      GLdepth z = FixedToDepth(ffz);			\
+      if (z < zRow[i]) {				\
+	 PIXEL_TYPE *ptr = pRow+i;			\
+         ptr->r = color[RCOMP];				\
+         ptr->g = color[GCOMP];				\
+         ptr->b = color[BCOMP];				\
+         zRow[i] = z;					\
+      }							\
+      ffz += fdzdx;					\
+   }							\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_TRUEDITHER triangle.
+ */
+static void flat_TRUEDITHER_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                    GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+#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;	\
+   for (i=0;i<len;i++,xx++) {						\
+      GLdepth z = FixedToDepth(ffz);					\
+      if (z < zRow[i]) {						\
+         unsigned long p;						\
+         PACK_TRUEDITHER( p, xx, yy, VB->ColorPtr->data[pv][0],		\
+            VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );	\
+         XMesaPutPixel( img, xx, yy, p );				\
+         zRow[i] = z;							\
+      }									\
+      ffz += fdzdx;							\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_5R6G5B triangle.
+ */
+static void flat_5R6G5B_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                    GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#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( VB->ColorPtr->data[pv][0],		\
+            VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y )			\
+{							\
+   GLint i, len = RIGHT-LEFT;				\
+   for (i=0;i<len;i++) {				\
+      DEPTH_TYPE z = FixedToDepth(ffz);			\
+      if (z < zRow[i]) {				\
+	 pRow[i] = (PIXEL_TYPE) p;			\
+         zRow[i] = z;					\
+      }							\
+      ffz += fdzdx;					\
+   }							\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_DITHER_5R6G5B triangle.
+ */
+static void flat_DITHER_5R6G5B_z_triangle( GLcontext *ctx, GLuint v0,
+                                           GLuint v1, GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+#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;					\
+   for (i=0;i<len;i++) {					\
+      DEPTH_TYPE z = FixedToDepth(ffz);				\
+      if (z < zRow[i]) {					\
+	 PACK_TRUEDITHER(pRow[i], LEFT+i, Y, color[RCOMP],	\
+			 color[GCOMP], color[BCOMP]);		\
+         zRow[i] = z;						\
+      }								\
+      ffz += fdzdx;						\
+   }								\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, 8-bit PF_DITHER triangle.
+ */
+static void flat_DITHER8_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                     GLuint v2, GLuint pv )
+{
+   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( VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+
+#define INNER_LOOP( LEFT, RIGHT, Y )				\
+{								\
+   GLint i, xx = LEFT, len = RIGHT-LEFT;			\
+   FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, Y));		\
+   for (i=0;i<len;i++,xx++) {					\
+      GLdepth z = FixedToDepth(ffz);				\
+      if (z < zRow[i]) {					\
+	 pRow[i] = (PIXEL_TYPE) FLAT_DITHER(xx);		\
+         zRow[i] = z;						\
+      }								\
+      ffz += fdzdx;						\
+   }								\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_DITHER triangle.
+ */
+static void flat_DITHER_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                    GLuint v2, GLuint pv )
+{
+   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( VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][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);						\
+   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;							\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, 8-bit PF_HPCR triangle.
+ */
+static void flat_HPCR_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                  GLuint v2, GLuint pv )
+{
+   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 = VB->ColorPtr->data[pv][0];	\
+   GLubyte g = VB->ColorPtr->data[pv][1];	\
+   GLubyte b = VB->ColorPtr->data[pv][2];
+#define INNER_LOOP( LEFT, RIGHT, Y )					\
+{									\
+   GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT;	\
+   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;							\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, 8-bit PF_LOOKUP triangle.
+ */
+static void flat_LOOKUP8_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                        	     GLuint v2, GLuint pv )
+{
+   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 = VB->ColorPtr->data[pv][0];	\
+   GLubyte g = VB->ColorPtr->data[pv][1];	\
+   GLubyte b = VB->ColorPtr->data[pv][2];	\
+   GLubyte p = LOOKUP(r,g,b);
+#define INNER_LOOP( LEFT, RIGHT, Y )			\
+{							\
+   GLint i, len = RIGHT-LEFT;				\
+   for (i=0;i<len;i++) {				\
+      GLdepth z = FixedToDepth(ffz);			\
+      if (z < zRow[i]) {				\
+	 pRow[i] = p;					\
+         zRow[i] = z;					\
+      }							\
+      ffz += fdzdx;					\
+   }							\
+}
+#include "tritemp.h"
+}
+
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_TRUECOLOR triangle.
+ */
+static void smooth_TRUECOLOR_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                       GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   (void) pv;
+#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;			\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_8A8B8G8R triangle.
+ */
+static void smooth_8A8B8G8R_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+				      GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   (void) pv;
+#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;			\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
+ */
+static void smooth_8R8G8B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                    GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   (void) pv;
+#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;			\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
+ */
+static void smooth_8R8G8B24_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                      GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   (void) pv;
+#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++;							\
+   }								\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_TRUEDITHER triangle.
+ */
+static void smooth_TRUEDITHER_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+				    GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   (void) pv;
+#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;			\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_5R6G5B triangle.
+ */
+static void smooth_5R6G5B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+				    GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   (void) pv;
+#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;			\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
+ */
+static void smooth_DITHER_5R6G5B_triangle( GLcontext *ctx, GLuint v0,
+                                           GLuint v1, GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   (void) pv;
+#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;			\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, 8-bit PF_DITHER triangle.
+ */
+static void smooth_DITHER8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+				     GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   (void) pv;
+#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;			\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_DITHER triangle.
+ */
+static void smooth_DITHER_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                    GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   (void) pv;
+#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;			\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
+ */
+static void smooth_LOOKUP8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                     GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   (void) pv;
+#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;			\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, 8-bit PF_HPCR triangle.
+ */
+static void smooth_HPCR_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                  GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   (void) pv;
+#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;			\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_TRUECOLOR triangle.
+ */
+static void flat_TRUECOLOR_triangle( GLcontext *ctx, GLuint v0,
+                                     GLuint v1, GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define SETUP_CODE						\
+   unsigned long pixel;						\
+   PACK_TRUECOLOR(pixel, VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][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 );			\
+   }								\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_8A8B8G8R triangle.
+ */
+static void flat_8A8B8G8R_triangle( GLcontext *ctx, GLuint v0,
+                        	    GLuint v1, GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#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( VB->ColorPtr->data[pv][0],	\
+		 VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y )			\
+{							\
+   GLint xx;						\
+   PIXEL_TYPE *pixel = pRow;				\
+   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {		\
+      *pixel = (PIXEL_TYPE) p;				\
+   }							\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_8R8G8B triangle.
+ */
+static void flat_8R8G8B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                  GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#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( VB->ColorPtr->data[pv][0],	\
+		 VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y )			\
+{							\
+   GLint xx;						\
+   PIXEL_TYPE *pixel = pRow;				\
+   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {		\
+      *pixel = (PIXEL_TYPE) p;				\
+   }							\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_8R8G8B24 triangle.
+ */
+static void flat_8R8G8B24_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                    GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+#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 = color[RCOMP];				\
+      pixel->g = color[GCOMP];				\
+      pixel->b = color[BCOMP];				\
+      pixel++;						\
+   }							\
+}
+#include "tritemp.h"
+}
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_TRUEDITHER triangle.
+ */
+static void flat_TRUEDITHER_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+				      GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   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, VB->ColorPtr->data[pv][0],		\
+               VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );	\
+      XMesaPutPixel( img, xx, yy, p );					\
+   }									\
+}
+#include "tritemp.h"
+}
+
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_5R6G5B triangle.
+ */
+static void flat_5R6G5B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                  GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#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( VB->ColorPtr->data[pv][0],	\
+		 VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y )			\
+{							\
+   GLint xx;						\
+   PIXEL_TYPE *pixel = pRow;				\
+   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {		\
+      *pixel = (PIXEL_TYPE) p;				\
+   }							\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
+ */
+static void flat_DITHER_5R6G5B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                         GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+#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]);	\
+   }							\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, 8-bit PF_DITHER triangle.
+ */
+static void flat_DITHER8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                   GLuint v2, GLuint pv )
+{
+   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( VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][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);		\
+   }							\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_DITHER triangle.
+ */
+static void flat_DITHER_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                  GLuint v2, GLuint pv )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define SETUP_CODE	\
+   FLAT_DITHER_SETUP( VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][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 );			\
+   }							\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, 8-bit PF_HPCR triangle.
+ */
+static void flat_HPCR_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                GLuint v2, GLuint pv )
+{
+   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 = VB->ColorPtr->data[pv][0];	\
+   GLubyte g = VB->ColorPtr->data[pv][1];	\
+   GLubyte b = VB->ColorPtr->data[pv][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 );	\
+   }								\
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
+ */
+static void flat_LOOKUP8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                        	   GLuint v2, GLuint pv )
+{
+   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 = VB->ColorPtr->data[pv][0];		\
+   GLubyte g = VB->ColorPtr->data[pv][1];		\
+   GLubyte b = VB->ColorPtr->data[pv][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;				\
+   }						\
+}
+#include "tritemp.h"
+}
+
+
+
+#if 0
+/*
+ * This function is called if we're about to render triangles into an
+ * X window/pixmap.  It sets the polygon stipple pattern if enabled.
+ */
+static void setup_x_polygon_options( GLcontext *ctx )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   int fill_type;
+
+   if (ctx->Polygon.StippleFlag) {
+      if (xmesa->xm_buffer->stipple_pixmap == 0) {
+         /* Allocate polygon stippling stuff once for this context. */
+         XMesaBuffer b = xmesa->xm_buffer;
+         b->stipple_pixmap = XMesaCreatePixmap( xmesa->display,
+						b->buffer, 32, 32, 1 );
+#ifdef XFree86Server
+	 b->stipple_gc = CreateScratchGC(xmesa->display, 1);
+#else
+         b->stipple_gc = XCreateGC(xmesa->display, b->stipple_pixmap, 0, NULL);
+#endif
+	 XMesaSetFunction(xmesa->display, b->stipple_gc, GXcopy);
+	 XMesaSetForeground(xmesa->display, b->stipple_gc, 1);
+	 XMesaSetBackground(xmesa->display, b->stipple_gc, 0);
+      }
+
+      /*
+       * NOTE: We don't handle the following here!
+       *    GL_UNPACK_SWAP_BYTES
+       *    GL_UNPACK_LSB_FIRST
+       */
+      /* Copy Mesa stipple pattern to an XImage then to Pixmap */
+      {
+         XMesaImage *stipple_ximage;
+         GLuint stipple[32];
+         int i;
+         int shift = xmesa->xm_buffer->height % 32;
+         for (i=0;i<32;i++) {
+            stipple[31-i] = ctx->PolygonStipple[(i+shift) % 32];
+         }
+#ifdef XFree86Server
+         stipple_ximage = XMesaCreateImage(1, 32, 32, (char *)stipple);
+#else
+         stipple_ximage = XCreateImage( xmesa->display,
+                                        xmesa->xm_visual->visinfo->visual,
+                                        1, ZPixmap, 0,
+                                        (char *)stipple,
+                                        32, 32, 8, 0 );
+         stipple_ximage->byte_order = LSBFirst;
+         stipple_ximage->bitmap_bit_order = LSBFirst;
+         stipple_ximage->bitmap_unit = 32;
+#endif
+         XMesaPutImage( xmesa->display,
+			(XMesaDrawable)xmesa->xm_buffer->stipple_pixmap,
+			xmesa->xm_buffer->stipple_gc,
+			stipple_ximage, 0, 0, 0, 0, 32, 32 );
+         stipple_ximage->data = NULL;
+         XMesaDestroyImage( stipple_ximage );
+      }
+
+      XMesaSetStipple( xmesa->display, xmesa->xm_buffer->gc1,
+		       xmesa->xm_buffer->stipple_pixmap );
+      XMesaSetStipple( xmesa->display, xmesa->xm_buffer->gc2,
+		       xmesa->xm_buffer->stipple_pixmap );
+      fill_type = FillStippled;
+   }
+   else {
+      fill_type = FillSolid;
+   }
+
+   XMesaSetFillStyle( xmesa->display, xmesa->xm_buffer->gc1, fill_type );
+   XMesaSetFillStyle( xmesa->display, xmesa->xm_buffer->gc2, fill_type );
+}
+#endif
+
+
+#ifdef DEBUG
+void
+_xmesa_print_triangle_func( triangle_func triFunc )
+{
+   printf("XMesa tri func = ");
+   if (triFunc ==smooth_TRUECOLOR_z_triangle)
+      printf("smooth_TRUECOLOR_z_triangle\n");
+   else if (triFunc ==smooth_8A8B8G8R_z_triangle)
+      printf("smooth_8A8B8G8R_z_triangle\n");
+   else if (triFunc ==smooth_8R8G8B_z_triangle)
+      printf("smooth_8R8G8B_z_triangle\n");
+   else if (triFunc ==smooth_8R8G8B24_z_triangle)
+      printf("smooth_8R8G8B24_z_triangle\n");
+   else if (triFunc ==smooth_TRUEDITHER_z_triangle)
+      printf("smooth_TRUEDITHER_z_triangle\n");
+   else if (triFunc ==smooth_5R6G5B_z_triangle)
+      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_8R8G8B_z_triangle)
+      printf("flat_8R8G8B_z_triangle\n");
+   else if (triFunc ==flat_8R8G8B24_z_triangle)
+      printf("flat_8R8G8B24_z_triangle\n");
+   else if (triFunc ==flat_TRUEDITHER_z_triangle)
+      printf("flat_TRUEDITHER_z_triangle\n");
+   else if (triFunc ==flat_5R6G5B_z_triangle)
+      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_8R8G8B_triangle)
+      printf("smooth_8R8G8B_triangle\n");
+   else if (triFunc ==smooth_8R8G8B24_triangle)
+      printf("smooth_8R8G8B24_triangle\n");
+   else if (triFunc ==smooth_TRUEDITHER_triangle)
+      printf("smooth_TRUEDITHER_triangle\n");
+   else if (triFunc ==smooth_5R6G5B_triangle)
+      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_8R8G8B_triangle)
+      printf("flat_8R8G8B_triangle\n");
+   else if (triFunc ==flat_8R8G8B24_triangle)
+      printf("flat_8R8G8B24_triangle\n");
+   else if (triFunc ==flat_5R6G5B_triangle)
+      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");
+}
+#endif
+
+
+triangle_func xmesa_get_triangle_func( GLcontext *ctx )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   int depth = GET_VISUAL_DEPTH(xmesa->xm_visual);
+
+   (void) kernel1;
+
+   if (ctx->Polygon.SmoothFlag)     return NULL;
+   if (ctx->Texture.Enabled)        return NULL;
+
+   if (xmesa->xm_buffer->buffer==XIMAGE) {
+      if (   ctx->Light.ShadeModel==GL_SMOOTH
+          && ctx->RasterMask==DEPTH_BIT
+          && ctx->Depth.Func==GL_LESS
+          && ctx->Depth.Mask==GL_TRUE
+          && 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_8A8B8G8R:
+               return smooth_8A8B8G8R_z_triangle;
+            case PF_8R8G8B:
+               return smooth_8R8G8B_z_triangle;
+            case PF_8R8G8B24:
+               return smooth_8R8G8B24_z_triangle;
+            case PF_TRUEDITHER:
+               return smooth_TRUEDITHER_z_triangle;
+            case PF_5R6G5B:
+               return smooth_5R6G5B_z_triangle;
+            case PF_DITHER_5R6G5B:
+               return 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 : NULL;
+            default:
+               return NULL;
+         }
+      }
+      if (   ctx->Light.ShadeModel==GL_FLAT
+          && ctx->RasterMask==DEPTH_BIT
+          && ctx->Depth.Func==GL_LESS
+          && ctx->Depth.Mask==GL_TRUE
+          && 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_8A8B8G8R:
+               return flat_8A8B8G8R_z_triangle;
+            case PF_8R8G8B:
+               return flat_8R8G8B_z_triangle;
+            case PF_8R8G8B24:
+               return flat_8R8G8B24_z_triangle;
+            case PF_TRUEDITHER:
+               return flat_TRUEDITHER_z_triangle;
+            case PF_5R6G5B:
+               return flat_5R6G5B_z_triangle;
+            case PF_DITHER_5R6G5B:
+               return 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 : NULL;
+            default:
+               return NULL;
+         }
+      }
+      if (   ctx->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_8A8B8G8R:
+               return smooth_8A8B8G8R_triangle;
+            case PF_8R8G8B:
+               return smooth_8R8G8B_triangle;
+            case PF_8R8G8B24:
+               return smooth_8R8G8B24_triangle;
+            case PF_TRUEDITHER:
+               return smooth_TRUEDITHER_triangle;
+            case PF_5R6G5B:
+               return smooth_5R6G5B_triangle;
+            case PF_DITHER_5R6G5B:
+               return 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 : NULL;
+            default:
+               return NULL;
+         }
+      }
+
+      if (   ctx->RasterMask==0   /* no depth test */
+          && 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_8A8B8G8R:
+               return flat_8A8B8G8R_triangle;
+            case PF_8R8G8B:
+               return flat_8R8G8B_triangle;
+            case PF_8R8G8B24:
+               return flat_8R8G8B24_triangle;
+            case PF_5R6G5B:
+               return flat_5R6G5B_triangle;
+            case PF_DITHER_5R6G5B:
+               return 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 : NULL;
+            default:
+               return NULL;
+         }
+      }
+
+      return NULL;
+   }
+   else {
+      /* draw to pixmap */
+#if 0
+      /* XXX have to disable this because X's rasterization rules
+       * don't match software Mesa's.  This causes a buffer invariance
+       * test failure in the conformance tests.
+       * In the future, we might provide a config option to enable this.
+       */
+      if (ctx->Light.ShadeModel==GL_FLAT && ctx->RasterMask==0) {
+         if (ctx->Color.DitherFlag && depth < 24)
+            return NULL;
+         setup_x_polygon_options( ctx );
+         return flat_pixmap_triangle;
+      }
+#endif
+      return NULL;
+   }
+}
-- 
cgit v1.2.3