/* Copyright (C) 1996-1997 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) /* There are three ways to draw a triangle, reflecting the three possible values of trivial accept. accept 0 draws spanned triangles. The triangles are clipped to the screen before the spans are generated. Hrm. accept 1 draws triangle spans. There's no clipping to the screen except the 8 bounding box points. accept 3 compleatly on screen. Triangles are not spanned but recursivly subdivided to fill. 0 is used on meshes that arn't fully on screen 1 is used for near meshes 3 is used for more distant meshes. Note that the C routines cover all methods as does the asm. However, the asm doesn't support any blending or any depth other than 8bit. C functions ending C are for C drawing only and shouldn't branch into the asm. Functions ending ASM will never be used in the pure C code. Texture coords are 16.16, not 0-1. Alternate skins thus need prescaling, but can be over-sized without too many changes. */ //changes include stvertexes now being seperatly number from the triangles. //this allows q2 models to be supported. #include "quakedef.h" #include "r_local.h" #include "d_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; qbyte *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; int r_p0[6], r_p1[6], r_p2[6]; qbyte *d_pcolormap; int d_aflatcolor; 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; qbyte *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; typedef struct { int quotient; int remainder; } adivtab_t; static adivtab_t adivtab[32*32] = { #include "adivtab.h" }; qbyte *skintable[MAX_LBM_HEIGHT]; int skinwidth; qbyte *skinstart; qbyte transfactor; qbyte transbackfac; #if id386 #define D_PolysetScanLeftEdge D_PolysetScanLeftEdge #define D_PolysetScanLeftEdge32 D_PolysetScanLeftEdgeC void D_PolysetScanLeftEdge (int height); #else #define D_PolysetScanLeftEdge D_PolysetScanLeftEdgeC #define D_PolysetScanLeftEdge32 D_PolysetScanLeftEdgeC #define D_PolysetSetUpForLineScan D_PolysetSetUpForLineScanC #define D_PolysetSetUpForLineScan32 D_PolysetSetUpForLineScanC #endif void D_PolysetDrawSpans8 (spanpackage_t *pspanpackage); void D_PolysetDrawSpans8C (spanpackage_t *pspanpackage); void D_PolysetCalcGradientsC (int skinwidth); void D_PolysetCalcGradientsAsm (int skinwidth); void D_DrawSubdiv (void); void D_DrawSubdivC (void); void D_DrawNonSubdiv (void); void D_DrawNonSubdivC (void); void D_DrawNonSubdiv32C (void); void D_PolysetRecursiveTriangleC (int *p1, int *p2, int *p3); void D_PolysetSetEdgeTable (void); void D_RasterizeAliasPolySmooth8Asm (void); void D_RasterizeAliasPolySmooth8C (void); void D_PolysetScanLeftEdgeC (int height); void D_PolysetSetUpForLineScan(fixed8_t startvertu, fixed8_t startvertv, fixed8_t endvertu, fixed8_t endvertv); void D_PolysetDrawFinalVertsTrans (finalvert_t *fv, int numverts) { int i, z; short *zbuf; for (i=0 ; iv[0] < r_refdef.vrectright) && (fv->v[1] < r_refdef.vrectbottom)) { z = fv->v[5]>>16; zbuf = zspantable[fv->v[1]] + fv->v[0]; if (z >= *zbuf) { int pix; *zbuf = z; pix = skintable[fv->v[3]>>16][fv->v[2]>>16]; pix = ((qbyte *)acolormap)[pix + (fv->v[4] & 0xFF00) ]; d_viewbuffer[d_scantable[fv->v[1]] + fv->v[0]] = Trans(d_viewbuffer[d_scantable[fv->v[1]] + fv->v[0]], (unsigned char)pix); } } } } void D_PolysetDrawFinalVerts32Trans (finalvert_t *fv, int numverts) { int i, z; short *zbuf; for (i=0 ; iv[0] < r_refdef.vrectright) && (fv->v[1] < r_refdef.vrectbottom)) { z = fv->v[5]>>16; if (fv->v[1] < 0 || fv->v[0] < 0) //FIXME: temp continue; zbuf = zspantable[fv->v[1]] + fv->v[0]; if (z >= *zbuf) { qbyte *pix; qbyte *out; *zbuf = z; pix = (qbyte *)(((unsigned int *)((unsigned int **)skintable)[fv->v[3]>>16]) + (fv->v[2]>>16)); // pix = ((qbyte *)acolormap)[pix + (fv->v[4] & 0xFF00) ]; out = d_viewbuffer + ((d_scantable[fv->v[1]] + fv->v[0])<<2); out[0] = (out[0]*transbackfac + pix[0] * transfactor)/255; out[1] = (out[1]*transbackfac + pix[1] * transfactor)/255; out[2] = (out[2]*transbackfac + pix[2] * transfactor)/255; } } } } void D_PolysetDrawFinalVerts32 (finalvert_t *fv, int numverts) { int i, z; short *zbuf; for (i=0 ; iv[0] < r_refdef.vrectright) && (fv->v[1] < r_refdef.vrectbottom)) { z = fv->v[5]>>16; if (fv->v[1] < 0 || fv->v[0] < 0) //FIXME: temp continue; zbuf = zspantable[fv->v[1]] + fv->v[0]; if (z >= *zbuf) { int pix; *zbuf = z; pix = ((unsigned int *)((unsigned int **)skintable)[fv->v[3]>>16])[fv->v[2]>>16]; // pix = ((qbyte *)acolormap)[pix + (fv->v[4] & 0xFF00) ]; ((unsigned int *)d_viewbuffer)[d_scantable[fv->v[1]] + fv->v[0]] = pix; } } } } void D_PolysetRecursiveTriangleTrans (int *lp1, int *lp2, int *lp3) { int *temp; int d; int new[6]; int z; short *zbuf; d = lp2[0] - lp1[0]; if (d < -1 || d > 1) goto split; d = lp2[1] - lp1[1]; if (d < -1 || d > 1) goto split; d = lp3[0] - lp2[0]; if (d < -1 || d > 1) goto split2; d = lp3[1] - lp2[1]; if (d < -1 || d > 1) goto split2; d = lp1[0] - lp3[0]; if (d < -1 || d > 1) goto split3; d = lp1[1] - lp3[1]; 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[0] = (lp1[0] + lp2[0]) >> 1; new[1] = (lp1[1] + lp2[1]) >> 1; new[2] = (lp1[2] + lp2[2]) >> 1; new[3] = (lp1[3] + lp2[3]) >> 1; new[5] = (lp1[5] + lp2[5]) >> 1; // draw the point if splitting a leading edge if (lp2[1] > lp1[1]) goto nodraw; if ((lp2[1] == lp1[1]) && (lp2[0] < lp1[0])) goto nodraw; z = new[5]>>16; zbuf = zspantable[new[1]] + new[0]; if (z >= *zbuf) { int pix; *zbuf = z; pix = d_pcolormap[skintable[new[3]>>16][new[2]>>16]]; d_viewbuffer[d_scantable[new[1]] + new[0]] = Trans(d_viewbuffer[d_scantable[new[1]] + new[0]], (unsigned char)pix); } nodraw: // recursively continue D_PolysetRecursiveTriangleTrans (lp3, lp1, new); D_PolysetRecursiveTriangleTrans (lp3, new, lp2); } void D_PolysetRecursiveTriangle32Trans (int *lp1, int *lp2, int *lp3) { int *temp; int d; int new[6]; int z; short *zbuf; d = lp2[0] - lp1[0]; if (d < -1 || d > 1) goto split; d = lp2[1] - lp1[1]; if (d < -1 || d > 1) goto split; d = lp3[0] - lp2[0]; if (d < -1 || d > 1) goto split2; d = lp3[1] - lp2[1]; if (d < -1 || d > 1) goto split2; d = lp1[0] - lp3[0]; if (d < -1 || d > 1) goto split3; d = lp1[1] - lp3[1]; 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[0] = (lp1[0] + lp2[0]) >> 1; new[1] = (lp1[1] + lp2[1]) >> 1; new[2] = (lp1[2] + lp2[2]) >> 1; new[3] = (lp1[3] + lp2[3]) >> 1; new[5] = (lp1[5] + lp2[5]) >> 1; // draw the point if splitting a leading edge if (lp2[1] > lp1[1]) goto nodraw; if ((lp2[1] == lp1[1]) && (lp2[0] < lp1[0])) goto nodraw; z = new[5]>>16; if ((new[1]>=vid.height|| new[1] < 0 || new[0] >= vid.width || new[0]<0)) //fixme: temp return; zbuf = zspantable[new[1]] + new[0]; if (z >= *zbuf) { int pix; *zbuf = z; pix = ((unsigned int *)((unsigned int **)skintable)[new[3]>>16])[new[2]>>16]; // pix = d_pcolormap[skintable[new[3]>>16][new[2]>>16]]; ((unsigned int *)d_viewbuffer)[d_scantable[new[1]] + new[0]] = pix;//d_8to32table[pix]; } nodraw: // recursively continue D_PolysetRecursiveTriangle32Trans (lp3, lp1, new); D_PolysetRecursiveTriangle32Trans (lp3, new, lp2); } void D_PolysetRecursiveTriangle16 (int *lp1, int *lp2, int *lp3) { int *temp; int d; int new[6]; int z; short *zbuf; d = lp2[0] - lp1[0]; if (d < -1 || d > 1) goto split; d = lp2[1] - lp1[1]; if (d < -1 || d > 1) goto split; d = lp3[0] - lp2[0]; if (d < -1 || d > 1) goto split2; d = lp3[1] - lp2[1]; if (d < -1 || d > 1) goto split2; d = lp1[0] - lp3[0]; if (d < -1 || d > 1) goto split3; d = lp1[1] - lp3[1]; 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[0] = (lp1[0] + lp2[0]) >> 1; new[1] = (lp1[1] + lp2[1]) >> 1; new[2] = (lp1[2] + lp2[2]) >> 1; new[3] = (lp1[3] + lp2[3]) >> 1; new[5] = (lp1[5] + lp2[5]) >> 1; // draw the point if splitting a leading edge if (lp2[1] > lp1[1]) goto nodraw; if ((lp2[1] == lp1[1]) && (lp2[0] < lp1[0])) goto nodraw; z = new[5]>>16; if ((new[1]>=vid.height|| new[1] < 0 || new[0] >= vid.width || new[0]<0)) //fixme: temp return; zbuf = zspantable[new[1]] + new[0]; if (z >= *zbuf) { int pix; *zbuf = z; pix = d_pcolormap[skintable[new[3]>>16][new[2]>>16]]; ((unsigned short *)d_viewbuffer)[d_scantable[new[1]] + new[0]] = pix;//d_8to32table[pix]; } nodraw: // recursively continue D_PolysetRecursiveTriangle16 (lp3, lp1, new); D_PolysetRecursiveTriangle16 (lp3, new, lp2); } void D_PolysetDrawSpans8Trans (spanpackage_t *pspanpackage) { int lcount; qbyte *lpdest; qbyte *lptex; int lsfrac, ltfrac; int llight; int lzi; short *lpz; if (d_aspancount<0) return; 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) { *lpdest = Trans(*lpdest, ((qbyte *)acolormap)[*lptex + (llight & 0xFF00)]); // gel mapping *lpdest = gelmap[*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 D_PolysetDrawSpans32Trans (spanpackage_t *pspanpackage) { int lcount; qbyte *lpdest; qbyte *lptex; int tex; 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; tex = pspanpackage->ptex-(qbyte *)r_affinetridesc.pskin; lpz = pspanpackage->pz; lsfrac = pspanpackage->sfrac; ltfrac = pspanpackage->tfrac; llight = pspanpackage->light; lzi = pspanpackage->zi; do { if ((lzi >> 16) >= *lpz) { extern qbyte gammatable[256]; // ((qbyte *)acolormap)[*lptex + (llight & 0xFF00)]; lptex = (qbyte *)((unsigned int *)r_affinetridesc.pskin+tex); #if 0 lpdest[0] = ((qbyte *)acolormap)[lptex[0] + (llight & 0xFF00)]; lpdest[1] = ((qbyte *)acolormap)[lptex[1] + (llight & 0xFF00)]; lpdest[2] = ((qbyte *)acolormap)[lptex[2] + (llight & 0xFF00)]; #else lpdest[0] = (lpdest[0]*transbackfac + gammatable[(lptex[0]*(llight&0x3FFF))/(0x3FFF)]*transfactor)/255; lpdest[1] = (lpdest[1]*transbackfac + gammatable[(lptex[1]*(llight&0x3FFF))/(0x3FFF)]*transfactor)/255; lpdest[2] = (lpdest[2]*transbackfac + gammatable[(lptex[2]*(llight&0x3FFF))/(0x3FFF)]*transfactor)/255; #endif *lpz = lzi >> 16; } lpdest+=4; lzi += r_zistepx; lpz++; llight += r_lstepx; tex += a_ststepxwhole; lsfrac += a_sstepxfrac; tex += lsfrac >> 16; lsfrac &= 0xFFFF; ltfrac += a_tstepxfrac; if (ltfrac & 0x10000) { tex += r_affinetridesc.skinwidth; ltfrac &= 0xFFFF; } } while (--lcount); } pspanpackage++; } while (pspanpackage->count != -999999); } void D_PolysetDrawSpans32 (spanpackage_t *pspanpackage) { int lcount; qbyte *lpdest; qbyte *lptex; int tex; 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; tex = pspanpackage->ptex-(qbyte *)r_affinetridesc.pskin; lpz = pspanpackage->pz; lsfrac = pspanpackage->sfrac; ltfrac = pspanpackage->tfrac; llight = pspanpackage->light; lzi = pspanpackage->zi; do { if ((lzi >> 16) >= *lpz) { extern qbyte gammatable[256]; // ((qbyte *)acolormap)[*lptex + (llight & 0xFF00)]; lptex = (qbyte *)((unsigned int *)r_affinetridesc.pskin+tex); #if 0 lpdest[0] = ((qbyte *)acolormap)[lptex[0] + (llight & 0xFF00)]; lpdest[1] = ((qbyte *)acolormap)[lptex[1] + (llight & 0xFF00)]; lpdest[2] = ((qbyte *)acolormap)[lptex[2] + (llight & 0xFF00)]; #else lpdest[0] = gammatable[(lptex[0]*(llight&0x3FFF))/(0x3FFF)]; lpdest[1] = gammatable[(lptex[1]*(llight&0x3FFF))/(0x3FFF)]; lpdest[2] = gammatable[(lptex[2]*(llight&0x3FFF))/(0x3FFF)]; #endif *lpz = lzi >> 16; } lpdest+=4; lzi += r_zistepx; lpz++; llight += r_lstepx; tex += a_ststepxwhole; lsfrac += a_sstepxfrac; tex += lsfrac >> 16; lsfrac &= 0xFFFF; ltfrac += a_tstepxfrac; if (ltfrac & 0x10000) { tex += r_affinetridesc.skinwidth; ltfrac &= 0xFFFF; } } while (--lcount); } pspanpackage++; } while (pspanpackage->count != -999999); } void D_PolysetDrawSpans16 (spanpackage_t *pspanpackage) { int lcount; unsigned short *lpdest; qbyte *lptex; int tex; 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; tex = pspanpackage->ptex-(qbyte *)r_affinetridesc.pskin; lpz = pspanpackage->pz; lsfrac = pspanpackage->sfrac; ltfrac = pspanpackage->tfrac; llight = pspanpackage->light; lzi = pspanpackage->zi; do { if ((lzi >> 16) >= *lpz) { // ((qbyte *)acolormap)[*lptex + (llight & 0xFF00)]; lptex = (qbyte *)((unsigned char *)r_affinetridesc.pskin+tex); lpdest[0] = ((unsigned short *)acolormap)[*lptex + (llight & 0xFF00)]; *lpz = lzi >> 16; } lpdest++; lzi += r_zistepx; lpz++; llight += r_lstepx; tex += a_ststepxwhole; lsfrac += a_sstepxfrac; tex += lsfrac >> 16; lsfrac &= 0xFFFF; ltfrac += a_tstepxfrac; if (ltfrac & 0x10000) { tex += r_affinetridesc.skinwidth; ltfrac &= 0xFFFF; } } while (--lcount); } pspanpackage++; } while (pspanpackage->count != -999999); } /* ================ D_PolysetFillSpans8 ================ */ void D_PolysetFillSpans8Trans (spanpackage_t *pspanpackage) { int color; // FIXME: do z buffering color = d_aflatcolor++; while (1) { int lcount; qbyte *lpdest; lcount = pspanpackage->count; if (lcount == -1) return; if (lcount) { lpdest = pspanpackage->pdest; do { *lpdest = Trans(*lpdest, (unsigned char)color); lpdest++; } while (--lcount); } pspanpackage++; } } void D_RasterizeAliasPolySmoothC (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 // D_PolysetCalcGradientsC (r_affinetridesc.skinwidth); //D_PolysetCalcGradients32 but not with asm possibilities // // rasterize the polygon // // // scan out the top (and possibly only) part of the left edge // D_PolysetSetUpForLineScan(plefttop[0], plefttop[1], pleftbottom[0], pleftbottom[1]); d_pedgespanpackage = a_spans; ystart = plefttop[1]; d_aspancount = plefttop[0] - prighttop[0]; d_ptex = (qbyte *)r_affinetridesc.pskin + (plefttop[2] >> 16) + (plefttop[3] >> 16) * r_affinetridesc.skinwidth; d_sfrac = plefttop[2] & 0xFFFF; d_tfrac = plefttop[3] & 0xFFFF; d_pzbasestep = d_zwidth + ubasestep; d_pzextrastep = d_pzbasestep + 1; d_light = plefttop[4]; d_zi = plefttop[5]; d_pdestbasestep = (screenwidth + ubasestep)*r_pixbytes; d_pdestextrastep = d_pdestbasestep + r_pixbytes; d_pdest = (qbyte *)d_viewbuffer + (ystart * screenwidth + plefttop[0])*r_pixbytes; d_pz = d_pzbuffer + ystart * d_zwidth + plefttop[0]; // 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; D_PolysetScanLeftEdgeC (initialleftheight); // // scan out the bottom part of the left edge, if it exists // if (pedgetable->numleftedges == 2) { int height; plefttop = pleftbottom; pleftbottom = pedgetable->pleftedgevert2; D_PolysetSetUpForLineScan(plefttop[0], plefttop[1], pleftbottom[0], pleftbottom[1]); 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 = (qbyte *)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_pdestbasestep = (screenwidth + ubasestep)*r_pixbytes; d_pdestextrastep = d_pdestbasestep + r_pixbytes; d_pdest = (qbyte *)d_viewbuffer + (ystart * screenwidth + plefttop[0])*r_pixbytes; d_pzbasestep = d_zwidth + ubasestep; d_pzextrastep = d_pzbasestep + 1; d_pz = d_pzbuffer + ystart * d_zwidth + plefttop[0]; 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; D_PolysetScanLeftEdgeC (height); } // scan out the top (and possibly only) part of the right edge, updating the // count field d_pedgespanpackage = a_spans; 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 if (r_pixbytes == 4) { if (transbackfac) D_PolysetDrawSpans32Trans (a_spans); else D_PolysetDrawSpans32 (a_spans); } else if (r_pixbytes == 2) D_PolysetDrawSpans16 (a_spans); else { if (transbackfac) D_PolysetDrawSpans8Trans (a_spans); else D_PolysetDrawSpans8C (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]; 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 if (r_pixbytes == 4) { if (transbackfac) D_PolysetDrawSpans32Trans (pstart); else D_PolysetDrawSpans32 (pstart); } else if (r_pixbytes == 2) D_PolysetDrawSpans16 (pstart); else { if (transbackfac) D_PolysetDrawSpans8Trans (pstart); else D_PolysetDrawSpans8C (pstart); } } } void D_PolysetDraw32 (void) { spanpackage_t spans[DPS_MAXSPANS + 1 + ((CACHE_SIZE - 1) / sizeof(spanpackage_t)) + 1]; // one extra because of cache line pretouching a_spans = (spanpackage_t *) (((long)&spans[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1)); if (r_affinetridesc.drawtype) { D_DrawSubdivC (); } else { D_DrawNonSubdiv32C (); } } void D_PolysetDraw16 (void) { spanpackage_t spans[DPS_MAXSPANS + 1 + ((CACHE_SIZE - 1) / sizeof(spanpackage_t)) + 1]; // one extra because of cache line pretouching a_spans = (spanpackage_t *) (((long)&spans[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1)); /* if (r_affinetridesc.drawtype) { D_DrawNonSubdiv (); //hrm. } else */ { D_DrawNonSubdivC (); } } /* ================ D_PolysetDraw ================ */ void D_PolysetDrawC (void) { spanpackage_t spans[DPS_MAXSPANS + 1 + ((CACHE_SIZE - 1) / sizeof(spanpackage_t)) + 1]; // one extra because of cache line pretouching a_spans = (spanpackage_t *) (((long)&spans[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1)); if (r_affinetridesc.drawtype) { D_DrawSubdivC (); } else { D_DrawNonSubdivC (); } } /* ================ D_PolysetDrawFinalVerts ================ */ void D_PolysetDrawFinalVertsC (finalvert_t *fv, int numverts) { int i, z; short *zbuf; for (i=0 ; iv[0] < r_refdef.vrectright) && (fv->v[1] < r_refdef.vrectbottom)) { z = fv->v[5]>>16; zbuf = zspantable[fv->v[1]] + fv->v[0]; if (z >= *zbuf) { int pix; *zbuf = z; pix = skintable[fv->v[3]>>16][fv->v[2]>>16]; pix = ((qbyte *)acolormap)[pix + (fv->v[4] & 0xFF00) ]; d_viewbuffer[d_scantable[fv->v[1]] + fv->v[0]] = pix; } } } } /* ================ D_DrawSubdiv ================ recursivly draws triangles (as opposed to spanned triangles). used on distant models as it's cheaper than generating spans on small models. */ void D_DrawSubdivC (void) { mtriangle_t *ptri; finalvert_t *pfv, *index0, *index1, *index2; int i; int lnumtriangles; void (*drawfnc) (int *p1, int *p2, int *p3); mstvert_t *pst, *stv; pst = r_affinetridesc.pstverts; pfv = r_affinetridesc.pfinalverts; ptri = r_affinetridesc.ptriangles; lnumtriangles = r_affinetridesc.numtriangles; #ifdef PEXT_TRANS if (r_pixbytes == 4) drawfnc = D_PolysetRecursiveTriangle32Trans; else if (r_pixbytes == 1) drawfnc = D_PolysetRecursiveTriangleTrans; else #endif drawfnc = D_PolysetRecursiveTriangleC; for (i=0 ; iv[1]-index1->v[1]) * (index0->v[0]-index2->v[0]) - (index0->v[0]-index1->v[0]) * (index0->v[1]-index2->v[1])) >= 0) { continue; } stv = pst + ptri[i].st_index[0]; index0->v[2] = stv->s; index0->v[3] = stv->t; stv = pst + ptri[i].st_index[1]; index1->v[2] = stv->s; index1->v[3] = stv->t; stv = pst + ptri[i].st_index[2]; index2->v[2] = stv->s; index2->v[3] = stv->t; { int z; short *zbuf; z = index0->v[5]>>16; zbuf = zspantable[index0->v[1]] + index0->v[0]; if (z >= *zbuf) { int pix; *zbuf = z; pix = skintable[index0->v[3]>>16][index0->v[2]>>16]; pix = ((qbyte *)acolormap)[pix + (index0->v[4] & 0xFF00) ]; d_viewbuffer[d_scantable[index0->v[1]] + index0->v[0]] = pix;//Trans(d_viewbuffer[d_scantable[index0->v[1]] + index0->v[0]], pix); } } { int z; short *zbuf; z = index1->v[5]>>16; zbuf = zspantable[index1->v[1]] + index1->v[0]; if (z >= *zbuf) { int pix; *zbuf = z; pix = skintable[index1->v[3]>>16][index1->v[2]>>16]; pix = ((qbyte *)acolormap)[pix + (index0->v[4] & 0xFF00) ]; d_viewbuffer[d_scantable[index1->v[1]] + index1->v[0]] = pix;//Trans(d_viewbuffer[d_scantable[index0->v[1]] + index0->v[0]], pix); } } { int z; short *zbuf; z = index2->v[5]>>16; zbuf = zspantable[index2->v[1]] + index2->v[0]; if (z >= *zbuf) { int pix; *zbuf = z; pix = skintable[index2->v[3]>>16][index2->v[2]>>16]; pix = ((qbyte *)acolormap)[pix + (index0->v[4] & 0xFF00) ]; d_viewbuffer[d_scantable[index2->v[1]] + index2->v[0]] = pix;//Trans(d_viewbuffer[d_scantable[index0->v[1]] + index0->v[0]], pix); } } d_pcolormap = &((qbyte *)acolormap)[index0->v[4] & 0xFF00]; drawfnc(index0->v, index1->v, index2->v); } } /* ================ D_DrawNonSubdiv ================ */ void D_DrawNonSubdivC (void) { mtriangle_t *ptri; finalvert_t *pfv, *index0, *index1, *index2; int i; int lnumtriangles; mstvert_t *pst, *stv; pst = r_affinetridesc.pstverts; pfv = r_affinetridesc.pfinalverts; ptri = r_affinetridesc.ptriangles; lnumtriangles = r_affinetridesc.numtriangles; for (i=0 ; ixyz_index[0]; index1 = pfv + ptri->xyz_index[1]; index2 = pfv + ptri->xyz_index[2]; d_xdenom = (index0->v[1]-index1->v[1]) * (index0->v[0]-index2->v[0]) - (index0->v[0]-index1->v[0])*(index0->v[1]-index2->v[1]); if (d_xdenom >= 0) { continue; } r_p0[0] = index0->v[0]; // u r_p0[1] = index0->v[1]; // v stv = pst + ptri->st_index[0]; r_p0[2] = stv->s; // s r_p0[3] = stv->t; // t r_p0[4] = index0->v[4]; // light r_p0[5] = index0->v[5]; // iz r_p1[0] = index1->v[0]; r_p1[1] = index1->v[1]; stv = pst + ptri->st_index[1]; r_p1[2] = stv->s; r_p1[3] = stv->t; r_p1[4] = index1->v[4]; r_p1[5] = index1->v[5]; r_p2[0] = index2->v[0]; r_p2[1] = index2->v[1]; stv = pst + ptri->st_index[2]; r_p2[2] = stv->s; r_p2[3] = stv->t; r_p2[4] = index2->v[4]; r_p2[5] = index2->v[5]; D_PolysetSetEdgeTable (); D_RasterizeAliasPolySmoothC (); } } void D_DrawNonSubdiv32C (void) { mtriangle_t *ptri; finalvert_t *pfv, *index0, *index1, *index2; int i; int lnumtriangles; mstvert_t *pst, *stv; pst = r_affinetridesc.pstverts; pfv = r_affinetridesc.pfinalverts; ptri = r_affinetridesc.ptriangles; lnumtriangles = r_affinetridesc.numtriangles; for (i=0 ; ixyz_index[0]; index1 = pfv + ptri->xyz_index[1]; index2 = pfv + ptri->xyz_index[2]; d_xdenom = (index0->v[1]-index1->v[1]) * (index0->v[0]-index2->v[0]) - (index0->v[0]-index1->v[0])*(index0->v[1]-index2->v[1]); if (d_xdenom >= 0) { continue; } r_p0[0] = index0->v[0]; // u r_p0[1] = index0->v[1]; // v stv = pst + ptri->st_index[0]; r_p0[2] = stv->s;//index0->v[2]; // s r_p0[3] = stv->t;//index0->v[3]; // t r_p0[4] = index0->v[4]; // light r_p0[5] = index0->v[5]; // iz r_p1[0] = index1->v[0]; r_p1[1] = index1->v[1]; stv = pst + ptri->st_index[1]; r_p1[2] = stv->s;//index1->v[2]; r_p1[3] = stv->t;//index1->v[3]; r_p1[4] = index1->v[4]; r_p1[5] = index1->v[5]; r_p2[0] = index2->v[0]; r_p2[1] = index2->v[1]; stv = pst + ptri->st_index[2]; r_p2[2] = stv->s;//index2->v[2]; r_p2[3] = stv->t;//index2->v[3]; r_p2[4] = index2->v[4]; r_p2[5] = index2->v[5]; D_PolysetSetEdgeTable (); D_RasterizeAliasPolySmoothC (); } } /* ================ D_PolysetRecursiveTriangle ================ */ void D_PolysetRecursiveTriangleC (int *lp1, int *lp2, int *lp3) { int *temp; int d; int new[6]; int z; short *zbuf; d = lp2[0] - lp1[0]; if (d < -1 || d > 1) goto split; d = lp2[1] - lp1[1]; if (d < -1 || d > 1) goto split; d = lp3[0] - lp2[0]; if (d < -1 || d > 1) goto split2; d = lp3[1] - lp2[1]; if (d < -1 || d > 1) goto split2; d = lp1[0] - lp3[0]; if (d < -1 || d > 1) goto split3; d = lp1[1] - lp3[1]; 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[0] = (lp1[0] + lp2[0]) >> 1; new[1] = (lp1[1] + lp2[1]) >> 1; new[2] = (lp1[2] + lp2[2]) >> 1; new[3] = (lp1[3] + lp2[3]) >> 1; new[5] = (lp1[5] + lp2[5]) >> 1; // draw the point if splitting a leading edge if (lp2[1] > lp1[1]) goto nodraw; if ((lp2[1] == lp1[1]) && (lp2[0] < lp1[0])) goto nodraw; z = new[5]>>16; zbuf = zspantable[new[1]] + new[0]; if (z >= *zbuf) { int pix; *zbuf = z; pix = d_pcolormap[skintable[new[3]>>16][new[2]>>16]]; d_viewbuffer[d_scantable[new[1]] + new[0]] = pix; } nodraw: // recursively continue D_PolysetRecursiveTriangleC (lp3, lp1, new); D_PolysetRecursiveTriangleC (lp3, new, lp2); } /* ================ D_PolysetUpdateTables ================ */ void D_PolysetUpdateTables (void) { int i; qbyte *s; if (r_affinetridesc.skinwidth*r_pixbytes != skinwidth || r_affinetridesc.pskin != skinstart) { skinwidth = r_affinetridesc.skinwidth*r_pixbytes; skinstart = r_affinetridesc.pskin; s = skinstart; for (i=0 ; ipdest = 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); } /* =================== D_PolysetSetUpForLineScan ==================== */ void D_PolysetSetUpForLineScan(fixed8_t startvertu, fixed8_t startvertv, fixed8_t endvertu, fixed8_t endvertv) { double 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 = (double)tm; dn = (double)tn; FloorDivMod (dm, dn, &ubasestep, &erroradjustup); erroradjustdown = dn; } } #if !id386 /* ================ D_PolysetCalcGradients ================ */ void D_PolysetCalcGradientsAsm (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]; 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 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 id386 a_sstepxfrac = r_sstepx << 16; a_tstepxfrac = r_tstepx << 16; #else a_sstepxfrac = r_sstepx & 0xFFFF; a_tstepxfrac = r_tstepx & 0xFFFF; #endif a_ststepxwhole = skinwidth * (r_tstepx >> 16) + (r_sstepx >> 16); } #endif // !id386 void D_PolysetCalcGradientsC (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]; 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 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); } #if 0 qbyte gelmap[256]; void InitGel (qbyte *palette) { int i; int r; for (i=0 ; i<256 ; i++) { // r = (palette[i*3]>>4); r = (palette[i*3] + palette[i*3+1] + palette[i*3+2])/(16*3); gelmap[i] = /* 64 */ 0 + r; } } #endif /* ================ D_PolysetDrawSpans8 ================ */ void D_PolysetDrawSpans8C (spanpackage_t *pspanpackage) { int lcount; qbyte *lpdest; qbyte *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) { *lpdest = ((qbyte *)acolormap)[*lptex + (llight & 0xFF00)]; // gel mapping *lpdest = gelmap[*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); } /* ================ D_PolysetFillSpans8 ================ */ void D_PolysetFillSpans8 (spanpackage_t *pspanpackage) { int color; // FIXME: do z buffering color = d_aflatcolor++; while (1) { int lcount; qbyte *lpdest; lcount = pspanpackage->count; if (lcount == -1) return; if (lcount) { lpdest = pspanpackage->pdest; do { *lpdest++ = color; } while (--lcount); } pspanpackage++; } } /* ================ D_RasterizeAliasPolySmooth ================ */ #if id386 void D_RasterizeAliasPolySmooth8Asm (void) { int initialleftheight, initialrightheight; int *plefttop, *prighttop, *pleftbottom, *prightbottom; int working_lstepx, originalcount; void (*DrawSpans) (spanpackage_t *pspanpackage); if (r_pixbytes == 1) DrawSpans = D_PolysetDrawSpans8; else DrawSpans = D_PolysetDrawSpans16; 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_PolysetCalcGradientsAsm (r_affinetridesc.skinwidth); // // rasterize the polygon // // // scan out the top (and possibly only) part of the left edge // D_PolysetSetUpForLineScan(plefttop[0], plefttop[1], pleftbottom[0], pleftbottom[1]); d_pedgespanpackage = a_spans; ystart = plefttop[1]; d_aspancount = plefttop[0] - prighttop[0]; d_ptex = (qbyte *)r_affinetridesc.pskin + (plefttop[2] >> 16) + (plefttop[3] >> 16) * r_affinetridesc.skinwidth; //#if id386 d_sfrac = (plefttop[2] & 0xFFFF) << 16; d_tfrac = (plefttop[3] & 0xFFFF) << 16; d_pzbasestep = (d_zwidth + ubasestep) << 1; d_pzextrastep = d_pzbasestep + 2; //#else // d_sfrac = plefttop[2] & 0xFFFF; // d_tfrac = plefttop[3] & 0xFFFF; // d_pzbasestep = d_zwidth + ubasestep; // d_pzextrastep = d_pzbasestep + 1; //#endif d_light = plefttop[4]; d_zi = plefttop[5]; d_pdestbasestep = (screenwidth + ubasestep)*r_pixbytes; d_pdestextrastep = d_pdestbasestep + r_pixbytes; d_pdest = (qbyte *)d_viewbuffer + (ystart * screenwidth + plefttop[0])*r_pixbytes; d_pz = d_pzbuffer + ystart * d_zwidth + plefttop[0]; // 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 id386 d_sfracbasestep = (r_sstepy + r_sstepx * ubasestep) << 16; d_tfracbasestep = (r_tstepy + r_tstepx * ubasestep) << 16; //#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 id386 d_sfracextrastep = (r_sstepy + r_sstepx*d_countextrastep) << 16; d_tfracextrastep = (r_tstepy + r_tstepx*d_countextrastep) << 16; //#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; 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; D_PolysetSetUpForLineScan(plefttop[0], plefttop[1], pleftbottom[0], pleftbottom[1]); 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 = (qbyte *)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_pdestbasestep = (screenwidth + ubasestep)*r_pixbytes; d_pdestextrastep = d_pdestbasestep + r_pixbytes; d_pdest = (qbyte *)d_viewbuffer + (ystart * screenwidth + plefttop[0])*r_pixbytes; //#if id386 d_pzbasestep = (d_zwidth + ubasestep) << 1; d_pzextrastep = d_pzbasestep + 2; //#else // d_pzbasestep = d_zwidth + ubasestep; // d_pzextrastep = d_pzbasestep + 1; //#endif d_pz = d_pzbuffer + ystart * d_zwidth + plefttop[0]; 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 id386 d_sfracbasestep = (r_sstepy + r_sstepx * ubasestep) << 16; d_tfracbasestep = (r_tstepy + r_tstepx * ubasestep) << 16; //#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 id386 d_sfracextrastep = ((r_sstepy+r_sstepx*d_countextrastep) & 0xFFFF)<<16; d_tfracextrastep = ((r_tstepy+r_tstepx*d_countextrastep) & 0xFFFF)<<16; //#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; 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[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 DrawSpans (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]; 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 DrawSpans (pstart); } } #endif void D_RasterizeAliasPolySmooth8C (void) { int initialleftheight, initialrightheight; int *plefttop, *prighttop, *pleftbottom, *prightbottom; int working_lstepx, originalcount; void (*DrawSpans) (spanpackage_t *pspanpackage); if (r_pixbytes == 1) DrawSpans = D_PolysetDrawSpans8C; else DrawSpans = D_PolysetDrawSpans16; 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_PolysetCalcGradientsC (r_affinetridesc.skinwidth); // // rasterize the polygon // // // scan out the top (and possibly only) part of the left edge // D_PolysetSetUpForLineScan(plefttop[0], plefttop[1], pleftbottom[0], pleftbottom[1]); d_pedgespanpackage = a_spans; ystart = plefttop[1]; d_aspancount = plefttop[0] - prighttop[0]; d_ptex = (qbyte *)r_affinetridesc.pskin + (plefttop[2] >> 16) + (plefttop[3] >> 16) * r_affinetridesc.skinwidth; //#if id386 // d_sfrac = (plefttop[2] & 0xFFFF) << 16; // d_tfrac = (plefttop[3] & 0xFFFF) << 16; // d_pzbasestep = (d_zwidth + ubasestep) << 1; // d_pzextrastep = d_pzbasestep + 2; //#else d_sfrac = plefttop[2] & 0xFFFF; d_tfrac = plefttop[3] & 0xFFFF; d_pzbasestep = d_zwidth + ubasestep; d_pzextrastep = d_pzbasestep + 1; //#endif d_light = plefttop[4]; d_zi = plefttop[5]; d_pdestbasestep = (screenwidth + ubasestep)*r_pixbytes; d_pdestextrastep = d_pdestbasestep + r_pixbytes; d_pdest = (qbyte *)d_viewbuffer + (ystart * screenwidth + plefttop[0])*r_pixbytes; d_pz = d_pzbuffer + ystart * d_zwidth + plefttop[0]; // 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 id386 // d_sfracbasestep = (r_sstepy + r_sstepx * ubasestep) << 16; // d_tfracbasestep = (r_tstepy + r_tstepx * ubasestep) << 16; //#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 id386 // d_sfracextrastep = (r_sstepy + r_sstepx*d_countextrastep) << 16; // d_tfracextrastep = (r_tstepy + r_tstepx*d_countextrastep) << 16; //#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; 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; D_PolysetSetUpForLineScan(plefttop[0], plefttop[1], pleftbottom[0], pleftbottom[1]); 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 = (qbyte *)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_pdestbasestep = (screenwidth + ubasestep)*r_pixbytes; d_pdestextrastep = d_pdestbasestep + r_pixbytes; d_pdest = (qbyte *)d_viewbuffer + (ystart * screenwidth + plefttop[0])*r_pixbytes; //#if id386 // d_pzbasestep = (d_zwidth + ubasestep) << 1; // d_pzextrastep = d_pzbasestep + 2; //#else d_pzbasestep = d_zwidth + ubasestep; d_pzextrastep = d_pzbasestep + 1; //#endif d_pz = d_pzbuffer + ystart * d_zwidth + plefttop[0]; 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 id386 // d_sfracbasestep = (r_sstepy + r_sstepx * ubasestep) << 16; // d_tfracbasestep = (r_tstepy + r_tstepx * ubasestep) << 16; //#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 id386 // d_sfracextrastep = ((r_sstepy+r_sstepx*d_countextrastep) & 0xFFFF)<<16; // d_tfracextrastep = ((r_tstepy+r_tstepx*d_countextrastep) & 0xFFFF)<<16; //#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; 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[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 DrawSpans (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]; 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 DrawSpans (pstart); } } /* void D_RasterizeAliasPolySmooth1Asm (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 // D_PolysetCalcGradients (r_affinetridesc.skinwidth); // // rasterize the polygon // // // scan out the top (and possibly only) part of the left edge // D_PolysetSetUpForLineScan(plefttop[0], plefttop[1], pleftbottom[0], pleftbottom[1]); d_pedgespanpackage = a_spans; ystart = plefttop[1]; d_aspancount = plefttop[0] - prighttop[0]; d_ptex = (qbyte *)r_affinetridesc.pskin + (plefttop[2] >> 16) + (plefttop[3] >> 16) * r_affinetridesc.skinwidth; #if id386 d_sfrac = (plefttop[2] & 0xFFFF) << 16; d_tfrac = (plefttop[3] & 0xFFFF) << 16; d_pzbasestep = (d_zwidth + ubasestep) << 1; d_pzextrastep = d_pzbasestep + 2; #else d_sfrac = plefttop[2] & 0xFFFF; d_tfrac = plefttop[3] & 0xFFFF; d_pzbasestep = d_zwidth + ubasestep; d_pzextrastep = d_pzbasestep + 1; #endif d_light = plefttop[4]; d_zi = plefttop[5]; d_pdestbasestep = (screenwidth + ubasestep)*r_pixbytes; d_pdestextrastep = d_pdestbasestep + r_pixbytes; d_pdest = (qbyte *)d_viewbuffer + (ystart * screenwidth + plefttop[0])*r_pixbytes; d_pz = d_pzbuffer + ystart * d_zwidth + plefttop[0]; // 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 id386 d_sfracbasestep = (r_sstepy + r_sstepx * ubasestep) << 16; d_tfracbasestep = (r_tstepy + r_tstepx * ubasestep) << 16; #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 id386 d_sfracextrastep = (r_sstepy + r_sstepx*d_countextrastep) << 16; d_tfracextrastep = (r_tstepy + r_tstepx*d_countextrastep) << 16; #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; 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; D_PolysetSetUpForLineScan(plefttop[0], plefttop[1], pleftbottom[0], pleftbottom[1]); 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 = (qbyte *)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_pdestbasestep = (screenwidth + ubasestep)*r_pixbytes; d_pdestextrastep = d_pdestbasestep + r_pixbytes; d_pdest = (qbyte *)d_viewbuffer + (ystart * screenwidth + plefttop[0])*r_pixbytes; #if id386 d_pzbasestep = (d_zwidth + ubasestep) << 1; d_pzextrastep = d_pzbasestep + 2; #else d_pzbasestep = d_zwidth + ubasestep; d_pzextrastep = d_pzbasestep + 1; #endif d_pz = d_pzbuffer + ystart * d_zwidth + plefttop[0]; 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 id386 d_sfracbasestep = (r_sstepy + r_sstepx * ubasestep) << 16; d_tfracbasestep = (r_tstepy + r_tstepx * ubasestep) << 16; #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 id386 d_sfracextrastep = ((r_sstepy+r_sstepx*d_countextrastep) & 0xFFFF)<<16; d_tfracextrastep = ((r_tstepy+r_tstepx*d_countextrastep) & 0xFFFF)<<16; #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; 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[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 (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]; 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_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[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]; } #if 0 void D_PolysetRecursiveDrawLine (int *lp1, int *lp2) { int d; int new[6]; int ofs; d = lp2[0] - lp1[0]; if (d < -1 || d > 1) goto split; d = lp2[1] - lp1[1]; if (d < -1 || d > 1) goto split; return; // line is completed split: // split this edge new[0] = (lp1[0] + lp2[0]) >> 1; new[1] = (lp1[1] + lp2[1]) >> 1; new[5] = (lp1[5] + lp2[5]) >> 1; new[2] = (lp1[2] + lp2[2]) >> 1; new[3] = (lp1[3] + lp2[3]) >> 1; new[4] = (lp1[4] + lp2[4]) >> 1; // draw the point ofs = d_scantable[new[1]] + new[0]; if (new[5] > d_pzbuffer[ofs]) { int pix; d_pzbuffer[ofs] = new[5]; pix = skintable[new[3]>>16][new[2]>>16]; // pix = ((qbyte *)acolormap)[pix + (new[4] & 0xFF00)]; d_viewbuffer[ofs] = pix; } // recursively continue D_PolysetRecursiveDrawLine (lp1, new); D_PolysetRecursiveDrawLine (new, lp2); } void D_PolysetRecursiveTriangle2 (int *lp1, int *lp2, int *lp3) { int d; int new[4]; d = lp2[0] - lp1[0]; if (d < -1 || d > 1) goto split; d = lp2[1] - lp1[1]; if (d < -1 || d > 1) goto split; return; split: // split this edge new[0] = (lp1[0] + lp2[0]) >> 1; new[1] = (lp1[1] + lp2[1]) >> 1; new[5] = (lp1[5] + lp2[5]) >> 1; new[2] = (lp1[2] + lp2[2]) >> 1; new[3] = (lp1[3] + lp2[3]) >> 1; new[4] = (lp1[4] + lp2[4]) >> 1; D_PolysetRecursiveDrawLine (new, lp3); // recursively continue D_PolysetRecursiveTriangle (lp1, new, lp3); D_PolysetRecursiveTriangle (new, lp2, lp3); } #endif