doom3-bfg/doomclassic/doom/r_things.cpp

/*
===========================================================================

Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.

This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").

Doom 3 BFG Edition Source Code 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 3 of the License, or
(at your option) any later version.

Doom 3 BFG Edition Source Code 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 Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#include "Precompiled.h"
#include "globaldata.h"


#include <stdio.h>
#include <stdlib.h>


#include "doomdef.h"
#include "m_swap.h"

#include "i_system.h"
#include "z_zone.h"
#include "w_wad.h"

#include "r_local.h"

#include "doomstat.h"




//void R_DrawColumn (void);
//void R_DrawFuzzColumn (void);






//
// Sprite rotation 0 is facing the viewer,
//  rotation 1 is one angle turn CLOCKWISE around the axis.
// This is not the same as the angle,
//  which increases counter clockwise (protractor).
// There was a lot of stuff grabbed wrong, so I changed it...
//


// constant arrays
//  used for psprite clipping and initializing clipping


//
// INITIALIZATION FUNCTIONS
//

// variables used to look up
//  and range check thing_t ::g->sprites patches






//
// R_InstallSpriteLump
// Local function for R_InitSprites.
//
void
R_InstallSpriteLump
( int		lump,
  unsigned	frame,
  unsigned	rotation,
  qboolean	flipped )
{
	int		r;

	if( frame >= 29 || rotation > 8 )
		I_Error( "R_InstallSpriteLump: "
				 "Bad frame characters in lump %i", lump );

	if( ( int )frame > ::g->maxframe )
	{
		::g->maxframe = frame;
	}

	if( rotation == 0 )
	{
		// the lump should be used for all rotations
		if( ::g->sprtemp[frame].rotate == false )
			I_Error( "R_InitSprites: Sprite %s frame %c has "
					 "multip rot=0 lump", ::g->spritename, 'A' + frame );

		if( ::g->sprtemp[frame].rotate == true )
			I_Error( "R_InitSprites: Sprite %s frame %c has rotations "
					 "and a rot=0 lump", ::g->spritename, 'A' + frame );

		::g->sprtemp[frame].rotate = false;
		for( r = 0 ; r < 8 ; r++ )
		{
			::g->sprtemp[frame].lump[r] = lump - ::g->firstspritelump;
			::g->sprtemp[frame].flip[r] = ( byte )flipped;
		}
		return;
	}

	// the lump is only used for one rotation
	if( ::g->sprtemp[frame].rotate == false )
		I_Error( "R_InitSprites: Sprite %s frame %c has rotations "
				 "and a rot=0 lump", ::g->spritename, 'A' + frame );

	::g->sprtemp[frame].rotate = true;

	// make 0 based
	rotation--;
	if( ::g->sprtemp[frame].lump[rotation] != -1 )
		I_Error( "R_InitSprites: Sprite %s : %c : %c "
				 "has two lumps mapped to it",
				 ::g->spritename, 'A' + frame, '1' + rotation );

	::g->sprtemp[frame].lump[rotation] = lump - ::g->firstspritelump;
	::g->sprtemp[frame].flip[rotation] = ( byte )flipped;
}




//
// R_InitSpriteDefs
// Pass a null terminated list of sprite names
//  (4 chars exactly) to be used.
// Builds the sprite rotation matrixes to account
//  for horizontally flipped ::g->sprites.
// Will report an error if the lumps are inconsistant.
// Only called at startup.
//
// Sprite lump names are 4 characters for the actor,
//  a letter for the frame, and a number for the rotation.
// A sprite that is flippable will have an additional
//  letter/number appended.
// The rotation character can be 0 to signify no rotations.
//
void R_InitSpriteDefs( const char* const* namelist )
{
	const char* const*	check;
	int		i;
	int		l;
	int		intname;
	int		frame;
	int		rotation;
	int		start;
	int		end;
	int		patched;

	// count the number of sprite names
	check = namelist;
	while( *check != NULL )
	{
		check++;
	}

	::g->numsprites = check - namelist;

	if( !::g->numsprites )
	{
		return;
	}

	::g->sprites = ( spritedef_t* )DoomLib::Z_Malloc( ::g->numsprites * sizeof( *::g->sprites ), PU_STATIC, NULL );

	start = ::g->firstspritelump - 1;
	end = ::g->lastspritelump + 1;

	// scan all the lump names for each of the names,
	//  noting the highest frame letter.
	// Just compare 4 characters as ints
	for( i = 0 ; i < ::g->numsprites ; i++ )
	{
		::g->spritename = namelist[i];
		memset( ::g->sprtemp, -1, sizeof( ::g->sprtemp ) );

		::g->maxframe = -1;
		intname = *( int* )namelist[i];

		// scan the lumps,
		//  filling in the frames for whatever is found
		for( l = start + 1 ; l < end ; l++ )
		{
			if( *( int* )lumpinfo[l].name == intname )
			{
				frame = lumpinfo[l].name[4] - 'A';
				rotation = lumpinfo[l].name[5] - '0';

				if( ::g->modifiedgame )
				{
					patched = W_GetNumForName( lumpinfo[l].name );
				}
				else
				{
					patched = l;
				}

				R_InstallSpriteLump( patched, frame, rotation, false );

				if( lumpinfo[l].name[6] )
				{
					frame = lumpinfo[l].name[6] - 'A';
					rotation = lumpinfo[l].name[7] - '0';
					R_InstallSpriteLump( l, frame, rotation, true );
				}
			}
		}

		// check the frames that were found for completeness
		if( ::g->maxframe == -1 )
		{
			::g->sprites[i].numframes = 0;
			continue;
		}

		::g->maxframe++;

		for( frame = 0 ; frame < ::g->maxframe ; frame++ )
		{
			switch( ( int )::g->sprtemp[frame].rotate )
			{
				case -1:
					// no rotations were found for that frame at all
					I_Error( "R_InitSprites: No patches found "
							 "for %s frame %c", namelist[i], frame + 'A' );
					break;

				case 0:
					// only the first rotation is needed
					break;

				case 1:
					// must have all 8 frames
					for( rotation = 0 ; rotation < 8 ; rotation++ )
						if( ::g->sprtemp[frame].lump[rotation] == -1 )
							I_Error( "R_InitSprites: Sprite %s frame %c "
									 "is missing rotations",
									 namelist[i], frame + 'A' );
					break;
			}
		}

		// allocate space for the frames present and copy ::g->sprtemp to it
		::g->sprites[i].numframes = ::g->maxframe;
		::g->sprites[i].spriteframes =
			( spriteframe_t* )DoomLib::Z_Malloc( ::g->maxframe * sizeof( spriteframe_t ), PU_STATIC, NULL );
		memcpy( ::g->sprites[i].spriteframes, ::g->sprtemp, ::g->maxframe * sizeof( spriteframe_t ) );
	}

}




//
// GAME FUNCTIONS
//



//
// R_InitSprites
// Called at program start.
//
void R_InitSprites( const char* const* namelist )
{
	int		i;

	for( i = 0 ; i < SCREENWIDTH ; i++ )
	{
		::g->negonearray[i] = -1;
	}

	R_InitSpriteDefs( namelist );
}



//
// R_ClearSprites
// Called at frame start.
//
void R_ClearSprites( void )
{
	::g->vissprite_p = ::g->vissprites;
}


//
// R_NewVisSprite
//

vissprite_t* R_NewVisSprite( void )
{
	if( ::g->vissprite_p == &::g->vissprites[MAXVISSPRITES] )
	{
		return &::g->overflowsprite;
	}

	::g->vissprite_p++;
	return ::g->vissprite_p - 1;
}



//
// R_DrawMaskedColumn
// Used for ::g->sprites and masked mid textures.
// Masked means: partly transparent, i.e. stored
//  in posts/runs of opaque pixels.
//


void R_DrawMaskedColumn( postColumn_t* column )
{
	int		topscreen;
	int 	bottomscreen;
	fixed_t	basetexturemid;

	basetexturemid = ::g->dc_texturemid;

	for( ; column->topdelta != 0xff ; )
	{
		// calculate unclipped screen coordinates
		//  for post
		topscreen = ::g->sprtopscreen + ::g->spryscale * column->topdelta;
		bottomscreen = topscreen + ::g->spryscale * column->length;

		::g->dc_yl = ( topscreen + FRACUNIT - 1 ) >> FRACBITS;
		::g->dc_yh = ( bottomscreen - 1 ) >> FRACBITS;

		if( ::g->dc_yh >= ::g->mfloorclip[::g->dc_x] )
		{
			::g->dc_yh = ::g->mfloorclip[::g->dc_x] - 1;
		}
		if( ::g->dc_yl <= ::g->mceilingclip[::g->dc_x] )
		{
			::g->dc_yl = ::g->mceilingclip[::g->dc_x] + 1;
		}

		if( ::g->dc_yl <= ::g->dc_yh )
		{
			::g->dc_source = ( byte* )column + 3;
			::g->dc_texturemid = basetexturemid - ( column->topdelta << FRACBITS );
			// ::g->dc_source = (byte *)column + 3 - column->topdelta;

			// Drawn by either R_DrawColumn
			//  or (SHADOW) R_DrawFuzzColumn.
			colfunc( ::g->dc_colormap, ::g->dc_source );
		}
		column = ( postColumn_t* )( ( byte* )column + column->length + 4 );
	}

	::g->dc_texturemid = basetexturemid;
}



//
// R_DrawVisSprite
//  ::g->mfloorclip and ::g->mceilingclip should also be set.
//
void
R_DrawVisSprite
( vissprite_t*		vis,
  int			x1,
  int			x2 )
{
	postColumn_t*		column;
	int			texturecolumn;
	fixed_t		frac;
	patch_t*		patch;


	patch = ( patch_t* )W_CacheLumpNum( vis->patch +::g->firstspritelump, PU_CACHE_SHARED );

	::g->dc_colormap = vis->colormap;

	if( !::g->dc_colormap )
	{
		// NULL colormap = shadow draw
		colfunc = fuzzcolfunc;
	}
	else if( vis->mobjflags & MF_TRANSLATION )
	{
		colfunc = R_DrawTranslatedColumn;
		::g->dc_translation = ::g->translationtables - 256 +
							  ( ( vis->mobjflags & MF_TRANSLATION ) >> ( MF_TRANSSHIFT - 8 ) );
	}

	::g->dc_iscale = abs( vis->xiscale ) >>::g->detailshift;
	::g->dc_texturemid = vis->texturemid;
	frac = vis->startfrac;
	::g->spryscale = vis->scale;
	::g->sprtopscreen = ::g->centeryfrac - FixedMul( ::g->dc_texturemid, ::g->spryscale );

	for( ::g->dc_x = vis->x1 ; ::g->dc_x <= vis->x2 ; ::g->dc_x++, frac += vis->xiscale )
	{
		texturecolumn = frac >> FRACBITS;
#ifdef RANGECHECK
		if( texturecolumn < 0 || texturecolumn >= SHORT( patch->width ) )
		{
			I_Error( "R_DrawSpriteRange: bad texturecolumn" );
		}
#endif
		column = ( postColumn_t* )( ( byte* )patch +
									LONG( patch->columnofs[texturecolumn] ) );
		R_DrawMaskedColumn( column );
	}

	colfunc = basecolfunc;
}







//
// R_ProjectSprite
// Generates a vissprite for a thing
//  if it might be visible.
//
void R_ProjectSprite( mobj_t* thing )
{
	fixed_t		tr_x;
	fixed_t		tr_y;

	fixed_t		gxt;
	fixed_t		gyt;

	fixed_t		tx;
	fixed_t		tz;

	fixed_t		xscale;

	int			x1;
	int			x2;

	spritedef_t*	sprdef;
	spriteframe_t*	sprframe;
	int			lump;

	unsigned		rot;
	qboolean		flip;

	int			index;

	vissprite_t*	vis;

	angle_t		ang;
	fixed_t		iscale;

	// transform the origin point
	extern fixed_t GetViewX();
	extern fixed_t GetViewY();
	tr_x = thing->x - GetViewX();
	tr_y = thing->y - GetViewY();

	gxt = FixedMul( tr_x, ::g->viewcos );
	gyt = -FixedMul( tr_y, ::g->viewsin );

	tz = gxt - gyt;

	// thing is behind view plane?
	if( tz < MINZ )
	{
		return;
	}

	xscale = FixedDiv( ::g->projection, tz );

	gxt = -FixedMul( tr_x, ::g->viewsin );
	gyt = FixedMul( tr_y, ::g->viewcos );
	tx = -( gyt + gxt );

	// too far off the side?
	if( abs( tx ) > ( tz << 2 ) )
	{
		return;
	}

	// decide which patch to use for sprite relative to player
#ifdef RANGECHECK
	if( thing->sprite >= ::g->numsprites )
		I_Error( "R_ProjectSprite: invalid sprite number %i ",
				 thing->sprite );
#endif
	sprdef = &::g->sprites[thing->sprite];
#ifdef RANGECHECK
	if( ( thing->frame & FF_FRAMEMASK ) >= sprdef->numframes )
		I_Error( "R_ProjectSprite: invalid sprite frame %i : %i ",
				 thing->sprite, thing->frame );
#endif
	sprframe = &sprdef->spriteframes[ thing->frame & FF_FRAMEMASK];

	if( sprframe->rotate )
	{
		// choose a different rotation based on player view
		ang = R_PointToAngle( thing->x, thing->y );
		rot = ( ang - thing->angle + ( unsigned )( ANG45 / 2 ) * 9 ) >> 29;
		lump = sprframe->lump[rot];
		flip = ( qboolean )sprframe->flip[rot];
	}
	else
	{
		// use single rotation for all views
		lump = sprframe->lump[0];
		flip = ( qboolean )sprframe->flip[0];
	}

	// calculate edges of the shape
	tx -= ::g->spriteoffset[lump];
	x1 = ( ::g->centerxfrac + FixedMul( tx, xscale ) ) >> FRACBITS;

	// off the right side?
	if( x1 > ::g->viewwidth )
	{
		return;
	}

	tx +=  ::g->spritewidth[lump];
	x2 = ( ( ::g->centerxfrac + FixedMul( tx, xscale ) ) >> FRACBITS ) - 1;

	// off the left side
	if( x2 < 0 )
	{
		return;
	}

	// store information in a vissprite
	vis = R_NewVisSprite();
	vis->mobjflags = thing->flags;
	vis->scale = xscale << ::g->detailshift;
	vis->gx = thing->x;
	vis->gy = thing->y;
	vis->gz = thing->z;
	vis->gzt = thing->z + ::g->spritetopoffset[lump];
	vis->texturemid = vis->gzt - ::g->viewz;
	vis->x1 = x1 < 0 ? 0 : x1;
	vis->x2 = x2 >= ::g->viewwidth ? ::g->viewwidth - 1 : x2;
	iscale = FixedDiv( FRACUNIT, xscale );

	if( flip )
	{
		vis->startfrac = ::g->spritewidth[lump] - 1;
		vis->xiscale = -iscale;
	}
	else
	{
		vis->startfrac = 0;
		vis->xiscale = iscale;
	}

	if( vis->x1 > x1 )
	{
		vis->startfrac += vis->xiscale * ( vis->x1 - x1 );
	}
	vis->patch = lump;

	// get light level
	if( thing->flags & MF_SHADOW )
	{
		// shadow draw
		vis->colormap = NULL;
	}
	else if( ::g->fixedcolormap )
	{
		// fixed map
		vis->colormap = ::g->fixedcolormap;
	}
	else if( thing->frame & FF_FULLBRIGHT )
	{
		// full bright
		vis->colormap = ::g->colormaps;
	}

	else
	{
		// diminished light
		index = xscale >> ( LIGHTSCALESHIFT -::g->detailshift );

		if( index >= MAXLIGHTSCALE )
		{
			index = MAXLIGHTSCALE - 1;
		}

		vis->colormap = ::g->spritelights[index];
	}
}




//
// R_AddSprites
// During BSP traversal, this adds ::g->sprites by sector.
//
void R_AddSprites( sector_t* sec )
{
	mobj_t*		thing;
	int			lightnum;

	// BSP is traversed by subsector.
	// A sector might have been split into several
	//  ::g->subsectors during BSP building.
	// Thus we check whether its already added.
	if( sec->validcount == ::g->validcount )
	{
		return;
	}

	// Well, now it will be done.
	sec->validcount = ::g->validcount;

	lightnum = ( sec->lightlevel >> LIGHTSEGSHIFT ) +::g->extralight;

	if( lightnum < 0 )
	{
		::g->spritelights = ::g->scalelight[0];
	}
	else if( lightnum >= LIGHTLEVELS )
	{
		::g->spritelights = ::g->scalelight[LIGHTLEVELS - 1];
	}
	else
	{
		::g->spritelights = ::g->scalelight[lightnum];
	}

	// Handle all things in sector.
	for( thing = sec->thinglist ; thing ; thing = thing->snext )
	{
		R_ProjectSprite( thing );
	}
}


//
// R_DrawPSprite
//
void R_DrawPSprite( pspdef_t* psp )
{
	fixed_t		tx;
	int			x1;
	int			x2;
	spritedef_t*	sprdef;
	spriteframe_t*	sprframe;
	int			lump;
	qboolean		flip;
	vissprite_t*	vis;
	vissprite_t		avis;

	// decide which patch to use
#ifdef RANGECHECK
	if( psp->state->sprite >= ::g->numsprites )
		I_Error( "R_ProjectSprite: invalid sprite number %i ",
				 psp->state->sprite );
#endif
	sprdef = &::g->sprites[psp->state->sprite];
#ifdef RANGECHECK
	if( ( psp->state->frame & FF_FRAMEMASK )  >= sprdef->numframes )
		I_Error( "R_ProjectSprite: invalid sprite frame %i : %i ",
				 psp->state->sprite, psp->state->frame );
#endif
	sprframe = &sprdef->spriteframes[ psp->state->frame & FF_FRAMEMASK ];

	lump = sprframe->lump[0];
	flip = ( qboolean )sprframe->flip[0];

	// calculate edges of the shape
	tx = psp->sx - 160 * FRACUNIT;

	tx -= ::g->spriteoffset[lump];
	x1 = ( ::g->centerxfrac + FixedMul( tx, ::g->pspritescale ) ) >> FRACBITS;

	// off the right side
	if( x1 > ::g->viewwidth )
	{
		return;
	}

	tx +=  ::g->spritewidth[lump];
	x2 = ( ( ::g->centerxfrac + FixedMul( tx, ::g->pspritescale ) ) >> FRACBITS ) - 1;

	// off the left side
	if( x2 < 0 )
	{
		return;
	}

	// store information in a vissprite
	vis = &avis;
	vis->mobjflags = 0;
	vis->texturemid = ( BASEYCENTER << FRACBITS ) + FRACUNIT / 2 - ( psp->sy -::g->spritetopoffset[lump] );
	vis->x1 = x1 < 0 ? 0 : x1;
	vis->x2 = x2 >= ::g->viewwidth ? ::g->viewwidth - 1 : x2;
	vis->scale = ::g->pspritescale << ::g->detailshift;

	if( flip )
	{
		vis->xiscale = -::g->pspriteiscale;
		vis->startfrac = ::g->spritewidth[lump] - 1;
	}
	else
	{
		vis->xiscale = ::g->pspriteiscale;
		vis->startfrac = 0;
	}

	if( vis->x1 > x1 )
	{
		vis->startfrac += vis->xiscale * ( vis->x1 - x1 );
	}

	vis->patch = lump;

	if( ::g->viewplayer->powers[pw_invisibility] > 4 * 32
			|| ::g->viewplayer->powers[pw_invisibility] & 8 )
	{
		// shadow draw
		vis->colormap = NULL;
	}
	else if( ::g->fixedcolormap )
	{
		// fixed color
		vis->colormap = ::g->fixedcolormap;
	}
	else if( psp->state->frame & FF_FULLBRIGHT )
	{
		// full bright
		vis->colormap = ::g->colormaps;
	}
	else
	{
		// local light
		vis->colormap = ::g->spritelights[MAXLIGHTSCALE - 1];
	}

	R_DrawVisSprite( vis, vis->x1, vis->x2 );
}



//
// R_DrawPlayerSprites
//
void R_DrawPlayerSprites( void )
{
	int		i;
	int		lightnum;
	pspdef_t*	psp;

	// get light level
	lightnum =
		( ::g->viewplayer->mo->subsector->sector->lightlevel >> LIGHTSEGSHIFT )
		+::g->extralight;

	if( lightnum < 0 )
	{
		::g->spritelights = ::g->scalelight[0];
	}
	else if( lightnum >= LIGHTLEVELS )
	{
		::g->spritelights = ::g->scalelight[LIGHTLEVELS - 1];
	}
	else
	{
		::g->spritelights = ::g->scalelight[lightnum];
	}

	// clip to screen bounds
	::g->mfloorclip = ::g->screenheightarray;
	::g->mceilingclip = ::g->negonearray;

	// add all active psprites
	for( i = 0, psp =::g->viewplayer->psprites;
			i < NUMPSPRITES;
			i++, psp++ )
	{
		if( psp->state )
		{
			R_DrawPSprite( psp );
		}
	}
}




//
// R_SortVisSprites
//


void R_SortVisSprites( void )
{
	int			i;
	int			count;
	vissprite_t*	ds = NULL;
	vissprite_t*	best = NULL;
	vissprite_t		unsorted;
	fixed_t		bestscale;

	count = ::g->vissprite_p - ::g->vissprites;

	unsorted.next = unsorted.prev = &unsorted;

	if( !count )
	{
		return;
	}

	for( ds =::g->vissprites ; ds < ::g->vissprite_p ; ds++ )
	{
		ds->next = ds + 1;
		ds->prev = ds - 1;
	}

	::g->vissprites[0].prev = &unsorted;
	unsorted.next = &::g->vissprites[0];
	( ::g->vissprite_p - 1 )->next = &unsorted;
	unsorted.prev = ::g->vissprite_p - 1;

	// pull the ::g->vissprites out by scale
	//best = 0;		// shut up the compiler warning
	::g->vsprsortedhead.next = ::g->vsprsortedhead.prev = &::g->vsprsortedhead;
	for( i = 0 ; i < count ; i++ )
	{
		bestscale = MAXINT;
		for( ds = unsorted.next ; ds != &unsorted ; ds = ds->next )
		{
			if( ds->scale < bestscale )
			{
				bestscale = ds->scale;
				best = ds;
			}
		}
		best->next->prev = best->prev;
		best->prev->next = best->next;
		best->next = &::g->vsprsortedhead;
		best->prev = ::g->vsprsortedhead.prev;
		::g->vsprsortedhead.prev->next = best;
		::g->vsprsortedhead.prev = best;
	}
}



//
// R_DrawSprite
//
void R_DrawSprite( vissprite_t* spr )
{
	drawseg_t*		ds;
	short		clipbot[SCREENWIDTH];
	short		cliptop[SCREENWIDTH];
	int			x;
	int			r1;
	int			r2;
	fixed_t		scale;
	fixed_t		lowscale;
	int			silhouette;

	for( x = spr->x1 ; x <= spr->x2 ; x++ )
	{
		clipbot[x] = cliptop[x] = -2;
	}

	// Scan ::g->drawsegs from end to start for obscuring ::g->segs.
	// The first drawseg that has a greater scale
	//  is the clip seg.
	for( ds =::g->ds_p - 1 ; ds >= ::g->drawsegs ; ds-- )
	{
		// determine if the drawseg obscures the sprite
		if( ds->x1 > spr->x2
				|| ds->x2 < spr->x1
				|| ( !ds->silhouette
					 && !ds->maskedtexturecol ) )
		{
			// does not cover sprite
			continue;
		}

		r1 = ds->x1 < spr->x1 ? spr->x1 : ds->x1;
		r2 = ds->x2 > spr->x2 ? spr->x2 : ds->x2;

		if( ds->scale1 > ds->scale2 )
		{
			lowscale = ds->scale2;
			scale = ds->scale1;
		}
		else
		{
			lowscale = ds->scale1;
			scale = ds->scale2;
		}

		if( scale < spr->scale
				|| ( lowscale < spr->scale
					 && !R_PointOnSegSide( spr->gx, spr->gy, ds->curline ) ) )
		{
			// masked mid texture?
			if( ds->maskedtexturecol )
			{
				R_RenderMaskedSegRange( ds, r1, r2 );
			}
			// seg is behind sprite
			continue;
		}


		// clip this piece of the sprite
		silhouette = ds->silhouette;

		if( spr->gz >= ds->bsilheight )
		{
			silhouette &= ~SIL_BOTTOM;
		}

		if( spr->gzt <= ds->tsilheight )
		{
			silhouette &= ~SIL_TOP;
		}

		if( silhouette == 1 )
		{
			// bottom sil
			for( x = r1 ; x <= r2 ; x++ )
				if( clipbot[x] == -2 )
				{
					clipbot[x] = ds->sprbottomclip[x];
				}
		}
		else if( silhouette == 2 )
		{
			// top sil
			for( x = r1 ; x <= r2 ; x++ )
				if( cliptop[x] == -2 )
				{
					cliptop[x] = ds->sprtopclip[x];
				}
		}
		else if( silhouette == 3 )
		{
			// both
			for( x = r1 ; x <= r2 ; x++ )
			{
				if( clipbot[x] == -2 )
				{
					clipbot[x] = ds->sprbottomclip[x];
				}
				if( cliptop[x] == -2 )
				{
					cliptop[x] = ds->sprtopclip[x];
				}
			}
		}

	}

	// all clipping has been performed, so draw the sprite

	// check for unclipped columns
	for( x = spr->x1 ; x <= spr->x2 ; x++ )
	{
		if( clipbot[x] == -2 )
		{
			clipbot[x] = ::g->viewheight;
		}

		if( cliptop[x] == -2 )
		{
			cliptop[x] = -1;
		}
	}

	::g->mfloorclip = clipbot;
	::g->mceilingclip = cliptop;
	R_DrawVisSprite( spr, spr->x1, spr->x2 );
}




//
// R_DrawMasked
//
void R_DrawMasked( void )
{
	vissprite_t*	spr;
	drawseg_t*		ds;

	R_SortVisSprites();

	if( ::g->vissprite_p > ::g->vissprites )
	{
		// draw all ::g->vissprites back to front
		for( spr = ::g->vsprsortedhead.next ;
				spr != &::g->vsprsortedhead ;
				spr = spr->next )
		{

			R_DrawSprite( spr );
		}
	}

	// render any remaining masked mid textures
	for( ds =::g->ds_p - 1 ; ds >= ::g->drawsegs ; ds-- )
		if( ds->maskedtexturecol )
		{
			R_RenderMaskedSegRange( ds, ds->x1, ds->x2 );
		}

	// draw the psprites on top of everything
	//  but does not draw on side views
	if( !::g->viewangleoffset )
	{
		R_DrawPlayerSprites();
	}
}