swrast: do texture sampling/combining in floating point

The code's cleaner and a step toward supporting float-valued texture sampling.
Some optimizations for common cases can be added and re-enabled...

1 files changed, 314 insertions, 513 deletions

diff --git a/src/mesa/swrast/s_texcombine.c b/src/mesa/swrast/s_texcombine.c
index aa28311672d..c48a6fb1141 100644
--- a/src/mesa/swrast/s_texcombine.c
+++ b/src/mesa/swrast/s_texcombine.c
@@ -37,13 +37,7 @@
 #include "s_texcombine.h"
 
 
-#define PROD(A,B)   ( (GLuint)(A) * ((GLuint)(B)+1) )
-#define S_PROD(A,B) ( (GLint)(A) * ((GLint)(B)+1) )
-#if CHAN_BITS == 32
-typedef GLfloat ChanTemp;
-#else
-typedef GLuint ChanTemp;
-#endif
+#define MAX_COMBINER_TERMS 4
 
 
 /**
@@ -63,32 +57,36 @@ typedef GLuint ChanTemp;
  */
 static void
 texture_combine( const GLcontext *ctx, GLuint unit, GLuint n,
-                 CONST GLchan (*primary_rgba)[4],
-                 CONST GLchan *texelBuffer,
-                 GLchan (*rgba)[4] )
+                 CONST GLfloat (*primary_rgba)[4],
+                 CONST GLfloat *texelBuffer,
+                 GLchan (*rgbaChan)[4] )
 {
    const struct gl_texture_unit *textureUnit = &(ctx->Texture.Unit[unit]);
-   const GLchan (*argRGB [4])[4];
-   const GLchan (*argA [4])[4];
+   const GLfloat (*argRGB [MAX_COMBINER_TERMS])[4];
+   const GLfloat (*argA [MAX_COMBINER_TERMS])[4];
    const GLint RGBshift = textureUnit->_CurrentCombine->ScaleShiftRGB;
    const GLuint Ashift   = textureUnit->_CurrentCombine->ScaleShiftA;
-#if CHAN_TYPE == GL_FLOAT
-   const GLchan RGBmult = (GLfloat) (1 << RGBshift);
-   const GLchan Amult = (GLfloat) (1 << Ashift);
-#else
-   const GLint half = (CHAN_MAX + 1) / 2;
-#endif
-   static const GLchan one[4] = { CHAN_MAX, CHAN_MAX, CHAN_MAX, CHAN_MAX };
-   static const GLchan zero[4] = { 0, 0, 0, 0 };
+   const GLfloat RGBmult = (GLfloat) (1 << RGBshift);
+   const GLfloat Amult = (GLfloat) (1 << Ashift);
+   static const GLfloat one[4] = { 1, 1, 1, 1 };
+   static const GLfloat zero[4] = { 0, 0, 0, 0 };
    const GLuint numColorArgs = textureUnit->_CurrentCombine->_NumArgsRGB;
    const GLuint numAlphaArgs = textureUnit->_CurrentCombine->_NumArgsA;
-   GLchan ccolor[4][MAX_WIDTH][4];
+   GLfloat ccolor[MAX_COMBINER_TERMS][MAX_WIDTH][4]; /* temp color buffers */
+   GLfloat rgba[MAX_WIDTH][4];
    GLuint i, j;
 
    ASSERT(ctx->Extensions.EXT_texture_env_combine ||
           ctx->Extensions.ARB_texture_env_combine);
    ASSERT(CONST_SWRAST_CONTEXT(ctx)->_AnyTextureCombine);
 
+   for (i = 0; i < n; i++) {
+      rgba[i][RCOMP] = CHAN_TO_FLOAT(rgbaChan[i][RCOMP]);
+      rgba[i][GCOMP] = CHAN_TO_FLOAT(rgbaChan[i][GCOMP]);
+      rgba[i][BCOMP] = CHAN_TO_FLOAT(rgbaChan[i][BCOMP]);
+      rgba[i][ACOMP] = CHAN_TO_FLOAT(rgbaChan[i][ACOMP]);
+   }
+
    /*
    printf("modeRGB 0x%x  modeA 0x%x  srcRGB1 0x%x  srcA1 0x%x  srcRGB2 0x%x  srcA2 0x%x\n",
           textureUnit->_CurrentCombine->ModeRGB,
@@ -107,39 +105,47 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n,
 
       switch (srcRGB) {
          case GL_TEXTURE:
-            argRGB[j] = (const GLchan (*)[4])
-               (texelBuffer + unit * (n * 4 * sizeof(GLchan)));
+            argRGB[j] = (const GLfloat (*)[4])
+               (texelBuffer + unit * (n * 4 * sizeof(GLfloat)));
             break;
          case GL_PRIMARY_COLOR:
             argRGB[j] = primary_rgba;
             break;
          case GL_PREVIOUS:
-            argRGB[j] = (const GLchan (*)[4]) rgba;
+            argRGB[j] = (const GLfloat (*)[4]) rgba;
             break;
          case GL_CONSTANT:
             {
-               GLchan (*c)[4] = ccolor[j];
-               GLchan red, green, blue, alpha;
-               UNCLAMPED_FLOAT_TO_CHAN(red,   textureUnit->EnvColor[0]);
-               UNCLAMPED_FLOAT_TO_CHAN(green, textureUnit->EnvColor[1]);
-               UNCLAMPED_FLOAT_TO_CHAN(blue,  textureUnit->EnvColor[2]);
-               UNCLAMPED_FLOAT_TO_CHAN(alpha, textureUnit->EnvColor[3]);
+               GLfloat (*c)[4] = ccolor[j];
+               GLfloat red   = textureUnit->EnvColor[0];
+               GLfloat green = textureUnit->EnvColor[1];
+               GLfloat blue  = textureUnit->EnvColor[2];
+               GLfloat alpha = textureUnit->EnvColor[3];
                for (i = 0; i < n; i++) {
-                  c[i][RCOMP] = red;
-                  c[i][GCOMP] = green;
-                  c[i][BCOMP] = blue;
-                  c[i][ACOMP] = alpha;
+                  ASSIGN_4V(c[i], red, green, blue, alpha);
                }
-               argRGB[j] = (const GLchan (*)[4]) ccolor[j];
+               argRGB[j] = (const GLfloat (*)[4]) ccolor[j];
             }
             break;
 	 /* GL_ATI_texture_env_combine3 allows GL_ZERO & GL_ONE as sources.
 	  */
 	 case GL_ZERO:
-            argRGB[j] = & zero;
+            {
+               GLfloat (*c)[4] = ccolor[j];
+               for (i = 0; i < n; i++) {
+                  ASSIGN_4V(c[i], 0.0F, 0.0F, 0.0F, 0.0F);
+               }
+               argRGB[j] = (const GLfloat (*)[4]) ccolor[j];
+            }
             break;
 	 case GL_ONE:
-            argRGB[j] = & one;
+            {
+               GLfloat (*c)[4] = ccolor[j];
+               for (i = 0; i < n; i++) {
+                  ASSIGN_4V(c[i], 1.0F, 1.0F, 1.0F, 1.0F);
+               }
+               argRGB[j] = (const GLfloat (*)[4]) ccolor[j];
+            }
             break;
          default:
             /* ARB_texture_env_crossbar source */
@@ -148,23 +154,23 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n,
                ASSERT(srcUnit < ctx->Const.MaxTextureUnits);
                if (!ctx->Texture.Unit[srcUnit]._ReallyEnabled)
                   return;
-               argRGB[j] = (const GLchan (*)[4])
-                  (texelBuffer + srcUnit * (n * 4 * sizeof(GLchan)));
+               argRGB[j] = (const GLfloat (*)[4])
+                  (texelBuffer + srcUnit * (n * 4 * sizeof(GLfloat)));
             }
       }
 
       if (textureUnit->_CurrentCombine->OperandRGB[j] != GL_SRC_COLOR) {
-         const GLchan (*src)[4] = argRGB[j];
-         GLchan (*dst)[4] = ccolor[j];
+         const GLfloat (*src)[4] = argRGB[j];
+         GLfloat (*dst)[4] = ccolor[j];
 
          /* point to new arg[j] storage */
-         argRGB[j] = (const GLchan (*)[4]) ccolor[j];
+         argRGB[j] = (const GLfloat (*)[4]) ccolor[j];
 
          if (textureUnit->_CurrentCombine->OperandRGB[j] == GL_ONE_MINUS_SRC_COLOR) {
             for (i = 0; i < n; i++) {
-               dst[i][RCOMP] = CHAN_MAX - src[i][RCOMP];
-               dst[i][GCOMP] = CHAN_MAX - src[i][GCOMP];
-               dst[i][BCOMP] = CHAN_MAX - src[i][BCOMP];
+               dst[i][RCOMP] = 1.0F - src[i][RCOMP];
+               dst[i][GCOMP] = 1.0F - src[i][GCOMP];
+               dst[i][BCOMP] = 1.0F - src[i][BCOMP];
             }
          }
          else if (textureUnit->_CurrentCombine->OperandRGB[j] == GL_SRC_ALPHA) {
@@ -177,9 +183,9 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n,
          else {
             ASSERT(textureUnit->_CurrentCombine->OperandRGB[j] ==GL_ONE_MINUS_SRC_ALPHA);
             for (i = 0; i < n; i++) {
-               dst[i][RCOMP] = CHAN_MAX - src[i][ACOMP];
-               dst[i][GCOMP] = CHAN_MAX - src[i][ACOMP];
-               dst[i][BCOMP] = CHAN_MAX - src[i][ACOMP];
+               dst[i][RCOMP] = 1.0F - src[i][ACOMP];
+               dst[i][GCOMP] = 1.0F - src[i][ACOMP];
+               dst[i][BCOMP] = 1.0F - src[i][ACOMP];
             }
          }
       }
@@ -193,22 +199,22 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n,
 
       switch (srcA) {
          case GL_TEXTURE:
-            argA[j] = (const GLchan (*)[4])
-               (texelBuffer + unit * (n * 4 * sizeof(GLchan)));
+            argA[j] = (const GLfloat (*)[4])
+               (texelBuffer + unit * (n * 4 * sizeof(GLfloat)));
             break;
          case GL_PRIMARY_COLOR:
             argA[j] = primary_rgba;
             break;
          case GL_PREVIOUS:
-            argA[j] = (const GLchan (*)[4]) rgba;
+            argA[j] = (const GLfloat (*)[4]) rgba;
             break;
          case GL_CONSTANT:
             {
-               GLchan alpha, (*c)[4] = ccolor[j];
-               UNCLAMPED_FLOAT_TO_CHAN(alpha, textureUnit->EnvColor[3]);
+               GLfloat alpha, (*c)[4] = ccolor[j];
+               alpha = textureUnit->EnvColor[3];
                for (i = 0; i < n; i++)
                   c[i][ACOMP] = alpha;
-               argA[j] = (const GLchan (*)[4]) ccolor[j];
+               argA[j] = (const GLfloat (*)[4]) ccolor[j];
             }
             break;
 	 /* GL_ATI_texture_env_combine3 allows GL_ZERO & GL_ONE as sources.
@@ -226,17 +232,17 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n,
                ASSERT(srcUnit < ctx->Const.MaxTextureUnits);
                if (!ctx->Texture.Unit[srcUnit]._ReallyEnabled)
                   return;
-               argA[j] = (const GLchan (*)[4])
-                  (texelBuffer + srcUnit * (n * 4 * sizeof(GLchan)));
+               argA[j] = (const GLfloat (*)[4])
+                  (texelBuffer + srcUnit * (n * 4 * sizeof(GLfloat)));
             }
       }
 
       if (textureUnit->_CurrentCombine->OperandA[j] == GL_ONE_MINUS_SRC_ALPHA) {
-         const GLchan (*src)[4] = argA[j];
-         GLchan (*dst)[4] = ccolor[j];
-         argA[j] = (const GLchan (*)[4]) ccolor[j];
+         const GLfloat (*src)[4] = argA[j];
+         GLfloat (*dst)[4] = ccolor[j];
+         argA[j] = (const GLfloat (*)[4]) ccolor[j];
          for (i = 0; i < n; i++) {
-            dst[i][ACOMP] = CHAN_MAX - src[i][ACOMP];
+            dst[i][ACOMP] = 1.0F - src[i][ACOMP];
          }
       }
    }
@@ -247,21 +253,12 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n,
    switch (textureUnit->_CurrentCombine->ModeRGB) {
       case GL_REPLACE:
          {
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argRGB[0];
             if (RGBshift) {
                for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
                   rgba[i][RCOMP] = arg0[i][RCOMP] * RGBmult;
                   rgba[i][GCOMP] = arg0[i][GCOMP] * RGBmult;
                   rgba[i][BCOMP] = arg0[i][BCOMP] * RGBmult;
-#else
-                  GLuint r = (GLuint) arg0[i][RCOMP] << RGBshift;
-                  GLuint g = (GLuint) arg0[i][GCOMP] << RGBshift;
-                  GLuint b = (GLuint) arg0[i][BCOMP] << RGBshift;
-                  rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
-                  rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
-                  rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
-#endif
                }
             }
             else {
@@ -275,179 +272,91 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n,
          break;
       case GL_MODULATE:
          {
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
-#if CHAN_TYPE != GL_FLOAT
-            const GLint shift = CHAN_BITS - RGBshift;
-#endif
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argRGB[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argRGB[1];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
                rgba[i][RCOMP] = arg0[i][RCOMP] * arg1[i][RCOMP] * RGBmult;
                rgba[i][GCOMP] = arg0[i][GCOMP] * arg1[i][GCOMP] * RGBmult;
                rgba[i][BCOMP] = arg0[i][BCOMP] * arg1[i][BCOMP] * RGBmult;
-#else
-               GLuint r = PROD(arg0[i][RCOMP], arg1[i][RCOMP]) >> shift;
-               GLuint g = PROD(arg0[i][GCOMP], arg1[i][GCOMP]) >> shift;
-               GLuint b = PROD(arg0[i][BCOMP], arg1[i][BCOMP]) >> shift;
-               rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
-               rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
-               rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
-#endif
             }
          }
          break;
       case GL_ADD:
          if (textureUnit->EnvMode == GL_COMBINE4_NV) {
             /* (a * b) + (c * d) */
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
-            const GLchan (*arg2)[4] = (const GLchan (*)[4]) argRGB[2];
-            const GLchan (*arg3)[4] = (const GLchan (*)[4]) argRGB[3];
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argRGB[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argRGB[1];
+            const GLfloat (*arg2)[4] = (const GLfloat (*)[4]) argRGB[2];
+            const GLfloat (*arg3)[4] = (const GLfloat (*)[4]) argRGB[3];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
                rgba[i][RCOMP] = (arg0[i][RCOMP] * arg1[i][RCOMP] +
                                  arg2[i][RCOMP] * arg3[i][RCOMP]) * RGBmult;
                rgba[i][GCOMP] = (arg0[i][GCOMP] * arg1[i][GCOMP] +
                                  arg2[i][GCOMP] * arg3[i][GCOMP]) * RGBmult;
                rgba[i][BCOMP] = (arg0[i][BCOMP] * arg1[i][BCOMP] +
                                  arg2[i][BCOMP] * arg3[i][BCOMP]) * RGBmult;
-#else
-               const GLint shift = CHAN_BITS - RGBshift;
-               GLint r = (PROD(arg0[i][RCOMP], arg1[i][RCOMP]) >> shift) +
-                         (PROD(arg2[i][RCOMP], arg3[i][RCOMP]) >> shift);
-               GLint g = (PROD(arg0[i][GCOMP], arg1[i][GCOMP]) >> shift) +
-                         (PROD(arg2[i][GCOMP], arg3[i][GCOMP]) >> shift);
-               GLint b = (PROD(arg0[i][BCOMP], arg1[i][BCOMP]) >> shift) +
-                         (PROD(arg2[i][BCOMP], arg3[i][BCOMP]) >> shift);
-               rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
-               rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
-               rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
-#endif
             }
          }
          else {
             /* 2-term addition */
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argRGB[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argRGB[1];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
                rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP]) * RGBmult;
                rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP]) * RGBmult;
                rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP]) * RGBmult;
