Napalm total immersion

1 files changed, 401 insertions, 66 deletions

diff --git a/src/mesa/drivers/glide/fxdd.c b/src/mesa/drivers/glide/fxdd.c
index 7087c30b667..fec2ee9d72a 100644
--- a/src/mesa/drivers/glide/fxdd.c
+++ b/src/mesa/drivers/glide/fxdd.c
@@ -1,9 +1,3 @@
-/* Hack alert:
- * fxDDReadPixels888 does not convert 8A8R8G8B into 5R5G5B
- */
-
-/* $Id: fxdd.c,v 1.103 2003/10/14 14:56:45 dborca Exp $ */
-
 /*
  * Mesa 3-D graphics library
  * Version:  5.1
@@ -55,6 +49,7 @@
 #include "texstore.h"
 #include "teximage.h"
 #include "swrast/swrast.h"
+#include "swrast/s_context.h"
 #include "swrast_setup/swrast_setup.h"
 #include "tnl/tnl.h"
 #include "tnl/t_context.h"
@@ -200,6 +195,12 @@ static void fxDDClear( GLcontext *ctx,
    const FxU32 clearD = (FxU32) (((1 << ctx->Visual.depthBits) - 1) * ctx->Depth.Clear);
    const FxU8 clearS = (FxU8) (ctx->Stencil.Clear & 0xff);
 
+   /* [dBorca] Hack alert:
+    * if we set Mesa for 32bit depth, we'll get
+    * clearD == 0
+    * due to 32bit integer overflow!
+    */
+
    if ( TDFX_DEBUG & MESA_VERBOSE ) {
       fprintf( stderr, "%s( %d, %d, %d, %d )\n",
 	       __FUNCTION__, (int) x, (int) y, (int) width, (int) height );
@@ -492,44 +493,48 @@ fxDDSetDrawBuffer(GLcontext * ctx, GLenum mode)
 }
 
 
-
-
-
 static void
