457b7fbfd9
Some checks are pending
Build & Deploy Engine / build (macos-13, amd64, apple) (push) Waiting to run
Build & Deploy Engine / build (macos-14, arm64, apple) (push) Waiting to run
Build & Deploy Engine / build (true, ubuntu-20.04, arm64, linux) (push) Waiting to run
Build & Deploy Engine / build (true, ubuntu-20.04, armhf, linux) (push) Waiting to run
Build & Deploy Engine / build (true, ubuntu-20.04, ppc64el, linux) (push) Waiting to run
Build & Deploy Engine / build (true, ubuntu-20.04, riscv64, linux) (push) Waiting to run
Build & Deploy Engine / build (ubuntu-20.04, amd64, linux) (push) Waiting to run
Build & Deploy Engine / build (ubuntu-20.04, i386, linux) (push) Waiting to run
Build & Deploy Engine / build (ubuntu-20.04, multiarch, android) (push) Waiting to run
Build & Deploy Engine / build (ubuntu-latest, arm64, nswitch) (push) Waiting to run
Build & Deploy Engine / build (ubuntu-latest, armv7hf, psvita) (push) Waiting to run
Build & Deploy Engine / build (windows-2019, i386, win32) (push) Waiting to run
Build & Deploy Engine / build (windows-latest, amd64, win32) (push) Waiting to run
Build & Deploy Engine / flatpak (su.xash.Engine.Compat.i386) (push) Waiting to run
Build & Deploy Engine / Upload releases (push) Blocked by required conditions
1387 lines
33 KiB
C
1387 lines
33 KiB
C
/*
|
|
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;
|
|
|
|
/*
|
|
=============
|
|
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
|
|
=============
|
|
*/
|
|
static 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 );
|
|
}
|
|
|
|
/*
|
|
=============
|
|
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)( gp_cl->time * SPEED ) & ( CYCLE - 1 ));
|
|
|
|
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 );
|
|
}
|
|
|
|
/*
|
|
=============
|
|
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)( gp_cl->time * SPEED ) & ( CYCLE - 1 ));
|
|
|
|
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;
|
|
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
|
|
// ====================
|
|
|
|
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 = 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 = 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 = 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 = 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 );
|
|
}
|
|
|
|
/*
|
|
=============
|
|
D_DrawZSpans
|
|
=============
|
|
*/
|
|
void D_DrawZSpans( espan_t *pspan )
|
|
{
|
|
int count, doublecount, izistep;
|
|
int izi;
|
|
short *pdest;
|
|
unsigned ltemp;
|
|
float zi;
|
|
float du, dv;
|
|
|
|
//Cobson wrote this frfr nocap blud
|
|
//Walls for software renderer check if rendering an entity and disable depth writing
|
|
if (RI.currententity)
|
|
{
|
|
do
|
|
{
|
|
pdest = d_pzbuffer + ( d_zwidth * pspan->v ) + pspan->u;
|
|
count = pspan->count;
|
|
|
|
// Calculate initial 1/z
|
|
du = (float)pspan->u;
|
|
dv = (float)pspan->v;
|
|
zi = d_ziorigin + dv * d_zistepv + du * d_zistepu;
|
|
izi = (int)( zi * 0x8000 * 0x10000 );
|
|
|
|
// Skip depth writing for entities
|
|
continue;
|
|
}
|
|
while ( ( pspan = pspan->pnext ) != NULL );
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
// 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((uintptr_t)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 );
|
|
}
|
|
|