qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-10 15:22:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

Whitespace and comment cleanup.

Browse source
This commit is contained in:
Ragnvald Maartmann-Moe IV 2001-05-15 17:38:43 +00:00
parent dd81f9bf30
commit 5d52236da1
23 changed files with 271 additions and 719 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

53
nq/source/d_edge.c
View file

@ -46,12 +46,7 @@ extern void R_TransformFrustum (void);
vec3_t transformed_modelorg;
/*
==============
D_DrawPoly
==============
*/
void
D_DrawPoly (void)
{
@ -59,11 +54,6 @@ D_DrawPoly (void)
}
/*
=============
D_MipLevelForScale
=============
*/
int
D_MipLevelForScale (float scale)
{
@ -85,14 +75,7 @@ D_MipLevelForScale (float scale)
}
/*
==============
D_DrawSolidSurface
==============
*/
// FIXME: clean this up
void
D_DrawSolidSurface (surf_t *surf, int color)
{
@ -125,11 +108,6 @@ D_DrawSolidSurface (surf_t *surf, int color)
}
/*
==============
D_CalcGradients
==============
*/
void
D_CalcGradients (msurface_t *pface)
{
@ -169,19 +147,12 @@ D_CalcGradients (msurface_t *pface)
((pface->texturemins[1] << 16) >> miplevel)
+ pface->texinfo->vecs[1][3] * t;
//
// -1 (-epsilon) so we never wander off the edge of the texture
//
// -1 (-epsilon) so we never wander off the edge of the texture
bbextents = ((pface->extents[0] << 16) >> miplevel) - 1;
bbextentt = ((pface->extents[1] << 16) >> miplevel) - 1;
}
/*
==============
D_DrawSurfaces
==============
*/
void
D_DrawSurfaces (void)
{
@ -248,17 +219,13 @@ D_DrawSurfaces (void)
// FIXME: we don't want to do all this for every polygon!
// TODO: store once at start of frame
currententity = s->entity; // FIXME: make this passed in
//
//
// to
// R_RotateBmodel ()
// to R_RotateBmodel ()
VectorSubtract (r_origin, currententity->origin,
local_modelorg);
TransformVector (local_modelorg, transformed_modelorg);
R_RotateBmodel (); // FIXME: don't mess with the
// frustum,
// make entity passed in
// frustum, make entity passed in
}
D_CalcGradients (pface);
@ -266,11 +233,10 @@ D_DrawSurfaces (void)
D_DrawZSpans (s->spans);
if (s->insubmodel) {
//
// restore the old drawing state
// FIXME: we don't want to do this every time!
// TODO: speed up
//
currententity = &cl_entities[0];
VectorCopy (world_transformed_modelorg,
transformed_modelorg);
@ -285,17 +251,13 @@ D_DrawSurfaces (void)
// FIXME: we don't want to do all this for every polygon!
// TODO: store once at start of frame
currententity = s->entity; // FIXME: make this passed in
//
//
// to
// R_RotateBmodel ()
// to R_RotateBmodel ()
VectorSubtract (r_origin, currententity->origin,
local_modelorg);
TransformVector (local_modelorg, transformed_modelorg);
R_RotateBmodel (); // FIXME: don't mess with the
// frustum,
// make entity passed in
// frustum, make entity passed in
}
pface = s->data;
@ -315,11 +277,10 @@ D_DrawSurfaces (void)
D_DrawZSpans (s->spans);
if (s->insubmodel) {
//
// restore the old drawing state
// FIXME: we don't want to do this every time!
// TODO: speed up
//
currententity = &cl_entities[0];
VectorCopy (world_transformed_modelorg,
transformed_modelorg);

3
nq/source/d_fill.c
View file

@ -33,9 +33,6 @@
#include "d_iface.h"
/*
D_FillRect
*/
void
D_FillRect (vrect_t *rect, int color)
{

11
nq/source/d_modech.c
View file

@ -43,11 +43,7 @@ int d_y_aspect_shift, d_pix_min, d_pix_max, d_pix_shift;
int d_scantable[MAXHEIGHT];
short *zspantable[MAXHEIGHT];
/*
================
D_Patch
================
*/
void
D_Patch (void)
{
@ -65,11 +61,6 @@ D_Patch (void)
}
/*
================
D_ViewChanged
================
*/
void
D_ViewChanged (void)
{

23
nq/source/d_part.c
View file

@ -48,7 +48,6 @@ D_StartParticles (void)
#ifndef USE_INTEL_ASM
void
D_DrawParticle (particle_t *pparticle)
{
@ -58,7 +57,7 @@ D_DrawParticle (particle_t *pparticle)
short *pz;
int i, izi, pix, count, u, v;
// transform point
// transform point
VectorSubtract (pparticle->org, r_origin, local);
transformed[0] = DotProduct (local, r_pright);
@ -68,8 +67,8 @@ D_DrawParticle (particle_t *pparticle)
if (transformed[2] < PARTICLE_Z_CLIP)
return;
// project the point
// FIXME: preadjust xcenter and ycenter
// project the point
// FIXME: preadjust xcenter and ycenter
zi = 1.0 / transformed[2];
u = (int) (xcenter + zi * transformed[0] + 0.5);
v = (int) (ycenter - zi * transformed[1] + 0.5);
@ -91,9 +90,8 @@ D_DrawParticle (particle_t *pparticle)
pix = d_pix_max;
switch (pix) {
case 1:
case 1:
count = 1 << d_y_aspect_shift;
for (; count; count--, pz += d_zwidth, pdest += screenwidth) {
if (pz[0] <= izi) {
pz[0] = izi;
@ -102,9 +100,8 @@ D_DrawParticle (particle_t *pparticle)
}
break;
case 2:
case 2:
count = 2 << d_y_aspect_shift;
for (; count; count--, pz += d_zwidth, pdest += screenwidth) {
if (pz[0] <= izi) {
pz[0] = izi;
@ -118,9 +115,8 @@ D_DrawParticle (particle_t *pparticle)
}
break;
case 3:
case 3:
count = 3 << d_y_aspect_shift;
for (; count; count--, pz += d_zwidth, pdest += screenwidth) {
if (pz[0] <= izi) {
pz[0] = izi;
@ -139,9 +135,8 @@ D_DrawParticle (particle_t *pparticle)
}
break;
case 4:
case 4:
count = 4 << d_y_aspect_shift;
for (; count; count--, pz += d_zwidth, pdest += screenwidth) {
if (pz[0] <= izi) {
pz[0] = izi;
@ -165,9 +160,8 @@ D_DrawParticle (particle_t *pparticle)
}
break;
default:
default:
count = pix << d_y_aspect_shift;
for (; count; count--, pz += d_zwidth, pdest += screenwidth) {
for (i = 0; i < pix; i++) {
if (pz[i] <= izi) {
@ -179,5 +173,4 @@ D_DrawParticle (particle_t *pparticle)
break;
}
}
#endif // !USE_INTEL_ASM

141
nq/source/d_polyse.c
View file

@ -126,11 +126,6 @@ void D_PolysetScanLeftEdge (int height);
#ifndef USE_INTEL_ASM
/*
================
D_PolysetDraw
================
*/
void
D_PolysetDraw (void)
{
@ -150,11 +145,6 @@ D_PolysetDraw (void)
}
/*
================
D_PolysetDrawFinalVerts
================
*/
void
D_PolysetDrawFinalVerts (finalvert_t *fv, int numverts)
{
@ -181,11 +171,6 @@ D_PolysetDrawFinalVerts (finalvert_t *fv, int numverts)
}
/*
================
D_DrawSubdiv
================
*/
void
D_DrawSubdiv (void)
{
@ -238,11 +223,6 @@ D_DrawSubdiv (void)
}
/*
================
D_DrawNonSubdiv
================
*/
void
D_DrawNonSubdiv (void)
{
@ -304,11 +284,6 @@ D_DrawNonSubdiv (void)
}
/*
================
D_PolysetRecursiveTriangle
================
*/
void
D_PolysetRecursiveTriangle (int *lp1, int *lp2, int *lp3)
{
@ -348,6 +323,7 @@ D_PolysetRecursiveTriangle (int *lp1, int *lp2, int *lp3)
return; // entire tri is filled
split2:
temp = lp1;
lp1 = lp2;
@ -355,20 +331,19 @@ D_PolysetRecursiveTriangle (int *lp1, int *lp2, int *lp3)
lp3 = temp;
split:
// split this edge
// 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
// 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) {
@ -380,7 +355,7 @@ D_PolysetRecursiveTriangle (int *lp1, int *lp2, int *lp3)
}
nodraw:
// recursively continue
// recursively continue
D_PolysetRecursiveTriangle (lp3, lp1, new);
D_PolysetRecursiveTriangle (lp3, new, lp2);
}
@ -388,11 +363,6 @@ D_PolysetRecursiveTriangle (int *lp1, int *lp2, int *lp3)
#endif // !USE_INTEL_ASM
/*
================
D_PolysetUpdateTables
================
*/
void
D_PolysetUpdateTables (void)
{
@ -411,12 +381,6 @@ D_PolysetUpdateTables (void)
#ifndef USE_INTEL_ASM
/*
===================
D_PolysetScanLeftEdge
====================
*/
void
D_PolysetScanLeftEdge (int height)
{
@ -472,15 +436,9 @@ D_PolysetScanLeftEdge (int height)
}
} while (--height);
}
#endif // USE_INTEL_ASM
/*
===================
D_PolysetSetUpForLineScan
====================
*/
void
D_PolysetSetUpForLineScan (fixed8_t startvertu, fixed8_t startvertv,
fixed8_t endvertu, fixed8_t endvertv)
@ -513,12 +471,6 @@ D_PolysetSetUpForLineScan (fixed8_t startvertu, fixed8_t startvertv,
#ifndef USE_INTEL_ASM
/*
================
D_PolysetCalcGradients
================
*/
void
D_PolysetCalcGradients (int skinwidth)
{
@ -534,9 +486,9 @@ D_PolysetCalcGradients (int skinwidth)
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
// 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)
@ -575,7 +527,6 @@ D_PolysetCalcGradients (int skinwidth)
a_ststepxwhole = skinwidth * (r_tstepx >> 16) + (r_sstepx >> 16);
}
#endif // USE_INTEL_ASM
@ -588,9 +539,8 @@ InitGel (byte * palette)
int r;
for (i = 0; i < 256; i++) {
// r = (palette[i*3]>>4);
r =
(palette[i * 3] + palette[i * 3 + 1] +
// r = (palette[i*3]>>4);
r = (palette[i * 3] + palette[i * 3 + 1] +
palette[i * 3 + 2]) / (16 * 3);
gelmap[i] = /* 64 */ 0 + r;
}
@ -599,12 +549,6 @@ InitGel (byte * palette)
#ifndef USE_INTEL_ASM
/*
================
D_PolysetDrawSpans8
================
*/
void
D_PolysetDrawSpans8 (spanpackage_t * pspanpackage)
{
@ -664,11 +608,6 @@ D_PolysetDrawSpans8 (spanpackage_t * pspanpackage)
#endif // USE_INTEL_ASM
/*
================
D_PolysetFillSpans8
================
*/
void
D_PolysetFillSpans8 (spanpackage_t * pspanpackage)
{
@ -699,11 +638,7 @@ D_PolysetFillSpans8 (spanpackage_t * pspanpackage)
}
}
/*
================
D_RasterizeAliasPolySmooth
================
*/
void
D_RasterizeAliasPolySmooth (void)
{
@ -720,19 +655,13 @@ D_RasterizeAliasPolySmooth (void)
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
//
// 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
//
// rasterize the polygon
//
// scan out the top (and possibly only) part of the left edge
//
// scan out the top (and possibly only) part of the left edge
d_pedgespanpackage = a_spans;
ystart = plefttop[1];
@ -785,10 +714,8 @@ D_RasterizeAliasPolySmooth (void)
// 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)
// 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
@ -824,9 +751,7 @@ D_RasterizeAliasPolySmooth (void)
D_PolysetScanLeftEdge (initialleftheight);
}
//
// scan out the bottom part of the left edge, if it exists
//
// scan out the bottom part of the left edge, if it exists
if (pedgetable->numleftedges == 2) {
int height;
@ -917,8 +842,8 @@ D_RasterizeAliasPolySmooth (void)
D_PolysetScanLeftEdge (height);
}
}
// scan out the top (and possibly only) part of the right edge, updating the
// count field
// 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],
@ -930,7 +855,7 @@ D_RasterizeAliasPolySmooth (void)
// spanpackages
D_PolysetDrawSpans8 (a_spans);
// scan out the bottom part of the right edge, if it exists
// scan out the bottom part of the right edge, if it exists
if (pedgetable->numrightedges == 2) {
int height;
spanpackage_t *pstart;
@ -956,23 +881,16 @@ D_RasterizeAliasPolySmooth (void)
}
/*
================
D_PolysetSetEdgeTable
================
*/
void
D_PolysetSetEdgeTable (void)
{
int edgetableindex;
edgetableindex = 0; // assume the vertices are already in
// top to bottom order
// top to bottom order
//
// determine which edges are right & left, and the order in which
// to rasterize them
//
// 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])
@ -1031,7 +949,7 @@ D_PolysetRecursiveDrawLine (int *lp1, int *lp2)
return; // line is completed
split:
// split this edge
// split this edge
new[0] = (lp1[0] + lp2[0]) >> 1;
new[1] = (lp1[1] + lp2[1]) >> 1;
new[5] = (lp1[5] + lp2[5]) >> 1;
@ -1039,21 +957,22 @@ D_PolysetRecursiveDrawLine (int *lp1, int *lp2)
new[3] = (lp1[3] + lp2[3]) >> 1;
new[4] = (lp1[4] + lp2[4]) >> 1;
// draw the point
// 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 = ((byte *)acolormap)[pix + (new[4] & 0xFF00)];
// pix = ((byte *)acolormap)[pix + (new[4] & 0xFF00)];
d_viewbuffer[ofs] = pix;
}
// recursively continue
// recursively continue
D_PolysetRecursiveDrawLine (lp1, new);
D_PolysetRecursiveDrawLine (new, lp2);
}
void
D_PolysetRecursiveTriangle2 (int *lp1, int *lp2, int *lp3)
{
@ -1069,7 +988,7 @@ D_PolysetRecursiveTriangle2 (int *lp1, int *lp2, int *lp3)
return;
split:
// split this edge
// split this edge
new[0] = (lp1[0] + lp2[0]) >> 1;
new[1] = (lp1[1] + lp2[1]) >> 1;
new[5] = (lp1[5] + lp2[5]) >> 1;
@ -1079,7 +998,7 @@ D_PolysetRecursiveTriangle2 (int *lp1, int *lp2, int *lp3)
D_PolysetRecursiveDrawLine (new, lp3);
// recursively continue
// recursively continue
D_PolysetRecursiveTriangle (lp1, new, lp3);
D_PolysetRecursiveTriangle (new, lp2, lp3);
}

92
nq/source/d_scan.c
View file

@ -44,12 +44,10 @@ void D_DrawTurbulent8Span (void);
/*
=============
D_WarpScreen
D_WarpScreen
// this performs a slight compression of the screen at the same time as
// the sine warp, to keep the edges from wrapping
=============
this performs a slight compression of the screen at the same time as
the sine warp, to keep the edges from wrapping
*/
void
D_WarpScreen (void)
@ -98,12 +96,6 @@ D_WarpScreen (void)
#ifndef USE_INTEL_ASM
/*
=============
D_DrawTurbulent8Span
=============
*/
void
D_DrawTurbulent8Span (void)
{
@ -121,15 +113,9 @@ D_DrawTurbulent8Span (void)
r_turb_t += r_turb_tstep;
} while (--r_turb_spancount > 0);
}
#endif // USE_INTEL_ASM
/*
=============
Turbulent8
=============
*/
void
Turbulent8 (espan_t *pspan)
{
@ -197,28 +183,24 @@ Turbulent8 (espan_t *pspan)
if (snext > bbextents)
snext = bbextents;
else if (snext < 16)
snext = 16; // prevent round-off error on <0
// steps from
// from causing overstepping & running off the
// edge of the texture
snext = 16; // prevent round-off error on <0 steps
// from from causing overstepping &
// running off the edge of the texture
tnext = (int) (tdivz * z) + tadjust;
if (tnext > bbextentt)
tnext = bbextentt;
else if (tnext < 16)
tnext = 16; // guard against round-off error on
// <0 steps
// <0 steps
r_turb_sstep = (snext - r_turb_s) >> 4;
r_turb_tstep = (tnext - r_turb_t) >> 4;
} else {
// calculate s/z, t/z, zi->fixed s and t at last pixel in
// span (so
// can't step off polygon), clamp, calculate s and t steps
// across
// span by division, biasing steps low so we don't run off
// the
// texture
// calculate s/z, t/z, zi->fixed s and t at last pixel in span
// (so can't step off polygon), clamp, calculate s and t steps
// across span by division, biasing steps low so we don't run
// off the texture
spancountminus1 = (float) (r_turb_spancount - 1);
sdivz += d_sdivzstepu * spancountminus1;
tdivz += d_tdivzstepu * spancountminus1;
@ -228,17 +210,16 @@ Turbulent8 (espan_t *pspan)
if (snext > bbextents)
snext = bbextents;
else if (snext < 16)
snext = 16; // prevent round-off error on <0
// steps from
// from causing overstepping & running off the
// edge of the texture
snext = 16; // prevent round-off error on <0 steps
// from causing overstepping & running
// off the edge of the texture
tnext = (int) (tdivz * z) + tadjust;
if (tnext > bbextentt)
tnext = bbextentt;
else if (tnext < 16)
tnext = 16; // guard against round-off error on
// <0 steps
// <0 steps
if (r_turb_spancount > 1) {
r_turb_sstep = (snext - r_turb_s) / (r_turb_spancount - 1);
@ -261,12 +242,6 @@ Turbulent8 (espan_t *pspan)
#ifndef USE_INTEL_ASM
/*
=============
D_DrawSpans8
=============
*/
void
D_DrawSpans8 (espan_t *pspan)
{
@ -333,28 +308,24 @@ D_DrawSpans8 (espan_t *pspan)
if (snext > bbextents)
snext = bbextents;
else if (snext < 8)
snext = 8; // prevent round-off error on <0
// steps from
// from causing overstepping & running off the
// edge of the texture
snext = 8; // prevent round-off error on <0 steps
// from causing overstepping & running
// off the edge of the texture
tnext = (int) (tdivz * z) + tadjust;
if (tnext > bbextentt)
tnext = bbextentt;
else if (tnext < 8)
tnext = 8; // guard against round-off error on
// <0 steps
// <0 steps
sstep = (snext - s) >> 3;
tstep = (tnext - t) >> 3;
} else {
// calculate s/z, t/z, zi->fixed s and t at last pixel in
// span (so
// can't step off polygon), clamp, calculate s and t steps
// across
// span by division, biasing steps low so we don't run off
// the
// texture
// calculate s/z, t/z, zi->fixed s and t at last pixel in span
// (so can't step off polygon), clamp, calculate s and t steps
// across span by division, biasing steps low so we don't run
// off the texture
spancountminus1 = (float) (spancount - 1);
sdivz += d_sdivzstepu * spancountminus1;
tdivz += d_tdivzstepu * spancountminus1;
@ -364,17 +335,16 @@ D_DrawSpans8 (espan_t *pspan)
if (snext > bbextents)
snext = bbextents;
else if (snext < 8)
snext = 8; // prevent round-off error on <0
// steps from
// from causing overstepping & running off the
// edge of the texture
snext = 8; // prevent round-off error on <0 steps
// from causing overstepping & running
// off the edge of the texture
tnext = (int) (tdivz * z) + tadjust;
if (tnext > bbextentt)
tnext = bbextentt;
else if (tnext < 8)
tnext = 8; // guard against round-off error on
// <0 steps
// <0 steps
if (spancount > 1) {
sstep = (snext - s) / (spancount - 1);
@ -395,17 +365,10 @@ D_DrawSpans8 (espan_t *pspan)
} while ((pspan = pspan->pnext) != NULL);
}
#endif
#ifndef USE_INTEL_ASM
/*
=============
D_DrawZSpans
=============
*/
void
D_DrawZSpans (espan_t *pspan)
{
@ -455,5 +418,4 @@ D_DrawZSpans (espan_t *pspan)
} while ((pspan = pspan->pnext) != NULL);
}
#endif

6
nq/source/d_sky.c
View file

@ -38,9 +38,6 @@
#define SKY_SPAN_MAX (1 << SKY_SPAN_SHIFT)
/*
D_Sky_uv_To_st
*/
void
D_Sky_uv_To_st (int u, int v, fixed16_t *s, fixed16_t *t)
{
@ -68,9 +65,6 @@ D_Sky_uv_To_st (int u, int v, fixed16_t *s, fixed16_t *t)
}
/*
D_DrawSkyScans8
*/
void
D_DrawSkyScans8 (espan_t *pspan)
{

67
nq/source/d_sprite.c
View file

@ -37,13 +37,8 @@ static int sprite_height;
static int minindex, maxindex;
static sspan_t *sprite_spans;
#ifndef USE_INTEL_ASM
/*
=====================
D_SpriteDrawSpans
=====================
*/
#ifndef USE_INTEL_ASM
void
D_SpriteDrawSpans (sspan_t *pspan)
{
@ -121,28 +116,24 @@ D_SpriteDrawSpans (sspan_t *pspan)
if (snext > bbextents)
snext = bbextents;
else if (snext < 8)
snext = 8; // prevent round-off error on <0
// steps from
// from causing overstepping & running off the
// edge of the texture
snext = 8; // prevent round-off error on <0 steps
// from causing overstepping & running
// off the edge of the texture
tnext = (int) (tdivz * z) + tadjust;
if (tnext > bbextentt)
tnext = bbextentt;
else if (tnext < 8)
tnext = 8; // guard against round-off error on
// <0 steps
// <0 steps
sstep = (snext - s) >> 3;
tstep = (tnext - t) >> 3;
} else {
// calculate s/z, t/z, zi->fixed s and t at last pixel in
// span (so
// can't step off polygon), clamp, calculate s and t steps
// across
// span by division, biasing steps low so we don't run off
// the
// texture
// calculate s/z, t/z, zi->fixed s and t at last pixel in span
// (so can't step off polygon), clamp, calculate s and t steps
// across span by division, biasing steps low so we don't run
// off the texture
spancountminus1 = (float) (spancount - 1);
sdivz += d_sdivzstepu * spancountminus1;
tdivz += d_tdivzstepu * spancountminus1;
@ -152,17 +143,16 @@ D_SpriteDrawSpans (sspan_t *pspan)
if (snext > bbextents)
snext = bbextents;
else if (snext < 8)
snext = 8; // prevent round-off error on <0
// steps from
// from causing overstepping & running off the
// edge of the texture
snext = 8; // prevent round-off error on <0 steps
// from causing overstepping & running
// off the edge of the texture
tnext = (int) (tdivz * z) + tadjust;
if (tnext > bbextentt)
tnext = bbextentt;
else if (tnext < 8)
tnext = 8; // guard against round-off error on
// <0 steps
// <0 steps
if (spancount > 1) {
sstep = (snext - s) / (spancount - 1);
@ -196,15 +186,9 @@ D_SpriteDrawSpans (sspan_t *pspan)
} while (pspan->count != DS_SPAN_LIST_END);
}
#endif
/*
=====================
D_SpriteScanLeftEdge
=====================
*/
void
D_SpriteScanLeftEdge (void)
{
@ -260,11 +244,6 @@ D_SpriteScanLeftEdge (void)
}
/*
=====================
D_SpriteScanRightEdge
=====================
*/
void
D_SpriteScanRightEdge (void)
{
@ -340,11 +319,6 @@ D_SpriteScanRightEdge (void)
}
/*
=====================
D_SpriteCalculateGradients
=====================
*/
void
D_SpriteCalculateGradients (void)
{
@ -381,17 +355,12 @@ D_SpriteCalculateGradients (void)
tadjust = ((fixed16_t) (DotProduct (p_temp1, p_taxis) * 0x10000 + 0.5)) -
(-(sprite_height >> 1) << 16);
// -1 (-epsilon) so we never wander off the edge of the texture
// -1 (-epsilon) so we never wander off the edge of the texture
bbextents = (cachewidth << 16) - 1;
bbextentt = (sprite_height << 16) - 1;
}
/*
=====================
D_DrawSprite
=====================
*/
void
D_DrawSprite (void)
{
@ -402,8 +371,8 @@ D_DrawSprite (void)
sprite_spans = spans;
// find the top and bottom vertices, and make sure there's at least one scan to
// draw
// find the top and bottom vertices, and make sure there's at least one
// scan to draw
ymin = 999999.9;
ymax = -999999.9;
pverts = r_spritedesc.pverts;
@ -432,8 +401,8 @@ D_DrawSprite (void)
sprite_height = r_spritedesc.pspriteframe->height;
cacheblock = (byte *) & r_spritedesc.pspriteframe->pixels[0];
// copy the first vertex to the last vertex, so we don't have to deal with
// wrapping
// copy the first vertex to the last vertex, so we don't have to deal with
// wrapping
nump = r_spritedesc.nump;
pverts = r_spritedesc.pverts;
pverts[nump] = pverts[0];

68
nq/source/d_surf.c
View file

@ -50,7 +50,8 @@ surfcache_t *sc_rover, *sc_base;
#define GUARDSIZE 4
void *
void *
D_SurfaceCacheAddress (void)
{
return sc_base;
@ -73,10 +74,10 @@ D_SurfaceCacheForRes (int width, int height)
if (pix > 64000)
size += (pix - 64000) * 3;
return size;
}
void
D_CheckCacheGuard (void)
{
@ -89,6 +90,7 @@ D_CheckCacheGuard (void)
Sys_Error ("D_CheckCacheGuard: failed");
}
void
D_ClearCacheGuard (void)
{
@ -101,12 +103,6 @@ D_ClearCacheGuard (void)
}
/*
================
D_InitCaches
================
*/
void
D_InitCaches (void *buffer, int size)
{
@ -128,11 +124,6 @@ D_InitCaches (void *buffer, int size)
}
/*
==================
D_FlushCaches
==================
*/
void
D_FlushCaches (void)
{
@ -152,11 +143,7 @@ D_FlushCaches (void)
sc_base->size = sc_size;
}
/*
=================
D_SCAlloc
=================
*/
surfcache_t *
D_SCAlloc (int width, int size)
{
@ -174,7 +161,7 @@ D_SCAlloc (int width, int size)
if (size > sc_size)
Sys_Error ("D_SCAlloc: %i > cache size", size);
// if there is not size bytes after the rover, reset to the start
// if there is not size bytes after the rover, reset to the start
wrapped_this_time = false;
if (!sc_rover || (byte *) sc_rover - (byte *) sc_base > sc_size - size) {
@ -183,7 +170,7 @@ D_SCAlloc (int width, int size)
}
sc_rover = sc_base;
}
// colect and free surfcache_t blocks until the rover block is large enough
// colect and free surfcache_t blocks until the rover block is large enough
new = sc_rover;
if (sc_rover->owner)
*sc_rover->owner = NULL;
@ -200,7 +187,7 @@ D_SCAlloc (int width, int size)
new->next = sc_rover->next;
}
// create a fragment out of any leftovers
// create a fragment out of any leftovers
if (new->size - size > 256) {
sc_rover = (surfcache_t *) ((byte *) new + size);
sc_rover->size = new->size - size;
@ -217,8 +204,7 @@ D_SCAlloc (int width, int size)
if (width > 0)
new->height = (size - sizeof (*new) + sizeof (new->data)) / width;
new->owner = NULL; // should be set properly after
// return
new->owner = NULL; // should be set properly after return
if (d_roverwrapped) {
if (wrapped_this_time || (sc_rover >= d_initial_rover))
@ -232,11 +218,6 @@ D_SCAlloc (int width, int size)
}
/*
=================
D_SCDump
=================
*/
void
D_SCDump (void)
{
@ -249,10 +230,8 @@ D_SCDump (void)
}
}
//=============================================================================
// if the num is not a power of 2, assume it will not repeat
int
MaskForNum (int num)
{
@ -267,6 +246,7 @@ MaskForNum (int num)
return 255;
}
int
D_log2 (int num)
{
@ -279,30 +259,20 @@ D_log2 (int num)
return c;
}
//=============================================================================
/*
================
D_CacheSurface
================
*/
surfcache_t *
D_CacheSurface (msurface_t *surface, int miplevel)
{
surfcache_t *cache;
//
// if the surface is animating or flashing, flush the cache
//
// if the surface is animating or flashing, flush the cache
r_drawsurf.texture = R_TextureAnimation (surface->texinfo->texture);
r_drawsurf.lightadj[0] = d_lightstylevalue[surface->styles[0]];
r_drawsurf.lightadj[1] = d_lightstylevalue[surface->styles[1]];
r_drawsurf.lightadj[2] = d_lightstylevalue[surface->styles[2]];
r_drawsurf.lightadj[3] = d_lightstylevalue[surface->styles[3]];
//
// see if the cache holds apropriate data
//
// see if the cache holds apropriate data
cache = surface->cachespots[miplevel];
if (cache && !cache->dlight && surface->dlightframe != r_framecount
@ -313,20 +283,16 @@ D_CacheSurface (msurface_t *surface, int miplevel)
&& cache->lightadj[3] == r_drawsurf.lightadj[3])
return cache;
//
// determine shape of surface
//
// determine shape of surface
surfscale = 1.0 / (1 << miplevel);
r_drawsurf.surfmip = miplevel;
r_drawsurf.surfwidth = surface->extents[0] >> miplevel;
r_drawsurf.rowbytes = r_drawsurf.surfwidth;
r_drawsurf.surfheight = surface->extents[1] >> miplevel;
//
// allocate memory if needed
//
// allocate memory if needed
if (!cache) // if a texture just animated, don't
// reallocate it
// reallocate it
{
cache = D_SCAlloc (r_drawsurf.surfwidth,
r_drawsurf.surfwidth * r_drawsurf.surfheight);
@ -348,9 +314,7 @@ D_CacheSurface (msurface_t *surface, int miplevel)
cache->lightadj[2] = r_drawsurf.lightadj[2];
cache->lightadj[3] = r_drawsurf.lightadj[3];
//
// draw and light the surface texture
//
// draw and light the surface texture
r_drawsurf.surf = surface;
c_surf++;

4
nq/source/d_vars.c
View file

@ -37,9 +37,7 @@
// all global and static refresh variables are collected in a contiguous block
// to avoid cache conflicts.
//-------------------------------------------------------
// global refresh variables
//-------------------------------------------------------
// global refresh variables ----------------------------
// FIXME: make into one big structure, like cl or sv
// FIXME: do separately for refresh engine and driver

5
nq/source/d_zpoint.c
View file

@ -33,11 +33,6 @@
#include "d_local.h"
/*
=====================
D_DrawZPoint
=====================
*/
void
D_DrawZPoint (void)
{

42
qw/source/d_edge.c
View file

@ -43,9 +43,7 @@ int vstartscan;
vec3_t transformed_modelorg;
/*
D_DrawPoly
*/
void
D_DrawPoly (void)
{
@ -53,9 +51,6 @@ D_DrawPoly (void)
}
/*
D_MipLevelForScale
*/
int
D_MipLevelForScale (float scale)
{
@ -77,12 +72,7 @@ D_MipLevelForScale (float scale)
}
/*
D_DrawSolidSurface
*/
// FIXME: clean this up
void
D_DrawSolidSurface (surf_t *surf, int color)
{
@ -115,9 +105,6 @@ D_DrawSolidSurface (surf_t *surf, int color)
}
/*
D_CalcGradients
*/
void
D_CalcGradients (msurface_t *pface)
{
@ -157,17 +144,12 @@ D_CalcGradients (msurface_t *pface)
((pface->texturemins[1] << 16) >> miplevel)
+ pface->texinfo->vecs[1][3] * t;
//
// -1 (-epsilon) so we never wander off the edge of the texture
//
// -1 (-epsilon) so we never wander off the edge of the texture
bbextents = ((pface->extents[0] << 16) >> miplevel) - 1;
bbextentt = ((pface->extents[1] << 16) >> miplevel) - 1;
}
/*
D_DrawSurfaces
*/
void
D_DrawSurfaces (void)
{
@ -181,7 +163,7 @@ D_DrawSurfaces (void)
TransformVector (modelorg, transformed_modelorg);
VectorCopy (transformed_modelorg, world_transformed_modelorg);
// TODO: could preset a lot of this at mode set time
// TODO: could preset a lot of this at mode set time
if (r_drawflat->int_val) {
for (s = &surfaces[1]; s < surface_p; s++) {
if (!s->spans)
@ -234,15 +216,13 @@ D_DrawSurfaces (void)
// FIXME: we don't want to do all this for every polygon!
// TODO: store once at start of frame
currententity = s->entity; // FIXME: make this passed in
// to
// R_RotateBmodel ()
// to R_RotateBmodel ()
VectorSubtract (r_origin, currententity->origin,
local_modelorg);
TransformVector (local_modelorg, transformed_modelorg);
R_RotateBmodel (); // FIXME: don't mess with the
// frustum,
// make entity passed in
// frustum, make entity passed in
}
D_CalcGradients (pface);
@ -251,11 +231,10 @@ D_DrawSurfaces (void)
D_DrawZSpans (s->spans);
if (s->insubmodel) {
//
// restore the old drawing state
// FIXME: we don't want to do this every time!
// TODO: speed up
//
currententity = &r_worldentity;
VectorCopy (world_transformed_modelorg,
transformed_modelorg);
@ -270,15 +249,13 @@ D_DrawSurfaces (void)
// FIXME: we don't want to do all this for every polygon!
// TODO: store once at start of frame
currententity = s->entity; // FIXME: make this passed in
// to
// R_RotateBmodel ()
// to R_RotateBmodel ()
VectorSubtract (r_origin, currententity->origin,
local_modelorg);
TransformVector (local_modelorg, transformed_modelorg);
R_RotateBmodel (); // FIXME: don't mess with the
// frustum,
// make entity passed in
// frustum, make entity passed in
}
pface = s->data;
@ -298,11 +275,10 @@ D_DrawSurfaces (void)
D_DrawZSpans (s->spans);
if (s->insubmodel) {
//
// restore the old drawing state
// FIXME: we don't want to do this every time!
// TODO: speed up
//
VectorCopy (world_transformed_modelorg,
transformed_modelorg);
VectorCopy (base_vpn, vpn);

3
qw/source/d_fill.c
View file

@ -33,9 +33,6 @@
#include "d_iface.h"
/*
D_FillRect
*/
void
D_FillRect (vrect_t *rect, int color)
{

26
qw/source/d_init.c
View file

@ -53,9 +53,6 @@ extern int d_aflatcolor;
void (*d_drawspans) (espan_t *pspan);
/*
D_Init
*/
void
D_Init (void)
{
@ -74,9 +71,7 @@ D_Init (void)
VID_InitBuffers ();
}
/*
D_CopyRects
*/
void
D_CopyRects (vrect_t *prects, int transparent)
{
@ -92,9 +87,6 @@ D_CopyRects (vrect_t *prects, int transparent)
}
/*
D_EnableBackBufferAccess
*/
void
D_EnableBackBufferAccess (void)
{
@ -103,9 +95,6 @@ D_EnableBackBufferAccess (void)
}
/*
D_TurnZOn
*/
void
D_TurnZOn (void)
{
@ -113,9 +102,6 @@ D_TurnZOn (void)
}
/*
D_DisableBackBufferAccess
*/
void
D_DisableBackBufferAccess (void)
{
@ -123,9 +109,6 @@ D_DisableBackBufferAccess (void)
}
/*
D_SetupFrame
*/
void
D_SetupFrame (void)
{
@ -162,14 +145,9 @@ D_SetupFrame (void)
}
/*
D_UpdateRects
*/
void
D_UpdateRects (vrect_t *prect)
{
// the software driver draws these directly to the vid buffer
// the software driver draws these directly to the vid buffer
UNUSED (prect);
}

7
qw/source/d_modech.c
View file

@ -42,9 +42,7 @@ int d_y_aspect_shift, d_pix_min, d_pix_max, d_pix_shift;
int d_scantable[MAXHEIGHT];
short *zspantable[MAXHEIGHT];
/*
D_Patch
*/
void
D_Patch (void)
{
@ -62,9 +60,6 @@ D_Patch (void)
}
/*
D_ViewChanged
*/
void
D_ViewChanged (void)
{

170
qw/source/d_part.c
View file

@ -48,7 +48,6 @@ D_StartParticles (void)
#ifndef USE_INTEL_ASM
void
D_DrawParticle (particle_t *pparticle)
{
@ -58,7 +57,7 @@ D_DrawParticle (particle_t *pparticle)
short *pz;
int i, izi, pix, count, u, v;
// transform point
// transform point
VectorSubtract (pparticle->org, r_origin, local);
transformed[0] = DotProduct (local, r_pright);
@ -67,9 +66,8 @@ D_DrawParticle (particle_t *pparticle)
if (transformed[2] < PARTICLE_Z_CLIP)
return;
// project the point
// FIXME: preadjust xcenter and ycenter
// project the point
// FIXME: preadjust xcenter and ycenter
zi = 1.0 / transformed[2];
u = (int) (xcenter + zi * transformed[0] + 0.5);
v = (int) (ycenter - zi * transformed[1] + 0.5);
@ -91,93 +89,87 @@ D_DrawParticle (particle_t *pparticle)
pix = d_pix_max;
switch (pix) {
case 1:
count = 1 << d_y_aspect_shift;
case 1:
count = 1 << d_y_aspect_shift;
for (; count; count--, pz += d_zwidth, pdest += screenwidth) {
if (pz[0] <= izi) {
pz[0] = izi;
pdest[0] = pparticle->color;
}
}
break;
for (; count; count--, pz += d_zwidth, pdest += screenwidth) {
if (pz[0] <= izi) {
pz[0] = izi;
pdest[0] = pparticle->color;
case 2:
count = 2 << d_y_aspect_shift;
for (; count; count--, pz += d_zwidth, pdest += screenwidth) {
if (pz[0] <= izi) {
pz[0] = izi;
pdest[0] = pparticle->color;
}
if (pz[1] <= izi) {
pz[1] = izi;
pdest[1] = pparticle->color;
}
}
break;
case 3:
count = 3 << d_y_aspect_shift;
for (; count; count--, pz += d_zwidth, pdest += screenwidth) {
if (pz[0] <= izi) {
pz[0] = izi;
pdest[0] = pparticle->color;
}
if (pz[1] <= izi) {
pz[1] = izi;
pdest[1] = pparticle->color;
}
if (pz[2] <= izi) {
pz[2] = izi;
pdest[2] = pparticle->color;
}
}
break;
case 4:
count = 4 << d_y_aspect_shift;
for (; count; count--, pz += d_zwidth, pdest += screenwidth) {
if (pz[0] <= izi) {
pz[0] = izi;
pdest[0] = pparticle->color;
}
if (pz[1] <= izi) {
pz[1] = izi;
pdest[1] = pparticle->color;
}
if (pz[2] <= izi) {
pz[2] = izi;
pdest[2] = pparticle->color;
}
if (pz[3] <= izi) {
pz[3] = izi;
pdest[3] = pparticle->color;
}
}
break;
default:
count = pix << d_y_aspect_shift;
for (; count; count--, pz += d_zwidth, pdest += screenwidth) {
for (i = 0; i < pix; i++) {
if (pz[i] <= izi) {
pz[i] = izi;
pdest[i] = pparticle->color;
}
}
break;
case 2:
count = 2 << d_y_aspect_shift;
for (; count; count--, pz += d_zwidth, pdest += screenwidth) {
if (pz[0] <= izi) {
pz[0] = izi;
pdest[0] = pparticle->color;
}
if (pz[1] <= izi) {
pz[1] = izi;
pdest[1] = pparticle->color;
}
}
break;
case 3:
count = 3 << d_y_aspect_shift;
for (; count; count--, pz += d_zwidth, pdest += screenwidth) {
if (pz[0] <= izi) {
pz[0] = izi;
pdest[0] = pparticle->color;
}
if (pz[1] <= izi) {
pz[1] = izi;
pdest[1] = pparticle->color;
}
if (pz[2] <= izi) {
pz[2] = izi;
pdest[2] = pparticle->color;
}
}
break;
case 4:
count = 4 << d_y_aspect_shift;
for (; count; count--, pz += d_zwidth, pdest += screenwidth) {
if (pz[0] <= izi) {
pz[0] = izi;
pdest[0] = pparticle->color;
}
if (pz[1] <= izi) {
pz[1] = izi;
pdest[1] = pparticle->color;
}
if (pz[2] <= izi) {
pz[2] = izi;
pdest[2] = pparticle->color;
}
if (pz[3] <= izi) {
pz[3] = izi;
pdest[3] = pparticle->color;
}
}
break;
default:
count = pix << d_y_aspect_shift;
for (; count; count--, pz += d_zwidth, pdest += screenwidth) {
for (i = 0; i < pix; i++) {
if (pz[i] <= izi) {
pz[i] = izi;
pdest[i] = pparticle->color;
}
}
}
break;
}
break;
}
}
#endif // !USE_INTEL_ASM

101
qw/source/d_polyse.c
View file

@ -128,9 +128,6 @@ void D_PolysetScanLeftEdge (int height);
#ifndef USE_INTEL_ASM
/*
D_PolysetDraw
*/
void
D_PolysetDraw (void)
{
@ -150,9 +147,6 @@ D_PolysetDraw (void)
}
/*
D_PolysetDrawFinalVerts
*/
void
D_PolysetDrawFinalVerts (finalvert_t *fv, int numverts)
{
@ -179,9 +173,6 @@ D_PolysetDrawFinalVerts (finalvert_t *fv, int numverts)
}
/*
D_DrawSubdiv
*/
void
D_DrawSubdiv (void)
{
@ -234,9 +225,6 @@ D_DrawSubdiv (void)
}
/*
D_DrawNonSubdiv
*/
void
D_DrawNonSubdiv (void)
{
@ -298,9 +286,6 @@ D_DrawNonSubdiv (void)
}
/*
D_PolysetRecursiveTriangle
*/
void
D_PolysetRecursiveTriangle (int *lp1, int *lp2, int *lp3)
{
@ -347,14 +332,14 @@ D_PolysetRecursiveTriangle (int *lp1, int *lp2, int *lp3)
lp3 = temp;
split:
// split this edge
// 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
// draw the point if splitting a leading edge
if (lp2[1] > lp1[1])
goto nodraw;
if ((lp2[1] == lp1[1]) && (lp2[0] < lp1[0]))
@ -372,7 +357,7 @@ D_PolysetRecursiveTriangle (int *lp1, int *lp2, int *lp3)
}
nodraw:
// recursively continue
// recursively continue
D_PolysetRecursiveTriangle (lp3, lp1, new);
D_PolysetRecursiveTriangle (lp3, new, lp2);
}
@ -380,9 +365,6 @@ D_PolysetRecursiveTriangle (int *lp1, int *lp2, int *lp3)
#endif // !USE_INTEL_ASM
/*
D_PolysetUpdateTables
*/
void
D_PolysetUpdateTables (void)
{
@ -401,10 +383,6 @@ D_PolysetUpdateTables (void)
#ifndef USE_INTEL_ASM
/*
D_PolysetScanLeftEdge
*/
void
D_PolysetScanLeftEdge (int height)
{
@ -460,13 +438,9 @@ D_PolysetScanLeftEdge (int height)
}
} while (--height);
}
#endif // !USE_INTEL_ASM
/*
D_PolysetSetUpForLineScan
*/
void
D_PolysetSetUpForLineScan (fixed8_t startvertu, fixed8_t startvertv,
fixed8_t endvertu, fixed8_t endvertv)
@ -499,10 +473,6 @@ D_PolysetSetUpForLineScan (fixed8_t startvertu, fixed8_t startvertv,
#ifndef USE_INTEL_ASM
/*
D_PolysetCalcGradients
*/
void
D_PolysetCalcGradients (int skinwidth)
{
@ -559,11 +529,11 @@ D_PolysetCalcGradients (int skinwidth)
a_ststepxwhole = skinwidth * (r_tstepx >> 16) + (r_sstepx >> 16);
}
#endif // !USE_INTEL_ASM
byte gelmap[256];
void
InitGel (byte * palette)
{
@ -581,10 +551,6 @@ InitGel (byte * palette)
#ifndef USE_INTEL_ASM
/*
D_PolysetDrawSpans8
*/
void
D_PolysetDrawSpans8 (spanpackage_t * pspanpackage)
{
@ -644,9 +610,6 @@ D_PolysetDrawSpans8 (spanpackage_t * pspanpackage)
#endif // !USE_INTEL_ASM
/*
D_PolysetFillSpans8
*/
void
D_PolysetFillSpans8 (spanpackage_t * pspanpackage)
{
@ -677,9 +640,7 @@ D_PolysetFillSpans8 (spanpackage_t * pspanpackage)
}
}
/*
D_RasterizeAliasPolySmooth
*/
void
D_RasterizeAliasPolySmooth (void)
{
@ -696,19 +657,13 @@ D_RasterizeAliasPolySmooth (void)
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
//
// 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
//
// scan out the top (and possibly only) part of the left edge
D_PolysetSetUpForLineScan (plefttop[0], plefttop[1],
pleftbottom[0], pleftbottom[1]);
@ -740,9 +695,9 @@ D_RasterizeAliasPolySmooth (void)
// 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)
// 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
@ -776,9 +731,7 @@ D_RasterizeAliasPolySmooth (void)
D_PolysetScanLeftEdge (initialleftheight);
//
// scan out the bottom part of the left edge, if it exists
//
// scan out the bottom part of the left edge, if it exists
if (pedgetable->numleftedges == 2) {
int height;
@ -849,8 +802,8 @@ D_RasterizeAliasPolySmooth (void)
D_PolysetScanLeftEdge (height);
}
// scan out the top (and possibly only) part of the right edge, updating the
// count field
// 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],
@ -862,7 +815,7 @@ D_RasterizeAliasPolySmooth (void)
// spanpackages
D_PolysetDrawSpans8 (a_spans);
// scan out the bottom part of the right edge, if it exists
// scan out the bottom part of the right edge, if it exists
if (pedgetable->numrightedges == 2) {
int height;
spanpackage_t *pstart;
@ -888,21 +841,16 @@ D_RasterizeAliasPolySmooth (void)
}
/*
D_PolysetSetEdgeTable
*/
void
D_PolysetSetEdgeTable (void)
{
int edgetableindex;
edgetableindex = 0; // assume the vertices are already in
// top to bottom order
// top to bottom order
//
// determine which edges are right & left, and the order in which
// to rasterize them
//
// 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])
@ -961,7 +909,7 @@ D_PolysetRecursiveDrawLine (int *lp1, int *lp2)
return; // line is completed
split:
// split this edge
// split this edge
new[0] = (lp1[0] + lp2[0]) >> 1;
new[1] = (lp1[1] + lp2[1]) >> 1;
new[5] = (lp1[5] + lp2[5]) >> 1;
@ -969,21 +917,22 @@ D_PolysetRecursiveDrawLine (int *lp1, int *lp2)
new[3] = (lp1[3] + lp2[3]) >> 1;
new[4] = (lp1[4] + lp2[4]) >> 1;
// draw the point
// 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 = ((byte *)acolormap)[pix + (new[4] & 0xFF00)];
// pix = ((byte *)acolormap)[pix + (new[4] & 0xFF00)];
d_viewbuffer[ofs] = pix;
}
// recursively continue
// recursively continue
D_PolysetRecursiveDrawLine (lp1, new);
D_PolysetRecursiveDrawLine (new, lp2);
}
void
D_PolysetRecursiveTriangle2 (int *lp1, int *lp2, int *lp3)
{
@ -999,7 +948,7 @@ D_PolysetRecursiveTriangle2 (int *lp1, int *lp2, int *lp3)
return;
split:
// split this edge
// split this edge
new[0] = (lp1[0] + lp2[0]) >> 1;
new[1] = (lp1[1] + lp2[1]) >> 1;
new[5] = (lp1[5] + lp2[5]) >> 1;
@ -1009,7 +958,7 @@ D_PolysetRecursiveTriangle2 (int *lp1, int *lp2, int *lp3)
D_PolysetRecursiveDrawLine (new, lp3);
// recursively continue
// recursively continue
D_PolysetRecursiveTriangle (lp1, new, lp3);
D_PolysetRecursiveTriangle (new, lp2, lp3);
}

53
qw/source/d_scan.c
View file

@ -95,10 +95,6 @@ D_WarpScreen (void)
#ifndef USE_INTEL_ASM
/*
D_DrawTurbulent8Span
*/
void
D_DrawTurbulent8Span (void)
{
@ -116,12 +112,9 @@ D_DrawTurbulent8Span (void)
r_turb_t += r_turb_tstep;
} while (--r_turb_spancount > 0);
}
#endif // !USE_INTEL_ASM
/*
Turbulent8
*/
void
Turbulent8 (espan_t *pspan)
{
@ -205,12 +198,9 @@ Turbulent8 (espan_t *pspan)
r_turb_tstep = (tnext - r_turb_t) >> 4;
} else {
// calculate s/z, t/z, zi->fixed s and t at last pixel in
// span (so
// can't step off polygon), clamp, calculate s and t steps
// across
// span by division, biasing steps low so we don't run off
// the
// texture
// span (so can't step off polygon), clamp, calculate s and t
// steps across span by division, biasing steps low so we
// don't run off the texture
spancountminus1 = (float) (r_turb_spancount - 1);
sdivz += d_sdivzstepu * spancountminus1;
tdivz += d_tdivzstepu * spancountminus1;
@ -220,10 +210,9 @@ Turbulent8 (espan_t *pspan)
if (snext > bbextents)
snext = bbextents;
else if (snext < 16)
snext = 16; // prevent round-off error on <0
// steps from
// from causing overstepping & running off the
// edge of the texture
snext = 16; // prevent round-off error on <0 steps
// from causing overstepping & running
// off the edge of the texture
tnext = (int) (tdivz * z) + tadjust;
if (tnext > bbextentt)
@ -253,10 +242,6 @@ Turbulent8 (espan_t *pspan)
#ifndef USE_INTEL_ASM
/*
D_DrawSpans8
*/
void
D_DrawSpans8 (espan_t *pspan)
{
@ -338,13 +323,10 @@ D_DrawSpans8 (espan_t *pspan)
sstep = (snext - s) >> 3;
tstep = (tnext - t) >> 3;
} else {
// calculate s/z, t/z, zi->fixed s and t at last pixel in
// span (so
// can't step off polygon), clamp, calculate s and t steps
// across
// span by division, biasing steps low so we don't run off
// the
// texture
// calculate s/z, t/z, zi->fixed s and t at last pixel in span
// (so can't step off polygon), clamp, calculate s and t steps
// across span by division, biasing steps low so we don't run
// off the texture
spancountminus1 = (float) (spancount - 1);
sdivz += d_sdivzstepu * spancountminus1;
tdivz += d_tdivzstepu * spancountminus1;
@ -354,10 +336,9 @@ D_DrawSpans8 (espan_t *pspan)
if (snext > bbextents)
snext = bbextents;
else if (snext < 8)
snext = 8; // prevent round-off error on <0
// steps from
// from causing overstepping & running off the
// edge of the texture
snext = 8; // prevent round-off error on <0 steps
// from from causing overstepping &
// running off the edge of the texture
tnext = (int) (tdivz * z) + tadjust;
if (tnext > bbextentt)
@ -385,15 +366,10 @@ D_DrawSpans8 (espan_t *pspan)
} while ((pspan = pspan->pnext) != NULL);
}
#endif
#ifndef USE_INTEL_ASM
/*
D_DrawZSpans
*/
void
D_DrawZSpans (espan_t *pspan)
{
@ -443,5 +419,4 @@ D_DrawZSpans (espan_t *pspan)
} while ((pspan = pspan->pnext) != NULL);
}
#endif

6
qw/source/d_sky.c
View file

@ -38,9 +38,6 @@
#define SKY_SPAN_MAX (1 << SKY_SPAN_SHIFT)
/*
D_Sky_uv_To_st
*/
void
D_Sky_uv_To_st (int u, int v, fixed16_t *s, fixed16_t *t)
{
@ -68,9 +65,6 @@ D_Sky_uv_To_st (int u, int v, fixed16_t *s, fixed16_t *t)
}
/*
D_DrawSkyScans8
*/
void
D_DrawSkyScans8 (espan_t *pspan)
{

43
qw/source/d_sprite.c
View file

@ -37,11 +37,9 @@ static int sprite_height;
static int minindex, maxindex;
static sspan_t *sprite_spans;
#ifndef USE_INTEL_ASM
/*
D_SpriteDrawSpans
*/
void
D_SpriteDrawSpans (sspan_t *pspan)
{
@ -135,12 +133,9 @@ D_SpriteDrawSpans (sspan_t *pspan)
tstep = (tnext - t) >> 3;
} else {
// calculate s/z, t/z, zi->fixed s and t at last pixel in
// span (so
// can't step off polygon), clamp, calculate s and t steps
// across
// span by division, biasing steps low so we don't run off
// the
// texture
// span (so can't step off polygon), clamp, calculate s and t
// steps across span by division, biasing steps low so we
// don't run off the texture
spancountminus1 = (float) (spancount - 1);
sdivz += d_sdivzstepu * spancountminus1;
tdivz += d_tdivzstepu * spancountminus1;
@ -150,10 +145,9 @@ D_SpriteDrawSpans (sspan_t *pspan)
if (snext > bbextents)
snext = bbextents;
else if (snext < 8)
snext = 8; // prevent round-off error on <0
// steps from
// from causing overstepping & running off the
// edge of the texture
snext = 8; // prevent round-off error on <0 steps
// from from causing overstepping &
// running off the edge of the texture
tnext = (int) (tdivz * z) + tadjust;
if (tnext > bbextentt)
@ -194,13 +188,9 @@ D_SpriteDrawSpans (sspan_t *pspan)
} while (pspan->count != DS_SPAN_LIST_END);
}
#endif
/*
D_SpriteScanLeftEdge
*/
void
D_SpriteScanLeftEdge (void)
{
@ -256,9 +246,6 @@ D_SpriteScanLeftEdge (void)
}
/*
D_SpriteScanRightEdge
*/
void
D_SpriteScanRightEdge (void)
{
@ -334,9 +321,6 @@ D_SpriteScanRightEdge (void)
}
/*
D_SpriteCalculateGradients
*/
void
D_SpriteCalculateGradients (void)
{
@ -373,15 +357,12 @@ D_SpriteCalculateGradients (void)
tadjust = ((fixed16_t) (DotProduct (p_temp1, p_taxis) * 0x10000 + 0.5)) -
(-(sprite_height >> 1) << 16);
// -1 (-epsilon) so we never wander off the edge of the texture
// -1 (-epsilon) so we never wander off the edge of the texture
bbextents = (cachewidth << 16) - 1;
bbextentt = (sprite_height << 16) - 1;
}
/*
D_DrawSprite
*/
void
D_DrawSprite (void)
{
@ -392,8 +373,8 @@ D_DrawSprite (void)
sprite_spans = spans;
// find the top and bottom vertices, and make sure there's at least one scan to
// draw
// find the top and bottom vertices, and make sure there's at least one
// scan to draw
ymin = 999999.9;
ymax = -999999.9;
pverts = r_spritedesc.pverts;
@ -422,8 +403,8 @@ D_DrawSprite (void)
sprite_height = r_spritedesc.pspriteframe->height;
cacheblock = (byte *) & r_spritedesc.pspriteframe->pixels[0];
// copy the first vertex to the last vertex, so we don't have to deal with
// wrapping
// copy the first vertex to the last vertex, so we don't have to deal with
// wrapping
nump = r_spritedesc.nump;
pverts = r_spritedesc.pverts;
pverts[nump] = pverts[0];

59
qw/source/d_surf.c
View file

@ -45,12 +45,14 @@ surfcache_t *sc_rover, *sc_base;
#define GUARDSIZE 4
void *
void *
D_SurfaceCacheAddress (void)
{
return sc_base;
}
int
D_SurfaceCacheForRes (int width, int height)
{
@ -71,6 +73,7 @@ D_SurfaceCacheForRes (int width, int height)
return size;
}
void
D_CheckCacheGuard (void)
{
@ -83,6 +86,7 @@ D_CheckCacheGuard (void)
Sys_Error ("D_CheckCacheGuard: failed");
}
void
D_ClearCacheGuard (void)
{
@ -95,14 +99,11 @@ D_ClearCacheGuard (void)
}
/*
D_InitCaches
*/
void
D_InitCaches (void *buffer, int size)
{
// if (!msg_suppress_1)
// Con_Printf ("%ik surface cache\n", size/1024);
// if (!msg_suppress_1)
// Con_Printf ("%ik surface cache\n", size/1024);
sc_size = size - GUARDSIZE;
sc_base = (surfcache_t *) buffer;
@ -118,9 +119,6 @@ D_InitCaches (void *buffer, int size)
}
/*
D_FlushCaches
*/
void
D_FlushCaches (void)
{
@ -140,9 +138,7 @@ D_FlushCaches (void)
sc_base->size = sc_size;
}
/*
D_SCAlloc
*/
surfcache_t *
D_SCAlloc (int width, int size)
{
@ -165,7 +161,7 @@ D_SCAlloc (int width, int size)
if (size > sc_size)
Sys_Error ("D_SCAlloc: %i > cache size", size);
// if there is not size bytes after the rover, reset to the start
// if there is not size bytes after the rover, reset to the start
wrapped_this_time = false;
if (!sc_rover || (byte *) sc_rover - (byte *) sc_base > sc_size - size) {
@ -174,7 +170,7 @@ D_SCAlloc (int width, int size)
}
sc_rover = sc_base;
}
// colect and free surfcache_t blocks until the rover block is large enough
// colect and free surfcache_t blocks until the rover block is large enough
new = sc_rover;
if (sc_rover->owner)
*sc_rover->owner = NULL;
@ -191,7 +187,7 @@ D_SCAlloc (int width, int size)
new->next = sc_rover->next;
}
// create a fragment out of any leftovers
// create a fragment out of any leftovers
if (new->size - size > 256) {
sc_rover = (surfcache_t *) ((byte *) new + size);
sc_rover->size = new->size - size;
@ -208,8 +204,7 @@ D_SCAlloc (int width, int size)
if (width > 0)
new->height = (size - sizeof (*new) + sizeof (new->data)) / width;
new->owner = NULL; // should be set properly after
// return
new->owner = NULL; // should be set properly after return
if (d_roverwrapped) {
if (wrapped_this_time || (sc_rover >= d_initial_rover))
@ -223,9 +218,6 @@ D_SCAlloc (int width, int size)
}
/*
D_SCDump
*/
void
D_SCDump (void)
{
@ -239,10 +231,8 @@ D_SCDump (void)
}
}
//=============================================================================
// if the num is not a power of 2, assume it will not repeat
int
MaskForNum (int num)
{
@ -257,6 +247,7 @@ MaskForNum (int num)
return 255;
}
int
D_log2 (int num)
{
@ -269,28 +260,20 @@ D_log2 (int num)
return c;
}
//=============================================================================
/*
D_CacheSurface
*/
surfcache_t *
D_CacheSurface (msurface_t *surface, int miplevel)
{
surfcache_t *cache;
//
// if the surface is animating or flashing, flush the cache
//
// if the surface is animating or flashing, flush the cache
r_drawsurf.texture = R_TextureAnimation (surface->texinfo->texture);
r_drawsurf.lightadj[0] = d_lightstylevalue[surface->styles[0]];
r_drawsurf.lightadj[1] = d_lightstylevalue[surface->styles[1]];
r_drawsurf.lightadj[2] = d_lightstylevalue[surface->styles[2]];
r_drawsurf.lightadj[3] = d_lightstylevalue[surface->styles[3]];
//
// see if the cache holds apropriate data
//
// see if the cache holds apropriate data
cache = surface->cachespots[miplevel];
if (cache && !cache->dlight && surface->dlightframe != r_framecount
@ -301,18 +284,14 @@ D_CacheSurface (msurface_t *surface, int miplevel)
&& cache->lightadj[3] == r_drawsurf.lightadj[3])
return cache;
//
// determine shape of surface
//
// determine shape of surface
surfscale = 1.0 / (1 << miplevel);
r_drawsurf.surfmip = miplevel;
r_drawsurf.surfwidth = surface->extents[0] >> miplevel;
r_drawsurf.rowbytes = r_drawsurf.surfwidth;
r_drawsurf.surfheight = surface->extents[1] >> miplevel;
//
// allocate memory if needed
//
// allocate memory if needed
if (!cache) // if a texture just animated, don't
// reallocate it
{
@ -336,9 +315,7 @@ D_CacheSurface (msurface_t *surface, int miplevel)
cache->lightadj[2] = r_drawsurf.lightadj[2];
cache->lightadj[3] = r_drawsurf.lightadj[3];
//
// draw and light the surface texture
//
// draw and light the surface texture
r_drawsurf.surf = surface;
c_surf++;

4
qw/source/d_vars.c
View file

@ -37,9 +37,7 @@
// all global and static refresh variables are collected in a contiguous block
// to avoid cache conflicts.
//-------------------------------------------------------
// global refresh variables
//-------------------------------------------------------
// global refresh variables -----------------------------
// FIXME: make into one big structure, like cl or sv
// FIXME: do separately for refresh engine and driver

3
qw/source/d_zpoint.c
View file

@ -33,9 +33,6 @@
#include "d_local.h"
/*
D_DrawZPoint
*/
void
D_DrawZPoint (void)
{