shithub: qk1

ref: 4c1435a0346ab111b5d9fec0abf5910952b7950e
dir: /d_polyse.c/

View raw version
#include "quakedef.h"

// !!! if this is changed, it must be changed in asm_draw.h too !!!
typedef struct {
	pixel_t *pdest, *ptex;
	uzint *pz;
	int count, sfrac, tfrac, zi, light[3];
} spanpackage_t;

typedef struct {
	finalvert_t *pleftedgevert0;
	finalvert_t *pleftedgevert1;
	finalvert_t *pleftedgevert2;
	finalvert_t *prightedgevert0;
	finalvert_t *prightedgevert1;
	finalvert_t *prightedgevert2;
	int isflattop;
	int numleftedges;
	int numrightedges;
} edgetable;

// TODO: put in span spilling to shrink list size
// !!! if this is changed, it must be changed in d_polysa.s too !!!
static spanpackage_t a_spans[MAXHEIGHT+1];
									// 1 extra for spanpackage that marks end

static finalvert_t r_p0, r_p1, r_p2;
static pixel_t *d_pcolormap;
static int d_xdenom;
static edgetable *pedgetable;

static edgetable edgetables[12] = {
	{&r_p0, &r_p2, nil,   &r_p0, &r_p1, &r_p2, 0, 1, 2},
	{&r_p1, &r_p0, &r_p2, &r_p1, &r_p2, nil,   0, 2, 1},
	{&r_p0, &r_p2, nil,   &r_p1, &r_p2, nil,   1, 1, 1},
	{&r_p1, &r_p0, nil,   &r_p1, &r_p2, &r_p0, 0, 1, 2},
	{&r_p0, &r_p2, &r_p1, &r_p0, &r_p1, nil,   0, 2, 1},
	{&r_p2, &r_p1, nil,   &r_p2, &r_p0, nil,   0, 1, 1},
	{&r_p2, &r_p1, nil,   &r_p2, &r_p0, &r_p1, 0, 1, 2},
	{&r_p2, &r_p1, &r_p0, &r_p2, &r_p0, nil,   0, 2, 1},
	{&r_p1, &r_p0, nil,   &r_p1, &r_p2, nil,   0, 1, 1},
	{&r_p2, &r_p1, nil,   &r_p0, &r_p1, nil,   1, 1, 1},
	{&r_p1, &r_p0, nil,   &r_p2, &r_p0, nil,   1, 1, 1},
	{&r_p0, &r_p2, nil,   &r_p0, &r_p1, nil,   0, 1, 1},
};

// FIXME: some of these can become statics
static int a_sstepxfrac, a_tstepxfrac, r_lstepx[3], a_ststepxwhole;
static int r_sstepx, r_tstepx, r_lstepy[3], r_sstepy, r_tstepy;
static int r_zistepx, r_zistepy;
static int d_aspancount, d_countextrastep;

static spanpackage_t *d_pedgespanpackage;
static int ystart;
static pixel_t *d_pdest, *d_ptex;
static uzint *d_pz;
static int d_sfrac, d_tfrac, d_light[3], d_zi;
static int d_ptexextrastep, d_sfracextrastep;
static int d_lightextrastep[3], d_pdestextrastep, d_tfracextrastep;
static int d_lightbasestep[3], d_pdestbasestep, d_ptexbasestep;
static int d_sfracbasestep, d_tfracbasestep;
static int d_ziextrastep, d_zibasestep;
static int d_pzextrastep, d_pzbasestep;
static int ubasestep, errorterm, erroradjustup, erroradjustdown;

typedef struct {
	int		quotient;
	int		remainder;
} adivtab_t;

static const adivtab_t adivtab[32*32] = {
#include "adivtab.h"
};

static pixel_t *skintable[MAX_LBM_HEIGHT];
static pixel_t *skinstart;
int skinwidth;

void D_PolysetDrawSpans8 (spanpackage_t *pspanpackage, pixel_t *colormap, byte alpha);
void D_PolysetCalcGradients (int skinwidth);
void D_DrawSubdiv (pixel_t *colormap);
void D_DrawNonSubdiv (void);
void D_PolysetRecursiveTriangle (finalvert_t *p1, finalvert_t *p2, finalvert_t *p3, byte alpha, int l[3]);
void D_PolysetSetEdgeTable (void);
void D_RasterizeAliasPolySmooth (void);
void D_PolysetScanLeftEdge (int height);

