/* Copyright (C) 1997-2001 Id Software, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ // d_polyset.c: routines for drawing sets of polygons sharing the same // texture (used for Alias models) #include "r_local.h" // TODO: put in span spilling to shrink list size // !!! if this is changed, it must be changed in d_polysa.s too !!! #define DPS_MAXSPANS MAXHEIGHT+1 // 1 extra for spanpackage that marks end // !!! if this is changed, it must be changed in asm_draw.h too !!! typedef struct { void *pdest; short *pz; int count; pixel_t *ptex; int sfrac, tfrac, light, zi; } spanpackage_t; typedef struct { int isflattop; int numleftedges; int *pleftedgevert0; int *pleftedgevert1; int *pleftedgevert2; int numrightedges; int *prightedgevert0; int *prightedgevert1; int *prightedgevert2; } edgetable; aliastriangleparms_t aliastriangleparms; int r_p0[6], r_p1[6], r_p2[6]; int d_xdenom; edgetable *pedgetable; edgetable edgetables[12] = { {0, 1, r_p0, r_p2, NULL, 2, r_p0, r_p1, r_p2 }, {0, 2, r_p1, r_p0, r_p2, 1, r_p1, r_p2, NULL}, {1, 1, r_p0, r_p2, NULL, 1, r_p1, r_p2, NULL}, {0, 1, r_p1, r_p0, NULL, 2, r_p1, r_p2, r_p0 }, {0, 2, r_p0, r_p2, r_p1, 1, r_p0, r_p1, NULL}, {0, 1, r_p2, r_p1, NULL, 1, r_p2, r_p0, NULL}, {0, 1, r_p2, r_p1, NULL, 2, r_p2, r_p0, r_p1 }, {0, 2, r_p2, r_p1, r_p0, 1, r_p2, r_p0, NULL}, {0, 1, r_p1, r_p0, NULL, 1, r_p1, r_p2, NULL}, {1, 1, r_p2, r_p1, NULL, 1, r_p0, r_p1, NULL}, {1, 1, r_p1, r_p0, NULL, 1, r_p2, r_p0, NULL}, {0, 1, r_p0, r_p2, NULL, 1, r_p0, r_p1, NULL}, }; // FIXME: some of these can become statics int a_sstepxfrac, a_tstepxfrac, r_lstepx, a_ststepxwhole; int r_sstepx, r_tstepx, r_lstepy, r_sstepy, r_tstepy; int r_zistepx, r_zistepy; int d_aspancount, d_countextrastep; spanpackage_t *a_spans; spanpackage_t *d_pedgespanpackage; static int ystart; pixel_t *d_pdest, *d_ptex; short *d_pz; int d_sfrac, d_tfrac, d_light, d_zi; int d_ptexextrastep, d_sfracextrastep; int d_tfracextrastep, d_lightextrastep, d_pdestextrastep; int d_lightbasestep, d_pdestbasestep, d_ptexbasestep; int d_sfracbasestep, d_tfracbasestep; int d_ziextrastep, d_zibasestep; int d_pzextrastep, d_pzbasestep; static int ubasestep, errorterm, erroradjustup, erroradjustdown; typedef struct { int quotient; int remainder; } adivtab_t; static adivtab_t adivtab[32*32] = { #include "adivtab.h" }; byte *skintable[MAX_LBM_HEIGHT]; int skinwidth; byte *skinstart; void (*d_pdrawspans)(spanpackage_t *pspanpackage); void R_PolysetStub (spanpackage_t *pspanpackage) { } void R_PolysetDrawSpans8_33 (spanpackage_t *pspanpackage); void R_PolysetDrawSpans8_66 (spanpackage_t *pspanpackage); void R_PolysetDrawSpans8_Opaque (spanpackage_t *pspanpackage); qboolean R_PolysetCalcGradients(int skinwidth); void R_DrawNonSubdiv (void); void R_PolysetSetEdgeTable (void); void R_RasterizeAliasPolySmooth (void); void R_PolysetScanLeftEdge(int height); qboolean R_PolysetScanLeftEdge_C(int height); /* ================ R_PolysetUpdateTables ================ */ void R_PolysetUpdateTables (void) { int i; byte *s; if (r_affinetridesc.skinwidth != skinwidth || r_affinetridesc.pskin != skinstart) { skinwidth = r_affinetridesc.skinwidth; skinstart = r_affinetridesc.pskin; s = skinstart; for (i=0 ; iv[1] - aliastriangleparms.b->v[1] ) * ( aliastriangleparms.a->v[0] - aliastriangleparms.c->v[0] ) - ( aliastriangleparms.a->v[0] - aliastriangleparms.b->v[0] ) * ( aliastriangleparms.a->v[1] - aliastriangleparms.c->v[1] ); */ dv0_ab = aliastriangleparms.a->u - aliastriangleparms.b->u; dv1_ab = aliastriangleparms.a->v - aliastriangleparms.b->v; if ( !( dv0_ab | dv1_ab ) ) return; dv0_ac = aliastriangleparms.a->u - aliastriangleparms.c->u; dv1_ac = aliastriangleparms.a->v - aliastriangleparms.c->v; if ( !( dv0_ac | dv1_ac ) ) return; d_xdenom = ( dv0_ac * dv1_ab ) - ( dv0_ab * dv1_ac ); if ( d_xdenom < 0 ) { a_spans = spans; r_p0[0] = aliastriangleparms.a->u; // u r_p0[1] = aliastriangleparms.a->v; // v r_p0[2] = aliastriangleparms.a->s; // s r_p0[3] = aliastriangleparms.a->t; // t r_p0[4] = aliastriangleparms.a->l; // light r_p0[5] = aliastriangleparms.a->zi; // iz r_p1[0] = aliastriangleparms.b->u; r_p1[1] = aliastriangleparms.b->v; r_p1[2] = aliastriangleparms.b->s; r_p1[3] = aliastriangleparms.b->t; r_p1[4] = aliastriangleparms.b->l; r_p1[5] = aliastriangleparms.b->zi; r_p2[0] = aliastriangleparms.c->u; r_p2[1] = aliastriangleparms.c->v; r_p2[2] = aliastriangleparms.c->s; r_p2[3] = aliastriangleparms.c->t; r_p2[4] = aliastriangleparms.c->l; r_p2[5] = aliastriangleparms.c->zi; R_PolysetSetEdgeTable (); R_RasterizeAliasPolySmooth (); } } static pixel_t *skinend; static inline qboolean R_DrawCheckBounds( pixel_t *lptex ) { pixel_t *skin = r_affinetridesc.pskin; if( lptex - skin < 0 || lptex - skinend >= 0 ) return false; return true; } #if 0 static inline qboolean R_CheckBounds2( spanpackage_t *pspanpackage, int lcount ) { int lsfrac, ltfrac; pixel_t *lptex, *start, *end; lptex = pspanpackage->ptex; lsfrac = pspanpackage->sfrac; ltfrac = pspanpackage->tfrac; start = r_affinetridesc.pskin; end = skinend; do { if( lptex - start < 0 || lptex - end >= 0 ) return false; lptex += a_ststepxwhole; lsfrac += a_sstepxfrac; lptex += lsfrac >> 16; lsfrac &= 0xFFFF; ltfrac += a_tstepxfrac; if (ltfrac & 0x10000) { lptex += r_affinetridesc.skinwidth; ltfrac &= 0xFFFF; } } while (--lcount); // span is linear, so only need to check first and last if( lptex - start < 0 || lptex - end >= 0 ) return false; //if( !(--lcount) ) //return true; lptex = lptex + a_ststepxwhole * lcount + ((lsfrac + ( a_sstepxfrac * lcount)) >> 16) + ((ltfrac + (a_tstepxfrac * lcount)) >> 16) * r_affinetridesc.skinwidth; if( lptex - start < 0 || lptex - end >= 0 ) return false; return true; } #endif static inline qboolean R_PolysetCheckBounds( pixel_t *lptex, int lsfrac, int ltfrac, int lcount ) { pixel_t *start, *end; start = r_affinetridesc.pskin; end = skinend; // span is linear, so only need to check first and last if( lptex - start < 0 || lptex - end >= 0 ) return false; if( !(--lcount) ) return true; lptex = lptex + a_ststepxwhole * lcount + ((lsfrac + ( a_sstepxfrac * lcount)) >> 16) + ((ltfrac + (a_tstepxfrac * lcount)) >> 16) * r_affinetridesc.skinwidth; if( lptex - start < 0 || lptex - end >= 0 ) return false; return true; } /* =================== R_PolysetScanLeftEdge_C ==================== */ qboolean R_PolysetScanLeftEdge_C(int height) { do { d_pedgespanpackage->pdest = d_pdest; d_pedgespanpackage->pz = d_pz; d_pedgespanpackage->count = d_aspancount; d_pedgespanpackage->ptex = d_ptex; d_pedgespanpackage->sfrac = d_sfrac; d_pedgespanpackage->tfrac = d_tfrac; // FIXME: need to clamp l, s, t, at both ends? d_pedgespanpackage->light = d_light; d_pedgespanpackage->zi = d_zi; d_pedgespanpackage++; errorterm += erroradjustup; if (errorterm >= 0) { d_pdest += d_pdestextrastep; d_pz += d_pzextrastep; d_aspancount += d_countextrastep; d_ptex += d_ptexextrastep; d_sfrac += d_sfracextrastep; d_ptex += d_sfrac >> 16; d_sfrac &= 0xFFFF; d_tfrac += d_tfracextrastep; if (d_tfrac & 0x10000) { d_ptex += r_affinetridesc.skinwidth; d_tfrac &= 0xFFFF; } d_light += d_lightextrastep; d_zi += d_ziextrastep; errorterm -= erroradjustdown; } else { d_pdest += d_pdestbasestep; d_pz += d_pzbasestep; d_aspancount += ubasestep; d_ptex += d_ptexbasestep; d_sfrac += d_sfracbasestep; d_ptex += d_sfrac >> 16; d_sfrac &= 0xFFFF; d_tfrac += d_tfracbasestep; if (d_tfrac & 0x10000) { d_ptex += r_affinetridesc.skinwidth; d_tfrac &= 0xFFFF; } d_light += d_lightbasestep; d_zi += d_zibasestep; } } while (--height); return true; } /* =================== FloorDivMod Returns mathematically correct (floor-based) quotient and remainder for numer and denom, both of which should contain no fractional part. The quotient must fit in 32 bits. FIXME: GET RID OF THIS! (FloorDivMod) ==================== */ void FloorDivMod (float numer, float denom, int *quotient, int *rem) { int q, r; float x; if (numer >= 0.0f) { x = floor(numer / denom); q = (int)x; r = (int)floor(numer - (x * denom)); } else { // // perform operations with positive values, and fix mod to make floor-based // x = floor(-numer / denom); q = -(int)x; r = (int)floor(-numer - (x * denom)); if (r != 0) { q--; r = (int)denom - r; } } if( q > INT_MAX / 2 || q < INT_MIN / 2 ) { int i; d_pdrawspans = R_PolysetStub; gEngfuncs.Con_Printf( S_ERROR "FloorDivMod: q overflow!\n" ); q = 1; } if( r > INT_MAX / 2 || r < INT_MIN / 2 ) { int i; d_pdrawspans = R_PolysetStub; gEngfuncs.Con_Printf( S_ERROR "FloorDivMod: r overflow!\n"); r = 1; } *quotient = q; *rem = r; } /* =================== R_PolysetSetUpForLineScan ==================== */ void R_PolysetSetUpForLineScan(fixed8_t startvertu, fixed8_t startvertv, fixed8_t endvertu, fixed8_t endvertv) { float dm, dn; int tm, tn; adivtab_t *ptemp; // TODO: implement x86 version errorterm = -1; tm = endvertu - startvertu; tn = endvertv - startvertv; if (((tm <= 16) && (tm >= -15)) && ((tn <= 16) && (tn >= -15))) { ptemp = &adivtab[((tm+15) << 5) + (tn+15)]; ubasestep = ptemp->quotient; erroradjustup = ptemp->remainder; erroradjustdown = tn; } else { dm = tm; dn = tn; FloorDivMod (dm, dn, &ubasestep, &erroradjustup); erroradjustdown = dn; } } /* ================ R_PolysetCalcGradients ================ */ #if id386 && !defined __linux__ void R_PolysetCalcGradients( int skinwidth ) { static float xstepdenominv, ystepdenominv, t0, t1; static float p01_minus_p21, p11_minus_p21, p00_minus_p20, p10_minus_p20; static float one = 1.0F, negative_one = -1.0F; static unsigned long t0_int, t1_int; extern unsigned long fpu_sp24_ceil_cw, fpu_ceil_cw, fpu_chop_cw; /* p00_minus_p20 = r_p0[0] - r_p2[0]; p01_minus_p21 = r_p0[1] - r_p2[1]; p10_minus_p20 = r_p1[0] - r_p2[0]; p11_minus_p21 = r_p1[1] - r_p2[1]; */ __asm mov eax, dword ptr [r_p0+0] __asm mov ebx, dword ptr [r_p0+4] __asm sub eax, dword ptr [r_p2+0] __asm sub ebx, dword ptr [r_p2+4] __asm mov p00_minus_p20, eax __asm mov p01_minus_p21, ebx __asm fild dword ptr p00_minus_p20 __asm fild dword ptr p01_minus_p21 __asm mov eax, dword ptr [r_p1+0] __asm mov ebx, dword ptr [r_p1+4] __asm sub eax, dword ptr [r_p2+0] __asm sub ebx, dword ptr [r_p2+4] __asm fstp p01_minus_p21 __asm fstp p00_minus_p20 __asm mov p10_minus_p20, eax __asm mov p11_minus_p21, ebx __asm fild dword ptr p10_minus_p20 __asm fild dword ptr p11_minus_p21 __asm fstp p11_minus_p21 __asm fstp p10_minus_p20 /* xstepdenominv = 1.0 / (float)d_xdenom; ystepdenominv = -xstepdenominv; */ /* ** put FPU in single precision ceil mode */ __asm fldcw word ptr [fpu_sp24_ceil_cw] // __asm fldcw word ptr [fpu_ceil_cw] __asm fild dword ptr d_xdenom ; d_xdenom __asm fdivr one ; 1 / d_xdenom __asm fst xstepdenominv ; __asm fmul negative_one ; -( 1 / d_xdenom ) // ceil () for light so positive steps are exaggerated, negative steps // diminished, pushing us away from underflow toward overflow. Underflow is // very visible, overflow is very unlikely, because of ambient lighting /* t0 = r_p0[4] - r_p2[4]; t1 = r_p1[4] - r_p2[4]; r_lstepx = (int) ceil((t1 * p01_minus_p21 - t0 * p11_minus_p21) * xstepdenominv); r_lstepy = (int) ceil((t1 * p00_minus_p20 - t0 * p10_minus_p20) * ystepdenominv); */ __asm mov eax, dword ptr [r_p0+16] __asm mov ebx, dword ptr [r_p1+16] __asm sub eax, dword ptr [r_p2+16] __asm sub ebx, dword ptr [r_p2+16] __asm fstp ystepdenominv ; (empty) __asm mov t0_int, eax __asm mov t1_int, ebx __asm fild t0_int ; t0 __asm fild t1_int ; t1 | t0 __asm fxch st(1) ; t0 | t1 __asm fstp t0 ; t1 __asm fst t1 ; t1 __asm fmul p01_minus_p21 ; t1 * p01_minus_p21 __asm fld t0 ; t0 | t1 * p01_minus_p21 __asm fmul p11_minus_p21 ; t0 * p11_minus_p21 | t1 * p01_minus_p21 __asm fld t1 ; t1 | t0 * p11_minus_p21 | t1 * p01_minus_p21 __asm fmul p00_minus_p20 ; t1 * p00_minus_p20 | t0 * p11_minus_p21 | t1 * p01_minus_p21 __asm fld t0 ; t0 | t1 * p00_minus_p20 | t0 * p11_minus_p21 | t1 * p01_minus_p21 __asm fmul p10_minus_p20 ; t0 * p10_minus_p20 | t1 * p00_minus_p20 | t0 * p11_minus_p21 | t1 * p01_minus_p21 __asm fxch st(2) ; t0 * p11_minus_p21 | t0 * p10_minus_p20 | t1 * p00_minus_p20 | t1 * p01_minus_p21 __asm fsubp st(3), st ; t0 * p10_minus_p20 | t1 * p00_minus_p20 | t1 * p01_minus_p21 - t0 * p11_minus_p21 __asm fsubrp st(1), st ; t1 * p00_minus_p20 - t0 * p10_minus_p20 | t1 * p01_minus_p21 - t0 * p11_minus_p21 __asm fxch st(1) ; t1 * p01_minus_p21 - t0 * p11_minus_p21 | t1 * p00_minus_p20 - t0 * p10_minus_p20 __asm fmul xstepdenominv ; r_lstepx | t1 * p00_minus_p20 - t0 * p10_minus_p20 __asm fxch st(1) __asm fmul ystepdenominv ; r_lstepy | r_lstepx __asm fxch st(1) ; r_lstepx | r_lstepy __asm fistp dword ptr [r_lstepx] __asm fistp dword ptr [r_lstepy] /* ** put FPU back into extended precision chop mode */ __asm fldcw word ptr [fpu_chop_cw] /* t0 = r_p0[2] - r_p2[2]; t1 = r_p1[2] - r_p2[2]; r_sstepx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) * xstepdenominv); r_sstepy = (int)((t1 * p00_minus_p20 - t0* p10_minus_p20) * ystepdenominv); */ __asm mov eax, dword ptr [r_p0+8] __asm mov ebx, dword ptr [r_p1+8] __asm sub eax, dword ptr [r_p2+8] __asm sub ebx, dword ptr [r_p2+8] __asm mov t0_int, eax __asm mov t1_int, ebx __asm fild t0_int ; t0 __asm fild t1_int ; t1 | t0 __asm fxch st(1) ; t0 | t1 __asm fstp t0 ; t1 __asm fst t1 ; (empty) __asm fmul p01_minus_p21 ; t1 * p01_minus_p21 __asm fld t0 ; t0 | t1 * p01_minus_p21 __asm fmul p11_minus_p21 ; t0 * p11_minus_p21 | t1 * p01_minus_p21 __asm fld t1 ; t1 | t0 * p11_minus_p21 | t1 * p01_minus_p21 __asm fmul p00_minus_p20 ; t1 * p00_minus_p20 | t0 * p11_minus_p21 | t1 * p01_minus_p21 __asm fld t0 ; t0 | t1 * p00_minus_p20 | t0 * p11_minus_p21 | t1 * p01_minus_p21 __asm fmul p10_minus_p20 ; t0 * p10_minus_p20 | t1 * p00_minus_p20 | t0 * p11_minus_p21 | t1 * p01_minus_p21 __asm fxch st(2) ; t0 * p11_minus_p21 | t0 * p10_minus_p20 | t1 * p00_minus_p20 | t1 * p01_minus_p21 __asm fsubp st(3), st ; t0 * p10_minus_p20 | t1 * p00_minus_p20 | t1 * p01_minus_p21 - t0 * p11_minus_p21 __asm fsubrp st(1), st ; t1 * p00_minus_p20 - t0 * p10_minus_p20 | t1 * p01_minus_p21 - t0 * p11_minus_p21 __asm fxch st(1) ; t1 * p01_minus_p21 - t0 * p11_minus_p21 | t1 * p00_minus_p20 - t0 * p10_minus_p20 __asm fmul xstepdenominv ; r_lstepx | t1 * p00_minus_p20 - t0 * p10_minus_p20 __asm fxch st(1) __asm fmul ystepdenominv ; r_lstepy | r_lstepx __asm fxch st(1) ; r_lstepx | r_lstepy __asm fistp dword ptr [r_sstepx] __asm fistp dword ptr [r_sstepy] /* t0 = r_p0[3] - r_p2[3]; t1 = r_p1[3] - r_p2[3]; r_tstepx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) * xstepdenominv); r_tstepy = (int)((t1 * p00_minus_p20 - t0 * p10_minus_p20) * ystepdenominv); */ __asm mov eax, dword ptr [r_p0+12] __asm mov ebx, dword ptr [r_p1+12] __asm sub eax, dword ptr [r_p2+12] __asm sub ebx, dword ptr [r_p2+12] __asm mov t0_int, eax __asm mov t1_int, ebx __asm fild t0_int ; t0 __asm fild t1_int ; t1 | t0 __asm fxch st(1) ; t0 | t1 __asm fstp t0 ; t1 __asm fst t1 ; (empty) __asm fmul p01_minus_p21 ; t1 * p01_minus_p21 __asm fld t0 ; t0 | t1 * p01_minus_p21 __asm fmul p11_minus_p21 ; t0 * p11_minus_p21 | t1 * p01_minus_p21 __asm fld t1 ; t1 | t0 * p11_minus_p21 | t1 * p01_minus_p21 __asm fmul p00_minus_p20 ; t1 * p00_minus_p20 | t0 * p11_minus_p21 | t1 * p01_minus_p21 __asm fld t0 ; t0 | t1 * p00_minus_p20 | t0 * p11_minus_p21 | t1 * p01_minus_p21 __asm fmul p10_minus_p20 ; t0 * p10_minus_p20 | t1 * p00_minus_p20 | t0 * p11_minus_p21 | t1 * p01_minus_p21 __asm fxch st(2) ; t0 * p11_minus_p21 | t0 * p10_minus_p20 | t1 * p00_minus_p20 | t1 * p01_minus_p21 __asm fsubp st(3), st ; t0 * p10_minus_p20 | t1 * p00_minus_p20 | t1 * p01_minus_p21 - t0 * p11_minus_p21 __asm fsubrp st(1), st ; t1 * p00_minus_p20 - t0 * p10_minus_p20 | t1 * p01_minus_p21 - t0 * p11_minus_p21 __asm fxch st(1) ; t1 * p01_minus_p21 - t0 * p11_minus_p21 | t1 * p00_minus_p20 - t0 * p10_minus_p20 __asm fmul xstepdenominv ; r_lstepx | t1 * p00_minus_p20 - t0 * p10_minus_p20 __asm fxch st(1) __asm fmul ystepdenominv ; r_lstepy | r_lstepx __asm fxch st(1) ; r_lstepx | r_lstepy __asm fistp dword ptr [r_tstepx] __asm fistp dword ptr [r_tstepy] /* t0 = r_p0[5] - r_p2[5]; t1 = r_p1[5] - r_p2[5]; r_zistepx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) * xstepdenominv); r_zistepy = (int)((t1 * p00_minus_p20 - t0 * p10_minus_p20) * ystepdenominv); */ __asm mov eax, dword ptr [r_p0+20] __asm mov ebx, dword ptr [r_p1+20] __asm sub eax, dword ptr [r_p2+20] __asm sub ebx, dword ptr [r_p2+20] __asm mov t0_int, eax __asm mov t1_int, ebx __asm fild t0_int ; t0 __asm fild t1_int ; t1 | t0 __asm fxch st(1) ; t0 | t1 __asm fstp t0 ; t1 __asm fst t1 ; (empty) __asm fmul p01_minus_p21 ; t1 * p01_minus_p21 __asm fld t0 ; t0 | t1 * p01_minus_p21 __asm fmul p11_minus_p21 ; t0 * p11_minus_p21 | t1 * p01_minus_p21 __asm fld t1 ; t1 | t0 * p11_minus_p21 | t1 * p01_minus_p21 __asm fmul p00_minus_p20 ; t1 * p00_minus_p20 | t0 * p11_minus_p21 | t1 * p01_minus_p21 __asm fld t0 ; t0 | t1 * p00_minus_p20 | t0 * p11_minus_p21 | t1 * p01_minus_p21 __asm fmul p10_minus_p20 ; t0 * p10_minus_p20 | t1 * p00_minus_p20 | t0 * p11_minus_p21 | t1 * p01_minus_p21 __asm fxch st(2) ; t0 * p11_minus_p21 | t0 * p10_minus_p20 | t1 * p00_minus_p20 | t1 * p01_minus_p21 __asm fsubp st(3), st ; t0 * p10_minus_p20 | t1 * p00_minus_p20 | t1 * p01_minus_p21 - t0 * p11_minus_p21 __asm fsubrp st(1), st ; t1 * p00_minus_p20 - t0 * p10_minus_p20 | t1 * p01_minus_p21 - t0 * p11_minus_p21 __asm fxch st(1) ; t1 * p01_minus_p21 - t0 * p11_minus_p21 | t1 * p00_minus_p20 - t0 * p10_minus_p20 __asm fmul xstepdenominv ; r_lstepx | t1 * p00_minus_p20 - t0 * p10_minus_p20 __asm fxch st(1) __asm fmul ystepdenominv ; r_lstepy | r_lstepx __asm fxch st(1) ; r_lstepx | r_lstepy __asm fistp dword ptr [r_zistepx] __asm fistp dword ptr [r_zistepy] /* #if id386ALIAS a_sstepxfrac = r_sstepx << 16; a_tstepxfrac = r_tstepx << 16; #else a_sstepxfrac = r_sstepx & 0xFFFF; a_tstepxfrac = r_tstepx & 0xFFFF; #endif */ __asm mov eax, d_pdrawspans __asm cmp eax, offset R_PolysetDrawSpans8_Opaque __asm mov eax, r_sstepx __asm mov ebx, r_tstepx __asm jne translucent //#if id386ALIAS __asm shl eax, 16 __asm shl ebx, 16 __asm jmp done_with_steps //#else translucent: __asm and eax, 0ffffh __asm and ebx, 0ffffh //#endif done_with_steps: __asm mov a_sstepxfrac, eax __asm mov a_tstepxfrac, ebx /* a_ststepxwhole = skinwidth * (r_tstepx >> 16) + (r_sstepx >> 16); */ __asm mov ebx, r_tstepx __asm mov ecx, r_sstepx __asm sar ebx, 16 __asm mov eax, skinwidth __asm mul ebx __asm sar ecx, 16 __asm add eax, ecx __asm mov a_ststepxwhole, eax } #else qboolean R_PolysetCalcGradients (int skinwidth) { float xstepdenominv, ystepdenominv, t0, t1; float p01_minus_p21, p11_minus_p21, p00_minus_p20, p10_minus_p20; p00_minus_p20 = r_p0[0] - r_p2[0]; p01_minus_p21 = r_p0[1] - r_p2[1]; p10_minus_p20 = r_p1[0] - r_p2[0]; p11_minus_p21 = r_p1[1] - r_p2[1]; /*printf("gradients for triangle\n"); printf("%d %d %d %d %d %d\n" , r_p0[0], r_p0[1], r_p0[2] >> 16, r_p0[3] >> 16, r_p0[4], r_p0[5]); printf("%d %d %d %d %d %d\n" , r_p1[0], r_p1[1], r_p1[2] >> 16, r_p1[3] >> 16, r_p1[4], r_p1[5]); printf("%d %d %d %d %d %d\n\n", r_p2[0], r_p2[1], r_p2[2] >> 16, r_p2[3] >> 16, r_p2[4], r_p2[5]); */ xstepdenominv = 1.0f / (float)d_xdenom; ystepdenominv = -xstepdenominv; // ceil () for light so positive steps are exaggerated, negative steps // diminished, pushing us away from underflow toward overflow. Underflow is // very visible, overflow is very unlikely, because of ambient lighting t0 = r_p0[4] - r_p2[4]; t1 = r_p1[4] - r_p2[4]; r_lstepx = (int) ceil((t1 * p01_minus_p21 - t0 * p11_minus_p21) * xstepdenominv); r_lstepy = (int) ceil((t1 * p00_minus_p20 - t0 * p10_minus_p20) * ystepdenominv); t0 = r_p0[2] - r_p2[2]; t1 = r_p1[2] - r_p2[2]; r_sstepx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) * xstepdenominv); r_sstepy = (int)((t1 * p00_minus_p20 - t0* p10_minus_p20) * ystepdenominv); t0 = r_p0[3] - r_p2[3]; t1 = r_p1[3] - r_p2[3]; r_tstepx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) * xstepdenominv); r_tstepy = (int)((t1 * p00_minus_p20 - t0 * p10_minus_p20) * ystepdenominv); t0 = r_p0[5] - r_p2[5]; t1 = r_p1[5] - r_p2[5]; r_zistepx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) * xstepdenominv); r_zistepy = (int)((t1 * p00_minus_p20 - t0 * p10_minus_p20) * ystepdenominv); /*if( r_zistepx > INT_MAX / 2 ) return false; if( r_zistepx < INT_MIN / 2 ) return false; if( r_zistepy > INT_MAX / 2 ) return false; if( r_zistepy < INT_MIN / 2 ) return false;*/ //#if id386ALIAS #if id386 if ( d_pdrawspans == R_PolysetDrawSpans8_Opaque ) { a_sstepxfrac = r_sstepx << 16; a_tstepxfrac = r_tstepx << 16; } else #endif { //#else a_sstepxfrac = r_sstepx & 0xFFFF; a_tstepxfrac = r_tstepx & 0xFFFF; } //#endif // do not allow big steps to make 512 byte extra bounds enough (still f**ng not) /*if( r_sstepx <= -65535*8 ) return false; if( r_tstepx <= -65535*8) return false; if( r_sstepx >= 65535*8 ) return false; if( r_tstepx >= 65535*8 ) return false;*/ a_ststepxwhole = skinwidth * (r_tstepx >> 16) + (r_sstepx >> 16); // printf("%d %d %d %d\n",a_ststepxwhole, r_sstepx, r_tstepx, skinwidth ); skinend = (pixel_t*)r_affinetridesc.pskin + r_affinetridesc.skinwidth * r_affinetridesc.skinheight; return true; } #endif /* ================ R_PolysetDrawSpans8 ================ */ void R_PolysetDrawSpansBlended( spanpackage_t *pspanpackage) { int lcount; pixel_t *lpdest; pixel_t *lptex; int lsfrac, ltfrac; int llight; int lzi; short *lpz; do { lcount = d_aspancount - pspanpackage->count; errorterm += erroradjustup; if (errorterm >= 0) { d_aspancount += d_countextrastep; errorterm -= erroradjustdown; } else { d_aspancount += ubasestep; } if (lcount) { lpdest = pspanpackage->pdest; lptex = pspanpackage->ptex; lpz = pspanpackage->pz; lsfrac = pspanpackage->sfrac; ltfrac = pspanpackage->tfrac; llight = pspanpackage->light; lzi = pspanpackage->zi; pspanpackage++; #if BOUNDCHECK_MODE == 0 if( !R_PolysetCheckBounds( lptex, lsfrac, ltfrac, lcount ) ) continue; #endif do { if ((lzi >> 16) >= *lpz) { #if 0 if((int)(lptex - (pixel_t*)r_affinetridesc.pskin) > r_affinetridesc.skinwidth * r_affinetridesc.skinheight || (int)(lptex - (pixel_t*)r_affinetridesc.pskin) < 0 ) { printf("%d %d %d %d\n",(int)(lptex - (pixel_t*)r_affinetridesc.pskin), r_affinetridesc.skinwidth * r_affinetridesc.skinheight, lsfrac, a_ststepxwhole ); return; } #endif #if BOUNDCHECK_MODE == 1 if( !R_DrawCheckBounds( lptex ) ) return; #endif pixel_t temp = *lptex;//vid.colormap[*lptex + ( llight & 0xFF00 )]; int alpha = vid.alpha; temp = BLEND_COLOR(temp, vid.color); if( alpha == 7 ) *lpdest = temp; else if(alpha) *lpdest = BLEND_ALPHA(alpha,temp,*lpdest);//vid.alphamap[temp+ *lpdest*256]; } lpdest++; lzi += r_zistepx; lpz++; llight += r_lstepx; lptex += a_ststepxwhole; lsfrac += a_sstepxfrac; lptex += lsfrac >> 16; lsfrac &= 0xFFFF; ltfrac += a_tstepxfrac; if (ltfrac & 0x10000) { lptex += r_affinetridesc.skinwidth; ltfrac &= 0xFFFF; } } while (--lcount); } else pspanpackage++; } while (pspanpackage->count != -999999); } /* ================ R_PolysetDrawSpans8 ================ */ void R_PolysetDrawSpansAdditive( spanpackage_t *pspanpackage) { int lcount; pixel_t *lpdest; pixel_t *lptex; int lsfrac, ltfrac; int llight; int lzi; short *lpz; do { lcount = d_aspancount - pspanpackage->count; errorterm += erroradjustup; if (errorterm >= 0) { d_aspancount += d_countextrastep; errorterm -= erroradjustdown; } else { d_aspancount += ubasestep; } if (lcount) { lpdest = pspanpackage->pdest; lptex = pspanpackage->ptex; lpz = pspanpackage->pz; lsfrac = pspanpackage->sfrac; ltfrac = pspanpackage->tfrac; llight = pspanpackage->light; lzi = pspanpackage->zi; pspanpackage++; #if BOUNDCHECK_MODE == 0 if( !R_PolysetCheckBounds( lptex, lsfrac, ltfrac, lcount ) ) continue; #endif do { if ((lzi >> 16) >= *lpz) { #if BOUNDCHECK_MODE == 1 if( !R_DrawCheckBounds( lptex ) ) return; #endif #if 0 if((int)(lptex - (pixel_t*)r_affinetridesc.pskin) > r_affinetridesc.skinwidth * r_affinetridesc.skinheight || (int)(lptex - (pixel_t*)r_affinetridesc.pskin) < 0 ) { printf("%d %d %d %d\n",(int)(lptex - (pixel_t*)r_affinetridesc.pskin), r_affinetridesc.skinwidth * r_affinetridesc.skinheight, lsfrac, a_ststepxwhole ); return; } #endif pixel_t temp = *lptex;//vid.colormap[*lptex + ( llight & 0xFF00 )]; temp = BLEND_COLOR(temp, vid.color); *lpdest = BLEND_ADD(temp,*lpdest); } lpdest++; lzi += r_zistepx; lpz++; llight += r_lstepx; lptex += a_ststepxwhole; lsfrac += a_sstepxfrac; lptex += lsfrac >> 16; lsfrac &= 0xFFFF; ltfrac += a_tstepxfrac; if (ltfrac & 0x10000) { lptex += r_affinetridesc.skinwidth; ltfrac &= 0xFFFF; } } while (--lcount); } else pspanpackage++; } while (pspanpackage->count != -999999); } /* ================ R_PolysetDrawSpans8 ================ */ void R_PolysetDrawSpansGlow( spanpackage_t *pspanpackage) { int lcount; pixel_t *lpdest; pixel_t *lptex; int lsfrac, ltfrac; int llight; int lzi; short *lpz; do { lcount = d_aspancount - pspanpackage->count; errorterm += erroradjustup; if (errorterm >= 0) { d_aspancount += d_countextrastep; errorterm -= erroradjustdown; } else { d_aspancount += ubasestep; } if (lcount) { lpdest = pspanpackage->pdest; lptex = pspanpackage->ptex; lpz = pspanpackage->pz; lsfrac = pspanpackage->sfrac; ltfrac = pspanpackage->tfrac; llight = pspanpackage->light; lzi = pspanpackage->zi; pspanpackage++; #if BOUNDCHECK_MODE == 0 if( !R_PolysetCheckBounds( lptex, lsfrac, ltfrac, lcount ) ) continue; #endif do { //if ((lzi >> 16) >= *lpz) { #if BOUNDCHECK_MODE == 1 if( !R_DrawCheckBounds( lptex ) ) return; #endif #if 0 if((int)(lptex - (pixel_t*)r_affinetridesc.pskin) > r_affinetridesc.skinwidth * r_affinetridesc.skinheight || (int)(lptex - (pixel_t*)r_affinetridesc.pskin) < 0 ) { printf("%d %d %d %d\n",(int)(lptex - (pixel_t*)r_affinetridesc.pskin), r_affinetridesc.skinwidth * r_affinetridesc.skinheight, lsfrac, a_ststepxwhole ); return; } #endif pixel_t temp = *lptex;//vid.colormap[*lptex + ( llight & 0xFF00 )]; temp = BLEND_COLOR(temp, vid.color); *lpdest = BLEND_ADD(temp,*lpdest); } lpdest++; lzi += r_zistepx; lpz++; llight += r_lstepx; lptex += a_ststepxwhole; lsfrac += a_sstepxfrac; lptex += lsfrac >> 16; lsfrac &= 0xFFFF; ltfrac += a_tstepxfrac; if (ltfrac & 0x10000) { lptex += r_affinetridesc.skinwidth; ltfrac &= 0xFFFF; } } while (--lcount); } else pspanpackage++; } while (pspanpackage->count != -999999); } /* ================ R_PolysetDrawSpans8 ================ */ void R_PolysetDrawSpansTextureBlended( spanpackage_t *pspanpackage) { int lcount; pixel_t *lpdest; pixel_t *lptex; int lsfrac, ltfrac; int llight; int lzi; short *lpz; do { lcount = d_aspancount - pspanpackage->count; errorterm += erroradjustup; if (errorterm >= 0) { d_aspancount += d_countextrastep; errorterm -= erroradjustdown; } else { d_aspancount += ubasestep; } if (lcount) { lpdest = pspanpackage->pdest; lptex = pspanpackage->ptex; lpz = pspanpackage->pz; lsfrac = pspanpackage->sfrac; ltfrac = pspanpackage->tfrac; llight = pspanpackage->light; lzi = pspanpackage->zi; pspanpackage++; #if BOUNDCHECK_MODE == 0 if( !R_PolysetCheckBounds( lptex, lsfrac, ltfrac, lcount ) ) continue; #endif do { if ((lzi >> 16) >= *lpz) { #if BOUNDCHECK_MODE == 1 if( !R_DrawCheckBounds( lptex ) ) return; #endif #if 0 if((int)(lptex - (pixel_t*)r_affinetridesc.pskin) > r_affinetridesc.skinwidth * r_affinetridesc.skinheight || (int)(lptex - (pixel_t*)r_affinetridesc.pskin) < 0 ) { printf("%d %d %d %d\n",(int)(lptex - (pixel_t*)r_affinetridesc.pskin), r_affinetridesc.skinwidth * r_affinetridesc.skinheight, lsfrac, a_ststepxwhole ); return; } #endif pixel_t temp = *lptex;//vid.colormap[*lptex + ( llight & 0xFF00 )]; int alpha = temp >> 13; temp = temp << 3; temp = BLEND_COLOR(temp, vid.color); if( alpha == 7 ) *lpdest = temp; else if(alpha) *lpdest = BLEND_ALPHA(alpha,temp,*lpdest);//vid.alphamap[temp+ *lpdest*256]; } lpdest++; lzi += r_zistepx; lpz++; llight += r_lstepx; lptex += a_ststepxwhole; lsfrac += a_sstepxfrac; lptex += lsfrac >> 16; lsfrac &= 0xFFFF; ltfrac += a_tstepxfrac; if (ltfrac & 0x10000) { lptex += r_affinetridesc.skinwidth; ltfrac &= 0xFFFF; } } while (--lcount); } else pspanpackage++; } while (pspanpackage->count != -999999); } /* ================ R_PolysetDrawSpans8 ================ */ void R_PolysetDrawSpans8_33( spanpackage_t *pspanpackage) { int lcount; pixel_t *lpdest; pixel_t *lptex; int lsfrac, ltfrac; int llight; int lzi; short *lpz; do { lcount = d_aspancount - pspanpackage->count; errorterm += erroradjustup; if (errorterm >= 0) { d_aspancount += d_countextrastep; errorterm -= erroradjustdown; } else { d_aspancount += ubasestep; } if (lcount) { lpdest = pspanpackage->pdest; lptex = pspanpackage->ptex; lpz = pspanpackage->pz; lsfrac = pspanpackage->sfrac; ltfrac = pspanpackage->tfrac; llight = pspanpackage->light; lzi = pspanpackage->zi; do { if ((lzi >> 16) >= *lpz) { #if 0 if((int)(lptex - (pixel_t*)r_affinetridesc.pskin) > r_affinetridesc.skinwidth * r_affinetridesc.skinheight || (int)(lptex - (pixel_t*)r_affinetridesc.pskin) < 0 ) { printf("%d %d %d %d\n",(int)(lptex - (pixel_t*)r_affinetridesc.pskin), r_affinetridesc.skinwidth * r_affinetridesc.skinheight, lsfrac, a_ststepxwhole ); return; } #endif pixel_t temp = *lptex;//vid.colormap[*lptex + ( llight & 0xFF00 )]; int alpha = tr.blend * 7; if( alpha == 7 ) *lpdest = temp; else if(alpha) *lpdest = BLEND_ALPHA(alpha,temp,*lpdest);//vid.alphamap[temp+ *lpdest*256]; } lpdest++; lzi += r_zistepx; lpz++; llight += r_lstepx; lptex += a_ststepxwhole; lsfrac += a_sstepxfrac; lptex += lsfrac >> 16; lsfrac &= 0xFFFF; ltfrac += a_tstepxfrac; if (ltfrac & 0x10000) { lptex += r_affinetridesc.skinwidth; ltfrac &= 0xFFFF; } } while (--lcount); } pspanpackage++; } while (pspanpackage->count != -999999); } void R_PolysetDrawSpansConstant8_33( spanpackage_t *pspanpackage) { int lcount; pixel_t *lpdest; int lzi; short *lpz; do { lcount = d_aspancount - pspanpackage->count; errorterm += erroradjustup; if (errorterm >= 0) { d_aspancount += d_countextrastep; errorterm -= erroradjustdown; } else { d_aspancount += ubasestep; } if (lcount) { lpdest = pspanpackage->pdest; lpz = pspanpackage->pz; lzi = pspanpackage->zi; do { if ((lzi >> 16) >= *lpz) { *lpdest = BLEND_ALPHA(2,r_aliasblendcolor,*lpdest);//vid.alphamap[r_aliasblendcolor + *lpdest*256]; } lpdest++; lzi += r_zistepx; lpz++; } while (--lcount); } pspanpackage++; } while (pspanpackage->count != -999999); } void R_PolysetDrawSpans8_66(spanpackage_t *pspanpackage) { int lcount; pixel_t *lpdest; pixel_t *lptex; int lsfrac, ltfrac; int llight; int lzi; short *lpz; do { lcount = d_aspancount - pspanpackage->count; errorterm += erroradjustup; if (errorterm >= 0) { d_aspancount += d_countextrastep; errorterm -= erroradjustdown; } else { d_aspancount += ubasestep; } if (lcount) { lpdest = pspanpackage->pdest; lptex = pspanpackage->ptex; lpz = pspanpackage->pz; lsfrac = pspanpackage->sfrac; ltfrac = pspanpackage->tfrac; llight = pspanpackage->light; lzi = pspanpackage->zi; do { if ((lzi >> 16) >= *lpz) { int temp = vid.colormap[*lptex + ( llight & 0xFF00 )]; *lpdest = BLEND_ALPHA(5,temp,*lpdest);//vid.alphamap[temp*256 + *lpdest]; *lpz = lzi >> 16; } lpdest++; lzi += r_zistepx; lpz++; llight += r_lstepx; lptex += a_ststepxwhole; lsfrac += a_sstepxfrac; lptex += lsfrac >> 16; lsfrac &= 0xFFFF; ltfrac += a_tstepxfrac; if (ltfrac & 0x10000) { lptex += r_affinetridesc.skinwidth; ltfrac &= 0xFFFF; } } while (--lcount); } pspanpackage++; } while (pspanpackage->count != -999999); } void R_PolysetDrawSpansConstant8_66( spanpackage_t *pspanpackage) { int lcount; pixel_t *lpdest; int lzi; short *lpz; do { lcount = d_aspancount - pspanpackage->count; errorterm += erroradjustup; if (errorterm >= 0) { d_aspancount += d_countextrastep; errorterm -= erroradjustdown; } else { d_aspancount += ubasestep; } if (lcount) { lpdest = pspanpackage->pdest; lpz = pspanpackage->pz; lzi = pspanpackage->zi; do { if ((lzi >> 16) >= *lpz) { *lpdest = BLEND_ALPHA(5,r_aliasblendcolor,*lpdest);//vid.alphamap[r_aliasblendcolor*256 + *lpdest]; } lpdest++; lzi += r_zistepx; lpz++; } while (--lcount); } pspanpackage++; } while (pspanpackage->count != -999999); } #if !id386 void R_PolysetDrawSpans8_Opaque (spanpackage_t *pspanpackage) { int lcount; do { lcount = d_aspancount - pspanpackage->count; errorterm += erroradjustup; if (errorterm >= 0) { d_aspancount += d_countextrastep; errorterm -= erroradjustdown; } else { d_aspancount += ubasestep; } if (lcount) { int lsfrac, ltfrac; pixel_t *lpdest; pixel_t *lptex; int llight; int lzi; short *lpz; lpdest = pspanpackage->pdest; lptex = pspanpackage->ptex; lpz = pspanpackage->pz; lsfrac = pspanpackage->sfrac; ltfrac = pspanpackage->tfrac; llight = pspanpackage->light; lzi = pspanpackage->zi; do { if ((lzi >> 16) >= *lpz) { //PGM /*if(r_newrefdef.rdflags & RDF_IRGOGGLES && RI.currententity->flags & RF_IR_VISIBLE) *lpdest = ((byte *)vid.colormap)[irtable[*lptex]]; else*/ *lpdest = ((byte *)vid.colormap)[*lptex + (llight & 0xFF00)]; //PGM *lpz = lzi >> 16; } lpdest++; lzi += r_zistepx; lpz++; llight += r_lstepx; lptex += a_ststepxwhole; lsfrac += a_sstepxfrac; lptex += lsfrac >> 16; lsfrac &= 0xFFFF; ltfrac += a_tstepxfrac; if (ltfrac & 0x10000) { lptex += r_affinetridesc.skinwidth; ltfrac &= 0xFFFF; } } while (--lcount); } pspanpackage++; } while (pspanpackage->count != -999999); } #endif #if 0 /* ================ R_PolysetFillSpans8 ================ */ void R_PolysetFillSpans8 (spanpackage_t *pspanpackage) { int color; // FIXME: do z buffering color = d_aflatcolor++; while (1) { int lcount; byte *lpdest; lcount = pspanpackage->count; if (lcount == -1) return; if (lcount) { lpdest = pspanpackage->pdest; do { *lpdest++ = color; } while (--lcount); } pspanpackage++; } } #else void R_PolysetFillSpans8 (spanpackage_t *pspanpackage) { //int color; int lcount; // FIXME: do z buffering //color = d_aflatcolor++ * 10; do { lcount = d_aspancount - pspanpackage->count; // d_ptex + a_ststepxwhole * lcount + ((a_sstepxfrac * lcount) >> 16) + ((a_tstepxfrac * lcount) >> 16)*r_affinetridesc.skinwidth; errorterm += erroradjustup; if (errorterm >= 0) { d_aspancount += d_countextrastep; errorterm -= erroradjustdown; } else { d_aspancount += ubasestep; } if (lcount) { int lsfrac, ltfrac; pixel_t *lpdest; pixel_t *lptex; int llight; int lzi; short *lpz; lpdest = pspanpackage->pdest; lptex = pspanpackage->ptex; lpz = pspanpackage->pz; lsfrac = pspanpackage->sfrac; ltfrac = pspanpackage->tfrac; llight = pspanpackage->light; lzi = pspanpackage->zi; pspanpackage ++; #if BOUNDCHECK_MODE == 0 if( !R_PolysetCheckBounds( lptex, lsfrac, ltfrac, lcount ) ) continue; #endif do { if ((lzi >> 16) >= *lpz) { #if BOUNDCHECK_MODE == 1 if( !R_DrawCheckBounds( lptex ) ) return; #endif //PGM /*if(r_newrefdef.rdflags & RDF_IRGOGGLES && RI.currententity->flags & RF_IR_VISIBLE) *lpdest = ((byte *)vid.colormap)[irtable[*lptex]]; else*/ //*lpdest = *lptex; //((byte *)vid.colormap)[*lptex + (llight & 0xFF00)]; #if 0 // check for texture bounds to make asan happy if((int)(lptex - (pixel_t*)r_affinetridesc.pskin) > r_affinetridesc.skinwidth * r_affinetridesc.skinheight || (int)(lptex - (pixel_t*)r_affinetridesc.pskin) < 0 ) { printf("%d %d %d %d\n",(int)(lptex - (pixel_t*)r_affinetridesc.pskin), r_affinetridesc.skinwidth * r_affinetridesc.skinheight, lsfrac, a_ststepxwhole ); return; } #endif pixel_t src = *lptex; //*lpdest = //vid.colormap[src & 0xff00|(llight>>8)] << 8 | (src & llight & 0xff) | ((src & 0xff) >> 3); // very dirty, maybe need dual colormap? //*lpdest = (vid.colormap[src >> 8 | (llight & 0xFF00)] << 8) | src & 0xff; // 13 bit lighting, 32 light levels *lpdest = vid.colormap[(src >> 3) | ((llight & 0x1F00) << 5)] | (src & 7); //PGM *lpz = lzi >> 16; } lpdest++; lzi += r_zistepx; lpz++; llight += r_lstepx; lptex += a_ststepxwhole; lsfrac += a_sstepxfrac; lptex += lsfrac >> 16; lsfrac &= 0xFFFF; ltfrac += a_tstepxfrac; if (ltfrac & 0x10000) { lptex += r_affinetridesc.skinwidth; ltfrac &= 0xFFFF; } } while (--lcount); } else pspanpackage++; } while (pspanpackage->count != -999999); } #endif /* ================ R_RasterizeAliasPolySmooth ================ */ void R_RasterizeAliasPolySmooth (void) { int initialleftheight, initialrightheight; int *plefttop, *prighttop, *pleftbottom, *prightbottom; int working_lstepx, originalcount; plefttop = pedgetable->pleftedgevert0; prighttop = pedgetable->prightedgevert0; pleftbottom = pedgetable->pleftedgevert1; prightbottom = pedgetable->prightedgevert1; initialleftheight = pleftbottom[1] - plefttop[1]; initialrightheight = prightbottom[1] - prighttop[1]; // // set the s, t, and light gradients, which are consistent across the triangle // because being a triangle, things are affine // if( !R_PolysetCalcGradients (r_affinetridesc.skinwidth) ) return; // // rasterize the polygon // // // scan out the top (and possibly only) part of the left edge // d_pedgespanpackage = a_spans; ystart = plefttop[1]; d_aspancount = plefttop[0] - prighttop[0]; d_ptex = (pixel_t*)r_affinetridesc.pskin + (plefttop[2] >> 16) + (plefttop[3] >> 16) * r_affinetridesc.skinwidth; //#if id386ALIAS #if id386 if ( d_pdrawspans == R_PolysetDrawSpans8_Opaque ) { d_sfrac = (plefttop[2] & 0xFFFF) << 16; d_tfrac = (plefttop[3] & 0xFFFF) << 16; } //#else else #endif { d_sfrac = plefttop[2] & 0xFFFF; d_tfrac = plefttop[3] & 0xFFFF; } //#endif d_light = plefttop[4]; d_zi = plefttop[5]; d_pdest = (pixel_t *)d_viewbuffer + ystart * r_screenwidth + plefttop[0]; d_pz = d_pzbuffer + ystart * d_zwidth + plefttop[0]; if (initialleftheight == 1) { d_pedgespanpackage->pdest = d_pdest; d_pedgespanpackage->pz = d_pz; d_pedgespanpackage->count = d_aspancount; d_pedgespanpackage->ptex = d_ptex; d_pedgespanpackage->sfrac = d_sfrac; d_pedgespanpackage->tfrac = d_tfrac; // FIXME: need to clamp l, s, t, at both ends? d_pedgespanpackage->light = d_light; d_pedgespanpackage->zi = d_zi; d_pedgespanpackage++; } else { R_PolysetSetUpForLineScan(plefttop[0], plefttop[1], pleftbottom[0], pleftbottom[1]); //#if id386ALIAS #if id386 if ( d_pdrawspans == R_PolysetDrawSpans8_Opaque ) { d_pzbasestep = (d_zwidth + ubasestep) << 1; d_pzextrastep = d_pzbasestep + 2; } //#else else #endif { d_pzbasestep = d_zwidth + ubasestep; d_pzextrastep = d_pzbasestep + 1; } //#endif d_pdestbasestep = r_screenwidth + ubasestep; d_pdestextrastep = d_pdestbasestep + 1; // TODO: can reuse partial expressions here // for negative steps in x along left edge, bias toward overflow rather than // underflow (sort of turning the floor () we did in the gradient calcs into // ceil (), but plus a little bit) if (ubasestep < 0) working_lstepx = r_lstepx - 1; else working_lstepx = r_lstepx; d_countextrastep = ubasestep + 1; d_ptexbasestep = ((r_sstepy + r_sstepx * ubasestep) >> 16) + ((r_tstepy + r_tstepx * ubasestep) >> 16) * r_affinetridesc.skinwidth; //#if id386ALIAS #if id386 if ( d_pdrawspans == R_PolysetDrawSpans8_Opaque ) { d_sfracbasestep = (r_sstepy + r_sstepx * ubasestep) << 16; d_tfracbasestep = (r_tstepy + r_tstepx * ubasestep) << 16; } else #endif { //#else d_sfracbasestep = (r_sstepy + r_sstepx * ubasestep) & 0xFFFF; d_tfracbasestep = (r_tstepy + r_tstepx * ubasestep) & 0xFFFF; } //#endif d_lightbasestep = r_lstepy + working_lstepx * ubasestep; d_zibasestep = r_zistepy + r_zistepx * ubasestep; d_ptexextrastep = ((r_sstepy + r_sstepx * d_countextrastep) >> 16) + ((r_tstepy + r_tstepx * d_countextrastep) >> 16) * r_affinetridesc.skinwidth; //#if id386ALIAS #if id386 if ( d_pdrawspans == R_PolysetDrawSpans8_Opaque ) { d_sfracextrastep = (r_sstepy + r_sstepx*d_countextrastep) << 16; d_tfracextrastep = (r_tstepy + r_tstepx*d_countextrastep) << 16; } else #endif { //#else d_sfracextrastep = (r_sstepy + r_sstepx*d_countextrastep) & 0xFFFF; d_tfracextrastep = (r_tstepy + r_tstepx*d_countextrastep) & 0xFFFF; } //#endif d_lightextrastep = d_lightbasestep + working_lstepx; d_ziextrastep = d_zibasestep + r_zistepx; #if id386 if ( d_pdrawspans == R_PolysetDrawSpans8_Opaque ) { R_PolysetScanLeftEdge (initialleftheight); } else #endif { if(!R_PolysetScanLeftEdge_C(initialleftheight)) return; } } // // scan out the bottom part of the left edge, if it exists // if (pedgetable->numleftedges == 2) { int height; plefttop = pleftbottom; pleftbottom = pedgetable->pleftedgevert2; height = pleftbottom[1] - plefttop[1]; // TODO: make this a function; modularize this function in general ystart = plefttop[1]; d_aspancount = plefttop[0] - prighttop[0]; d_ptex = (pixel_t*)r_affinetridesc.pskin + (plefttop[2] >> 16) + (plefttop[3] >> 16) * r_affinetridesc.skinwidth; d_sfrac = 0; d_tfrac = 0; d_light = plefttop[4]; d_zi = plefttop[5]; d_pdest = (pixel_t *)d_viewbuffer + ystart * r_screenwidth + plefttop[0]; d_pz = d_pzbuffer + ystart * d_zwidth + plefttop[0]; if (height == 1) { d_pedgespanpackage->pdest = d_pdest; d_pedgespanpackage->pz = d_pz; d_pedgespanpackage->count = d_aspancount; d_pedgespanpackage->ptex = d_ptex; d_pedgespanpackage->sfrac = d_sfrac; d_pedgespanpackage->tfrac = d_tfrac; // FIXME: need to clamp l, s, t, at both ends? d_pedgespanpackage->light = d_light; d_pedgespanpackage->zi = d_zi; d_pedgespanpackage++; } else { R_PolysetSetUpForLineScan(plefttop[0], plefttop[1], pleftbottom[0], pleftbottom[1]); d_pdestbasestep = r_screenwidth + ubasestep; d_pdestextrastep = d_pdestbasestep + 1; //#if id386ALIAS #if id386 if ( d_pdrawspans == R_PolysetDrawSpans8_Opaque ) { d_pzbasestep = (d_zwidth + ubasestep) << 1; d_pzextrastep = d_pzbasestep + 2; } //#else else #endif { d_pzbasestep = d_zwidth + ubasestep; d_pzextrastep = d_pzbasestep + 1; } //#endif if (ubasestep < 0) working_lstepx = r_lstepx - 1; else working_lstepx = r_lstepx; d_countextrastep = ubasestep + 1; d_ptexbasestep = ((r_sstepy + r_sstepx * ubasestep) >> 16) + ((r_tstepy + r_tstepx * ubasestep) >> 16) * r_affinetridesc.skinwidth; //#if id386ALIAS #if id386 if ( d_pdrawspans == R_PolysetDrawSpans8_Opaque ) { d_sfracbasestep = (r_sstepy + r_sstepx * ubasestep) << 16; d_tfracbasestep = (r_tstepy + r_tstepx * ubasestep) << 16; } //#else else #endif { d_sfracbasestep = (r_sstepy + r_sstepx * ubasestep) & 0xFFFF; d_tfracbasestep = (r_tstepy + r_tstepx * ubasestep) & 0xFFFF; } //#endif d_lightbasestep = r_lstepy + working_lstepx * ubasestep; d_zibasestep = r_zistepy + r_zistepx * ubasestep; d_ptexextrastep = ((r_sstepy + r_sstepx * d_countextrastep) >> 16) + ((r_tstepy + r_tstepx * d_countextrastep) >> 16) * r_affinetridesc.skinwidth; //#if id386ALIAS #if id386 if ( d_pdrawspans == R_PolysetDrawSpans8_Opaque ) { d_sfracextrastep = ((r_sstepy+r_sstepx*d_countextrastep) & 0xFFFF)<<16; d_tfracextrastep = ((r_tstepy+r_tstepx*d_countextrastep) & 0xFFFF)<<16; } else #endif //#endif { d_sfracextrastep = (r_sstepy+r_sstepx*d_countextrastep) & 0xFFFF; d_tfracextrastep = (r_tstepy+r_tstepx*d_countextrastep) & 0xFFFF; } //#endif d_lightextrastep = d_lightbasestep + working_lstepx; d_ziextrastep = d_zibasestep + r_zistepx; #if id386 if ( d_pdrawspans == R_PolysetDrawSpans8_Opaque ) { R_PolysetScanLeftEdge (height); } else #endif { if(!R_PolysetScanLeftEdge_C(height)) return; } } } // scan out the top (and possibly only) part of the right edge, updating the // count field d_pedgespanpackage = a_spans; R_PolysetSetUpForLineScan(prighttop[0], prighttop[1], prightbottom[0], prightbottom[1]); d_aspancount = 0; d_countextrastep = ubasestep + 1; originalcount = a_spans[initialrightheight].count; a_spans[initialrightheight].count = -999999; // mark end of the spanpackages (*d_pdrawspans) (a_spans); // scan out the bottom part of the right edge, if it exists if (pedgetable->numrightedges == 2) { int height; spanpackage_t *pstart; pstart = a_spans + initialrightheight; pstart->count = originalcount; d_aspancount = prightbottom[0] - prighttop[0]; prighttop = prightbottom; prightbottom = pedgetable->prightedgevert2; height = prightbottom[1] - prighttop[1]; R_PolysetSetUpForLineScan(prighttop[0], prighttop[1], prightbottom[0], prightbottom[1]); d_countextrastep = ubasestep + 1; a_spans[initialrightheight + height].count = -999999; // mark end of the spanpackages (*d_pdrawspans) (pstart); } } /* ================ R_PolysetSetEdgeTable ================ */ void R_PolysetSetEdgeTable (void) { int edgetableindex; edgetableindex = 0; // assume the vertices are already in // top to bottom order // // determine which edges are right & left, and the order in which // to rasterize them // if (r_p0[1] >= r_p1[1]) { if (r_p0[1] == r_p1[1]) { if (r_p0[1] < r_p2[1]) pedgetable = &edgetables[2]; else pedgetable = &edgetables[5]; return; } else { edgetableindex = 1; } } if (r_p0[1] == r_p2[1]) { if (edgetableindex) pedgetable = &edgetables[8]; else pedgetable = &edgetables[9]; return; } else if (r_p1[1] == r_p2[1]) { if (edgetableindex) pedgetable = &edgetables[10]; else pedgetable = &edgetables[11]; return; } if (r_p0[1] > r_p2[1]) edgetableindex += 2; if (r_p1[1] > r_p2[1]) edgetableindex += 4; pedgetable = &edgetables[edgetableindex]; }