Lots of GLchan datatype changes.

Added GLvector4us datatype in math/m_vector.[ch]
Added _math_trans_4us() in math/m_translate.[ch]
Choose GLvector4ub, GLvector4us, GLvector4f at compile time based on CHAN_BITS.
Made Driver.ClearColor() and Driver.ClearIndex() optional driver functions.
Changed args to Driver.ClearColor(), updated drivers.
Reordered files in Makefile.X11

47 files changed, 1459 insertions, 1091 deletions

diff --git a/src/mesa/Makefile.X11 b/src/mesa/Makefile.X11
index fbf8d20999d..afcffbb6cc0 100644
--- a/src/mesa/Makefile.X11
+++ b/src/mesa/Makefile.X11
@@ -1,4 +1,4 @@
-# $Id: Makefile.X11,v 1.39 2001/01/08 21:55:59 keithw Exp $
+# $Id: Makefile.X11,v 1.40 2001/01/24 00:04:58 brianp Exp $
 
 # Mesa 3-D graphics library
 # Version:  3.5
@@ -86,6 +86,35 @@ CORE_SOURCES = \
 	X86/common_x86.c \
 	X86/3dnow.c \
 	X86/katmai.c \
+	swrast/s_aaline.c \
+	swrast/s_aatriangle.c \
+	swrast/s_accum.c \
+	swrast/s_alpha.c \
+	swrast/s_alphabuf.c \
+	swrast/s_bitmap.c \
+	swrast/s_blend.c \
+	swrast/s_buffers.c \
+	swrast/s_copypix.c \
+	swrast/s_context.c \
+	swrast/s_depth.c \
+	swrast/s_drawpix.c \
+	swrast/s_feedback.c \
+	swrast/s_fog.c \
+	swrast/s_histogram.c \
+	swrast/s_lines.c \
+	swrast/s_logic.c \
+	swrast/s_masking.c \
+	swrast/s_pb.c \
+	swrast/s_pixeltex.c \
+	swrast/s_points.c \
+	swrast/s_quads.c \
+	swrast/s_readpix.c \
+	swrast/s_scissor.c \
+	swrast/s_span.c \
+	swrast/s_stencil.c \
+	swrast/s_texture.c \
+	swrast/s_triangle.c \
+	swrast/s_zoom.c \
 	swrast_setup/ss_context.c \
 	swrast_setup/ss_triangle.c \
 	swrast_setup/ss_vb.c \
@@ -119,36 +148,7 @@ CORE_SOURCES = \
 	tnl/t_vb_render.c \
 	tnl/t_vb_texgen.c \
 	tnl/t_vb_texmat.c \
-	tnl/t_vb_vertex.c \
-	swrast/s_aaline.c \
-	swrast/s_aatriangle.c \
-	swrast/s_accum.c \
-	swrast/s_alpha.c \
-	swrast/s_alphabuf.c \
-	swrast/s_bitmap.c \
-	swrast/s_blend.c \
-	swrast/s_buffers.c \
-	swrast/s_copypix.c \
-	swrast/s_context.c \
-	swrast/s_depth.c \
-	swrast/s_drawpix.c \
-	swrast/s_feedback.c \
-	swrast/s_fog.c \
-	swrast/s_histogram.c \
-	swrast/s_lines.c \
-	swrast/s_logic.c \
-	swrast/s_masking.c \
-	swrast/s_pb.c \
-	swrast/s_pixeltex.c \
-	swrast/s_points.c \
-	swrast/s_quads.c \
-	swrast/s_readpix.c \
-	swrast/s_scissor.c \
-	swrast/s_span.c \
-	swrast/s_stencil.c \
-	swrast/s_texture.c \
-	swrast/s_triangle.c \
-	swrast/s_zoom.c 
+	tnl/t_vb_vertex.c
 
 
 DRIVER_SOURCES = \
@@ -188,8 +188,8 @@ ASM_SOURCES =
 ADDITIONAL_OBJ = 
 
 OBJECTS = $(ASM_SOURCES:.S=.o) \
-	$(DRIVER_SOURCES:.c=.o) \
 	$(CORE_SOURCES:.c=.o) \
+	$(DRIVER_SOURCES:.c=.o) \
 	$(ADDITIONAL_OBJ)
 
 
diff --git a/src/mesa/array_cache/ac_import.c b/src/mesa/array_cache/ac_import.c
index e6d7651170b..3c665e9d665 100644
--- a/src/mesa/array_cache/ac_import.c
+++ b/src/mesa/array_cache/ac_import.c
@@ -1,4 +1,4 @@
-/* $Id: ac_import.c,v 1.3 2001/01/16 15:25:11 brianp Exp $ */
+/* $Id: ac_import.c,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -33,6 +33,7 @@
 #include "mmath.h"
 #include "mtypes.h"
 
+#include "math/m_translate.h"
 #include "array_cache/ac_context.h"
 #include "math/m_translate.h"
 
@@ -270,20 +271,39 @@ static void import_color( GLcontext *ctx,
 
    /* Limited choices at this stage:
     */
-   ASSERT(type == GL_UNSIGNED_BYTE);
-   ASSERT(stride == 4*sizeof(GLubyte) || stride == 0);
+   /* XXX GLchan: is this right for GLchan? */
+   ASSERT(type == CHAN_TYPE);
+   ASSERT(stride == 4 * sizeof(GLchan) || stride == 0);
 
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
    _math_trans_4ub( to->Ptr,
-		    from->Ptr,
-		    from->StrideB,
-		    from->Type,
-		    from->Size,
-		    ac->start, 
-		    ac->count);
+                    from->Ptr,
+                    from->StrideB,
+                    from->Type,
+                    from->Size,
+                    ac->start, 
+                    ac->count);
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+   _math_trans_4us( to->Ptr,
+                    from->Ptr,
+                    from->StrideB,
+                    from->Type,
+                    from->Size,
+                    ac->start, 
+                    ac->count);
+#elif CHAN_TYPE == GL_FLOAT
+   _math_trans_4f( to->Ptr,
+                   from->Ptr,
+                   from->StrideB,
+                   from->Type,
+                   from->Size,
+                   ac->start, 
+                   ac->count);
+#endif
 
    to->Size = from->Size;
-   to->StrideB = 4 * sizeof(GLubyte);
-   to->Type = GL_UNSIGNED_BYTE;
+   to->StrideB = 4 * sizeof(GLchan);
+   to->Type = CHAN_TYPE;
    ac->Current.Color = to;
    ac->Writeable.Color = GL_TRUE;
 }
@@ -322,19 +342,37 @@ static void import_secondarycolor( GLcontext *ctx,
 
    /* Limited choices at this stage:
     */
-   ASSERT(type == GL_UNSIGNED_BYTE);
-   ASSERT(stride == 4*sizeof(GLubyte) || stride == 0);
+   ASSERT(type == CHAN_TYPE);
+   ASSERT(stride == 4 * sizeof(GLchan) || stride == 0);
 
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
    _math_trans_4ub( to->Ptr,
-		    from->Ptr,
-		    from->StrideB,
-		    from->Type,
-		    from->Size,
-		    ac->start, 
-		    ac->count);
-
-   to->StrideB = 4 * sizeof(GLubyte);
-   to->Type = GL_UNSIGNED_BYTE;
+                    from->Ptr,
+                    from->StrideB,
+                    from->Type,
+                    from->Size,
+                    ac->start, 
+                    ac->count);
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+   _math_trans_4us( to->Ptr,
+                    from->Ptr,
+                    from->StrideB,
+                    from->Type,
+                    from->Size,
+                    ac->start, 
+                    ac->count);
+#elif CHAN_TYPE == GL_FLOAT
+   _math_trans_4f( to->Ptr,
+                   from->Ptr,
+                   from->StrideB,
+                   from->Type,
+                   from->Size,
+                   ac->start, 
+                   ac->count);
+#endif
+
+   to->StrideB = 4 * sizeof(GLchan);
+   to->Type = CHAN_TYPE;
    ac->Current.SecondaryColor = to;
    ac->Writeable.SecondaryColor = GL_TRUE;
 }
diff --git a/src/mesa/drivers/ggi/ggimesa.c b/src/mesa/drivers/ggi/ggimesa.c
index cc22ba32b7e..6bcb2d17cd5 100644
--- a/src/mesa/drivers/ggi/ggimesa.c
+++ b/src/mesa/drivers/ggi/ggimesa.c
@@ -97,17 +97,16 @@ static void gl_ggiSetColor(GLcontext *ctx, GLubyte red, GLubyte green,
 	GGICTX->color = col;
 }
 
-static void gl_ggiSetClearColor(GLcontext *ctx, GLubyte red, GLubyte green,
-				GLubyte blue, GLubyte alpha)
+static void gl_ggiSetClearColor(GLcontext *ctx, const GLchan color[4])
 {
 	ggi_color rgb;
 	ggi_pixel col;
 	
 	GGIMESADPRINT_CORE("gl_ggiSetClearColor() called\n");
 	
-	rgb.r = (uint16)red << SHIFT;
-	rgb.g = (uint16)green << SHIFT;
-	rgb.b = (uint16)blue << SHIFT;
+	rgb.r = (uint16)color[0] << SHIFT;
+	rgb.g = (uint16)color[1] << SHIFT;
+	rgb.b = (uint16)color[2] << SHIFT;
 	col = ggiMapColor(VIS, &rgb);
 	ggiSetGCForeground(VIS, col);
 	GGICTX->clearcolor = col;
diff --git a/src/mesa/drivers/glide/fxdd.c b/src/mesa/drivers/glide/fxdd.c
index fe918a7eac3..d854ba9950f 100644
--- a/src/mesa/drivers/glide/fxdd.c
+++ b/src/mesa/drivers/glide/fxdd.c
@@ -128,22 +128,19 @@ static void fxDDBufferSize(GLcontext *ctx, GLuint *width, GLuint *height)
 
 
 /* Implements glClearColor() */
-static void fxDDClearColor(GLcontext *ctx, GLubyte red, GLubyte green,
-                           GLubyte blue, GLubyte alpha )
+static void fxDDClearColor(GLcontext *ctx, const GLchan color[4])
 {
   fxMesaContext fxMesa=(fxMesaContext)ctx->DriverCtx;
   GLubyte col[4];
 
-
-
-  ASSIGN_4V( col, red, green, blue, 255 );
-
   if (MESA_VERBOSE&VERBOSE_DRIVER) {
-    fprintf(stderr,"fxmesa: fxDDClearColor(%d,%d,%d,%d)\n",red,green,blue,alpha);
+    fprintf(stderr,"fxmesa: fxDDClearColor(%d,%d,%d,%d)\n",
+            color[0], color[1], color[2], color[3]);
   }
 
-  fxMesa->clearC=FXCOLOR4( col );
-  fxMesa->clearA=alpha;
+  ASSIGN_4V( col, color[0], color[1], color[2], 255 );
+  fxMesa->clearC = FXCOLOR4( col );
+  fxMesa->clearA = color[3];
 }
 
 
diff --git a/src/mesa/drivers/osmesa/osmesa.c b/src/mesa/drivers/osmesa/osmesa.c
index a5c58598677..36e306cf6ec 100644
--- a/src/mesa/drivers/osmesa/osmesa.c
+++ b/src/mesa/drivers/osmesa/osmesa.c
@@ -1,10 +1,10 @@
-/* $Id: osmesa.c,v 1.40 2001/01/23 23:39:36 brianp Exp $ */
+/* $Id: osmesa.c,v 1.41 2001/01/24 00:04:58 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
+ * Version:  3.5
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  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"),
@@ -41,6 +41,7 @@
 #include "glheader.h"
 #include "GL/osmesa.h"
 #include "context.h"
+#include "colormac.h"
 #include "depth.h"
 #include "macros.h"
 #include "mem.h"
@@ -75,13 +76,12 @@ struct osmesa_context {
    GLenum format;		/* either GL_RGBA or GL_COLOR_INDEX */
    void *buffer;		/* the image buffer */
    GLint width, height;		/* size of image buffer */
-   GLuint clearpixel;		/* pixel for clearing the color buffer */
    GLint rowlength;		/* number of pixels per row */
    GLint userRowLength;		/* user-specified number of pixels per row */
    GLint rshift, gshift;	/* bit shifts for RGBA formats */
    GLint bshift, ashift;
-   GLint rind, gind, bind;	/* index offsets for RGBA formats */
-   void *rowaddr[MAX_HEIGHT];	/* address of first pixel in each image row */
+   GLint rInd, gInd, bInd, aInd;/* index offsets for RGBA formats */
+   GLchan *rowaddr[MAX_HEIGHT];	/* address of first pixel in each image row */
    GLboolean yup;		/* TRUE  -> Y increases upward */
 				/* FALSE -> Y increases downward */
 };