-#else
-               GLint r = ((GLint) arg0[i][RCOMP] + (GLint) arg1[i][RCOMP]) << RGBshift;
-               GLint g = ((GLint) arg0[i][GCOMP] + (GLint) arg1[i][GCOMP]) << RGBshift;
-               GLint b = ((GLint) arg0[i][BCOMP] + (GLint) arg1[i][BCOMP]) << RGBshift;
-               rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
-               rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
-               rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
-#endif
             }
          }
          break;
       case GL_ADD_SIGNED:
          if (textureUnit->EnvMode == GL_COMBINE4_NV) {
             /* (a * b) + (c * d) - 0.5 */
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
-            const GLchan (*arg2)[4] = (const GLchan (*)[4]) argRGB[2];
-            const GLchan (*arg3)[4] = (const GLchan (*)[4]) argRGB[3];
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argRGB[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argRGB[1];
+            const GLfloat (*arg2)[4] = (const GLfloat (*)[4]) argRGB[2];
+            const GLfloat (*arg3)[4] = (const GLfloat (*)[4]) argRGB[3];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
                rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP] *
                                  arg2[i][RCOMP] + arg3[i][RCOMP] - 0.5) * RGBmult;
                rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP] *
                                  arg2[i][GCOMP] + arg3[i][GCOMP] - 0.5) * RGBmult;
                rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP] *
                                  arg2[i][BCOMP] + arg3[i][BCOMP] - 0.5) * RGBmult;
