X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fdrivers%2Fglide%2Ffxdd.c;h=213ef2382feaad5db265bc964c147a20aaf9ef0a;hb=3a40dee3eb5151a282ce831b67427f3aa625de28;hp=a5541eceb1dc39510cdf9b277289b81bda3e8f26;hpb=9a33a11d714c90162d32781ebbd2c1dfab52cfd1;p=mesa.git diff --git a/src/mesa/drivers/glide/fxdd.c b/src/mesa/drivers/glide/fxdd.c index a5541eceb1d..213ef2382fe 100644 --- a/src/mesa/drivers/glide/fxdd.c +++ b/src/mesa/drivers/glide/fxdd.c @@ -1,10 +1,8 @@ -/* $Id: fxdd.c,v 1.86 2002/06/13 04:28:30 brianp Exp $ */ - /* * Mesa 3-D graphics library - * Version: 4.0 + * Version: 5.1 * - * Copyright (C) 1999-2001 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2003 Brian Paul All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), @@ -29,6 +27,8 @@ * Brian Paul * Daryll Strauss * Keith Whitwell + * Daniel Borca + * Hiroshi Morii */ /* fxdd.c - 3Dfx VooDoo Mesa device driver functions */ @@ -40,60 +40,64 @@ #if defined(FX) -#include "image.h" -#include "mtypes.h" +#include "main/image.h" +#include "main/mtypes.h" #include "fxdrv.h" -#include "enums.h" -#include "extensions.h" -#include "texstore.h" +#include "main/buffers.h" +#include "main/enums.h" +#include "main/extensions.h" +#include "main/macros.h" +#include "main/texstore.h" +#include "main/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" #include "tnl/t_pipeline.h" -#include "array_cache/acache.h" +#include "vbo/vbo.h" -float gl_ubyte_to_float_255_color_tab[256]; +/* lookup table for scaling 4 bit colors up to 8 bits */ +GLuint FX_rgb_scale_4[16] = { + 0, 17, 34, 51, 68, 85, 102, 119, + 136, 153, 170, 187, 204, 221, 238, 255 +}; -/* These lookup table are used to extract RGB values in [0,255] from - * 16-bit pixel values. - */ -GLubyte FX_PixelToR[0x10000]; -GLubyte FX_PixelToG[0x10000]; -GLubyte FX_PixelToB[0x10000]; +/* lookup table for scaling 5 bit colors up to 8 bits */ +GLuint FX_rgb_scale_5[32] = { + 0, 8, 16, 25, 33, 41, 49, 58, + 66, 74, 82, 90, 99, 107, 115, 123, + 132, 140, 148, 156, 165, 173, 181, 189, + 197, 206, 214, 222, 230, 239, 247, 255 +}; + +/* lookup table for scaling 6 bit colors up to 8 bits */ +GLuint FX_rgb_scale_6[64] = { + 0, 4, 8, 12, 16, 20, 24, 28, + 32, 36, 40, 45, 49, 53, 57, 61, + 65, 69, 73, 77, 81, 85, 89, 93, + 97, 101, 105, 109, 113, 117, 121, 125, + 130, 134, 138, 142, 146, 150, 154, 158, + 162, 166, 170, 174, 178, 182, 186, 190, + 194, 198, 202, 206, 210, 215, 219, 223, + 227, 231, 235, 239, 243, 247, 251, 255 +}; /* - * Initialize the FX_PixelTo{RGB} arrays. - * Input: bgrOrder - if TRUE, pixels are in BGR order, else RGB order. + * Disable color by masking out R, G, B, A */ -void -fxInitPixelTables(fxMesaContext fxMesa, GLboolean bgrOrder) +static void fxDisableColor (fxMesaContext fxMesa) { - GLuint pixel; - - fxMesa->bgrOrder = bgrOrder; - for (pixel = 0; pixel <= 0xffff; pixel++) { - GLuint r, g, b; - if (bgrOrder) { - r = (pixel & 0x001F) << 3; - g = (pixel & 0x07E0) >> 3; - b = (pixel & 0xF800) >> 8; - } - else { - r = (pixel & 0xF800) >> 8; - g = (pixel & 0x07E0) >> 3; - b = (pixel & 0x001F) << 3; - } - r = r * 255 / 0xF8; /* fill in low-order bits */ - g = g * 255 / 0xFC; - b = b * 255 / 0xF8; - FX_PixelToR[pixel] = r; - FX_PixelToG[pixel] = g; - FX_PixelToB[pixel] = b; - } + if (fxMesa->colDepth == 32) { + /* 32bpp mode */ + fxMesa->Glide.grColorMaskExt(FXFALSE, FXFALSE, FXFALSE, FXFALSE); + } else { + /* 15/16 bpp mode */ + grColorMask(FXFALSE, FXFALSE); + } } @@ -103,232 +107,361 @@ fxInitPixelTables(fxMesaContext fxMesa, GLboolean bgrOrder) /* Return buffer size information */ static void -fxDDBufferSize(GLframebuffer *buffer, GLuint * width, GLuint * height) +fxDDGetBufferSize(GLframebuffer *buffer, GLuint *width, GLuint *height) { GET_CURRENT_CONTEXT(ctx); - if (ctx && ctx->DriverCtx) { - fxMesaContext fxMesa = (fxMesaContext) ctx->DriverCtx; + if (ctx && FX_CONTEXT(ctx)) { + fxMesaContext fxMesa = FX_CONTEXT(ctx); - if (MESA_VERBOSE & VERBOSE_DRIVER) { - fprintf(stderr, "fxmesa: fxDDBufferSize(...) Start\n"); + if (TDFX_DEBUG & VERBOSE_DRIVER) { + fprintf(stderr, "fxDDGetBufferSize(...)\n"); } *width = fxMesa->width; *height = fxMesa->height; + } +} - if (MESA_VERBOSE & VERBOSE_DRIVER) { - fprintf(stderr, "fxmesa: fxDDBufferSize(...) End\n"); - } + +/** + * We only implement this function as a mechanism to check if the + * framebuffer size has changed (and update corresponding state). + */ +static void +fxDDViewport(GLcontext *ctx, GLint x, GLint y, GLsizei w, GLsizei h) +{ + GLuint newWidth, newHeight; + GLframebuffer *buffer = ctx->WinSysDrawBuffer; + fxDDGetBufferSize( buffer, &newWidth, &newHeight ); + if (buffer->Width != newWidth || buffer->Height != newHeight) { + _mesa_resize_framebuffer(ctx, buffer, newWidth, newHeight ); } } /* Implements glClearColor() */ static void -fxDDClearColor(GLcontext * ctx, const GLchan color[4]) +fxDDClearColor(GLcontext * ctx, const GLfloat color[4]) { - fxMesaContext fxMesa = (fxMesaContext) ctx->DriverCtx; + fxMesaContext fxMesa = FX_CONTEXT(ctx); GLubyte col[4]; - if (MESA_VERBOSE & VERBOSE_DRIVER) { - fprintf(stderr, "fxmesa: fxDDClearColor(%d,%d,%d,%d)\n", - color[0], color[1], color[2], color[3]); + if (TDFX_DEBUG & VERBOSE_DRIVER) { + fprintf(stderr, "fxDDClearColor(%f, %f, %f, %f)\n", + color[0], color[1], color[2], color[3]); } - ASSIGN_4V(col, color[0], color[1], color[2], 255); + CLAMPED_FLOAT_TO_UBYTE(col[0], color[0]); + CLAMPED_FLOAT_TO_UBYTE(col[1], color[1]); + CLAMPED_FLOAT_TO_UBYTE(col[2], color[2]); + CLAMPED_FLOAT_TO_UBYTE(col[3], color[3]); + fxMesa->clearC = FXCOLOR4(col); - fxMesa->clearA = color[3]; + fxMesa->clearA = col[3]; } /* Clear the color and/or depth buffers */ -static void -fxDDClear(GLcontext * ctx, GLbitfield mask, GLboolean all, - GLint x, GLint y, GLint width, GLint height) +static void fxDDClear( GLcontext *ctx, GLbitfield mask ) { - fxMesaContext fxMesa = (fxMesaContext) ctx->DriverCtx; - const GLuint colorMask = *((GLuint *) & ctx->Color.ColorMask); - const FxU16 clearD = (FxU16) (ctx->Depth.Clear * 0xffff); - GLbitfield softwareMask = mask & (DD_STENCIL_BIT | DD_ACCUM_BIT); - - /* we can't clear stencil or accum buffers */ - mask &= ~(DD_STENCIL_BIT | DD_ACCUM_BIT); + fxMesaContext fxMesa = FX_CONTEXT(ctx); + GLbitfield softwareMask = mask & (BUFFER_BIT_ACCUM); + const GLuint stencil_size = fxMesa->haveHwStencil ? ctx->Visual.stencilBits : 0; + const FxU32 clearD = (FxU32) (ctx->DrawBuffer->_DepthMaxF * ctx->Depth.Clear); + const FxU8 clearS = (FxU8) (ctx->Stencil.Clear & 0xff); - if (MESA_VERBOSE & VERBOSE_DRIVER) { - fprintf(stderr, "fxmesa: fxDDClear(%d,%d,%d,%d)\n", (int) x, (int) y, - (int) width, (int) height); + if ( TDFX_DEBUG & MESA_VERBOSE ) { + fprintf( stderr, "fxDDClear\n"); } - if (colorMask != 0xffffffff) { - /* do masked color buffer clears in software */ - softwareMask |= (mask & (DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT)); - mask &= ~(DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT); + /* we can't clear accum buffers nor stereo */ + mask &= ~(BUFFER_BIT_ACCUM | BUFFER_BIT_FRONT_RIGHT | BUFFER_BIT_BACK_RIGHT); + + /* Need this check to respond to certain HW updates */ + if (fxMesa->new_state & (FX_NEW_SCISSOR | FX_NEW_COLOR_MASK)) { + fxSetupScissor(ctx); + fxSetupColorMask(ctx); + fxMesa->new_state &= ~(FX_NEW_SCISSOR | FX_NEW_COLOR_MASK); } /* - * This could probably be done fancier but doing each possible case - * explicitly is less error prone. + * As per GL spec, color masking should be obeyed when clearing */ - switch (mask) { - case DD_BACK_LEFT_BIT | DD_DEPTH_BIT: - /* back buffer & depth */ - FX_grDepthMask(FXTRUE); - FX_grRenderBuffer(GR_BUFFER_BACKBUFFER); - FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, clearD); - if (!ctx->Depth.Mask) { - FX_grDepthMask(FXFALSE); + if (ctx->Visual.greenBits != 8) { + /* can only do color masking if running in 24/32bpp on Napalm */ + if (ctx->Color.ColorMask[RCOMP] != ctx->Color.ColorMask[GCOMP] || + ctx->Color.ColorMask[GCOMP] != ctx->Color.ColorMask[BCOMP]) { + softwareMask |= (mask & (BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT)); + mask &= ~(BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT); } - break; - case DD_FRONT_LEFT_BIT | DD_DEPTH_BIT: - /* XXX it appears that the depth buffer isn't cleared when - * glRenderBuffer(GR_BUFFER_FRONTBUFFER) is set. - * This is a work-around/ + } + + if (fxMesa->haveHwStencil) { + /* + * If we want to clear stencil, it must be enabled + * in the HW, even if the stencil test is not enabled + * in the OGL state. */ - /* clear depth */ - FX_grDepthMask(FXTRUE); - FX_grRenderBuffer(GR_BUFFER_BACKBUFFER); - FX_grColorMask(FXFALSE, FXFALSE); - FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, clearD); - /* clear front */ - FX_grColorMask(FXTRUE, ctx->Color.ColorMask[ACOMP] - && fxMesa->haveAlphaBuffer); - FX_grRenderBuffer(GR_BUFFER_FRONTBUFFER); - FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, clearD); - break; - case DD_BACK_LEFT_BIT: - /* back buffer only */ - FX_grDepthMask(FXFALSE); - FX_grRenderBuffer(GR_BUFFER_BACKBUFFER); - FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, clearD); - if (ctx->Depth.Mask) { - FX_grDepthMask(FXTRUE); - } - break; - case DD_FRONT_LEFT_BIT: - /* front buffer only */ - FX_grDepthMask(FXFALSE); - FX_grRenderBuffer(GR_BUFFER_FRONTBUFFER); - FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, clearD); - if (ctx->Depth.Mask) { - FX_grDepthMask(FXTRUE); - } - break; - case DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT: - /* front and back */ - FX_grDepthMask(FXFALSE); - FX_grRenderBuffer(GR_BUFFER_BACKBUFFER); - FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, clearD); - FX_grRenderBuffer(GR_BUFFER_FRONTBUFFER); - FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, clearD); - if (ctx->Depth.Mask) { - FX_grDepthMask(FXTRUE); + BEGIN_BOARD_LOCK(); + if (mask & BUFFER_BIT_STENCIL) { + fxMesa->Glide.grStencilMaskExt(fxMesa->unitsState.stencilWriteMask); + /* set stencil ref value = desired clear value */ + fxMesa->Glide.grStencilFuncExt(GR_CMP_ALWAYS, clearS, 0xff); + fxMesa->Glide.grStencilOpExt(GR_STENCILOP_REPLACE, + GR_STENCILOP_REPLACE, GR_STENCILOP_REPLACE); + grEnable(GR_STENCIL_MODE_EXT); } - break; - case DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT | DD_DEPTH_BIT: - /* clear front */ - FX_grDepthMask(FXFALSE); - FX_grRenderBuffer(GR_BUFFER_FRONTBUFFER); - FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, clearD); - /* clear back and depth */ - FX_grDepthMask(FXTRUE); - FX_grRenderBuffer(GR_BUFFER_BACKBUFFER); - FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, clearD); - if (!ctx->Depth.Mask) { - FX_grDepthMask(FXFALSE); + else { + grDisable(GR_STENCIL_MODE_EXT); } - break; - case DD_DEPTH_BIT: - /* just the depth buffer */ - FX_grRenderBuffer(GR_BUFFER_BACKBUFFER); - FX_grColorMask(FXFALSE, FXFALSE); - FX_grDepthMask(FXTRUE); - FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, clearD); - FX_grColorMask(FXTRUE, ctx->Color.ColorMask[ACOMP] - && fxMesa->haveAlphaBuffer); - if (ctx->Color.DrawDestMask & FRONT_LEFT_BIT) - FX_grRenderBuffer(GR_BUFFER_FRONTBUFFER); - if (!ctx->Depth.Test || !ctx->Depth.Mask) - FX_grDepthMask(FXFALSE); - break; - default: - /* error */ - ; - } - - /* Clear any remaining buffers: + END_BOARD_LOCK(); + } else if (mask & BUFFER_BIT_STENCIL) { + softwareMask |= (mask & (BUFFER_BIT_STENCIL)); + mask &= ~(BUFFER_BIT_STENCIL); + } + + /* + * This may be ugly, but it's needed in order to work around a number + * of Glide bugs. */ + BEGIN_CLIP_LOOP(); + { + /* + * This could probably be done fancier but doing each possible case + * explicitly is less error prone. + */ + switch (mask & ~BUFFER_BIT_STENCIL) { + case BUFFER_BIT_BACK_LEFT | BUFFER_BIT_DEPTH: + /* back buffer & depth */ + grDepthMask(FXTRUE); + grRenderBuffer(GR_BUFFER_BACKBUFFER); + if (stencil_size > 0) { + fxMesa->Glide.grBufferClearExt(fxMesa->clearC, + fxMesa->clearA, + clearD, clearS); + } + else + grBufferClear(fxMesa->clearC, + fxMesa->clearA, + clearD); + break; + case BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_DEPTH: + /* XXX it appears that the depth buffer isn't cleared when + * glRenderBuffer(GR_BUFFER_FRONTBUFFER) is set. + * This is a work-around/ + */ + /* clear depth */ + grDepthMask(FXTRUE); + fxDisableColor(fxMesa); + grRenderBuffer(GR_BUFFER_BACKBUFFER); + if (stencil_size > 0) + fxMesa->Glide.grBufferClearExt(fxMesa->clearC, + fxMesa->clearA, + clearD, clearS); + else + grBufferClear(fxMesa->clearC, + fxMesa->clearA, + clearD); + fxSetupColorMask(ctx); + grDepthMask(FXFALSE); + /* clear front */ + grRenderBuffer(GR_BUFFER_FRONTBUFFER); + if (stencil_size > 0) + fxMesa->Glide.grBufferClearExt(fxMesa->clearC, + fxMesa->clearA, + clearD, clearS); + else + grBufferClear(fxMesa->clearC, + fxMesa->clearA, + clearD); + break; + case BUFFER_BIT_BACK_LEFT: + /* back buffer only */ + grDepthMask(FXFALSE); + grRenderBuffer(GR_BUFFER_BACKBUFFER); + if (stencil_size > 0) + fxMesa->Glide.grBufferClearExt(fxMesa->clearC, + fxMesa->clearA, + clearD, clearS); + else + grBufferClear(fxMesa->clearC, + fxMesa->clearA, + clearD); + break; + case BUFFER_BIT_FRONT_LEFT: + /* front buffer only */ + grDepthMask(FXFALSE); + grRenderBuffer(GR_BUFFER_FRONTBUFFER); + if (stencil_size > 0) + fxMesa->Glide.grBufferClearExt(fxMesa->clearC, + fxMesa->clearA, + clearD, clearS); + else + grBufferClear(fxMesa->clearC, + fxMesa->clearA, + clearD); + break; + case BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT: + /* front and back */ + grDepthMask(FXFALSE); + grRenderBuffer(GR_BUFFER_BACKBUFFER); + if (stencil_size > 0) + fxMesa->Glide.grBufferClearExt(fxMesa->clearC, + fxMesa->clearA, + clearD, clearS); + else + grBufferClear(fxMesa->clearC, + fxMesa->clearA, + clearD); + grRenderBuffer(GR_BUFFER_FRONTBUFFER); + if (stencil_size > 0) + fxMesa->Glide.grBufferClearExt(fxMesa->clearC, + fxMesa->clearA, + clearD, clearS); + else + grBufferClear(fxMesa->clearC, + fxMesa->clearA, + clearD); + break; + case BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT | BUFFER_BIT_DEPTH: + /* clear back and depth */ + grDepthMask(FXTRUE); + grRenderBuffer(GR_BUFFER_BACKBUFFER); + if (stencil_size > 0) + fxMesa->Glide.grBufferClearExt(fxMesa->clearC, + fxMesa->clearA, + clearD, clearS); + else + grBufferClear(fxMesa->clearC, + fxMesa->clearA, + clearD); + /* clear front */ + grDepthMask(FXFALSE); + grRenderBuffer(GR_BUFFER_FRONTBUFFER); + if (stencil_size > 0) + fxMesa->Glide.grBufferClearExt(fxMesa->clearC, + fxMesa->clearA, + clearD, clearS); + else + grBufferClear(fxMesa->clearC, + fxMesa->clearA, + clearD); + break; + case BUFFER_BIT_DEPTH: + /* just the depth buffer */ + grDepthMask(FXTRUE); + fxDisableColor(fxMesa); + grRenderBuffer(GR_BUFFER_BACKBUFFER); + if (stencil_size > 0) + fxMesa->Glide.grBufferClearExt(fxMesa->clearC, + fxMesa->clearA, + clearD, clearS); + else + grBufferClear(fxMesa->clearC, + fxMesa->clearA, + clearD); + fxSetupColorMask(ctx); + break; + default: + /* clear no color buffers or depth buffer but might clear stencil */ + if ((stencil_size > 0) && (mask & BUFFER_BIT_STENCIL)) { + /* XXX need this RenderBuffer call to work around Glide bug */ + grDepthMask(FXFALSE); + grRenderBuffer(GR_BUFFER_BACKBUFFER); + fxDisableColor(fxMesa); + fxMesa->Glide.grBufferClearExt(fxMesa->clearC, + fxMesa->clearA, + clearD, clearS); + fxSetupColorMask(ctx); + } + } + } + END_CLIP_LOOP(); + + if (fxMesa->haveHwStencil) { + /* We changed the stencil state above. Restore it! */ + fxSetupStencil(ctx); + } + fxSetupDepthTest(ctx); + grRenderBuffer(fxMesa->currentFB); + if (softwareMask) - _swrast_Clear(ctx, softwareMask, all, x, y, width, height); + _swrast_Clear( ctx, softwareMask ); } /* Set the buffer used for drawing */ /* XXX support for separate read/draw buffers hasn't been tested */ -static GLboolean +/* XXX GL_NONE disables color, but fails to correctly maintain state */ +static void fxDDSetDrawBuffer(GLcontext * ctx, GLenum mode) { - fxMesaContext fxMesa = (fxMesaContext) ctx->DriverCtx; + fxMesaContext fxMesa = FX_CONTEXT(ctx); - if (MESA_VERBOSE & VERBOSE_DRIVER) { - fprintf(stderr, "fxmesa: fxDDSetBuffer(%x)\n", (int) mode); + if (TDFX_DEBUG & VERBOSE_DRIVER) { + fprintf(stderr, "fxDDSetDrawBuffer(%x)\n", (int)mode); } if (mode == GL_FRONT_LEFT) { fxMesa->currentFB = GR_BUFFER_FRONTBUFFER; - FX_grRenderBuffer(fxMesa->currentFB); - return GL_TRUE; + grRenderBuffer(fxMesa->currentFB); } else if (mode == GL_BACK_LEFT) { fxMesa->currentFB = GR_BUFFER_BACKBUFFER; - FX_grRenderBuffer(fxMesa->currentFB); - return GL_TRUE; + grRenderBuffer(fxMesa->currentFB); } else if (mode == GL_NONE) { - FX_grColorMask(FXFALSE, FXFALSE); - return GL_TRUE; + fxDisableColor(fxMesa); } else { - return GL_FALSE; + /* we'll need a software fallback */ + /* XXX not implemented */ } -} - - + /* update s/w fallback state */ + _swrast_DrawBuffer(ctx, 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 = (fxMesaContext) ctx->DriverCtx; + 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.MultiDrawBuffer) { + 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 | + 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); + /* FIXME! _RasterMask & CLIP_BIT gets set if we're out of Viewport, also! */ 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 */ @@ -367,34 +500,31 @@ 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); */ - 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); + 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 (fxMesa->colDepth == 15) { + color = TDFXPACKCOLOR1555(b, g, r, a); + mode = GR_LFBWRITEMODE_1555; + } else { + color = fxMesa->bgrOrder ? TDFXPACKCOLOR565(r, g, b) : TDFXPACKCOLOR565(b, g, r); + mode = GR_LFBWRITEMODE_565; + } } info.size = sizeof(info); - if (!FX_grLfbLock(GR_LFB_WRITE_ONLY, - fxMesa->currentFB, - GR_LFBWRITEMODE_565, - GR_ORIGIN_UPPER_LEFT, FXFALSE, &info)) { -#ifndef FX_SILENT - fprintf(stderr, "fx Driver: error locking the linear frame buffer\n"); -#endif + if (!grLfbLock(GR_LFB_WRITE_ONLY, + fxMesa->currentFB, + mode, + GR_ORIGIN_LOWER_LEFT, FXTRUE, &info)) { + _swrast_Bitmap(ctx, px, py, width, height, finalUnpack, bitmap); return; } { const GLint winX = 0; - const GLint winY = fxMesa->height - 1; + const GLint winY = 0; /* 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. @@ -404,14 +534,172 @@ fxDDDrawBitmap(GLcontext * ctx, GLint px, GLint py, GLint row; /* compute dest address of bottom-left pixel in bitmap */ GLushort *dst = (GLushort *) info.lfbPtr - + (winY - py) * dstStride + (winX + px); + + (winY + py) * dstStride + (winX + px); + + for (row = 0; row < height; row++) { + const GLubyte *src = + (const GLubyte *) _mesa_image_address2d(finalUnpack, + bitmap, width, height, + GL_COLOR_INDEX, GL_BITMAP, + 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 +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 */ + 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); + + /* FIXME! _RasterMask & CLIP_BIT gets set if we're out of Viewport, also! */ + 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); + color = TDFXPACKCOLOR8888(b, g, r, a); + } + + info.size = sizeof(info); + if (!grLfbLock(GR_LFB_WRITE_ONLY, + fxMesa->currentFB, + GR_LFBWRITEMODE_8888, + GR_ORIGIN_LOWER_LEFT, FXTRUE, &info)) { + _swrast_Bitmap(ctx, px, py, width, height, finalUnpack, bitmap); + return; + } + + { + const GLint winX = 0; + const GLint winY = 0; + /* 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); + (const GLubyte *) _mesa_image_address2d(finalUnpack, + bitmap, width, height, + GL_COLOR_INDEX, GL_BITMAP, + row, 0); if (finalUnpack->LsbFirst) { /* least significan bit first */ GLubyte mask = 1U << (finalUnpack->SkipPixels & 0x7); @@ -450,30 +738,33 @@ fxDDDrawBitmap(GLcontext * ctx, GLint px, GLint py, if (mask != 128) src++; } - dst -= dstStride; + dst += dstStride; } } - FX_grLfbUnlock(GR_LFB_WRITE_ONLY, fxMesa->currentFB); + 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; } else { - fxMesaContext fxMesa = (fxMesaContext) ctx->DriverCtx; + fxMesaContext fxMesa = FX_CONTEXT(ctx); GrLfbInfo_t info; BEGIN_BOARD_LOCK(); + info.size = sizeof(info); if (grLfbLock(GR_LFB_READ_ONLY, fxMesa->currentFB, GR_LFBWRITEMODE_ANY, @@ -483,9 +774,9 @@ fxDDReadPixels(GLcontext * ctx, GLint x, GLint y, const GLint srcStride = info.strideInBytes / 2; /* stride in GLushorts */ const GLushort *src = (const GLushort *) info.lfbPtr + (winY - y) * srcStride + (winX + x); - GLubyte *dst = (GLubyte *) _mesa_image_address(packing, dstImage, + GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, dstImage, width, height, format, - type, 0, 0, 0); + type, 0, 0); GLint dstStride = _mesa_image_row_stride(packing, width, format, type); @@ -498,20 +789,18 @@ fxDDReadPixels(GLcontext * ctx, GLint x, GLint y, GLubyte *d = dst; for (col = 0; col < halfWidth; col++) { const GLuint pixel = ((const GLuint *) src)[col]; - const GLint pixel0 = pixel & 0xffff; - const GLint pixel1 = pixel >> 16; - *d++ = FX_PixelToR[pixel0]; - *d++ = FX_PixelToG[pixel0]; - *d++ = FX_PixelToB[pixel0]; - *d++ = FX_PixelToR[pixel1]; - *d++ = FX_PixelToG[pixel1]; - *d++ = FX_PixelToB[pixel1]; + *d++ = FX_rgb_scale_5[(pixel >> 11) & 0x1f]; + *d++ = FX_rgb_scale_6[(pixel >> 5) & 0x3f]; + *d++ = FX_rgb_scale_5[ pixel & 0x1f]; + *d++ = FX_rgb_scale_5[(pixel >> 27) & 0x1f]; + *d++ = FX_rgb_scale_6[(pixel >> 21) & 0x3f]; + *d++ = FX_rgb_scale_5[(pixel >> 16) & 0x1f]; } if (extraPixel) { GLushort pixel = src[width - 1]; - *d++ = FX_PixelToR[pixel]; - *d++ = FX_PixelToG[pixel]; - *d++ = FX_PixelToB[pixel]; + *d++ = FX_rgb_scale_5[(pixel >> 11) & 0x1f]; + *d++ = FX_rgb_scale_6[(pixel >> 5) & 0x3f]; + *d++ = FX_rgb_scale_5[ pixel & 0x1f]; } dst += dstStride; src -= srcStride; @@ -526,22 +815,20 @@ fxDDReadPixels(GLcontext * ctx, GLint x, GLint y, GLubyte *d = dst; for (col = 0; col < halfWidth; col++) { const GLuint pixel = ((const GLuint *) src)[col]; - const GLint pixel0 = pixel & 0xffff; - const GLint pixel1 = pixel >> 16; - *d++ = FX_PixelToR[pixel0]; - *d++ = FX_PixelToG[pixel0]; - *d++ = FX_PixelToB[pixel0]; + *d++ = FX_rgb_scale_5[(pixel >> 11) & 0x1f]; + *d++ = FX_rgb_scale_6[(pixel >> 5) & 0x3f]; + *d++ = FX_rgb_scale_5[ pixel & 0x1f]; *d++ = 255; - *d++ = FX_PixelToR[pixel1]; - *d++ = FX_PixelToG[pixel1]; - *d++ = FX_PixelToB[pixel1]; + *d++ = FX_rgb_scale_5[(pixel >> 27) & 0x1f]; + *d++ = FX_rgb_scale_6[(pixel >> 21) & 0x3f]; + *d++ = FX_rgb_scale_5[(pixel >> 16) & 0x1f]; *d++ = 255; } if (extraPixel) { const GLushort pixel = src[width - 1]; - *d++ = FX_PixelToR[pixel]; - *d++ = FX_PixelToG[pixel]; - *d++ = FX_PixelToB[pixel]; + *d++ = FX_rgb_scale_5[(pixel >> 11) & 0x1f]; + *d++ = FX_rgb_scale_6[(pixel >> 5) & 0x3f]; + *d++ = FX_rgb_scale_5[ pixel & 0x1f]; *d++ = 255; } dst += dstStride; @@ -572,107 +859,825 @@ fxDDReadPixels(GLcontext * ctx, GLint x, GLint y, } } - - static void -fxDDFinish(GLcontext * ctx) +fxDDReadPixels555 (GLcontext * ctx, + GLint x, GLint y, + GLsizei width, GLsizei height, + GLenum format, GLenum type, + const struct gl_pixelstore_attrib *packing, + GLvoid *dstImage) { - FX_grFlush(); -} - - - + if (ctx->_ImageTransferState/* & (IMAGE_SCALE_BIAS_BIT|IMAGE_MAP_COLOR_BIT)*/) { + _swrast_ReadPixels(ctx, x, y, width, height, format, type, + packing, dstImage); + return; + } + else { + fxMesaContext fxMesa = FX_CONTEXT(ctx); + GrLfbInfo_t info; + BEGIN_BOARD_LOCK(); + info.size = sizeof(info); + if (grLfbLock(GR_LFB_READ_ONLY, + fxMesa->currentFB, + GR_LFBWRITEMODE_ANY, + GR_ORIGIN_UPPER_LEFT, FXFALSE, &info)) { + const GLint winX = 0; + const GLint winY = fxMesa->height - 1; + const GLint srcStride = info.strideInBytes / 2; /* stride in GLushorts */ + const GLushort *src = (const GLushort *) info.lfbPtr + + (winY - y) * srcStride + (winX + x); + GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, dstImage, + width, height, format, + type, 0, 0); + GLint dstStride = + _mesa_image_row_stride(packing, width, format, type); -/* KW: Put the word Mesa in the render string because quakeworld - * checks for this rather than doing a glGet(GL_MAX_TEXTURE_SIZE). - * Why? - */ -static const GLubyte * -fxDDGetString(GLcontext * ctx, GLenum name) -{ - switch (name) { - case GL_RENDERER: - { - static char buf[80]; - - if (glbHWConfig.SSTs[glbCurrentBoard].type == GR_SSTTYPE_VOODOO) { - GrVoodooConfig_t *vc = - &glbHWConfig.SSTs[glbCurrentBoard].sstBoard.VoodooConfig; - - sprintf(buf, - "Mesa Glide v0.30 Voodoo_Graphics %d " - "CARD/%d FB/%d TM/%d TMU/%s", - glbCurrentBoard, - (vc->sliDetect ? (vc->fbRam * 2) : vc->fbRam), - (vc->tmuConfig[GR_TMU0].tmuRam + - ((vc->nTexelfx > 1) ? vc->tmuConfig[GR_TMU1]. - tmuRam : 0)), vc->nTexelfx, - (vc->sliDetect ? "SLI" : "NOSLI")); + if (format == GL_RGB && type == GL_UNSIGNED_BYTE) { + /* convert 5R5G5B into 8R8G8B */ + GLint row, col; + const GLint halfWidth = width >> 1; + const GLint extraPixel = (width & 1); + for (row = 0; row < height; row++) { + GLubyte *d = dst; + for (col = 0; col < halfWidth; col++) { + const GLuint pixel = ((const GLuint *) src)[col]; + *d++ = FX_rgb_scale_5[(pixel >> 10) & 0x1f]; + *d++ = FX_rgb_scale_5[(pixel >> 5) & 0x1f]; + *d++ = FX_rgb_scale_5[ pixel & 0x1f]; + *d++ = FX_rgb_scale_5[(pixel >> 26) & 0x1f]; + *d++ = FX_rgb_scale_5[(pixel >> 21) & 0x1f]; + *d++ = FX_rgb_scale_5[(pixel >> 16) & 0x1f]; + } + if (extraPixel) { + GLushort pixel = src[width - 1]; + *d++ = FX_rgb_scale_5[(pixel >> 10) & 0x1f]; + *d++ = FX_rgb_scale_5[(pixel >> 5) & 0x1f]; + *d++ = FX_rgb_scale_5[ pixel & 0x1f]; + } + dst += dstStride; + src -= srcStride; + } + } + else if (format == GL_RGBA && type == GL_UNSIGNED_BYTE) { + /* convert 5R6G5B into 8R8G8B8A */ + GLint row, col; + const GLint halfWidth = width >> 1; + const GLint extraPixel = (width & 1); + for (row = 0; row < height; row++) { + GLubyte *d = dst; + for (col = 0; col < halfWidth; col++) { + const GLuint pixel = ((const GLuint *) src)[col]; + *d++ = FX_rgb_scale_5[(pixel >> 10) & 0x1f]; + *d++ = FX_rgb_scale_5[(pixel >> 5) & 0x1f]; + *d++ = FX_rgb_scale_5[ pixel & 0x1f]; + *d++ = (pixel & 0x8000) ? 255 : 0; + *d++ = FX_rgb_scale_5[(pixel >> 26) & 0x1f]; + *d++ = FX_rgb_scale_5[(pixel >> 21) & 0x1f]; + *d++ = FX_rgb_scale_5[(pixel >> 16) & 0x1f]; + *d++ = (pixel & 0x80000000) ? 255 : 0; + } + if (extraPixel) { + const GLushort pixel = src[width - 1]; + *d++ = FX_rgb_scale_5[(pixel >> 10) & 0x1f]; + *d++ = FX_rgb_scale_5[(pixel >> 5) & 0x1f]; + *d++ = FX_rgb_scale_5[ pixel & 0x1f]; + *d++ = (pixel & 0x8000) ? 255 : 0; + } + dst += dstStride; + src -= srcStride; + } } - else if (glbHWConfig.SSTs[glbCurrentBoard].type == GR_SSTTYPE_SST96) { - GrSst96Config_t *sc = - &glbHWConfig.SSTs[glbCurrentBoard].sstBoard.SST96Config; - - sprintf(buf, - "Glide v0.30 Voodoo_Rush %d " - "CARD/%d FB/%d TM/%d TMU/NOSLI", - glbCurrentBoard, - sc->fbRam, sc->tmuConfig.tmuRam, sc->nTexelfx); + else if (format == GL_BGRA && type == GL_UNSIGNED_SHORT_1_5_5_5_REV) { + /* directly memcpy 5R5G5B pixels into client's buffer */ + const GLint widthInBytes = width * 2; + GLint row; + for (row = 0; row < height; row++) { + MEMCPY(dst, src, widthInBytes); + dst += dstStride; + src -= srcStride; + } } else { - strcpy(buf, "Glide v0.30 UNKNOWN"); + grLfbUnlock(GR_LFB_READ_ONLY, fxMesa->currentFB); + END_BOARD_LOCK(); + _swrast_ReadPixels(ctx, x, y, width, height, format, type, + packing, dstImage); + return; } - return (GLubyte *) buf; + + grLfbUnlock(GR_LFB_READ_ONLY, fxMesa->currentFB); } - default: - return NULL; + END_BOARD_LOCK(); } } -static const struct gl_pipeline_stage *fx_pipeline[] = { - &_tnl_vertex_transform_stage, /* TODO: Add the fastpath here */ - &_tnl_normal_transform_stage, - &_tnl_lighting_stage, - &_tnl_fog_coordinate_stage, /* TODO: Omit fog stage */ - &_tnl_texgen_stage, - &_tnl_texture_transform_stage, - &_tnl_point_attenuation_stage, - &_tnl_render_stage, - 0, -}; +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/* & (IMAGE_SCALE_BIAS_BIT|IMAGE_MAP_COLOR_BIT)*/) { + _swrast_ReadPixels(ctx, x, y, width, height, format, type, + packing, dstImage); + return; + } + else { + fxMesaContext fxMesa = FX_CONTEXT(ctx); + GrLfbInfo_t info; + + BEGIN_BOARD_LOCK(); + info.size = sizeof(info); + if (grLfbLock(GR_LFB_READ_ONLY, + fxMesa->currentFB, + GR_LFBWRITEMODE_ANY, + GR_ORIGIN_UPPER_LEFT, FXFALSE, &info)) { + const GLint winX = 0; + const GLint winY = fxMesa->height - 1; + const GLint srcStride = info.strideInBytes / 4; /* stride in GLuints */ + const GLuint *src = (const GLuint *) info.lfbPtr + + (winY - y) * srcStride + (winX + x); + GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, dstImage, + width, height, format, + type, 0, 0); + GLint dstStride = + _mesa_image_row_stride(packing, width, format, type); + if (format == GL_RGB && type == GL_UNSIGNED_BYTE) { + /* convert 8A8R8G8B into 8R8G8B */ + GLint row, col; + for (row = 0; row < height; row++) { + GLubyte *d = dst; + for (col = 0; col < width; col++) { + const GLuint pixel = ((const GLuint *) src)[col]; + *d++ = pixel >> 16; + *d++ = pixel >> 8; + *d++ = pixel; + } + dst += dstStride; + src -= srcStride; + } + } + else if (format == GL_RGBA && type == GL_UNSIGNED_BYTE) { + /* 8A8R8G8B pixels into client's buffer */ + GLint row, col; + for (row = 0; row < height; row++) { + 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 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); + END_BOARD_LOCK(); + _swrast_ReadPixels(ctx, x, y, width, height, format, type, + packing, dstImage); + return; + } + grLfbUnlock(GR_LFB_READ_ONLY, fxMesa->currentFB); + } + END_BOARD_LOCK(); + } +} -int -fxDDInitFxMesaContext(fxMesaContext fxMesa) +static void +fxDDDrawPixels555 (GLcontext * ctx, GLint x, GLint y, + GLsizei width, GLsizei height, + GLenum format, GLenum type, + const struct gl_pixelstore_attrib *unpack, + const GLvoid * pixels) { - int i; + fxMesaContext fxMesa = FX_CONTEXT(ctx); + SWcontext *swrast = SWRAST_CONTEXT(ctx); + GrLfbInfo_t info; + const struct gl_pixelstore_attrib *finalUnpack; + struct gl_pixelstore_attrib scissoredUnpack; - for (i = 0; i < 256; i++) { - gl_ubyte_to_float_255_color_tab[i] = (float) i; + if (ctx->Pixel.ZoomX != 1.0F || + ctx->Pixel.ZoomY != 1.0F || + (ctx->_ImageTransferState & (IMAGE_SCALE_BIAS_BIT| + IMAGE_MAP_COLOR_BIT)) || + (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 | + MULTI_DRAW_BIT | + OCCLUSION_BIT | /* nope! at least not yet */ + TEXTURE_BIT | + FRAGPROG_BIT)) || + fxMesa->fallback) + { + _swrast_DrawPixels( ctx, x, y, width, height, format, type, + unpack, pixels ); + return; } - FX_setupGrVertexLayout(); + /* make sure the pixelpipe is configured correctly */ + fxSetupFXUnits(ctx); + + /* FIXME! _RasterMask & CLIP_BIT gets set if we're out of Viewport, also! */ + 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 (x < ctx->Scissor.X) { + scissoredUnpack.SkipPixels += (ctx->Scissor.X - x); + width -= (ctx->Scissor.X - x); + x = ctx->Scissor.X; + } + /* clip right */ + if (x + width >= ctx->Scissor.X + ctx->Scissor.Width) { + width -= (x + width - (ctx->Scissor.X + ctx->Scissor.Width)); + } + /* clip bottom */ + if (y < ctx->Scissor.Y) { + scissoredUnpack.SkipRows += (ctx->Scissor.Y - y); + height -= (ctx->Scissor.Y - y); + y = ctx->Scissor.Y; + } + /* clip top */ + if (y + height >= ctx->Scissor.Y + ctx->Scissor.Height) { + height -= (y + height - (ctx->Scissor.Y + ctx->Scissor.Height)); + } + + if (width <= 0 || height <= 0) + return; + } + else { + finalUnpack = unpack; + } + + info.size = sizeof(info); + if (!grLfbLock(GR_LFB_WRITE_ONLY, + fxMesa->currentFB, + GR_LFBWRITEMODE_1555, + GR_ORIGIN_LOWER_LEFT, FXTRUE, &info)) { + _swrast_DrawPixels(ctx, x, y, width, height, format, type, finalUnpack, pixels); + return; + } + + { + const GLint winX = 0; + const GLint winY = 0; + + const GLint dstStride = info.strideInBytes / 2; /* stride in GLushorts */ + GLushort *dst = (GLushort *) info.lfbPtr + (winY + y) * dstStride + (winX + x); + + if (format == GL_RGBA && type == GL_UNSIGNED_BYTE) { + GLint row; + for (row = 0; row < height; row++) { + GLubyte *src = (GLubyte *) _mesa_image_address2d(finalUnpack, + pixels, width, height, format, type, row, 0); + GLint col; + for (col = 0; col < width; col++) { + dst[col] = TDFXPACKCOLOR1555(src[2], src[1], src[0], src[3]); + src += 4; + } + dst += dstStride; + } + } + else if (format == GL_RGB && type == GL_UNSIGNED_BYTE) { + GLint row; + for (row = 0; row < height; row++) { + GLubyte *src = (GLubyte *) _mesa_image_address2d(finalUnpack, + pixels, width, height, format, type, row, 0); + GLint col; + for (col = 0; col < width; col++) { + dst[col] = TDFXPACKCOLOR1555(src[2], src[1], src[0], 255); + src += 3; + } + dst += dstStride; + } + } + else { + grLfbUnlock(GR_LFB_WRITE_ONLY, fxMesa->currentFB); + _swrast_DrawPixels(ctx, x, y, width, height, format, type, finalUnpack, pixels); + return; + } + + } + + grLfbUnlock(GR_LFB_WRITE_ONLY, fxMesa->currentFB); +} + + +static void +fxDDDrawPixels565 (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); + SWcontext *swrast = SWRAST_CONTEXT(ctx); + GrLfbInfo_t info; + const struct gl_pixelstore_attrib *finalUnpack; + struct gl_pixelstore_attrib scissoredUnpack; + + if (ctx->Pixel.ZoomX != 1.0F || + ctx->Pixel.ZoomY != 1.0F || + (ctx->_ImageTransferState & (IMAGE_SCALE_BIAS_BIT| + IMAGE_MAP_COLOR_BIT)) || + (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 | + MULTI_DRAW_BIT | + OCCLUSION_BIT | /* nope! at least not yet */ + TEXTURE_BIT | + FRAGPROG_BIT)) || + fxMesa->fallback) + { + _swrast_DrawPixels( ctx, x, y, width, height, format, type, + unpack, pixels ); + return; + } + + /* make sure the pixelpipe is configured correctly */ + fxSetupFXUnits(ctx); + + /* FIXME! _RasterMask & CLIP_BIT gets set if we're out of Viewport, also! */ + 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 (x < ctx->Scissor.X) { + scissoredUnpack.SkipPixels += (ctx->Scissor.X - x); + width -= (ctx->Scissor.X - x); + x = ctx->Scissor.X; + } + /* clip right */ + if (x + width >= ctx->Scissor.X + ctx->Scissor.Width) { + width -= (x + width - (ctx->Scissor.X + ctx->Scissor.Width)); + } + /* clip bottom */ + if (y < ctx->Scissor.Y) { + scissoredUnpack.SkipRows += (ctx->Scissor.Y - y); + height -= (ctx->Scissor.Y - y); + y = ctx->Scissor.Y; + } + /* clip top */ + if (y + height >= ctx->Scissor.Y + ctx->Scissor.Height) { + height -= (y + height - (ctx->Scissor.Y + ctx->Scissor.Height)); + } + + if (width <= 0 || height <= 0) + return; + } + else { + finalUnpack = unpack; + } + + info.size = sizeof(info); + if (!grLfbLock(GR_LFB_WRITE_ONLY, + fxMesa->currentFB, + GR_LFBWRITEMODE_565, + GR_ORIGIN_LOWER_LEFT, FXTRUE, &info)) { + _swrast_DrawPixels(ctx, x, y, width, height, format, type, finalUnpack, pixels); + return; + } + + { + const GLint winX = 0; + const GLint winY = 0; + + const GLint dstStride = info.strideInBytes / 2; /* stride in GLushorts */ + GLushort *dst = (GLushort *) info.lfbPtr + (winY + y) * dstStride + (winX + x); + + if (format == GL_RGBA && type == GL_UNSIGNED_BYTE) { + GLint row; + for (row = 0; row < height; row++) { + GLubyte *src = (GLubyte *) _mesa_image_address2d(finalUnpack, + pixels, width, height, format, type, row, 0); + GLint col; + for (col = 0; col < width; col++) { + dst[col] = TDFXPACKCOLOR565(src[2], src[1], src[0]); + src += 4; + } + dst += dstStride; + } + } + else if (format == GL_RGB && type == GL_UNSIGNED_BYTE) { + GLint row; + for (row = 0; row < height; row++) { + GLubyte *src = (GLubyte *) _mesa_image_address2d(finalUnpack, + pixels, width, height, format, type, row, 0); + GLint col; + for (col = 0; col < width; col++) { + dst[col] = TDFXPACKCOLOR565(src[2], src[1], src[0]); + src += 3; + } + dst += dstStride; + } + } + else { + grLfbUnlock(GR_LFB_WRITE_ONLY, fxMesa->currentFB); + _swrast_DrawPixels(ctx, x, y, width, height, format, type, finalUnpack, pixels); + return; + } + + } + + grLfbUnlock(GR_LFB_WRITE_ONLY, fxMesa->currentFB); +} + + +static void +fxDDDrawPixels565_rev (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); + SWcontext *swrast = SWRAST_CONTEXT(ctx); + GrLfbInfo_t info; + const struct gl_pixelstore_attrib *finalUnpack; + struct gl_pixelstore_attrib scissoredUnpack; + + if (ctx->Pixel.ZoomX != 1.0F || + ctx->Pixel.ZoomY != 1.0F || + (ctx->_ImageTransferState & (IMAGE_SCALE_BIAS_BIT| + IMAGE_MAP_COLOR_BIT)) || + (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 | + MULTI_DRAW_BIT | + OCCLUSION_BIT | /* nope! at least not yet */ + TEXTURE_BIT | + FRAGPROG_BIT)) || + fxMesa->fallback) + { + _swrast_DrawPixels( ctx, x, y, width, height, format, type, + unpack, pixels ); + return; + } + + /* make sure the pixelpipe is configured correctly */ + fxSetupFXUnits(ctx); + + /* FIXME! _RasterMask & CLIP_BIT gets set if we're out of Viewport, also! */ + 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 (x < ctx->Scissor.X) { + scissoredUnpack.SkipPixels += (ctx->Scissor.X - x); + width -= (ctx->Scissor.X - x); + x = ctx->Scissor.X; + } + /* clip right */ + if (x + width >= ctx->Scissor.X + ctx->Scissor.Width) { + width -= (x + width - (ctx->Scissor.X + ctx->Scissor.Width)); + } + /* clip bottom */ + if (y < ctx->Scissor.Y) { + scissoredUnpack.SkipRows += (ctx->Scissor.Y - y); + height -= (ctx->Scissor.Y - y); + y = ctx->Scissor.Y; + } + /* clip top */ + if (y + height >= ctx->Scissor.Y + ctx->Scissor.Height) { + height -= (y + height - (ctx->Scissor.Y + ctx->Scissor.Height)); + } + + if (width <= 0 || height <= 0) + return; + } + else { + finalUnpack = unpack; + } + + info.size = sizeof(info); + if (!grLfbLock(GR_LFB_WRITE_ONLY, + fxMesa->currentFB, + GR_LFBWRITEMODE_565, + GR_ORIGIN_LOWER_LEFT, FXTRUE, &info)) { + _swrast_DrawPixels(ctx, x, y, width, height, format, type, finalUnpack, pixels); + return; + } + + { + const GLint winX = 0; + const GLint winY = 0; + + const GLint dstStride = info.strideInBytes / 2; /* stride in GLushorts */ + GLushort *dst = (GLushort *) info.lfbPtr + (winY + y) * dstStride + (winX + x); + + if (format == GL_RGBA && type == GL_UNSIGNED_BYTE) { + GLint row; + for (row = 0; row < height; row++) { + GLubyte *src = (GLubyte *) _mesa_image_address2d(finalUnpack, + pixels, width, height, format, type, row, 0); + GLint col; + for (col = 0; col < width; col++) { + dst[col] = TDFXPACKCOLOR565(src[0], src[1], src[2]); + src += 4; + } + dst += dstStride; + } + } + else if (format == GL_RGB && type == GL_UNSIGNED_BYTE) { + GLint row; + for (row = 0; row < height; row++) { + GLubyte *src = (GLubyte *) _mesa_image_address2d(finalUnpack, + pixels, width, height, format, type, row, 0); + GLint col; + for (col = 0; col < width; col++) { + dst[col] = TDFXPACKCOLOR565(src[0], src[1], src[2]); + src += 3; + } + dst += dstStride; + } + } + else { + grLfbUnlock(GR_LFB_WRITE_ONLY, fxMesa->currentFB); + _swrast_DrawPixels(ctx, x, y, width, height, format, type, finalUnpack, pixels); + return; + } + + } + + grLfbUnlock(GR_LFB_WRITE_ONLY, fxMesa->currentFB); +} + + +static 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); + SWcontext *swrast = SWRAST_CONTEXT(ctx); + GrLfbInfo_t info; + const struct gl_pixelstore_attrib *finalUnpack; + struct gl_pixelstore_attrib scissoredUnpack; + + if (ctx->Pixel.ZoomX != 1.0F || + ctx->Pixel.ZoomY != 1.0F || + (ctx->_ImageTransferState & (IMAGE_SCALE_BIAS_BIT| + IMAGE_MAP_COLOR_BIT)) || + (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 */ + MULTI_DRAW_BIT | + OCCLUSION_BIT | /* nope! at least not yet */ + TEXTURE_BIT | + FRAGPROG_BIT)) || + fxMesa->fallback) + { + _swrast_DrawPixels( ctx, x, y, width, height, format, type, + unpack, pixels ); + return; + } + + /* make sure the pixelpipe is configured correctly */ + fxSetupFXUnits(ctx); + + /* FIXME! _RasterMask & CLIP_BIT gets set if we're out of Viewport, also! */ + 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 (x < ctx->Scissor.X) { + scissoredUnpack.SkipPixels += (ctx->Scissor.X - x); + width -= (ctx->Scissor.X - x); + x = ctx->Scissor.X; + } + /* clip right */ + if (x + width >= ctx->Scissor.X + ctx->Scissor.Width) { + width -= (x + width - (ctx->Scissor.X + ctx->Scissor.Width)); + } + /* clip bottom */ + if (y < ctx->Scissor.Y) { + scissoredUnpack.SkipRows += (ctx->Scissor.Y - y); + height -= (ctx->Scissor.Y - y); + y = ctx->Scissor.Y; + } + /* clip top */ + if (y + height >= ctx->Scissor.Y + ctx->Scissor.Height) { + height -= (y + height - (ctx->Scissor.Y + ctx->Scissor.Height)); + } + + if (width <= 0 || height <= 0) + return; + } + else { + finalUnpack = unpack; + } + + info.size = sizeof(info); + if (!grLfbLock(GR_LFB_WRITE_ONLY, + fxMesa->currentFB, + GR_LFBWRITEMODE_8888, + GR_ORIGIN_LOWER_LEFT, FXTRUE, &info)) { + _swrast_DrawPixels(ctx, x, y, width, height, format, type, finalUnpack, pixels); + return; + } + + { + const GLint winX = 0; + const GLint winY = 0; + + const GLint dstStride = info.strideInBytes / 4; /* stride in GLuints */ + GLuint *dst = (GLuint *) info.lfbPtr + (winY + y) * dstStride + (winX + x); + + 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++) { + GLubyte *src = (GLubyte *) _mesa_image_address2d(finalUnpack, + pixels, width, height, format, type, row, 0); + MEMCPY(dst, src, widthInBytes); + dst += dstStride; + } + } + else if (format == GL_RGB && type == GL_UNSIGNED_BYTE) { + GLint row; + for (row = 0; row < height; row++) { + GLubyte *src = (GLubyte *) _mesa_image_address2d(finalUnpack, + pixels, width, height, format, type, row, 0); + GLint col; + for (col = 0; col < width; col++) { + dst[col] = TDFXPACKCOLOR8888(src[2], src[1], src[0], 255); + src += 3; + } + dst += dstStride; + } + } + else { + grLfbUnlock(GR_LFB_WRITE_ONLY, fxMesa->currentFB); + _swrast_DrawPixels(ctx, x, y, width, height, format, type, finalUnpack, pixels); + return; + } + + } + + grLfbUnlock(GR_LFB_WRITE_ONLY, fxMesa->currentFB); +} + + +static void +fxDDFinish(GLcontext * ctx) +{ + grFlush(); +} + + + + + +/* KW: Put the word Mesa in the render string because quakeworld + * checks for this rather than doing a glGet(GL_MAX_TEXTURE_SIZE). + * Why? + */ +static const GLubyte * +fxDDGetString(GLcontext * ctx, GLenum name) +{ + fxMesaContext fxMesa = FX_CONTEXT(ctx); + + switch (name) { + case GL_RENDERER: + return (GLubyte *)fxMesa->rendererString; +#if __WIN32__ /* hack to advertise vanilla extension names */ + case GL_EXTENSIONS: + if (ctx->Extensions.String == NULL) { + GLubyte *ext = _mesa_make_extension_string(ctx); + if (ext != NULL) { + ctx->Extensions.String = _mesa_malloc(strlen((char *)ext) + 256); + if (ctx->Extensions.String != NULL) { + strcpy((char *)ctx->Extensions.String, (char *)ext); + /* put any additional extension names here */ +#if 0 + strcat((char *)ctx->Extensions.String, " 3DFX_set_global_palette"); +#endif +#if __WIN32__ + strcat((char *)ctx->Extensions.String, " WGL_3DFX_gamma_control"); + strcat((char *)ctx->Extensions.String, " WGL_EXT_swap_control"); + strcat((char *)ctx->Extensions.String, " WGL_EXT_extensions_string WGL_ARB_extensions_string"); +#endif + /* put any additional extension names here */ + _mesa_free(ext); + } else { + ctx->Extensions.String = ext; + } + } + } + return ctx->Extensions.String; +#endif + default: + return NULL; + } +} + +static const struct tnl_pipeline_stage *fx_pipeline[] = { + &_tnl_vertex_transform_stage, /* XXX todo - Add the fastpath here */ + &_tnl_normal_transform_stage, + &_tnl_lighting_stage, + &_tnl_fog_coordinate_stage, + &_tnl_texgen_stage, + &_tnl_texture_transform_stage, + &_tnl_point_attenuation_stage, +#if defined(FEATURE_NV_vertex_program) || defined(FEATURE_ARB_vertex_program) + &_tnl_vertex_program_stage, +#endif + &_tnl_render_stage, + 0, +}; - if (getenv("FX_EMULATE_SINGLE_TMU")) - fxMesa->haveTwoTMUs = GL_FALSE; - if (getenv("FX_GLIDE_SWAPINTERVAL")) - fxMesa->swapInterval = atoi(getenv("FX_GLIDE_SWAPINTERVAL")); - else - fxMesa->swapInterval = 1; - if (getenv("MESA_FX_SWAP_PENDING")) - fxMesa->maxPendingSwapBuffers = atoi(getenv("MESA_FX_SWAP_PENDING")); - else - fxMesa->maxPendingSwapBuffers = 2; - if (getenv("MESA_FX_INFO")) - fxMesa->verbose = GL_TRUE; - else - fxMesa->verbose = GL_FALSE; +int +fxDDInitFxMesaContext(fxMesaContext fxMesa) +{ + GLcontext *ctx = fxMesa->glCtx; + + FX_setupGrVertexLayout(); fxMesa->color = 0xffffffff; fxMesa->clearC = 0; @@ -690,81 +1695,125 @@ fxDDInitFxMesaContext(fxMesaContext fxMesa) /* FX units setup */ fxMesa->unitsState.alphaTestEnabled = GL_FALSE; - fxMesa->unitsState.alphaTestFunc = GR_CMP_ALWAYS; - fxMesa->unitsState.alphaTestRefValue = 0; + fxMesa->unitsState.alphaTestFunc = GL_ALWAYS; + fxMesa->unitsState.alphaTestRefValue = 0.0; fxMesa->unitsState.blendEnabled = GL_FALSE; fxMesa->unitsState.blendSrcFuncRGB = GR_BLEND_ONE; fxMesa->unitsState.blendDstFuncRGB = GR_BLEND_ZERO; fxMesa->unitsState.blendSrcFuncAlpha = GR_BLEND_ONE; fxMesa->unitsState.blendDstFuncAlpha = GR_BLEND_ZERO; + fxMesa->unitsState.blendEqRGB = GR_BLEND_OP_ADD; + fxMesa->unitsState.blendEqAlpha = GR_BLEND_OP_ADD; fxMesa->unitsState.depthTestEnabled = GL_FALSE; fxMesa->unitsState.depthMask = GL_TRUE; - fxMesa->unitsState.depthTestFunc = GR_CMP_LESS; + fxMesa->unitsState.depthTestFunc = GL_LESS; + fxMesa->unitsState.depthBias = 0; - FX_grColorMask(FXTRUE, fxMesa->haveAlphaBuffer ? FXTRUE : FXFALSE); - if (fxMesa->haveDoubleBuffer) { - fxMesa->currentFB = GR_BUFFER_BACKBUFFER; - FX_grRenderBuffer(GR_BUFFER_BACKBUFFER); - } - else { - fxMesa->currentFB = GR_BUFFER_FRONTBUFFER; - FX_grRenderBuffer(GR_BUFFER_FRONTBUFFER); + fxMesa->unitsState.stencilWriteMask = 0xff; + + if (fxMesa->colDepth == 32) { + /* 32bpp */ + fxMesa->Glide.grColorMaskExt(FXTRUE, FXTRUE, FXTRUE, fxMesa->haveHwAlpha); + } else { + /* 15/16 bpp mode */ + grColorMask(FXTRUE, fxMesa->haveHwAlpha); } - fxMesa->state = malloc(FX_grGetInteger(FX_GLIDE_STATE_SIZE)); - fxMesa->fogTable = malloc(FX_grGetInteger(FX_FOG_TABLE_ENTRIES) * + fxMesa->currentFB = fxMesa->haveDoubleBuffer ? GR_BUFFER_BACKBUFFER : GR_BUFFER_FRONTBUFFER; + grRenderBuffer(fxMesa->currentFB); + + fxMesa->state = MALLOC(FX_grGetInteger(GR_GLIDE_STATE_SIZE)); + fxMesa->fogTable = (GrFog_t *) MALLOC(FX_grGetInteger(GR_FOG_TABLE_ENTRIES) * sizeof(GrFog_t)); if (!fxMesa->state || !fxMesa->fogTable) { if (fxMesa->state) - free(fxMesa->state); + FREE(fxMesa->state); if (fxMesa->fogTable) - free(fxMesa->fogTable); + FREE(fxMesa->fogTable); return 0; } - if (fxMesa->haveZBuffer) - FX_grDepthBufferMode(GR_DEPTHBUFFER_ZBUFFER); + if (fxMesa->haveZBuffer) { + grDepthBufferMode(GR_DEPTHBUFFER_ZBUFFER); + } -#ifndef FXMESA_USE_ARGB - FX_grLfbWriteColorFormat(GR_COLORFORMAT_ABGR); /* Not every Glide has this */ + if (!fxMesa->bgrOrder) { + grLfbWriteColorFormat(GR_COLORFORMAT_ABGR); + } + + if (fxMesa->Glide.grSetNumPendingBuffers != NULL) { + fxMesa->Glide.grSetNumPendingBuffers(fxMesa->maxPendingSwapBuffers); + } + + fxMesa->textureAlign = FX_grGetInteger(GR_TEXTURE_ALIGN); + /* [koolsmoky] */ + { + char *env; + int textureLevels = 0; + int textureSize = FX_grGetInteger(GR_MAX_TEXTURE_SIZE); + do { + textureLevels++; + } while ((textureSize >>= 0x1) & 0x7ff); + ctx->Const.MaxTextureLevels = textureLevels; + ctx->Const.MaxTextureLodBias = /*textureLevels - 1*/8; /* Glide bug */ +#if FX_RESCALE_BIG_TEXURES_HACK + fxMesa->textureMaxLod = textureLevels - 1; + if ((env = getenv("MESA_FX_MAXLOD")) != NULL) { + int maxLevels = atoi(env) + 1; + if ((maxLevels <= MAX_TEXTURE_LEVELS) && (maxLevels > textureLevels)) { + ctx->Const.MaxTextureLevels = maxLevels; + } + } #endif + } + ctx->Const.MaxTextureCoordUnits = + ctx->Const.MaxTextureImageUnits = fxMesa->haveTwoTMUs ? 2 : 1; + ctx->Const.MaxTextureUnits = MAX2(ctx->Const.MaxTextureImageUnits, ctx->Const.MaxTextureCoordUnits); - fxMesa->textureAlign = FX_grGetInteger(FX_TEXTURE_ALIGN); - fxMesa->glCtx->Const.MaxTextureLevels = 9; - fxMesa->glCtx->Const.MaxTextureUnits = fxMesa->haveTwoTMUs ? 2 : 1; fxMesa->new_state = _NEW_ALL; + if (!fxMesa->haveHwStencil) { + /* don't touch stencil if there is none */ + fxMesa->new_state &= ~FX_NEW_STENCIL; + } /* Initialize the software rasterizer and helper modules. */ - _swrast_CreateContext(fxMesa->glCtx); - _ac_CreateContext(fxMesa->glCtx); - _tnl_CreateContext(fxMesa->glCtx); - _swsetup_CreateContext(fxMesa->glCtx); + _swrast_CreateContext(ctx); + _vbo_CreateContext(ctx); + _tnl_CreateContext(ctx); + _swsetup_CreateContext(ctx); - _tnl_destroy_pipeline(fxMesa->glCtx); - _tnl_install_pipeline(fxMesa->glCtx, fx_pipeline); + /* Install customized pipeline */ + _tnl_destroy_pipeline(ctx); + _tnl_install_pipeline(ctx, fx_pipeline); - fxAllocVB(fxMesa->glCtx); + fxAllocVB(ctx); - fxSetupDDPointers(fxMesa->glCtx); - fxDDInitTriFuncs(fxMesa->glCtx); + fxSetupDDPointers(ctx); + fxDDInitTriFuncs(ctx); /* Tell the software rasterizer to use pixel fog always. */ - _swrast_allow_vertex_fog(fxMesa->glCtx, GL_FALSE); - _swrast_allow_pixel_fog(fxMesa->glCtx, GL_TRUE); + _swrast_allow_vertex_fog(ctx, GL_FALSE); + _swrast_allow_pixel_fog(ctx, GL_TRUE); + _tnl_allow_vertex_fog( ctx, GL_FALSE ); + _tnl_allow_pixel_fog( ctx, GL_TRUE ); /* Tell tnl not to calculate or use vertex fog factors. (Needed to * tell render stage not to clip fog coords). */ -/* _tnl_calculate_vertex_fog( fxMesa->glCtx, GL_FALSE ); */ +/* _tnl_calculate_vertex_fog( ctx, GL_FALSE ); */ - fxDDInitExtensions(fxMesa->glCtx); + fxDDInitExtensions(ctx); - FX_grGlideGetState((GrState *) fxMesa->state); +#if 0 + /* do we want dither? It just looks bad... */ + grEnable(GR_ALLOW_MIPMAP_DITHER); +#endif + grGlideGetState((GrState *) fxMesa->state); return 1; } @@ -776,14 +1825,13 @@ fxDDDestroyFxMesaContext(fxMesaContext fxMesa) { _swsetup_DestroyContext(fxMesa->glCtx); _tnl_DestroyContext(fxMesa->glCtx); - _ac_DestroyContext(fxMesa->glCtx); + _vbo_DestroyContext(fxMesa->glCtx); _swrast_DestroyContext(fxMesa->glCtx); if (fxMesa->state) - free(fxMesa->state); + FREE(fxMesa->state); if (fxMesa->fogTable) - free(fxMesa->fogTable); - fxTMClose(fxMesa); + FREE(fxMesa->fogTable); fxFreeVB(fxMesa->glCtx); } @@ -793,19 +1841,96 @@ fxDDDestroyFxMesaContext(fxMesaContext fxMesa) void fxDDInitExtensions(GLcontext * ctx) { - fxMesaContext fxMesa = (fxMesaContext) ctx->DriverCtx; + fxMesaContext fxMesa = FX_CONTEXT(ctx); + +#if 1 /* multipass ColorSum stage */ + _mesa_enable_extension(ctx, "GL_EXT_secondary_color"); +#endif - _mesa_add_extension(ctx, GL_TRUE, "3DFX_set_global_palette", 0); + _mesa_enable_extension(ctx, "GL_ARB_point_sprite"); _mesa_enable_extension(ctx, "GL_EXT_point_parameters"); _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"); + _mesa_enable_extension(ctx, "GL_EXT_texture_env_add"); + _mesa_enable_extension(ctx, "GL_EXT_stencil_wrap"); + _mesa_enable_extension(ctx, "GL_EXT_stencil_two_side"); - if (fxMesa->haveTwoTMUs) - _mesa_enable_extension(ctx, "GL_EXT_texture_env_add"); - - if (fxMesa->haveTwoTMUs) + if (fxMesa->haveTwoTMUs) { _mesa_enable_extension(ctx, "GL_ARB_multitexture"); + } + + if (fxMesa->type >= GR_SSTTYPE_Voodoo4) { + _mesa_enable_extension(ctx, "GL_ARB_texture_compression"); + _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"); + _mesa_enable_extension(ctx, "GL_NV_blend_square"); + } else { + /* [dBorca] + * We should enable generic texture compression functions, + * but some poorly written apps automatically assume S3TC. + * Binding NCC to GL_COMPRESSED_RGB[A] is an unnecessary hassle, + * since it's slow and ugly (better with palette textures, then). + * Moreover, NCC is not an OpenGL standard, so we can't use + * precompressed textures. Last, but not least, NCC runs amok + * when multitexturing on a Voodoo3 and up (see POINTCAST vs UMA). + * Note: this is also a problem with palette textures, but + * faking multitex by multipass is evil... + * Implementing NCC requires three stages: + * fxDDChooseTextureFormat: + * bind GL_COMPRESSED_RGB[A] to _mesa_texformat_argb8888, + * so we can quantize properly, at a later time + * fxDDTexImage: + * if GL_COMPRESSED_RGB + * use _mesa_texformat_l8 to get 1bpt and set GR_TEXFMT_YIQ_422 + * if GL_COMPRESSED_RGBA + * use _mesa_texformat_al88 to get 2bpt and set GR_TEXFMT_AYIQ_8422 + * txMipQuantize(...); + * if (level == 0) { + * txPalToNcc((GuNccTable *)(&(ti->palette)), pxMip.pal); + * } + * fxSetupSingleTMU_NoLock/fxSetupDoubleTMU_NoLock: + * grTexDownloadTable(GR_TEXTABLE_NCC0, &(ti->palette)); + */ + /*_mesa_enable_extension(ctx, "GL_ARB_texture_compression");*/ + _mesa_enable_extension(ctx, "GL_SGIS_generate_mipmap"); + } + + if (fxMesa->HaveCmbExt) { + _mesa_enable_extension(ctx, "GL_ARB_texture_env_combine"); + _mesa_enable_extension(ctx, "GL_EXT_texture_env_combine"); + } + + if (fxMesa->HavePixExt) { + _mesa_enable_extension(ctx, "GL_EXT_blend_subtract"); + _mesa_enable_extension(ctx, "GL_EXT_blend_equation_separate"); + } + + if (fxMesa->HaveMirExt) { + _mesa_enable_extension(ctx, "GL_ARB_texture_mirrored_repeat"); + } + + if (fxMesa->type >= GR_SSTTYPE_Voodoo2) { + _mesa_enable_extension(ctx, "GL_EXT_fog_coord"); + } + + /* core-level extensions */ + _mesa_enable_extension(ctx, "GL_EXT_multi_draw_arrays"); + _mesa_enable_extension(ctx, "GL_IBM_multimode_draw_arrays"); + _mesa_enable_extension(ctx, "GL_ARB_vertex_buffer_object"); + /* dangerous */ + if (getenv("MESA_FX_ALLOW_VP")) { + _mesa_enable_extension(ctx, "GL_ARB_vertex_program"); + _mesa_enable_extension(ctx, "GL_NV_vertex_program"); + _mesa_enable_extension(ctx, "GL_NV_vertex_program1_1"); + _mesa_enable_extension(ctx, "GL_MESA_program_debug"); + } +#if 0 + /* this requires _tnl_vertex_cull_stage in the pipeline */ + _mesa_enable_extension(ctx, "EXT_cull_vertex"); +#endif } @@ -817,165 +1942,169 @@ fxDDInitExtensions(GLcontext * ctx) * * Performs similar work to fxDDChooseRenderState() - should be merged. */ -GLboolean +GLuint fx_check_IsInHardware(GLcontext * ctx) { - fxMesaContext fxMesa = (fxMesaContext) ctx->DriverCtx; - - if (ctx->RenderMode != GL_RENDER) - return GL_FALSE; - - if (ctx->Stencil.Enabled || - ctx->Color.MultiDrawBuffer || - ((ctx->Color.BlendEnabled) - && (ctx->Color.BlendEquation != GL_FUNC_ADD_EXT)) - || ((ctx->Color.ColorLogicOpEnabled) - && (ctx->Color.LogicOp != GL_COPY)) - || (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR) - || - (!((ctx-> - Color.ColorMask[RCOMP] == ctx->Color.ColorMask[GCOMP]) - && (ctx->Color.ColorMask[GCOMP] == ctx->Color.ColorMask[BCOMP]) - && (ctx->Color.ColorMask[ACOMP] == ctx->Color.ColorMask[ACOMP]))) - ) { - return GL_FALSE; + fxMesaContext fxMesa = FX_CONTEXT(ctx); + + if (ctx->RenderMode != GL_RENDER) { + return FX_FALLBACK_RENDER_MODE; + } + + if (ctx->Stencil.Enabled && !fxMesa->haveHwStencil) { + return FX_FALLBACK_STENCIL; + } + + if ((ctx->DrawBuffer->_ColorDrawBufferIndexes[0] != BUFFER_BIT_FRONT_LEFT) && + (ctx->DrawBuffer->_ColorDrawBufferIndexes[0] != BUFFER_BIT_BACK_LEFT)) { + return FX_FALLBACK_DRAW_BUFFER; + } + + if (ctx->Color.BlendEnabled) { + if (ctx->Color.BlendEquationRGB != GL_FUNC_ADD) { + if (!fxMesa->HavePixExt || + ((ctx->Color.BlendEquationRGB != GL_FUNC_SUBTRACT) && + (ctx->Color.BlendEquationRGB != GL_FUNC_REVERSE_SUBTRACT))) { + return FX_FALLBACK_BLEND; + } + } + + if (ctx->Color.BlendEquationA != GL_FUNC_ADD) { + if (!fxMesa->HavePixExt || + ((ctx->Color.BlendEquationA != GL_FUNC_SUBTRACT) && + (ctx->Color.BlendEquationA != GL_FUNC_REVERSE_SUBTRACT))) { + return FX_FALLBACK_BLEND; + } + } + +#if 0 + /* [dBorca] + * We fail the spec here, unless certain blending modes: + * RGB: (GL_ONE + GL_*) or (GL_ZERO + GL_*) or ... + */ + if (NEED_SECONDARY_COLOR(ctx)) { + if ((ctx->Color.BlendEquationRGB != GL_FUNC_ADD) && + (ctx->Color.BlendSrcRGB != GL_ONE)) { + /* Can't use multipass to blend ColorSum stage */ + return FX_FALLBACK_SPECULAR; + } + } +#endif } + + /* [dBorca] + * We could avoid this for certain `sfactor/dfactor' + * I do not think that is even worthwhile to check + * because if someone is using blending they use more + * interesting settings and also it would add more + * state tracking to a lot of the code. + */ + if (ctx->Color.ColorLogicOpEnabled && (ctx->Color.LogicOp != GL_COPY)) { + return FX_FALLBACK_LOGICOP; + } + + if ((fxMesa->colDepth != 32) && + ((ctx->Color.ColorMask[RCOMP] != ctx->Color.ColorMask[GCOMP]) || + (ctx->Color.ColorMask[GCOMP] != ctx->Color.ColorMask[BCOMP]))) { + return FX_FALLBACK_COLORMASK; + } + /* Unsupported texture/multitexture cases */ + /* we can only do 1D/2D textures */ + if (ctx->Texture.Unit[0]._ReallyEnabled & ~(TEXTURE_1D_BIT|TEXTURE_2D_BIT)) + return FX_FALLBACK_TEXTURE_MAP; + if (fxMesa->haveTwoTMUs) { - if (ctx->Texture._ReallyEnabled & (TEXTURE0_3D | TEXTURE1_3D)) - return GL_FALSE; /* can't do 3D textures */ - if (ctx->Texture._ReallyEnabled & (TEXTURE0_1D | TEXTURE1_1D)) - return GL_FALSE; /* can't do 1D textures */ + if (ctx->Texture.Unit[1]._ReallyEnabled & ~(TEXTURE_1D_BIT|TEXTURE_2D_BIT)) + return FX_FALLBACK_TEXTURE_MAP; - if (ctx->Texture._ReallyEnabled & TEXTURE0_2D) { + if (ctx->Texture.Unit[0]._ReallyEnabled) { + if (fxMesa->type < GR_SSTTYPE_Voodoo2) if (ctx->Texture.Unit[0].EnvMode == GL_BLEND && - (ctx->Texture._ReallyEnabled & TEXTURE1_2D || + (ctx->Texture.Unit[1]._ReallyEnabled || ctx->Texture.Unit[0].EnvColor[0] != 0 || ctx->Texture.Unit[0].EnvColor[1] != 0 || ctx->Texture.Unit[0].EnvColor[2] != 0 || ctx->Texture.Unit[0].EnvColor[3] != 1)) { - return GL_FALSE; + return FX_FALLBACK_TEXTURE_ENV; } - if (ctx->Texture.Unit[0]._Current->Image[0]->Border > 0) - return GL_FALSE; + if (ctx->Texture.Unit[0]._Current->Image[0][0]->Border > 0) + return FX_FALLBACK_TEXTURE_BORDER; } - if (ctx->Texture._ReallyEnabled & TEXTURE1_2D) { + if (ctx->Texture.Unit[1]._ReallyEnabled) { + if (fxMesa->type < GR_SSTTYPE_Voodoo2) if (ctx->Texture.Unit[1].EnvMode == GL_BLEND) - return GL_FALSE; - if (ctx->Texture.Unit[1]._Current->Image[0]->Border > 0) - return GL_FALSE; + return FX_FALLBACK_TEXTURE_ENV; + if (ctx->Texture.Unit[1]._Current->Image[0][0]->Border > 0) + return FX_FALLBACK_TEXTURE_BORDER; } - if (MESA_VERBOSE & (VERBOSE_DRIVER | VERBOSE_TEXTURE)) - fprintf(stderr, "fxMesa: fxIsInHardware, envmode is %s/%s\n", + if (TDFX_DEBUG & (VERBOSE_DRIVER | VERBOSE_TEXTURE)) + fprintf(stderr, "fx_check_IsInHardware: envmode is %s/%s\n", _mesa_lookup_enum_by_nr(ctx->Texture.Unit[0].EnvMode), _mesa_lookup_enum_by_nr(ctx->Texture.Unit[1].EnvMode)); /* KW: This was wrong (I think) and I changed it... which doesn't mean * it is now correct... + * BP: The old condition just seemed to test if both texture units + * were enabled. That's easy! */ - if ((ctx->Texture._ReallyEnabled & (TEXTURE0_1D | TEXTURE0_2D | TEXTURE0_3D)) && - (ctx->Texture._ReallyEnabled & (TEXTURE1_1D | TEXTURE1_2D | TEXTURE1_3D))) { + if (ctx->Texture._EnabledUnits == 0x3) { +#if 0 /* Can't use multipass to blend a multitextured triangle - fall * back to software. */ if (!fxMesa->haveTwoTMUs && ctx->Color.BlendEnabled) { - return GL_FALSE; + return FX_FALLBACK_TEXTURE_MULTI; } +#endif - if ((ctx->Texture.Unit[0].EnvMode != ctx->Texture.Unit[1].EnvMode) && + if (!fxMesa->HaveCmbExt && + (ctx->Texture.Unit[0].EnvMode != ctx->Texture.Unit[1].EnvMode) && (ctx->Texture.Unit[0].EnvMode != GL_MODULATE) && (ctx->Texture.Unit[0].EnvMode != GL_REPLACE)) { /* q2, seems ok... */ - if (MESA_VERBOSE & VERBOSE_DRIVER) - fprintf(stderr, "fxMesa: unsupported multitex env mode\n"); - return GL_FALSE; + if (TDFX_DEBUG & VERBOSE_DRIVER) + fprintf(stderr, "fx_check_IsInHardware: unsupported multitex env mode\n"); + return FX_FALLBACK_TEXTURE_MULTI; } } } else { - if ((ctx->Texture._ReallyEnabled & (TEXTURE1_1D | TEXTURE1_2D | TEXTURE1_3D)) || - /* Not very well written ... */ - ((ctx->Texture._ReallyEnabled & TEXTURE0_1D) && - (!(ctx->Texture._ReallyEnabled & TEXTURE0_2D))) - ) { - return GL_FALSE; + /* we have just one texture unit */ + if (ctx->Texture._EnabledUnits > 0x1) { + return FX_FALLBACK_TEXTURE_MULTI; } - - if ((ctx->Texture._ReallyEnabled & TEXTURE0_2D) && + if (fxMesa->type < GR_SSTTYPE_Voodoo2) + if (ctx->Texture.Unit[0]._ReallyEnabled && (ctx->Texture.Unit[0].EnvMode == GL_BLEND)) { - return GL_FALSE; + return FX_FALLBACK_TEXTURE_ENV; } } - return GL_TRUE; + return 0; } static void -update_texture_scales(GLcontext * ctx) +fxDDUpdateDDPointers(GLcontext * ctx, GLuint new_state) { + /* TNLcontext *tnl = TNL_CONTEXT(ctx); */ fxMesaContext fxMesa = FX_CONTEXT(ctx); - struct gl_texture_unit *t0 = &ctx->Texture.Unit[fxMesa->tmu_source[0]]; - struct gl_texture_unit *t1 = &ctx->Texture.Unit[fxMesa->tmu_source[1]]; - if (t0 && t0->_Current && FX_TEXTURE_DATA(t0)) { - fxMesa->s0scale = FX_TEXTURE_DATA(t0)->sScale; - fxMesa->t0scale = FX_TEXTURE_DATA(t0)->tScale; - fxMesa->inv_s0scale = 1.0 / fxMesa->s0scale; - fxMesa->inv_t0scale = 1.0 / fxMesa->t0scale; + if (TDFX_DEBUG & VERBOSE_DRIVER) { + fprintf(stderr, "fxDDUpdateDDPointers(%08x)\n", new_state); } - if (t1 && t1->_Current && FX_TEXTURE_DATA(t1)) { - fxMesa->s1scale = FX_TEXTURE_DATA(t1)->sScale; - fxMesa->t1scale = FX_TEXTURE_DATA(t1)->tScale; - fxMesa->inv_s1scale = 1.0 / fxMesa->s1scale; - fxMesa->inv_t1scale = 1.0 / fxMesa->t1scale; - } -} - -static void -fxDDUpdateDDPointers(GLcontext * ctx, GLuint new_state) -{ - /* TNLcontext *tnl = TNL_CONTEXT(ctx);*/ - fxMesaContext fxMesa = FX_CONTEXT(ctx); - _swrast_InvalidateState(ctx, new_state); - _ac_InvalidateState(ctx, new_state); + _vbo_InvalidateState(ctx, new_state); _tnl_InvalidateState(ctx, new_state); _swsetup_InvalidateState(ctx, new_state); - /* Recalculate fog table on projection matrix changes. This used to - * be triggered by the NearFar callback. - */ - if (new_state & _NEW_PROJECTION) - fxMesa->new_state |= FX_NEW_FOG; - - if (new_state & (_FX_NEW_IS_IN_HARDWARE | - _FX_NEW_RENDERSTATE | - _FX_NEW_SETUP_FUNCTION | - _NEW_TEXTURE)) { - - if (new_state & _FX_NEW_IS_IN_HARDWARE) - fxCheckIsInHardware(ctx); - - if (fxMesa->new_state) - fxSetupFXUnits(ctx); - - if (fxMesa->is_in_hardware) { - if (new_state & _FX_NEW_RENDERSTATE) - fxDDChooseRenderState(ctx); - - if (new_state & _FX_NEW_SETUP_FUNCTION) - fxChooseVertexState(ctx); - } - - if (new_state & _NEW_TEXTURE) - update_texture_scales(ctx); - } + fxMesa->new_gl_state |= new_state; } @@ -984,10 +2113,11 @@ fxDDUpdateDDPointers(GLcontext * ctx, GLuint new_state) void fxSetupDDPointers(GLcontext * ctx) { - TNLcontext *tnl = TNL_CONTEXT(ctx); + fxMesaContext fxMesa = FX_CONTEXT(ctx); + /* TNLcontext *tnl = TNL_CONTEXT(ctx); */ - if (MESA_VERBOSE & VERBOSE_DRIVER) { - fprintf(stderr, "fxmesa: fxSetupDDPointers()\n"); + if (TDFX_DEBUG & VERBOSE_DRIVER) { + fprintf(stderr, "fxSetupDDPointers()\n"); } ctx->Driver.UpdateState = fxDDUpdateDDPointers; @@ -995,40 +2125,45 @@ fxSetupDDPointers(GLcontext * ctx) ctx->Driver.ClearIndex = NULL; ctx->Driver.ClearColor = fxDDClearColor; ctx->Driver.Clear = fxDDClear; - ctx->Driver.SetDrawBuffer = fxDDSetDrawBuffer; - ctx->Driver.GetBufferSize = fxDDBufferSize; - ctx->Driver.Accum = _swrast_Accum; - ctx->Driver.Bitmap = fxDDDrawBitmap; - ctx->Driver.CopyPixels = _swrast_CopyPixels; - ctx->Driver.DrawPixels = _swrast_DrawPixels; - ctx->Driver.ReadPixels = fxDDReadPixels; - ctx->Driver.ResizeBuffers = _swrast_alloc_buffers; + ctx->Driver.DrawBuffer = fxDDSetDrawBuffer; + ctx->Driver.GetBufferSize = fxDDGetBufferSize; + ctx->Driver.Viewport = fxDDViewport; + switch (fxMesa->colDepth) { + case 15: + ctx->Driver.DrawPixels = fxDDDrawPixels555; + ctx->Driver.ReadPixels = fxDDReadPixels555; + ctx->Driver.Bitmap = fxDDDrawBitmap2; + break; + case 16: + ctx->Driver.DrawPixels = !fxMesa->bgrOrder ? fxDDDrawPixels565 : fxDDDrawPixels565_rev; + ctx->Driver.ReadPixels = fxDDReadPixels565; + ctx->Driver.Bitmap = fxDDDrawBitmap2; + break; + case 32: + ctx->Driver.DrawPixels = fxDDDrawPixels8888; + ctx->Driver.ReadPixels = fxDDReadPixels8888; + ctx->Driver.Bitmap = fxDDDrawBitmap4; + break; + } ctx->Driver.Finish = fxDDFinish; ctx->Driver.Flush = NULL; ctx->Driver.ChooseTextureFormat = fxDDChooseTextureFormat; - ctx->Driver.TexImage1D = _mesa_store_teximage1d; + ctx->Driver.TexImage1D = fxDDTexImage1D; ctx->Driver.TexImage2D = fxDDTexImage2D; - ctx->Driver.TexImage3D = _mesa_store_teximage3d; - ctx->Driver.TexSubImage1D = _mesa_store_texsubimage1d; + ctx->Driver.TexSubImage1D = fxDDTexSubImage1D; ctx->Driver.TexSubImage2D = fxDDTexSubImage2D; - ctx->Driver.TexSubImage3D = _mesa_store_texsubimage3d; - ctx->Driver.CopyTexImage1D = _swrast_copy_teximage1d; - ctx->Driver.CopyTexImage2D = _swrast_copy_teximage2d; - ctx->Driver.CopyTexSubImage1D = _swrast_copy_texsubimage1d; - ctx->Driver.CopyTexSubImage2D = _swrast_copy_texsubimage2d; - ctx->Driver.CopyTexSubImage3D = _swrast_copy_texsubimage3d; - ctx->Driver.TestProxyTexImage = _mesa_test_proxy_teximage; - ctx->Driver.CopyColorTable = _swrast_CopyColorTable; - ctx->Driver.CopyColorSubTable = _swrast_CopyColorSubTable; - ctx->Driver.CopyConvolutionFilter1D = _swrast_CopyConvolutionFilter1D; - ctx->Driver.CopyConvolutionFilter2D = _swrast_CopyConvolutionFilter2D; + ctx->Driver.CompressedTexImage2D = fxDDCompressedTexImage2D; + ctx->Driver.CompressedTexSubImage2D = fxDDCompressedTexSubImage2D; + ctx->Driver.TestProxyTexImage = fxDDTestProxyTexImage; ctx->Driver.TexEnv = fxDDTexEnv; ctx->Driver.TexParameter = fxDDTexParam; ctx->Driver.BindTexture = fxDDTexBind; ctx->Driver.DeleteTexture = fxDDTexDel; + ctx->Driver.IsTextureResident = fxDDIsTextureResident; ctx->Driver.UpdateTexturePalette = fxDDTexPalette; ctx->Driver.AlphaFunc = fxDDAlphaFunc; - ctx->Driver.BlendFunc = fxDDBlendFunc; + ctx->Driver.BlendFuncSeparate = fxDDBlendFuncSeparate; + ctx->Driver.BlendEquationSeparate = fxDDBlendEquationSeparate; ctx->Driver.DepthFunc = fxDDDepthFunc; ctx->Driver.DepthMask = fxDDDepthMask; ctx->Driver.ColorMask = fxDDColorMask; @@ -1038,8 +2173,11 @@ fxSetupDDPointers(GLcontext * ctx) ctx->Driver.CullFace = fxDDCullFace; ctx->Driver.ShadeModel = fxDDShadeModel; ctx->Driver.Enable = fxDDEnable; - - tnl->Driver.RunPipeline = _tnl_run_pipeline; + if (fxMesa->haveHwStencil) { + ctx->Driver.StencilFuncSeparate = fxDDStencilFuncSeparate; + ctx->Driver.StencilMaskSeparate = fxDDStencilMaskSeparate; + ctx->Driver.StencilOpSeparate = fxDDStencilOpSeparate; + } fxSetupDDSpanPointers(ctx); fxDDUpdateDDPointers(ctx, ~0);