FWGS/xash3d-fwgs
2
0
Fork 0
mirror of https://github.com/FWGS/xash3d-fwgs synced 2024-11-22 18:07:09 +01:00
Code Issues 2 Projects Releases Wiki Activity
a56f512dc3
xash3d-fwgs/ref/soft/r_polyse.c

1484 lines
32 KiB
C
Raw Blame History

/*
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
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 );
static 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_DrawTriangle
================
*/
void R_DrawTriangle( void )
{
spanpackage_t spans[DPS_MAXSPANS];
int dv1_ab, dv0_ac;
int dv0_ab, dv1_ac;
/*
d_xdenom = ( aliastriangleparms.a->v[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;
}
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)
====================
*/
static 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 "%s: q overflow!\n", __func__ );
q = 1;
}
if( r > INT_MAX / 2 || r < INT_MIN / 2 )
{
int i;
d_pdrawspans = R_PolysetStub;
gEngfuncs.Con_Printf( S_ERROR "%s: r overflow!\n", __func__ );
r = 1;
}
*quotient = q;
*rem = r;
}
/*
===================
R_PolysetSetUpForLineScan
====================
*/
static 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
================
*/
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 );
{
a_sstepxfrac = r_sstepx & 0xFFFF;
a_tstepxfrac = r_tstepx & 0xFFFF;
}
a_ststepxwhole = skinwidth * ( r_tstepx >> 16 ) + ( r_sstepx >> 16 );
skinend = (pixel_t *)r_affinetridesc.pskin + r_affinetridesc.skinwidth * r_affinetridesc.skinheight;
return true;
}
/*
================
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 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
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
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
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 )
{
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 );
}
static 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 );
}
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 );
}
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
pixel_t src = *lptex;
*lpdest = vid.colormap[( src >> 3 ) | (( llight & 0x1F00 ) << 5 )] | ( src & 7 );
*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 );
}
/*
================
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;
{
d_sfrac = plefttop[2] & 0xFFFF;
d_tfrac = plefttop[3] & 0xFFFF;
}
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] );
{
d_pzbasestep = d_zwidth + ubasestep;
d_pzextrastep = d_pzbasestep + 1;
}
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;
{
d_sfracbasestep = ( r_sstepy + r_sstepx * ubasestep ) & 0xFFFF;
d_tfracbasestep = ( r_tstepy + r_tstepx * ubasestep ) & 0xFFFF;
}
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;
{
d_sfracextrastep = ( r_sstepy + r_sstepx * d_countextrastep ) & 0xFFFF;
d_tfracextrastep = ( r_tstepy + r_tstepx * d_countextrastep ) & 0xFFFF;
}
d_lightextrastep = d_lightbasestep + working_lstepx;
d_ziextrastep = d_zibasestep + r_zistepx;
{
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;
{
d_pzbasestep = d_zwidth + ubasestep;
d_pzextrastep = d_pzbasestep + 1;
}
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;
{
d_sfracbasestep = ( r_sstepy + r_sstepx * ubasestep ) & 0xFFFF;
d_tfracbasestep = ( r_tstepy + r_tstepx * ubasestep ) & 0xFFFF;
}
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;
{
d_sfracextrastep = ( r_sstepy + r_sstepx * d_countextrastep ) & 0xFFFF;
d_tfracextrastep = ( r_tstepy + r_tstepx * d_countextrastep ) & 0xFFFF;
}
d_lightextrastep = d_lightbasestep + working_lstepx;
d_ziextrastep = d_zibasestep + r_zistepx;
{
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];
}
Reference in New Issue View Git Blame Copy Permalink