-#else
-               GLint r = (((PROD(arg0[i][RCOMP], arg1[i][RCOMP]) +
-                            PROD(arg2[i][RCOMP], arg3[i][RCOMP])) >> CHAN_BITS) - half)
-                          << RGBshift;
-               GLint g = (((PROD(arg0[i][GCOMP], arg1[i][GCOMP]) +
-                            PROD(arg2[i][GCOMP], arg3[i][GCOMP])) >> CHAN_BITS) - half)
-                          << RGBshift;
-               GLint b = (((PROD(arg0[i][BCOMP], arg1[i][BCOMP]) +
-                            PROD(arg2[i][BCOMP], arg3[i][BCOMP])) >> CHAN_BITS) - half)
-                          << RGBshift;
-               rgba[i][RCOMP] = (GLchan) CLAMP(r, 0, CHAN_MAX);
-               rgba[i][GCOMP] = (GLchan) CLAMP(g, 0, CHAN_MAX);
-               rgba[i][BCOMP] = (GLchan) CLAMP(b, 0, CHAN_MAX);
-#endif
             }
          }
          else {
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argRGB[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argRGB[1];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
                rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP] - 0.5) * RGBmult;
                rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP] - 0.5) * RGBmult;
                rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP] - 0.5) * RGBmult;
-#else
-               GLint r = (GLint) arg0[i][RCOMP] + (GLint) arg1[i][RCOMP] - half;
-               GLint g = (GLint) arg0[i][GCOMP] + (GLint) arg1[i][GCOMP] - half;
-               GLint b = (GLint) arg0[i][BCOMP] + (GLint) arg1[i][BCOMP] - half;
-               r = (r < 0) ? 0 : r << RGBshift;
-               g = (g < 0) ? 0 : g << RGBshift;
-               b = (b < 0) ? 0 : b << RGBshift;
-               rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
-               rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
-               rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
-#endif
             }
          }
          break;
       case GL_INTERPOLATE:
          {
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
-            const GLchan (*arg2)[4] = (const GLchan (*)[4]) argRGB[2];
-#if CHAN_TYPE != GL_FLOAT
-            const GLint shift = CHAN_BITS - RGBshift;
-#endif
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argRGB[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argRGB[1];
+            const GLfloat (*arg2)[4] = (const GLfloat (*)[4]) argRGB[2];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
                rgba[i][RCOMP] = (arg0[i][RCOMP] * arg2[i][RCOMP] +
-                      arg1[i][RCOMP] * (CHAN_MAXF - arg2[i][RCOMP])) * RGBmult;
+                      arg1[i][RCOMP] * (1.0F - arg2[i][RCOMP])) * RGBmult;
                rgba[i][GCOMP] = (arg0[i][GCOMP] * arg2[i][GCOMP] +
-                      arg1[i][GCOMP] * (CHAN_MAXF - arg2[i][GCOMP])) * RGBmult;
+                      arg1[i][GCOMP] * (1.0F - arg2[i][GCOMP])) * RGBmult;
                rgba[i][BCOMP] = (arg0[i][BCOMP] * arg2[i][BCOMP] +
-                      arg1[i][BCOMP] * (CHAN_MAXF - arg2[i][BCOMP])) * RGBmult;
-#else
-               GLuint r = (PROD(arg0[i][RCOMP], arg2[i][RCOMP])
-                           + PROD(arg1[i][RCOMP], CHAN_MAX - arg2[i][RCOMP]))
-                              >> shift;
-               GLuint g = (PROD(arg0[i][GCOMP], arg2[i][GCOMP])
-                           + PROD(arg1[i][GCOMP], CHAN_MAX - arg2[i][GCOMP]))
-                              >> shift;
-               GLuint b = (PROD(arg0[i][BCOMP], arg2[i][BCOMP])
-                           + PROD(arg1[i][BCOMP], CHAN_MAX - arg2[i][BCOMP]))
-                              >> shift;
-               rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
-               rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
-               rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
-#endif
+                      arg1[i][BCOMP] * (1.0F - arg2[i][BCOMP])) * RGBmult;
             }
          }
          break;
       case GL_SUBTRACT:
          {
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argRGB[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argRGB[1];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
                rgba[i][RCOMP] = (arg0[i][RCOMP] - arg1[i][RCOMP]) * RGBmult;
                rgba[i][GCOMP] = (arg0[i][GCOMP] - arg1[i][GCOMP]) * RGBmult;
                rgba[i][BCOMP] = (arg0[i][BCOMP] - arg1[i][BCOMP]) * RGBmult;
-#else
-               GLint r = ((GLint) arg0[i][RCOMP] - (GLint) arg1[i][RCOMP]) << RGBshift;
-               GLint g = ((GLint) arg0[i][GCOMP] - (GLint) arg1[i][GCOMP]) << RGBshift;
-               GLint b = ((GLint) arg0[i][BCOMP] - (GLint) arg1[i][BCOMP]) << RGBshift;
-               rgba[i][RCOMP] = (GLchan) CLAMP(r, 0, CHAN_MAX);
-               rgba[i][GCOMP] = (GLchan) CLAMP(g, 0, CHAN_MAX);
-               rgba[i][BCOMP] = (GLchan) CLAMP(b, 0, CHAN_MAX);
-#endif
             }
          }
          break;