/*
================
D_PolysetDraw
================
*/
void D_PolysetDraw (pixel_t *colormap)
{
	if (r_affinetridesc.drawtype)
	{
		D_DrawSubdiv (colormap);
	}
	else
	{
		D_DrawNonSubdiv ();
	}
}


/*
================
D_PolysetDrawFinalVerts
================
*/
void D_PolysetDrawFinalVerts (finalvert_t *fv, int numverts, pixel_t *colormap, byte alpha)
{
	int		i, z;
	uzint	*zbuf;

	for(i = 0 ; i < numverts; i++, fv++){
		// valid triangle coordinates for filling can include the bottom and
		// right clip edges, due to the fill rule; these shouldn't be drawn
		if (fv->u < r_refdef.vrectright && fv->v < r_refdef.vrectbottom){
			z = fv->zi >> 16;
			zbuf = zspantable[fv->v] + fv->u;
			if(z >= *zbuf){
				pixel_t p = addlight(skintable[fv->t >> 16][fv->s >> 16], fv->l[0], fv->l[1], fv->l[2]);
				int n = d_scantable[fv->v] + fv->u;
				if(r_drawflags & DRAW_BLEND){
					d_viewbuffer[n] = blendalpha(p, d_viewbuffer[n], alpha);
				}else{
					d_viewbuffer[n] = p;
					*zbuf = z;
				}
			}
		}
	}
}


/*
================
D_DrawSubdiv
================
*/
void D_DrawSubdiv (pixel_t *colormap)
{
	mtriangle_t		*ptri;
	finalvert_t		*pfv, *index0, *index1, *index2;
	int				i;
	int				lnumtriangles;

	pfv = r_affinetridesc.pfinalverts;
	ptri = r_affinetridesc.ptriangles;
	lnumtriangles = r_affinetridesc.numtriangles;

	for (i=0 ; i<lnumtriangles ; i++)
	{
		index0 = pfv + ptri[i].vertindex[0];
		index1 = pfv + ptri[i].vertindex[1];
		index2 = pfv + ptri[i].vertindex[2];

		if (((index0->v - index1->v) *
			 (index0->u - index2->u) -
			 (index0->u - index1->u) *
			 (index0->v - index2->v)) >= 0)
		{
			continue;
		}

		d_pcolormap = colormap + (index0->l[0] & 0xFF00);

		if (ptri[i].facesfront)
		{
			D_PolysetRecursiveTriangle(index0, index1, index2, currententity->alpha, index0->l);
		}
		else
		{
			int		s0, s1, s2;

			s0 = index0->s;
			s1 = index1->s;
			s2 = index2->s;

			if (index0->flags & ALIAS_ONSEAM)
				index0->s += r_affinetridesc.seamfixupX16;
			if (index1->flags & ALIAS_ONSEAM)
				index1->s += r_affinetridesc.seamfixupX16;
			if (index2->flags & ALIAS_ONSEAM)
				index2->s += r_affinetridesc.seamfixupX16;

			D_PolysetRecursiveTriangle(index0, index1, index2, currententity->alpha, index0->l);

			index0->s = s0;
			index1->s = s1;
			index2->s = s2;
		}
	}
}