@@ -132,16 +132,16 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
 {
    OSMesaContext osmesa;
    GLint rshift, gshift, bshift, ashift;
-   GLint rind, gind, bind;
+   GLint rind, gind, bind, aind;
    GLint indexBits, redBits, greenBits, blueBits, alphaBits;
    GLboolean rgbmode;
    GLboolean swalpha;
-   GLuint i4 = 1;
-   GLubyte *i1 = (GLubyte *) &i4;
-   GLint little_endian = *i1;
+   const GLuint i4 = 1;
+   const GLubyte *i1 = (GLubyte *) &i4;
+   const GLint little_endian = *i1;
 
    swalpha = GL_FALSE;
-   rind = gind = bind = 0;
+   rind = gind = bind = aind = 0;
    if (format==OSMESA_COLOR_INDEX) {
       indexBits = 8;
       rshift = gshift = bshift = ashift = 0;
@@ -153,6 +153,10 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
       greenBits = 8;
       blueBits = 8;
       alphaBits = 8;
+      rind = 0;
+      gind = 1;
+      bind = 2;
+      aind = 3;
       if (little_endian) {
          rshift = 0;
          gshift = 8;
@@ -173,6 +177,10 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
       greenBits = 8;
       blueBits = 8;
       alphaBits = 8;
+      rind = 2;
+      gind = 1;
+      bind = 0;
+      aind = 3;
       if (little_endian) {
          ashift = 0;
          rshift = 8;
@@ -193,6 +201,10 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
       greenBits = 8;
       blueBits = 8;
       alphaBits = 8;
+      rind = 1;
+      gind = 2;
+      bind = 3;
+      aind = 0;
       if (little_endian) {
          bshift = 0;
          gshift = 8;
@@ -217,9 +229,9 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
       gshift = 8;
       rshift = 16;
       ashift = 24;
-      bind = 2;
-      gind = 1;
       rind = 0;
+      gind = 1;
+      bind = 2;
       rgbmode = GL_TRUE;
       swalpha = GL_TRUE;
    }
@@ -233,9 +245,9 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
       gshift = 8;
       rshift = 16;
       ashift = 24;
-      bind = 0;
-      gind = 1;
       rind = 2;
+      gind = 1;
+      bind = 0;
       rgbmode = GL_TRUE;
       swalpha = GL_TRUE;
    }
@@ -295,7 +307,6 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
       osmesa->buffer = NULL;
       osmesa->width = 0;
       osmesa->height = 0;
-      osmesa->clearpixel = 0;
       osmesa->userRowLength = 0;
       osmesa->rowlength = 0;
       osmesa->yup = GL_TRUE;
@@ -303,9 +314,10 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
       osmesa->gshift = gshift;
       osmesa->bshift = bshift;
       osmesa->ashift = ashift;
-      osmesa->rind = rind;
-      osmesa->gind = gind;
-      osmesa->bind = bind;
+      osmesa->rInd = rind;
+      osmesa->gInd = gind;
+      osmesa->bInd = bind;
+      osmesa->aInd = aind;
 
 
       /* Initialize the software rasterizer and helper modules.
@@ -349,56 +361,35 @@ void GLAPIENTRY OSMesaDestroyContext( OSMesaContext ctx )
  */
 static void compute_row_addresses( OSMesaContext ctx )
 {
-   GLint i;
+   GLint bytesPerPixel, bytesPerRow, i;
+   GLubyte *origin = (GLubyte *) ctx->buffer;
+
+   if (ctx->format == OSMESA_COLOR_INDEX) {
+      /* CI mode */
+      bytesPerPixel = 1 * sizeof(GLchan);
+   }
+   else if ((ctx->format == OSMESA_RGB) || (ctx->format == OSMESA_BGR)) {
+      /* RGB mode */
+      bytesPerPixel = 3 * sizeof(GLchan);
+   }
+   else {
+      /* RGBA mode */
+      bytesPerPixel = 4 * sizeof(GLchan);
+   }
+
+   bytesPerRow = ctx->rowlength * bytesPerPixel;
 
    if (ctx->yup) {
       /* Y=0 is bottom line of window */
-      if (ctx->format==OSMESA_COLOR_INDEX) {
-         /* 1-byte CI mode */
-         GLubyte *origin = (GLubyte *) ctx->buffer;
-         for (i=0;i<MAX_HEIGHT;i++) {
-            ctx->rowaddr[i] = origin + i * ctx->rowlength;
-         }
-      }
-      else {
-         if ((ctx->format==OSMESA_RGB) || (ctx->format==OSMESA_BGR)) {
-            /* 3-byte RGB mode */
-            GLubyte *origin = (GLubyte *) ctx->buffer;
-            for (i=0;i<MAX_HEIGHT;i++) {
-               ctx->rowaddr[i] = origin + (i * (ctx->rowlength*3));
-            }
-         } else {
-            /* 4-byte RGBA mode */
-            GLuint *origin = (GLuint *) ctx->buffer;
-            for (i=0;i<MAX_HEIGHT;i++) {
-               ctx->rowaddr[i] = origin + i * ctx->rowlength;
-            }
-         }
+      for (i = 0; i < MAX_HEIGHT; i++) {
+         ctx->rowaddr[i] = (GLchan *) ((GLubyte *) origin + i * bytesPerRow);
       }
    }
    else {
       /* Y=0 is top line of window */
-      if (ctx->format==OSMESA_COLOR_INDEX) {
-         /* 1-byte CI mode */
-         GLubyte *origin = (GLubyte *) ctx->buffer;
-         for (i=0;i<MAX_HEIGHT;i++) {
-            ctx->rowaddr[i] = origin + (ctx->height-i-1) * ctx->rowlength;
-         }
-      }
-      else {
-         if ((ctx->format==OSMESA_RGB) || (ctx->format==OSMESA_BGR)) {
-            /* 3-byte RGB mode */
-            GLubyte *origin = (GLubyte *) ctx->buffer;
-            for (i=0;i<MAX_HEIGHT;i++) {
-               ctx->rowaddr[i] = origin + ((ctx->height-i-1) * (ctx->rowlength*3));
-            }
-         } else {
-            /* 4-byte RGBA mode */
-            GLuint *origin = (GLuint *) ctx->buffer;
-            for (i=0;i<MAX_HEIGHT;i++) {
-               ctx->rowaddr[i] = origin + (ctx->height-i-1) * ctx->rowlength;
-            }
-         }
+      for (i = 0; i < MAX_HEIGHT; i++) {
+         GLint j = ctx->height - i - 1;
+         ctx->rowaddr[i] = (GLchan *) ((GLubyte *) origin + j * bytesPerRow);
       }
    }
 }
@@ -435,8 +426,9 @@ GLboolean GLAPIENTRY
 OSMesaMakeCurrent( OSMesaContext ctx, void *buffer, GLenum type,
                    GLsizei width, GLsizei height )
 {
-   if (!ctx || !buffer || type!=GL_UNSIGNED_BYTE
-       || width<1 || height<1 || width>MAX_WIDTH || height>MAX_HEIGHT) {
+   if (!ctx || !buffer || type != CHAN_TYPE ||
+       width < 1 || height < 1 ||
+       width > MAX_WIDTH || height > MAX_HEIGHT) {
       return GL_FALSE;
    }
 
@@ -596,25 +588,39 @@ OSMesaGetColorBuffer( OSMesaContext c, GLint *width,
 /*
  * Useful macros:
  */
-#define PACK_RGBA(R,G,B,A)  (  ((R) << osmesa->rshift) \
-                             | ((G) << osmesa->gshift) \
-                             | ((B) << osmesa->bshift) \
-                             | ((A) << osmesa->ashift) )
 
-#define PACK_RGBA2(R,G,B,A)  (  ((R) << rshift) \
-                              | ((G) << gshift) \
-                              | ((B) << bshift) \
-                              | ((A) << ashift) )
+#define PACK_RGBA(DST, R, G, B, A)	\
+do {					\
+   (DST)[osmesa->rInd] = R;		\
+   (DST)[osmesa->gInd] = G;		\
+   (DST)[osmesa->bInd] = B;		\
+   (DST)[osmesa->aInd] = A;		\
+} while (0)
+
+#define PACK_RGB(DST, R, G, B)  \
+do {				\
+   (DST)[0] = R;		\
+   (DST)[1] = G;		\
+   (DST)[2] = B;		\
+} while (0)
 
-#define UNPACK_RED(P)      (((P) >> osmesa->rshift) & 0xff)
-#define UNPACK_GREEN(P)    (((P) >> osmesa->gshift) & 0xff)
-#define UNPACK_BLUE(P)     (((P) >> osmesa->bshift) & 0xff)
-#define UNPACK_ALPHA(P)    (((P) >> osmesa->ashift) & 0xff)
+#define PACK_BGR(DST, R, G, B)  \
+do {				\
+   (DST)[0] = B;		\
+   (DST)[1] = G;		\
+   (DST)[2] = R;		\
+} while (0)
 
-#define PIXELADDR1(X,Y)  ((GLubyte *) osmesa->rowaddr[Y] + (X))
-#define PIXELADDR3(X,Y)  ((GLubyte *) osmesa->rowaddr[Y] + ((X)*3))
-#define PIXELADDR4(X,Y)  ((GLuint *)  osmesa->rowaddr[Y] + (X))
 
+#define UNPACK_RED(P)      ( ((GLchan *) &(P))[osmesa->rInd] )
+#define UNPACK_GREEN(P)    ( ((GLchan *) &(P))[osmesa->gInd] )
+#define UNPACK_BLUE(P)     ( ((GLchan *) &(P))[osmesa->bInd] )
+#define UNPACK_ALPHA(P)    ( ((GLchan *) &(P))[osmesa->aInd] )
+
+
+#define PIXELADDR1(X,Y)  (osmesa->rowaddr[Y] + (X))
+#define PIXELADDR3(X,Y)  (osmesa->rowaddr[Y] + 3 * (X))
+#define PIXELADDR4(X,Y)  (osmesa->rowaddr[Y] + 4 * (X))
 
 
 
@@ -638,23 +644,6 @@ static void set_read_buffer( GLcontext *ctx, GLframebuffer *buffer, GLenum mode
 }
 
 
-static void clear_index( GLcontext *ctx, GLuint index )
-{
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   osmesa->clearpixel = index;
-}
-
-
-
-static void clear_color( GLcontext *ctx,
-                         GLchan r, GLchan g, GLchan b, GLchan a )
-{
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   osmesa->clearpixel = PACK_RGBA( r, g, b, a );
-}
-
-
-
 static GLbitfield clear( GLcontext *ctx, GLbitfield mask, GLboolean all,
                          GLint x, GLint y, GLint width, GLint height )
 {
@@ -669,65 +658,102 @@ static GLbitfield clear( GLcontext *ctx, GLbitfield mask, GLboolean all,
    ASSERT((mask & (DD_FRONT_RIGHT_BIT | DD_BACK_LEFT_BIT | DD_BACK_RIGHT_BIT)) == 0);
 
    if (mask & DD_FRONT_LEFT_BIT) {
-      if (osmesa->format==OSMESA_COLOR_INDEX) {
+      if (osmesa->format == OSMESA_COLOR_INDEX) {
          if (all) {
             /* Clear whole CI buffer */
-            MEMSET(osmesa->buffer, osmesa->clearpixel,
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
+            MEMSET(osmesa->buffer, ctx->Color.ClearIndex,
                    osmesa->rowlength * osmesa->height);
+#else
+            const GLint n = osmesa->rowlength * osmesa->height;
+            GLchan *buffer = (GLchan *) osmesa->buffer;
+            GLint i;
+            for (i = 0; i < n; i ++) {
+               buffer[i] = ctx->Color.ClearIndex;
+            }
+#endif
          }
          else {
             /* Clear part of CI buffer */
+            const GLchan clearIndex = (GLchan) ctx->Color.ClearIndex;
             GLint i, j;
-            for (i=0;i<height;i++) {
-               GLubyte *ptr1 = PIXELADDR1( x, (y+i) );
-               for (j=0;j<width;j++) {
-                  *ptr1++ = osmesa->clearpixel;
+            for (i = 0; i < height; i++) {
+               GLchan *ptr1 = PIXELADDR1(x, (y + i));
+               for (j = 0; j < width; j++) {
+                  *ptr1++ = clearIndex;
                }
             }
          }
       }
-      else if ((osmesa->format==OSMESA_RGB)||(osmesa->format==OSMESA_BGR)) {
-         GLubyte rval = UNPACK_RED(osmesa->clearpixel);
-         GLubyte gval = UNPACK_GREEN(osmesa->clearpixel);
-         GLubyte bval = UNPACK_BLUE(osmesa->clearpixel);
-         GLint   rind = osmesa->rind;
-         GLint   gind = osmesa->gind;
-         GLint   bind = osmesa->bind;
+      else if (osmesa->format == OSMESA_RGB) {
+         const GLchan r = ctx->Color.ClearColor[0];
+         const GLchan g = ctx->Color.ClearColor[1];
+         const GLchan b = ctx->Color.ClearColor[2];
          if (all) {
-            GLuint  i, n;
-            GLubyte *ptr3 = (GLubyte *) osmesa->buffer;
             /* Clear whole RGB buffer */
-            n = osmesa->rowlength * osmesa->height;
-            for (i=0;i<n;i++) {
-               ptr3[rind] = rval;
-               ptr3[gind] = gval;
-               ptr3[bind] = bval;
+            GLuint n = osmesa->rowlength * osmesa->height;
+            GLchan *ptr3 = (GLchan *) osmesa->buffer;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               PACK_RGB(ptr3, r, g, b);
                ptr3 += 3;
             }
          }
          else {
             /* Clear part of RGB buffer */
             GLint i, j;
-            for (i=0;i<height;i++) {
-               GLubyte *ptr3 = PIXELADDR3( x, (y+i) );
-               for (j=0;j<width;j++) {
-                  ptr3[rind] = rval;
-                  ptr3[gind] = gval;
-                  ptr3[bind] = bval;
+            for (i = 0; i < height; i++) {
+               GLchan *ptr3 = PIXELADDR3(x, (y + i));
+               for (j = 0; j < width; j++) {
+                  PACK_RGB(ptr3, r, g, b);
+                  ptr3 += 3;
+               }
+            }
+         }
+      }
+      else if (osmesa->format == OSMESA_BGR) {
+         const GLchan r = ctx->Color.ClearColor[0];
+         const GLchan g = ctx->Color.ClearColor[1];
+         const GLchan b = ctx->Color.ClearColor[2];
+         if (all) {
+            /* Clear whole RGB buffer */
+            const GLint n = osmesa->rowlength * osmesa->height;
+            GLchan *ptr3 = (GLchan *) osmesa->buffer;
+            GLint i;
+            for (i = 0; i < n; i++) {
+               PACK_BGR(ptr3, r, g, b);
+               ptr3 += 3;
+            }
+         }
+         else {
+            /* Clear part of RGB buffer */
+            GLint i, j;
+            for (i = 0; i < height; i++) {
+               GLchan *ptr3 = PIXELADDR3(x, (y + i));
+               for (j = 0; j < width; j++) {
+                  PACK_BGR(ptr3, r, g, b);
                   ptr3 += 3;
                }
             }
          }
       }
       else {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
+         /* 4-byte pixel value */
+         GLuint clearPixel;
+         GLchan *clr = (GLchan *) &clearPixel;
+         clr[osmesa->rInd] = ctx->Color.ClearColor[0];
+         clr[osmesa->gInd] = ctx->Color.ClearColor[1];
+         clr[osmesa->bInd] = ctx->Color.ClearColor[2];
+         clr[osmesa->aInd] = ctx->Color.ClearColor[3];
          if (all) {
             /* Clear whole RGBA buffer */
-            GLuint i, n, *ptr4;
-            n = osmesa->rowlength * osmesa->height;
-            ptr4 = (GLuint *) osmesa->buffer;
-            if (osmesa->clearpixel) {
-               for (i=0;i<n;i++) {
-                  *ptr4++ = osmesa->clearpixel;
+            const GLuint n = osmesa->rowlength * osmesa->height;
+            GLuint *ptr4 = (GLuint *) osmesa->buffer;
+            GLuint i;
+            if (clearPixel) {
+               for (i = 0; i < n; i++) {
+                  *ptr4++ = clearPixel;
                }
             }
             else {
@@ -737,13 +763,41 @@ static GLbitfield clear( GLcontext *ctx, GLbitfield mask, GLboolean all,
          else {
             /* Clear part of RGBA buffer */
             GLint i, j;
-            for (i=0;i<height;i++) {
-               GLuint *ptr4 = PIXELADDR4( x, (y+i) );
-               for (j=0;j<width;j++) {
-                  *ptr4++ = osmesa->clearpixel;
+            for (i = 0; i < height; i++) {
+               GLuint *ptr4 = (GLuint *) PIXELADDR4(x, (y + i));
+               for (j = 0; j < width; j++) {
+                  *ptr4++ = clearPixel;
+               }
+            }
+         }
+#else
+         const GLchan r = ctx->Color.ClearColor[0];
+         const GLchan g = ctx->Color.ClearColor[1];
+         const GLchan b = ctx->Color.ClearColor[2];
+         const GLchan a = ctx->Color.ClearColor[3];
+         if (all) {
+            /* Clear whole RGBA buffer */
+            const GLuint n = osmesa->rowlength * osmesa->height;
+            GLchan *p = (GLchan *) osmesa->buffer;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               PACK_RGBA(p, r, g, b, a);
+               p += 4;
+            }
+         }
+         else {
+            /* Clear part of RGBA buffer */
+            GLint i, j;
+            for (i = 0; i < height; i++) {
+               GLchan *p = PIXELADDR4(x, (y + i));
+               for (j = 0; j < width; j++) {
+                  PACK_RGBA(p, r, g, b, a);
+                  p += 4;
                }
             }
          }
+
+#endif
       }
    }
    /* have Mesa clear all other buffers */
@@ -765,44 +819,42 @@ static void buffer_size( GLcontext *ctx, GLuint *width, GLuint *height )
 /**********************************************************************/
 
 /* Write RGBA pixels to an RGBA (or permuted) buffer. */
-static void write_rgba_span( const GLcontext *ctx,
-                             GLuint n, GLint x, GLint y,
-                             CONST GLchan rgba[][4], const GLubyte mask[] )
+static void
+write_rgba_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                 CONST GLchan rgba[][4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLuint *ptr4 = PIXELADDR4( x, y );
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR4(x, y);
    GLuint i;
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint ashift = osmesa->ashift;
    if (mask) {
-      for (i=0;i<n;i++,ptr4++) {
+      for (i = 0; i < n; i++, p += 4) {
          if (mask[i]) {
-            *ptr4 = PACK_RGBA2( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
+            PACK_RGBA(p, rgba[i][RCOMP], rgba[i][GCOMP],
+                         rgba[i][BCOMP], rgba[i][ACOMP]);
          }
       }
    }
    else {
-      for (i=0;i<n;i++,ptr4++) {
-         *ptr4 = PACK_RGBA2( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
+      for (i = 0; i < n; i++, p += 4) {
+         PACK_RGBA(p, rgba[i][RCOMP], rgba[i][GCOMP],
+                      rgba[i][BCOMP], rgba[i][ACOMP]);
       }
    }
 }
 
 
 /* Write RGBA pixels to an RGBA buffer.  This is the fastest span-writer. */
-static void write_rgba_span_rgba( const GLcontext *ctx,
-                                  GLuint n, GLint x, GLint y,
-                                  CONST GLchan rgba[][4],
-                                  const GLubyte mask[] )
+static void
+write_rgba_span_rgba( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                      CONST GLchan rgba[][4], const GLubyte mask[] )
 {
    OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLuint *ptr4 = PIXELADDR4( x, y );
+   GLuint *ptr4 = (GLuint *) PIXELADDR4(x, y);
    const GLuint *rgba4 = (const GLuint *) rgba;
    GLuint i;
+   ASSERT(CHAN_TYPE == GL_UNSIGNED_BYTE);
    if (mask) {
-      for (i=0;i<n;i++) {
+      for (i = 0; i < n; i++) {
          if (mask[i]) {
             ptr4[i] = rgba4[i];
          }
@@ -815,130 +867,120 @@ static void write_rgba_span_rgba( const GLcontext *ctx,
 
 
 /* Write RGB pixels to an RGBA (or permuted) buffer. */
-static void write_rgb_span( const GLcontext *ctx,
-                            GLuint n, GLint x, GLint y,
-                            CONST GLchan rgb[][3], const GLubyte mask[] )
+static void
+write_rgb_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                CONST GLchan rgb[][3], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLuint *ptr4 = PIXELADDR4( x, y );
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR4(x, y);
    GLuint i;
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint ashift = osmesa->ashift;
    if (mask) {
-      for (i=0;i<n;i++,ptr4++) {
+      for (i = 0; i < n; i++, p+=4) {
          if (mask[i]) {
-            *ptr4 = PACK_RGBA2( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], 255 );
+            PACK_RGBA(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], 255);
          }
       }
    }
    else {
-      for (i=0;i<n;i++,ptr4++) {
-         *ptr4 = PACK_RGBA2( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], 255);
+      for (i = 0; i < n; i++, p+=4) {
+         PACK_RGBA(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], 255);
       }
    }
 }
 
 
 
-static void write_monocolor_span( const GLcontext *ctx,
-                                  GLuint n, GLint x, GLint y,
-				  const GLchan color[4], const GLubyte mask[] )
+static void
+write_monocolor_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                      const GLchan color[4], const GLubyte mask[] )
 {
    const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   const GLuint pixel = PACK_RGBA(color[RCOMP], color[GCOMP],
-                                  color[BCOMP], color[ACOMP]);
-   GLuint *ptr4 = PIXELADDR4(x,y);
+   GLchan *p = PIXELADDR4(x, y);
    GLuint i;
-   for (i=0;i<n;i++,ptr4++) {
+   for (i = 0; i < n; i++, p += 4) {
       if (mask[i]) {
-         *ptr4 = pixel;
+         PACK_RGBA(p, color[RCOMP], color[GCOMP], color[BCOMP], color[ACOMP]);
       }
    }
 }
 
 
 
-static void write_rgba_pixels( const GLcontext *ctx,
-                               GLuint n, const GLint x[], const GLint y[],
-                               CONST GLchan rgba[][4], const GLubyte mask[] )
+static void
+write_rgba_pixels( const GLcontext *ctx, GLuint n,
+                   const GLint x[], const GLint y[],
+                   CONST GLchan rgba[][4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint ashift = osmesa->ashift;
-   for (i=0;i<n;i++) {
+   for (i = 0; i < n; i++) {
       if (mask[i]) {
-         GLuint *ptr4 = PIXELADDR4(x[i],y[i]);
-         *ptr4 = PACK_RGBA2( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
+         GLchan *p = PIXELADDR4(x[i], y[i]);
+         PACK_RGBA(p, rgba[i][RCOMP], rgba[i][GCOMP],
+                      rgba[i][BCOMP], rgba[i][ACOMP]);
       }
    }
 }
 
 
 
-static void write_monocolor_pixels( const GLcontext *ctx,
-                                    GLuint n, const GLint x[], const GLint y[],
-				    const GLchan color[4],
-                                    const GLubyte mask[] )
+static void
+write_monocolor_pixels( const GLcontext *ctx, GLuint n,
+                        const GLint x[], const GLint y[],
+                        const GLchan color[4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   const GLuint pixel = PACK_RGBA(color[RCOMP], color[GCOMP],
-                                  color[BCOMP], color[ACOMP]);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
-   for (i=0;i<n;i++) {
+   for (i = 0; i < n; i++) {
       if (mask[i]) {
-         GLuint *ptr4 = PIXELADDR4(x[i],y[i]);
-         *ptr4 = pixel;
+         GLchan *p = PIXELADDR4(x[i], y[i]);
+         PACK_RGBA(p, color[RCOMP], color[GCOMP], color[BCOMP], color[ACOMP]);
       }
    }
 }
 
 
-static void read_rgba_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
-                             GLchan rgba[][4] )
+static void
+read_rgba_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                GLchan rgba[][4] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
-   GLuint *ptr4 = PIXELADDR4(x,y);
-   for (i=0;i<n;i++) {
-      GLuint pixel = *ptr4++;
-      rgba[i][RCOMP] = UNPACK_RED(pixel);
-      rgba[i][GCOMP] = UNPACK_GREEN(pixel);
-      rgba[i][BCOMP] = UNPACK_BLUE(pixel);
-      rgba[i][ACOMP] = UNPACK_ALPHA(pixel);
+   GLchan *p = PIXELADDR4(x, y);
+   for (i = 0; i < n; i++, p += 4) {
+      rgba[i][RCOMP] = UNPACK_RED(p);
+      rgba[i][GCOMP] = UNPACK_GREEN(p);
+      rgba[i][BCOMP] = UNPACK_BLUE(p);
+      rgba[i][ACOMP] = UNPACK_ALPHA(p);
    }
 }
 
 
 /* Read RGBA pixels from an RGBA buffer */
-static void read_rgba_span_rgba( const GLcontext *ctx,
-                                 GLuint n, GLint x, GLint y,
-                                 GLchan rgba[][4] )
+static void
+read_rgba_span_rgba( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                     GLchan rgba[][4] )
 {
    OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLuint *ptr4 = PIXELADDR4(x,y);
+   GLuint *ptr4 = (GLuint *) PIXELADDR4(x, y);
    MEMCPY( rgba, ptr4, n * 4 * sizeof(GLchan) );
 }
 
 
-static void read_rgba_pixels( const GLcontext *ctx,
-                               GLuint n, const GLint x[], const GLint y[],
-			       GLchan rgba[][4], const GLubyte mask[] )
+static void
+read_rgba_pixels( const GLcontext *ctx,
+                  GLuint n, const GLint x[], const GLint y[],
+                  GLchan rgba[][4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
-   for (i=0;i<n;i++) {
+   for (i = 0; i < n; i++) {
       if (mask[i]) {
-         GLuint *ptr4 = PIXELADDR4(x[i],y[i]);
-         GLuint pixel = *ptr4;
-         rgba[i][RCOMP] = UNPACK_RED(pixel);
-         rgba[i][GCOMP] = UNPACK_GREEN(pixel);
-         rgba[i][BCOMP] = UNPACK_BLUE(pixel);
-         rgba[i][ACOMP] = UNPACK_ALPHA(pixel);
+         const GLchan *p = PIXELADDR4(x[i], y[i]);
+         rgba[i][RCOMP] = UNPACK_RED(p);
+         rgba[i][GCOMP] = UNPACK_GREEN(p);
+         rgba[i][BCOMP] = UNPACK_BLUE(p);
+         rgba[i][ACOMP] = UNPACK_ALPHA(p);
       }
    }
 }
@@ -947,164 +989,212 @@ static void read_rgba_pixels( const GLcontext *ctx,
 /*****                3 byte RGB pixel support funcs              *****/
 /**********************************************************************/
 
-/* Write RGBA pixels to an RGB or BGR buffer. */
-static void write_rgba_span3( const GLcontext *ctx,
-                              GLuint n, GLint x, GLint y,
-                              CONST GLchan rgba[][4], const GLubyte mask[] )
+/* Write RGBA pixels to an RGB buffer. */
+static void
+write_rgba_span_RGB( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                     CONST GLchan rgba[][4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLubyte *ptr3 = PIXELADDR3( x, y);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR3(x, y);
    GLuint i;
-   GLint rind = osmesa->rind;
-   GLint gind = osmesa->gind;
-   GLint bind = osmesa->bind;
    if (mask) {
-      for (i=0;i<n;i++,ptr3+=3) {
+      for (i = 0; i < n; i++, p += 3) {
          if (mask[i]) {
-            ptr3[rind] = rgba[i][RCOMP];
-            ptr3[gind] = rgba[i][GCOMP];
-            ptr3[bind] = rgba[i][BCOMP];
+            PACK_RGB(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
          }
       }
    }
    else {
-      for (i=0;i<n;i++,ptr3+=3) {
-         ptr3[rind] = rgba[i][RCOMP];
-         ptr3[gind] = rgba[i][GCOMP];
-         ptr3[bind] = rgba[i][BCOMP];
+      for (i = 0; i < n; i++, p += 3) {
+         PACK_RGB(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
       }
    }
 }
 
-/* Write RGB pixels to an RGB or BGR buffer. */
-static void write_rgb_span3( const GLcontext *ctx,
-                             GLuint n, GLint x, GLint y,
-                             CONST GLchan rgb[][3], const GLubyte mask[] )
+/* Write RGBA pixels to an BGR buffer. */
+static void
+write_rgba_span_BGR( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                     CONST GLchan rgba[][4], const GLubyte mask[] )
 {
    const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   const GLint rind = osmesa->rind;
-   const GLint gind = osmesa->gind;
-   const GLint bind = osmesa->bind;
-   GLubyte *ptr3 = PIXELADDR3( x, y);
+   GLchan *p = PIXELADDR3(x, y);
    GLuint i;
    if (mask) {
-      for (i=0;i<n;i++,ptr3+=3) {
+      for (i = 0; i < n; i++, p += 3) {
          if (mask[i]) {
-            ptr3[rind] = rgb[i][RCOMP];
-            ptr3[gind] = rgb[i][GCOMP];
-            ptr3[bind] = rgb[i][BCOMP];
+            PACK_BGR(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
          }
       }
    }
    else {
-      for (i=0;i<n;i++,ptr3+=3) {
-         ptr3[rind] = rgb[i][RCOMP];
-         ptr3[gind] = rgb[i][GCOMP];
-         ptr3[bind] = rgb[i][BCOMP];
+      for (i = 0; i < n; i++, p += 3) {
+         PACK_BGR(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
       }
    }
 }
 
+/* Write RGB pixels to an RGB buffer. */
+static void
+write_rgb_span_RGB( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                    CONST GLchan rgb[][3], const GLubyte mask[] )
+{
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR3(x, y);
+   GLuint i;
+   if (mask) {
+      for (i = 0; i < n; i++, p += 3) {
+         if (mask[i]) {
+            PACK_RGB(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+         }
+      }
+   }
+   else {
+      for (i = 0; i < n; i++, p += 3) {
+         PACK_RGB(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+      }
+   }
+}
 
-static void write_monocolor_span3( const GLcontext *ctx,
-                                   GLuint n, GLint x, GLint y,
-                                   const GLchan color[4], const GLubyte mask[] )
+/* Write RGB pixels to an BGR buffer. */
+static void
+write_rgb_span_BGR( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                    CONST GLchan rgb[][3], const GLubyte mask[] )
 {
    const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   const GLubyte rval = color[RCOMP];
-   const GLubyte gval = color[GCOMP];
-   const GLubyte bval = color[BCOMP];
-   const GLint   rind = osmesa->rind;
-   const GLint   gind = osmesa->gind;
-   const GLint   bind = osmesa->bind;
-   GLubyte *ptr3 = PIXELADDR3( x, y);
+   GLchan *p = PIXELADDR3(x, y);
    GLuint i;
-   for (i=0;i<n;i++,ptr3+=3) {
+   if (mask) {
+      for (i = 0; i < n; i++, p += 3) {
+         if (mask[i]) {
+            PACK_BGR(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+         }
+      }
+   }
+   else {
+      for (i = 0; i < n; i++, p += 3) {
+         PACK_BGR(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+      }
+   }
+}
+
+
+static void
+write_monocolor_span_RGB( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                          const GLchan color[4], const GLubyte mask[] )
+{
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR3(x, y);
+   GLuint i;
+   for (i = 0; i < n; i++, p += 3) {
+      if (mask[i]) {
+         PACK_RGB(p, color[RCOMP], color[GCOMP], color[BCOMP]);
+      }
+   }
+}
+
+static void
+write_monocolor_span_BGR( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                          const GLchan color[4], const GLubyte mask[] )
+{
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR3(x, y);
+   GLuint i;
+   for (i = 0; i < n; i++, p += 3) {
       if (mask[i]) {
-         ptr3[rind] = rval;
-         ptr3[gind] = gval;
-         ptr3[bind] = bval;
+         PACK_BGR(p, color[RCOMP], color[GCOMP], color[BCOMP]);
       }
    }
 }
 
-static void write_rgba_pixels3( const GLcontext *ctx,
-                                GLuint n, const GLint x[], const GLint y[],
-                                CONST GLchan rgba[][4], const GLubyte mask[] )
+static void
+write_rgba_pixels_RGB( const GLcontext *ctx, GLuint n,
+                       const GLint x[], const GLint y[],
+                       CONST GLchan rgba[][4], const GLubyte mask[] )
 {
    const OSMesaContext osmesa = (const OSMesaContext) ctx;
    GLuint i;
-   GLint rind = osmesa->rind;
-   GLint gind = osmesa->gind;
-   GLint bind = osmesa->bind;
-   for (i=0;i<n;i++) {
+   for (i = 0; i < n; i++) {
+      if (mask[i]) {
+         GLchan *p = PIXELADDR3(x[i], y[i]);
+         PACK_RGB(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+      }
+   }
+}
+
+static void
+write_rgba_pixels_BGR( const GLcontext *ctx, GLuint n,
+                       const GLint x[], const GLint y[],
+                       CONST GLchan rgba[][4], const GLubyte mask[] )
+{
+   const OSMesaContext osmesa = (const OSMesaContext) ctx;
+   GLuint i;
+   for (i = 0; i < n; i++) {
       if (mask[i]) {
-         GLubyte *ptr3 = PIXELADDR3(x[i],y[i]);
-         ptr3[rind] = rgba[i][RCOMP];
-         ptr3[gind] = rgba[i][GCOMP];
-         ptr3[bind] = rgba[i][BCOMP];
+         GLchan *p = PIXELADDR3(x[i], y[i]);
+         PACK_BGR(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
       }
    }
 }
 
-static void write_monocolor_pixels3( const GLcontext *ctx,
-                                     GLuint n, const GLint x[],
-                                     const GLint y[],
-                                     const GLchan color[4],
-                                     const GLubyte mask[] )
+static void
+write_monocolor_pixels_RGB( const GLcontext *ctx,
+                            GLuint n, const GLint x[], const GLint y[],
+                            const GLchan color[4], const GLubyte mask[] )
 {
    const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   const GLint rind = osmesa->rind;
-   const GLint gind = osmesa->gind;
-   const GLint bind = osmesa->bind;
-   const GLubyte rval = color[RCOMP];
-   const GLubyte gval = color[GCOMP];
-   const GLubyte bval = color[BCOMP];
    GLuint i;
-   for (i=0;i<n;i++) {
+   for (i = 0; i < n; i++) {
       if (mask[i]) {
-         GLubyte *ptr3 = PIXELADDR3(x[i],y[i]);
-         ptr3[rind] = rval;
-         ptr3[gind] = gval;
-         ptr3[bind] = bval;
+         GLchan *p = PIXELADDR3(x[i], y[i]);
+         PACK_RGB(p, color[RCOMP], color[GCOMP], color[BCOMP]);
       }
    }
 }
 
-static void read_rgba_span3( const GLcontext *ctx,
-                             GLuint n, GLint x, GLint y,
-                             GLchan rgba[][4] )
+static void
+write_monocolor_pixels_BGR( const GLcontext *ctx,
+                            GLuint n, const GLint x[], const GLint y[],
+                            const GLchan color[4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLuint i;
+   for (i = 0; i < n; i++) {
+      if (mask[i]) {
+         GLchan *p = PIXELADDR3(x[i], y[i]);
+         PACK_BGR(p, color[RCOMP], color[GCOMP], color[BCOMP]);
+      }
+   }
+}
+
+static void
+read_rgba_span3( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                 GLchan rgba[][4] )
+{
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
-   GLint rind = osmesa->rind;
-   GLint gind = osmesa->gind;
-   GLint bind = osmesa->bind;
-   const GLubyte *ptr3 = PIXELADDR3( x, y);
-   for (i=0;i<n;i++,ptr3+=3) {
-      rgba[i][RCOMP] = ptr3[rind];
-      rgba[i][GCOMP] = ptr3[gind];
-      rgba[i][BCOMP] = ptr3[bind];
-      rgba[i][ACOMP] = 0;
+   const GLchan *p = PIXELADDR3(x, y);
+   for (i = 0; i < n; i++, p += 3) {
+      rgba[i][RCOMP] = UNPACK_RED(p);
+      rgba[i][GCOMP] = UNPACK_GREEN(p);
+      rgba[i][BCOMP] = UNPACK_BLUE(p);
+      rgba[i][ACOMP] = 255;
    }
 }
 
-static void read_rgba_pixels3( const GLcontext *ctx,
-                               GLuint n, const GLint x[], const GLint y[],
-			       GLchan rgba[][4], const GLubyte mask[] )
+static void
+read_rgba_pixels3( const GLcontext *ctx,
+                   GLuint n, const GLint x[], const GLint y[],
+                   GLchan rgba[][4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
-   GLint rind = osmesa->rind;
-   GLint gind = osmesa->gind;
-   GLint bind = osmesa->bind;
-   for (i=0;i<n;i++) {
+   for (i = 0; i < n; i++) {
       if (mask[i]) {
-         const GLubyte *ptr3 = PIXELADDR3(x[i],y[i]);
-         rgba[i][RCOMP] = ptr3[rind];
-         rgba[i][GCOMP] = ptr3[gind];
-         rgba[i][BCOMP] = ptr3[bind];
-         rgba[i][ACOMP] = 0;
+         const GLchan *p = PIXELADDR3(x[i], y[i]);
+         rgba[i][RCOMP] = UNPACK_RED(p);
+         rgba[i][GCOMP] = UNPACK_GREEN(p);
+         rgba[i][BCOMP] = UNPACK_BLUE(p);
+         rgba[i][ACOMP] = 255;
       }
    }
 }
@@ -1115,115 +1205,119 @@ static void read_rgba_pixels3( const GLcontext *ctx,
 /**********************************************************************/
 
 /* Write 32-bit color index to buffer */
-static void write_index32_span( const GLcontext *ctx,
-                                GLuint n, GLint x, GLint y,
-                                const GLuint index[], const GLubyte mask[] )
+static void
+write_index32_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                    const GLuint index[], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLubyte *ptr1 = PIXELADDR1(x,y);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *ptr1 = PIXELADDR1(x, y);
    GLuint i;
    if (mask) {
       for (i=0;i<n;i++,ptr1++) {
          if (mask[i]) {
-            *ptr1 = (GLubyte) index[i];
+            *ptr1 = (GLchan) index[i];
          }
       }
    }
    else {
       for (i=0;i<n;i++,ptr1++) {
-         *ptr1 = (GLubyte) index[i];
+         *ptr1 = (GLchan) index[i];
       }
    }
 }
 
 
 /* Write 8-bit color index to buffer */
-static void write_index8_span( const GLcontext *ctx,
-                               GLuint n, GLint x, GLint y,
-                               const GLubyte index[], const GLubyte mask[] )
+static void
+write_index8_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                   const GLubyte index[], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLubyte *ptr1 = PIXELADDR1(x,y);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *ptr1 = PIXELADDR1(x, y);
    GLuint i;
    if (mask) {
       for (i=0;i<n;i++,ptr1++) {
          if (mask[i]) {
-            *ptr1 = (GLubyte) index[i];
+            *ptr1 = (GLchan) index[i];
          }
       }
    }
    else {
-      MEMCPY( ptr1, index, n );
+      MEMCPY(ptr1, index, n * sizeof(GLchan));
    }
 }
 
 
-static void write_monoindex_span( const GLcontext *ctx,
-                                  GLuint n, GLint x, GLint y,
-				  GLuint colorIndex, const GLubyte mask[] )
+static void
+write_monoindex_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                      GLuint colorIndex, const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLubyte *ptr1 = PIXELADDR1(x,y);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *ptr1 = PIXELADDR1(x, y);
    GLuint i;
    for (i=0;i<n;i++,ptr1++) {
       if (mask[i]) {
-         *ptr1 = (GLubyte) colorIndex;
+         *ptr1 = (GLchan) colorIndex;
       }
    }
 }
 
 
-static void write_index_pixels( const GLcontext *ctx,
-                                GLuint n, const GLint x[], const GLint y[],
-			        const GLuint index[], const GLubyte mask[] )
+static void
+write_index_pixels( const GLcontext *ctx,
+                    GLuint n, const GLint x[], const GLint y[],
+                    const GLuint index[], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
    for (i=0;i<n;i++) {
       if (mask[i]) {
-         GLubyte *ptr1 = PIXELADDR1(x[i],y[i]);
-         *ptr1 = (GLubyte) index[i];
+         GLchan *ptr1 = PIXELADDR1(x[i], y[i]);
+         *ptr1 = (GLchan) index[i];
       }
    }
 }
 
 
-static void write_monoindex_pixels( const GLcontext *ctx,
-                                    GLuint n, const GLint x[], const GLint y[],
-				    GLuint colorIndex, const GLubyte mask[] )
+static void
+write_monoindex_pixels( const GLcontext *ctx,
+                        GLuint n, const GLint x[], const GLint y[],
+                        GLuint colorIndex, const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
    for (i=0;i<n;i++) {
       if (mask[i]) {
-         GLubyte *ptr1 = PIXELADDR1(x[i],y[i]);
-         *ptr1 = (GLubyte) colorIndex;
+         GLchan *ptr1 = PIXELADDR1(x[i], y[i]);
+         *ptr1 = (GLchan) colorIndex;
       }
    }
 }
 
 
-static void read_index_span( const GLcontext *ctx,
-                             GLuint n, GLint x, GLint y, GLuint index[] )
+static void
+read_index_span( const GLcontext *ctx,
+                 GLuint n, GLint x, GLint y, GLuint index[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
-   const GLubyte *ptr1 = PIXELADDR1(x,y);
+   const GLchan *ptr1 = (const GLchan *) PIXELADDR1(x, y);
    for (i=0;i<n;i++,ptr1++) {
       index[i] = (GLuint) *ptr1;
    }
 }
 
 
-static void read_index_pixels( const GLcontext *ctx,
-                               GLuint n, const GLint x[], const GLint y[],
-			       GLuint index[], const GLubyte mask[] )
+static void
+read_index_pixels( const GLcontext *ctx,
+                   GLuint n, const GLint x[], const GLint y[],
+                   GLuint index[], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
    for (i=0;i<n;i++) {
       if (mask[i] ) {
-         const GLubyte *ptr1 = PIXELADDR1(x[i],y[i]);
+         const GLchan *ptr1 = PIXELADDR1(x[i], y[i]);
          index[i] = (GLuint) *ptr1;
       }
    }
@@ -1239,16 +1333,19 @@ static void read_index_pixels( const GLcontext *ctx,
 /*
  * Draw a flat-shaded, RGB line into an osmesa buffer.
  */
-static void flat_rgba_line( GLcontext *ctx,
-                            const SWvertex *vert0, const SWvertex *vert1 )
+static void
+flat_rgba_line( GLcontext *ctx, const SWvertex *vert0, const SWvertex *vert1 )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLubyte *color = (GLubyte*) vert0->color;
-   unsigned long pixel = PACK_RGBA( color[0], color[1], color[2], color[3] );
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const GLchan *color = vert0->color;
 
 #define INTERP_XY 1
 #define CLIP_HACK 1
-#define PLOT(X,Y) { GLuint *ptr4 = PIXELADDR4(X,Y); *ptr4 = pixel; }
+#define PLOT(X, Y)						\
+do {								\
+   GLchan *p = PIXELADDR4(X, Y);				\
+   PACK_RGBA(p, color[0], color[1], color[2], color[3]);	\
+} while (0)
 
 #ifdef WIN32
 #include "..\swrast\s_linetemp.h"
@@ -1261,23 +1358,26 @@ static void flat_rgba_line( GLcontext *ctx,
 /*
  * Draw a flat-shaded, Z-less, RGB line into an osmesa buffer.
  */
-static void flat_rgba_z_line( GLcontext *ctx,
-			      const SWvertex *vert0, const SWvertex *vert1 )
+static void
+flat_rgba_z_line(GLcontext *ctx, const SWvertex *vert0, const SWvertex *vert1)
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLubyte *color = (GLubyte*) vert0->color;
-   unsigned long pixel = PACK_RGBA( color[0], color[1], color[2], color[3] );
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const GLchan *color = vert0->color;
 
 #define INTERP_XY 1
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 #define CLIP_HACK 1
-#define PLOT(X,Y)				\
-	if (Z < *zPtr) {			\
-	   GLuint *ptr4 = PIXELADDR4(X,Y);	\
-	   *ptr4 = pixel;			\
-	   *zPtr = Z;				\
-	}
+#define PLOT(X, Y)					\
+do {							\
+   if (Z < *zPtr) {					\
+      GLchan *p = PIXELADDR4(X, Y);			\
+      PACK_RGBA(p, color[RCOMP], color[GCOMP],		\
+                   color[BCOMP], color[ACOMP]);		\
+      *zPtr = Z;					\
+   }							\
+} while (0)
+
 
 #ifdef WIN32
 #include "..\swrast\s_linetemp.h"
@@ -1289,24 +1389,26 @@ static void flat_rgba_z_line( GLcontext *ctx,
 
 /*
  * Draw a flat-shaded, alpha-blended, RGB line into an osmesa buffer.
+ * XXX update for GLchan
  */
-static void flat_blend_rgba_line( GLcontext *ctx,
-				  const SWvertex *vert0, const SWvertex *vert1 )
+static void
+flat_blend_rgba_line( GLcontext *ctx,
+                      const SWvertex *vert0, const SWvertex *vert1 )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint avalue = vert0->color[3];
-   GLint msavalue = 255 - avalue;
-   GLint rvalue = vert0->color[0]*avalue;
-   GLint gvalue = vert0->color[1]*avalue;
-   GLint bvalue = vert0->color[2]*avalue;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const GLint rshift = osmesa->rshift;
+   const GLint gshift = osmesa->gshift;
+   const GLint bshift = osmesa->bshift;
+   const GLint avalue = vert0->color[3];
+   const GLint msavalue = 255 - avalue;
+   const GLint rvalue = vert0->color[0]*avalue;
+   const GLint gvalue = vert0->color[1]*avalue;
+   const GLint bvalue = vert0->color[2]*avalue;
 
 #define INTERP_XY 1
 #define CLIP_HACK 1
 #define PLOT(X,Y)					\
-   { GLuint *ptr4 = PIXELADDR4(X,Y);			\
+   { GLuint *ptr4 = (GLuint *) PIXELADDR4(X, Y);		\
      GLuint  pixel = 0;					\
      pixel |=((((((*ptr4) >> rshift) & 0xff)*msavalue+rvalue)>>8) << rshift);\
      pixel |=((((((*ptr4) >> gshift) & 0xff)*msavalue+gvalue)>>8) << gshift);\
@@ -1324,19 +1426,21 @@ static void flat_blend_rgba_line( GLcontext *ctx,
 
 /*
  * Draw a flat-shaded, Z-less, alpha-blended, RGB line into an osmesa buffer.
+ * XXX update for GLchan
  */
-static void flat_blend_rgba_z_line( GLcontext *ctx,
-				    const SWvertex *vert0, const SWvertex *vert1 )
+static void
+flat_blend_rgba_z_line( GLcontext *ctx,
+                        const SWvertex *vert0, const SWvertex *vert1 )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint avalue = vert0->color[3];
-   GLint msavalue = 256 - avalue;
-   GLint rvalue = vert0->color[0]*avalue;
-   GLint gvalue = vert0->color[1]*avalue;
-   GLint bvalue = vert0->color[2]*avalue;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const GLint rshift = osmesa->rshift;
+   const GLint gshift = osmesa->gshift;
+   const GLint bshift = osmesa->bshift;
+   const GLint avalue = vert0->color[3];
+   const GLint msavalue = 256 - avalue;
+   const GLint rvalue = vert0->color[0]*avalue;
+   const GLint gvalue = vert0->color[1]*avalue;
+   const GLint bvalue = vert0->color[2]*avalue;
 
 #define INTERP_XY 1
 #define INTERP_Z 1
@@ -1344,7 +1448,7 @@ static void flat_blend_rgba_z_line( GLcontext *ctx,
 #define CLIP_HACK 1
 #define PLOT(X,Y)							\
 	if (Z < *zPtr) {						\
-	   GLuint *ptr4 = PIXELADDR4(X,Y);				\
+	   GLuint *ptr4 = (GLuint *) PIXELADDR4(X, Y);			\
 	   GLuint  pixel = 0;						\
 	   pixel |=((((((*ptr4) >> rshift) & 0xff)*msavalue+rvalue)>>8) << rshift);	\
 	   pixel |=((((((*ptr4) >> gshift) & 0xff)*msavalue+gvalue)>>8) << gshift);	\
@@ -1362,19 +1466,21 @@ static void flat_blend_rgba_z_line( GLcontext *ctx,
 
 /*
  * Draw a flat-shaded, Z-less, alpha-blended, RGB line into an osmesa buffer.
+ * XXX update for GLchan
  */
-static void flat_blend_rgba_z_line_write( GLcontext *ctx,
-					  const SWvertex *vert0, const SWvertex *vert1 )
+static void
+flat_blend_rgba_z_line_write( GLcontext *ctx,
+                              const SWvertex *vert0, const SWvertex *vert1 )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint avalue = vert0->color[3];
-   GLint msavalue = 256 - avalue;
-   GLint rvalue = vert0->color[0]*avalue;
-   GLint gvalue = vert0->color[1]*avalue;
-   GLint bvalue = vert0->color[2]*avalue;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const GLint rshift = osmesa->rshift;
+   const GLint gshift = osmesa->gshift;
+   const GLint bshift = osmesa->bshift;
+   const GLint avalue = vert0->color[3];
+   const GLint msavalue = 256 - avalue;
+   const GLint rvalue = vert0->color[0]*avalue;
+   const GLint gvalue = vert0->color[1]*avalue;
+   const GLint bvalue = vert0->color[2]*avalue;
 
 #define INTERP_XY 1
 #define INTERP_Z 1
@@ -1382,7 +1488,7 @@ static void flat_blend_rgba_z_line_write( GLcontext *ctx,
 #define CLIP_HACK 1
 #define PLOT(X,Y)							\
 	if (Z < *zPtr) {						\
-	   GLuint *ptr4 = PIXELADDR4(X,Y);				\
+	   GLuint *ptr4 = (GLuint *) PIXELADDR4(X, Y);			\
 	   GLuint  pixel = 0;						\
 	   pixel |=((((((*ptr4) >> rshift) & 0xff)*msavalue+rvalue)>>8) << rshift);	\
 	   pixel |=((((((*ptr4) >> gshift) & 0xff)*msavalue+gvalue)>>8) << gshift);	\
@@ -1406,97 +1512,65 @@ static void flat_blend_rgba_z_line_write( GLcontext *ctx,
 static swrast_line_func
 osmesa_choose_line_function( GLcontext *ctx )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const SWcontext *swrast = SWRAST_CONTEXT(ctx);
 
+   if (CHAN_BITS != 8)                    return NULL;
    if (ctx->RenderMode != GL_RENDER)      return NULL;
    if (ctx->Line.SmoothFlag)              return NULL;
    if (ctx->Texture._ReallyEnabled)       return NULL;
-   if (ctx->Light.ShadeModel!=GL_FLAT)    return NULL;
-
-   if (ctx->Line.Width==1.0F
-       && ctx->Line.StippleFlag==GL_FALSE) {
-
-       if (swrast->_RasterMask==DEPTH_BIT
-           && ctx->Depth.Func==GL_LESS
-           && ctx->Depth.Mask==GL_TRUE
-           && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS) {
-           switch(osmesa->format) {
-       		case OSMESA_RGBA:
-       		case OSMESA_BGRA:
-       		case OSMESA_ARGB:
-       			return flat_rgba_z_line;
-       		default:
-       			return NULL;
-           }
-       }
-
-       if (swrast->_RasterMask==0) {
-           switch(osmesa->format) {
-       		case OSMESA_RGBA:
-       		case OSMESA_BGRA:
-       		case OSMESA_ARGB:
-       			return flat_rgba_line;
-       		default:
-       			return NULL;
-           }
-       }
-
-       if (swrast->_RasterMask==(DEPTH_BIT|BLEND_BIT)
-           && ctx->Depth.Func==GL_LESS
-           && ctx->Depth.Mask==GL_TRUE
-           && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
-           && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
-           && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
-           && ctx->Color.BlendSrcA==GL_SRC_ALPHA
-           && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
-           && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
-           switch(osmesa->format) {
-       		case OSMESA_RGBA:
-       		case OSMESA_BGRA:
-       		case OSMESA_ARGB:
-       			return flat_blend_rgba_z_line_write;
-       		default:
-       			return NULL;
-           }
-       }
-
-       if (swrast->_RasterMask==(DEPTH_BIT|BLEND_BIT)
-           && ctx->Depth.Func==GL_LESS
-           && ctx->Depth.Mask==GL_FALSE
-           && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
-           && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
-           && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
-           && ctx->Color.BlendSrcA==GL_SRC_ALPHA
-           && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
-           && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
-           switch(osmesa->format) {
-       		case OSMESA_RGBA:
-       		case OSMESA_BGRA:
-       		case OSMESA_ARGB:
-       			return flat_blend_rgba_z_line;
-       		default:
-       			return NULL;
-           }
-       }
-
-       if (swrast->_RasterMask==BLEND_BIT
-           && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
-           && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
-           && ctx->Color.BlendSrcA==GL_SRC_ALPHA
-           && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
-           && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
-           switch(osmesa->format) {
-       		case OSMESA_RGBA:
-       		case OSMESA_BGRA:
-       		case OSMESA_ARGB:
-       			return flat_blend_rgba_line;
-       		default:
-       			return NULL;
-           }
-       }
+   if (ctx->Light.ShadeModel != GL_FLAT)  return NULL;
+   if (ctx->Line.Width != 1.0F)           return NULL;
+   if (ctx->Line.StippleFlag)             return NULL;
+   if (ctx->Line.SmoothFlag)              return NULL;
+   if (osmesa->format != OSMESA_RGBA &&
+       osmesa->format != OSMESA_BGRA &&
+       osmesa->format != OSMESA_ARGB)     return NULL;
+
+   if (swrast->_RasterMask==DEPTH_BIT
+       && ctx->Depth.Func==GL_LESS
+       && ctx->Depth.Mask==GL_TRUE
+       && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS) {
+      return flat_rgba_z_line;
+   }
+
+   if (swrast->_RasterMask == 0) {
+      return flat_rgba_line;
+   }
+
+   if (swrast->_RasterMask==(DEPTH_BIT|BLEND_BIT)
+       && ctx->Depth.Func==GL_LESS
+       && ctx->Depth.Mask==GL_TRUE
+       && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
+       && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
+       && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
+       && ctx->Color.BlendSrcA==GL_SRC_ALPHA
+       && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
+       && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
+      return flat_blend_rgba_z_line_write;
+   }
+
+   if (swrast->_RasterMask==(DEPTH_BIT|BLEND_BIT)
+       && ctx->Depth.Func==GL_LESS
+       && ctx->Depth.Mask==GL_FALSE
+       && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
+       && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
+       && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
+       && ctx->Color.BlendSrcA==GL_SRC_ALPHA
+       && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
+       && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
+      return flat_blend_rgba_z_line;
+   }
 
+   if (swrast->_RasterMask==BLEND_BIT
+       && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
+       && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
+       && ctx->Color.BlendSrcA==GL_SRC_ALPHA
+       && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
+       && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
+      return flat_blend_rgba_line;
    }
+
    return NULL;
 }
 
@@ -1514,11 +1588,7 @@ static void smooth_rgba_z_triangle( GLcontext *ctx,
                                     const SWvertex *v1,
                                     const SWvertex *v2 )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint ashift = osmesa->ashift;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
 
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
@@ -1527,13 +1597,13 @@ static void smooth_rgba_z_triangle( GLcontext *ctx,
 #define INNER_LOOP( LEFT, RIGHT, Y )				\
 {								\
    GLint i, len = RIGHT-LEFT;					\
-   GLuint *img = PIXELADDR4(LEFT,Y);   				\
-   (void) fffog;                        \
-   for (i=0;i<len;i++,img++) {					\
+   GLchan *img = PIXELADDR4(LEFT, Y); 				\
+   (void) fffog;                        			\
+   for (i = 0; i < len; i++, img += 4) {			\
       GLdepth z = FixedToDepth(ffz);				\
       if (z < zRow[i]) {					\
-         *img = PACK_RGBA2( FixedToInt(ffr), FixedToInt(ffg),	\
-		            FixedToInt(ffb), FixedToInt(ffa) );	\
+         PACK_RGBA(img, FixedToInt(ffr), FixedToInt(ffg),	\
+		        FixedToInt(ffb), FixedToInt(ffa));	\
          zRow[i] = z;						\
       }								\
       ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;  ffa += fdadx;\
@@ -1558,29 +1628,27 @@ static void flat_rgba_z_triangle( GLcontext *ctx,
                                   const SWvertex *v1,
                                   const SWvertex *v2 )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define SETUP_CODE			\
-   GLubyte r = v0->color[0];		\
-   GLubyte g = v0->color[1];		\
-   GLubyte b = v0->color[2];		\
-   GLubyte a = v0->color[3];		\
-   GLuint pixel = PACK_RGBA(r,g,b,a);
-
-#define INNER_LOOP( LEFT, RIGHT, Y )	\
-{					\
-   GLint i, len = RIGHT-LEFT;		\
-   GLuint *img = PIXELADDR4(LEFT,Y);   	\
-   (void) fffog;                        \
-   for (i=0;i<len;i++,img++) {		\
-      GLdepth z = FixedToDepth(ffz);	\
-      if (z < zRow[i]) {		\
-         *img = pixel;			\
-         zRow[i] = z;			\
-      }					\
-      ffz += fdzdx;			\
-   }					\
+#define SETUP_CODE						\
+   GLuint pixel;						\
+   PACK_RGBA((GLchan *) &pixel, v0->color[0], v0->color[1],	\
+                                v0->color[2], v0->color[3]);
+
+#define INNER_LOOP( LEFT, RIGHT, Y )			\
+{							\
+   GLint i, len = RIGHT-LEFT;				\
+   GLuint *img = (GLuint *) PIXELADDR4(LEFT, Y);   	\
+   (void) fffog;                        		\
+   for (i=0;i<len;i++) {				\
+      GLdepth z = FixedToDepth(ffz);			\
+      if (z < zRow[i]) {				\
+         img[i] = pixel;				\
+         zRow[i] = z;					\
+      }							\
+      ffz += fdzdx;					\
+   }							\
 }
 #ifdef WIN32
 #include "..\swrast\s_tritemp.h"
@@ -1597,32 +1665,34 @@ static void flat_rgba_z_triangle( GLcontext *ctx,
 static swrast_tri_func
 osmesa_choose_triangle_function( GLcontext *ctx )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   if ((osmesa->format==OSMESA_RGB)||(osmesa->format==OSMESA_BGR))
-      return (swrast_tri_func)NULL;
-
-   if (ctx->RenderMode != GL_RENDER)  return (swrast_tri_func) NULL;
-   if (ctx->Polygon.SmoothFlag)       return (swrast_tri_func) NULL;
-   if (ctx->Polygon.StippleFlag)      return (swrast_tri_func) NULL;
-   if (ctx->Texture._ReallyEnabled)   return (swrast_tri_func) NULL;
-
-   if (swrast->_RasterMask==DEPTH_BIT
-       && ctx->Depth.Func==GL_LESS
-       && ctx->Depth.Mask==GL_TRUE
-       && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
-       && osmesa->format!=OSMESA_COLOR_INDEX) {
-      if (ctx->Light.ShadeModel==GL_SMOOTH) {
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   if (CHAN_BITS != 8)                  return (swrast_tri_func) NULL;
+   if (ctx->RenderMode != GL_RENDER)    return (swrast_tri_func) NULL;
+   if (ctx->Polygon.SmoothFlag)         return (swrast_tri_func) NULL;
+   if (ctx->Polygon.StippleFlag)        return (swrast_tri_func) NULL;
+   if (ctx->Texture._ReallyEnabled)     return (swrast_tri_func) NULL;
+   if (osmesa->format != OSMESA_RGBA &&
+       osmesa->format != OSMESA_BGRA &&
+       osmesa->format != OSMESA_ARGB)   return (swrast_tri_func) NULL;
+
+   if (swrast->_RasterMask == DEPTH_BIT &&
+       ctx->Depth.Func == GL_LESS &&
+       ctx->Depth.Mask == GL_TRUE &&
+       ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS) {
+      if (ctx->Light.ShadeModel == GL_SMOOTH) {
          return smooth_rgba_z_triangle;
       }
       else {
          return flat_rgba_z_triangle;
       }
    }
-   return (swrast_tri_func)NULL;
+   return (swrast_tri_func) NULL;
 }
 
+
+
 /* Override for the swrast triangle-selection function.  Try to use one
  * of our internal triangle functions, otherwise fall back to the
  * standard swrast functions.
@@ -1694,14 +1764,17 @@ static void osmesa_update_state( GLcontext *ctx, GLuint new_state )
 
    ASSERT((void *) osmesa == (void *) ctx->DriverCtx);
 
+   /*
+    * XXX these function pointers could be initialized just once during
+    * context creation since they don't depend on any state changes.
+    */
+
    ctx->Driver.GetString = get_string;
    ctx->Driver.UpdateState = osmesa_update_state;
 
    ctx->Driver.SetDrawBuffer = set_draw_buffer;
    ctx->Driver.SetReadBuffer = set_read_buffer;
 
-   ctx->Driver.ClearIndex = clear_index;
-   ctx->Driver.ClearColor = clear_color;
    ctx->Driver.Clear = clear;
 
    ctx->Driver.GetBufferSize = buffer_size;
@@ -1716,32 +1789,41 @@ static void osmesa_update_state( GLcontext *ctx, GLuint new_state )
    ctx->Driver.RenderFinish = _swsetup_RenderFinish;
 
    /* RGB(A) span/pixel functions */
-   if ((osmesa->format==OSMESA_RGB) || (osmesa->format==OSMESA_BGR)) {
-      /* 3 bytes / pixel in frame buffer */
-      ctx->Driver.WriteRGBASpan = write_rgba_span3;
-      ctx->Driver.WriteRGBSpan = write_rgb_span3;
-      ctx->Driver.WriteRGBAPixels = write_rgba_pixels3;
-      ctx->Driver.WriteMonoRGBASpan = write_monocolor_span3;
-      ctx->Driver.WriteMonoRGBAPixels = write_monocolor_pixels3;
+   if (osmesa->format == OSMESA_RGB) {
+      ctx->Driver.WriteRGBASpan = write_rgba_span_RGB;
+      ctx->Driver.WriteRGBSpan = write_rgb_span_RGB;
+      ctx->Driver.WriteMonoRGBASpan = write_monocolor_span_RGB;
+      ctx->Driver.WriteRGBAPixels = write_rgba_pixels_RGB;
+      ctx->Driver.WriteMonoRGBAPixels = write_monocolor_pixels_RGB;
+      ctx->Driver.ReadRGBASpan = read_rgba_span3;
+      ctx->Driver.ReadRGBAPixels = read_rgba_pixels3;
+   }
+   else if (osmesa->format == OSMESA_BGR) {
+      ctx->Driver.WriteRGBASpan = write_rgba_span_BGR;
+      ctx->Driver.WriteRGBSpan = write_rgb_span_BGR;
+      ctx->Driver.WriteMonoRGBASpan = write_monocolor_span_BGR;
+      ctx->Driver.WriteRGBAPixels = write_rgba_pixels_BGR;
+      ctx->Driver.WriteMonoRGBAPixels = write_monocolor_pixels_BGR;
       ctx->Driver.ReadRGBASpan = read_rgba_span3;
       ctx->Driver.ReadRGBAPixels = read_rgba_pixels3;
    }
    else {
       /* 4 bytes / pixel in frame buffer */
-      if (osmesa->format==OSMESA_RGBA
-          && RCOMP==0 && GCOMP==1 && BCOMP==2 && ACOMP==3)
-         ctx->Driver.WriteRGBASpan = write_rgba_span_rgba;
-      else
-         ctx->Driver.WriteRGBASpan = write_rgba_span;
       ctx->Driver.WriteRGBSpan = write_rgb_span;
       ctx->Driver.WriteRGBAPixels = write_rgba_pixels;
       ctx->Driver.WriteMonoRGBASpan = write_monocolor_span;
       ctx->Driver.WriteMonoRGBAPixels = write_monocolor_pixels;
-      if (osmesa->format==OSMESA_RGBA
-          && RCOMP==0 && GCOMP==1 && BCOMP==2 && ACOMP==3)
+      if (osmesa->format == OSMESA_RGBA &&
+          CHAN_TYPE == GL_UNSIGNED_BYTE &&
+          RCOMP==0 && GCOMP==1 && BCOMP==2 && ACOMP==3) {
+         /* special, fast case */
+         ctx->Driver.WriteRGBASpan = write_rgba_span_rgba;
          ctx->Driver.ReadRGBASpan = read_rgba_span_rgba;
-      else
+      }
+      else {
+         ctx->Driver.WriteRGBASpan = write_rgba_span;
          ctx->Driver.ReadRGBASpan = read_rgba_span;
+      }
       ctx->Driver.ReadRGBAPixels = read_rgba_pixels;
    }
 
diff --git a/src/mesa/drivers/svga/svgamesa15.c b/src/mesa/drivers/svga/svgamesa15.c
index 3332503d2b8..0f8ebd330ba 100644
--- a/src/mesa/drivers/svga/svgamesa15.c
+++ b/src/mesa/drivers/svga/svgamesa15.c
@@ -1,4 +1,4 @@
-/* $Id: svgamesa15.c,v 1.7 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa15.c,v 1.8 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -54,11 +54,9 @@ static unsigned long __svga_getpixel15(int x, int y)
     return shortBuffer[offset];
 }
 
-void __clear_color15( GLcontext *ctx,
-                      GLubyte red, GLubyte green,
-                      GLubyte blue, GLubyte alpha )
+void __clear_color15( GLcontext *ctx, const GLchan color[4] )
 {
-   SVGAMesa->clear_hicolor=(red>>3)<<10 | (green>>3)<<5 | (blue>>3);  
+   SVGAMesa->clear_hicolor=(color[0]>>3)<<10 | (color[1]>>3)<<5 | (color[2]>>3);  
 /*   SVGAMesa->clear_hicolor=(red)<<10 | (green)<<5 | (blue);*/
 }   
 
diff --git a/src/mesa/drivers/svga/svgamesa15.h b/src/mesa/drivers/svga/svgamesa15.h
index 83591a610fb..f2c16d9f833 100644
--- a/src/mesa/drivers/svga/svgamesa15.h
+++ b/src/mesa/drivers/svga/svgamesa15.h
@@ -1,4 +1,4 @@
-/* $Id: svgamesa15.h,v 1.4 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa15.h,v 1.5 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -31,7 +31,7 @@
 #ifndef SVGA_MESA_15_H
 #define SVGA_MESA_15_H
 
-extern void __clear_color15( GLcontext *ctx, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha );
+extern void __clear_color15( GLcontext *ctx, const GLchan color[4] );
 extern GLbitfield __clear15( GLcontext *ctx, GLbitfield mask, GLboolean all, GLint x, GLint y, GLint width, GLint height );
 extern void __write_rgba_span15( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLubyte rgba[][4], const GLubyte mask[] );
 extern void __write_mono_rgba_span15( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLchan color[4], const GLubyte mask[]);
diff --git a/src/mesa/drivers/svga/svgamesa16.c b/src/mesa/drivers/svga/svgamesa16.c
index 02d1251665f..20d1ed6fecb 100644
--- a/src/mesa/drivers/svga/svgamesa16.c
+++ b/src/mesa/drivers/svga/svgamesa16.c
@@ -1,4 +1,4 @@
-/* $Id: svgamesa16.c,v 1.7 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa16.c,v 1.8 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -56,11 +56,11 @@ static unsigned long __svga_getpixel16(int x, int y)
     return shortBuffer[offset];
 }
 
-void __clear_color16( GLcontext *ctx,
-                      GLubyte red, GLubyte green,
-                      GLubyte blue, GLubyte alpha )
+void __clear_color16( GLcontext *ctx, const GLchan color[4] )
 {
-    SVGAMesa->clear_hicolor=(red>>3)<<11 | (green>>2)<<5 | (blue>>3); 
+    SVGAMesa->clear_hicolor = (color[0] >> 3) << 11 |
+                              (color[1] >> 2) << 5 |
+                              (color[2] >> 3); 
 /*    SVGAMesa->clear_hicolor=(red)<<11 | (green)<<5 | (blue); */
 }   
 
diff --git a/src/mesa/drivers/svga/svgamesa16.h b/src/mesa/drivers/svga/svgamesa16.h
index 94ddcf3a195..f18d559cdb2 100644
--- a/src/mesa/drivers/svga/svgamesa16.h
+++ b/src/mesa/drivers/svga/svgamesa16.h
@@ -1,4 +1,4 @@
-/* $Id: svgamesa16.h,v 1.3 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa16.h,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -31,7 +31,7 @@
 #ifndef SVGA_MESA_16_H
 #define SVGA_MESA_16_H
 
-extern void __clear_color16( GLcontext *ctx, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha );
+extern void __clear_color16( GLcontext *ctx, const GLchan color[4] );
 extern GLbitfield __clear16( GLcontext *ctx, GLbitfield mask, GLboolean all, GLint x, GLint y, GLint width, GLint height );
 extern void __write_rgba_span16( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLubyte rgba[][4], const GLubyte mask[] );
 extern void __write_mono_rgba_span16( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLchan color[4], const GLubyte mask[]);
diff --git a/src/mesa/drivers/svga/svgamesa24.c b/src/mesa/drivers/svga/svgamesa24.c
index aa174df4cc4..0d0c8e74c8f 100644
--- a/src/mesa/drivers/svga/svgamesa24.c
+++ b/src/mesa/drivers/svga/svgamesa24.c
@@ -1,4 +1,4 @@
-/* $Id: svgamesa24.c,v 1.8 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa24.c,v 1.9 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -78,13 +78,11 @@ static unsigned long __svga_getpixel24(int x, int y)
     return rgbBuffer[offset].r<<16 | rgbBuffer[offset].g<<8 | rgbBuffer[offset].b;
 }
 
-void __clear_color24( GLcontext *ctx,
-                      GLubyte red, GLubyte green,
-                      GLubyte blue, GLubyte alpha )
+void __clear_color24( GLcontext *ctx, const GLchan color[4] )
 {
-   SVGAMesa->clear_red = red;
-   SVGAMesa->clear_green = green;
-   SVGAMesa->clear_blue = blue;
+   SVGAMesa->clear_red = color[0];
+   SVGAMesa->clear_green = color[1];
+   SVGAMesa->clear_blue = color[2];
 /*   SVGAMesa->clear_truecolor = red<<16 | green<<8 | blue; */
 }
 
diff --git a/src/mesa/drivers/svga/svgamesa24.h b/src/mesa/drivers/svga/svgamesa24.h
index dc9382034bb..9707e993c33 100644
--- a/src/mesa/drivers/svga/svgamesa24.h
+++ b/src/mesa/drivers/svga/svgamesa24.h
@@ -1,4 +1,4 @@
-/* $Id: svgamesa24.h,v 1.3 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa24.h,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -31,7 +31,7 @@
 #ifndef SVGA_MESA_24_H
 #define SVGA_MESA_24_H
 
-extern void __clear_color24( GLcontext *ctx, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha );
+extern void __clear_color24( GLcontext *ctx, const GLchan color[4] );
 extern GLbitfield __clear24( GLcontext *ctx, GLbitfield mask, GLboolean all, GLint x, GLint y, GLint width, GLint height );
 extern void __write_rgba_span24( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLubyte rgba[][4], const GLubyte mask[] );
 extern void __write_mono_rgba_span24( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLchan color[4], const GLubyte mask[]);
diff --git a/src/mesa/drivers/svga/svgamesa32.c b/src/mesa/drivers/svga/svgamesa32.c
index a56afdc86ce..88907c49c8d 100644
--- a/src/mesa/drivers/svga/svgamesa32.c
+++ b/src/mesa/drivers/svga/svgamesa32.c
@@ -1,4 +1,4 @@
-/* $Id: svgamesa32.c,v 1.8 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa32.c,v 1.9 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -74,11 +74,9 @@ static unsigned long __svga_getpixel32(int x, int y)
     return intBuffer[offset];
 }
 
-void __clear_color32( GLcontext *ctx,
-                      GLubyte red, GLubyte green,
-                      GLubyte blue, GLubyte alpha )
+void __clear_color32( GLcontext *ctx, const GLchan color[4] )
 {
-   SVGAMesa->clear_truecolor = red<<16 | green<<8 | blue;
+   SVGAMesa->clear_truecolor = (color[0] << 16) | (color[1] << 8) | color[2];
 }
 
 GLbitfield __clear32( GLcontext *ctx, GLbitfield mask, GLboolean all,
diff --git a/src/mesa/drivers/svga/svgamesa32.h b/src/mesa/drivers/svga/svgamesa32.h
index 36406249721..d24b95a6cd9 100644
--- a/src/mesa/drivers/svga/svgamesa32.h
+++ b/src/mesa/drivers/svga/svgamesa32.h
@@ -1,4 +1,4 @@
-/* $Id: svgamesa32.h,v 1.3 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa32.h,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -31,7 +31,7 @@
 #ifndef SVGA_MESA_32_H
 #define SVGA_MESA_32_H
 
-extern void __clear_color32( GLcontext *ctx, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha );
+extern void __clear_color32( GLcontext *ctx, const GLchan color[4] );
 extern GLbitfield __clear32( GLcontext *ctx, GLbitfield mask, GLboolean all, GLint x, GLint y, GLint width, GLint height );
 extern void __write_rgba_span32( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLubyte rgba[][4], const GLubyte mask[] );
 extern void __write_mono_rgba_span32( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLchan color[4], const GLubyte mask[]);
diff --git a/src/mesa/drivers/windows/wmesa.c b/src/mesa/drivers/windows/wmesa.c
index b55142e8add..74fea18030e 100644
--- a/src/mesa/drivers/windows/wmesa.c
+++ b/src/mesa/drivers/windows/wmesa.c
@@ -1,4 +1,4 @@
-/* $Id: wmesa.c,v 1.12 2000/11/17 21:01:47 brianp Exp $ */
+/* $Id: wmesa.c,v 1.13 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Windows (Win32) device driver for Mesa 3.4
@@ -366,10 +366,10 @@ static void clear_index(GLcontext* ctx, GLuint index)
 /*
 * Set the color used to clear the color buffer.
 */
-static void clear_color( GLcontext* ctx, GLubyte r, GLubyte g, GLubyte b, GLubyte a )
+static void clear_color( GLcontext* ctx, const GLchan color[4] )
 {
     STARTPROFILE
-        Current->clearpixel=RGB(r, g, b );
+        Current->clearpixel = RGB(color[0], color[1], color[2]);
     ENDPROFILE(clear_color)
 }
 
diff --git a/src/mesa/drivers/windows/wmesa_stereo.c b/src/mesa/drivers/windows/wmesa_stereo.c
index d3787909ee9..b0b6f811ddc 100644
--- a/src/mesa/drivers/windows/wmesa_stereo.c
+++ b/src/mesa/drivers/windows/wmesa_stereo.c
@@ -152,10 +152,10 @@ static void clear_index(GLcontext* ctx, GLuint index)
 /*

  * Set the color used to clear the color buffer.

  */

-static void clear_color( GLcontext* ctx, GLubyte r, GLubyte g, GLubyte b, GLubyte a )

+static void clear_color( GLcontext* ctx, const GLchan color[4] )

 {

   STARTPROFILE

-  Current->clearpixel=RGB(r, g, b );

+  Current->clearpixel = RGB(color[0], color[1], color[2]);

   ENDPROFILE(clear_color)

 }

 

diff --git a/src/mesa/drivers/x11/xm_dd.c b/src/mesa/drivers/x11/xm_dd.c
index 77e4ab58c4c..d6444a51461 100644
--- a/src/mesa/drivers/x11/xm_dd.c
+++ b/src/mesa/drivers/x11/xm_dd.c
@@ -1,4 +1,4 @@
-/* $Id: xm_dd.c,v 1.10 2001/01/16 05:29:43 keithw Exp $ */
+/* $Id: xm_dd.c,v 1.11 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -229,14 +229,15 @@ clear_index( GLcontext *ctx, GLuint index )
 
 
 static void
-clear_color( GLcontext *ctx, GLubyte r, GLubyte g, GLubyte b, GLubyte a )
+clear_color( GLcontext *ctx, const GLchan color[4] )
 {
    const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   xmesa->clearcolor[0] = r;
-   xmesa->clearcolor[1] = g;
-   xmesa->clearcolor[2] = b;
-   xmesa->clearcolor[3] = a;
-   xmesa->clearpixel = xmesa_color_to_pixel( xmesa, r, g, b, a,
+   xmesa->clearcolor[0] = color[0];
+   xmesa->clearcolor[1] = color[1];
+   xmesa->clearcolor[2] = color[2];
+   xmesa->clearcolor[3] = color[3];
+   xmesa->clearpixel = xmesa_color_to_pixel( xmesa, color[0], color[1],
+                                             color[2], color[3],
                                              xmesa->xm_visual->undithered_pf );
    _glthread_LOCK_MUTEX(_xmesa_lock);
    XMesaSetForeground( xmesa->display, xmesa->xm_buffer->cleargc,
diff --git a/src/mesa/drivers/x11/xm_span.c b/src/mesa/drivers/x11/xm_span.c
index 00c36af44c2..623762f2057 100644
--- a/src/mesa/drivers/x11/xm_span.c
+++ b/src/mesa/drivers/x11/xm_span.c
@@ -1,4 +1,4 @@
-/* $Id: xm_span.c,v 1.5 2001/01/08 04:06:20 keithw Exp $ */
+/* $Id: xm_span.c,v 1.6 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -4152,17 +4152,14 @@ static void read_color_pixels( const GLcontext *ctx,
 
 
 static void
-clear_color_HPCR_ximage( GLcontext *ctx,
-                         GLubyte r, GLubyte g, GLubyte b, GLubyte a )
+clear_color_HPCR_ximage( GLcontext *ctx, const GLchan color[4] )
 {
    int i;
    const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   xmesa->clearcolor[0] = r;
-   xmesa->clearcolor[1] = g;
-   xmesa->clearcolor[2] = b;
-   xmesa->clearcolor[3] = a;
 
-   if (r == 0 && g == 0 && b == 0) {
+   COPY_4V(xmesa->clearcolor, color);
+
+   if (color[0] == 0 && color[1] == 0 && color[2] == 0) {
       /* black is black */
       MEMSET( xmesa->xm_visual->hpcr_clear_ximage_pattern, 0x0 ,
               sizeof(xmesa->xm_visual->hpcr_clear_ximage_pattern));
@@ -4171,27 +4168,23 @@ clear_color_HPCR_ximage( GLcontext *ctx,
       /* build clear pattern */
       for (i=0; i<16; i++) {
          xmesa->xm_visual->hpcr_clear_ximage_pattern[0][i]    =
-            DITHER_HPCR(i, 0, r, g, b);
+            DITHER_HPCR(i, 0, color[0], color[1], color[2]);
          xmesa->xm_visual->hpcr_clear_ximage_pattern[1][i]    =
-            DITHER_HPCR(i, 1, r, g, b);
+            DITHER_HPCR(i, 1, color[0], color[1], color[2]);
       }
    }
 }
 
 
 static void
-clear_color_HPCR_pixmap( GLcontext *ctx,
-                         GLubyte r, GLubyte g, GLubyte b, GLubyte a )
+clear_color_HPCR_pixmap( GLcontext *ctx, const GLchan color[4] )
 {
    int i;
    const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   xmesa->clearcolor[0] = r;
-   xmesa->clearcolor[1] = g;
-   xmesa->clearcolor[2] = b;
-   xmesa->clearcolor[3] = a;
 
+   COPY_4V(xmesa->clearcolor, color);
 
-   if (0x0==r && 0x0==g && 0x0==b) {
+   if (color[0] == 0 && color[1] == 0 && color[2] == 0) {
       /* black is black */
       for (i=0; i<16; i++) {
          XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0, 0);
@@ -4200,8 +4193,10 @@ clear_color_HPCR_pixmap( GLcontext *ctx,
    }
    else {
       for (i=0; i<16; i++) {
-         XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0, DITHER_HPCR(i, 0, r, g, b));
-         XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 1, DITHER_HPCR(i, 1, r, g, b));
+         XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0,
+                       DITHER_HPCR(i, 0, color[0], color[1], color[2]));
+         XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 1,
+                       DITHER_HPCR(i, 1, color[0], color[1], color[2]));
       }
    }
    /* change tile pixmap content */
diff --git a/src/mesa/main/Makefile.X11 b/src/mesa/main/Makefile.X11
index fbf8d20999d..afcffbb6cc0 100644
--- a/src/mesa/main/Makefile.X11
+++ b/src/mesa/main/Makefile.X11
@@ -1,4 +1,4 @@
-# $Id: Makefile.X11,v 1.39 2001/01/08 21:55:59 keithw Exp $
+# $Id: Makefile.X11,v 1.40 2001/01/24 00:04:58 brianp Exp $
 
 # Mesa 3-D graphics library
 # Version:  3.5
@@ -86,6 +86,35 @@ CORE_SOURCES = \
 	X86/common_x86.c \
 	X86/3dnow.c \
 	X86/katmai.c \
+	swrast/s_aaline.c \
+	swrast/s_aatriangle.c \
+	swrast/s_accum.c \
+	swrast/s_alpha.c \
+	swrast/s_alphabuf.c \
+	swrast/s_bitmap.c \
+	swrast/s_blend.c \
+	swrast/s_buffers.c \
+	swrast/s_copypix.c \
+	swrast/s_context.c \
+	swrast/s_depth.c \
+	swrast/s_drawpix.c \
+	swrast/s_feedback.c \
+	swrast/s_fog.c \
+	swrast/s_histogram.c \
+	swrast/s_lines.c \
+	swrast/s_logic.c \
+	swrast/s_masking.c \
+	swrast/s_pb.c \
+	swrast/s_pixeltex.c \
+	swrast/s_points.c \
+	swrast/s_quads.c \
+	swrast/s_readpix.c \
+	swrast/s_scissor.c \
+	swrast/s_span.c \
+	swrast/s_stencil.c \
+	swrast/s_texture.c \
+	swrast/s_triangle.c \
+	swrast/s_zoom.c \
 	swrast_setup/ss_context.c \
 	swrast_setup/ss_triangle.c \
 	swrast_setup/ss_vb.c \
@@ -119,36 +148,7 @@ CORE_SOURCES = \
 	tnl/t_vb_render.c \
 	tnl/t_vb_texgen.c \
 	tnl/t_vb_texmat.c \
-	tnl/t_vb_vertex.c \
-	swrast/s_aaline.c \
-	swrast/s_aatriangle.c \
-	swrast/s_accum.c \
-	swrast/s_alpha.c \
-	swrast/s_alphabuf.c \
-	swrast/s_bitmap.c \
-	swrast/s_blend.c \
-	swrast/s_buffers.c \
-	swrast/s_copypix.c \
-	swrast/s_context.c \
-	swrast/s_depth.c \
-	swrast/s_drawpix.c \
-	swrast/s_feedback.c \
-	swrast/s_fog.c \
-	swrast/s_histogram.c \
-	swrast/s_lines.c \
-	swrast/s_logic.c \
-	swrast/s_masking.c \
-	swrast/s_pb.c \
-	swrast/s_pixeltex.c \
-	swrast/s_points.c \
-	swrast/s_quads.c \
-	swrast/s_readpix.c \
-	swrast/s_scissor.c \
-	swrast/s_span.c \
-	swrast/s_stencil.c \
-	swrast/s_texture.c \
-	swrast/s_triangle.c \
-	swrast/s_zoom.c 
+	tnl/t_vb_vertex.c
 
 
 DRIVER_SOURCES = \
@@ -188,8 +188,8 @@ ASM_SOURCES =
 ADDITIONAL_OBJ = 
 
 OBJECTS = $(ASM_SOURCES:.S=.o) \
-	$(DRIVER_SOURCES:.c=.o) \
 	$(CORE_SOURCES:.c=.o) \
+	$(DRIVER_SOURCES:.c=.o) \
 	$(ADDITIONAL_OBJ)
 
 
diff --git a/src/mesa/main/api_noop.c b/src/mesa/main/api_noop.c
index e8298186f55..8ee5b9fc6d2 100644
--- a/src/mesa/main/api_noop.c
+++ b/src/mesa/main/api_noop.c
@@ -1,3 +1,30 @@
+/* $Id: api_noop.c,v 1.4 2001/01/24 00:04:58 brianp Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
 #include "glheader.h"
 #include "api_noop.h"
 #include "api_validate.h"
@@ -133,34 +160,41 @@ void _mesa_noop_Materialfv(  GLenum face, GLenum pname, const GLfloat *params )
 void _mesa_noop_Color4ub( GLubyte a, GLubyte b, GLubyte c, GLubyte d )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLubyte *color = ctx->Current.Color;
-   color[0] = a;
-   color[1] = b;
-   color[2] = c;
-   color[3] = d;
+   GLchan *color = ctx->Current.Color;
+   color[0] = UBYTE_TO_CHAN(a);
+   color[1] = UBYTE_TO_CHAN(b);
+   color[2] = UBYTE_TO_CHAN(c);
+   color[3] = UBYTE_TO_CHAN(d);
 }
 
 void _mesa_noop_Color4ubv( const GLubyte *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLubyte *color = ctx->Current.Color;
+   GLchan *color = ctx->Current.Color;
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
    COPY_4UBV( color, v );
+#else
+   color[0] = UBYTE_TO_CHAN(v[0]);
+   color[1] = UBYTE_TO_CHAN(v[1]);
+   color[2] = UBYTE_TO_CHAN(v[2]);
+   color[3] = UBYTE_TO_CHAN(v[3]);
+#endif
 }
 
 void _mesa_noop_Color4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLubyte *color = ctx->Current.Color;
-   UNCLAMPED_FLOAT_TO_UBYTE(color[0], a);
-   UNCLAMPED_FLOAT_TO_UBYTE(color[1], b);
-   UNCLAMPED_FLOAT_TO_UBYTE(color[2], c);
-   UNCLAMPED_FLOAT_TO_UBYTE(color[3], d);
+   GLchan *color = ctx->Current.Color;
+   UNCLAMPED_FLOAT_TO_CHAN(color[0], a);
+   UNCLAMPED_FLOAT_TO_CHAN(color[1], b);
+   UNCLAMPED_FLOAT_TO_CHAN(color[2], c);
+   UNCLAMPED_FLOAT_TO_CHAN(color[3], d);
 }
 
 void _mesa_noop_Color4fv( const GLfloat *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLubyte *color = ctx->Current.Color;
+   GLchan *color = ctx->Current.Color;
    UNCLAMPED_FLOAT_TO_CHAN(color[0], v[0]);
    UNCLAMPED_FLOAT_TO_CHAN(color[1], v[1]);
    UNCLAMPED_FLOAT_TO_CHAN(color[2], v[2]);
@@ -169,41 +203,41 @@ void _mesa_noop_Color4fv( const GLfloat *v )
 void _mesa_noop_Color3ub( GLubyte a, GLubyte b, GLubyte c )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLubyte *color = ctx->Current.Color;
-   color[0] = a;
-   color[1] = b;
-   color[2] = c;
-   color[3] = 255;
+   GLchan *color = ctx->Current.Color;
+   color[0] = UBYTE_TO_CHAN(a);
+   color[1] = UBYTE_TO_CHAN(b);
+   color[2] = UBYTE_TO_CHAN(c);
+   color[3] = CHAN_MAX;
 }
 
 void _mesa_noop_Color3ubv( const GLubyte *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLubyte *color = ctx->Current.Color;
-   color[0] = v[0];
-   color[1] = v[1];
-   color[2] = v[2];
-   color[3] = 255;
+   GLchan *color = ctx->Current.Color;
+   color[0] = UBYTE_TO_CHAN(v[0]);
+   color[1] = UBYTE_TO_CHAN(v[1]);
+   color[2] = UBYTE_TO_CHAN(v[2]);
+   color[3] = CHAN_MAX;
 }
 
 void _mesa_noop_Color3f( GLfloat a, GLfloat b, GLfloat c )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLubyte *color = ctx->Current.Color;
-   UNCLAMPED_FLOAT_TO_UBYTE(color[0], a);
-   UNCLAMPED_FLOAT_TO_UBYTE(color[1], b);
-   UNCLAMPED_FLOAT_TO_UBYTE(color[2], c);
-   color[3] = 255;
+   GLchan *color = ctx->Current.Color;
+   UNCLAMPED_FLOAT_TO_CHAN(color[0], a);
+   UNCLAMPED_FLOAT_TO_CHAN(color[1], b);
+   UNCLAMPED_FLOAT_TO_CHAN(color[2], c);
+   color[3] = CHAN_MAX;
 }
 
 void _mesa_noop_Color3fv( const GLfloat *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLubyte *color = ctx->Current.Color;
+   GLchan *color = ctx->Current.Color;
    UNCLAMPED_FLOAT_TO_CHAN(color[0], v[0]);
    UNCLAMPED_FLOAT_TO_CHAN(color[1], v[1]);
    UNCLAMPED_FLOAT_TO_CHAN(color[2], v[2]);
-   color[3] = 255;
+   color[3] = CHAN_MAX;
 }
 
 void _mesa_noop_MultiTexCoord1fARB( GLenum target, GLfloat a )
@@ -346,41 +380,41 @@ void _mesa_noop_MultiTexCoord4fvARB( GLenum target, GLfloat *v )
 void _mesa_noop_SecondaryColor3ubEXT( GLubyte a, GLubyte b, GLubyte c )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLubyte *color = ctx->Current.SecondaryColor;
-   color[0] = a;
-   color[1] = b;
-   color[2] = c;
-   color[3] = 255;
+   GLchan *color = ctx->Current.SecondaryColor;
+   color[0] = UBYTE_TO_CHAN(a);
+   color[1] = UBYTE_TO_CHAN(b);
+   color[2] = UBYTE_TO_CHAN(c);
+   color[3] = CHAN_MAX;
 }
 
 void _mesa_noop_SecondaryColor3ubvEXT( const GLubyte *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLubyte *color = ctx->Current.SecondaryColor;
-   color[0] = v[0];
-   color[1] = v[1];
-   color[2] = v[2];
-   color[3] = 255;
+   GLchan *color = ctx->Current.SecondaryColor;
+   color[0] = UBYTE_TO_CHAN(v[0]);
+   color[1] = UBYTE_TO_CHAN(v[1]);
+   color[2] = UBYTE_TO_CHAN(v[2]);
+   color[3] = CHAN_MAX;
 }
 
 void _mesa_noop_SecondaryColor3fEXT( GLfloat a, GLfloat b, GLfloat c )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLubyte *color = ctx->Current.SecondaryColor;
-   UNCLAMPED_FLOAT_TO_UBYTE(color[0], a);
-   UNCLAMPED_FLOAT_TO_UBYTE(color[1], b);
-   UNCLAMPED_FLOAT_TO_UBYTE(color[2], c);
-   color[3] = 255;
+   GLchan *color = ctx->Current.SecondaryColor;
+   UNCLAMPED_FLOAT_TO_CHAN(color[0], a);
+   UNCLAMPED_FLOAT_TO_CHAN(color[1], b);
+   UNCLAMPED_FLOAT_TO_CHAN(color[2], c);
+   color[3] = CHAN_MAX;
 }
 
 void _mesa_noop_SecondaryColor3fvEXT( const GLfloat *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLubyte *color = ctx->Current.SecondaryColor;
+   GLchan *color = ctx->Current.SecondaryColor;
    UNCLAMPED_FLOAT_TO_CHAN(color[0], v[0]);
    UNCLAMPED_FLOAT_TO_CHAN(color[1], v[1]);
    UNCLAMPED_FLOAT_TO_CHAN(color[2], v[2]);
-   color[3] = 255;
+   color[3] = CHAN_MAX;
 }
 
 void _mesa_noop_TexCoord1f( GLfloat a )
diff --git a/src/mesa/main/attrib.c b/src/mesa/main/attrib.c
index e669ff11d59..2a335625a44 100644
--- a/src/mesa/main/attrib.c
+++ b/src/mesa/main/attrib.c
@@ -1,4 +1,4 @@
-/* $Id: attrib.c,v 1.40 2001/01/23 23:39:36 brianp Exp $ */
+/* $Id: attrib.c,v 1.41 2001/01/24 00:04:58 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -589,11 +589,7 @@ _mesa_PopAttrib(void)
 		  ctx->Driver.LogicOpcode( ctx, ctx->Color.LogicOp );
                }
                if (ctx->Visual.rgbMode) {
-                  GLchan r = (GLint) (ctx->Color.ClearColor[0] * CHAN_MAXF);
-                  GLchan g = (GLint) (ctx->Color.ClearColor[1] * CHAN_MAXF);
-                  GLchan b = (GLint) (ctx->Color.ClearColor[2] * CHAN_MAXF);
-                  GLchan a = (GLint) (ctx->Color.ClearColor[3] * CHAN_MAXF);
-                  (*ctx->Driver.ClearColor)( ctx, r, g, b, a );
+                  (*ctx->Driver.ClearColor)(ctx, ctx->Color.ClearColor);
                   if ((ctx->Color.AlphaFunc != oldAlphaFunc ||
                        ctx->Color.AlphaRef != oldAlphaRef) &&
                       ctx->Driver.AlphaFunc)
diff --git a/src/mesa/main/buffers.c b/src/mesa/main/buffers.c
index 410524e3352..0699e74b90d 100644
--- a/src/mesa/main/buffers.c
+++ b/src/mesa/main/buffers.c
@@ -1,4 +1,4 @@
-/* $Id: buffers.c,v 1.23 2001/01/23 23:39:36 brianp Exp $ */
+/* $Id: buffers.c,v 1.24 2001/01/24 00:04:58 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -31,6 +31,7 @@
 #include "glheader.h"
 #include "accum.h"
 #include "buffers.h"
+#include "colormac.h"
 #include "context.h"
 #include "depth.h"
 #include "enums.h"
@@ -51,14 +52,13 @@ _mesa_ClearIndex( GLfloat c )
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   if (ctx->Color.ClearIndex == (GLuint)c)
+   if (ctx->Color.ClearIndex == (GLuint) c)
       return;
    
-
    FLUSH_VERTICES(ctx, _NEW_COLOR);
    ctx->Color.ClearIndex = (GLuint) c;
 
-   if (!ctx->Visual.rgbMode) {
+   if (!ctx->Visual.rgbMode && ctx->Driver.ClearIndex) {
       /* it's OK to call glClearIndex in RGBA mode but it should be a NOP */
       (*ctx->Driver.ClearIndex)( ctx, ctx->Color.ClearIndex );
    }
@@ -67,38 +67,31 @@ _mesa_ClearIndex( GLfloat c )
 
 
 void
-_mesa_ClearColor( GLclampf red, GLclampf green,
-                  GLclampf blue, GLclampf alpha )
+_mesa_ClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
 {
-   GLfloat tmp[4];
+   GLchan tmp[4];
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   tmp[0] = CLAMP( red,   0.0, 1.0 );
-   tmp[1] = CLAMP( green, 0.0, 1.0 );
-   tmp[2] = CLAMP( blue,  0.0, 1.0 );
-   tmp[3] = CLAMP( alpha, 0.0, 1.0 );
+   UNCLAMPED_FLOAT_TO_CHAN(tmp[0], red);
+   UNCLAMPED_FLOAT_TO_CHAN(tmp[1], green);
+   UNCLAMPED_FLOAT_TO_CHAN(tmp[2], blue);
+   UNCLAMPED_FLOAT_TO_CHAN(tmp[3], alpha);
 
    if (TEST_EQ_4V(tmp, ctx->Color.ClearColor))
       return;
 
    FLUSH_VERTICES(ctx, _NEW_COLOR);
-   COPY_4FV( ctx->Color.ClearColor, tmp );
-
-   if (ctx->Visual.rgbMode) {
-      GLchan r = (GLint) (ctx->Color.ClearColor[0] * CHAN_MAXF);
-      GLchan g = (GLint) (ctx->Color.ClearColor[1] * CHAN_MAXF);
-      GLchan b = (GLint) (ctx->Color.ClearColor[2] * CHAN_MAXF);
-      GLchan a = (GLint) (ctx->Color.ClearColor[3] * CHAN_MAXF);
-      (*ctx->Driver.ClearColor)( ctx, r, g, b, a );
+   COPY_CHAN4(ctx->Color.ClearColor, tmp);
+
+   if (ctx->Visual.rgbMode && ctx->Driver.ClearColor) {
+      /* it's OK to call glClearColor in CI mode but it should be a NOP */
+      (*ctx->Driver.ClearColor)(ctx, ctx->Color.ClearColor);
    }
 }
 
 
 
-
-
-
 void
 _mesa_Clear( GLbitfield mask )
 {
diff --git a/src/mesa/main/context.c b/src/mesa/main/context.c
index 736d13a2e96..64ac160c359 100644
--- a/src/mesa/main/context.c
+++ b/src/mesa/main/context.c
@@ -1,4 +1,4 @@
-/* $Id: context.c,v 1.117 2001/01/23 23:39:36 brianp Exp $ */
+/* $Id: context.c,v 1.118 2001/01/24 00:04:58 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -792,7 +792,7 @@ init_attrib_groups( GLcontext *ctx )
    ctx->Color.ColorMask[2] = 0xff;
    ctx->Color.ColorMask[3] = 0xff;
    ctx->Color.ClearIndex = 0;
-   ASSIGN_4V( ctx->Color.ClearColor, 0.0, 0.0, 0.0, 0.0 );
+   ASSIGN_4V( ctx->Color.ClearColor, 0, 0, 0, 0 );
    ctx->Color.DrawBuffer = GL_FRONT;
    ctx->Color.AlphaEnabled = GL_FALSE;
    ctx->Color.AlphaFunc = GL_ALWAYS;
diff --git a/src/mesa/main/dd.h b/src/mesa/main/dd.h
index 86220bdf4ad..e529cdde2ba 100644
--- a/src/mesa/main/dd.h
+++ b/src/mesa/main/dd.h
@@ -1,4 +1,4 @@
-/* $Id: dd.h,v 1.47 2001/01/09 00:02:55 brianp Exp $ */
+/* $Id: dd.h,v 1.48 2001/01/24 00:04:58 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -161,19 +161,6 @@ struct dd_function_table {
     * LineFunc, or TriangleFunc).
     */
 
-   void (*ClearIndex)( GLcontext *ctx, GLuint index );
-   /*
-    * Called whenever glClearIndex() is called.  Set the index for clearing
-    * the color buffer when in color index mode.
-    */
-
-   void (*ClearColor)( GLcontext *ctx, GLchan red, GLchan green,
-                                        GLchan blue, GLchan alpha );
-   /*
-    * Called whenever glClearColor() is called.  Set the color for clearing
-    * the color buffer when in RGBA mode.
-    */
-
    GLbitfield (*Clear)( GLcontext *ctx, GLbitfield mask, GLboolean all,
                         GLint x, GLint y, GLint width, GLint height );
    /* Clear the color/depth/stencil/accum buffer(s).
@@ -754,7 +741,9 @@ struct dd_function_table {
    void (*BlendFuncSeparate)(GLcontext *ctx,
                              GLenum sfactorRGB, GLenum dfactorRGB,
                              GLenum sfactorA, GLenum dfactorA);
+   void (*ClearColor)(GLcontext *ctx, const GLchan color[4]);
    void (*ClearDepth)(GLcontext *ctx, GLclampd d);
+   void (*ClearIndex)(GLcontext *ctx, GLuint index);
    void (*ClearStencil)(GLcontext *ctx, GLint s);
    void (*ColorMask)(GLcontext *ctx, GLboolean rmask, GLboolean gmask,
                      GLboolean bmask, GLboolean amask );
diff --git a/src/mesa/main/get.c b/src/mesa/main/get.c
index ecbb16f0433..d9b046556f3 100644
--- a/src/mesa/main/get.c
+++ b/src/mesa/main/get.c
@@ -1,4 +1,4 @@
-/* $Id: get.c,v 1.50 2001/01/23 23:39:36 brianp Exp $ */
+/* $Id: get.c,v 1.51 2001/01/24 00:04:58 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -200,10 +200,10 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          *params = ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
          break;
       case GL_COLOR_CLEAR_VALUE:
-         params[0] = FLOAT_TO_BOOL(ctx->Color.ClearColor[0]);
-         params[1] = FLOAT_TO_BOOL(ctx->Color.ClearColor[1]);
-         params[2] = FLOAT_TO_BOOL(ctx->Color.ClearColor[2]);
-         params[3] = FLOAT_TO_BOOL(ctx->Color.ClearColor[3]);
+         params[0] = ctx->Color.ClearColor[0] ? GL_TRUE : GL_FALSE;
+         params[1] = ctx->Color.ClearColor[1] ? GL_TRUE : GL_FALSE;
+         params[2] = ctx->Color.ClearColor[2] ? GL_TRUE : GL_FALSE;
+         params[3] = ctx->Color.ClearColor[3] ? GL_TRUE : GL_FALSE;
          break;
       case GL_COLOR_MATERIAL:
          *params = ctx->Light.ColorMaterialEnabled;
@@ -1438,10 +1438,10 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
          *params = (GLdouble) ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
          break;
       case GL_COLOR_CLEAR_VALUE:
-         params[0] = (GLdouble) ctx->Color.ClearColor[0];
-         params[1] = (GLdouble) ctx->Color.ClearColor[1];
-         params[2] = (GLdouble) ctx->Color.ClearColor[2];
-         params[3] = (GLdouble) ctx->Color.ClearColor[3];
+         params[0] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[0]);
+         params[1] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[1]);
+         params[2] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[2]);
+         params[3] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[3]);
          break;
       case GL_COLOR_MATERIAL:
          *params = (GLdouble) ctx->Light.ColorMaterialEnabled;
@@ -2676,10 +2676,10 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
          *params = (GLfloat) ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
          break;
       case GL_COLOR_CLEAR_VALUE:
-         params[0] = (GLfloat) ctx->Color.ClearColor[0];
-         params[1] = (GLfloat) ctx->Color.ClearColor[1];
-         params[2] = (GLfloat) ctx->Color.ClearColor[2];
-         params[3] = (GLfloat) ctx->Color.ClearColor[3];
+         params[0] = CHAN_TO_FLOAT(ctx->Color.ClearColor[0]);
+         params[1] = CHAN_TO_FLOAT(ctx->Color.ClearColor[1]);
+         params[2] = CHAN_TO_FLOAT(ctx->Color.ClearColor[2]);
+         params[3] = CHAN_TO_FLOAT(ctx->Color.ClearColor[3]);
          break;
       case GL_COLOR_MATERIAL:
          *params = (GLfloat) ctx->Light.ColorMaterialEnabled;
@@ -3890,10 +3890,10 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          *params = (GLint) ctx->Transform.ClipEnabled[i];
          break;
       case GL_COLOR_CLEAR_VALUE:
-         params[0] = FLOAT_TO_INT( ctx->Color.ClearColor[0] );
-         params[1] = FLOAT_TO_INT( ctx->Color.ClearColor[1] );
-         params[2] = FLOAT_TO_INT( ctx->Color.ClearColor[2] );
-         params[3] = FLOAT_TO_INT( ctx->Color.ClearColor[3] );
+         params[0] = FLOAT_TO_INT( CHAN_TO_FLOAT(ctx->Color.ClearColor[0]) );
+         params[1] = FLOAT_TO_INT( CHAN_TO_FLOAT(ctx->Color.ClearColor[1]) );
+         params[2] = FLOAT_TO_INT( CHAN_TO_FLOAT(ctx->Color.ClearColor[2]) );
+         params[3] = FLOAT_TO_INT( CHAN_TO_FLOAT(ctx->Color.ClearColor[3]) );
          break;
       case GL_COLOR_MATERIAL:
          *params = (GLint) ctx->Light.ColorMaterialEnabled;
diff --git a/src/mesa/main/macros.h b/src/mesa/main/macros.h
index a8694a96c39..9a3f227758f 100644
--- a/src/mesa/main/macros.h
+++ b/src/mesa/main/macros.h
@@ -1,4 +1,4 @@
-/* $Id: macros.h,v 1.17 2001/01/08 04:09:41 keithw Exp $ */
+/* $Id: macros.h,v 1.18 2001/01/24 00:04:58 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -73,6 +73,7 @@
 #define STRIDE_F(p, i)  (p = (GLfloat *)((GLubyte *)p + i))
 #define STRIDE_UI(p, i)  (p = (GLuint *)((GLubyte *)p + i))
 #define STRIDE_4UB(p, i)  (p = (GLubyte (*)[4])((GLubyte *)p + i))
+#define STRIDE_4CHAN(p, i)  (p = (GLchan (*)[4])((GLchan *)p + i))
 #define STRIDE_T(p, t, i)  (p = (t)((GLubyte *)p + i))
 
 
diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h
index 66d085ba816..80721c50a90 100644
--- a/src/mesa/main/mtypes.h
+++ b/src/mesa/main/mtypes.h
@@ -1,4 +1,4 @@
-/* $Id: mtypes.h,v 1.14 2001/01/23 23:39:36 brianp Exp $ */
+/* $Id: mtypes.h,v 1.15 2001/01/24 00:04:58 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -265,7 +265,7 @@ struct gl_accum_attrib {
 
 struct gl_colorbuffer_attrib {
    GLuint ClearIndex;			/* Index to use for glClear */
-   GLfloat ClearColor[4];		/* Color to use for glClear */
+   GLchan ClearColor[4];		/* Color to use for glClear */
 
    GLuint IndexMask;			/* Color index write mask */
    GLubyte ColorMask[4];		/* Each flag is 0xff or 0x0 */
diff --git a/src/mesa/main/texstate.c b/src/mesa/main/texstate.c
index 9bf4bbb3c87..ced3940b651 100644
--- a/src/mesa/main/texstate.c
+++ b/src/mesa/main/texstate.c
@@ -1,4 +1,4 @@
-/* $Id: texstate.c,v 1.27 2001/01/06 22:46:13 gareth Exp $ */
+/* $Id: texstate.c,v 1.28 2001/01/24 00:04:58 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -743,10 +743,10 @@ _mesa_TexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
          }
          break;
       case GL_TEXTURE_BORDER_COLOR:
-         texObj->BorderColor[0] = (GLchan) CLAMP((GLint)(params[0]*CHAN_MAXF), 0, CHAN_MAX);
-         texObj->BorderColor[1] = (GLchan) CLAMP((GLint)(params[1]*CHAN_MAXF), 0, CHAN_MAX);
-         texObj->BorderColor[2] = (GLchan) CLAMP((GLint)(params[2]*CHAN_MAXF), 0, CHAN_MAX);
-         texObj->BorderColor[3] = (GLchan) CLAMP((GLint)(params[3]*CHAN_MAXF), 0, CHAN_MAX);
+         UNCLAMPED_FLOAT_TO_CHAN(texObj->BorderColor[0], params[0]);
+         UNCLAMPED_FLOAT_TO_CHAN(texObj->BorderColor[1], params[1]);
+         UNCLAMPED_FLOAT_TO_CHAN(texObj->BorderColor[2], params[2]);
+         UNCLAMPED_FLOAT_TO_CHAN(texObj->BorderColor[3], params[3]);
          break;
       case GL_TEXTURE_MIN_LOD:
          texObj->MinLod = params[0];
diff --git a/src/mesa/main/texutil.h b/src/mesa/main/texutil.h
index 6790d9b3354..3cdd5545500 100644
--- a/src/mesa/main/texutil.h
+++ b/src/mesa/main/texutil.h
@@ -1,4 +1,4 @@
-/* $Id: texutil.h,v 1.6 2000/11/22 07:32:17 joukj Exp $ */
+/* $Id: texutil.h,v 1.7 2001/01/24 00:04:58 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -81,7 +81,7 @@ _mesa_unconvert_teximage(MesaIntTexFormat srcFormat,
                          GLint srcWidth, GLint srcHeight,
                          const GLvoid *srcImage, GLint srcRowStride,
                          GLint dstWidth, GLint dstHeight,
-                         GLenum dstFormat, GLchan *dstImage);
+                         GLenum dstFormat, GLubyte *dstImage);
 
 
 extern void
diff --git a/src/mesa/math/m_trans_tmp.h b/src/mesa/math/m_trans_tmp.h
index e7d8a880719..1b20266fbce 100644
--- a/src/mesa/math/m_trans_tmp.h
+++ b/src/mesa/math/m_trans_tmp.h
@@ -1,10 +1,10 @@
-/* $Id: m_trans_tmp.h,v 1.2 2001/01/02 22:02:52 brianp Exp $ */
+/* $Id: m_trans_tmp.h,v 1.3 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
  * Version:  3.5
  * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  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"),
@@ -104,9 +104,9 @@ static void DEST_1F( GLfloat *t,
 
 #ifdef DEST_4UB
 static void DEST_4UB( GLubyte (*t)[4],
-		      CONST void *ptr,
-		      GLuint stride,
-		      ARGS)
+                      CONST void *ptr,
+                      GLuint stride,
+                      ARGS)
 {
    const GLubyte *f = (GLubyte *) ptr + SRC_START * stride;
    const GLubyte *first = f;
@@ -126,6 +126,30 @@ static void DEST_4UB( GLubyte (*t)[4],
 #endif
 
 
+#ifdef DEST_4US
+static void DEST_4US( GLushort (*t)[4],
+                      CONST void *ptr,
+                      GLuint stride,
+                      ARGS)
+{
+   const GLushort *f = (GLushort *) ptr + SRC_START * stride;
+   const GLushort *first = f;
+   GLuint i;
+   (void) start;
+   (void) first;
+   for (i = DST_START ; i < n ; i++, NEXT_F) {
+      CHECK {
+         NEXT_F2;
+	 if (SZ >= 1) TRX_US(t[i][0], f, 0);
+	 if (SZ >= 2) TRX_US(t[i][1], f, 1);
+	 if (SZ >= 3) TRX_US(t[i][2], f, 2); 
+	 if (SZ == 4) TRX_US(t[i][3], f, 3); else t[i][3] = 65535;
+      }
+   }
+}
+#endif
+
+
 #ifdef DEST_1UB
 static void DEST_1UB( GLubyte *t,
 		      CONST void *ptr,
@@ -190,6 +214,9 @@ static void INIT(void)
 #ifdef DEST_4UB
    TAB(_4ub)[SZ][SRC_IDX] = DEST_4UB;
 #endif
+#ifdef DEST_4US
+   TAB(_4us)[SZ][SRC_IDX] = DEST_4US;
+#endif
 #ifdef DEST_4F
    TAB(_4f)[SZ][SRC_IDX] = DEST_4F;
 #endif
@@ -201,6 +228,7 @@ static void INIT(void)
 #undef DEST_1UI
 #undef DEST_1UB
 #undef DEST_4UB
+#undef DEST_4US
 #undef DEST_3F
 #undef DEST_4F
 #undef DEST_1F
diff --git a/src/mesa/math/m_translate.c b/src/mesa/math/m_translate.c
index 1f22b5a0bcb..0eb2ee8281f 100644
--- a/src/mesa/math/m_translate.c
+++ b/src/mesa/math/m_translate.c
@@ -1,10 +1,10 @@
-/* $Id: m_translate.c,v 1.3 2001/01/02 22:02:52 brianp Exp $ */
+/* $Id: m_translate.c,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
+ * Version:  3.5
  * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  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"),
@@ -57,10 +57,16 @@ typedef void (*trans_1ub_func)(GLubyte *to,
 			       GLuint n );
 
 typedef void (*trans_4ub_func)(GLubyte (*to)[4],
-			       CONST void *ptr,
-			       GLuint stride,
-			       GLuint start,
-			       GLuint n );
+                               CONST void *ptr,
+                               GLuint stride,
+                               GLuint start,
+                               GLuint n );
+
+typedef void (*trans_4us_func)(GLushort (*to)[4],
+                               CONST void *ptr,
+                               GLuint stride,
+                               GLuint start,
+                               GLuint n );
 
 typedef void (*trans_4f_func)(GLfloat (*to)[4],
 			      CONST void *ptr,
@@ -90,6 +96,7 @@ static trans_1ui_func _math_trans_1ui_tab[MAX_TYPES];
 static trans_1ub_func _math_trans_1ub_tab[MAX_TYPES];
 static trans_3f_func  _math_trans_3f_tab[MAX_TYPES];
 static trans_4ub_func _math_trans_4ub_tab[5][MAX_TYPES];
+static trans_4us_func _math_trans_4us_tab[5][MAX_TYPES];
 static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 
 
@@ -110,13 +117,12 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 
 /* GL_BYTE
  */
-#define BYTE_TO_UBYTE(b)   (b < 0 ? 0 : (GLubyte) b)
-
 #define SRC GLbyte
 #define SRC_IDX TYPE_IDX(GL_BYTE)
 #define TRX_3F(f,n)   BYTE_TO_FLOAT( PTR_ELT(f,n) )
 #define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
 #define TRX_UB(ub, f,n)  ub = BYTE_TO_UBYTE( PTR_ELT(f,n) )
+#define TRX_US(ch, f,n)  ch = BYTE_TO_USHORT( PTR_ELT(f,n) )
 #define TRX_UI(f,n)  (PTR_ELT(f,n) < 0 ? 0 : (GLuint)  PTR_ELT(f,n))
 
 
@@ -124,12 +130,14 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #define INIT init_trans_4_GLbyte_raw
 #define DEST_4F trans_4_GLbyte_4f_raw
 #define DEST_4UB trans_4_GLbyte_4ub_raw
+#define DEST_4US trans_4_GLbyte_4us_raw
 #include "m_trans_tmp.h"
 
 #define SZ 3
 #define INIT init_trans_3_GLbyte_raw
 #define DEST_4F trans_3_GLbyte_4f_raw
 #define DEST_4UB trans_3_GLbyte_4ub_raw
+#define DEST_4US trans_3_GLbyte_4us_raw
 #define DEST_3F trans_3_GLbyte_3f_raw
 #include "m_trans_tmp.h"
 
@@ -149,9 +157,11 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #undef TRX_3F
 #undef TRX_4F
 #undef TRX_UB
+#undef TRX_US
 #undef TRX_UI
 #undef SRC_IDX
 
+
 /* GL_UNSIGNED_BYTE
  */
 #define SRC GLubyte
@@ -159,6 +169,7 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #define TRX_3F(f,n)		/* unused */
 #define TRX_4F(f,n)		/* unused */
 #define TRX_UB(ub, f,n)	     ub = PTR_ELT(f,n)
+#define TRX_US(us, f,n)      us = UBYTE_TO_USHORT(PTR_ELT(f,n))
 #define TRX_UI(f,n)          (GLuint)PTR_ELT(f,n)
 
 /* 4ub->4ub handled in special case below.
@@ -167,6 +178,7 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #define SZ 3
 #define INIT init_trans_3_GLubyte_raw
 #define DEST_4UB trans_3_GLubyte_4ub_raw
+#define DEST_4US trans_3_GLubyte_4us_raw
 #include "m_trans_tmp.h"
 
 
@@ -181,6 +193,7 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #undef TRX_3F
 #undef TRX_4F
 #undef TRX_UB
+#undef TRX_US
 #undef TRX_UI
 
 
@@ -191,6 +204,7 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #define TRX_3F(f,n)   SHORT_TO_FLOAT( PTR_ELT(f,n) )
 #define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
 #define TRX_UB(ub, f,n)  ub = SHORT_TO_UBYTE(PTR_ELT(f,n))
+#define TRX_US(us, f,n)  us = SHORT_TO_USHORT(PTR_ELT(f,n))
 #define TRX_UI(f,n)  (PTR_ELT(f,n) < 0 ? 0 : (GLuint)  PTR_ELT(f,n))
 
 
@@ -198,12 +212,14 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #define INIT init_trans_4_GLshort_raw
 #define DEST_4F trans_4_GLshort_4f_raw
 #define DEST_4UB trans_4_GLshort_4ub_raw
+#define DEST_4US trans_4_GLshort_4us_raw
 #include "m_trans_tmp.h"
 
 #define SZ 3
 #define INIT init_trans_3_GLshort_raw
 #define DEST_4F trans_3_GLshort_4f_raw
 #define DEST_4UB trans_3_GLshort_4ub_raw
+#define DEST_4US trans_3_GLshort_4us_raw
 #define DEST_3F trans_3_GLshort_3f_raw
 #include "m_trans_tmp.h"
 
@@ -225,6 +241,7 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #undef TRX_3F
 #undef TRX_4F
 #undef TRX_UB
+#undef TRX_US
 #undef TRX_UI
 
 
@@ -235,6 +252,7 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #define TRX_3F(f,n)   USHORT_TO_FLOAT( PTR_ELT(f,n) )
 #define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
 #define TRX_UB(ub,f,n)  ub = (GLubyte) (PTR_ELT(f,n) >> 8)
+#define TRX_US(us,f,n)  us = (GLushort) (PTR_ELT(f,n) >> 8)
 #define TRX_UI(f,n)  (GLuint)   PTR_ELT(f,n)
 
 
@@ -242,12 +260,14 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #define INIT init_trans_4_GLushort_raw
 #define DEST_4F trans_4_GLushort_4f_raw
 #define DEST_4UB trans_4_GLushort_4ub_raw
+#define DEST_4US trans_4_GLushort_4us_raw
 #include "m_trans_tmp.h"
 
 #define SZ 3
 #define INIT init_trans_3_GLushort_raw
 #define DEST_4F trans_3_GLushort_4f_raw
 #define DEST_4UB trans_3_GLushort_4ub_raw
+#define DEST_4US trans_3_GLushort_4us_raw
 #define DEST_3F trans_3_GLushort_3f_raw
 #include "m_trans_tmp.h"
 
@@ -268,6 +288,7 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #undef TRX_3F
 #undef TRX_4F
 #undef TRX_UB
+#undef TRX_US
 #undef TRX_UI
 
 
@@ -278,6 +299,7 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #define TRX_3F(f,n)   INT_TO_FLOAT( PTR_ELT(f,n) )
 #define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
 #define TRX_UB(ub, f,n)  ub = INT_TO_UBYTE(PTR_ELT(f,n))
+#define TRX_US(us, f,n)  us = INT_TO_USHORT(PTR_ELT(f,n))
 #define TRX_UI(f,n)  (PTR_ELT(f,n) < 0 ? 0 : (GLuint)  PTR_ELT(f,n))
 
 
@@ -285,12 +307,14 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #define INIT init_trans_4_GLint_raw
 #define DEST_4F trans_4_GLint_4f_raw
 #define DEST_4UB trans_4_GLint_4ub_raw
+#define DEST_4US trans_4_GLint_4us_raw
 #include "m_trans_tmp.h"
 
 #define SZ 3
 #define INIT init_trans_3_GLint_raw
 #define DEST_4F trans_3_GLint_4f_raw
 #define DEST_4UB trans_3_GLint_4ub_raw
+#define DEST_4US trans_3_GLint_4us_raw
 #define DEST_3F trans_3_GLint_3f_raw
 #include "m_trans_tmp.h"
 
@@ -312,6 +336,7 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #undef TRX_3F
 #undef TRX_4F
 #undef TRX_UB
+#undef TRX_US
 #undef TRX_UI
 
 
@@ -322,6 +347,7 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #define TRX_3F(f,n)   INT_TO_FLOAT( PTR_ELT(f,n) )
 #define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
 #define TRX_UB(ub, f,n)  ub = (GLubyte) (PTR_ELT(f,n) >> 24)
+#define TRX_US(us, f,n)  us = (GLshort) (PTR_ELT(f,n) >> 16)
 #define TRX_UI(f,n)		PTR_ELT(f,n)
 
 
@@ -329,12 +355,14 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #define INIT init_trans_4_GLuint_raw
 #define DEST_4F trans_4_GLuint_4f_raw
 #define DEST_4UB trans_4_GLuint_4ub_raw
+#define DEST_4US trans_4_GLuint_4us_raw
 #include "m_trans_tmp.h"
 
 #define SZ 3
 #define INIT init_trans_3_GLuint_raw
 #define DEST_4F trans_3_GLuint_4f_raw
 #define DEST_4UB trans_3_GLuint_4ub_raw
+#define DEST_4US trans_3_GLuint_4us_raw
 #define DEST_3F trans_3_GLuint_3f_raw
 #include "m_trans_tmp.h"
 
@@ -355,6 +383,7 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #undef TRX_3F
 #undef TRX_4F
 #undef TRX_UB
+#undef TRX_US
 #undef TRX_UI
 
 
@@ -364,7 +393,8 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #define SRC_IDX TYPE_IDX(GL_DOUBLE)
 #define TRX_3F(f,n)   PTR_ELT(f,n)
 #define TRX_4F(f,n)   PTR_ELT(f,n)
-#define TRX_UB(ub,f,n) UNCLAMPED_FLOAT_TO_CHAN(ub, PTR_ELT(f,n))
+#define TRX_UB(ub,f,n) UNCLAMPED_FLOAT_TO_UBYTE(ub, PTR_ELT(f,n))
+#define TRX_US(us,f,n) UNCLAMPED_FLOAT_TO_USHORT(us, PTR_ELT(f,n))
 #define TRX_UI(f,n)  (GLuint) (GLint) PTR_ELT(f,n)
 #define TRX_1F(f,n)   PTR_ELT(f,n)
 
@@ -373,12 +403,14 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #define INIT init_trans_4_GLdouble_raw
 #define DEST_4F trans_4_GLdouble_4f_raw
 #define DEST_4UB trans_4_GLdouble_4ub_raw
+#define DEST_4US trans_4_GLdouble_4us_raw
 #include "m_trans_tmp.h"
 
 #define SZ 3
 #define INIT init_trans_3_GLdouble_raw
 #define DEST_4F trans_3_GLdouble_4f_raw
 #define DEST_4UB trans_3_GLdouble_4ub_raw
+#define DEST_4US trans_3_GLdouble_4us_raw
 #define DEST_3F trans_3_GLdouble_3f_raw
 #include "m_trans_tmp.h"
 
@@ -405,6 +437,7 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #define SZ 4
 #define INIT init_trans_4_GLfloat_raw 
 #define DEST_4UB trans_4_GLfloat_4ub_raw 
+#define DEST_4US trans_4_GLfloat_4us_raw 
 #define DEST_4F  trans_4_GLfloat_4f_raw
 #include "m_trans_tmp.h"
 
@@ -412,6 +445,7 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #define INIT init_trans_3_GLfloat_raw
 #define DEST_4F  trans_3_GLfloat_4f_raw
 #define DEST_4UB trans_3_GLfloat_4ub_raw
+#define DEST_4US trans_3_GLfloat_4us_raw
 #define DEST_3F trans_3_GLfloat_3f_raw
 #include "m_trans_tmp.h"
 
@@ -434,13 +468,14 @@ static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
 #undef TRX_3F
 #undef TRX_4F
 #undef TRX_UB
+#undef TRX_US
 #undef TRX_UI
 
 
-static void trans_4_GLubyte_4ub_raw (GLubyte (*t)[4],
-				     CONST void *Ptr,
-				     GLuint stride,
-				     ARGS )
+static void trans_4_GLubyte_4ub_raw(GLubyte (*t)[4],
+				    CONST void *Ptr,
+				    GLuint stride,
+				    ARGS )
 {
    const GLubyte *f = (GLubyte *) Ptr + SRC_START * stride;
    GLuint i;
@@ -468,6 +503,7 @@ static void init_translate_raw(void)
    MEMSET( TAB(_1ub), 0, sizeof(TAB(_1ub)) );
    MEMSET( TAB(_3f),  0, sizeof(TAB(_3f)) );
    MEMSET( TAB(_4ub), 0, sizeof(TAB(_4ub)) );
+   MEMSET( TAB(_4us), 0, sizeof(TAB(_4us)) );
    MEMSET( TAB(_4f),  0, sizeof(TAB(_4f)) );
 
    TAB(_4ub)[4][TYPE_IDX(GL_UNSIGNED_BYTE)] = trans_4_GLubyte_4ub_raw;
@@ -567,6 +603,17 @@ void _math_trans_4ub(GLubyte (*to)[4],
    _math_trans_4ub_tab[size][TYPE_IDX(type)]( to, ptr, stride, start, n ); 
 }
 
+void _math_trans_4us(GLushort (*to)[4],
+		     CONST void *ptr,
+		     GLuint stride,
+		     GLenum type,
+		     GLuint size,
+		     GLuint start,
+		     GLuint n )
+{
+   _math_trans_4us_tab[size][TYPE_IDX(type)]( to, ptr, stride, start, n ); 
+}
+
 void _math_trans_4f(GLfloat (*to)[4],
 		    CONST void *ptr,
 		    GLuint stride,
diff --git a/src/mesa/math/m_translate.h b/src/mesa/math/m_translate.h
index b6db1f60480..3151e458176 100644
--- a/src/mesa/math/m_translate.h
+++ b/src/mesa/math/m_translate.h
@@ -1,10 +1,10 @@
-/* $Id: m_translate.h,v 1.3 2000/12/26 05:09:31 keithw Exp $ */
+/* $Id: m_translate.h,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.1
+ * Version:  3.5
  * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  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"),
@@ -61,6 +61,14 @@ extern void _math_trans_4ub(GLubyte (*to)[4],
 			    GLuint start,
 			    GLuint n );
 
+extern void _math_trans_4us(GLushort (*to)[4],
+			    CONST void *ptr,
+			    GLuint stride,
+			    GLenum type,
+			    GLuint size,
+			    GLuint start,
+			    GLuint n );
+
 extern void _math_trans_4f(GLfloat (*to)[4],
 			   CONST void *ptr,
 			   GLuint stride,
diff --git a/src/mesa/math/m_vector.c b/src/mesa/math/m_vector.c
index e582ccce37e..7fa2b726e4e 100644
--- a/src/mesa/math/m_vector.c
+++ b/src/mesa/math/m_vector.c
@@ -1,10 +1,10 @@
-/* $Id: m_vector.c,v 1.2 2000/12/26 05:09:31 keithw Exp $ */
+/* $Id: m_vector.c,v 1.3 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
  * Version:  3.5
  * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  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"),
@@ -115,6 +115,15 @@ void gl_vector4ub_init( GLvector4ub *v, GLuint flags, GLubyte (*storage)[4] )
    v->flags = flags ;
 }
 
+void gl_vector4us_init( GLvector4us *v, GLuint flags, GLushort (*storage)[4] )
+{
+   v->stride = 4 * sizeof(GLushort);
+   v->data = storage;
+   v->start = (GLushort *) storage;
+   v->count = 0;
+   v->flags = flags ;
+}
+
 void gl_vector1ub_init( GLvector1ub *v, GLuint flags, GLubyte *storage )
 {
    v->stride = 1 * sizeof(GLubyte);
@@ -189,6 +198,17 @@ void gl_vector4ub_alloc( GLvector4ub *v, GLuint flags, GLuint count,
    v->flags = flags | VEC_MALLOC ;
 }
 
+void gl_vector4us_alloc( GLvector4us *v, GLuint flags, GLuint count,
+                         GLuint alignment )
+{
+   v->stride = 4 * sizeof(GLushort);
+   v->storage = ALIGN_MALLOC( count * 4 * sizeof(GLushort), alignment );
+   v->start = (GLushort *) v->storage;
+   v->data = (GLushort (*)[4]) v->storage;
+   v->count = 0;
+   v->flags = flags | VEC_MALLOC ;
+}
+
 void gl_vector1ub_alloc( GLvector1ub *v, GLuint flags, GLuint count,
 			 GLuint alignment )
 {
@@ -264,6 +284,17 @@ void gl_vector4ub_free( GLvector4ub *v )
    }
 }
 
+void gl_vector4us_free( GLvector4us *v )
+{
+   if (v->flags & VEC_MALLOC) {
+      ALIGN_FREE( v->storage );
+      v->data = NULL;
+      v->start = NULL;
+      v->storage = NULL;
+      v->flags &= ~VEC_MALLOC;
+   }
+}
+
 void gl_vector1ub_free( GLvector1ub *v )
 {
    if (v->flags & VEC_MALLOC) {
diff --git a/src/mesa/math/m_vector.h b/src/mesa/math/m_vector.h
index 24a392a12b4..12200f960c4 100644
--- a/src/mesa/math/m_vector.h
+++ b/src/mesa/math/m_vector.h
@@ -1,10 +1,10 @@
-/* $Id: m_vector.h,v 1.2 2000/12/26 05:09:31 keithw Exp $ */
+/* $Id: m_vector.h,v 1.3 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
  * Version:  3.5
  * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  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"),
@@ -133,6 +133,25 @@ extern void gl_vector4ub_free( GLvector4ub * );
 
 
 
+/* For 4 * GLushort rgba values.
+ */
+typedef struct {
+   GLushort (*data)[4];
+   GLushort *start;
+   GLuint count;
+   GLuint stride;		 
+   GLuint flags; 
+   void *storage;
+} GLvector4us;
+
+extern void gl_vector4us_init( GLvector4us *v, GLuint flags, 
+                               GLushort (*storage)[4] );
+extern void gl_vector4us_alloc( GLvector4us *v, GLuint flags, GLuint count,
+                                GLuint alignment );
+extern void gl_vector4us_free( GLvector4us * );
+
+
+
 
 /* For 1ub values, eg edgeflag.
  */
diff --git a/src/mesa/swrast/s_alphabuf.c b/src/mesa/swrast/s_alphabuf.c
index 0da11a5f250..9002d9099ac 100644
--- a/src/mesa/swrast/s_alphabuf.c
+++ b/src/mesa/swrast/s_alphabuf.c
@@ -1,4 +1,4 @@
-/* $Id: s_alphabuf.c,v 1.3 2001/01/23 23:39:37 brianp Exp $ */
+/* $Id: s_alphabuf.c,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -136,7 +136,7 @@ _mesa_alloc_alpha_buffers( GLcontext *ctx )
 void
 _mesa_clear_alpha_buffers( GLcontext *ctx )
 {
-   const GLchan aclear = (GLint) (ctx->Color.ClearColor[3] * CHAN_MAXF);
+   const GLchan aclear = ctx->Color.ClearColor[3];
    GLuint bufferBit;
 
    ASSERT(ctx->DrawBuffer->UseSoftwareAlphaBuffers);
diff --git a/src/mesa/swrast/s_buffers.c b/src/mesa/swrast/s_buffers.c
index 46ffe8cc90c..bff5da00886 100644
--- a/src/mesa/swrast/s_buffers.c
+++ b/src/mesa/swrast/s_buffers.c
@@ -1,4 +1,4 @@
-/* $Id: s_buffers.c,v 1.3 2001/01/23 23:39:37 brianp Exp $ */
+/* $Id: s_buffers.c,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -51,15 +51,15 @@ clear_color_buffer_with_masking( GLcontext *ctx )
 
    if (ctx->Visual.rgbMode) {
       /* RGBA mode */
-      const GLchan r = (GLint) (ctx->Color.ClearColor[0] * CHAN_MAXF);
-      const GLchan g = (GLint) (ctx->Color.ClearColor[1] * CHAN_MAXF);
-      const GLchan b = (GLint) (ctx->Color.ClearColor[2] * CHAN_MAXF);
-      const GLchan a = (GLint) (ctx->Color.ClearColor[3] * CHAN_MAXF);
+      const GLchan r = ctx->Color.ClearColor[0];
+      const GLchan g = ctx->Color.ClearColor[1];
+      const GLchan b = ctx->Color.ClearColor[2];
+      const GLchan a = ctx->Color.ClearColor[3];
       GLint i;
       for (i = 0; i < height; i++) {
          GLchan rgba[MAX_WIDTH][4];
          GLint j;
-         for (j=0; j<width; j++) {
+         for (j = 0; j < width; j++) {
             rgba[j][RCOMP] = r;
             rgba[j][GCOMP] = g;
             rgba[j][BCOMP] = b;
@@ -101,10 +101,10 @@ clear_color_buffer(GLcontext *ctx)
 
    if (ctx->Visual.rgbMode) {
       /* RGBA mode */
-      const GLchan r = (GLint) (ctx->Color.ClearColor[0] * CHAN_MAXF);
-      const GLchan g = (GLint) (ctx->Color.ClearColor[1] * CHAN_MAXF);
-      const GLchan b = (GLint) (ctx->Color.ClearColor[2] * CHAN_MAXF);
-      const GLchan a = (GLint) (ctx->Color.ClearColor[3] * CHAN_MAXF);
+      const GLchan r = ctx->Color.ClearColor[0];
+      const GLchan g = ctx->Color.ClearColor[1];
+      const GLchan b = ctx->Color.ClearColor[2];
+      const GLchan a = ctx->Color.ClearColor[3];
       GLchan span[MAX_WIDTH][4];
       GLint i;
 
diff --git a/src/mesa/swrast_setup/ss_tritmp.h b/src/mesa/swrast_setup/ss_tritmp.h
index 6064bbb5e02..92f85dab915 100644
--- a/src/mesa/swrast_setup/ss_tritmp.h
+++ b/src/mesa/swrast_setup/ss_tritmp.h
@@ -59,8 +59,8 @@ static void TAG(triangle)(GLcontext *ctx, GLuint e0, GLuint e1, GLuint e2 )
 	 if (facing == 1) {
 	    if (IND & SS_TWOSIDE_BIT) {
 	       if (IND & SS_RGBA_BIT) {
-		  GLubyte (*vbcolor)[4] = VB->ColorPtr[1]->data;
-		  GLubyte (*vbspec)[4] = VB->SecondaryColorPtr[1]->data;
+		  GLchan (*vbcolor)[4] = VB->ColorPtr[1]->data;
+		  GLchan (*vbspec)[4] = VB->SecondaryColorPtr[1]->data;
 		  SS_COLOR(v[0]->color, vbcolor[e0]);
 		  SS_COLOR(v[1]->color, vbcolor[e1]);
 		  SS_COLOR(v[2]->color, vbcolor[e2]);
@@ -132,8 +132,8 @@ static void TAG(triangle)(GLcontext *ctx, GLuint e0, GLuint e1, GLuint e2 )
    if (IND & SS_TWOSIDE_BIT) { 
       if (facing == 1) {
 	 if (IND & SS_RGBA_BIT) {
-	    GLubyte (*vbcolor)[4] = VB->ColorPtr[0]->data;
-	    GLubyte (*vbspec)[4] = VB->SecondaryColorPtr[0]->data;
+	    GLchan (*vbcolor)[4] = VB->ColorPtr[0]->data;
+	    GLchan (*vbspec)[4] = VB->SecondaryColorPtr[0]->data;
 	    SS_COLOR(v[0]->color, vbcolor[e0]);
 	    SS_COLOR(v[1]->color, vbcolor[e1]);
 	    SS_COLOR(v[2]->color, vbcolor[e2]);
diff --git a/src/mesa/swrast_setup/ss_vbtmp.h b/src/mesa/swrast_setup/ss_vbtmp.h
index 15d51a41df3..23b22d95ab7 100644
--- a/src/mesa/swrast_setup/ss_vbtmp.h
+++ b/src/mesa/swrast_setup/ss_vbtmp.h
@@ -33,8 +33,8 @@ static void TAG(rs)(GLcontext *ctx, GLuint start, GLuint end, GLuint newinputs )
    SWvertex *v;
    GLfloat (*proj)[4];		/* projected clip coordinates */
    GLfloat (*tc[MAX_TEXTURE_UNITS])[4];
-   GLubyte (*color)[4];
-   GLubyte (*spec)[4];
+   GLchan (*color)[4];
+   GLchan (*spec)[4];
    GLuint *index;
    GLfloat *fog;
    GLfloat *pointSize;
diff --git a/src/mesa/tnl/t_array_api.c b/src/mesa/tnl/t_array_api.c
index 908328513d8..b3ef1dbeed0 100644
--- a/src/mesa/tnl/t_array_api.c
+++ b/src/mesa/tnl/t_array_api.c
@@ -1,10 +1,10 @@
-/* $Id: t_array_api.c,v 1.3 2001/01/14 06:14:21 keithw Exp $ */
+/* $Id: t_array_api.c,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
  * Version:  3.5
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  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"),
@@ -336,8 +336,16 @@ void _tnl_array_init( GLcontext *ctx )
     */
    gl_vector4f_init( &tmp->Obj, 0, 0 );
    gl_vector3f_init( &tmp->Normal, 0, 0 );
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
    gl_vector4ub_init( &tmp->Color, 0, 0 );
    gl_vector4ub_init( &tmp->SecondaryColor, 0, 0 );
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+   gl_vector4us_init( &tmp->Color, 0, 0 );
+   gl_vector4us_init( &tmp->SecondaryColor, 0, 0 );
+#elif CHAN_TYPE == GL_FLOAT
+   gl_vector4f_init( &tmp->Color, 0, 0 );
+   gl_vector4f_init( &tmp->SecondaryColor, 0, 0 );
+#endif
    gl_vector1f_init( &tmp->FogCoord, 0, 0 );
    gl_vector1ui_init( &tmp->Index, 0, 0 );
    gl_vector1ub_init( &tmp->EdgeFlag, 0, 0 );
diff --git a/src/mesa/tnl/t_array_import.c b/src/mesa/tnl/t_array_import.c
index 0379bd402b3..b88391c8522 100644
--- a/src/mesa/tnl/t_array_import.c
+++ b/src/mesa/tnl/t_array_import.c
@@ -1,4 +1,4 @@
-/* $Id: t_array_import.c,v 1.6 2001/01/08 21:56:00 keithw Exp $ */
+/* $Id: t_array_import.c,v 1.7 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -107,10 +107,10 @@ static void _tnl_import_color( GLcontext *ctx,
 			  &is_writeable);
       
    inputs->Color.data = tmp->Ptr;
-   inputs->Color.start = (GLubyte *)tmp->Ptr;
+   inputs->Color.start = (GLchan *)tmp->Ptr;
    inputs->Color.stride = tmp->StrideB;
    inputs->Color.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE);
-   if (inputs->Color.stride != 4*sizeof(GLubyte))
+   if (inputs->Color.stride != 4*sizeof(GLchan))
       inputs->Color.flags |= VEC_BAD_STRIDE;
    if (!is_writeable)
       inputs->Color.flags |= VEC_NOT_WRITEABLE;
@@ -132,7 +132,7 @@ static void _tnl_import_secondarycolor( GLcontext *ctx,
 				   &is_writeable);
       
    inputs->SecondaryColor.data = tmp->Ptr;
-   inputs->SecondaryColor.start = (GLubyte *)tmp->Ptr;
+   inputs->SecondaryColor.start = (GLchan *)tmp->Ptr;
    inputs->SecondaryColor.stride = tmp->StrideB;
    inputs->SecondaryColor.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE);
    if (inputs->SecondaryColor.stride != 4*sizeof(GLubyte))
@@ -464,21 +464,53 @@ void _tnl_fill_immediate_drawarrays( GLcontext *ctx, struct immediate *IM,
    }
 	
    if (required & VERT_RGBA) {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
       _math_trans_4ub( IM->Color + IM->Start,
 		       ctx->Array.Color.Ptr, 
 		       ctx->Array.Color.StrideB,
 		       ctx->Array.Color.Type,
 		       ctx->Array.Color.Size,
 		       start, n );
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+      _math_trans_4us( IM->Color + IM->Start,
+		       ctx->Array.Color.Ptr, 
+		       ctx->Array.Color.StrideB,
+		       ctx->Array.Color.Type,
+		       ctx->Array.Color.Size,
+		       start, n );
+#elif CHAN_TYPE == GL_FLOAT
+      _math_trans_4f( IM->Color + IM->Start,
+                      ctx->Array.Color.Ptr, 
+                      ctx->Array.Color.StrideB,
+                      ctx->Array.Color.Type,
+                      ctx->Array.Color.Size,
+                      start, n );
+#endif
    }
 
    if (required & VERT_SPEC_RGB) {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
       _math_trans_4ub( IM->SecondaryColor + IM->Start,
 		       ctx->Array.SecondaryColor.Ptr,
 		       ctx->Array.SecondaryColor.StrideB, 
 		       ctx->Array.SecondaryColor.Type, 
 		       ctx->Array.SecondaryColor.Size, 
 		       start, n );
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+      _math_trans_4us( IM->SecondaryColor + IM->Start,
+		       ctx->Array.SecondaryColor.Ptr,
+		       ctx->Array.SecondaryColor.StrideB, 
+		       ctx->Array.SecondaryColor.Type, 
+		       ctx->Array.SecondaryColor.Size, 
+		       start, n );
+#elif CHAN_TYPE == GL_FLOAT
+      _math_trans_4f( IM->SecondaryColor + IM->Start,
+		       ctx->Array.SecondaryColor.Ptr,
+		       ctx->Array.SecondaryColor.StrideB, 
+		       ctx->Array.SecondaryColor.Type, 
+		       ctx->Array.SecondaryColor.Size, 
+		       start, n );
+#endif
    }
 
    if (required & VERT_FOG_COORD) {
diff --git a/src/mesa/tnl/t_context.h b/src/mesa/tnl/t_context.h
index 41be51e4e25..d3414be29ba 100644
--- a/src/mesa/tnl/t_context.h
+++ b/src/mesa/tnl/t_context.h
@@ -1,4 +1,4 @@
-/* $Id: t_context.h,v 1.11 2001/01/14 06:14:21 keithw Exp $ */
+/* $Id: t_context.h,v 1.12 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -205,7 +205,7 @@ struct immediate
    GLuint  Elt[IMM_SIZE];
    GLubyte EdgeFlag[IMM_SIZE];
    GLuint  Index[IMM_SIZE];
-   GLubyte SecondaryColor[IMM_SIZE][4];
+   GLchan  SecondaryColor[IMM_SIZE][4];
    GLfloat FogCoord[IMM_SIZE];
 };
 
@@ -214,12 +214,20 @@ struct vertex_arrays
 {
    GLvector4f  Obj;
    GLvector3f  Normal;
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
    GLvector4ub Color;
+   GLvector4ub SecondaryColor;
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+   GLvector4us Color;
+   GLvector4us SecondaryColor;
+#elif CHAN_TYPE == GL_FLOAT
+   GLvector4f Color;
+   GLvector4f SecondaryColor;
+#endif
    GLvector1ui Index;
    GLvector1ub EdgeFlag;
    GLvector4f  TexCoord[MAX_TEXTURE_UNITS];
    GLvector1ui Elt;
-   GLvector4ub SecondaryColor;
    GLvector1f  FogCoord;
 };
 
@@ -260,8 +268,17 @@ typedef struct vertex_buffer
    GLboolean   *EdgeFlag;	                /* VERT_EDGE */
    GLvector4f  *TexCoordPtr[MAX_TEXTURE_UNITS];	/* VERT_TEX_0..n */
    GLvector1ui *IndexPtr[2];	                /* VERT_INDEX */
+
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
    GLvector4ub *ColorPtr[2];	                /* VERT_RGBA */
-   GLvector4ub *SecondaryColorPtr[2];           /* VERT_SPEC_RGB */
+   GLvector4ub *SecondaryColorPtr[2];         /* VERT_SPEC_RGB */
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+   GLvector4us *ColorPtr[2];	                /* VERT_RGBA */
+   GLvector4us *SecondaryColorPtr[2];         /* VERT_SPEC_RGB */
+#elif CHAN_TYPE == GL_FLOAT
+   GLvector4f *ColorPtr[2];	                /* VERT_RGBA */
+   GLvector4f *SecondaryColorPtr[2];         /* VERT_SPEC_RGB */
+#endif
    GLvector1f  *FogCoordPtr;	                /* VERT_FOG_COORD */
    GLvector1f  *PointSizePtr;	                /* VERT_POINT_SIZE */
    GLmaterial (*Material)[2];                   /* VERT_MATERIAL, optional */
diff --git a/src/mesa/tnl/t_imm_api.c b/src/mesa/tnl/t_imm_api.c
index 0e00e59cdb7..0ba46b9b7c8 100644
--- a/src/mesa/tnl/t_imm_api.c
+++ b/src/mesa/tnl/t_imm_api.c
@@ -382,22 +382,13 @@ _tnl_End(void)
 static void
 _tnl_Color3f( GLfloat red, GLfloat green, GLfloat blue )
 {
-#if CHAN_BITS == 8
-   GLubyte col[4];
+   GLchan col[4];
    GET_IMMEDIATE;
-   UNCLAMPED_FLOAT_TO_UBYTE(col[0], red);
-   UNCLAMPED_FLOAT_TO_UBYTE(col[1], green);
-   UNCLAMPED_FLOAT_TO_UBYTE(col[2], blue);
+   UNCLAMPED_FLOAT_TO_CHAN(col[0], red);
+   UNCLAMPED_FLOAT_TO_CHAN(col[1], green);
+   UNCLAMPED_FLOAT_TO_CHAN(col[2], blue);
    col[3] = CHAN_MAX;
    COLORV( IM, col );
-#else
-   GET_IMMEDIATE;
-   COLOR(IM,
-         UNCLAMPED_FLOAT_TO_CHAN(red),
-         UNCLAMPED_FLOAT_TO_CHAN(green),
-         UNCLAMPED_FLOAT_TO_CHAN(blue),
-         CHAN_MAX);
-#endif
 }
 
 
@@ -423,61 +414,37 @@ _tnl_Color3ub( GLubyte red, GLubyte green, GLubyte blue )
 static void
 _tnl_Color4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
 {
-#if CHAN_BITS == 8
-   GLubyte col[4];
+   GLchan col[4];
    GET_IMMEDIATE;
-   UNCLAMPED_FLOAT_TO_UBYTE(col[0], red);
-   UNCLAMPED_FLOAT_TO_UBYTE(col[1], green);
-   UNCLAMPED_FLOAT_TO_UBYTE(col[2], blue);
-   UNCLAMPED_FLOAT_TO_UBYTE(col[3], alpha);
+   UNCLAMPED_FLOAT_TO_CHAN(col[0], red);
+   UNCLAMPED_FLOAT_TO_CHAN(col[1], green);
+   UNCLAMPED_FLOAT_TO_CHAN(col[2], blue);
+   UNCLAMPED_FLOAT_TO_CHAN(col[3], alpha);
    COLORV( IM, col );
-#else
-   GET_IMMEDIATE;
-   COLOR(IM,
-         UNCLAMPED_FLOAT_TO_CHAN(red),
-         UNCLAMPED_FLOAT_TO_CHAN(green),
-         UNCLAMPED_FLOAT_TO_CHAN(blue),
-         UNCLAMPED_FLOAT_TO_CHAN(alpha));
-#endif
 }
 
 static void
 _tnl_Color4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
 {
-#if CHAN_BITS == 8
-   GET_IMMEDIATE;
-   COLOR( IM, red, green, blue, alpha );
-#else
    GET_IMMEDIATE;
    COLOR(IM,
          UBYTE_TO_CHAN(red),
          UBYTE_TO_CHAN(green),
          UBYTE_TO_CHAN(blue),
          UBYTE_TO_CHAN(alpha));
-#endif
 }
 
 
 static void
 _tnl_Color3fv( const GLfloat *v )
 {
-#if CHAN_BITS == 8
-   GLubyte col[4];
+   GLchan col[4];
    GET_IMMEDIATE;
-   UNCLAMPED_FLOAT_TO_UBYTE(col[0], v[0]);
-   UNCLAMPED_FLOAT_TO_UBYTE(col[1], v[1]);
-   UNCLAMPED_FLOAT_TO_UBYTE(col[2], v[2]);
+   UNCLAMPED_FLOAT_TO_CHAN(col[0], v[0]);
+   UNCLAMPED_FLOAT_TO_CHAN(col[1], v[1]);
+   UNCLAMPED_FLOAT_TO_CHAN(col[2], v[2]);
    col[3] = CHAN_MAX;
    COLORV( IM, col );
-#else
-   GET_IMMEDIATE;
-   COLOR(IM,
-         UNCLAMPED_FLOAT_TO_CHAN(v[0]),
-         UNCLAMPED_FLOAT_TO_CHAN(v[1]),
-         UNCLAMPED_FLOAT_TO_CHAN(v[2]),
-         CHAN_MAX);
-
-#endif
 }
 
 
@@ -485,38 +452,24 @@ _tnl_Color3fv( const GLfloat *v )
 static void
 _tnl_Color3ubv( const GLubyte *v )
 {
-#if CHAN_BITS == 8
-   GET_IMMEDIATE;
-   COLOR( IM, v[0], v[1], v[2], CHAN_MAX );
-#else
    GET_IMMEDIATE;
    COLOR(IM,
          UBYTE_TO_CHAN(v[0]),
          UBYTE_TO_CHAN(v[1]),
          UBYTE_TO_CHAN(v[2]),
-         CHAN_MAX);
-#endif
+         CHAN_MAX );
 }
 
 static void
 _tnl_Color4fv( const GLfloat *v )
 {
-#if CHAN_BITS == 8
-   GLubyte col[4];
+   GLchan col[4];
    GET_IMMEDIATE;
-   UNCLAMPED_FLOAT_TO_UBYTE(col[0], v[0]);
-   UNCLAMPED_FLOAT_TO_UBYTE(col[1], v[1]);
-   UNCLAMPED_FLOAT_TO_UBYTE(col[2], v[2]);
-   UNCLAMPED_FLOAT_TO_UBYTE(col[3], v[3]);
+   UNCLAMPED_FLOAT_TO_CHAN(col[0], v[0]);
+   UNCLAMPED_FLOAT_TO_CHAN(col[1], v[1]);
+   UNCLAMPED_FLOAT_TO_CHAN(col[2], v[2]);
+   UNCLAMPED_FLOAT_TO_CHAN(col[3], v[3]);
    COLORV( IM, col );
-#else
-   GET_IMMEDIATE;
-   COLOR(IM,
-         UNCLAMPED_FLOAT_TO_CHAN(v[0]),
-         UNCLAMPED_FLOAT_TO_CHAN(v[1]),
-         UNCLAMPED_FLOAT_TO_CHAN(v[2]),
-         UNCLAMPED_FLOAT_TO_CHAN(v[3]));
-#endif
 }
 
 
@@ -524,17 +477,12 @@ _tnl_Color4fv( const GLfloat *v )
 static void
 _tnl_Color4ubv( const GLubyte *v)
 {
-#if CHAN_BITS == 8
-   GET_IMMEDIATE;
-   COLORV( IM, v );
-#else
    GET_IMMEDIATE;
    COLOR(IM,
          UBYTE_TO_CHAN(v[0]),
          UBYTE_TO_CHAN(v[1]),
          UBYTE_TO_CHAN(v[2]),
          UBYTE_TO_CHAN(v[3]));
-#endif
 }
 
 
@@ -564,20 +512,12 @@ _tnl_Color4ubv( const GLubyte *v)
 static void
 _tnl_SecondaryColor3fEXT( GLfloat red, GLfloat green, GLfloat blue )
 {
-#if CHAN_BITS == 8
-   GLubyte col[3];
+   GLchan col[3];
    GET_IMMEDIATE;
-   UNCLAMPED_FLOAT_TO_UBYTE(col[0], red);
-   UNCLAMPED_FLOAT_TO_UBYTE(col[1], green);
-   UNCLAMPED_FLOAT_TO_UBYTE(col[2], blue);
+   UNCLAMPED_FLOAT_TO_CHAN(col[0], red);
+   UNCLAMPED_FLOAT_TO_CHAN(col[1], green);
+   UNCLAMPED_FLOAT_TO_CHAN(col[2], blue);
    SECONDARY_COLORV( IM, col );
-#else
-   GET_IMMEDIATE;
-   SECONDARY_COLOR(IM,
-                   UNCLAMPED_FLOAT_TO_CHAN(red),
-                   UNCLAMPED_FLOAT_TO_CHAN(green),
-                   UNCLAMPED_FLOAT_TO_CHAN(blue));
-#endif
 }
 
 
@@ -585,16 +525,11 @@ _tnl_SecondaryColor3fEXT( GLfloat red, GLfloat green, GLfloat blue )
 static void
 _tnl_SecondaryColor3ubEXT( GLubyte red, GLubyte green, GLubyte blue )
 {
-#if CHAN_BITS == 8
-   GET_IMMEDIATE;
-   SECONDARY_COLOR( IM, red, green, blue );
-#else
    GET_IMMEDIATE;
    SECONDARY_COLOR(IM,
                    UBYTE_TO_CHAN(red),
                    UBYTE_TO_CHAN(green),
                    UBYTE_TO_CHAN(blue));
-#endif
 }
 
 
@@ -603,20 +538,12 @@ _tnl_SecondaryColor3ubEXT( GLubyte red, GLubyte green, GLubyte blue )
 static void
 _tnl_SecondaryColor3fvEXT( const GLfloat *v )
 {
-#if CHAN_BITS == 8
-   GLubyte col[3];
+   GLchan col[3];
    GET_IMMEDIATE;
-   UNCLAMPED_FLOAT_TO_UBYTE(col[0], v[0]);
-   UNCLAMPED_FLOAT_TO_UBYTE(col[1], v[1]);
-   UNCLAMPED_FLOAT_TO_UBYTE(col[2], v[2]);
+   UNCLAMPED_FLOAT_TO_CHAN(col[0], v[0]);
+   UNCLAMPED_FLOAT_TO_CHAN(col[1], v[1]);
+   UNCLAMPED_FLOAT_TO_CHAN(col[2], v[2]);
    SECONDARY_COLORV( IM, col );
-#else
-   GET_IMMEDIATE;
-   SECONDARY_COLOR(IM,
-                   UNCLAMPED_FLOAT_TO_CHAN(v[0]),
-                   UNCLAMPED_FLOAT_TO_CHAN(v[1]),
-                   UNCLAMPED_FLOAT_TO_CHAN(v[2]));
-#endif
 }
 
 
@@ -624,16 +551,11 @@ _tnl_SecondaryColor3fvEXT( const GLfloat *v )
 static void
 _tnl_SecondaryColor3ubvEXT( const GLubyte *v )
 {
-#if CHAN_BITS == 8
-   GET_IMMEDIATE;
-   SECONDARY_COLOR( IM, v[0], v[1], v[2] );
-#else
    GET_IMMEDIATE;
    SECONDARY_COLOR(IM,
                    UBYTE_TO_CHAN(v[0]),
                    UBYTE_TO_CHAN(v[1]),
                    UBYTE_TO_CHAN(v[2]));
-#endif
 }
 
 
diff --git a/src/mesa/tnl/t_imm_elt.c b/src/mesa/tnl/t_imm_elt.c
index ec79c7e52be..83a76294b6c 100644
--- a/src/mesa/tnl/t_imm_elt.c
+++ b/src/mesa/tnl/t_imm_elt.c
@@ -1,4 +1,4 @@
-/* $Id: t_imm_elt.c,v 1.2 2001/01/02 22:02:53 brianp Exp $ */
+/* $Id: t_imm_elt.c,v 1.3 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -68,13 +68,22 @@ typedef void (*trans_elt_1ub_func)(GLubyte *to,
 				   GLuint n );
 
 typedef void (*trans_elt_4ub_func)(GLubyte (*to)[4],
-				   CONST void *ptr,
-				   GLuint stride,
-				   GLuint *flags,
-				   GLuint *elts,
-				   GLuint match,
-				   GLuint start,
-				   GLuint n );
+                                   CONST void *ptr,
+                                   GLuint stride,
+                                   GLuint *flags,
+                                   GLuint *elts,
+                                   GLuint match,
+                                   GLuint start,
+                                   GLuint n );
+
+typedef void (*trans_elt_4us_func)(GLushort (*to)[4],
+                                   CONST void *ptr,
+                                   GLuint stride,
+                                   GLuint *flags,
+                                   GLuint *elts,
+                                   GLuint match,
+                                   GLuint start,
+                                   GLuint n );
 
 typedef void (*trans_elt_4f_func)(GLfloat (*to)[4],
 				  CONST void *ptr,
@@ -102,6 +111,7 @@ static trans_elt_1ui_func _tnl_trans_elt_1ui_tab[MAX_TYPES];
 static trans_elt_1ub_func _tnl_trans_elt_1ub_tab[MAX_TYPES];
 static trans_elt_3f_func  _tnl_trans_elt_3f_tab[MAX_TYPES];
 static trans_elt_4ub_func _tnl_trans_elt_4ub_tab[5][MAX_TYPES];
+static trans_elt_4us_func _tnl_trans_elt_4us_tab[5][MAX_TYPES];
 static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 
 
@@ -141,6 +151,7 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #define TRX_3F(f,n)   BYTE_TO_FLOAT( PTR_ELT(f,n) )
 #define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
 #define TRX_UB(ub, f,n)  ub = BYTE_TO_UBYTE( PTR_ELT(f,n) )
+#define TRX_US(us, f,n)  us = BYTE_TO_USHORT( PTR_ELT(f,n) )
 #define TRX_UI(f,n)  (PTR_ELT(f,n) < 0 ? 0 : (GLuint)  PTR_ELT(f,n))
 
 
@@ -154,6 +165,7 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #define INIT init_trans_3_GLbyte_elt
 #define DEST_4F trans_3_GLbyte_4f_elt
 #define DEST_4UB trans_3_GLbyte_4ub_elt
+#define DEST_4US trans_3_GLbyte_4us_elt
 #define DEST_3F trans_3_GLbyte_3f_elt
 #include "math/m_trans_tmp.h"
 
@@ -173,6 +185,7 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #undef TRX_3F
 #undef TRX_4F
 #undef TRX_UB
+#undef TRX_US
 #undef TRX_UI
 #undef SRC_IDX
 
@@ -183,6 +196,7 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #define TRX_3F(f,n)		/* unused */
 #define TRX_4F(f,n)		/* unused */
 #define TRX_UB(ub, f,n)	     ub = PTR_ELT(f,n)
+#define TRX_US(us, f,n)	     us = PTR_ELT(f,n)
 #define TRX_UI(f,n)          (GLuint)PTR_ELT(f,n)
 
 /* 4ub->4ub handled in special case below.
@@ -191,6 +205,7 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #define SZ 3
 #define INIT init_trans_3_GLubyte_elt
 #define DEST_4UB trans_3_GLubyte_4ub_elt
+#define DEST_4US trans_3_GLubyte_4us_elt
 #include "math/m_trans_tmp.h"
 
 
@@ -205,6 +220,7 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #undef TRX_3F
 #undef TRX_4F
 #undef TRX_UB
+#undef TRX_US
 #undef TRX_UI
 
 
@@ -215,6 +231,7 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #define TRX_3F(f,n)   SHORT_TO_FLOAT( PTR_ELT(f,n) )
 #define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
 #define TRX_UB(ub, f,n)  ub = SHORT_TO_UBYTE(PTR_ELT(f,n))
+#define TRX_US(us, f,n)  us = SHORT_TO_USHORT(PTR_ELT(f,n))
 #define TRX_UI(f,n)  (PTR_ELT(f,n) < 0 ? 0 : (GLuint)  PTR_ELT(f,n))
 
 
@@ -222,12 +239,14 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #define INIT init_trans_4_GLshort_elt
 #define DEST_4F trans_4_GLshort_4f_elt
 #define DEST_4UB trans_4_GLshort_4ub_elt
+#define DEST_4US trans_4_GLshort_4us_elt
 #include "math/m_trans_tmp.h"
 
 #define SZ 3
 #define INIT init_trans_3_GLshort_elt
 #define DEST_4F trans_3_GLshort_4f_elt
 #define DEST_4UB trans_3_GLshort_4ub_elt
+#define DEST_4US trans_3_GLshort_4us_elt
 #define DEST_3F trans_3_GLshort_3f_elt
 #include "math/m_trans_tmp.h"
 
@@ -249,6 +268,7 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #undef TRX_3F
 #undef TRX_4F
 #undef TRX_UB
+#undef TRX_US
 #undef TRX_UI
 
 
@@ -259,6 +279,7 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #define TRX_3F(f,n)   USHORT_TO_FLOAT( PTR_ELT(f,n) )
 #define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
 #define TRX_UB(ub,f,n)  ub = (GLubyte) (PTR_ELT(f,n) >> 8)
+#define TRX_US(us,f,n)  us = PTR_ELT(f,n)
 #define TRX_UI(f,n)  (GLuint)   PTR_ELT(f,n)
 
 
@@ -266,12 +287,14 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #define INIT init_trans_4_GLushort_elt
 #define DEST_4F trans_4_GLushort_4f_elt
 #define DEST_4UB trans_4_GLushort_4ub_elt
+#define DEST_4US trans_4_GLushort_4us_elt
 #include "math/m_trans_tmp.h"
 
 #define SZ 3
 #define INIT init_trans_3_GLushort_elt
 #define DEST_4F trans_3_GLushort_4f_elt
 #define DEST_4UB trans_3_GLushort_4ub_elt
+#define DEST_4US trans_3_GLushort_4us_elt
 #define DEST_3F trans_3_GLushort_3f_elt
 #include "math/m_trans_tmp.h"
 
@@ -292,6 +315,7 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #undef TRX_3F
 #undef TRX_4F
 #undef TRX_UB
+#undef TRX_US
 #undef TRX_UI
 
 
@@ -302,6 +326,7 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #define TRX_3F(f,n)   INT_TO_FLOAT( PTR_ELT(f,n) )
 #define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
 #define TRX_UB(ub, f,n)  ub = INT_TO_UBYTE(PTR_ELT(f,n))
+#define TRX_US(us, f,n)  us = INT_TO_USHORT(PTR_ELT(f,n))
 #define TRX_UI(f,n)  (PTR_ELT(f,n) < 0 ? 0 : (GLuint)  PTR_ELT(f,n))
 
 
@@ -309,12 +334,14 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #define INIT init_trans_4_GLint_elt
 #define DEST_4F trans_4_GLint_4f_elt
 #define DEST_4UB trans_4_GLint_4ub_elt
+#define DEST_4US trans_4_GLint_4us_elt
 #include "math/m_trans_tmp.h"
 
 #define SZ 3
 #define INIT init_trans_3_GLint_elt
 #define DEST_4F trans_3_GLint_4f_elt
 #define DEST_4UB trans_3_GLint_4ub_elt
+#define DEST_4US trans_3_GLint_4us_elt
 #define DEST_3F trans_3_GLint_3f_elt
 #include "math/m_trans_tmp.h"
 
@@ -336,6 +363,7 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #undef TRX_3F
 #undef TRX_4F
 #undef TRX_UB
+#undef TRX_US
 #undef TRX_UI
 
 
@@ -346,6 +374,7 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #define TRX_3F(f,n)   UINT_TO_FLOAT( PTR_ELT(f,n) )
 #define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
 #define TRX_UB(ub, f,n)  ub = (GLubyte) (PTR_ELT(f,n) >> 24)
+#define TRX_US(us, f,n)  us = (GLushort) (PTR_ELT(f,n) >> 16)
 #define TRX_UI(f,n)		PTR_ELT(f,n)
 
 
@@ -353,12 +382,14 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #define INIT init_trans_4_GLuint_elt
 #define DEST_4F trans_4_GLuint_4f_elt
 #define DEST_4UB trans_4_GLuint_4ub_elt
+#define DEST_4US trans_4_GLuint_4us_elt
 #include "math/m_trans_tmp.h"
 
 #define SZ 3
 #define INIT init_trans_3_GLuint_elt
 #define DEST_4F trans_3_GLuint_4f_elt
 #define DEST_4UB trans_3_GLuint_4ub_elt
+#define DEST_4US trans_3_GLuint_4us_elt
 #define DEST_3F trans_3_GLuint_3f_elt
 #include "math/m_trans_tmp.h"
 
@@ -379,6 +410,7 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #undef TRX_3F
 #undef TRX_4F
 #undef TRX_UB
+#undef TRX_US
 #undef TRX_UI
 
 
@@ -388,7 +420,8 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #define SRC_IDX TYPE_IDX(GL_DOUBLE)
 #define TRX_3F(f,n)   PTR_ELT(f,n)
 #define TRX_4F(f,n)   PTR_ELT(f,n)
-#define TRX_UB(ub,f,n) UNCLAMPED_FLOAT_TO_CHAN(ub, PTR_ELT(f,n))
+#define TRX_UB(ub,f,n) UNCLAMPED_FLOAT_TO_UBYTE(ub, PTR_ELT(f,n))
+#define TRX_US(us,f,n) UNCLAMPED_FLOAT_TO_USHORT(us, PTR_ELT(f,n))
 #define TRX_UI(f,n)  (GLuint) (GLint) PTR_ELT(f,n)
 #define TRX_1F(f,n)   PTR_ELT(f,n)
 
@@ -397,12 +430,14 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #define INIT init_trans_4_GLdouble_elt
 #define DEST_4F trans_4_GLdouble_4f_elt
 #define DEST_4UB trans_4_GLdouble_4ub_elt
+#define DEST_4US trans_4_GLdouble_4us_elt
 #include "math/m_trans_tmp.h"
 
 #define SZ 3
 #define INIT init_trans_3_GLdouble_elt
 #define DEST_4F trans_3_GLdouble_4f_elt
 #define DEST_4UB trans_3_GLdouble_4ub_elt
+#define DEST_4US trans_3_GLdouble_4us_elt
 #define DEST_3F trans_3_GLdouble_3f_elt
 #include "math/m_trans_tmp.h"
 
@@ -429,6 +464,7 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #define SZ 4
 #define INIT init_trans_4_GLfloat_elt
 #define DEST_4UB trans_4_GLfloat_4ub_elt
+#define DEST_4US trans_4_GLfloat_4us_elt
 #define DEST_4F  trans_4_GLfloat_4f_elt
 #include "math/m_trans_tmp.h"
 
@@ -436,6 +472,7 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #define INIT init_trans_3_GLfloat_elt
 #define DEST_4F  trans_3_GLfloat_4f_elt
 #define DEST_4UB trans_3_GLfloat_4ub_elt
+#define DEST_4US trans_3_GLfloat_4us_elt
 #define DEST_3F trans_3_GLfloat_3f_elt
 #include "math/m_trans_tmp.h"
 
@@ -457,13 +494,14 @@ static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
 #undef TRX_3F
 #undef TRX_4F
 #undef TRX_UB
+#undef TRX_US
 #undef TRX_UI
 
 
 static void trans_4_GLubyte_4ub(GLubyte (*t)[4],
-				CONST void *Ptr,
-				GLuint stride,
-				ARGS )
+                                CONST void *Ptr,
+                                GLuint stride,
+                                ARGS )
 {
    const GLubyte *f = (GLubyte *) Ptr + SRC_START * stride;
    const GLubyte *first = f;
@@ -498,6 +536,7 @@ static void init_translate_elt(void)
    MEMSET( TAB(_1ub), 0, sizeof(TAB(_1ub)) );
    MEMSET( TAB(_3f),  0, sizeof(TAB(_3f)) );
    MEMSET( TAB(_4ub), 0, sizeof(TAB(_4ub)) );
+   MEMSET( TAB(_4us), 0, sizeof(TAB(_4us)) );
    MEMSET( TAB(_4f),  0, sizeof(TAB(_4f)) );
 
    TAB(_4ub)[4][TYPE_IDX(GL_UNSIGNED_BYTE)] = trans_4_GLubyte_4ub;
@@ -598,43 +637,62 @@ static void _tnl_trans_elt_1ub(GLubyte *to,
 			GLuint n )
 {
    _tnl_trans_elt_1ub_tab[TYPE_IDX(from->Type)]( to, 
-					      from->Ptr,
-					      from->StrideB,
-					      flags,
-					      elts,
-					      match,
-					      start,
-					      n );
+                                                 from->Ptr,
+                                                 from->StrideB,
+                                                 flags,
+                                                 elts,
+                                                 match,
+                                                 start,
+                                                 n );
 					
 }
 
 
 static void _tnl_trans_elt_4ub(GLubyte (*to)[4],
-			const struct gl_client_array *from,
-			GLuint *flags,
-			GLuint *elts,
-			GLuint match,
-			GLuint start,
-			GLuint n )
+                               const struct gl_client_array *from,
+                               GLuint *flags,
+                               GLuint *elts,
+                               GLuint match,
+                               GLuint start,
+                               GLuint n )
 {
    _tnl_trans_elt_4ub_tab[from->Size][TYPE_IDX(from->Type)]( to, 
-					      from->Ptr,
-					      from->StrideB,
-					      flags,
-					      elts,
-					      match,
-					      start,
-					      n );
+                                                             from->Ptr,
+                                                             from->StrideB,
+                                                             flags,
+                                                             elts,
+                                                             match,
+                                                             start,
+                                                             n );
+					
+}
+
+static void _tnl_trans_elt_4us(GLushort (*to)[4],
+                               const struct gl_client_array *from,
+                               GLuint *flags,
+                               GLuint *elts,
+                               GLuint match,
+                               GLuint start,
+                               GLuint n )
+{
+   _tnl_trans_elt_4us_tab[from->Size][TYPE_IDX(from->Type)]( to, 
+                                                             from->Ptr,
+                                                             from->StrideB,
+                                                             flags,
+                                                             elts,
+                                                             match,
+                                                             start,
+                                                             n );
 					
 }
 
 static void _tnl_trans_elt_4f(GLfloat (*to)[4],
-		       const struct gl_client_array *from,
-		       GLuint *flags,
-		       GLuint *elts,
-		       GLuint match,
-		       GLuint start,
-		       GLuint n )
+                              const struct gl_client_array *from,
+                              GLuint *flags,
+                              GLuint *elts,
+                              GLuint match,
+                              GLuint start,
+                              GLuint n )
 {
    _tnl_trans_elt_4f_tab[from->Size][TYPE_IDX(from->Type)]( to, 
 					      from->Ptr,
@@ -710,18 +768,43 @@ void _tnl_translate_array_elts( GLcontext *ctx, struct immediate *IM,
 			  flags, elts, (VERT_ELT|VERT_EDGE),
 			  start, count);
 
-   if (translate & VERT_RGBA)
+   if (translate & VERT_RGBA) {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
       _tnl_trans_elt_4ub( IM->Color,
-			  &ctx->Array.Color,
-			  flags, elts, (VERT_ELT|VERT_RGBA),
-			  start, count);
-
+                          &ctx->Array.Color,
+                          flags, elts, (VERT_ELT|VERT_RGBA),
+                          start, count);
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+      _tnl_trans_elt_4us( IM->Color,
+                          &ctx->Array.Color,
+                          flags, elts, (VERT_ELT|VERT_RGBA),
+                          start, count);
+#elif CHAN_TYPE == GL_FLOAT
+      _tnl_trans_elt_4f( IM->Color,
+                         &ctx->Array.Color,
+                         flags, elts, (VERT_ELT|VERT_RGBA),
+                         start, count);
+#endif
+   }
 
-   if (translate & VERT_SPEC_RGB)
+   if (translate & VERT_SPEC_RGB) {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
       _tnl_trans_elt_4ub( IM->SecondaryColor,
-			  &ctx->Array.SecondaryColor,
-			  flags, elts, (VERT_ELT|VERT_SPEC_RGB),
-			  start, count);
+                          &ctx->Array.SecondaryColor,
+                          flags, elts, (VERT_ELT|VERT_SPEC_RGB),
+                          start, count);
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+      _tnl_trans_elt_4us( IM->SecondaryColor,
+                          &ctx->Array.SecondaryColor,
+                          flags, elts, (VERT_ELT|VERT_SPEC_RGB),
+                          start, count);
+#elif CHAN_TYPE == GL_FLOAT
+      _tnl_trans_elt_4f( IM->SecondaryColor,
+                         &ctx->Array.SecondaryColor,
+                         flags, elts, (VERT_ELT|VERT_SPEC_RGB),
+                         start, count);
+#endif
+   }
 
    if (translate & VERT_FOG_COORD)
       _tnl_trans_elt_1f( IM->FogCoord,
diff --git a/src/mesa/tnl/t_imm_eval.c b/src/mesa/tnl/t_imm_eval.c
index 235baa38b8b..a7c5b7db039 100644
--- a/src/mesa/tnl/t_imm_eval.c
+++ b/src/mesa/tnl/t_imm_eval.c
@@ -1,4 +1,4 @@
-/* $Id: t_imm_eval.c,v 1.3 2001/01/03 15:59:30 brianp Exp $ */
+/* $Id: t_imm_eval.c,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -144,14 +144,21 @@ static void eval1_norm( GLvector3f *dest,
       }
 }
 
-static void eval1_color( GLvector4ub *dest,
+static void eval1_color(
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
+                         GLvector4ub *dest,
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+                         GLvector4us *dest,
+#elif CHAN_TYPE == GL_FLOAT
+                         GLvector4f *dest,
+#endif
 			 GLfloat coord[][4],
 			 const GLuint *flags,
 			 struct gl_1d_map *map )
 {
    const GLfloat u1 = map->u1;
    const GLfloat du = map->du;
-   GLubyte (*to)[4] = dest->data;
+   GLchan (*to)[4] = dest->data;
    GLuint i;
 
    for (i = 0 ; !(flags[i] & VERT_END_VB) ; i++) {
@@ -276,7 +283,14 @@ static void eval2_1ui( GLvector1ui *dest,
 
 
 
-static void eval2_color( GLvector4ub *dest,
+static void eval2_color(
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
+                         GLvector4ub *dest,
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+                         GLvector4us *dest,
+#elif CHAN_TYPE == GL_FLOAT
+                         GLvector4f *dest,
+#endif
 			 GLfloat coord[][4],
 			 GLuint *flags,
 			 struct gl_2d_map *map )
@@ -285,7 +299,7 @@ static void eval2_color( GLvector4ub *dest,
    const GLfloat du = map->du;
    const GLfloat v1 = map->v1;
    const GLfloat dv = map->dv;
-   GLubyte (*to)[4] = dest->data;
+   GLchan (*to)[4] = dest->data;
    GLuint i;
 
    for (i = 0 ; !(flags[i] & VERT_END_VB) ; i++) {
@@ -312,7 +326,7 @@ static void copy_3f( GLfloat to[][3], GLfloat from[][3], GLuint count )
    MEMCPY( to, from, (count) * sizeof(to[0])); 
 }
 
-static void copy_4ub( GLubyte to[][4], GLubyte from[][4], GLuint count )
+static void copy_4chan( GLchan to[][4], GLchan from[][4], GLuint count )
 {
    MEMCPY( to, from, (count) * sizeof(to[0])); 
 }
@@ -472,10 +486,10 @@ void _tnl_eval_vb( GLcontext *ctx,
    if (req & VERT_RGBA)
    {
       if (!all_eval)
-	 copy_4ub( store->Color, tmp->Color.data, count );
+	 copy_4chan( store->Color, tmp->Color.data, count );
 
       tmp->Color.data = store->Color;
-      tmp->Color.start = (GLubyte *)store->Color;
+      tmp->Color.start = (GLchan *) store->Color;
 
       if (ctx->Eval.Map1Color4 && any_eval1)
 	 eval1_color( &tmp->Color, coord, flags, &ctx->EvalMap.Map1Color4 );
diff --git a/src/mesa/tnl/t_imm_exec.c b/src/mesa/tnl/t_imm_exec.c
index 4d3f874ce4d..5889592a1a6 100644
--- a/src/mesa/tnl/t_imm_exec.c
+++ b/src/mesa/tnl/t_imm_exec.c
@@ -1,10 +1,10 @@
-/* $Id: t_imm_exec.c,v 1.8 2001/01/14 06:14:21 keithw Exp $ */
+/* $Id: t_imm_exec.c,v 1.9 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
  * Version:  3.5
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  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"),
@@ -253,7 +253,7 @@ static void _tnl_vb_bind_immediate( GLcontext *ctx, struct immediate *IM )
 
    if (inputs & VERT_SPEC_RGB) {
       tmp->SecondaryColor.data = IM->SecondaryColor + start;
-      tmp->SecondaryColor.start = (GLubyte *)(IM->SecondaryColor + start);
+      tmp->SecondaryColor.start = (GLchan *)(IM->SecondaryColor + start);
       tmp->SecondaryColor.count = count;
       VB->SecondaryColorPtr[0] = &tmp->SecondaryColor;
    }
@@ -264,7 +264,7 @@ static void _tnl_vb_bind_immediate( GLcontext *ctx, struct immediate *IM )
 
    if (inputs & VERT_RGBA) {
       tmp->Color.data = IM->Color + start;
-      tmp->Color.start = (GLubyte *)(IM->Color + start);
+      tmp->Color.start = (GLchan *)(IM->Color + start);
       tmp->Color.count = count;
       VB->ColorPtr[0] = &tmp->Color;
    }
@@ -486,8 +486,16 @@ void _tnl_imm_init( GLcontext *ctx )
 
    gl_vector4f_init( &tmp->Obj, 0, 0 );
    gl_vector3f_init( &tmp->Normal, 0, 0 );
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
    gl_vector4ub_init( &tmp->Color, 0, 0 );
    gl_vector4ub_init( &tmp->SecondaryColor, 0, 0 );
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+   gl_vector4us_init( &tmp->Color, 0, 0 );
+   gl_vector4us_init( &tmp->SecondaryColor, 0, 0 );
+#elif CHAN_TYPE == GL_FLOAT
+   gl_vector4f_init( &tmp->Color, 0, 0 );
+   gl_vector4f_init( &tmp->SecondaryColor, 0, 0 );
+#endif
    gl_vector1f_init( &tmp->FogCoord, 0, 0 );
    gl_vector1ui_init( &tmp->Index, 0, 0 );
    gl_vector1ub_init( &tmp->EdgeFlag, 0, 0 );
diff --git a/src/mesa/tnl/t_imm_fixup.c b/src/mesa/tnl/t_imm_fixup.c
index d4489160dd2..44bd4c4c338 100644
--- a/src/mesa/tnl/t_imm_fixup.c
+++ b/src/mesa/tnl/t_imm_fixup.c
@@ -1,4 +1,4 @@
-/* $Id: t_imm_fixup.c,v 1.3 2001/01/08 21:56:00 keithw Exp $ */
+/* $Id: t_imm_fixup.c,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -34,6 +34,7 @@
 #include "context.h"
 #include "enums.h"
 #include "dlist.h"
+#include "colormac.h"
 #include "macros.h"
 #include "mem.h"
 #include "mmath.h"
@@ -124,13 +125,13 @@ fixup_1ub( GLubyte *data, GLuint flag[], GLuint start, GLuint match )
 
 
 static void
-fixup_4ub( GLubyte data[][4], GLuint flag[], GLuint start, GLuint match )
+fixup_4chan( GLchan data[][4], GLuint flag[], GLuint start, GLuint match )
 {
    GLuint i = start;
 
    for (;;) {
       if ((flag[++i] & match) == 0) {
-	 COPY_4UBV(data[i], data[i-1]);
+	 COPY_CHAN4(data[i], data[i-1]);
 	 if (flag[i] & VERT_END_VB) break;
       }
    }
@@ -197,14 +198,14 @@ fixup_first_1ub( GLubyte data[], GLuint flag[], GLuint match,
 
 
 static void
-fixup_first_4ub( GLubyte data[][4], GLuint flag[], GLuint match,
-		 GLuint start, GLubyte dflt[4] )
+fixup_first_4chan( GLchan data[][4], GLuint flag[], GLuint match,
+                   GLuint start, GLchan dflt[4] )
 {
    GLuint i = start-1;
    match |= VERT_END_VB;
 
    while ((flag[++i]&match) == 0)
-      COPY_4UBV(data[i], dflt);
+      COPY_CHAN4(data[i], dflt);
 }
 
 
@@ -250,11 +251,11 @@ void _tnl_fixup_input( GLcontext *ctx, struct immediate *IM )
 	 }
 
 	 if (copy & VERT_RGBA) {
-	    COPY_4UBV( IM->Color[start], ctx->Current.Color);
+	    COPY_CHAN4( IM->Color[start], ctx->Current.Color);
 	 }
 
 	 if (copy & VERT_SPEC_RGB)
-	    COPY_4UBV( IM->SecondaryColor[start], ctx->Current.SecondaryColor);
+	    COPY_CHAN4( IM->SecondaryColor[start], ctx->Current.SecondaryColor);
 
 	 if (copy & VERT_FOG_COORD)
 	    IM->FogCoord[start] = ctx->Current.FogCoord;
@@ -308,17 +309,17 @@ void _tnl_fixup_input( GLcontext *ctx, struct immediate *IM )
 
    if (fixup & VERT_RGBA) {
       if (orflag & VERT_RGBA)
-	 fixup_4ub( IM->Color, IM->Flag, start, VERT_RGBA );
+	 fixup_4chan( IM->Color, IM->Flag, start, VERT_RGBA );
       else
-	 fixup_first_4ub( IM->Color, IM->Flag, VERT_END_VB, start, IM->Color[start] );
+	 fixup_first_4chan( IM->Color, IM->Flag, VERT_END_VB, start, IM->Color[start] );
    }
 
    if (fixup & VERT_SPEC_RGB) {
       if (orflag & VERT_SPEC_RGB)
-	 fixup_4ub( IM->SecondaryColor, IM->Flag, start, VERT_SPEC_RGB );
+	 fixup_4chan( IM->SecondaryColor, IM->Flag, start, VERT_SPEC_RGB );
       else
-	 fixup_first_4ub( IM->SecondaryColor, IM->Flag, VERT_END_VB, start,
-			  IM->SecondaryColor[start] );
+	 fixup_first_4chan( IM->SecondaryColor, IM->Flag, VERT_END_VB, start,
+                            IM->SecondaryColor[start] );
    }
 
    if (fixup & VERT_FOG_COORD) {
@@ -393,7 +394,7 @@ static void copy_vertices( GLcontext *ctx,
 
       COPY_4FV( next->Obj[dst], prev->Obj[src] );
       COPY_3FV( next->Normal[dst], prev->Normal[src] );      
-      COPY_4UBV( next->Color[dst], prev->Color[src] );
+      COPY_CHAN4( next->Color[dst], prev->Color[src] );
 
       if (prev->OrFlag & VERT_TEX_ANY) {
 	 GLuint i;
@@ -409,7 +410,7 @@ static void copy_vertices( GLcontext *ctx,
       next->Elt[dst] = prev->Elt[src];
       next->EdgeFlag[dst] = prev->EdgeFlag[src];
       next->Index[dst] = prev->Index[src];
-      COPY_4UBV( next->SecondaryColor[dst], prev->SecondaryColor[src] );
+      COPY_CHAN4( next->SecondaryColor[dst], prev->SecondaryColor[src] );
       next->FogCoord[dst] = prev->FogCoord[src];
       next->Flag[dst] = (prev->CopyOrFlag & VERT_FIXUP);
       next->CopyOrFlag |= prev->Flag[src];  /* redundant for current_im */
@@ -535,12 +536,12 @@ void _tnl_fixup_compiled_cassette( GLcontext *ctx, struct immediate *IM )
 			 ctx->Current.Index );
 
       if (fixup & VERT_RGBA)
-	 fixup_first_4ub(IM->Color, IM->Flag, VERT_RGBA, start,
-			 ctx->Current.Color );
+	 fixup_first_4chan(IM->Color, IM->Flag, VERT_RGBA, start,
+                           ctx->Current.Color );
 
       if (fixup & VERT_SPEC_RGB)
-	 fixup_first_4ub(IM->SecondaryColor, IM->Flag, VERT_SPEC_RGB, start,
-			 ctx->Current.SecondaryColor );
+	 fixup_first_4chan(IM->SecondaryColor, IM->Flag, VERT_SPEC_RGB, start,
+                           ctx->Current.SecondaryColor );
 
       if (fixup & VERT_FOG_COORD)
 	 fixup_first_1f(IM->FogCoord, IM->Flag, VERT_FOG_COORD, start,
@@ -783,7 +784,7 @@ void _tnl_fixup_purged_eval( GLcontext *ctx,
       fixup_1ui( store->Index, flags, 0, VERT_INDEX|fixup_fence );
 
    if (fixup & VERT_RGBA) 
-      fixup_4ub( store->Color, flags, 0, VERT_RGBA|fixup_fence );
+      fixup_4chan( store->Color, flags, 0, VERT_RGBA|fixup_fence );
 
    if (fixup & VERT_NORM) 
       fixup_3f( store->Normal, flags, 0, VERT_NORM|fixup_fence );
diff --git a/src/mesa/tnl/t_vb_light.c b/src/mesa/tnl/t_vb_light.c
index 60a87ef8abd..a4f7cfa3c31 100644
--- a/src/mesa/tnl/t_vb_light.c
+++ b/src/mesa/tnl/t_vb_light.c
@@ -1,4 +1,4 @@
-/* $Id: t_vb_light.c,v 1.4 2001/01/23 23:39:37 brianp Exp $ */
+/* $Id: t_vb_light.c,v 1.5 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -49,10 +49,17 @@ typedef void (*light_func)( GLcontext *ctx,
 			    GLvector4f *input );
 
 struct light_stage_data {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
    GLvector4ub LitColor[2];
-   GLvector1ui LitIndex[2];
    GLvector4ub LitSecondary[2];
-
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+   GLvector4us LitColor[2];
+   GLvector4us LitSecondary[2];
+#elif CHAN_TYPE == GL_FLOAT
+   GLvector4f LitColor[2];
+   GLvector4f LitSecondary[2];
+#endif
+   GLvector1ui LitIndex[2];
    light_func *light_func_tab;
 };
 
@@ -216,10 +223,22 @@ static GLboolean run_init_lighting( GLcontext *ctx,
     */
    init_lighting();
 
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
    gl_vector4ub_alloc( &store->LitColor[0], 0, size, 32 );
    gl_vector4ub_alloc( &store->LitColor[1], 0, size, 32 );
    gl_vector4ub_alloc( &store->LitSecondary[0], 0, size, 32 );
    gl_vector4ub_alloc( &store->LitSecondary[1], 0, size, 32 );
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+   gl_vector4us_alloc( &store->LitColor[0], 0, size, 32 );
+   gl_vector4us_alloc( &store->LitColor[1], 0, size, 32 );
+   gl_vector4us_alloc( &store->LitSecondary[0], 0, size, 32 );
+   gl_vector4us_alloc( &store->LitSecondary[1], 0, size, 32 );
+#elif CHAN_TYPE == GL_FLOAT
+   gl_vector4f_alloc( &store->LitColor[0], 0, size, 32 );
+   gl_vector4f_alloc( &store->LitColor[1], 0, size, 32 );
+   gl_vector4f_alloc( &store->LitSecondary[0], 0, size, 32 );
+   gl_vector4f_alloc( &store->LitSecondary[1], 0, size, 32 );
+#endif
    gl_vector1ui_alloc( &store->LitIndex[0], 0, size, 32 );
    gl_vector1ui_alloc( &store->LitIndex[1], 0, size, 32 );
 
@@ -259,12 +278,24 @@ static void dtr( struct gl_pipeline_stage *stage )
    struct light_stage_data *store = LIGHT_STAGE_DATA(stage);
 
    if (store) {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
       gl_vector4ub_free( &store->LitColor[0] );      
       gl_vector4ub_free( &store->LitColor[1] );      
-      gl_vector1ui_free( &store->LitIndex[0] );      
-      gl_vector1ui_free( &store->LitIndex[1] );      
       gl_vector4ub_free( &store->LitSecondary[0] );  
       gl_vector4ub_free( &store->LitSecondary[1] );  
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+      gl_vector4us_free( &store->LitColor[0] );      
+      gl_vector4us_free( &store->LitColor[1] );      
+      gl_vector4us_free( &store->LitSecondary[0] );  
+      gl_vector4us_free( &store->LitSecondary[1] );  
+#elif CHAN_TYPE == GL_FLOAT
+      gl_vector4f_free( &store->LitColor[0] );      
+      gl_vector4f_free( &store->LitColor[1] );      
+      gl_vector4f_free( &store->LitSecondary[0] );  
+      gl_vector4f_free( &store->LitSecondary[1] );  
+#endif
+      gl_vector1ui_free( &store->LitIndex[0] );      
+      gl_vector1ui_free( &store->LitIndex[1] );      
       FREE( store );
       stage->private = 0;
    }
diff --git a/src/mesa/tnl/t_vb_lighttmp.h b/src/mesa/tnl/t_vb_lighttmp.h
index 575c568c06f..1fe896c6068 100644
--- a/src/mesa/tnl/t_vb_lighttmp.h
+++ b/src/mesa/tnl/t_vb_lighttmp.h
@@ -1,4 +1,4 @@
-/* $Id: t_vb_lighttmp.h,v 1.3 2001/01/17 02:49:39 keithw Exp $ */
+/* $Id: t_vb_lighttmp.h,v 1.4 2001/01/24 00:05:00 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -36,7 +36,7 @@
 #  define CHECK_MATERIAL(x)  (flags[x] & VERT_MATERIAL)
 #  define CHECK_END_VB(x)    (flags[x] & VERT_END_VB)
 #  if (IDX & LIGHT_COLORMATERIAL)
-#    define CMSTRIDE STRIDE_4UB(CMcolor, (4 * sizeof(GLubyte)))
+#    define CMSTRIDE STRIDE_4CHAN(CMcolor, (4 * sizeof(GLchan)))
 #    define CHECK_COLOR_MATERIAL(x) (flags[x] & VERT_RGBA)
 #    define CHECK_VALIDATE(x) (flags[x] & (VERT_RGBA|VERT_MATERIAL))
 #    define DO_ANOTHER_NORMAL(x) \
@@ -58,7 +58,7 @@
 #  define CHECK_MATERIAL(x)   0	           /* no materials on array paths */
 #  define CHECK_END_VB(XX)     (XX >= nr)        
 #  if (IDX & LIGHT_COLORMATERIAL)
-#     define CMSTRIDE STRIDE_4UB(CMcolor, CMstride)
+#     define CMSTRIDE STRIDE_4CHAN(CMcolor, CMstride)
 #     define CHECK_COLOR_MATERIAL(x) (x < nr) /* always have colormaterial */
 #     define CHECK_VALIDATE(x) (x < nr)
 #     define DO_ANOTHER_NORMAL(x) 0        /* always stop to recalc colormat */
@@ -307,7 +307,7 @@ static void TAG(light_rgba)( GLcontext *ctx,
    GLuint  nstride = VB->NormalPtr->stride; 
    const GLfloat *normal = (GLfloat *)VB->NormalPtr->data;
 
-   GLubyte (*CMcolor)[4];
+   GLchan (*CMcolor)[4];
    GLuint CMstride;
 
    GLchan (*Fcolor)[4] = (GLchan (*)[4]) store->LitColor[0].data;
@@ -508,7 +508,7 @@ static void TAG(light_fast_rgba_single)( GLcontext *ctx,
    struct light_stage_data *store = LIGHT_STAGE_DATA(stage);
    GLuint  nstride = VB->NormalPtr->stride; 
    const GLfloat *normal = (GLfloat *)VB->NormalPtr->data;
-   GLubyte (*CMcolor)[4];
+   GLchan (*CMcolor)[4];
    GLuint CMstride;
    GLchan (*Fcolor)[4] = (GLchan (*)[4]) store->LitColor[0].data;
    GLchan (*Bcolor)[4] = (GLchan (*)[4]) store->LitColor[1].data;
@@ -636,7 +636,7 @@ static void TAG(light_fast_rgba)( GLcontext *ctx,
    const GLchan *sumA = ctx->Light._BaseAlpha;
    GLuint  nstride = VB->NormalPtr->stride; 
    const GLfloat *normal = (GLfloat *)VB->NormalPtr->data;
-   GLubyte (*CMcolor)[4];
+   GLchan (*CMcolor)[4];
    GLuint CMstride;
    GLchan (*Fcolor)[4] = (GLchan (*)[4]) store->LitColor[0].data;
    GLchan (*Bcolor)[4] = (GLchan (*)[4]) store->LitColor[1].data;
@@ -770,7 +770,7 @@ static void TAG(light_ci)( GLcontext *ctx,
    const GLfloat *vertex = (GLfloat *) input->data;
    GLuint  nstride = VB->NormalPtr->stride; 
    const GLfloat *normal = (GLfloat *)VB->NormalPtr->data;
-   GLubyte (*CMcolor)[4];
+   GLchan (*CMcolor)[4];
    GLuint CMstride;
    GLuint *flags = VB->Flag;
    GLuint  *indexResult[2];