@@ -455,25 +364,15 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n,
       case GL_DOT3_RGBA_EXT:
          {
             /* Do not scale the result by 1 2 or 4 */
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argRGB[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argRGB[1];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
-               GLchan dot = ((arg0[i][RCOMP]-0.5F) * (arg1[i][RCOMP]-0.5F) +
+               GLfloat dot = ((arg0[i][RCOMP]-0.5F) * (arg1[i][RCOMP]-0.5F) +
                              (arg0[i][GCOMP]-0.5F) * (arg1[i][GCOMP]-0.5F) +
                              (arg0[i][BCOMP]-0.5F) * (arg1[i][BCOMP]-0.5F))
                             * 4.0F;
-               dot = CLAMP(dot, 0.0F, CHAN_MAXF);
-#else
-               GLint dot = (S_PROD((GLint)arg0[i][RCOMP] - half,
-				   (GLint)arg1[i][RCOMP] - half) +
-			    S_PROD((GLint)arg0[i][GCOMP] - half,
-				   (GLint)arg1[i][GCOMP] - half) +
-			    S_PROD((GLint)arg0[i][BCOMP] - half,
-				   (GLint)arg1[i][BCOMP] - half)) >> 6;
-               dot = CLAMP(dot, 0, CHAN_MAX);
-#endif
-               rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = (GLchan) dot;
+               dot = CLAMP(dot, 0.0F, 1.0F);
+               rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = (GLfloat) dot;
             }
          }
          break;
@@ -481,113 +380,60 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n,
       case GL_DOT3_RGBA:
          {
             /* DO scale the result by 1 2 or 4 */
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argRGB[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argRGB[1];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
-               GLchan dot = ((arg0[i][RCOMP]-0.5F) * (arg1[i][RCOMP]-0.5F) +
+               GLfloat dot = ((arg0[i][RCOMP]-0.5F) * (arg1[i][RCOMP]-0.5F) +
                              (arg0[i][GCOMP]-0.5F) * (arg1[i][GCOMP]-0.5F) +
                              (arg0[i][BCOMP]-0.5F) * (arg1[i][BCOMP]-0.5F))
                             * 4.0F * RGBmult;
-               dot = CLAMP(dot, 0.0, CHAN_MAXF);
-#else
-               GLint dot = (S_PROD((GLint)arg0[i][RCOMP] - half,
-				   (GLint)arg1[i][RCOMP] - half) +
-			    S_PROD((GLint)arg0[i][GCOMP] - half,
-				   (GLint)arg1[i][GCOMP] - half) +
-			    S_PROD((GLint)arg0[i][BCOMP] - half,
-				   (GLint)arg1[i][BCOMP] - half)) >> 6;
-               dot <<= RGBshift;
-               dot = CLAMP(dot, 0, CHAN_MAX);
-#endif
-               rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = (GLchan) dot;
+               dot = CLAMP(dot, 0.0, 1.0F);
+               rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = (GLfloat) dot;
             }
          }
          break;
       case GL_MODULATE_ADD_ATI:
          {
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
-            const GLchan (*arg2)[4] = (const GLchan (*)[4]) argRGB[2];
-#if CHAN_TYPE != GL_FLOAT
-            const GLint shift = CHAN_BITS - RGBshift;
-#endif
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argRGB[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argRGB[1];
+            const GLfloat (*arg2)[4] = (const GLfloat (*)[4]) argRGB[2];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
-               rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) + arg1[i][RCOMP]) * RGBmult;
-               rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) + arg1[i][GCOMP]) * RGBmult;
-               rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) + arg1[i][BCOMP]) * RGBmult;
-#else
-               GLuint r = (PROD(arg0[i][RCOMP], arg2[i][RCOMP])
-                           + ((GLuint) arg1[i][RCOMP] << CHAN_BITS)) >> shift;
-               GLuint g = (PROD(arg0[i][GCOMP], arg2[i][GCOMP])
-                           + ((GLuint) arg1[i][GCOMP] << CHAN_BITS)) >> shift;
-               GLuint b = (PROD(arg0[i][BCOMP], arg2[i][BCOMP])
-                           + ((GLuint) arg1[i][BCOMP] << CHAN_BITS)) >> shift;
-               rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
-               rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
-               rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
-#endif
+               rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) +
+                                 arg1[i][RCOMP]) * RGBmult;
+               rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) +
+                                 arg1[i][GCOMP]) * RGBmult;
+               rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) +
+                                 arg1[i][BCOMP]) * RGBmult;
             }
 	 }
          break;
       case GL_MODULATE_SIGNED_ADD_ATI:
          {
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
-            const GLchan (*arg2)[4] = (const GLchan (*)[4]) argRGB[2];
-#if CHAN_TYPE != GL_FLOAT
-            const GLint shift = CHAN_BITS - RGBshift;
-#endif
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argRGB[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argRGB[1];
+            const GLfloat (*arg2)[4] = (const GLfloat (*)[4]) argRGB[2];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
-               rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) + arg1[i][RCOMP] - 0.5) * RGBmult;
-               rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) + arg1[i][GCOMP] - 0.5) * RGBmult;
-               rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) + arg1[i][BCOMP] - 0.5) * RGBmult;
-#else
-               GLint r = (S_PROD(arg0[i][RCOMP], arg2[i][RCOMP])
-			  + (((GLint) arg1[i][RCOMP] - half) << CHAN_BITS))
-		    >> shift;
-               GLint g = (S_PROD(arg0[i][GCOMP], arg2[i][GCOMP])
-			  + (((GLint) arg1[i][GCOMP] - half) << CHAN_BITS))
-		    >> shift;
-               GLint b = (S_PROD(arg0[i][BCOMP], arg2[i][BCOMP])
-			  + (((GLint) arg1[i][BCOMP] - half) << CHAN_BITS))
-		    >> shift;
-               rgba[i][RCOMP] = (GLchan) CLAMP(r, 0, CHAN_MAX);
-               rgba[i][GCOMP] = (GLchan) CLAMP(g, 0, CHAN_MAX);
-               rgba[i][BCOMP] = (GLchan) CLAMP(b, 0, CHAN_MAX);
-#endif
+               rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) +
+                                 arg1[i][RCOMP] - 0.5) * RGBmult;
+               rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) +
+                                 arg1[i][GCOMP] - 0.5) * RGBmult;
+               rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) +
+                                 arg1[i][BCOMP] - 0.5) * RGBmult;
             }
 	 }
          break;
       case GL_MODULATE_SUBTRACT_ATI:
          {
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
-            const GLchan (*arg2)[4] = (const GLchan (*)[4]) argRGB[2];
-#if CHAN_TYPE != GL_FLOAT
-            const GLint shift = CHAN_BITS - RGBshift;
-#endif
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argRGB[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argRGB[1];
+            const GLfloat (*arg2)[4] = (const GLfloat (*)[4]) argRGB[2];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
-               rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) - arg1[i][RCOMP]) * RGBmult;
-               rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) - arg1[i][GCOMP]) * RGBmult;
-               rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) - arg1[i][BCOMP]) * RGBmult;
-#else
-               GLint r = (S_PROD(arg0[i][RCOMP], arg2[i][RCOMP])
-			  - ((GLint) arg1[i][RCOMP] << CHAN_BITS))
-		    >> shift;
-               GLint g = (S_PROD(arg0[i][GCOMP], arg2[i][GCOMP])
-			  - ((GLint) arg1[i][GCOMP] << CHAN_BITS))
-		    >> shift;
-               GLint b = (S_PROD(arg0[i][BCOMP], arg2[i][BCOMP])
-			  - ((GLint) arg1[i][BCOMP] << CHAN_BITS))
-		    >> shift;
-               rgba[i][RCOMP] = (GLchan) CLAMP(r, 0, CHAN_MAX);
-               rgba[i][GCOMP] = (GLchan) CLAMP(g, 0, CHAN_MAX);
-               rgba[i][BCOMP] = (GLchan) CLAMP(b, 0, CHAN_MAX);
-#endif
+               rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) -
+                                 arg1[i][RCOMP]) * RGBmult;
+               rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) -
+                                 arg1[i][GCOMP]) * RGBmult;
+               rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) -
+                                 arg1[i][BCOMP]) * RGBmult;
             }
 	 }
          break;