/*
================
D_DrawNonSubdiv
================
*/
void D_DrawNonSubdiv (void)
{
	mtriangle_t		*ptri;
	finalvert_t		*pfv, *index0, *index1, *index2;
	int				i;
	int				lnumtriangles;

	pfv = r_affinetridesc.pfinalverts;
	ptri = r_affinetridesc.ptriangles;
	lnumtriangles = r_affinetridesc.numtriangles;

	for (i=0 ; i<lnumtriangles ; i++, ptri++)
	{
		index0 = pfv + ptri->vertindex[0];
		index1 = pfv + ptri->vertindex[1];
		index2 = pfv + ptri->vertindex[2];

		d_xdenom = (index0->v - index1->v) * (index0->u - index2->u) -
				(index0->u - index1->u) * (index0->v - index2->v);

		if(d_xdenom >= 0)
			continue;

		memmove(r_p0.x, index0->x, sizeof(r_p0.x));
		memmove(r_p1.x, index1->x, sizeof(r_p1.x));
		memmove(r_p2.x, index2->x, sizeof(r_p2.x));

		if (!ptri->facesfront)
		{
			if (index0->flags & ALIAS_ONSEAM)
				r_p0.s += r_affinetridesc.seamfixupX16;
			if (index1->flags & ALIAS_ONSEAM)
				r_p1.s += r_affinetridesc.seamfixupX16;
			if (index2->flags & ALIAS_ONSEAM)
				r_p2.s += r_affinetridesc.seamfixupX16;
		}

		D_PolysetSetEdgeTable();
		D_RasterizeAliasPolySmooth();
	}
}


/*
================
D_PolysetRecursiveTriangle
================
*/
void D_PolysetRecursiveTriangle (finalvert_t *lp1, finalvert_t *lp2, finalvert_t *lp3, byte alpha, int l[3])
{
	finalvert_t new, *temp;
	uzint *zbuf;
	int d, z;

	d = lp2->u - lp1->u;
	if (d < -1 || d > 1)
		goto split;
	d = lp2->v - lp1->v;
	if (d < -1 || d > 1)
		goto split;

	d = lp3->u - lp2->u;
	if (d < -1 || d > 1)
		goto split2;
	d = lp3->v - lp2->v;
	if (d < -1 || d > 1)
		goto split2;

	d = lp1->u - lp3->u;
	if (d < -1 || d > 1)
		goto split3;
	d = lp1->v - lp3->v;
	if (d < -1 || d > 1)
	{
split3:
		temp = lp1;
		lp1 = lp3;
		lp3 = lp2;
		lp2 = temp;

		goto split;
	}

	return;			// entire tri is filled

split2:
	temp = lp1;
	lp1 = lp2;
	lp2 = lp3;
	lp3 = temp;

split:
	// split this edge
	new.u = (lp1->u + lp2->u) >> 1;
	new.v = (lp1->v + lp2->v) >> 1;
	new.s = (lp1->s + lp2->s) >> 1;
	new.t = (lp1->t + lp2->t) >> 1;
	new.zi = (lp1->zi + lp2->zi) >> 1;

	// draw the point if splitting a leading edge
	if (lp2->v > lp1->v)
		goto nodraw;
	if ((lp2->v == lp1->v) && (lp2->u < lp1->u))
		goto nodraw;

	z = new.zi >> 16;
	zbuf = zspantable[new.v] + new.u;
	if (z >= *zbuf){
		pixel_t p = addlight(skintable[new.t >> 16][new.s >> 16], l[0], l[1], l[2]);
		int n = d_scantable[new.v] + new.u;
		if(r_drawflags & DRAW_BLEND){
			d_viewbuffer[n] = blendalpha(p, d_viewbuffer[n], alpha);
		}else{
			d_viewbuffer[n] = p;
			*zbuf = z;
		}
	}

nodraw:
	// recursively continue
	D_PolysetRecursiveTriangle(lp3, lp1, &new, alpha, l);
	D_PolysetRecursiveTriangle(lp3, &new, lp2, alpha, l);
}


/*
================
D_PolysetUpdateTables
================
*/
void D_PolysetUpdateTables (void)
{
	int		i;
	pixel_t	*s;

	if (r_affinetridesc.skinwidth != skinwidth ||
		r_affinetridesc.pskin != skinstart)
	{
		skinwidth = r_affinetridesc.skinwidth;
		skinstart = r_affinetridesc.pskin;
		s = skinstart;
		for (i=0 ; i<MAX_LBM_HEIGHT ; i++, s+=skinwidth)
			skintable[i] = s;
	}
}

