From 9bf68ad963ba92b5d1e725f965979042495a5313 Mon Sep 17 00:00:00 2001 From: Brian Paul Date: Mon, 14 May 2001 16:23:04 +0000 Subject: New triangle rasterization code. Store per-span initial/step values in the new triangle_span struct. Much cleaner code and possibilities for future optimizations. --- src/mesa/swrast/s_tritemp.h | 567 +++++++++++++++++++++++--------------------- 1 file changed, 299 insertions(+), 268 deletions(-) (limited to 'src/mesa/swrast/s_tritemp.h') diff --git a/src/mesa/swrast/s_tritemp.h b/src/mesa/swrast/s_tritemp.h index 3bdb1537a0..09e1223506 100644 --- a/src/mesa/swrast/s_tritemp.h +++ b/src/mesa/swrast/s_tritemp.h @@ -1,4 +1,4 @@ -/* $Id: s_tritemp.h,v 1.15 2001/05/03 22:13:32 brianp Exp $ */ +/* $Id: s_tritemp.h,v 1.16 2001/05/14 16:23:04 brianp Exp $ */ /* * Mesa 3-D graphics library @@ -43,9 +43,7 @@ * INTERP_TEX - if defined, interpolate set 0 float STRQ texcoords * NOTE: OpenGL STRQ = Mesa STUV (R was taken for red) * INTERP_MULTITEX - if defined, interpolate N units of STRQ texcoords - * INTERP_LAMBDA - if defined, the lambda value is computed at every - * pixel, to apply MIPMAPPING, and min/maxification - * INTERP_MULTILAMBDA - like above but for multitexturing, i.e. + * INTERP_LAMBDA - if defined, compute lambda value (for mipmapping) * a lambda value for every texture unit * * When one can directly address pixels in the color buffer the following @@ -64,20 +62,13 @@ * SETUP_CODE - code which is to be executed once per triangle * * The following macro MUST be defined: - * INNER_LOOP(LEFT,RIGHT,Y) - code to write a span of pixels. - * Something like: - * - * for (x=LEFT; x_backface_sign; GLboolean tiny; + struct triangle_span span; + +#ifdef INTERP_Z + (void) fixedToDepthShift; +#endif + /* find the order of the 3 vertices along the Y axis */ { GLfloat y0 = v0->win[1]; @@ -253,58 +250,47 @@ { GLint ltor; /* true if scanning left-to-right */ #ifdef INTERP_Z - GLfloat dzdx, dzdy; GLfixed fdzdx; + GLfloat dzdx, dzdy; #endif #ifdef INTERP_FOG - GLfloat dfogdx, dfogdy; + GLfloat dfogdy; #endif #ifdef INTERP_RGB - GLfloat drdx, drdy; GLfixed fdrdx; - GLfloat dgdx, dgdy; GLfixed fdgdx; - GLfloat dbdx, dbdy; GLfixed fdbdx; -#endif -#ifdef INTERP_SPEC - GLfloat dsrdx, dsrdy; GLfixed fdsrdx; - GLfloat dsgdx, dsgdy; GLfixed fdsgdx; - GLfloat dsbdx, dsbdy; GLfixed fdsbdx; + GLfloat drdx, drdy; + GLfloat dgdx, dgdy; + GLfloat dbdx, dbdy; #endif #ifdef INTERP_ALPHA - GLfloat dadx, dady; GLfixed fdadx; + GLfloat dadx, dady; +#endif +#ifdef INTERP_SPEC + GLfloat dsrdx, dsrdy; + GLfloat dsgdx, dsgdy; + GLfloat dsbdx, dsbdy; #endif #ifdef INTERP_INDEX - GLfloat didx, didy; GLfixed fdidx; + GLfloat didx, didy; #endif #ifdef INTERP_INT_TEX - GLfloat dsdx, dsdy; GLfixed fdsdx; - GLfloat dtdx, dtdy; GLfixed fdtdx; -#endif -#ifdef INTERP_TEX GLfloat dsdx, dsdy; GLfloat dtdx, dtdy; - GLfloat dudx, dudy; - GLfloat dvdx, dvdy; +#endif +#ifdef INTERP_TEX + GLfloat dsdy; + GLfloat dtdy; + GLfloat dudy; + GLfloat dvdy; #endif #ifdef INTERP_MULTITEX - GLfloat dsdx[MAX_TEXTURE_UNITS], dsdy[MAX_TEXTURE_UNITS]; - GLfloat dtdx[MAX_TEXTURE_UNITS], dtdy[MAX_TEXTURE_UNITS]; - GLfloat dudx[MAX_TEXTURE_UNITS], dudy[MAX_TEXTURE_UNITS]; - GLfloat dvdx[MAX_TEXTURE_UNITS], dvdy[MAX_TEXTURE_UNITS]; + GLfloat dsdy[MAX_TEXTURE_UNITS]; + GLfloat dtdy[MAX_TEXTURE_UNITS]; + GLfloat dudy[MAX_TEXTURE_UNITS]; + GLfloat dvdy[MAX_TEXTURE_UNITS]; #endif -#ifdef INTERP_LAMBDA -#ifndef INTERP_TEX +#if defined(INTERP_LAMBDA) && !defined(INTERP_TEX) && !defined(INTERP_MULTITEX) #error "Mipmapping without texturing doesn't make sense." #endif - GLfloat lambda_nominator; -#endif /* INTERP_LAMBDA */ - -#ifdef INTERP_MULTILAMBDA -#ifndef INTERP_MULTITEX -#error "Multi-Mipmapping without multi-texturing doesn't make sense." -#endif - GLfloat lambda_nominator[MAX_TEXTURE_UNITS]; -#endif /* INTERP_MULTILAMBDA */ - /* * Execute user-supplied setup code @@ -315,8 +301,11 @@ ltor = (oneOverArea < 0.0F); + span.activeMask = 0; + /* compute d?/dx and d?/dy derivatives */ #ifdef INTERP_Z + span.activeMask |= SPAN_Z; { GLfloat eMaj_dz, eBot_dz; eMaj_dz = vMax->win[2] - vMin->win[2]; @@ -331,28 +320,30 @@ dzdy = oneOverArea * (eMaj.dx * eBot_dz - eMaj_dz * eBot.dx); } if (depthBits <= 16) - fdzdx = SignedFloatToFixed(dzdx); + span.zStep = SignedFloatToFixed(dzdx); else - fdzdx = (GLint) dzdx; + span.zStep = (GLint) dzdx; } #endif #ifdef INTERP_FOG + span.activeMask |= SPAN_FOG; { const GLfloat eMaj_dfog = vMax->fog - vMin->fog; const GLfloat eBot_dfog = vMid->fog - vMin->fog; - dfogdx = oneOverArea * (eMaj_dfog * eBot.dy - eMaj.dy * eBot_dfog); + span.fogStep = oneOverArea * (eMaj_dfog * eBot.dy - eMaj.dy * eBot_dfog); dfogdy = oneOverArea * (eMaj.dx * eBot_dfog - eMaj_dfog * eBot.dx); } #endif #ifdef INTERP_RGB + span.activeMask |= SPAN_RGBA; if (tiny) { /* This is kind of a hack to eliminate RGB color over/underflow * problems when rendering very tiny triangles. We're not doing * anything with alpha or specular color at this time. */ - drdx = drdy = 0.0; fdrdx = 0; - dgdx = dgdy = 0.0; fdgdx = 0; - dbdx = dbdy = 0.0; fdbdx = 0; + drdx = drdy = 0.0; span.redStep = 0; + dgdx = dgdy = 0.0; span.greenStep = 0; + dbdx = dbdy = 0.0; span.blueStep = 0; } else { GLfloat eMaj_dr, eBot_dr; @@ -361,27 +352,38 @@ eMaj_dr = (GLint) vMax->color[0] - (GLint) vMin->color[0]; eBot_dr = (GLint) vMid->color[0] - (GLint) vMin->color[0]; drdx = oneOverArea * (eMaj_dr * eBot.dy - eMaj.dy * eBot_dr); - fdrdx = SignedFloatToFixed(drdx); + span.redStep = SignedFloatToFixed(drdx); drdy = oneOverArea * (eMaj.dx * eBot_dr - eMaj_dr * eBot.dx); eMaj_dg = (GLint) vMax->color[1] - (GLint) vMin->color[1]; eBot_dg = (GLint) vMid->color[1] - (GLint) vMin->color[1]; dgdx = oneOverArea * (eMaj_dg * eBot.dy - eMaj.dy * eBot_dg); - fdgdx = SignedFloatToFixed(dgdx); + span.greenStep = SignedFloatToFixed(dgdx); dgdy = oneOverArea * (eMaj.dx * eBot_dg - eMaj_dg * eBot.dx); eMaj_db = (GLint) vMax->color[2] - (GLint) vMin->color[2]; eBot_db = (GLint) vMid->color[2] - (GLint) vMin->color[2]; dbdx = oneOverArea * (eMaj_db * eBot.dy - eMaj.dy * eBot_db); - fdbdx = SignedFloatToFixed(dbdx); + span.blueStep = SignedFloatToFixed(dbdx); dbdy = oneOverArea * (eMaj.dx * eBot_db - eMaj_db * eBot.dx); } #endif +#ifdef INTERP_ALPHA + { + GLfloat eMaj_da, eBot_da; + eMaj_da = (GLint) vMax->color[3] - (GLint) vMin->color[3]; + eBot_da = (GLint) vMid->color[3] - (GLint) vMin->color[3]; + dadx = oneOverArea * (eMaj_da * eBot.dy - eMaj.dy * eBot_da); + span.alphaStep = SignedFloatToFixed(dadx); + dady = oneOverArea * (eMaj.dx * eBot_da - eMaj_da * eBot.dx); + } +#endif #ifdef INTERP_SPEC + span.activeMask |= SPAN_SPEC; { GLfloat eMaj_dsr, eBot_dsr; eMaj_dsr = (GLint) vMax->specular[0] - (GLint) vMin->specular[0]; eBot_dsr = (GLint) vMid->specular[0] - (GLint) vMin->specular[0]; dsrdx = oneOverArea * (eMaj_dsr * eBot.dy - eMaj.dy * eBot_dsr); - fdsrdx = SignedFloatToFixed(dsrdx); + span.specRedStep = SignedFloatToFixed(dsrdx); dsrdy = oneOverArea * (eMaj.dx * eBot_dsr - eMaj_dsr * eBot.dx); } { @@ -389,7 +391,7 @@ eMaj_dsg = (GLint) vMax->specular[1] - (GLint) vMin->specular[1]; eBot_dsg = (GLint) vMid->specular[1] - (GLint) vMin->specular[1]; dsgdx = oneOverArea * (eMaj_dsg * eBot.dy - eMaj.dy * eBot_dsg); - fdsgdx = SignedFloatToFixed(dsgdx); + span.specGreenStep = SignedFloatToFixed(dsgdx); dsgdy = oneOverArea * (eMaj.dx * eBot_dsg - eMaj_dsg * eBot.dx); } { @@ -397,37 +399,29 @@ eMaj_dsb = (GLint) vMax->specular[2] - (GLint) vMin->specular[2]; eBot_dsb = (GLint) vMid->specular[2] - (GLint) vMin->specular[2]; dsbdx = oneOverArea * (eMaj_dsb * eBot.dy - eMaj.dy * eBot_dsb); - fdsbdx = SignedFloatToFixed(dsbdx); + span.specBlueStep = SignedFloatToFixed(dsbdx); dsbdy = oneOverArea * (eMaj.dx * eBot_dsb - eMaj_dsb * eBot.dx); } #endif -#ifdef INTERP_ALPHA - { - GLfloat eMaj_da, eBot_da; - eMaj_da = (GLint) vMax->color[3] - (GLint) vMin->color[3]; - eBot_da = (GLint) vMid->color[3] - (GLint) vMin->color[3]; - dadx = oneOverArea * (eMaj_da * eBot.dy - eMaj.dy * eBot_da); - fdadx = SignedFloatToFixed(dadx); - dady = oneOverArea * (eMaj.dx * eBot_da - eMaj_da * eBot.dx); - } -#endif #ifdef INTERP_INDEX + span.activeMask |= SPAN_INDEX; { GLfloat eMaj_di, eBot_di; eMaj_di = (GLint) vMax->index - (GLint) vMin->index; eBot_di = (GLint) vMid->index - (GLint) vMin->index; didx = oneOverArea * (eMaj_di * eBot.dy - eMaj.dy * eBot_di); - fdidx = SignedFloatToFixed(didx); + span.indexStep = SignedFloatToFixed(didx); didy = oneOverArea * (eMaj.dx * eBot_di - eMaj_di * eBot.dx); } #endif #ifdef INTERP_INT_TEX + span.activeMask |= SPAN_INT_TEXTURE; { GLfloat eMaj_ds, eBot_ds; eMaj_ds = (vMax->texcoord[0][0] - vMin->texcoord[0][0]) * S_SCALE; eBot_ds = (vMid->texcoord[0][0] - vMin->texcoord[0][0]) * S_SCALE; dsdx = oneOverArea * (eMaj_ds * eBot.dy - eMaj.dy * eBot_ds); - fdsdx = SignedFloatToFixed(dsdx); + span.intTexStep[0] = SignedFloatToFixed(dsdx); dsdy = oneOverArea * (eMaj.dx * eBot_ds - eMaj_ds * eBot.dx); } { @@ -435,12 +429,14 @@ eMaj_dt = (vMax->texcoord[0][1] - vMin->texcoord[0][1]) * T_SCALE; eBot_dt = (vMid->texcoord[0][1] - vMin->texcoord[0][1]) * T_SCALE; dtdx = oneOverArea * (eMaj_dt * eBot.dy - eMaj.dy * eBot_dt); - fdtdx = SignedFloatToFixed(dtdx); + span.intTexStep[1] = SignedFloatToFixed(dtdx); dtdy = oneOverArea * (eMaj.dx * eBot_dt - eMaj_dt * eBot.dx); } #endif + #ifdef INTERP_TEX + span.activeMask |= SPAN_TEXTURE; { GLfloat wMax = vMax->win[3]; GLfloat wMin = vMin->win[3]; @@ -452,26 +448,47 @@ eMaj_ds = vMax->texcoord[0][0] * wMax - vMin->texcoord[0][0] * wMin; eBot_ds = vMid->texcoord[0][0] * wMid - vMin->texcoord[0][0] * wMin; - dsdx = oneOverArea * (eMaj_ds * eBot.dy - eMaj.dy * eBot_ds); + span.texStep[0][0] = oneOverArea * (eMaj_ds * eBot.dy + - eMaj.dy * eBot_ds); dsdy = oneOverArea * (eMaj.dx * eBot_ds - eMaj_ds * eBot.dx); eMaj_dt = vMax->texcoord[0][1] * wMax - vMin->texcoord[0][1] * wMin; eBot_dt = vMid->texcoord[0][1] * wMid - vMin->texcoord[0][1] * wMin; - dtdx = oneOverArea * (eMaj_dt * eBot.dy - eMaj.dy * eBot_dt); + span.texStep[0][1] = oneOverArea * (eMaj_dt * eBot.dy + - eMaj.dy * eBot_dt); dtdy = oneOverArea * (eMaj.dx * eBot_dt - eMaj_dt * eBot.dx); eMaj_du = vMax->texcoord[0][2] * wMax - vMin->texcoord[0][2] * wMin; eBot_du = vMid->texcoord[0][2] * wMid - vMin->texcoord[0][2] * wMin; - dudx = oneOverArea * (eMaj_du * eBot.dy - eMaj.dy * eBot_du); + span.texStep[0][2] = oneOverArea * (eMaj_du * eBot.dy + - eMaj.dy * eBot_du); dudy = oneOverArea * (eMaj.dx * eBot_du - eMaj_du * eBot.dx); eMaj_dv = vMax->texcoord[0][3] * wMax - vMin->texcoord[0][3] * wMin; eBot_dv = vMid->texcoord[0][3] * wMid - vMin->texcoord[0][3] * wMin; - dvdx = oneOverArea * (eMaj_dv * eBot.dy - eMaj.dy * eBot_dv); + span.texStep[0][3] = oneOverArea * (eMaj_dv * eBot.dy + - eMaj.dy * eBot_dv); dvdy = oneOverArea * (eMaj.dx * eBot_dv - eMaj_dv * eBot.dx); } +# ifdef INTERP_LAMBDA + { + GLfloat dudx = span.texStep[0][0] * span.texWidth[0]; + GLfloat dudy = dsdy * span.texWidth[0]; + GLfloat dvdx = span.texStep[0][1] * span.texHeight[0]; + GLfloat dvdy = dtdy * span.texHeight[0]; + GLfloat r1 = dudx * dudx + dudy * dudy; + GLfloat r2 = dvdx * dvdx + dvdy * dvdy; + span.rho[0] = r1 + r2; /* was rho2 = MAX2(r1,r2) */ + span.activeMask |= SPAN_LAMBDA; + } +# endif #endif + #ifdef INTERP_MULTITEX + span.activeMask |= SPAN_TEXTURE; +# ifdef INTERP_LAMBDA + span.activeMask |= SPAN_LAMBDA; +# endif { GLfloat wMax = vMax->win[3]; GLfloat wMin = vMin->win[3]; @@ -487,29 +504,44 @@ - vMin->texcoord[u][0] * wMin; eBot_ds = vMid->texcoord[u][0] * wMid - vMin->texcoord[u][0] * wMin; - dsdx[u] = oneOverArea * (eMaj_ds * eBot.dy - eMaj.dy * eBot_ds); + span.texStep[u][0] = oneOverArea * (eMaj_ds * eBot.dy + - eMaj.dy * eBot_ds); dsdy[u] = oneOverArea * (eMaj.dx * eBot_ds - eMaj_ds * eBot.dx); eMaj_dt = vMax->texcoord[u][1] * wMax - vMin->texcoord[u][1] * wMin; eBot_dt = vMid->texcoord[u][1] * wMid - vMin->texcoord[u][1] * wMin; - dtdx[u] = oneOverArea * (eMaj_dt * eBot.dy - eMaj.dy * eBot_dt); + span.texStep[u][1] = oneOverArea * (eMaj_dt * eBot.dy + - eMaj.dy * eBot_dt); dtdy[u] = oneOverArea * (eMaj.dx * eBot_dt - eMaj_dt * eBot.dx); eMaj_du = vMax->texcoord[u][2] * wMax - vMin->texcoord[u][2] * wMin; eBot_du = vMid->texcoord[u][2] * wMid - vMin->texcoord[u][2] * wMin; - dudx[u] = oneOverArea * (eMaj_du * eBot.dy - eMaj.dy * eBot_du); + span.texStep[u][2] = oneOverArea * (eMaj_du * eBot.dy + - eMaj.dy * eBot_du); dudy[u] = oneOverArea * (eMaj.dx * eBot_du - eMaj_du * eBot.dx); eMaj_dv = vMax->texcoord[u][3] * wMax - vMin->texcoord[u][3] * wMin; eBot_dv = vMid->texcoord[u][3] * wMid - vMin->texcoord[u][3] * wMin; - dvdx[u] = oneOverArea * (eMaj_dv * eBot.dy - eMaj.dy * eBot_dv); + span.texStep[u][3] = oneOverArea * (eMaj_dv * eBot.dy + - eMaj.dy * eBot_dv); dvdy[u] = oneOverArea * (eMaj.dx * eBot_dv - eMaj_dv * eBot.dx); +# ifdef INTERP_LAMBDA + { + GLfloat dudx = span.texStep[u][0] * span.texWidth[u]; + GLfloat dudy = dsdy[u] * span.texWidth[u]; + GLfloat dvdx = span.texStep[u][1] * span.texHeight[u]; + GLfloat dvdy = dtdy[u] * span.texHeight[u]; + GLfloat r1 = dudx * dudx + dudy * dudy; + GLfloat r2 = dvdx * dvdx + dvdy * dvdy; + span.rho[u] = r1 + r2; /* was rho2 = MAX2(r1,r2) */ + } +# endif } } } @@ -565,41 +597,40 @@ { int subTriangle; GLfixed fx; - GLfixed fxLeftEdge=0, fxRightEdge=0, fdxLeftEdge=0, fdxRightEdge=0; + GLfixed fxLeftEdge, fxRightEdge, fdxLeftEdge, fdxRightEdge; GLfixed fdxOuter; int idxOuter; float dxOuter; - GLfixed fError=0, fdError=0; + GLfixed fError, fdError; float adjx, adjy; GLfixed fy; - int iy=0; #ifdef PIXEL_ADDRESS - PIXEL_TYPE *pRow=NULL; - int dPRowOuter=0, dPRowInner=0; /* offset in bytes */ + PIXEL_TYPE *pRow; + int dPRowOuter, dPRowInner; /* offset in bytes */ #endif #ifdef INTERP_Z # ifdef DEPTH_TYPE - DEPTH_TYPE *zRow=NULL; - int dZRowOuter=0, dZRowInner=0; /* offset in bytes */ + DEPTH_TYPE *zRow; + int dZRowOuter, dZRowInner; /* offset in bytes */ # endif - GLfixed fz=0, fdzOuter=0, fdzInner; + GLfixed fz, fdzOuter, fdzInner; #endif #ifdef INTERP_FOG GLfloat fogLeft, dfogOuter, dfogInner; #endif #ifdef INTERP_RGB - GLfixed fr=0, fdrOuter=0, fdrInner; - GLfixed fg=0, fdgOuter=0, fdgInner; - GLfixed fb=0, fdbOuter=0, fdbInner; + GLfixed fr, fdrOuter, fdrInner; + GLfixed fg, fdgOuter, fdgInner; + GLfixed fb, fdbOuter, fdbInner; +#endif +#ifdef INTERP_ALPHA + GLfixed fa=0, fdaOuter=0, fdaInner; #endif #ifdef INTERP_SPEC GLfixed fsr=0, fdsrOuter=0, fdsrInner; GLfixed fsg=0, fdsgOuter=0, fdsgInner; GLfixed fsb=0, fdsbOuter=0, fdsbInner; #endif -#ifdef INTERP_ALPHA - GLfixed fa=0, fdaOuter=0, fdaInner; -#endif #ifdef INTERP_INDEX GLfixed fi=0, fdiOuter=0, fdiInner; #endif @@ -680,7 +711,7 @@ (void) dxOuter; fy = eLeft->fsy; - iy = FixedToInt(fy); + span.y = FixedToInt(fy); adjx = (float)(fx - eLeft->fx0); /* SCALED! */ adjy = eLeft->adjy; /* SCALED! */ @@ -692,7 +723,7 @@ #ifdef PIXEL_ADDRESS { - pRow = PIXEL_ADDRESS( FixedToInt(fxLeftEdge), iy ); + pRow = (PIXEL_TYPE *) PIXEL_ADDRESS(FixedToInt(fxLeftEdge), span.y); dPRowOuter = -((int)BYTES_PER_ROW) + idxOuter * sizeof(PIXEL_TYPE); /* negative because Y=0 at bottom and increases upward */ } @@ -722,19 +753,21 @@ } else { /* interpolate depth values exactly */ - fz = (GLint) (z0 + dzdx*FixedToFloat(adjx) + dzdy*FixedToFloat(adjy)); + fz = (GLint) (z0 + dzdx * FixedToFloat(adjx) + + dzdy * FixedToFloat(adjy)); fdzOuter = (GLint) (dzdy + dxOuter * dzdx); } # ifdef DEPTH_TYPE - zRow = (DEPTH_TYPE *) _mesa_zbuffer_address(ctx, FixedToInt(fxLeftEdge), iy); + zRow = (DEPTH_TYPE *) + _mesa_zbuffer_address(ctx, FixedToInt(fxLeftEdge), span.y); dZRowOuter = (ctx->DrawBuffer->Width + idxOuter) * sizeof(DEPTH_TYPE); # endif } #endif #ifdef INTERP_FOG - fogLeft = vLower->fog + (dfogdx * adjx + dfogdy * adjy) + fogLeft = vLower->fog + (span.fogStep * adjx + dfogdy * adjy) * (1.0F/FIXED_SCALE); - dfogOuter = dfogdy + dxOuter * dfogdx; + dfogOuter = dfogdy + dxOuter * span.fogStep; #endif #ifdef INTERP_RGB fr = (GLfixed)(IntToFixed(vLower->color[0]) @@ -749,6 +782,11 @@ + dbdx * adjx + dbdy * adjy) + FIXED_HALF; fdbOuter = SignedFloatToFixed(dbdy + dxOuter * dbdx); #endif +#ifdef INTERP_ALPHA + fa = (GLfixed)(IntToFixed(vLower->color[3]) + + dadx * adjx + dady * adjy) + FIXED_HALF; + fdaOuter = SignedFloatToFixed(dady + dxOuter * dadx); +#endif #ifdef INTERP_SPEC fsr = (GLfixed)(IntToFixed(vLower->specular[0]) + dsrdx * adjx + dsrdy * adjy) + FIXED_HALF; @@ -762,11 +800,6 @@ + dsbdx * adjx + dsbdy * adjy) + FIXED_HALF; fdsbOuter = SignedFloatToFixed(dsbdy + dxOuter * dsbdx); #endif -#ifdef INTERP_ALPHA - fa = (GLfixed)(IntToFixed(vLower->color[3]) - + dadx * adjx + dady * adjy) + FIXED_HALF; - fdaOuter = SignedFloatToFixed(dady + dxOuter * dadx); -#endif #ifdef INTERP_INDEX fi = (GLfixed)(vLower->index * FIXED_SCALE + didx * adjx + didy * adjy) + FIXED_HALF; @@ -776,11 +809,13 @@ { GLfloat s0, t0; s0 = vLower->texcoord[0][0] * S_SCALE; - fs = (GLfixed)(s0 * FIXED_SCALE + dsdx * adjx + dsdy * adjy) + FIXED_HALF; + fs = (GLfixed)(s0 * FIXED_SCALE + dsdx * adjx + + dsdy * adjy) + FIXED_HALF; fdsOuter = SignedFloatToFixed(dsdy + dxOuter * dsdx); t0 = vLower->texcoord[0][1] * T_SCALE; - ft = (GLfixed)(t0 * FIXED_SCALE + dtdx * adjx + dtdy * adjy) + FIXED_HALF; + ft = (GLfixed)(t0 * FIXED_SCALE + dtdx * adjx + + dtdy * adjy) + FIXED_HALF; fdtOuter = SignedFloatToFixed(dtdy + dxOuter * dtdx); } #endif @@ -789,17 +824,21 @@ GLfloat invW = vLower->win[3]; GLfloat s0, t0, u0, v0; s0 = vLower->texcoord[0][0] * invW; - sLeft = s0 + (dsdx * adjx + dsdy * adjy) * (1.0F/FIXED_SCALE); - dsOuter = dsdy + dxOuter * dsdx; + sLeft = s0 + (span.texStep[0][0] * adjx + dsdy * adjy) + * (1.0F/FIXED_SCALE); + dsOuter = dsdy + dxOuter * span.texStep[0][0]; t0 = vLower->texcoord[0][1] * invW; - tLeft = t0 + (dtdx * adjx + dtdy * adjy) * (1.0F/FIXED_SCALE); - dtOuter = dtdy + dxOuter * dtdx; + tLeft = t0 + (span.texStep[0][1] * adjx + dtdy * adjy) + * (1.0F/FIXED_SCALE); + dtOuter = dtdy + dxOuter * span.texStep[0][1]; u0 = vLower->texcoord[0][2] * invW; - uLeft = u0 + (dudx * adjx + dudy * adjy) * (1.0F/FIXED_SCALE); - duOuter = dudy + dxOuter * dudx; + uLeft = u0 + (span.texStep[0][2] * adjx + dudy * adjy) + * (1.0F/FIXED_SCALE); + duOuter = dudy + dxOuter * span.texStep[0][2]; v0 = vLower->texcoord[0][3] * invW; - vLeft = v0 + (dvdx * adjx + dvdy * adjy) * (1.0F/FIXED_SCALE); - dvOuter = dvdy + dxOuter * dvdx; + vLeft = v0 + (span.texStep[0][3] * adjx + dvdy * adjy) + * (1.0F/FIXED_SCALE); + dvOuter = dvdy + dxOuter * span.texStep[0][3]; } #endif #ifdef INTERP_MULTITEX @@ -810,17 +849,21 @@ GLfloat invW = vLower->win[3]; GLfloat s0, t0, u0, v0; s0 = vLower->texcoord[u][0] * invW; - sLeft[u] = s0 + (dsdx[u] * adjx + dsdy[u] * adjy) * (1.0F/FIXED_SCALE); - dsOuter[u] = dsdy[u] + dxOuter * dsdx[u]; + sLeft[u] = s0 + (span.texStep[u][0] * adjx + dsdy[u] + * adjy) * (1.0F/FIXED_SCALE); + dsOuter[u] = dsdy[u] + dxOuter * span.texStep[u][0]; t0 = vLower->texcoord[u][1] * invW; - tLeft[u] = t0 + (dtdx[u] * adjx + dtdy[u] * adjy) * (1.0F/FIXED_SCALE); - dtOuter[u] = dtdy[u] + dxOuter * dtdx[u]; + tLeft[u] = t0 + (span.texStep[u][1] * adjx + dtdy[u] + * adjy) * (1.0F/FIXED_SCALE); + dtOuter[u] = dtdy[u] + dxOuter * span.texStep[u][1]; u0 = vLower->texcoord[u][2] * invW; - uLeft[u] = u0 + (dudx[u] * adjx + dudy[u] * adjy) * (1.0F/FIXED_SCALE); - duOuter[u] = dudy[u] + dxOuter * dudx[u]; + uLeft[u] = u0 + (span.texStep[u][2] * adjx + dudy[u] + * adjy) * (1.0F/FIXED_SCALE); + duOuter[u] = dudy[u] + dxOuter * span.texStep[u][2]; v0 = vLower->texcoord[u][3] * invW; - vLeft[u] = v0 + (dvdx[u] * adjx + dvdy[u] * adjy) * (1.0F/FIXED_SCALE); - dvOuter[u] = dvdy[u] + dxOuter * dvdx[u]; + vLeft[u] = v0 + (span.texStep[u][3] * adjx + dvdy[u] + * adjy) * (1.0F/FIXED_SCALE); + dvOuter[u] = dvdy[u] + dxOuter * span.texStep[u][3]; } } } @@ -847,93 +890,104 @@ # ifdef DEPTH_TYPE dZRowInner = dZRowOuter + sizeof(DEPTH_TYPE); # endif - fdzInner = fdzOuter + fdzdx; + fdzInner = fdzOuter + span.zStep; #endif #ifdef INTERP_FOG - dfogInner = dfogOuter + dfogdx; + dfogInner = dfogOuter + span.fogStep; #endif #ifdef INTERP_RGB - fdrInner = fdrOuter + fdrdx; - fdgInner = fdgOuter + fdgdx; - fdbInner = fdbOuter + fdbdx; -#endif -#ifdef INTERP_SPEC - fdsrInner = fdsrOuter + fdsrdx; - fdsgInner = fdsgOuter + fdsgdx; - fdsbInner = fdsbOuter + fdsbdx; + fdrInner = fdrOuter + span.redStep; + fdgInner = fdgOuter + span.greenStep; + fdbInner = fdbOuter + span.blueStep; #endif #ifdef INTERP_ALPHA - fdaInner = fdaOuter + fdadx; + fdaInner = fdaOuter + span.alphaStep; +#endif +#ifdef INTERP_SPEC + fdsrInner = fdsrOuter + span.specRedStep; + fdsgInner = fdsgOuter + span.specGreenStep; + fdsbInner = fdsbOuter + span.specBlueStep; #endif #ifdef INTERP_INDEX - fdiInner = fdiOuter + fdidx; + fdiInner = fdiOuter + span.indexStep; #endif #ifdef INTERP_INT_TEX - fdsInner = fdsOuter + fdsdx; - fdtInner = fdtOuter + fdtdx; + fdsInner = fdsOuter + span.intTexStep[0]; + fdtInner = fdtOuter + span.intTexStep[1]; #endif #ifdef INTERP_TEX - dsInner = dsOuter + dsdx; - dtInner = dtOuter + dtdx; - duInner = duOuter + dudx; - dvInner = dvOuter + dvdx; + dsInner = dsOuter + span.texStep[0][0]; + dtInner = dtOuter + span.texStep[0][1]; + duInner = duOuter + span.texStep[0][2]; + dvInner = dvOuter + span.texStep[0][3]; #endif #ifdef INTERP_MULTITEX { GLuint u; for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { if (ctx->Texture.Unit[u]._ReallyEnabled) { - dsInner[u] = dsOuter[u] + dsdx[u]; - dtInner[u] = dtOuter[u] + dtdx[u]; - duInner[u] = duOuter[u] + dudx[u]; - dvInner[u] = dvOuter[u] + dvdx[u]; + dsInner[u] = dsOuter[u] + span.texStep[u][0]; + dtInner[u] = dtOuter[u] + span.texStep[u][1]; + duInner[u] = duOuter[u] + span.texStep[u][2]; + dvInner[u] = dvOuter[u] + span.texStep[u][3]; } } } #endif - while (lines>0) { + while (lines > 0) { /* initialize the span interpolants to the leftmost value */ /* ff = fixed-pt fragment */ - GLint left = FixedToInt(fxLeftEdge); - GLint right = FixedToInt(fxRightEdge); + const GLint right = FixedToInt(fxRightEdge); + span.x = FixedToInt(fxLeftEdge); + if (right <= span.x) + span.count = 0; + else + span.count = right - span.x; + #ifdef INTERP_Z - GLfixed ffz = fz; + span.z = fz; #endif #ifdef INTERP_FOG - GLfloat ffog = fogLeft; + span.fog = fogLeft; #endif #ifdef INTERP_RGB - GLfixed ffr = fr, ffg = fg, ffb = fb; -#endif -#ifdef INTERP_SPEC - GLfixed ffsr = fsr, ffsg = fsg, ffsb = fsb; + span.red = fr; + span.green = fg; + span.blue = fb; #endif #ifdef INTERP_ALPHA - GLfixed ffa = fa; + span.alpha = fa; +#endif +#ifdef INTERP_SPEC + span.specRed = fsr; + span.specGreen = fsg; + span.specBlue = fsb; #endif #ifdef INTERP_INDEX - GLfixed ffi = fi; + span.index = fi; #endif #ifdef INTERP_INT_TEX - GLfixed ffs = fs, fft = ft; + span.intTex[0] = fs; + span.intTex[1] = ft; #endif + #ifdef INTERP_TEX - GLfloat ss = sLeft, tt = tLeft, uu = uLeft, vv = vLeft; + span.tex[0][0] = sLeft; + span.tex[0][1] = tLeft; + span.tex[0][2] = uLeft; + span.tex[0][3] = vLeft; #endif + #ifdef INTERP_MULTITEX - GLfloat ss[MAX_TEXTURE_UNITS]; - GLfloat tt[MAX_TEXTURE_UNITS]; - GLfloat uu[MAX_TEXTURE_UNITS]; - GLfloat vv[MAX_TEXTURE_UNITS]; { GLuint u; for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { if (ctx->Texture.Unit[u]._ReallyEnabled) { - ss[u] = sLeft[u]; - tt[u] = tLeft[u]; - uu[u] = uLeft[u]; - vv[u] = vLeft[u]; + span.tex[u][0] = sLeft[u]; + span.tex[u][1] = tLeft[u]; + span.tex[u][2] = uLeft[u]; + span.tex[u][3] = vLeft[u]; } } } @@ -942,100 +996,70 @@ #ifdef INTERP_RGB { /* need this to accomodate round-off errors */ - GLfixed ffrend = ffr+(right-left-1)*fdrdx; - GLfixed ffgend = ffg+(right-left-1)*fdgdx; - GLfixed ffbend = ffb+(right-left-1)*fdbdx; - if (ffrend<0) ffr -= ffrend; - if (ffgend<0) ffg -= ffgend; - if (ffbend<0) ffb -= ffbend; - if (ffr<0) ffr = 0; - if (ffg<0) ffg = 0; - if (ffb<0) ffb = 0; + const GLint len = right - span.x - 1; + GLfixed ffrend = span.red + len * span.redStep; + GLfixed ffgend = span.green + len * span.greenStep; + GLfixed ffbend = span.blue + len * span.blueStep; + if (ffrend < 0) { + span.red -= ffrend; + if (span.red < 0) + span.red = 0; + } + if (ffgend < 0) { + span.green -= ffgend; + if (span.green < 0) + span.green = 0; + } + if (ffbend < 0) { + span.blue -= ffbend; + if (span.blue < 0) + span.blue = 0; + } } #endif -#ifdef INTERP_SPEC +#ifdef INTERP_ALPHA { - /* need this to accomodate round-off errors */ - GLfixed ffsrend = ffsr+(right-left-1)*fdsrdx; - GLfixed ffsgend = ffsg+(right-left-1)*fdsgdx; - GLfixed ffsbend = ffsb+(right-left-1)*fdsbdx; - if (ffsrend<0) ffsr -= ffsrend; - if (ffsgend<0) ffsg -= ffsgend; - if (ffsbend<0) ffsb -= ffsbend; - if (ffsr<0) ffsr = 0; - if (ffsg<0) ffsg = 0; - if (ffsb<0) ffsb = 0; + const GLint len = right - span.x - 1; + GLfixed ffaend = span.alpha + len * span.alphaStep; + if (ffaend < 0) { + span.alpha -= ffaend; + if (span.alpha < 0) + span.alpha = 0; + } } #endif -#ifdef INTERP_ALPHA +#ifdef INTERP_SPEC { - GLfixed ffaend = ffa+(right-left-1)*fdadx; - if (ffaend<0) ffa -= ffaend; - if (ffa<0) ffa = 0; + /* need this to accomodate round-off errors */ + const GLint len = right - span.x - 1; + GLfixed ffsrend = span.specRed + len * span.specRedStep; + GLfixed ffsgend = span.specGreen + len * span.specGreenStep; + GLfixed ffsbend = span.specBlue + len * span.specBlueStep; + if (ffsrend < 0) { + span.specRed -= ffsrend; + if (span.specRed < 0) + span.specRed = 0; + } + if (ffsgend < 0) { + span.specGreen -= ffsgend; + if (span.specGreen < 0) + span.specGreen = 0; + } + if (ffsbend < 0) { + span.specBlue -= ffsbend; + if (span.specBlue < 0) + span.specBlue = 0; + } } #endif #ifdef INTERP_INDEX - if (ffi<0) ffi = 0; -#endif - -#ifdef INTERP_LAMBDA -/* - * The lambda value is: - * log_2(sqrt(f(n))) = 1/2*log_2(f(n)), where f(n) is a function - * defined by - * f(n):= dudx * dudx + dudy * dudy + dvdx * dvdx + dvdy * dvdy; - * and each of this terms is resp. - * dudx = dsdx * invQ(n) * tex_width; - * dudy = dsdy * invQ(n) * tex_width; - * dvdx = dtdx * invQ(n) * tex_height; - * dvdy = dtdy * invQ(n) * tex_height; - * Therefore the function lambda can be represented (by factoring out) as: - * f(n) = lambda_nominator * invQ(n) * invQ(n), - * which saves some computation time. - */ - { - GLfloat dudx = dsdx /* * invQ*/ * twidth; - GLfloat dudy = dsdy /* * invQ*/ * twidth; - GLfloat dvdx = dtdx /* * invQ*/ * theight; - GLfloat dvdy = dtdy /* * invQ*/ * theight; - GLfloat r1 = dudx * dudx + dudy * dudy; - GLfloat r2 = dvdx * dvdx + dvdy * dvdy; - GLfloat rho2 = r1 + r2; /* was: rho2 = MAX2(r1,r2); */ - lambda_nominator = rho2; - } - - /* set DEST to log_(base 2) of sqrt(rho) */ - /* 1.442695 = 1/log(2) */ -#define COMPUTE_LAMBDA(DEST, X) \ - DEST = log( lambda_nominator * (X)*(X) ) * 1.442695F * 0.5F -#endif - -#ifdef INTERP_MULTILAMBDA -/* - * Read the comment for INTERP_LAMBDA, but apply to each texture unit - */ - { - GLuint unit; - for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { - if (ctx->Texture.Unit[unit]._ReallyEnabled) { - GLfloat dudx = dsdx[unit] /* * invQ*/ * twidth[unit]; - GLfloat dudy = dsdy[unit] /* * invQ*/ * twidth[unit]; - GLfloat dvdx = dtdx[unit] /* * invQ*/ * theight[unit]; - GLfloat dvdy = dtdy[unit] /* * invQ*/ * theight[unit]; - GLfloat r1 = dudx * dudx + dudy * dudy; - GLfloat r2 = dvdx * dvdx + dvdy * dvdy; - GLfloat rho2 = r1 + r2; /* used to be: rho2 = MAX2(r1,r2); */ - lambda_nominator[unit] = rho2; - } - } - } - /* set DEST to log_(base 2) of sqrt(rho) */ -#define COMPUTE_MULTILAMBDA(DEST, X, unit) \ - DEST = log( lambda_nominator[unit] * (X)*(X) ) * 1.442695F * 0.5F + if (span.index < 0) span.index = 0; #endif - - INNER_LOOP( left, right, iy ); + /* This is where we actually generate fragments */ + if (span.count > 0) { + RENDER_SPAN( span ); + } /* * Advance to the next scan line. Compute the @@ -1043,7 +1067,7 @@ * pixel-center x coordinate so that it stays * on or inside the major edge. */ - iy++; + span.y++; lines--; fxLeftEdge += fdxLeftEdge; @@ -1054,11 +1078,11 @@ if (fError >= 0) { fError -= FIXED_ONE; #ifdef PIXEL_ADDRESS - pRow = (PIXEL_TYPE *) ((GLubyte*)pRow + dPRowOuter); + pRow = (PIXEL_TYPE *) ((GLubyte *) pRow + dPRowOuter); #endif #ifdef INTERP_Z # ifdef DEPTH_TYPE - zRow = (DEPTH_TYPE *) ((GLubyte*)zRow + dZRowOuter); + zRow = (DEPTH_TYPE *) ((GLubyte *) zRow + dZRowOuter); # endif fz += fdzOuter; #endif @@ -1066,19 +1090,24 @@ fogLeft += dfogOuter; #endif #ifdef INTERP_RGB - fr += fdrOuter; fg += fdgOuter; fb += fdbOuter; -#endif -#ifdef INTERP_SPEC - fsr += fdsrOuter; fsg += fdsgOuter; fsb += fdsbOuter; + fr += fdrOuter; + fg += fdgOuter; + fb += fdbOuter; #endif #ifdef INTERP_ALPHA fa += fdaOuter; #endif +#ifdef INTERP_SPEC + fsr += fdsrOuter; + fsg += fdsgOuter; + fsb += fdsbOuter; +#endif #ifdef INTERP_INDEX fi += fdiOuter; #endif #ifdef INTERP_INT_TEX - fs += fdsOuter; ft += fdtOuter; + fs += fdsOuter; + ft += fdtOuter; #endif #ifdef INTERP_TEX sLeft += dsOuter; @@ -1102,11 +1131,11 @@ } else { #ifdef PIXEL_ADDRESS - pRow = (PIXEL_TYPE *) ((GLubyte*)pRow + dPRowInner); + pRow = (PIXEL_TYPE *) ((GLubyte *) pRow + dPRowInner); #endif #ifdef INTERP_Z # ifdef DEPTH_TYPE - zRow = (DEPTH_TYPE *) ((GLubyte*)zRow + dZRowInner); + zRow = (DEPTH_TYPE *) ((GLubyte *) zRow + dZRowInner); # endif fz += fdzInner; #endif @@ -1114,19 +1143,24 @@ fogLeft += dfogInner; #endif #ifdef INTERP_RGB - fr += fdrInner; fg += fdgInner; fb += fdbInner; -#endif -#ifdef INTERP_SPEC - fsr += fdsrInner; fsg += fdsgInner; fsb += fdsbInner; + fr += fdrInner; + fg += fdgInner; + fb += fdbInner; #endif #ifdef INTERP_ALPHA fa += fdaInner; #endif +#ifdef INTERP_SPEC + fsr += fdsrInner; + fsg += fdsgInner; + fsb += fdsbInner; +#endif #ifdef INTERP_INDEX fi += fdiInner; #endif #ifdef INTERP_INT_TEX - fs += fdsInner; ft += fdtInner; + fs += fdsInner; + ft += fdtInner; #endif #ifdef INTERP_TEX sLeft += dsInner; @@ -1157,7 +1191,7 @@ } #undef SETUP_CODE -#undef INNER_LOOP +#undef RENDER_SPAN #undef PIXEL_TYPE #undef BYTES_PER_ROW @@ -1166,16 +1200,13 @@ #undef INTERP_Z #undef INTERP_FOG #undef INTERP_RGB -#undef INTERP_SPEC #undef INTERP_ALPHA +#undef INTERP_SPEC #undef INTERP_INDEX #undef INTERP_INT_TEX #undef INTERP_TEX #undef INTERP_MULTITEX #undef INTERP_LAMBDA -#undef COMPUTE_LAMBDA -#undef INTERP_MULTILAMBDA -#undef COMPUTE_MULTILAMBDA #undef S_SCALE #undef T_SCALE -- cgit v1.2.3