@@ -617,15 +463,11 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n,
    switch (textureUnit->_CurrentCombine->ModeA) {
       case GL_REPLACE:
          {
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argA[0];
             if (Ashift) {
                for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
-                  GLchan a = arg0[i][ACOMP] * Amult;
-#else
-                  GLuint a = (GLuint) arg0[i][ACOMP] << Ashift;
-#endif
-                  rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
+                  GLfloat a = arg0[i][ACOMP] * Amult;
+                  rgba[i][ACOMP] = (GLfloat) MIN2(a, 1.0F);
                }
             }
             else {
@@ -637,182 +479,107 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n,
          break;
       case GL_MODULATE:
          {
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
-#if CHAN_TYPE != GL_FLOAT
-            const GLint shift = CHAN_BITS - Ashift;
-#endif
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argA[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argA[1];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
                rgba[i][ACOMP] = arg0[i][ACOMP] * arg1[i][ACOMP] * Amult;
-#else
-               GLuint a = (PROD(arg0[i][ACOMP], arg1[i][ACOMP]) >> shift);
-               rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
-#endif
             }
          }
          break;
       case GL_ADD:
          if (textureUnit->EnvMode == GL_COMBINE4_NV) {
             /* (a * b) + (c * d) */
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
-            const GLchan (*arg2)[4] = (const GLchan (*)[4]) argA[2];
-            const GLchan (*arg3)[4] = (const GLchan (*)[4]) argA[3];
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argA[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argA[1];
+            const GLfloat (*arg2)[4] = (const GLfloat (*)[4]) argA[2];
+            const GLfloat (*arg3)[4] = (const GLfloat (*)[4]) argA[3];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
                rgba[i][ACOMP] = (arg0[i][ACOMP] * arg1[i][ACOMP] +
                                  arg2[i][ACOMP] * arg3[i][ACOMP]) * Amult;
-#else
-               const GLint shift = CHAN_BITS - Ashift;
-               GLint a = (PROD(arg0[i][ACOMP], arg1[i][ACOMP]) >> shift) +
-                         (PROD(arg2[i][ACOMP], arg3[i][ACOMP]) >> shift);
-               rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
-#endif
             }
          }
          else {
             /* two-term add */
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argA[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argA[1];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
                rgba[i][ACOMP] = (arg0[i][ACOMP] + arg1[i][ACOMP]) * Amult;
-#else
-               GLint a = ((GLint) arg0[i][ACOMP] + arg1[i][ACOMP]) << Ashift;
-               rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
-#endif
             }
          }
          break;
       case GL_ADD_SIGNED:
          if (textureUnit->EnvMode == GL_COMBINE4_NV) {
             /* (a * b) + (c * d) - 0.5 */
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
-            const GLchan (*arg2)[4] = (const GLchan (*)[4]) argA[2];
-            const GLchan (*arg3)[4] = (const GLchan (*)[4]) argA[3];
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argA[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argA[1];
+            const GLfloat (*arg2)[4] = (const GLfloat (*)[4]) argA[2];
+            const GLfloat (*arg3)[4] = (const GLfloat (*)[4]) argA[3];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
                rgba[i][ACOMP] = (arg0[i][ACOMP] * arg1[i][ACOMP] +
                                  arg2[i][ACOMP] * arg3[i][ACOMP] -
                                  0.5) * Amult;
-#else
-               GLint a = (((PROD(arg0[i][ACOMP], arg1[i][ACOMP]) +
-                            PROD(arg2[i][ACOMP], arg3[i][ACOMP])) >> CHAN_BITS) - half)
-                          << Ashift;
-               rgba[i][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX);
-#endif
             }
          }
          else {
             /* a + b - 0.5 */
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argA[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argA[1];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
                rgba[i][ACOMP] = (arg0[i][ACOMP] + arg1[i][ACOMP] - 0.5F) * Amult;
-#else
-               GLint a = (GLint) arg0[i][ACOMP] + (GLint) arg1[i][ACOMP] -half;
-               a = (a < 0) ? 0 : a << Ashift;
-               rgba[i][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX);
-#endif
             }
          }
          break;
       case GL_INTERPOLATE:
          {
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
-            const GLchan (*arg2)[4] = (const GLchan (*)[4]) argA[2];
-#if CHAN_TYPE != GL_FLOAT
-            const GLint shift = CHAN_BITS - Ashift;
-#endif
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argA[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argA[1];
+            const GLfloat (*arg2)[4] = (const GLfloat (*)[4]) argA[2];
             for (i=0; i<n; i++) {
-#if CHAN_TYPE == GL_FLOAT
                rgba[i][ACOMP] = (arg0[i][ACOMP] * arg2[i][ACOMP] +
-                                 arg1[i][ACOMP] * (CHAN_MAXF - arg2[i][ACOMP]))
+                                 arg1[i][ACOMP] * (1.0F - arg2[i][ACOMP]))
                                 * Amult;
-#else
-               GLuint a = (PROD(arg0[i][ACOMP], arg2[i][ACOMP])
-                           + PROD(arg1[i][ACOMP], CHAN_MAX - arg2[i][ACOMP]))
-                              >> shift;
-               rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
-#endif
             }
          }
          break;
       case GL_SUBTRACT:
          {
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argA[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argA[1];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
                rgba[i][ACOMP] = (arg0[i][ACOMP] - arg1[i][ACOMP]) * Amult;
-#else
-               GLint a = ((GLint) arg0[i][ACOMP] - (GLint) arg1[i][ACOMP]) << Ashift;
-               rgba[i][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX);
-#endif
             }
          }
          break;
       case GL_MODULATE_ADD_ATI:
          {
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
-            const GLchan (*arg2)[4] = (const GLchan (*)[4]) argA[2];
-#if CHAN_TYPE != GL_FLOAT
-            const GLint shift = CHAN_BITS - Ashift;
-#endif
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argA[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argA[1];
+            const GLfloat (*arg2)[4] = (const GLfloat (*)[4]) argA[2];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
-               rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP]) + arg1[i][ACOMP]) * Amult;
-#else
-               GLint a = (PROD(arg0[i][ACOMP], arg2[i][ACOMP])
-			   + ((GLuint) arg1[i][ACOMP] << CHAN_BITS))
-		    >> shift;
-               rgba[i][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX);
-#endif
+               rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP])
+                                 + arg1[i][ACOMP]) * Amult;
             }
          }
          break;
       case GL_MODULATE_SIGNED_ADD_ATI:
          {
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
-            const GLchan (*arg2)[4] = (const GLchan (*)[4]) argA[2];
-#if CHAN_TYPE != GL_FLOAT
-            const GLint shift = CHAN_BITS - Ashift;
-#endif
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argA[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argA[1];
+            const GLfloat (*arg2)[4] = (const GLfloat (*)[4]) argA[2];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
-               rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP]) + arg1[i][ACOMP] - 0.5F) * Amult;
-#else
-               GLint a = (S_PROD(arg0[i][ACOMP], arg2[i][ACOMP])
-			  + (((GLint) arg1[i][ACOMP] - half) << CHAN_BITS))
-		    >> shift;
-               rgba[i][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX);
-#endif
+               rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP]) +
+                                 arg1[i][ACOMP] - 0.5F) * Amult;
             }
          }
          break;
       case GL_MODULATE_SUBTRACT_ATI:
          {
-            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
-            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
-            const GLchan (*arg2)[4] = (const GLchan (*)[4]) argA[2];
-#if CHAN_TYPE != GL_FLOAT
-            const GLint shift = CHAN_BITS - Ashift;
-#endif
+            const GLfloat (*arg0)[4] = (const GLfloat (*)[4]) argA[0];
+            const GLfloat (*arg1)[4] = (const GLfloat (*)[4]) argA[1];
+            const GLfloat (*arg2)[4] = (const GLfloat (*)[4]) argA[2];
             for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
-               rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP]) - arg1[i][ACOMP]) * Amult;
-#else
-               GLint a = (S_PROD(arg0[i][ACOMP], arg2[i][ACOMP]) 
-			  - ((GLint) arg1[i][ACOMP] << CHAN_BITS))
-		    >> shift;
-               rgba[i][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX);
-#endif
+               rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP])
+                                 - arg1[i][ACOMP]) * Amult;
             }
          }
          break;
@@ -831,8 +598,15 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n,
 	 rgba[i][ACOMP] = rgba[i][RCOMP];
       }
    }
+
+   for (i = 0; i < n; i++) {
+      UNCLAMPED_FLOAT_TO_CHAN(rgbaChan[i][RCOMP], rgba[i][RCOMP]);
+      UNCLAMPED_FLOAT_TO_CHAN(rgbaChan[i][GCOMP], rgba[i][GCOMP]);
+      UNCLAMPED_FLOAT_TO_CHAN(rgbaChan[i][BCOMP], rgba[i][BCOMP]);
+      UNCLAMPED_FLOAT_TO_CHAN(rgbaChan[i][ACOMP], rgba[i][ACOMP]);
+   }
 }
-#undef PROD
+
 
 
 /**
@@ -840,17 +614,17 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n,
  * See GL_EXT_texture_swizzle.
  */
 static void