-fxDDDrawBitmap(GLcontext * ctx, GLint px, GLint py,
-	       GLsizei width, GLsizei height,
-	       const struct gl_pixelstore_attrib *unpack,
-	       const GLubyte * bitmap)
+fxDDDrawBitmap2 (GLcontext *ctx, GLint px, GLint py,
+		 GLsizei width, GLsizei height,
+		 const struct gl_pixelstore_attrib *unpack,
+		 const GLubyte *bitmap)
 {
    fxMesaContext fxMesa = FX_CONTEXT(ctx);
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
    GrLfbInfo_t info;
+   GrLfbWriteMode_t mode;
    FxU16 color;
    const struct gl_pixelstore_attrib *finalUnpack;
    struct gl_pixelstore_attrib scissoredUnpack;
 
    /* check if there's any raster operations enabled which we can't handle */
-   if (ctx->Color.AlphaEnabled ||
-       ctx->Color.BlendEnabled ||
-       ctx->Depth.Test ||
-       ctx->Fog.Enabled ||
-       ctx->Color.ColorLogicOpEnabled ||
-       ctx->Stencil.Enabled ||
-       ctx->Scissor.Enabled ||
-       (ctx->DrawBuffer->UseSoftwareAlphaBuffers &&
-	ctx->Color.ColorMask[ACOMP]) ||
-       (ctx->Color._DrawDestMask != FRONT_LEFT_BIT &&
-        ctx->Color._DrawDestMask != BACK_LEFT_BIT)) {
+   if ((swrast->_RasterMask & (ALPHATEST_BIT |
+			      /*BLEND_BIT |*/   /* blending ok, through pixpipe */
+			      DEPTH_BIT |       /* could be done with RGB:DEPTH */
+			      FOG_BIT |         /* could be done with RGB:DEPTH */
+			      LOGIC_OP_BIT |
+			      /*CLIP_BIT |*/    /* clipping ok, below */
+			      STENCIL_BIT |
+			      /*MASKING_BIT |*/ /* masking ok, test follows */
+			      ALPHABUF_BIT |    /* nope! see 565 span kludge */
+			      MULTI_DRAW_BIT |
+			      OCCLUSION_BIT |   /* nope! at least not yet */
+			      TEXTURE_BIT |
+			      FRAGPROG_BIT))
+       ||
+       ((swrast->_RasterMask & MASKING_BIT) /*&& (ctx->Visual.greenBits != 8)*/ && (ctx->Visual.greenBits != 5))
+      ) {
       _swrast_Bitmap(ctx, px, py, width, height, unpack, bitmap);
       return;
    }
 
+   /* make sure the pixelpipe is configured correctly */
+   fxSetupFXUnits(ctx);
 
    if (ctx->Scissor.Enabled) {
       /* This is a bit tricky, but by carefully adjusting the px, py,
        * width, height, skipPixels and skipRows values we can do
        * scissoring without special code in the rendering loop.
-       *
-       * KW: This code is never reached, see the test above.
        */
 
       /* we'll construct a new pixelstore struct */
@@ -568,10 +573,14 @@ fxDDDrawBitmap(GLcontext * ctx, GLint px, GLint py,
 
    /* compute pixel value */
    {
-      GLint r = (GLint) (ctx->Current.RasterColor[0] * 255.0f);
-      GLint g = (GLint) (ctx->Current.RasterColor[1] * 255.0f);
-      GLint b = (GLint) (ctx->Current.RasterColor[2] * 255.0f);
-      /*GLint a = (GLint)(ctx->Current.RasterColor[3]*255.0f); */
+      GLint r = (GLint) (ctx->Current.RasterColor[RCOMP] * 255.0f);
+      GLint g = (GLint) (ctx->Current.RasterColor[GCOMP] * 255.0f);
+      GLint b = (GLint) (ctx->Current.RasterColor[BCOMP] * 255.0f);
+      GLint a = (GLint) (ctx->Current.RasterColor[ACOMP] * 255.0f);
+#if 0
+      /* [dBorca]
+       * who uses bgr, anyway? Expecting the V2 from HM... :D
+       */
       if (fxMesa->bgrOrder)
 	 color = (FxU16)
 	    (((FxU16) 0xf8 & b) << (11 - 3)) |
@@ -580,14 +589,23 @@ fxDDDrawBitmap(GLcontext * ctx, GLint px, GLint py,
 	 color = (FxU16)
 	    (((FxU16) 0xf8 & r) << (11 - 3)) |
 	    (((FxU16) 0xfc & g) << (5 - 3 + 1)) | (((FxU16) 0xf8 & b) >> 3);
+#else
+      if (fxMesa->colDepth == 15) {
+         color = TDFXPACKCOLOR1555(b, g, r, a);
+         mode = GR_LFBWRITEMODE_1555;
+      } else {
+         color = TDFXPACKCOLOR565(b, g, r);
+         mode = GR_LFBWRITEMODE_565;
+      }
+#endif
    }
 
    info.size = sizeof(info);
    if (!grLfbLock(GR_LFB_WRITE_ONLY,
 		  fxMesa->currentFB,
-		  GR_LFBWRITEMODE_565,
-		  GR_ORIGIN_UPPER_LEFT, FXFALSE, &info)) {
-      fprintf(stderr, "%s: ERROR: locking the linear frame buffer\n", __FUNCTION__);
+		  mode,
+		  GR_ORIGIN_UPPER_LEFT, FXTRUE, &info)) {
+      _swrast_Bitmap(ctx, px, py, width, height, unpack, bitmap);
       return;
    }
 
@@ -656,14 +674,188 @@ fxDDDrawBitmap(GLcontext * ctx, GLint px, GLint py,
    grLfbUnlock(GR_LFB_WRITE_ONLY, fxMesa->currentFB);
 }
 
+static void
+fxDDDrawBitmap4 (GLcontext *ctx, GLint px, GLint py,
+		 GLsizei width, GLsizei height,
+		 const struct gl_pixelstore_attrib *unpack,
+		 const GLubyte *bitmap)
+{
+   fxMesaContext fxMesa = FX_CONTEXT(ctx);
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GrLfbInfo_t info;
+   FxU32 color;
+   const struct gl_pixelstore_attrib *finalUnpack;
+   struct gl_pixelstore_attrib scissoredUnpack;
+
+   /* check if there's any raster operations enabled which we can't handle */
+   if ((swrast->_RasterMask & (ALPHATEST_BIT |
+			      /*BLEND_BIT |*/   /* blending ok, through pixpipe */
+			      DEPTH_BIT |       /* could be done with RGB:DEPTH */
+			      FOG_BIT |         /* could be done with RGB:DEPTH */
+			      LOGIC_OP_BIT |
+			      /*CLIP_BIT |*/    /* clipping ok, below */
+			      STENCIL_BIT |
+			      /*MASKING_BIT |*/ /* masking ok, we're in 32bpp */
+			      /*ALPHABUF_BIT |*//* alpha ok, we're in 32bpp */
+			      MULTI_DRAW_BIT |
+			      OCCLUSION_BIT |   /* nope! at least not yet */
+			      TEXTURE_BIT |
+			      FRAGPROG_BIT))
+      ) {
+      _swrast_Bitmap(ctx, px, py, width, height, unpack, bitmap);
+      return;
+   }
+
+   /* make sure the pixelpipe is configured correctly */
+   fxSetupFXUnits(ctx);
+
+   if (ctx->Scissor.Enabled) {
+      /* This is a bit tricky, but by carefully adjusting the px, py,
+       * width, height, skipPixels and skipRows values we can do
+       * scissoring without special code in the rendering loop.
+       */
+
+      /* we'll construct a new pixelstore struct */
+      finalUnpack = &scissoredUnpack;
+      scissoredUnpack = *unpack;
+      if (scissoredUnpack.RowLength == 0)
+	 scissoredUnpack.RowLength = width;
+
+      /* clip left */
+      if (px < ctx->Scissor.X) {
+	 scissoredUnpack.SkipPixels += (ctx->Scissor.X - px);
+	 width -= (ctx->Scissor.X - px);
+	 px = ctx->Scissor.X;
+      }
+      /* clip right */
+      if (px + width >= ctx->Scissor.X + ctx->Scissor.Width) {
+	 width -= (px + width - (ctx->Scissor.X + ctx->Scissor.Width));
+      }
+      /* clip bottom */
+      if (py < ctx->Scissor.Y) {
+	 scissoredUnpack.SkipRows += (ctx->Scissor.Y - py);
+	 height -= (ctx->Scissor.Y - py);
+	 py = ctx->Scissor.Y;
+      }
+      /* clip top */
+      if (py + height >= ctx->Scissor.Y + ctx->Scissor.Height) {
+	 height -= (py + height - (ctx->Scissor.Y + ctx->Scissor.Height));
+      }
+
+      if (width <= 0 || height <= 0)
+	 return;
+   }
+   else {
+      finalUnpack = unpack;
+   }
+
+   /* compute pixel value */
+   {
+      GLint r = (GLint) (ctx->Current.RasterColor[RCOMP] * 255.0f);
+      GLint g = (GLint) (ctx->Current.RasterColor[GCOMP] * 255.0f);
+      GLint b = (GLint) (ctx->Current.RasterColor[BCOMP] * 255.0f);
+      GLint a = (GLint) (ctx->Current.RasterColor[ACOMP] * 255.0f);
+#if 0
+      /* [dBorca]
+       * who uses bgr, anyway? Expecting the V2 from HM... :D
+       */
+      if (fxMesa->bgrOrder)
+	 color = (FxU16)
+	    (((FxU16) 0xf8 & b) << (11 - 3)) |
+	    (((FxU16) 0xfc & g) << (5 - 3 + 1)) | (((FxU16) 0xf8 & r) >> 3);
+      else
+	 color = (FxU16)
+	    (((FxU16) 0xf8 & r) << (11 - 3)) |
+	    (((FxU16) 0xfc & g) << (5 - 3 + 1)) | (((FxU16) 0xf8 & b) >> 3);
+#else
+      color = TDFXPACKCOLOR8888(b, g, r, a);
+#endif
+   }
+
+   info.size = sizeof(info);
+   if (!grLfbLock(GR_LFB_WRITE_ONLY,
+		  fxMesa->currentFB,
+		  GR_LFBWRITEMODE_8888,
+		  GR_ORIGIN_UPPER_LEFT, FXTRUE, &info)) {
+      _swrast_Bitmap(ctx, px, py, width, height, unpack, bitmap);
+      return;
+   }
+
+   {
+      const GLint winX = 0;
+      const GLint winY = fxMesa->height - 1;
+      /* The dest stride depends on the hardware and whether we're drawing
+       * to the front or back buffer.  This compile-time test seems to do
+       * the job for now.
+       */
+      const GLint dstStride = info.strideInBytes / 4;	/* stride in GLuints */
+
+      GLint row;
+      /* compute dest address of bottom-left pixel in bitmap */
+      GLuint *dst = (GLuint *) info.lfbPtr
+	 + (winY - py) * dstStride + (winX + px);
+
+      for (row = 0; row < height; row++) {
+	 const GLubyte *src =
+	    (const GLubyte *) _mesa_image_address(finalUnpack,
+						  bitmap, width, height,
+						  GL_COLOR_INDEX, GL_BITMAP,
+						  0, row, 0);
+	 if (finalUnpack->LsbFirst) {
+	    /* least significan bit first */
+	    GLubyte mask = 1U << (finalUnpack->SkipPixels & 0x7);
+	    GLint col;
+	    for (col = 0; col < width; col++) {
+	       if (*src & mask) {
+		  dst[col] = color;
+	       }
+	       if (mask == 128U) {
+		  src++;
+		  mask = 1U;
+	       }
+	       else {
+		  mask = mask << 1;
+	       }
+	    }
+	    if (mask != 1)
+	       src++;
+	 }
+	 else {
+	    /* most significan bit first */
+	    GLubyte mask = 128U >> (finalUnpack->SkipPixels & 0x7);
+	    GLint col;
+	    for (col = 0; col < width; col++) {
+	       if (*src & mask) {
+		  dst[col] = color;
+	       }
+	       if (mask == 1U) {
+		  src++;
+		  mask = 128U;
+	       }
+	       else {
+		  mask = mask >> 1;
+	       }
+	    }
+	    if (mask != 128)
+	       src++;
+	 }
+	 dst -= dstStride;
+      }
+   }
+
+   grLfbUnlock(GR_LFB_WRITE_ONLY, fxMesa->currentFB);
+}
+
 
 static void
-fxDDReadPixels(GLcontext * ctx, GLint x, GLint y,
-	       GLsizei width, GLsizei height,
-	       GLenum format, GLenum type,
-	       const struct gl_pixelstore_attrib *packing, GLvoid * dstImage)
+fxDDReadPixels565 (GLcontext * ctx,
+		   GLint x, GLint y,
+		   GLsizei width, GLsizei height,
+		   GLenum format, GLenum type,
+		   const struct gl_pixelstore_attrib *packing,
+		   GLvoid *dstImage)
 {
-   if (ctx->_ImageTransferState) {
+   if (ctx->_ImageTransferState/* & (IMAGE_SCALE_BIAS_BIT|IMAGE_MAP_COLOR_BIT)*/) {
       _swrast_ReadPixels(ctx, x, y, width, height, format, type,
 			 packing, dstImage);
       return;
@@ -771,14 +963,15 @@ fxDDReadPixels(GLcontext * ctx, GLint x, GLint y,
    }
 }
 
-static void fxDDReadPixels555 (GLcontext * ctx,
-                               GLint x, GLint y,
-                               GLsizei width, GLsizei height,
-                               GLenum format, GLenum type,
-                               const struct gl_pixelstore_attrib *packing,
-                               GLvoid *dstImage)
+static void
+fxDDReadPixels555 (GLcontext * ctx,
+		   GLint x, GLint y,
+		   GLsizei width, GLsizei height,
+		   GLenum format, GLenum type,
+		   const struct gl_pixelstore_attrib *packing,
+		   GLvoid *dstImage)
 {
-   if (ctx->_ImageTransferState) {
+   if (ctx->_ImageTransferState/* & (IMAGE_SCALE_BIAS_BIT|IMAGE_MAP_COLOR_BIT)*/) {
       _swrast_ReadPixels(ctx, x, y, width, height, format, type,
 			 packing, dstImage);
       return;
@@ -839,7 +1032,7 @@ static void fxDDReadPixels555 (GLcontext * ctx,
 	       for (col = 0; col < halfWidth; col++) {
 		  const GLuint pixel = ((const GLuint *) src)[col];
                   *d++ = FX_rgb_scale_5[ pixel        & 0x1f];
-                  *d++ = FX_rgb_scale_5[(pixel >> 5)  & 0x1f];
+                  *d++ = FX_rgb_scale_5[(pixel >>  5) & 0x1f];
                   *d++ = FX_rgb_scale_5[(pixel >> 10) & 0x1f];
 		  *d++ =  (pixel & 0x8000) ? 255 : 0;
                   *d++ = FX_rgb_scale_5[(pixel >> 16) & 0x1f];
@@ -850,7 +1043,7 @@ static void fxDDReadPixels555 (GLcontext * ctx,
 	       if (extraPixel) {
 		  const GLushort pixel = src[width - 1];
                   *d++ = FX_rgb_scale_5[ pixel        & 0x1f];
-                  *d++ = FX_rgb_scale_5[(pixel >> 5)  & 0x1f];
+                  *d++ = FX_rgb_scale_5[(pixel >>  5) & 0x1f];
                   *d++ = FX_rgb_scale_5[(pixel >> 10) & 0x1f];
 		  *d++ =  (pixel & 0x8000) ? 255 : 0;
 	       }
@@ -882,14 +1075,15 @@ static void fxDDReadPixels555 (GLcontext * ctx,
    }
 }
 
-static void fxDDReadPixels888 (GLcontext * ctx,
-                               GLint x, GLint y,
-                               GLsizei width, GLsizei height,
-                               GLenum format, GLenum type,
-                               const struct gl_pixelstore_attrib *packing,
-                               GLvoid *dstImage)
+static void
+fxDDReadPixels8888 (GLcontext * ctx,
+		    GLint x, GLint y,
+		    GLsizei width, GLsizei height,
+		    GLenum format, GLenum type,
+		    const struct gl_pixelstore_attrib *packing,
+		    GLvoid *dstImage)
 {
-   if (ctx->_ImageTransferState) {
+   if (ctx->_ImageTransferState/* & (IMAGE_SCALE_BIAS_BIT|IMAGE_MAP_COLOR_BIT)*/) {
       _swrast_ReadPixels(ctx, x, y, width, height, format, type,
 			 packing, dstImage);
       return;
@@ -930,17 +1124,35 @@ static void fxDDReadPixels888 (GLcontext * ctx,
 	    }
 	 }
 	 else if (format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
-	    /* directly memcpy 8A8R8G8B pixels into client's buffer */
-	    const GLint widthInBytes = width * 4;
-	    GLint row;
+	    /* 8A8R8G8B pixels into client's buffer */
+	    GLint row, col;
 	    for (row = 0; row < height; row++) {
-	       MEMCPY(dst, src, widthInBytes);
+	       GLubyte *d = dst;
+	       for (col = 0; col < width; col++) {
+		  const GLuint pixel = ((const GLuint *) src)[col];
+                  *d++ = pixel >> 16;
+                  *d++ = pixel >> 8;
+                  *d++ = pixel;
+                  *d++ = pixel >> 24;
+	       }
 	       dst += dstStride;
 	       src -= srcStride;
 	    }
 	 }
 	 else if (format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5) {
-	    /* convert 8A8R8G8B into 5R5G5B */
+	    /* convert 8A8R8G8B into 5R6G5B */
+	    GLint row, col;
+	    for (row = 0; row < height; row++) {
+	       GLushort *d = (GLushort *)dst;
+	       for (col = 0; col < width; col++) {
+		  const GLuint pixel = ((const GLuint *) src)[col];
+                  *d++ = (((pixel >> 16) & 0xf8) << 8) |
+                         (((pixel >>  8) & 0xfc) << 3) |
+                          ((pixel        & 0xf8) >> 3);
+	       }
+	       dst += dstStride;
+	       src -= srcStride;
+	    }
 	 }
 	 else {
 	    grLfbUnlock(GR_LFB_READ_ONLY, fxMesa->currentFB);
@@ -957,6 +1169,105 @@ static void fxDDReadPixels888 (GLcontext * ctx,
 }
 
 
+/* [dBorca] Hack alert:
+ * not finished!!!
+ * revise fallback tests and fix scissor; implement new formats
+ * also write its siblings: 565 and 1555
+ */
+void
+fxDDDrawPixels8888 (GLcontext * ctx, GLint x, GLint y,
+                    GLsizei width, GLsizei height,
+                    GLenum format, GLenum type,
+                    const struct gl_pixelstore_attrib *unpack,
+                    const GLvoid * pixels)
+{
+   fxMesaContext fxMesa = FX_CONTEXT(ctx);
+   GrLfbInfo_t info;
+
+   if (ctx->Pixel.ZoomX != 1.0F ||
+       ctx->Pixel.ZoomY != 1.0F ||
+       (ctx->_ImageTransferState & (IMAGE_SCALE_BIAS_BIT|
+				    IMAGE_MAP_COLOR_BIT)) ||
+       ctx->Color.AlphaEnabled ||
+       ctx->Depth.Test ||
+       ctx->Fog.Enabled ||
+       ctx->Scissor.Enabled ||
+       ctx->Stencil.Enabled ||
+       !ctx->Color.ColorMask[0] ||
+       !ctx->Color.ColorMask[1] ||
+       !ctx->Color.ColorMask[2] ||
+       !ctx->Color.ColorMask[3] ||
+       ctx->Color.ColorLogicOpEnabled ||
+       ctx->Texture._EnabledUnits ||
+       ctx->Depth.OcclusionTest ||
+       fxMesa->fallback)
+   {
+      _swrast_DrawPixels( ctx, x, y, width, height, format, type, 
+			  unpack, pixels );
+      return; 
+   }
+
+   /* lock early to make sure cliprects are right */
+   BEGIN_BOARD_LOCK();
+
+   /* make sure the pixelpipe is configured correctly */
+   fxSetupFXUnits(ctx);
+
+   /* look for clipmasks, giveup if region obscured */
+#if 0
+   if (ctx->Color.DrawBuffer == GL_FRONT) {
+      if (!inClipRects_Region(fxMesa, scrX, scrY, width, height)) {
+         END_BOARD_LOCK(fxMesa);
+         _swrast_DrawPixels(ctx, x, y, width, height, format, type, unpack, pixels);
+         return;
+      }
+   }
+#endif
+
+   info.size = sizeof(info);
+   if (!grLfbLock(GR_LFB_WRITE_ONLY,
+                  fxMesa->currentFB,
+                  GR_LFBWRITEMODE_8888,
+                  GR_ORIGIN_UPPER_LEFT, FXTRUE, &info)) {
+      _swrast_DrawPixels(ctx, x, y, width, height, format, type, unpack, pixels);
+      return;
+   }
+
+   {
+      const GLint winX = 0;
+      const GLint winY = fxMesa->height - 1;
+
+      const GLint dstStride = info.strideInBytes / 4;	/* stride in GLuints */
+      GLuint *dst = (GLuint *) info.lfbPtr + (winY - y) * dstStride + (winX + x);
+      const GLubyte *src = (GLubyte *)_mesa_image_address(unpack, pixels,
+							width, height, format,
+							type, 0, 0, 0);
+      const GLint srcStride = _mesa_image_row_stride(unpack, width, format, type);
+
+      if (format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
+         /* directly memcpy 8A8R8G8B pixels to screen */
+         const GLint widthInBytes = width * 4;
+         GLint row;
+         for (row = 0; row < height; row++) {
+             MEMCPY(dst, src, widthInBytes);
+             dst -= dstStride;
+             src += srcStride;
+         }
+      }
+      else {
+         grLfbUnlock(GR_LFB_WRITE_ONLY, fxMesa->currentFB);
+         END_BOARD_LOCK();
+         _swrast_DrawPixels(ctx, x, y, width, height, format, type, unpack, pixels);
+         return;
+      }
+
+   }
+
+   grLfbUnlock(GR_LFB_WRITE_ONLY, fxMesa->currentFB);
+   END_BOARD_LOCK();
+}
+
+
 static void
 fxDDFinish(GLcontext * ctx)
 {
@@ -1031,6 +1342,7 @@ fxDDInitFxMesaContext(fxMesaContext fxMesa)
    fxMesa->unitsState.blendDstFuncRGB = GR_BLEND_ZERO;
    fxMesa->unitsState.blendSrcFuncAlpha = GR_BLEND_ONE;
    fxMesa->unitsState.blendDstFuncAlpha = GR_BLEND_ZERO;
+   fxMesa->unitsState.blendEq = GR_BLEND_OP_ADD;
 
    fxMesa->unitsState.depthTestEnabled = GL_FALSE;
    fxMesa->unitsState.depthMask = GL_TRUE;
@@ -1151,6 +1463,7 @@ fxDDInitExtensions(GLcontext * ctx)
    _mesa_enable_extension(ctx, "GL_EXT_paletted_texture");
    _mesa_enable_extension(ctx, "GL_EXT_texture_lod_bias");
    _mesa_enable_extension(ctx, "GL_EXT_shared_texture_palette");
+   _mesa_enable_extension(ctx, "GL_EXT_blend_func_separate");
 
    if (fxMesa->haveTwoTMUs) {
       _mesa_enable_extension(ctx, "GL_EXT_texture_env_add");
@@ -1170,9 +1483,14 @@ fxDDInitExtensions(GLcontext * ctx)
       _mesa_enable_extension( ctx, "GL_3DFX_texture_compression_FXT1" );
       _mesa_enable_extension( ctx, "GL_EXT_texture_compression_s3tc" );
       /*_mesa_enable_extension( ctx, "GL_S3_s3tc" );*/
+   }
+
+   if (fxMesa->HaveCmbExt) {
+      _mesa_enable_extension(ctx, "GL_EXT_texture_env_combine");
+   }
 
-      /* env_combine: not ready yet */
-      /*_mesa_enable_extension( ctx, "GL_EXT_texture_env_combine" );*/
+   if (fxMesa->HavePixExt) {
+      _mesa_enable_extension(ctx, "GL_EXT_blend_subtract");
    }
 
    if (fxMesa->HaveMirExt) {
@@ -1206,8 +1524,17 @@ fx_check_IsInHardware(GLcontext * ctx)
       return FX_FALLBACK_DRAW_BUFFER;
    }
 
-   if (ctx->Color.BlendEnabled && (ctx->Color.BlendEquation != GL_FUNC_ADD_EXT)) {
-      return FX_FALLBACK_BLEND;
+   if (ctx->Color.BlendEnabled) {
+      if (ctx->Color.BlendEquation != GL_FUNC_ADD_EXT) {
+         if (fxMesa->HavePixExt) {
+            if ((ctx->Color.BlendEquation != GL_FUNC_SUBTRACT_EXT) &&
+                (ctx->Color.BlendEquation != GL_FUNC_REVERSE_SUBTRACT_EXT)) {
+               return FX_FALLBACK_BLEND;
+            }
+         } else {
+            return FX_FALLBACK_BLEND;
+         }
+      }
    }
 
    if (ctx->Color.ColorLogicOpEnabled && (ctx->Color.LogicOp != GL_COPY)) {
@@ -1237,6 +1564,7 @@ fx_check_IsInHardware(GLcontext * ctx)
 	 return FX_FALLBACK_TEXTURE_1D_3D;
 
       if (ctx->Texture.Unit[0]._ReallyEnabled & TEXTURE_2D_BIT) {
+         if (fxMesa->type < GR_SSTTYPE_Voodoo2)
 	 if (ctx->Texture.Unit[0].EnvMode == GL_BLEND &&
 	     (ctx->Texture.Unit[1]._ReallyEnabled & TEXTURE_2D_BIT ||
 	      ctx->Texture.Unit[0].EnvColor[0] != 0 ||
@@ -1250,6 +1578,7 @@ fx_check_IsInHardware(GLcontext * ctx)
       }
 
       if (ctx->Texture.Unit[1]._ReallyEnabled & TEXTURE_2D_BIT) {
+         if (fxMesa->type < GR_SSTTYPE_Voodoo2)
 	 if (ctx->Texture.Unit[1].EnvMode == GL_BLEND)
 	    return FX_FALLBACK_TEXTURE_ENV;
 	 if (ctx->Texture.Unit[1]._Current->Image[0]->Border > 0)
@@ -1289,6 +1618,7 @@ fx_check_IsInHardware(GLcontext * ctx)
 	 return FX_FALLBACK_TEXTURE_MULTI;
       }
 
+      if (fxMesa->type < GR_SSTTYPE_Voodoo2)
       if ((ctx->Texture.Unit[0]._ReallyEnabled & TEXTURE_2D_BIT) &&
 	  (ctx->Texture.Unit[0].EnvMode == GL_BLEND)) {
 	 return FX_FALLBACK_TEXTURE_ENV;
@@ -1339,18 +1669,21 @@ fxSetupDDPointers(GLcontext * ctx)
    ctx->Driver.DrawBuffer = fxDDSetDrawBuffer;
    ctx->Driver.GetBufferSize = fxDDBufferSize;
    ctx->Driver.Accum = _swrast_Accum;
-   ctx->Driver.Bitmap = fxDDDrawBitmap;
    ctx->Driver.CopyPixels = _swrast_CopyPixels;
    ctx->Driver.DrawPixels = _swrast_DrawPixels;
    switch (fxMesa->colDepth) {
           case 15:
                ctx->Driver.ReadPixels = fxDDReadPixels555;
+               ctx->Driver.Bitmap = fxDDDrawBitmap2;
                break;
           case 16:
-               ctx->Driver.ReadPixels = fxDDReadPixels;
+               ctx->Driver.ReadPixels = fxDDReadPixels565;
+               ctx->Driver.Bitmap = fxDDDrawBitmap2;
                break;
           case 32:
-               ctx->Driver.ReadPixels = fxDDReadPixels888;
+               ctx->Driver.DrawPixels = fxDDDrawPixels8888;
+               ctx->Driver.ReadPixels = fxDDReadPixels8888;
+               ctx->Driver.Bitmap = fxDDDrawBitmap4;
                break;
    }
    ctx->Driver.ResizeBuffers = _swrast_alloc_buffers;
@@ -1387,6 +1720,8 @@ fxSetupDDPointers(GLcontext * ctx)
    ctx->Driver.UpdateTexturePalette = fxDDTexPalette;
    ctx->Driver.AlphaFunc = fxDDAlphaFunc;
    ctx->Driver.BlendFunc = fxDDBlendFunc;
+   ctx->Driver.BlendFuncSeparate = fxDDBlendFuncSeparate;
+   ctx->Driver.BlendEquation = fxDDBlendEquation;
    ctx->Driver.DepthFunc = fxDDDepthFunc;
    ctx->Driver.DepthMask = fxDDDepthMask;
    ctx->Driver.ColorMask = fxDDColorMask;