static void d_polyse_init()
{
spans = new spanpackage_t[DPS_MAXSPANS + 1]; // one extra because of cache line pretouching
for (int kk = 0; kk < DPS_MAXSPANS + 1; kk++) spans[kk] = new spanpackage_t();
a_spans = (spanpackage_t[])spans;
}
/*
================
D_RasterizeAliasPolySmooth
================
*/
static void D_RasterizeAliasPolySmooth()
{
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
//
D_PolysetCalcGradients (render.r_affinetridesc.skinwidth);
//
// rasterize the polygon
//
//
// scan out the top (and possibly only) part of the left edge
//
d_pedgespanpackage = 0;
ystart = plefttop[1];
d_aspancount = plefttop[0] - prighttop[0];
d_ptex = (plefttop[2] >> 16) +
(plefttop[3] >> 16) * render.r_affinetridesc.skinwidth;
if (d_ptex > render.r_affinetridesc.pskin.Length)
d_ptex = d_ptex;
d_sfrac = plefttop[2] & 0xFFFF;
d_tfrac = plefttop[3] & 0xFFFF;
d_light = plefttop[4];
d_zi = plefttop[5];
d_pdest = ystart * screenwidth + plefttop[0];
d_pz = (int)(ystart * d_zwidth + plefttop[0]);
if (initialleftheight == 1)
{
d_edgespanpackage = a_spans[d_pedgespanpackage];
d_edgespanpackage.pdest = d_pdest;
d_edgespanpackage.pz = d_pz;
d_edgespanpackage.count = d_aspancount;
d_edgespanpackage.ptex = d_ptex;
d_edgespanpackage.sfrac = d_sfrac;
d_edgespanpackage.tfrac = d_tfrac;
// FIXME: need to clamp l, s, t, at both ends?
d_edgespanpackage.light = d_light;
d_edgespanpackage.zi = d_zi;
d_pedgespanpackage++;
}
else
{
D_PolysetSetUpForLineScan(plefttop[0], plefttop[1],
pleftbottom[0], pleftbottom[1]);
d_pzbasestep = (int)(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)
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) *
render.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) *
render.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;
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[1] - plefttop[1];
// TODO: make this a function; modularize this function in general
ystart = plefttop[1];
d_aspancount = plefttop[0] - prighttop[0];
d_ptex = (plefttop[2] >> 16) +
(plefttop[3] >> 16) * render.r_affinetridesc.skinwidth;
d_sfrac = 0;
d_tfrac = 0;
d_light = plefttop[4];
d_zi = plefttop[5];
d_pdest = ystart * screenwidth + plefttop[0];
d_pz = (int)(ystart * d_zwidth + plefttop[0]);
if (height == 1)
{
d_edgespanpackage = a_spans[d_pedgespanpackage];
d_edgespanpackage.pdest = d_pdest;
d_edgespanpackage.pz = d_pz;
d_edgespanpackage.count = d_aspancount;
d_edgespanpackage.ptex = d_ptex;
d_edgespanpackage.sfrac = d_sfrac;
d_edgespanpackage.tfrac = d_tfrac;
// FIXME: need to clamp l, s, t, at both ends?
d_edgespanpackage.light = d_light;
d_edgespanpackage.zi = d_zi;
d_pedgespanpackage++;
}
else
{
D_PolysetSetUpForLineScan(plefttop[0], plefttop[1],
pleftbottom[0], pleftbottom[1]);
d_pdestbasestep = screenwidth + ubasestep;
d_pdestextrastep = d_pdestbasestep + 1;
d_pzbasestep = (int)(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) *
render.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) *
render.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;
D_PolysetScanLeftEdge (height);
}
}
// scan out the top (and possibly only) part of the right edge, updating the
// count field
d_pedgespanpackage = 0;
D_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_PolysetDrawSpans8 (0);
// scan out the bottom part of the right edge, if it exists
if (pedgetable.numrightedges == 2)
{
int height;
int pstart;
pstart = initialrightheight;
a_spans[pstart].count = originalcount;
d_aspancount = prightbottom[0] - prighttop[0];
prighttop = prightbottom;
prightbottom = pedgetable.prightedgevert2;
height = prightbottom[1] - prighttop[1];
D_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_PolysetDrawSpans8 (pstart);
}
}
/*
===================
D_PolysetScanLeftEdge
====================
*/
static void D_PolysetScanLeftEdge(int height)
{
do
{
d_edgespanpackage = a_spans[d_pedgespanpackage];
d_edgespanpackage.pdest = d_pdest;
d_edgespanpackage.pz = d_pz;
d_edgespanpackage.count = d_aspancount;
d_edgespanpackage.ptex = d_ptex;
d_edgespanpackage.sfrac = d_sfrac;
d_edgespanpackage.tfrac = d_tfrac;
// FIXME: need to clamp l, s, t, at both ends?
d_edgespanpackage.light = d_light;
d_edgespanpackage.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) != 0)
{
d_ptex += render.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) != 0)
{
d_ptex += render.r_affinetridesc.skinwidth;
d_tfrac &= 0xFFFF;
}
d_light += d_lightbasestep;
d_zi += d_zibasestep;
}
} while (--height != 0);
}