-swizzle_texels(GLuint swizzle, GLuint count, GLchan (*texels)[4])
+swizzle_texels(GLuint swizzle, GLuint count, GLfloat (*texels)[4])
 {
    const GLuint swzR = GET_SWZ(swizzle, 0);
    const GLuint swzG = GET_SWZ(swizzle, 1);
    const GLuint swzB = GET_SWZ(swizzle, 2);
    const GLuint swzA = GET_SWZ(swizzle, 3);
-   GLchan vector[6];
+   GLfloat vector[6];
    GLuint i;
 
    vector[SWIZZLE_ZERO] = 0;
-   vector[SWIZZLE_ONE] = CHAN_MAX;
+   vector[SWIZZLE_ONE] = 1.0F;
 
    for (i = 0; i < count; i++) {
       vector[SWIZZLE_X] = texels[i][0];
@@ -880,13 +654,15 @@ static void
 texture_apply( const GLcontext *ctx,
                const struct gl_texture_unit *texUnit,
                GLuint n,
-               CONST GLchan primary_rgba[][4], CONST GLchan texel[][4],
-               GLchan rgba[][4] )
+               CONST GLfloat primary_rgba[][4], CONST GLfloat texel[][4],
+               GLchan rgbaChan[][4] )
 {
    GLint baseLevel;
    GLuint i;
-   GLchan Rc, Gc, Bc, Ac;
+   GLfloat Rc, Gc, Bc, Ac;
    GLenum format;
+   GLfloat rgba[MAX_WIDTH][4];
+
    (void) primary_rgba;
 
    ASSERT(texUnit);
@@ -904,6 +680,16 @@ texture_apply( const GLcontext *ctx,
       format = texUnit->_Current->DepthMode;
    }
 
+   if (texUnit->EnvMode != GL_REPLACE) {
+      /* convert GLchan colors to GLfloat */
+      for (i = 0; i < n; i++) {
+         rgba[i][RCOMP] = CHAN_TO_FLOAT(rgbaChan[i][RCOMP]);
+         rgba[i][GCOMP] = CHAN_TO_FLOAT(rgbaChan[i][GCOMP]);
+         rgba[i][BCOMP] = CHAN_TO_FLOAT(rgbaChan[i][BCOMP]);
+         rgba[i][ACOMP] = CHAN_TO_FLOAT(rgbaChan[i][ACOMP]);
+      }
+   }
+
    switch (texUnit->EnvMode) {
       case GL_REPLACE:
 	 switch (format) {
@@ -917,14 +703,14 @@ texture_apply( const GLcontext *ctx,
 	    case GL_LUMINANCE:
 	       for (i=0;i<n;i++) {
 		  /* Cv = Lt */
-                  GLchan Lt = texel[i][RCOMP];
+                  GLfloat Lt = texel[i][RCOMP];
                   rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = Lt;
                   /* Av = Af */
 	       }
 	       break;
 	    case GL_LUMINANCE_ALPHA:
 	       for (i=0;i<n;i++) {
-                  GLchan Lt = texel[i][RCOMP];
+                  GLfloat Lt = texel[i][RCOMP];
 		  /* Cv = Lt */
 		  rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = Lt;
 		  /* Av = At */
@@ -934,7 +720,7 @@ texture_apply( const GLcontext *ctx,
 	    case GL_INTENSITY:
 	       for (i=0;i<n;i++) {
 		  /* Cv = It */
-                  GLchan It = texel[i][RCOMP];
+                  GLfloat It = texel[i][RCOMP];
                   rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = It;
                   /* Av = It */
                   rgba[i][ACOMP] = It;
@@ -971,58 +757,58 @@ texture_apply( const GLcontext *ctx,
 	       for (i=0;i<n;i++) {
 		  /* Cv = Cf */
 		  /* Av = AfAt */
-		  rgba[i][ACOMP] = CHAN_PRODUCT( rgba[i][ACOMP], texel[i][ACOMP] );
+		  rgba[i][ACOMP] = rgba[i][ACOMP] * texel[i][ACOMP];
 	       }
 	       break;
 	    case GL_LUMINANCE:
 	       for (i=0;i<n;i++) {
 		  /* Cv = LtCf */
-                  GLchan Lt = texel[i][RCOMP];
-		  rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], Lt );
-		  rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], Lt );
-		  rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], Lt );
+                  GLfloat Lt = texel[i][RCOMP];
+		  rgba[i][RCOMP] = rgba[i][RCOMP] * Lt;
+		  rgba[i][GCOMP] = rgba[i][GCOMP] * Lt;
+		  rgba[i][BCOMP] = rgba[i][BCOMP] * Lt;
 		  /* Av = Af */
 	       }
 	       break;
 	    case GL_LUMINANCE_ALPHA:
 	       for (i=0;i<n;i++) {
 		  /* Cv = CfLt */
-                  GLchan Lt = texel[i][RCOMP];
-		  rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], Lt );
-		  rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], Lt );
-		  rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], Lt );
+                  GLfloat Lt = texel[i][RCOMP];
+		  rgba[i][RCOMP] = rgba[i][RCOMP] * Lt;
+		  rgba[i][GCOMP] = rgba[i][GCOMP] * Lt;
+		  rgba[i][BCOMP] = rgba[i][BCOMP] * Lt;
 		  /* Av = AfAt */
-		  rgba[i][ACOMP] = CHAN_PRODUCT( rgba[i][ACOMP], texel[i][ACOMP] );
+		  rgba[i][ACOMP] = rgba[i][ACOMP] * texel[i][ACOMP];
 	       }
 	       break;
 	    case GL_INTENSITY:
 	       for (i=0;i<n;i++) {
 		  /* Cv = CfIt */
-                  GLchan It = texel[i][RCOMP];
-		  rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], It );
-		  rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], It );
-		  rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], It );
+                  GLfloat It = texel[i][RCOMP];
+		  rgba[i][RCOMP] = rgba[i][RCOMP] * It;
+		  rgba[i][GCOMP] = rgba[i][GCOMP] * It;
+		  rgba[i][BCOMP] = rgba[i][BCOMP] * It;
 		  /* Av = AfIt */
-		  rgba[i][ACOMP] = CHAN_PRODUCT( rgba[i][ACOMP], It );
+		  rgba[i][ACOMP] = rgba[i][ACOMP] * It;
 	       }
 	       break;
 	    case GL_RGB:
 	       for (i=0;i<n;i++) {
 		  /* Cv = CfCt */
-		  rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], texel[i][RCOMP] );
-		  rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], texel[i][GCOMP] );
-		  rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], texel[i][BCOMP] );
+		  rgba[i][RCOMP] = rgba[i][RCOMP] * texel[i][RCOMP];
+		  rgba[i][GCOMP] = rgba[i][GCOMP] * texel[i][GCOMP];
+		  rgba[i][BCOMP] = rgba[i][BCOMP] * texel[i][BCOMP];
 		  /* Av = Af */
 	       }
 	       break;
 	    case GL_RGBA:
 	       for (i=0;i<n;i++) {
 		  /* Cv = CfCt */
-		  rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], texel[i][RCOMP] );
-		  rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], texel[i][GCOMP] );
-		  rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], texel[i][BCOMP] );
+		  rgba[i][RCOMP] = rgba[i][RCOMP] * texel[i][RCOMP];
+		  rgba[i][GCOMP] = rgba[i][GCOMP] * texel[i][GCOMP];
+		  rgba[i][BCOMP] = rgba[i][BCOMP] * texel[i][BCOMP];
 		  /* Av = AfAt */
-		  rgba[i][ACOMP] = CHAN_PRODUCT( rgba[i][ACOMP], texel[i][ACOMP] );
+		  rgba[i][ACOMP] = rgba[i][ACOMP] * texel[i][ACOMP];
 	       }
 	       break;
             default:
@@ -1051,10 +837,10 @@ texture_apply( const GLcontext *ctx,
 	    case GL_RGBA:
 	       for (i=0;i<n;i++) {
 		  /* Cv = Cf(1-At) + CtAt */
-		  GLchan t = texel[i][ACOMP], s = CHAN_MAX - t;
-		  rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], s) + CHAN_PRODUCT(texel[i][RCOMP],t);
-		  rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], s) + CHAN_PRODUCT(texel[i][GCOMP],t);
-		  rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], s) + CHAN_PRODUCT(texel[i][BCOMP],t);
+		  GLfloat t = texel[i][ACOMP], s = 1.0F - t;
+		  rgba[i][RCOMP] = rgba[i][RCOMP] * s + texel[i][RCOMP] * t;
+		  rgba[i][GCOMP] = rgba[i][GCOMP] * s + texel[i][GCOMP] * t;
+		  rgba[i][BCOMP] = rgba[i][BCOMP] * s + texel[i][BCOMP] * t;
 		  /* Av = Af */
 	       }
 	       break;
