You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1420 lines
33 KiB
1420 lines
33 KiB
/* |
|
Copyright (C) 1997-2001 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_scan.c |
|
// |
|
// Portable C scan-level rasterization code, all pixel depths. |
|
|
|
#include "r_local.h" |
|
|
|
pixel_t *r_turb_pbase, *r_turb_pdest; |
|
short *r_turb_pz; |
|
fixed16_t r_turb_s, r_turb_t, r_turb_sstep, r_turb_tstep; |
|
int r_turb_izistep, r_turb_izi; |
|
int *r_turb_turb; |
|
static int r_turb_spancount; |
|
int alpha; |
|
|
|
void D_DrawTurbulent8Span (void); |
|
|
|
|
|
/* |
|
============= |
|
D_WarpScreen |
|
|
|
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) |
|
{ |
|
#if 0 |
|
int w, h; |
|
int u,v, u2, v2; |
|
byte *dest; |
|
int *turb; |
|
int *col; |
|
byte **row; |
|
|
|
static int cached_width, cached_height; |
|
static byte *rowptr[1200+AMP2*2]; |
|
static int column[1600+AMP2*2]; |
|
|
|
// |
|
// these are constant over resolutions, and can be saved |
|
// |
|
w = r_newrefdef.width; |
|
h = r_newrefdef.height; |
|
if (w != cached_width || h != cached_height) |
|
{ |
|
cached_width = w; |
|
cached_height = h; |
|
for (v=0 ; v<h+AMP2*2 ; v++) |
|
{ |
|
v2 = (int)((float)v/(h + AMP2 * 2) * r_refdef.vrect.height); |
|
rowptr[v] = r_warpbuffer + (WARP_WIDTH * v2); |
|
} |
|
|
|
for (u=0 ; u<w+AMP2*2 ; u++) |
|
{ |
|
u2 = (int)((float)u/(w + AMP2 * 2) * r_refdef.vrect.width); |
|
column[u] = u2; |
|
} |
|
} |
|
|
|
turb = intsintable + ((int)(r_newrefdef.time*SPEED)&(CYCLE-1)); |
|
dest = vid.buffer + r_newrefdef.y * vid.rowbytes + r_newrefdef.x; |
|
|
|
for (v=0 ; v<h ; v++, dest += vid.rowbytes) |
|
{ |
|
col = &column[turb[v]]; |
|
row = &rowptr[v]; |
|
for (u=0 ; u<w ; u+=4) |
|
{ |
|
dest[u+0] = row[turb[u+0]][col[u+0]]; |
|
dest[u+1] = row[turb[u+1]][col[u+1]]; |
|
dest[u+2] = row[turb[u+2]][col[u+2]]; |
|
dest[u+3] = row[turb[u+3]][col[u+3]]; |
|
} |
|
} |
|
#endif |
|
} |
|
|
|
|
|
#if !id386 |
|
|
|
/* |
|
============= |
|
D_DrawTurbulent8Span |
|
============= |
|
*/ |
|
void D_DrawTurbulent8Span (void) |
|
{ |
|
int sturb, tturb; |
|
|
|
do |
|
{ |
|
sturb = ((r_turb_s + r_turb_turb[(r_turb_t>>16)&(CYCLE-1)])>>16)&63; |
|
tturb = ((r_turb_t + r_turb_turb[(r_turb_s>>16)&(CYCLE-1)])>>16)&63; |
|
*r_turb_pdest++ = *(r_turb_pbase + (tturb<<6) + sturb); |
|
r_turb_s += r_turb_sstep; |
|
r_turb_t += r_turb_tstep; |
|
} while (--r_turb_spancount > 0); |
|
} |
|
|
|
|
|
/* |
|
============= |
|
D_DrawTurbulent8Span |
|
============= |
|
*/ |
|
void D_DrawTurbulent8ZSpan (void) |
|
{ |
|
int sturb, tturb; |
|
|
|
do |
|
{ |
|
sturb = ((r_turb_s + r_turb_turb[(r_turb_t>>16)&(CYCLE-1)])>>16)&63; |
|
tturb = ((r_turb_t + r_turb_turb[(r_turb_s>>16)&(CYCLE-1)])>>16)&63; |
|
if (*r_turb_pz <= (r_turb_izi >> 16)) |
|
{ |
|
pixel_t btemp = *(r_turb_pbase + (tturb<<6) + sturb); |
|
if( alpha == 7 ) |
|
*r_turb_pdest = btemp; |
|
else |
|
*r_turb_pdest = BLEND_ALPHA( alpha, btemp, *r_turb_pdest); |
|
} |
|
r_turb_pdest++; |
|
r_turb_pz++; |
|
r_turb_izi += r_turb_izistep; |
|
r_turb_s += r_turb_sstep; |
|
r_turb_t += r_turb_tstep; |
|
} while (--r_turb_spancount > 0); |
|
} |
|
|
|
#endif // !id386 |
|
|
|
|
|
/* |
|
============= |
|
Turbulent8 |
|
============= |
|
*/ |
|
void Turbulent8 (espan_t *pspan) |
|
{ |
|
int count; |
|
fixed16_t snext, tnext; |
|
float sdivz, tdivz, zi, z, du, dv, spancountminus1; |
|
float sdivz16stepu, tdivz16stepu, zi16stepu; |
|
|
|
r_turb_turb = sintable + ((int)(gpGlobals->time*SPEED)&(CYCLE-1)); |
|
|
|
r_turb_sstep = 0; // keep compiler happy |
|
r_turb_tstep = 0; // ditto |
|
|
|
r_turb_pbase = (unsigned char *)cacheblock; |
|
|
|
sdivz16stepu = d_sdivzstepu * 16; |
|
tdivz16stepu = d_tdivzstepu * 16; |
|
zi16stepu = d_zistepu * 16; |
|
|
|
do |
|
{ |
|
r_turb_pdest = (d_viewbuffer + |
|
(r_screenwidth * pspan->v) + pspan->u); |
|
|
|
count = pspan->count; |
|
|
|
// calculate the initial s/z, t/z, 1/z, s, and t and clamp |
|
du = (float)pspan->u; |
|
dv = (float)pspan->v; |
|
|
|
sdivz = d_sdivzorigin + dv*d_sdivzstepv + du*d_sdivzstepu; |
|
tdivz = d_tdivzorigin + dv*d_tdivzstepv + du*d_tdivzstepu; |
|
zi = d_ziorigin + dv*d_zistepv + du*d_zistepu; |
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
|
|
r_turb_s = (int)(sdivz * z) + sadjust; |
|
if (r_turb_s > bbextents) |
|
r_turb_s = bbextents; |
|
else if (r_turb_s < 0) |
|
r_turb_s = 0; |
|
|
|
r_turb_t = (int)(tdivz * z) + tadjust; |
|
if (r_turb_t > bbextentt) |
|
r_turb_t = bbextentt; |
|
else if (r_turb_t < 0) |
|
r_turb_t = 0; |
|
|
|
do |
|
{ |
|
// calculate s and t at the far end of the span |
|
if (count >= 16) |
|
r_turb_spancount = 16; |
|
else |
|
r_turb_spancount = count; |
|
|
|
count -= r_turb_spancount; |
|
|
|
if (count) |
|
{ |
|
// calculate s/z, t/z, zi->fixed s and t at far end of span, |
|
// calculate s and t steps across span by shifting |
|
sdivz += sdivz16stepu; |
|
tdivz += tdivz16stepu; |
|
zi += zi16stepu; |
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
|
|
snext = (int)(sdivz * z) + sadjust; |
|
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 |
|
|
|
tnext = (int)(tdivz * z) + tadjust; |
|
if (tnext > bbextentt) |
|
tnext = bbextentt; |
|
else if (tnext < 16) |
|
tnext = 16; // guard against round-off error on <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 |
|
spancountminus1 = (float)(r_turb_spancount - 1); |
|
sdivz += d_sdivzstepu * spancountminus1; |
|
tdivz += d_tdivzstepu * spancountminus1; |
|
zi += d_zistepu * spancountminus1; |
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
snext = (int)(sdivz * z) + sadjust; |
|
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 |
|
|
|
tnext = (int)(tdivz * z) + tadjust; |
|
if (tnext > bbextentt) |
|
tnext = bbextentt; |
|
else if (tnext < 16) |
|
tnext = 16; // guard against round-off error on <0 steps |
|
|
|
if (r_turb_spancount > 1) |
|
{ |
|
r_turb_sstep = (snext - r_turb_s) / (r_turb_spancount - 1); |
|
r_turb_tstep = (tnext - r_turb_t) / (r_turb_spancount - 1); |
|
} |
|
} |
|
|
|
r_turb_s = r_turb_s & ((CYCLE<<16)-1); |
|
r_turb_t = r_turb_t & ((CYCLE<<16)-1); |
|
|
|
D_DrawTurbulent8Span (); |
|
|
|
r_turb_s = snext; |
|
r_turb_t = tnext; |
|
|
|
} while (count > 0); |
|
|
|
} while ((pspan = pspan->pnext) != NULL); |
|
} |
|
|
|
|
|
/* |
|
============= |
|
Turbulent8 |
|
============= |
|
*/ |
|
void TurbulentZ8 (espan_t *pspan, int alpha1) |
|
{ |
|
int count; |
|
fixed16_t snext, tnext; |
|
float sdivz, tdivz, zi, z, du, dv, spancountminus1; |
|
float sdivz16stepu, tdivz16stepu, zi16stepu; |
|
alpha = alpha1; |
|
|
|
if( alpha > 7 ) |
|
alpha = 7; |
|
if( alpha == 0 ) |
|
return; |
|
|
|
r_turb_turb = sintable + ((int)(gpGlobals->time*SPEED)&(CYCLE-1)); |
|
|
|
r_turb_sstep = 0; // keep compiler happy |
|
r_turb_tstep = 0; // ditto |
|
|
|
r_turb_pbase = (unsigned char *)cacheblock; |
|
|
|
sdivz16stepu = d_sdivzstepu * 16; |
|
tdivz16stepu = d_tdivzstepu * 16; |
|
zi16stepu = d_zistepu * 16; |
|
r_turb_izistep = (int)(d_zistepu * 0x8000 * 0x10000); |
|
|
|
do |
|
{ |
|
r_turb_pdest = (d_viewbuffer + |
|
(r_screenwidth * pspan->v) + pspan->u); |
|
r_turb_pz = d_pzbuffer + (d_zwidth * pspan->v) + pspan->u; |
|
|
|
count = pspan->count; |
|
|
|
// calculate the initial s/z, t/z, 1/z, s, and t and clamp |
|
du = (float)pspan->u; |
|
dv = (float)pspan->v; |
|
|
|
sdivz = d_sdivzorigin + dv*d_sdivzstepv + du*d_sdivzstepu; |
|
tdivz = d_tdivzorigin + dv*d_tdivzstepv + du*d_tdivzstepu; |
|
zi = d_ziorigin + dv*d_zistepv + du*d_zistepu; |
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
r_turb_izi = (int)(zi * 0x8000 * 0x10000); |
|
|
|
r_turb_s = (int)(sdivz * z) + sadjust; |
|
if (r_turb_s > bbextents) |
|
r_turb_s = bbextents; |
|
else if (r_turb_s < 0) |
|
r_turb_s = 0; |
|
|
|
r_turb_t = (int)(tdivz * z) + tadjust; |
|
if (r_turb_t > bbextentt) |
|
r_turb_t = bbextentt; |
|
else if (r_turb_t < 0) |
|
r_turb_t = 0; |
|
|
|
do |
|
{ |
|
// calculate s and t at the far end of the span |
|
if (count >= 16) |
|
r_turb_spancount = 16; |
|
else |
|
r_turb_spancount = count; |
|
|
|
count -= r_turb_spancount; |
|
|
|
if (count) |
|
{ |
|
// calculate s/z, t/z, zi->fixed s and t at far end of span, |
|
// calculate s and t steps across span by shifting |
|
sdivz += sdivz16stepu; |
|
tdivz += tdivz16stepu; |
|
zi += zi16stepu; |
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
|
|
snext = (int)(sdivz * z) + sadjust; |
|
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 |
|
|
|
tnext = (int)(tdivz * z) + tadjust; |
|
if (tnext > bbextentt) |
|
tnext = bbextentt; |
|
else if (tnext < 16) |
|
tnext = 16; // guard against round-off error on <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 |
|
spancountminus1 = (float)(r_turb_spancount - 1); |
|
sdivz += d_sdivzstepu * spancountminus1; |
|
tdivz += d_tdivzstepu * spancountminus1; |
|
zi += d_zistepu * spancountminus1; |
|
|
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
snext = (int)(sdivz * z) + sadjust; |
|
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 |
|
|
|
tnext = (int)(tdivz * z) + tadjust; |
|
if (tnext > bbextentt) |
|
tnext = bbextentt; |
|
else if (tnext < 16) |
|
tnext = 16; // guard against round-off error on <0 steps |
|
|
|
if (r_turb_spancount > 1) |
|
{ |
|
r_turb_sstep = (snext - r_turb_s) / (r_turb_spancount - 1); |
|
r_turb_tstep = (tnext - r_turb_t) / (r_turb_spancount - 1); |
|
} |
|
} |
|
|
|
r_turb_s = r_turb_s & ((CYCLE<<16)-1); |
|
r_turb_t = r_turb_t & ((CYCLE<<16)-1); |
|
|
|
D_DrawTurbulent8ZSpan (); |
|
|
|
r_turb_s = snext; |
|
r_turb_t = tnext; |
|
|
|
} while (count > 0); |
|
|
|
} while ((pspan = pspan->pnext) != NULL); |
|
} |
|
|
|
|
|
|
|
//==================== |
|
//PGM |
|
/* |
|
============= |
|
NonTurbulent8 - this is for drawing scrolling textures. they're warping water textures |
|
but the turbulence is automatically 0. |
|
============= |
|
*/ |
|
void NonTurbulent8 (espan_t *pspan) |
|
{ |
|
int count; |
|
fixed16_t snext, tnext; |
|
float sdivz, tdivz, zi, z, du, dv, spancountminus1; |
|
float sdivz16stepu, tdivz16stepu, zi16stepu; |
|
|
|
// r_turb_turb = sintable + ((int)(r_newrefdef.time*SPEED)&(CYCLE-1)); |
|
r_turb_turb = blanktable; |
|
|
|
r_turb_sstep = 0; // keep compiler happy |
|
r_turb_tstep = 0; // ditto |
|
|
|
r_turb_pbase = cacheblock; |
|
|
|
sdivz16stepu = d_sdivzstepu * 16; |
|
tdivz16stepu = d_tdivzstepu * 16; |
|
zi16stepu = d_zistepu * 16; |
|
|
|
do |
|
{ |
|
r_turb_pdest = (d_viewbuffer + |
|
(r_screenwidth * pspan->v) + pspan->u); |
|
|
|
count = pspan->count; |
|
|
|
// calculate the initial s/z, t/z, 1/z, s, and t and clamp |
|
du = (float)pspan->u; |
|
dv = (float)pspan->v; |
|
|
|
sdivz = d_sdivzorigin + dv*d_sdivzstepv + du*d_sdivzstepu; |
|
tdivz = d_tdivzorigin + dv*d_tdivzstepv + du*d_tdivzstepu; |
|
zi = d_ziorigin + dv*d_zistepv + du*d_zistepu; |
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
|
|
r_turb_s = (int)(sdivz * z) + sadjust; |
|
if (r_turb_s > bbextents) |
|
r_turb_s = bbextents; |
|
else if (r_turb_s < 0) |
|
r_turb_s = 0; |
|
|
|
r_turb_t = (int)(tdivz * z) + tadjust; |
|
if (r_turb_t > bbextentt) |
|
r_turb_t = bbextentt; |
|
else if (r_turb_t < 0) |
|
r_turb_t = 0; |
|
|
|
do |
|
{ |
|
// calculate s and t at the far end of the span |
|
if (count >= 16) |
|
r_turb_spancount = 16; |
|
else |
|
r_turb_spancount = count; |
|
|
|
count -= r_turb_spancount; |
|
|
|
if (count) |
|
{ |
|
// calculate s/z, t/z, zi->fixed s and t at far end of span, |
|
// calculate s and t steps across span by shifting |
|
sdivz += sdivz16stepu; |
|
tdivz += tdivz16stepu; |
|
zi += zi16stepu; |
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
|
|
snext = (int)(sdivz * z) + sadjust; |
|
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 |
|
|
|
tnext = (int)(tdivz * z) + tadjust; |
|
if (tnext > bbextentt) |
|
tnext = bbextentt; |
|
else if (tnext < 16) |
|
tnext = 16; // guard against round-off error on <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 |
|
spancountminus1 = (float)(r_turb_spancount - 1); |
|
sdivz += d_sdivzstepu * spancountminus1; |
|
tdivz += d_tdivzstepu * spancountminus1; |
|
zi += d_zistepu * spancountminus1; |
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
snext = (int)(sdivz * z) + sadjust; |
|
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 |
|
|
|
tnext = (int)(tdivz * z) + tadjust; |
|
if (tnext > bbextentt) |
|
tnext = bbextentt; |
|
else if (tnext < 16) |
|
tnext = 16; // guard against round-off error on <0 steps |
|
|
|
if (r_turb_spancount > 1) |
|
{ |
|
r_turb_sstep = (snext - r_turb_s) / (r_turb_spancount - 1); |
|
r_turb_tstep = (tnext - r_turb_t) / (r_turb_spancount - 1); |
|
} |
|
} |
|
|
|
r_turb_s = r_turb_s & ((CYCLE<<16)-1); |
|
r_turb_t = r_turb_t & ((CYCLE<<16)-1); |
|
|
|
D_DrawTurbulent8Span (); |
|
|
|
r_turb_s = snext; |
|
r_turb_t = tnext; |
|
|
|
} while (count > 0); |
|
|
|
} while ((pspan = pspan->pnext) != NULL); |
|
} |
|
//PGM |
|
//==================== |
|
|
|
|
|
#if !id386 |
|
|
|
int kernel[2][2][2] = |
|
{ |
|
{ |
|
{16384,0}, |
|
{49152,32768} |
|
} |
|
, |
|
{ |
|
{32768,49152}, |
|
{0,16384} |
|
} |
|
}; |
|
#ifndef DISABLE_TEXFILTER |
|
#define SW_TEXFILT (sw_texfilt->value == 1.0f) |
|
#else |
|
#define SW_TEXFILT 0 |
|
#endif |
|
/* |
|
============= |
|
D_DrawSpans16 |
|
|
|
FIXME: actually make this subdivide by 16 instead of 8!!! |
|
============= |
|
*/ |
|
void D_DrawSpans16 (espan_t *pspan) |
|
{ |
|
int count, spancount; |
|
pixel_t *pbase, *pdest; |
|
fixed16_t s, t, snext, tnext, sstep, tstep; |
|
float sdivz, tdivz, zi, z, du, dv, spancountminus1; |
|
float sdivz8stepu, tdivz8stepu, zi8stepu; |
|
|
|
sstep = 0; // keep compiler happy |
|
tstep = 0; // ditto |
|
|
|
pbase = (unsigned char *)cacheblock; |
|
|
|
sdivz8stepu = d_sdivzstepu * 8; |
|
tdivz8stepu = d_tdivzstepu * 8; |
|
zi8stepu = d_zistepu * 8; |
|
|
|
do |
|
{ |
|
pdest = (d_viewbuffer + |
|
(r_screenwidth * pspan->v) + pspan->u); |
|
|
|
count = pspan->count; |
|
|
|
// calculate the initial s/z, t/z, 1/z, s, and t and clamp |
|
du = (float)pspan->u; |
|
dv = (float)pspan->v; |
|
|
|
sdivz = d_sdivzorigin + dv*d_sdivzstepv + du*d_sdivzstepu; |
|
tdivz = d_tdivzorigin + dv*d_tdivzstepv + du*d_tdivzstepu; |
|
zi = d_ziorigin + dv*d_zistepv + du*d_zistepu; |
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
|
|
s = (int)(sdivz * z) + sadjust; |
|
if (s > bbextents) |
|
s = bbextents; |
|
else if (s < 0) |
|
s = 0; |
|
|
|
t = (int)(tdivz * z) + tadjust; |
|
if (t > bbextentt) |
|
t = bbextentt; |
|
else if (t < 0) |
|
t = 0; |
|
|
|
do |
|
{ |
|
// calculate s and t at the far end of the span |
|
if (count >= 8) |
|
spancount = 8; |
|
else |
|
spancount = count; |
|
|
|
count -= spancount; |
|
|
|
if (count) |
|
{ |
|
// calculate s/z, t/z, zi->fixed s and t at far end of span, |
|
// calculate s and t steps across span by shifting |
|
sdivz += sdivz8stepu; |
|
tdivz += tdivz8stepu; |
|
zi += zi8stepu; |
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
|
|
snext = (int)(sdivz * z) + sadjust; |
|
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 |
|
|
|
tnext = (int)(tdivz * z) + tadjust; |
|
if (tnext > bbextentt) |
|
tnext = bbextentt; |
|
else if (tnext < 8) |
|
tnext = 8; // guard against round-off error on <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 |
|
spancountminus1 = (float)(spancount - 1); |
|
sdivz += d_sdivzstepu * spancountminus1; |
|
tdivz += d_tdivzstepu * spancountminus1; |
|
zi += d_zistepu * spancountminus1; |
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
snext = (int)(sdivz * z) + sadjust; |
|
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 |
|
|
|
tnext = (int)(tdivz * z) + tadjust; |
|
if (tnext > bbextentt) |
|
tnext = bbextentt; |
|
else if (tnext < 8) |
|
tnext = 8; // guard against round-off error on <0 steps |
|
|
|
if (spancount > 1) |
|
{ |
|
sstep = (snext - s) / (spancount - 1); |
|
tstep = (tnext - t) / (spancount - 1); |
|
} |
|
} |
|
|
|
|
|
// Drawing phrase |
|
if (!SW_TEXFILT) |
|
{ |
|
do |
|
{ |
|
*pdest++ = *(pbase + (s >> 16) + (t >> 16) * cachewidth); |
|
s += sstep; |
|
t += tstep; |
|
} while (--spancount > 0); |
|
} |
|
else |
|
{ |
|
do |
|
{ |
|
int idiths = s; |
|
int iditht = t; |
|
|
|
int X = (pspan->u + spancount) & 1; |
|
int Y = (pspan->v)&1; |
|
|
|
//Using the kernel |
|
idiths += kernel[X][Y][0]; |
|
iditht += kernel[X][Y][1]; |
|
|
|
idiths = idiths >> 16; |
|
idiths = idiths ? idiths -1 : idiths; |
|
|
|
|
|
iditht = iditht >> 16; |
|
iditht = iditht ? iditht -1 : iditht; |
|
|
|
|
|
*pdest++ = *(pbase + idiths + iditht * cachewidth); |
|
s += sstep; |
|
t += tstep; |
|
} while (--spancount > 0); |
|
} |
|
|
|
|
|
} while (count > 0); |
|
|
|
} while ((pspan = pspan->pnext) != NULL); |
|
} |
|
|
|
|
|
/* |
|
============= |
|
D_DrawSpans16 |
|
|
|
FIXME: actually make this subdivide by 16 instead of 8!!! |
|
============= |
|
*/ |
|
void D_AlphaSpans16 (espan_t *pspan) |
|
{ |
|
int count, spancount; |
|
pixel_t *pbase, *pdest; |
|
fixed16_t s, t, snext, tnext, sstep, tstep; |
|
float sdivz, tdivz, zi, z, du, dv, spancountminus1; |
|
float sdivz8stepu, tdivz8stepu, zi8stepu; |
|
int izi, izistep; |
|
short *pz; |
|
|
|
sstep = 0; // keep compiler happy |
|
tstep = 0; // ditto |
|
|
|
pbase = (unsigned char *)cacheblock; |
|
|
|
sdivz8stepu = d_sdivzstepu * 8; |
|
tdivz8stepu = d_tdivzstepu * 8; |
|
zi8stepu = d_zistepu * 8; |
|
izistep = (int)(d_zistepu * 0x8000 * 0x10000); |
|
|
|
do |
|
{ |
|
pdest = (d_viewbuffer + |
|
(r_screenwidth * pspan->v) + pspan->u); |
|
pz = d_pzbuffer + (d_zwidth * pspan->v) + pspan->u; |
|
|
|
count = pspan->count; |
|
|
|
// calculate the initial s/z, t/z, 1/z, s, and t and clamp |
|
du = (float)pspan->u; |
|
dv = (float)pspan->v; |
|
|
|
sdivz = d_sdivzorigin + dv*d_sdivzstepv + du*d_sdivzstepu; |
|
tdivz = d_tdivzorigin + dv*d_tdivzstepv + du*d_tdivzstepu; |
|
zi = d_ziorigin + dv*d_zistepv + du*d_zistepu; |
|
izi = (int)(zi * 0x8000 * 0x10000); |
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
|
|
s = (int)(sdivz * z) + sadjust; |
|
if (s > bbextents) |
|
s = bbextents; |
|
else if (s < 0) |
|
s = 0; |
|
|
|
t = (int)(tdivz * z) + tadjust; |
|
if (t > bbextentt) |
|
t = bbextentt; |
|
else if (t < 0) |
|
t = 0; |
|
|
|
do |
|
{ |
|
// calculate s and t at the far end of the span |
|
if (count >= 8) |
|
spancount = 8; |
|
else |
|
spancount = count; |
|
|
|
count -= spancount; |
|
|
|
if (count) |
|
{ |
|
// calculate s/z, t/z, zi->fixed s and t at far end of span, |
|
// calculate s and t steps across span by shifting |
|
sdivz += sdivz8stepu; |
|
tdivz += tdivz8stepu; |
|
zi += zi8stepu; |
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
|
|
snext = (int)(sdivz * z) + sadjust; |
|
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 |
|
|
|
tnext = (int)(tdivz * z) + tadjust; |
|
if (tnext > bbextentt) |
|
tnext = bbextentt; |
|
else if (tnext < 8) |
|
tnext = 8; // guard against round-off error on <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 |
|
spancountminus1 = (float)(spancount - 1); |
|
sdivz += d_sdivzstepu * spancountminus1; |
|
tdivz += d_tdivzstepu * spancountminus1; |
|
zi += d_zistepu * spancountminus1; |
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
snext = (int)(sdivz * z) + sadjust; |
|
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 |
|
|
|
tnext = (int)(tdivz * z) + tadjust; |
|
if (tnext > bbextentt) |
|
tnext = bbextentt; |
|
else if (tnext < 8) |
|
tnext = 8; // guard against round-off error on <0 steps |
|
|
|
if (spancount > 1) |
|
{ |
|
sstep = (snext - s) / (spancount - 1); |
|
tstep = (tnext - t) / (spancount - 1); |
|
} |
|
} |
|
|
|
|
|
// Drawing phrase |
|
if (!SW_TEXFILT) |
|
{ |
|
do |
|
{ |
|
pixel_t btemp; |
|
|
|
btemp = *(pbase + (s >> 16) + (t >> 16) * cachewidth); |
|
if (btemp != TRANSPARENT_COLOR) |
|
{ |
|
if (*pz <= (izi >> 16)) |
|
{ |
|
*pdest = btemp; |
|
*pz = izi >> 16; |
|
} |
|
} |
|
pdest++; |
|
pz++; |
|
izi += izistep; |
|
s += sstep; |
|
t += tstep; |
|
} while (--spancount > 0); |
|
} |
|
else |
|
{ |
|
do |
|
{ |
|
if (*pz <= (izi >> 16)) |
|
{ |
|
int idiths = s; |
|
int iditht = t; |
|
|
|
int X = (pspan->u + spancount) & 1; |
|
int Y = (pspan->v)&1; |
|
pixel_t btemp; |
|
|
|
//Using the kernel |
|
idiths += kernel[X][Y][0]; |
|
iditht += kernel[X][Y][1]; |
|
|
|
idiths = idiths >> 16; |
|
idiths = idiths ? idiths -1 : idiths; |
|
|
|
|
|
iditht = iditht >> 16; |
|
iditht = iditht ? iditht -1 : iditht; |
|
|
|
|
|
btemp = *(pbase + idiths + iditht * cachewidth); |
|
if (btemp != TRANSPARENT_COLOR) |
|
{ |
|
*pdest = btemp; |
|
*pz = izi >> 16; |
|
} |
|
} |
|
pdest++; |
|
pz++; |
|
s += sstep; |
|
t += tstep; |
|
} while (--spancount > 0); |
|
} |
|
|
|
|
|
} while (count > 0); |
|
|
|
} while ((pspan = pspan->pnext) != NULL); |
|
} |
|
|
|
|
|
|
|
/* |
|
============= |
|
D_DrawSpans16 |
|
|
|
FIXME: actually make this subdivide by 16 instead of 8!!! |
|
============= |
|
*/ |
|
void D_BlendSpans16 (espan_t *pspan, int alpha) |
|
{ |
|
int count, spancount; |
|
pixel_t *pbase, *pdest; |
|
fixed16_t s, t, snext, tnext, sstep, tstep; |
|
float sdivz, tdivz, zi, z, du, dv, spancountminus1; |
|
float sdivz8stepu, tdivz8stepu, zi8stepu; |
|
int izi, izistep; |
|
short *pz; |
|
|
|
if( alpha > 7 ) |
|
alpha = 7; |
|
if( alpha == 0 ) |
|
return; |
|
|
|
sstep = 0; // keep compiler happy |
|
tstep = 0; // ditto |
|
|
|
pbase = (unsigned char *)cacheblock; |
|
|
|
sdivz8stepu = d_sdivzstepu * 8; |
|
tdivz8stepu = d_tdivzstepu * 8; |
|
zi8stepu = d_zistepu * 8; |
|
izistep = (int)(d_zistepu * 0x8000 * 0x10000); |
|
|
|
do |
|
{ |
|
pdest = (d_viewbuffer + |
|
(r_screenwidth * pspan->v) + pspan->u); |
|
pz = d_pzbuffer + (d_zwidth * pspan->v) + pspan->u; |
|
|
|
count = pspan->count; |
|
|
|
// calculate the initial s/z, t/z, 1/z, s, and t and clamp |
|
du = (float)pspan->u; |
|
dv = (float)pspan->v; |
|
|
|
sdivz = d_sdivzorigin + dv*d_sdivzstepv + du*d_sdivzstepu; |
|
tdivz = d_tdivzorigin + dv*d_tdivzstepv + du*d_tdivzstepu; |
|
zi = d_ziorigin + dv*d_zistepv + du*d_zistepu; |
|
izi = (int)(zi * 0x8000 * 0x10000); |
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
|
|
s = (int)(sdivz * z) + sadjust; |
|
if (s > bbextents) |
|
s = bbextents; |
|
else if (s < 0) |
|
s = 0; |
|
|
|
t = (int)(tdivz * z) + tadjust; |
|
if (t > bbextentt) |
|
t = bbextentt; |
|
else if (t < 0) |
|
t = 0; |
|
|
|
do |
|
{ |
|
// calculate s and t at the far end of the span |
|
if (count >= 8) |
|
spancount = 8; |
|
else |
|
spancount = count; |
|
|
|
count -= spancount; |
|
|
|
if (count) |
|
{ |
|
// calculate s/z, t/z, zi->fixed s and t at far end of span, |
|
// calculate s and t steps across span by shifting |
|
sdivz += sdivz8stepu; |
|
tdivz += tdivz8stepu; |
|
zi += zi8stepu; |
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
|
|
snext = (int)(sdivz * z) + sadjust; |
|
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 |
|
|
|
tnext = (int)(tdivz * z) + tadjust; |
|
if (tnext > bbextentt) |
|
tnext = bbextentt; |
|
else if (tnext < 8) |
|
tnext = 8; // guard against round-off error on <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 |
|
spancountminus1 = (float)(spancount - 1); |
|
sdivz += d_sdivzstepu * spancountminus1; |
|
tdivz += d_tdivzstepu * spancountminus1; |
|
zi += d_zistepu * spancountminus1; |
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
snext = (int)(sdivz * z) + sadjust; |
|
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 |
|
|
|
tnext = (int)(tdivz * z) + tadjust; |
|
if (tnext > bbextentt) |
|
tnext = bbextentt; |
|
else if (tnext < 8) |
|
tnext = 8; // guard against round-off error on <0 steps |
|
|
|
if (spancount > 1) |
|
{ |
|
sstep = (snext - s) / (spancount - 1); |
|
tstep = (tnext - t) / (spancount - 1); |
|
} |
|
} |
|
|
|
|
|
// Drawing phrase |
|
if (!SW_TEXFILT) |
|
{ |
|
do |
|
{ |
|
if (*pz <= (izi >> 16)) |
|
{ |
|
pixel_t btemp; |
|
|
|
btemp = *(pbase + (s >> 16) + (t >> 16) * cachewidth); |
|
|
|
if( btemp != TRANSPARENT_COLOR ) |
|
{ |
|
if( alpha != 7 ) |
|
btemp = BLEND_ALPHA( alpha, btemp, *pdest); |
|
*pdest = btemp; |
|
} |
|
//*pz = izi >> 16; |
|
} |
|
pdest++; |
|
pz++; |
|
izi += izistep; |
|
s += sstep; |
|
t += tstep; |
|
} while (--spancount > 0); |
|
} |
|
else |
|
{ |
|
do |
|
{ |
|
int idiths = s; |
|
int iditht = t; |
|
|
|
int X = (pspan->u + spancount) & 1; |
|
int Y = (pspan->v)&1; |
|
if (*pz <= (izi >> 16)) |
|
{ |
|
pixel_t btemp; |
|
|
|
//Using the kernel |
|
idiths += kernel[X][Y][0]; |
|
iditht += kernel[X][Y][1]; |
|
|
|
idiths = idiths >> 16; |
|
idiths = idiths ? idiths -1 : idiths; |
|
|
|
|
|
iditht = iditht >> 16; |
|
iditht = iditht ? iditht -1 : iditht; |
|
|
|
btemp = *(pbase + idiths + iditht * cachewidth); |
|
|
|
if( btemp != TRANSPARENT_COLOR ) |
|
{ |
|
if( alpha != 7 ) |
|
btemp = BLEND_ALPHA( alpha, btemp, *pdest); |
|
*pdest = btemp; |
|
} |
|
//*pz = izi >> 16; |
|
} |
|
pdest++; |
|
pz++; |
|
izi += izistep; |
|
s += sstep; |
|
t += tstep; |
|
} while (--spancount > 0); |
|
} |
|
|
|
|
|
} while (count > 0); |
|
|
|
} while ((pspan = pspan->pnext) != NULL); |
|
} |
|
|
|
|
|
|
|
/* |
|
============= |
|
D_DrawSpans16 |
|
|
|
FIXME: actually make this subdivide by 16 instead of 8!!! |
|
============= |
|
*/ |
|
void D_AddSpans16 (espan_t *pspan) |
|
{ |
|
int count, spancount; |
|
pixel_t *pbase, *pdest; |
|
fixed16_t s, t, snext, tnext, sstep, tstep; |
|
float sdivz, tdivz, zi, z, du, dv, spancountminus1; |
|
float sdivz8stepu, tdivz8stepu, zi8stepu; |
|
int izi, izistep; |
|
short *pz; |
|
|
|
sstep = 0; // keep compiler happy |
|
tstep = 0; // ditto |
|
|
|
pbase = (unsigned char *)cacheblock; |
|
|
|
sdivz8stepu = d_sdivzstepu * 8; |
|
tdivz8stepu = d_tdivzstepu * 8; |
|
zi8stepu = d_zistepu * 8; |
|
izistep = (int)(d_zistepu * 0x8000 * 0x10000); |
|
|
|
do |
|
{ |
|
pdest = (d_viewbuffer + |
|
(r_screenwidth * pspan->v) + pspan->u); |
|
pz = d_pzbuffer + (d_zwidth * pspan->v) + pspan->u; |
|
|
|
count = pspan->count; |
|
|
|
// calculate the initial s/z, t/z, 1/z, s, and t and clamp |
|
du = (float)pspan->u; |
|
dv = (float)pspan->v; |
|
|
|
sdivz = d_sdivzorigin + dv*d_sdivzstepv + du*d_sdivzstepu; |
|
tdivz = d_tdivzorigin + dv*d_tdivzstepv + du*d_tdivzstepu; |
|
zi = d_ziorigin + dv*d_zistepv + du*d_zistepu; |
|
izi = (int)(zi * 0x8000 * 0x10000); |
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
|
|
s = (int)(sdivz * z) + sadjust; |
|
if (s > bbextents) |
|
s = bbextents; |
|
else if (s < 0) |
|
s = 0; |
|
|
|
t = (int)(tdivz * z) + tadjust; |
|
if (t > bbextentt) |
|
t = bbextentt; |
|
else if (t < 0) |
|
t = 0; |
|
|
|
do |
|
{ |
|
// calculate s and t at the far end of the span |
|
if (count >= 8) |
|
spancount = 8; |
|
else |
|
spancount = count; |
|
|
|
count -= spancount; |
|
|
|
if (count) |
|
{ |
|
// calculate s/z, t/z, zi->fixed s and t at far end of span, |
|
// calculate s and t steps across span by shifting |
|
sdivz += sdivz8stepu; |
|
tdivz += tdivz8stepu; |
|
zi += zi8stepu; |
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
|
|
snext = (int)(sdivz * z) + sadjust; |
|
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 |
|
|
|
tnext = (int)(tdivz * z) + tadjust; |
|
if (tnext > bbextentt) |
|
tnext = bbextentt; |
|
else if (tnext < 8) |
|
tnext = 8; // guard against round-off error on <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 |
|
spancountminus1 = (float)(spancount - 1); |
|
sdivz += d_sdivzstepu * spancountminus1; |
|
tdivz += d_tdivzstepu * spancountminus1; |
|
zi += d_zistepu * spancountminus1; |
|
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
|
snext = (int)(sdivz * z) + sadjust; |
|
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 |
|
|
|
tnext = (int)(tdivz * z) + tadjust; |
|
if (tnext > bbextentt) |
|
tnext = bbextentt; |
|
else if (tnext < 8) |
|
tnext = 8; // guard against round-off error on <0 steps |
|
|
|
if (spancount > 1) |
|
{ |
|
sstep = (snext - s) / (spancount - 1); |
|
tstep = (tnext - t) / (spancount - 1); |
|
} |
|
} |
|
|
|
|
|
// Drawing phrase |
|
if (!SW_TEXFILT) |
|
{ |
|
do |
|
{ |
|
if (*pz <= (izi >> 16)) |
|
{ |
|
pixel_t btemp; |
|
|
|
btemp = *(pbase + (s >> 16) + (t >> 16) * cachewidth); |
|
|
|
if( btemp != TRANSPARENT_COLOR ) |
|
{ |
|
btemp = BLEND_ADD( btemp, *pdest); |
|
*pdest = btemp; |
|
} |
|
//*pz = izi >> 16; |
|
} |
|
pdest++; |
|
pz++; |
|
izi += izistep; |
|
s += sstep; |
|
t += tstep; |
|
} while (--spancount > 0); |
|
} |
|
else |
|
{ |
|
do |
|
{ |
|
int idiths = s; |
|
int iditht = t; |
|
|
|
int X = (pspan->u + spancount) & 1; |
|
int Y = (pspan->v)&1; |
|
if (*pz <= (izi >> 16)) |
|
{ |
|
pixel_t btemp; |
|
|
|
//Using the kernel |
|
idiths += kernel[X][Y][0]; |
|
iditht += kernel[X][Y][1]; |
|
|
|
idiths = idiths >> 16; |
|
idiths = idiths ? idiths -1 : idiths; |
|
|
|
|
|
iditht = iditht >> 16; |
|
iditht = iditht ? iditht -1 : iditht; |
|
|
|
btemp = *(pbase + idiths + iditht * cachewidth); |
|
|
|
if( btemp != TRANSPARENT_COLOR ) |
|
{ |
|
btemp = BLEND_ADD( btemp, *pdest); |
|
*pdest = btemp; |
|
} |
|
//*pz = izi >> 16; |
|
} |
|
pdest++; |
|
pz++; |
|
izi += izistep; |
|
s += sstep; |
|
t += tstep; |
|
} while (--spancount > 0); |
|
} |
|
|
|
|
|
} while (count > 0); |
|
|
|
} while ((pspan = pspan->pnext) != NULL); |
|
} |
|
|
|
#endif |
|
|
|
|
|
#if !id386 |
|
|
|
/* |
|
============= |
|
D_DrawZSpans |
|
============= |
|
*/ |
|
void D_DrawZSpans (espan_t *pspan) |
|
{ |
|
int count, doublecount, izistep; |
|
int izi; |
|
short *pdest; |
|
unsigned ltemp; |
|
float zi; |
|
float du, dv; |
|
|
|
// FIXME: check for clamping/range problems |
|
// we count on FP exceptions being turned off to avoid range problems |
|
izistep = (int)(d_zistepu * 0x8000 * 0x10000); |
|
|
|
do |
|
{ |
|
pdest = d_pzbuffer + (d_zwidth * pspan->v) + pspan->u; |
|
|
|
count = pspan->count; |
|
|
|
// calculate the initial 1/z |
|
du = (float)pspan->u; |
|
dv = (float)pspan->v; |
|
|
|
zi = d_ziorigin + dv*d_zistepv + du*d_zistepu; |
|
// we count on FP exceptions being turned off to avoid range problems |
|
izi = (int)(zi * 0x8000 * 0x10000); |
|
|
|
if ((long)pdest & 0x02) |
|
{ |
|
*pdest++ = (short)(izi >> 16); |
|
izi += izistep; |
|
count--; |
|
} |
|
|
|
if ((doublecount = count >> 1) > 0) |
|
{ |
|
do |
|
{ |
|
ltemp = izi >> 16; |
|
izi += izistep; |
|
ltemp |= izi & 0xFFFF0000; |
|
izi += izistep; |
|
*(int *)pdest = ltemp; |
|
pdest += 2; |
|
} while (--doublecount > 0); |
|
} |
|
|
|
if (count & 1) |
|
*pdest = (short)(izi >> 16); |
|
|
|
} while ((pspan = pspan->pnext) != NULL); |
|
} |
|
|
|
#endif |
|
|
|
|