/*
===================
D_PolysetScanLeftEdge
====================
*/
void D_PolysetScanLeftEdge (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[0] = d_light[0];
		d_pedgespanpackage->light[1] = d_light[1];
		d_pedgespanpackage->light[2] = d_light[2];
		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[0] += d_lightextrastep[0];
			d_light[1] += d_lightextrastep[1];
			d_light[2] += d_lightextrastep[2];
			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[0] += d_lightbasestep[0];
			d_light[1] += d_lightbasestep[1];
			d_light[2] += d_lightbasestep[2];
			d_zi += d_zibasestep;
		}
	} while (--height);
}


/*
===================
D_PolysetSetUpForLineScan
====================
*/
void D_PolysetSetUpForLineScan(fixed8_t startvertu, fixed8_t startvertv,
		fixed8_t endvertu, fixed8_t endvertv)
{
	double		dm, dn;
	int			tm, tn, n;

	// TODO: implement x86 version

	errorterm = -1;

	tm = endvertu - startvertu;
	tn = endvertv - startvertv;

	if (((tm <= 16) && (tm >= -15)) &&
		((tn <= 16) && (tn >= -15)))
	{
		n = ((tm+15) << 5) + (tn+15);
		ubasestep = adivtab[n].quotient;
		erroradjustup = adivtab[n].remainder;
		erroradjustdown = tn;
	}
	else
	{
		dm = (double)tm;
		dn = (double)tn;

		FloorDivMod (dm, dn, &ubasestep, &erroradjustup);

		erroradjustdown = dn;
	}
}