@@ -1065,67 +851,73 @@ texture_apply( const GLcontext *ctx,
 	 break;
 
       case GL_BLEND:
-         UNCLAMPED_FLOAT_TO_CHAN(Rc, texUnit->EnvColor[0]);
-         UNCLAMPED_FLOAT_TO_CHAN(Gc, texUnit->EnvColor[1]);
-         UNCLAMPED_FLOAT_TO_CHAN(Bc, texUnit->EnvColor[2]);
-         UNCLAMPED_FLOAT_TO_CHAN(Ac, texUnit->EnvColor[3]);
+         Rc = texUnit->EnvColor[0];
+         Gc = texUnit->EnvColor[1];
+         Bc = texUnit->EnvColor[2];
+         Ac = texUnit->EnvColor[3];
 	 switch (format) {
 	    case GL_ALPHA:
 	       for (i=0;i<n;i++) {
 		  /* Cv = Cf */
 		  /* Av = AfAt */
-                  rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], texel[i][ACOMP]);
+                  rgba[i][ACOMP] = rgba[i][ACOMP] * texel[i][ACOMP];
 	       }
 	       break;
             case GL_LUMINANCE:
 	       for (i=0;i<n;i++) {
 		  /* Cv = Cf(1-Lt) + CcLt */
-		  GLchan Lt = texel[i][RCOMP], s = CHAN_MAX - Lt;
-		  rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], s) + CHAN_PRODUCT(Rc, Lt);
-		  rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], s) + CHAN_PRODUCT(Gc, Lt);
-		  rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], s) + CHAN_PRODUCT(Bc, Lt);
+		  GLfloat Lt = texel[i][RCOMP], s = 1.0F - Lt;
+		  rgba[i][RCOMP] = rgba[i][RCOMP] * s + Rc * Lt;
+		  rgba[i][GCOMP] = rgba[i][GCOMP] * s + Gc * Lt;
+		  rgba[i][BCOMP] = rgba[i][BCOMP] * s + Bc * Lt;
 		  /* Av = Af */
 	       }
 	       break;
 	    case GL_LUMINANCE_ALPHA:
 	       for (i=0;i<n;i++) {
 		  /* Cv = Cf(1-Lt) + CcLt */
-		  GLchan Lt = texel[i][RCOMP], s = CHAN_MAX - Lt;
-		  rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], s) + CHAN_PRODUCT(Rc, Lt);
-		  rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], s) + CHAN_PRODUCT(Gc, Lt);
-		  rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], s) + CHAN_PRODUCT(Bc, Lt);
+		  GLfloat Lt = texel[i][RCOMP], s = 1.0F - Lt;
+		  rgba[i][RCOMP] = rgba[i][RCOMP] * s + Rc * Lt;
+		  rgba[i][GCOMP] = rgba[i][GCOMP] * s + Gc * Lt;
+		  rgba[i][BCOMP] = rgba[i][BCOMP] * s + Bc * Lt;
 		  /* Av = AfAt */
-		  rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP],texel[i][ACOMP]);
+		  rgba[i][ACOMP] = rgba[i][ACOMP] * texel[i][ACOMP];
 	       }
 	       break;
             case GL_INTENSITY:
 	       for (i=0;i<n;i++) {
 		  /* Cv = Cf(1-It) + CcIt */
-		  GLchan It = texel[i][RCOMP], s = CHAN_MAX - It;
-		  rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], s) + CHAN_PRODUCT(Rc, It);
-		  rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], s) + CHAN_PRODUCT(Gc, It);
-		  rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], s) + CHAN_PRODUCT(Bc, It);
+		  GLfloat It = texel[i][RCOMP], s = 1.0F - It;
+		  rgba[i][RCOMP] = rgba[i][RCOMP] * s + Rc * It;
+		  rgba[i][GCOMP] = rgba[i][GCOMP] * s + Gc * It;
+		  rgba[i][BCOMP] = rgba[i][BCOMP] * s + Bc * It;
                   /* Av = Af(1-It) + Ac*It */
-                  rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], s) + CHAN_PRODUCT(Ac, It);
+                  rgba[i][ACOMP] = rgba[i][ACOMP] * s + Ac * It;
                }
                break;
 	    case GL_RGB:
 	       for (i=0;i<n;i++) {
 		  /* Cv = Cf(1-Ct) + CcCt */
-		  rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], (CHAN_MAX-texel[i][RCOMP])) + CHAN_PRODUCT(Rc,texel[i][RCOMP]);
-		  rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], (CHAN_MAX-texel[i][GCOMP])) + CHAN_PRODUCT(Gc,texel[i][GCOMP]);
-		  rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], (CHAN_MAX-texel[i][BCOMP])) + CHAN_PRODUCT(Bc,texel[i][BCOMP]);
+		  rgba[i][RCOMP] = rgba[i][RCOMP] * (1.0F - texel[i][RCOMP])
+                     + Rc * texel[i][RCOMP];
+		  rgba[i][GCOMP] = rgba[i][GCOMP] * (1.0F - texel[i][GCOMP])
+                     + Gc * texel[i][GCOMP];
+		  rgba[i][BCOMP] = rgba[i][BCOMP] * (1.0F - texel[i][BCOMP])
+                     + Bc * texel[i][BCOMP];
 		  /* Av = Af */
 	       }
 	       break;
 	    case GL_RGBA:
 	       for (i=0;i<n;i++) {
 		  /* Cv = Cf(1-Ct) + CcCt */
-		  rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], (CHAN_MAX-texel[i][RCOMP])) + CHAN_PRODUCT(Rc,texel[i][RCOMP]);
-		  rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], (CHAN_MAX-texel[i][GCOMP])) + CHAN_PRODUCT(Gc,texel[i][GCOMP]);
-		  rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], (CHAN_MAX-texel[i][BCOMP])) + CHAN_PRODUCT(Bc,texel[i][BCOMP]);
+		  rgba[i][RCOMP] = rgba[i][RCOMP] * (1.0F - texel[i][RCOMP])
+                     + Rc * texel[i][RCOMP];
+		  rgba[i][GCOMP] = rgba[i][GCOMP] * (1.0F - texel[i][GCOMP])
+                     + Gc * texel[i][GCOMP];
+		  rgba[i][BCOMP] = rgba[i][BCOMP] * (1.0F - texel[i][BCOMP])
+                     + Bc * texel[i][BCOMP];
 		  /* Av = AfAt */
-		  rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP],texel[i][ACOMP]);
+		  rgba[i][ACOMP] = rgba[i][ACOMP] * texel[i][ACOMP];
 	       }
 	       break;
             default:
@@ -1134,7 +926,7 @@ texture_apply( const GLcontext *ctx,
 	 }
 	 break;
 
