2634 lines
65 KiB
C
2634 lines
65 KiB
C
/*
|
|
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_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_PolysetRecursiveTriangle16C (int *lp1, int *lp2, int *lp3);
|
|
|
|
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 ; 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->v[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)[apalremap[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 ; 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->v[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 ; 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->v[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 newt[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
|
|
newt[0] = (lp1[0] + lp2[0]) >> 1;
|
|
newt[1] = (lp1[1] + lp2[1]) >> 1;
|
|
newt[2] = (lp1[2] + lp2[2]) >> 1;
|
|
newt[3] = (lp1[3] + lp2[3]) >> 1;
|
|
newt[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 = newt[5]>>16;
|
|
zbuf = zspantable[newt[1]] + newt[0];
|
|
if (z >= *zbuf)
|
|
{
|
|
int pix;
|
|
|
|
*zbuf = z;
|
|
pix = d_pcolormap[apalremap[skintable[newt[3]>>16][newt[2]>>16]]];
|
|
d_viewbuffer[d_scantable[newt[1]] + newt[0]] = Trans(d_viewbuffer[d_scantable[newt[1]] + newt[0]], (unsigned char)pix);
|
|
}
|
|
|
|
nodraw:
|
|
// recursively continue
|
|
D_PolysetRecursiveTriangleTrans (lp3, lp1, newt);
|
|
D_PolysetRecursiveTriangleTrans (lp3, newt, lp2);
|
|
}
|
|
|
|
void D_PolysetRecursiveTriangle32Trans (int *lp1, int *lp2, int *lp3)
|
|
{
|
|
int *temp;
|
|
int d;
|
|
int newt[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
|
|
newt[0] = (lp1[0] + lp2[0]) >> 1;
|
|
newt[1] = (lp1[1] + lp2[1]) >> 1;
|
|
newt[2] = (lp1[2] + lp2[2]) >> 1;
|
|
newt[3] = (lp1[3] + lp2[3]) >> 1;
|
|
newt[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 = newt[5]>>16;
|
|
if ((newt[1]>=vid.height|| newt[1] < 0 || newt[0] >= vid.width || newt[0]<0)) //fixme: temp
|
|
return;
|
|
zbuf = zspantable[newt[1]] + newt[0];
|
|
|
|
if (z >= *zbuf)
|
|
{
|
|
int pix;
|
|
|
|
*zbuf = z;
|
|
pix = ((unsigned int *)((unsigned int **)skintable)[newt[3]>>16])[newt[2]>>16];
|
|
// pix = d_pcolormap[skintable[new[3]>>16][new[2]>>16]];
|
|
((unsigned int *)d_viewbuffer)[d_scantable[newt[1]] + newt[0]] = pix;//d_8to32table[pix];
|
|
}
|
|
|
|
nodraw:
|
|
// recursively continue
|
|
D_PolysetRecursiveTriangle32Trans (lp3, lp1, newt);
|
|
D_PolysetRecursiveTriangle32Trans (lp3, newt, lp2);
|
|
}
|
|
|
|
void D_PolysetRecursiveTriangle16 (int *lp1, int *lp2, int *lp3)
|
|
{
|
|
int *temp;
|
|
int d;
|
|
int newt[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
|
|
newt[0] = (lp1[0] + lp2[0]) >> 1;
|
|
newt[1] = (lp1[1] + lp2[1]) >> 1;
|
|
newt[2] = (lp1[2] + lp2[2]) >> 1;
|
|
newt[3] = (lp1[3] + lp2[3]) >> 1;
|
|
newt[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 = newt[5]>>16;
|
|
if ((newt[1]>=vid.height|| newt[1] < 0 || newt[0] >= vid.width || newt[0]<0)) //fixme: temp
|
|
return;
|
|
zbuf = zspantable[newt[1]] + newt[0];
|
|
|
|
if (z >= *zbuf)
|
|
{
|
|
int pix;
|
|
|
|
*zbuf = z;
|
|
pix = ((unsigned short *)d_pcolormap)[skintable[newt[3]>>16][newt[2]>>16]];
|
|
((unsigned short *)d_viewbuffer)[d_scantable[newt[1]] + newt[0]] = pix;//d_8to32table[pix];
|
|
}
|
|
|
|
nodraw:
|
|
// recursively continue
|
|
D_PolysetRecursiveTriangle16 (lp3, lp1, newt);
|
|
D_PolysetRecursiveTriangle16 (lp3, newt, 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)[apalremap[*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)[apalremap[*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);
|
|
}
|
|
|
|
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 ; 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->v[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)[apalremap[pix] + (fv->v[4] & 0xFF00) ];
|
|
d_viewbuffer[d_scantable[fv->v[1]] + fv->v[0]] = pix;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void D_PolysetDrawFinalVerts16C (finalvert_t *fv, int numverts)
|
|
{
|
|
int i, z;
|
|
short *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->v[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 = ((unsigned short *)acolormap)[apalremap[pix] + (fv->v[4] & 0xFF00) ];
|
|
((unsigned short*)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 (transbackfac)
|
|
{
|
|
if (r_pixbytes == 4)
|
|
drawfnc = D_PolysetRecursiveTriangle32Trans;
|
|
else if (r_pixbytes == 2)
|
|
drawfnc = D_PolysetRecursiveTriangle16C;
|
|
else //if (r_pixbytes == 1)
|
|
drawfnc = D_PolysetRecursiveTriangleTrans;
|
|
}
|
|
else
|
|
#endif
|
|
if (r_pixbytes == 2)
|
|
drawfnc = D_PolysetRecursiveTriangle16C;
|
|
else
|
|
drawfnc = D_PolysetRecursiveTriangleC;
|
|
|
|
for (i=0 ; i<lnumtriangles ; i++)
|
|
{
|
|
index0 = pfv + ptri[i].xyz_index[0];
|
|
index1 = pfv + ptri[i].xyz_index[1];
|
|
index2 = pfv + ptri[i].xyz_index[2];
|
|
|
|
if (((index0->v[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)[apalremap[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)[apalremap[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)[apalremap[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 ; i<lnumtriangles ; i++, ptri++)
|
|
{
|
|
index0 = pfv + ptri->xyz_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 ; i<lnumtriangles ; i++, ptri++)
|
|
{
|
|
index0 = pfv + ptri->xyz_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 newt[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
|
|
newt[0] = (lp1[0] + lp2[0]) >> 1;
|
|
newt[1] = (lp1[1] + lp2[1]) >> 1;
|
|
newt[2] = (lp1[2] + lp2[2]) >> 1;
|
|
newt[3] = (lp1[3] + lp2[3]) >> 1;
|
|
newt[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 = newt[5]>>16;
|
|
zbuf = zspantable[newt[1]] + newt[0];
|
|
if (z >= *zbuf)
|
|
{
|
|
int pix;
|
|
|
|
*zbuf = z;
|
|
pix = d_pcolormap[apalremap[skintable[newt[3]>>16][newt[2]>>16]]];
|
|
d_viewbuffer[d_scantable[newt[1]] + newt[0]] = pix;
|
|
}
|
|
|
|
nodraw:
|
|
// recursively continue
|
|
D_PolysetRecursiveTriangleC (lp3, lp1, newt);
|
|
D_PolysetRecursiveTriangleC (lp3, newt, lp2);
|
|
}
|
|
|
|
void D_PolysetRecursiveTriangle16C (int *lp1, int *lp2, int *lp3)
|
|
{
|
|
int *temp;
|
|
int d;
|
|
int newt[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
|
|
newt[0] = (lp1[0] + lp2[0]) >> 1;
|
|
newt[1] = (lp1[1] + lp2[1]) >> 1;
|
|
newt[2] = (lp1[2] + lp2[2]) >> 1;
|
|
newt[3] = (lp1[3] + lp2[3]) >> 1;
|
|
newt[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 = newt[5]>>16;
|
|
zbuf = zspantable[newt[1]] + newt[0];
|
|
if (z >= *zbuf)
|
|
{
|
|
int pix;
|
|
|
|
// lptex = (qbyte *)((unsigned char *)r_affinetridesc.pskin+tex);
|
|
// lpdest[0] = ((unsigned short *)acolormap)[apalremap[*lptex] + (llight & 0xFF00)];
|
|
|
|
|
|
*zbuf = z;
|
|
pix = skintable[newt[3]>>16][newt[2]>>16];
|
|
((unsigned short *)d_viewbuffer)[d_scantable[newt[1]] + newt[0]] = pix;
|
|
}
|
|
|
|
nodraw:
|
|
// recursively continue
|
|
D_PolysetRecursiveTriangle16C (lp3, lp1, newt);
|
|
D_PolysetRecursiveTriangle16C (lp3, newt, 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 ; i<MAX_LBM_HEIGHT ; i++, s+=skinwidth)
|
|
skintable[i] = s;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
===================
|
|
D_PolysetScanLeftEdge
|
|
====================
|
|
*/
|
|
void D_PolysetScanLeftEdgeC (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);
|
|
}
|
|
|
|
/*
|
|
===================
|
|
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)[apalremap[*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_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 newt[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
|
|
newt[0] = (lp1[0] + lp2[0]) >> 1;
|
|
newt[1] = (lp1[1] + lp2[1]) >> 1;
|
|
newt[5] = (lp1[5] + lp2[5]) >> 1;
|
|
newt[2] = (lp1[2] + lp2[2]) >> 1;
|
|
newt[3] = (lp1[3] + lp2[3]) >> 1;
|
|
newt[4] = (lp1[4] + lp2[4]) >> 1;
|
|
|
|
// draw the point
|
|
ofs = d_scantable[newt[1]] + newt[0];
|
|
if (newt[5] > d_pzbuffer[ofs])
|
|
{
|
|
int pix;
|
|
|
|
d_pzbuffer[ofs] = newt[5];
|
|
pix = apalremap[skintable[newt[3]>>16][newt[2]>>16]];
|
|
// pix = ((qbyte *)acolormap)[pix + (newt[4] & 0xFF00)];
|
|
d_viewbuffer[ofs] = pix;
|
|
}
|
|
|
|
// recursively continue
|
|
D_PolysetRecursiveDrawLine (lp1, newt);
|
|
D_PolysetRecursiveDrawLine (newt, lp2);
|
|
}
|
|
|
|
void D_PolysetRecursiveTriangle2 (int *lp1, int *lp2, int *lp3)
|
|
{
|
|
int d;
|
|
int newt[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
|
|
newt[0] = (lp1[0] + lp2[0]) >> 1;
|
|
newt[1] = (lp1[1] + lp2[1]) >> 1;
|
|
newt[5] = (lp1[5] + lp2[5]) >> 1;
|
|
newt[2] = (lp1[2] + lp2[2]) >> 1;
|
|
newt[3] = (lp1[3] + lp2[3]) >> 1;
|
|
newt[4] = (lp1[4] + lp2[4]) >> 1;
|
|
|
|
D_PolysetRecursiveDrawLine (newt, lp3);
|
|
|
|
// recursively continue
|
|
D_PolysetRecursiveTriangle (lp1, newt, lp3);
|
|
D_PolysetRecursiveTriangle (newt, lp2, lp3);
|
|
}
|
|
|
|
#endif
|
|
|