From f03cb2e4eea23fd82e9837e05f0ab3a83cb474c7 Mon Sep 17 00:00:00 2001 From: Daniel Borca Date: Tue, 21 Oct 2003 08:31:02 +0000 Subject: Napalm total immersion --- src/mesa/drivers/glide/fxdd.c | 467 ++++++++++++++++++++++++++++++++++++------ 1 file changed, 401 insertions(+), 66 deletions(-) (limited to 'src/mesa/drivers/glide/fxdd.c') diff --git a/src/mesa/drivers/glide/fxdd.c b/src/mesa/drivers/glide/fxdd.c index 7087c30b66..fec2ee9d72 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; -- cgit v1.2.3