-     /* XXX don't clamp results if GLchan is float??? */
+     /* XXX don't clamp results if GLfloat is float??? */
 
       case GL_ADD:  /* GL_EXT_texture_add_env */
          switch (format) {
@@ -1143,66 +935,66 @@ texture_apply( const GLcontext *ctx,
                   /* Rv = Rf */
                   /* Gv = Gf */
                   /* Bv = Bf */
-                  rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], texel[i][ACOMP]);
+                  rgba[i][ACOMP] = rgba[i][ACOMP] * texel[i][ACOMP];
                }
                break;
             case GL_LUMINANCE:
                for (i=0;i<n;i++) {
-                  ChanTemp Lt = texel[i][RCOMP];
-                  ChanTemp r = rgba[i][RCOMP] + Lt;
-                  ChanTemp g = rgba[i][GCOMP] + Lt;
-                  ChanTemp b = rgba[i][BCOMP] + Lt;
-                  rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
-                  rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
-                  rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
+                  GLfloat Lt = texel[i][RCOMP];
+                  GLfloat r = rgba[i][RCOMP] + Lt;
+                  GLfloat g = rgba[i][GCOMP] + Lt;
+                  GLfloat b = rgba[i][BCOMP] + Lt;
+                  rgba[i][RCOMP] = MIN2(r, 1.0F);
+                  rgba[i][GCOMP] = MIN2(g, 1.0F);
+                  rgba[i][BCOMP] = MIN2(b, 1.0F);
                   /* Av = Af */
                }
                break;
             case GL_LUMINANCE_ALPHA:
                for (i=0;i<n;i++) {
-                  ChanTemp Lt = texel[i][RCOMP];
-                  ChanTemp r = rgba[i][RCOMP] + Lt;
-                  ChanTemp g = rgba[i][GCOMP] + Lt;
-                  ChanTemp b = rgba[i][BCOMP] + Lt;
-                  rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
-                  rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
-                  rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
-                  rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], texel[i][ACOMP]);
+                  GLfloat Lt = texel[i][RCOMP];
+                  GLfloat r = rgba[i][RCOMP] + Lt;
+                  GLfloat g = rgba[i][GCOMP] + Lt;
+                  GLfloat b = rgba[i][BCOMP] + Lt;
+                  rgba[i][RCOMP] = MIN2(r, 1.0F);
+                  rgba[i][GCOMP] = MIN2(g, 1.0F);
+                  rgba[i][BCOMP] = MIN2(b, 1.0F);
+                  rgba[i][ACOMP] = rgba[i][ACOMP] * texel[i][ACOMP];
                }
                break;
             case GL_INTENSITY:
                for (i=0;i<n;i++) {
-                  GLchan It = texel[i][RCOMP];
-                  ChanTemp r = rgba[i][RCOMP] + It;
-                  ChanTemp g = rgba[i][GCOMP] + It;
-                  ChanTemp b = rgba[i][BCOMP] + It;
-                  ChanTemp a = rgba[i][ACOMP] + It;
-                  rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
-                  rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
-                  rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
-                  rgba[i][ACOMP] = MIN2(a, CHAN_MAX);
+                  GLfloat It = texel[i][RCOMP];
+                  GLfloat r = rgba[i][RCOMP] + It;
+                  GLfloat g = rgba[i][GCOMP] + It;
+                  GLfloat b = rgba[i][BCOMP] + It;
+                  GLfloat a = rgba[i][ACOMP] + It;
+                  rgba[i][RCOMP] = MIN2(r, 1.0F);
+                  rgba[i][GCOMP] = MIN2(g, 1.0F);
+                  rgba[i][BCOMP] = MIN2(b, 1.0F);
+                  rgba[i][ACOMP] = MIN2(a, 1.0F);
                }
                break;
 	    case GL_RGB:
 	       for (i=0;i<n;i++) {
-                  ChanTemp r = rgba[i][RCOMP] + texel[i][RCOMP];
-                  ChanTemp g = rgba[i][GCOMP] + texel[i][GCOMP];
-                  ChanTemp b = rgba[i][BCOMP] + texel[i][BCOMP];
-		  rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
-		  rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
-		  rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
+                  GLfloat r = rgba[i][RCOMP] + texel[i][RCOMP];
+                  GLfloat g = rgba[i][GCOMP] + texel[i][GCOMP];
+                  GLfloat b = rgba[i][BCOMP] + texel[i][BCOMP];
+		  rgba[i][RCOMP] = MIN2(r, 1.0F);
+		  rgba[i][GCOMP] = MIN2(g, 1.0F);
+		  rgba[i][BCOMP] = MIN2(b, 1.0F);
 		  /* Av = Af */
 	       }
 	       break;
 	    case GL_RGBA:
 	       for (i=0;i<n;i++) {
-                  ChanTemp r = rgba[i][RCOMP] + texel[i][RCOMP];
-                  ChanTemp g = rgba[i][GCOMP] + texel[i][GCOMP];
-                  ChanTemp b = rgba[i][BCOMP] + texel[i][BCOMP];
-		  rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
-		  rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
-		  rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
-                  rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], texel[i][ACOMP]);
+                  GLfloat r = rgba[i][RCOMP] + texel[i][RCOMP];
+                  GLfloat g = rgba[i][GCOMP] + texel[i][GCOMP];
+                  GLfloat b = rgba[i][BCOMP] + texel[i][BCOMP];
+		  rgba[i][RCOMP] = MIN2(r, 1.0F);
+		  rgba[i][GCOMP] = MIN2(g, 1.0F);
+		  rgba[i][BCOMP] = MIN2(b, 1.0F);
+                  rgba[i][ACOMP] = rgba[i][ACOMP] * texel[i][ACOMP];
                }
                break;
             default:
@@ -1215,6 +1007,14 @@ texture_apply( const GLcontext *ctx,
          _mesa_problem(ctx, "Bad env mode in texture_apply");
          return;
    }
+
+   /* convert GLfloat colors to GLchan */
+   for (i = 0; i < n; i++) {
+      CLAMPED_FLOAT_TO_CHAN(rgbaChan[i][RCOMP], rgba[i][RCOMP]);
+      CLAMPED_FLOAT_TO_CHAN(rgbaChan[i][GCOMP], rgba[i][GCOMP]);
+      CLAMPED_FLOAT_TO_CHAN(rgbaChan[i][BCOMP], rgba[i][BCOMP]);
+      CLAMPED_FLOAT_TO_CHAN(rgbaChan[i][ACOMP], rgba[i][ACOMP]);
+   }
 }
 
 
@@ -1226,7 +1026,7 @@ void
 _swrast_texture_span( GLcontext *ctx, SWspan *span )
 {
    SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLchan primary_rgba[MAX_WIDTH][4];
+   GLfloat primary_rgba[MAX_WIDTH][4];
    GLuint unit;
 
    ASSERT(span->end < MAX_WIDTH);
@@ -1234,8 +1034,15 @@ _swrast_texture_span( GLcontext *ctx, SWspan *span )
    /*
     * Save copy of the incoming fragment colors (the GL_PRIMARY_COLOR)
     */
-   if (swrast->_AnyTextureCombine)
-      MEMCPY(primary_rgba, span->array->rgba, 4 * span->end * sizeof(GLchan));
+   if (swrast->_AnyTextureCombine) {
+      GLuint i;
+      for (i = 0; i < span->end; i++) {
+         primary_rgba[i][RCOMP] = CHAN_TO_FLOAT(span->array->rgba[i][RCOMP]);
+         primary_rgba[i][GCOMP] = CHAN_TO_FLOAT(span->array->rgba[i][GCOMP]);
+         primary_rgba[i][BCOMP] = CHAN_TO_FLOAT(span->array->rgba[i][BCOMP]);
+         primary_rgba[i][ACOMP] = CHAN_TO_FLOAT(span->array->rgba[i][ACOMP]);
+      }
+   }
 
    /* First must sample all bump maps */
    for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
@@ -1323,8 +1130,8 @@ _swrast_texture_span( GLcontext *ctx, SWspan *span )
          const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
          const struct gl_texture_object *curObj = texUnit->_Current;
          GLfloat *lambda = span->array->lambda[unit];
-         GLchan (*texels)[4] = (GLchan (*)[4])
-            (swrast->TexelBuffer + unit * (span->end * 4 * sizeof(GLchan)));
+         GLfloat (*texels)[4] = (GLfloat (*)[4])
+            (swrast->TexelBuffer + unit * (span->end * 4 * sizeof(GLfloat)));
 
          /* adjust texture lod (lambda) */
          if (span->arrayMask & SPAN_LAMBDA) {
@@ -1357,13 +1164,7 @@ _swrast_texture_span( GLcontext *ctx, SWspan *span )
 
          /* GL_SGI_texture_color_table */
          if (texUnit->ColorTableEnabled) {
-#if CHAN_TYPE == GL_UNSIGNED_BYTE
-            _mesa_lookup_rgba_ubyte(&texUnit->ColorTable, span->end, texels);
-#elif CHAN_TYPE == GL_UNSIGNED_SHORT
-            _mesa_lookup_rgba_ubyte(&texUnit->ColorTable, span->end, texels);
-#else
             _mesa_lookup_rgba_float(&texUnit->ColorTable, span->end, texels);
-#endif
          }
 
          /* GL_EXT_texture_swizzle */
@@ -1383,19 +1184,19 @@ _swrast_texture_span( GLcontext *ctx, SWspan *span )
          const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
          if (texUnit->_CurrentCombine != &texUnit->_EnvMode ) {
             texture_combine( ctx, unit, span->end,
-                             (CONST GLchan (*)[4]) primary_rgba,
+                             (CONST GLfloat (*)[4]) primary_rgba,
                              swrast->TexelBuffer,
                              span->array->rgba );
          }
          else {
             /* conventional texture blend */
-            const GLchan (*texels)[4] = (const GLchan (*)[4])
+            const GLfloat (*texels)[4] = (const GLfloat (*)[4])
                (swrast->TexelBuffer + unit *
-                (span->end * 4 * sizeof(GLchan)));
+                (span->end * 4 * sizeof(GLfloat)));
 
 
             texture_apply( ctx, texUnit, span->end,
-                           (CONST GLchan (*)[4]) primary_rgba, texels,
+                           (CONST GLfloat (*)[4]) primary_rgba, texels,
                            span->array->rgba );
          }
       }