/*
================
D_PolysetCalcGradients
================
*/
void D_PolysetCalcGradients (int skinwidth)
{
	float	xstepdenominv, ystepdenominv, t0, t1;
	float	p0v_minus_p2v, p1v_minus_p2v, p0u_minus_p2u, p1u_minus_p2u;
	int i;

	p0u_minus_p2u = r_p0.u - r_p2.u;
	p0v_minus_p2v = r_p0.v - r_p2.v;
	p1u_minus_p2u = r_p1.u - r_p2.u;
	p1v_minus_p2v = r_p1.v - r_p2.v;

	xstepdenominv = 1.0 / (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
	for(i = 0; i < 3; i++){
		t0 = r_p0.l[i] - r_p2.l[i];
		t1 = r_p1.l[i] - r_p2.l[i];
		r_lstepx[i] = (int)ceil((t1 * p0v_minus_p2v - t0 * p1v_minus_p2v) * xstepdenominv);
		r_lstepy[i] = (int)ceil((t1 * p0u_minus_p2u - t0 * p1u_minus_p2u) * ystepdenominv);
	}

	t0 = r_p0.s - r_p2.s;
	t1 = r_p1.s - r_p2.s;
	r_sstepx = (int)((t1 * p0v_minus_p2v - t0 * p1v_minus_p2v) * xstepdenominv);
	r_sstepy = (int)((t1 * p0u_minus_p2u - t0 * p1u_minus_p2u) * ystepdenominv);

	t0 = r_p0.t - r_p2.t;
	t1 = r_p1.t - r_p2.t;
	r_tstepx = (int)((t1 * p0v_minus_p2v - t0 * p1v_minus_p2v) * xstepdenominv);
	r_tstepy = (int)((t1 * p0u_minus_p2u - t0 * p1u_minus_p2u) * ystepdenominv);

	t0 = r_p0.zi - r_p2.zi;
	t1 = r_p1.zi - r_p2.zi;
	r_zistepx = (int)((t1 * p0v_minus_p2v - t0 * p1v_minus_p2v) * xstepdenominv);
	r_zistepy = (int)((t1 * p0u_minus_p2u - t0 * p1u_minus_p2u) * ystepdenominv);

	a_sstepxfrac = r_sstepx & 0xFFFF;
	a_tstepxfrac = r_tstepx & 0xFFFF;
	a_ststepxwhole = skinwidth * (r_tstepx >> 16) + (r_sstepx >> 16);
}

/*
================
D_PolysetDrawSpans8
================
*/
void D_PolysetDrawSpans8 (spanpackage_t *pspanpackage, pixel_t *colormap, byte alpha)
{
	int		lcount;
	pixel_t	*lpdest, *lptex;
	int		lsfrac, ltfrac;
	int		llight[3];
	int		lzi;
	uzint	*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[0] = pspanpackage->light[0];
			llight[1] = pspanpackage->light[1];
			llight[2] = pspanpackage->light[2];
			lzi = pspanpackage->zi;

			do
			{
				if ((lzi >> 16) >= *lpz){
					pixel_t p = addlight(*lptex, llight[0], llight[1], llight[2]);
					if(r_drawflags & DRAW_BLEND){
						*lpdest = blendalpha(
							p,
							*lpdest,
							alpha
						);
					}else{
						*lpdest = p;
						// gel mapping	*lpdest = gelmap[*lpdest];
						*lpz = lzi >> 16;
					}
				}
				lpdest++;
				lzi += r_zistepx;
				lpz++;
				llight[0] += r_lstepx[0];
				llight[1] += r_lstepx[1];
				llight[2] += r_lstepx[2];
				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 != Q_MININT);
}

/*
================
D_RasterizeAliasPolySmooth
================
*/
void D_RasterizeAliasPolySmooth (void)
{
	int initialleftheight, initialrightheight;
	finalvert_t *plefttop, *prighttop, *pleftbottom, *prightbottom;
	int working_lstepx[3], originalcount;

	plefttop = pedgetable->pleftedgevert0;
	prighttop = pedgetable->prightedgevert0;

	pleftbottom = pedgetable->pleftedgevert1;
	prightbottom = pedgetable->prightedgevert1;

	initialleftheight = pleftbottom->v - plefttop->v;
	initialrightheight = prightbottom->v - prighttop->v;
	assert(initialleftheight <= MAXHEIGHT);

	// set the s, t, and light gradients, which are consistent across the triangle
	// because being a triangle, things are affine
	D_PolysetCalcGradients (r_affinetridesc.skinwidth);

	// rasterize the polygon
	// scan out the top (and possibly only) part of the left edge
	d_pedgespanpackage = a_spans;

	ystart = plefttop->v;
	d_aspancount = plefttop->u - prighttop->u;

	d_ptex = r_affinetridesc.pskin + (plefttop->s >> 16) +
			(plefttop->t >> 16) * r_affinetridesc.skinwidth;
	d_sfrac = plefttop->s & 0xFFFF;
	d_tfrac = plefttop->t & 0xFFFF;
	d_zi = plefttop->zi;
	d_light[0] = plefttop->l[0];
	d_light[1] = plefttop->l[1];
	d_light[2] = plefttop->l[2];

	d_pdest = d_viewbuffer + ystart * screenwidth + plefttop->u;
	d_pz = d_pzbuffer + ystart * d_zwidth + plefttop->u;

	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[0] = d_light[0];
		d_pedgespanpackage->light[1] = d_light[1];
		d_pedgespanpackage->light[2] = d_light[2];
		d_pedgespanpackage->zi = d_zi;

		d_pedgespanpackage++;
	}
	else
	{
		D_PolysetSetUpForLineScan(plefttop->u, plefttop->v,
							  pleftbottom->u, pleftbottom->v);

		d_pzbasestep = d_zwidth + ubasestep;
		d_pzextrastep = d_pzbasestep + 1;
		d_pdestbasestep = 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)
		working_lstepx[0] = r_lstepx[0];
		working_lstepx[1] = r_lstepx[1];
		working_lstepx[2] = r_lstepx[2];
		if(ubasestep < 0){
			working_lstepx[0] -= 1;
			working_lstepx[1] -= 1;
			working_lstepx[2] -= 1;
		}

		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[0] = r_lstepy[0] + working_lstepx[0] * ubasestep;
		d_lightbasestep[1] = r_lstepy[1] + working_lstepx[1] * ubasestep;
		d_lightbasestep[2] = r_lstepy[2] + working_lstepx[2] * 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[0] = d_lightbasestep[0] + working_lstepx[0];
		d_lightextrastep[1] = d_lightbasestep[1] + working_lstepx[1];
		d_lightextrastep[2] = d_lightbasestep[2] + working_lstepx[2];
		d_ziextrastep = d_zibasestep + r_zistepx;

		D_PolysetScanLeftEdge (initialleftheight);
	}

	// 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->v - plefttop->v;

		// TODO: make this a function; modularize this function in general

		ystart = plefttop->v;
		d_aspancount = plefttop->u - prighttop->u;
		d_ptex = r_affinetridesc.pskin + (plefttop->s >> 16) +
				(plefttop->t >> 16) * r_affinetridesc.skinwidth;
		d_sfrac = 0;
		d_tfrac = 0;
		d_zi = plefttop->zi;
		d_light[0] = plefttop->l[0];
		d_light[1] = plefttop->l[1];
		d_light[2] = plefttop->l[2];

		d_pdest = d_viewbuffer + ystart * screenwidth + plefttop->u;
		d_pz = d_pzbuffer + ystart * d_zwidth + plefttop->u;

		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[0] = d_light[0];
			d_pedgespanpackage->light[1] = d_light[1];
			d_pedgespanpackage->light[2] = d_light[2];
			d_pedgespanpackage->zi = d_zi;
		}
		else
		{
			D_PolysetSetUpForLineScan(plefttop->u, plefttop->v,
								  pleftbottom->u, pleftbottom->v);

			d_pdestbasestep = screenwidth + ubasestep;
			d_pdestextrastep = d_pdestbasestep + 1;
			d_pzbasestep = d_zwidth + ubasestep;
			d_pzextrastep = d_pzbasestep + 1;

			if (ubasestep < 0){
				working_lstepx[0] = r_lstepx[0] - 1;
				working_lstepx[1] = r_lstepx[1] - 1;
				working_lstepx[2] = r_lstepx[2] - 1;
			}else{
				working_lstepx[0] = r_lstepx[0];
				working_lstepx[1] = r_lstepx[1];
				working_lstepx[2] = r_lstepx[2];
			}

			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[0] = r_lstepy[0] + working_lstepx[0] * ubasestep;
			d_lightbasestep[1] = r_lstepy[1] + working_lstepx[1] * ubasestep;
			d_lightbasestep[2] = r_lstepy[2] + working_lstepx[2] * 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[0] = d_lightbasestep[0] + working_lstepx[0];
			d_lightextrastep[1] = d_lightbasestep[1] + working_lstepx[1];
			d_lightextrastep[2] = d_lightbasestep[2] + working_lstepx[2];
			d_ziextrastep = d_zibasestep + r_zistepx;

			D_PolysetScanLeftEdge (height);
		}
	}

	// scan out the top (and possibly only) part of the right edge, updating the
	// count field
	d_pedgespanpackage = a_spans;

	D_PolysetSetUpForLineScan(prighttop->u, prighttop->v,
						  prightbottom->u, prightbottom->v);
	d_aspancount = 0;
	d_countextrastep = ubasestep + 1;
	originalcount = a_spans[initialrightheight].count;
	a_spans[initialrightheight].count = Q_MININT; // mark end of the spanpackages
	D_PolysetDrawSpans8 (a_spans, currententity->colormap, currententity->alpha);

	// 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->u - prighttop->u;

		prighttop = prightbottom;
		prightbottom = pedgetable->prightedgevert2;

		height = prightbottom->v - prighttop->v;

		D_PolysetSetUpForLineScan(prighttop->u, prighttop->v,
							  prightbottom->u, prightbottom->v);

		d_countextrastep = ubasestep + 1;
		a_spans[initialrightheight + height].count = Q_MININT;
											// mark end of the spanpackages
		D_PolysetDrawSpans8 (pstart, currententity->colormap, currententity->alpha);
	}
}


/*
================
D_PolysetSetEdgeTable
================
*/
void D_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.v >= r_p1.v){
		if(r_p0.v == r_p1.v){
			pedgetable = &edgetables[r_p0.v < r_p2.v ? 2 : 5];
			return;
		}
		edgetableindex = 1;
	}

	if(r_p0.v == r_p2.v){
		pedgetable = &edgetables[edgetableindex ? 8 : 9];
		return;
	}
	if(r_p1.v == r_p2.v){
		pedgetable = &edgetables[edgetableindex ? 10 : 11];
		return;
	}

	if(r_p0.v > r_p2.v)
		edgetableindex += 2;
	if(r_p1.v > r_p2.v)
		edgetableindex += 4;

	pedgetable = &edgetables[edgetableindex];
}