doom3-bfg/doomclassic/doom/r_draw.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 "doomdef.h"

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

#include "r_local.h"

// Needs access to LFB (guess what).
#include "v_video.h"

// State.
#include "doomstat.h"


// ?

// status bar height at bottom of screen

//
// All drawing to the view buffer is accomplished in this file.
// The other refresh files only know about ccordinates,
//  not the architecture of the frame buffer.
// Conveniently, the frame buffer is a linear one,
//  and we need only the base address,
//  and the total size == width*height*depth/8.,
//



// Color tables for different ::g->players,
//  translate a limited part to another
//  (color ramps used for  suit colors).
//




//
// R_DrawColumn
// Source is the top of the column to scale.
//

// first pixel in a column (possibly virtual) 

// just for profiling 

//
// A column is a vertical slice/span from a wall texture that,
//  given the DOOM style restrictions on the view orientation,
//  will always have constant z depth.
// Thus a special case loop for very fast rendering can
//  be used. It has also been used with Wolfenstein 3D.
// 
void R_DrawColumn ( lighttable_t * dc_colormap,
					byte * dc_source ) 
{ 
	int			count; 
	byte*		dest; 
	fixed_t		frac;
	fixed_t		fracstep;	 

	count = ::g->dc_yh - ::g->dc_yl; 

	// Zero length, column does not exceed a pixel.
	if (count >= 0) {
		//return; 

	#ifdef RANGECHECK 
		if ((unsigned)::g->dc_x >= SCREENWIDTH
			|| ::g->dc_yl < 0
			|| ::g->dc_yh >= SCREENHEIGHT) 
			I_Error ("R_DrawColumn: %i to %i at %i", ::g->dc_yl, ::g->dc_yh, ::g->dc_x); 
	#endif 

		// Framebuffer destination address.
		// Use ::g->ylookup LUT to avoid multiply with ScreenWidth.
		// Use ::g->columnofs LUT for subwindows? 
		dest = ::g->ylookup[::g->dc_yl] + ::g->columnofs[::g->dc_x];  

		// Determine scaling,
		//  which is the only mapping to be done.
		fracstep = ::g->dc_iscale; 
		frac = ::g->dc_texturemid + (::g->dc_yl-::g->centery)*fracstep; 

		// Inner loop that does the actual texture mapping,
		//  e.g. a DDA-lile scaling.
		// This is as fast as it gets.
		do 
		{
			// Re-map color indices from wall texture column
			//  using a lighting/special effects LUT.
			const int truncated1 = frac >> FRACBITS;
			const int wrapped1 = truncated1 & 127;

			*dest = dc_colormap[dc_source[wrapped1]];

			frac += fracstep;
			dest += SCREENWIDTH; 
		} while (count--);
	}
} 



// UNUSED.
// Loop unrolled.
#if 0
void R_DrawColumn (void) 
{ 
	int			count; 
	byte*		source;
	byte*		dest;
	byte*		colormap;

	unsigned		frac;
	unsigned		fracstep;
	unsigned		fracstep2;
	unsigned		fracstep3;
	unsigned		fracstep4;	 

	count = ::g->dc_yh - ::g->dc_yl + 1; 

	source = ::g->dc_source;
	colormap = ::g->dc_colormap;		 
	dest = ::g->ylookup[::g->dc_yl] + ::g->columnofs[::g->dc_x];  

	fracstep = ::g->dc_iscale<<9; 
	frac = (::g->dc_texturemid + (::g->dc_yl-::g->centery)*::g->dc_iscale)<<9; 

	fracstep2 = fracstep+fracstep;
	fracstep3 = fracstep2+fracstep;
	fracstep4 = fracstep3+fracstep;

	while (count >= 8) 
	{ 
		dest[0] = colormap[source[frac>>25]]; 
		dest[SCREENWIDTH] = colormap[source[(frac+fracstep)>>25]]; 
		dest[SCREENWIDTH*2] = colormap[source[(frac+fracstep2)>>25]]; 
		dest[SCREENWIDTH*3] = colormap[source[(frac+fracstep3)>>25]];

		frac += fracstep4; 

		dest[SCREENWIDTH*4] = colormap[source[frac>>25]]; 
		dest[SCREENWIDTH*5] = colormap[source[(frac+fracstep)>>25]]; 
		dest[SCREENWIDTH*6] = colormap[source[(frac+fracstep2)>>25]]; 
		dest[SCREENWIDTH*7] = colormap[source[(frac+fracstep3)>>25]]; 

		frac += fracstep4; 
		dest += SCREENWIDTH*8; 
		count -= 8;
	} 

	while (count > 0)
	{ 
		*dest = colormap[source[frac>>25]]; 
		dest += SCREENWIDTH; 
		frac += fracstep; 
		count--;
	} 
}
#endif


void R_DrawColumnLow ( lighttable_t * dc_colormap,
					   byte * dc_source ) 
{ 
	int			count; 
	byte*		dest; 
	byte*		dest2;
	fixed_t		frac;
	fixed_t		fracstep;	 

	count = ::g->dc_yh - ::g->dc_yl; 

	// Zero length.
	if (count < 0) 
		return; 

#ifdef RANGECHECK 
	if ((unsigned)::g->dc_x >= SCREENWIDTH
		|| ::g->dc_yl < 0
		|| ::g->dc_yh >= SCREENHEIGHT)
	{

		I_Error ("R_DrawColumn: %i to %i at %i", ::g->dc_yl, ::g->dc_yh, ::g->dc_x);
	}
	//	::g->dccount++; 
#endif 
	// Blocky mode, need to multiply by 2.
	::g->dc_x <<= 1;

	dest = ::g->ylookup[::g->dc_yl] + ::g->columnofs[::g->dc_x];
	dest2 = ::g->ylookup[::g->dc_yl] + ::g->columnofs[::g->dc_x+1];

	fracstep = ::g->dc_iscale; 
	frac = ::g->dc_texturemid + (::g->dc_yl-::g->centery)*fracstep;

	do 
	{
		// Hack. Does not work corretly.
		*dest2 = *dest = ::g->dc_colormap[::g->dc_source[(frac>>FRACBITS)&127]];
		dest += SCREENWIDTH;
		dest2 += SCREENWIDTH;
		frac += fracstep; 

	} while (count--);
}


//
// Spectre/Invisibility.
//





//
// Framebuffer postprocessing.
// Creates a fuzzy image by copying pixels
//  from adjacent ones to left and right.
// Used with an all black colormap, this
//  could create the SHADOW effect,
//  i.e. spectres and invisible ::g->players.
//
void R_DrawFuzzColumn ( lighttable_t * dc_colormap,
						  byte * dc_source ) 
{ 
	int			count; 
	byte*		dest; 
	fixed_t		frac;
	fixed_t		fracstep;	 

	// Adjust borders. Low... 
	if (!::g->dc_yl) 
		::g->dc_yl = 1;

	// .. and high.
	if (::g->dc_yh == ::g->viewheight-1) 
		::g->dc_yh = ::g->viewheight - 2; 

	count = ::g->dc_yh - ::g->dc_yl; 

	// Zero length.
	if (count < 0) 
		return; 


#ifdef RANGECHECK 
	if ((unsigned)::g->dc_x >= SCREENWIDTH
		|| ::g->dc_yl < 0 || ::g->dc_yh >= SCREENHEIGHT)
	{
		I_Error ("R_DrawFuzzColumn: %i to %i at %i",
			::g->dc_yl, ::g->dc_yh, ::g->dc_x);
	}
#endif


	// Keep till ::g->detailshift bug in blocky mode fixed,
	//  or blocky mode removed.
	/* WATCOM code 
	if (::g->detailshift)
	{
	if (::g->dc_x & 1)
	{
	outpw (GC_INDEX,GC_READMAP+(2<<8) ); 
	outp (SC_INDEX+1,12); 
	}
	else
	{
	outpw (GC_INDEX,GC_READMAP); 
	outp (SC_INDEX+1,3); 
	}
	dest = destview + ::g->dc_yl*80 + (::g->dc_x>>1); 
	}
	else
	{
	outpw (GC_INDEX,GC_READMAP+((::g->dc_x&3)<<8) ); 
	outp (SC_INDEX+1,1<<(::g->dc_x&3)); 
	dest = destview + ::g->dc_yl*80 + (::g->dc_x>>2); 
	}*/


	// Does not work with blocky mode.
	dest = ::g->ylookup[::g->dc_yl] + ::g->columnofs[::g->dc_x];

	// Looks familiar.
	fracstep = ::g->dc_iscale; 
	frac = ::g->dc_texturemid + (::g->dc_yl-::g->centery)*fracstep; 

	// Looks like an attempt at dithering,
	//  using the colormap #6 (of 0-31, a bit
	//  brighter than average).
	do 
	{
		// Lookup framebuffer, and retrieve
		//  a pixel that is either one column
		//  left or right of the current one.
		// Add index from colormap to index.
		*dest = ::g->colormaps[6*256+dest[::g->fuzzoffset[::g->fuzzpos]]]; 

		// Clamp table lookup index.
		if (++::g->fuzzpos == FUZZTABLE) 
			::g->fuzzpos = 0;

		dest += SCREENWIDTH;

		frac += fracstep; 
	} while (count--); 
} 




//
// R_DrawTranslatedColumn
// Used to draw player ::g->sprites
//  with the green colorramp mapped to others.
// Could be used with different translation
//  tables, e.g. the lighter colored version
//  of the BaronOfHell, the HellKnight, uses
//  identical ::g->sprites, kinda brightened up.
//

void R_DrawTranslatedColumn ( lighttable_t * dc_colormap,
						  byte * dc_source ) 
{ 
	int			count; 
	byte*		dest; 
	fixed_t		frac;
	fixed_t		fracstep;	 

	count = ::g->dc_yh - ::g->dc_yl; 
	if (count < 0) 
		return; 

#ifdef RANGECHECK 
	if ((unsigned)::g->dc_x >= SCREENWIDTH
		|| ::g->dc_yl < 0
		|| ::g->dc_yh >= SCREENHEIGHT)
	{
		I_Error ( "R_DrawColumn: %i to %i at %i",
			::g->dc_yl, ::g->dc_yh, ::g->dc_x);
	}

#endif 


	// WATCOM VGA specific.
	/* Keep for fixing.
	if (::g->detailshift)
	{
	if (::g->dc_x & 1)
	outp (SC_INDEX+1,12); 
	else
	outp (SC_INDEX+1,3);

	dest = destview + ::g->dc_yl*80 + (::g->dc_x>>1); 
	}
	else
	{
	outp (SC_INDEX+1,1<<(::g->dc_x&3)); 

	dest = destview + ::g->dc_yl*80 + (::g->dc_x>>2); 
	}*/


	// FIXME. As above.
	dest = ::g->ylookup[::g->dc_yl] + ::g->columnofs[::g->dc_x]; 

	// Looks familiar.
	fracstep = ::g->dc_iscale; 
	frac = ::g->dc_texturemid + (::g->dc_yl-::g->centery)*fracstep; 

	// Here we do an additional index re-mapping.
	do 
	{
		// Translation tables are used
		//  to map certain colorramps to other ones,
		//  used with PLAY ::g->sprites.
		// Thus the "green" ramp of the player 0 sprite
		//  is mapped to gray, red, black/indigo. 
		*dest = dc_colormap[::g->dc_translation[dc_source[frac>>FRACBITS]]];
		dest += SCREENWIDTH;

		frac += fracstep; 
	} while (count--); 
} 




//
// R_InitTranslationTables
// Creates the translation tables to map
//  the green color ramp to gray, brown, red.
// Assumes a given structure of the PLAYPAL.
// Could be read from a lump instead.
//
void R_InitTranslationTables (void)
{
	int		i;

	::g->translationtables = (byte*)DoomLib::Z_Malloc (256*3+255, PU_STATIC, 0);
	::g->translationtables = (byte *)(( (intptr_t)::g->translationtables + 255 )& ~255);

	// translate just the 16 green colors
	for (i=0 ; i<256 ; i++)
	{
		if (i >= 0x70 && i<= 0x7f)
		{
			// map green ramp to gray, brown, red
			::g->translationtables[i] = 0x60 + (i&0xf);
			::g->translationtables [i+256] = 0x40 + (i&0xf);
			::g->translationtables [i+512] = 0x20 + (i&0xf);
		}
		else
		{
			// Keep all other colors as is.
			::g->translationtables[i] = ::g->translationtables[i+256] 
			= ::g->translationtables[i+512] = i;
		}
	}
}




//
// R_DrawSpan 
// With DOOM style restrictions on view orientation,
//  the floors and ceilings consist of horizontal slices
//  or spans with constant z depth.
// However, rotation around the world z axis is possible,
//  thus this mapping, while simpler and faster than
//  perspective correct texture mapping, has to traverse
//  the texture at an angle in all but a few cases.
// In consequence, flats are not stored by column (like walls),
//  and the inner loop has to step in texture space u and v.
//



// start of a 64*64 tile image 

// just for profiling


//
// Draws the actual span.
void R_DrawSpan ( fixed_t xfrac,
				  fixed_t yfrac,
				  fixed_t ds_y,
				  int ds_x1,
				  int ds_x2,
				  fixed_t ds_xstep,
				  fixed_t ds_ystep,
				  lighttable_t * ds_colormap,
				  byte * ds_source ) 
{ 
	byte*		dest; 
	int			count;
	int			spot; 

#ifdef RANGECHECK
	if (::g->ds_x2 < ::g->ds_x1
		|| ::g->ds_x1<0
		|| ::g->ds_x2>=SCREENWIDTH  
		|| (unsigned)::g->ds_y>SCREENHEIGHT)
	{
		I_Error( "R_DrawSpan: %i to %i at %i",
			::g->ds_x1,::g->ds_x2,::g->ds_y);
	}
	//	::g->dscount++; 
#endif 

	dest = ::g->ylookup[::g->ds_y] + ::g->columnofs[::g->ds_x1];

	// We do not check for zero spans here?
	count = ds_x2 - g->ds_x1; 

	if ( ds_x2 < ds_x1 ) {
		return;						// SMF - think this is the sky
	}

	do 
	{
		// Current texture index in u,v.
		spot = ((yfrac>>(16-6))&(63*64)) + ((xfrac>>16)&63);

		// Lookup pixel from flat texture tile,
		//  re-index using light/colormap.
		*dest++ = ds_colormap[ds_source[spot]];

		// Next step in u,v.
		xfrac += ds_xstep; 
		yfrac += ds_ystep;

	} while (count--); 
} 



// UNUSED.
// Loop unrolled by 4.
#if 0
void R_DrawSpan (void) 
{ 
	unsigned	position, step;

	byte*	source;
	byte*	colormap;
	byte*	dest;

	unsigned	count;
	usingned	spot; 
	unsigned	value;
	unsigned	temp;
	unsigned	xtemp;
	unsigned	ytemp;

	position = ((::g->ds_xfrac<<10)&0xffff0000) | ((::g->ds_yfrac>>6)&0xffff);
	step = ((::g->ds_xstep<<10)&0xffff0000) | ((::g->ds_ystep>>6)&0xffff);

	source = ::g->ds_source;
	colormap = ::g->ds_colormap;
	dest = ::g->ylookup[::g->ds_y] + ::g->columnofs[::g->ds_x1];	 
	count = ::g->ds_x2 - ::g->ds_x1 + 1; 

	while (count >= 4) 
	{ 
		ytemp = position>>4;
		ytemp = ytemp & 4032;
		xtemp = position>>26;
		spot = xtemp | ytemp;
		position += step;
		dest[0] = colormap[source[spot]]; 

		ytemp = position>>4;
		ytemp = ytemp & 4032;
		xtemp = position>>26;
		spot = xtemp | ytemp;
		position += step;
		dest[1] = colormap[source[spot]];

		ytemp = position>>4;
		ytemp = ytemp & 4032;
		xtemp = position>>26;
		spot = xtemp | ytemp;
		position += step;
		dest[2] = colormap[source[spot]];

		ytemp = position>>4;
		ytemp = ytemp & 4032;
		xtemp = position>>26;
		spot = xtemp | ytemp;
		position += step;
		dest[3] = colormap[source[spot]]; 

		count -= 4;
		dest += 4;
	} 
	while (count > 0) 
	{ 
		ytemp = position>>4;
		ytemp = ytemp & 4032;
		xtemp = position>>26;
		spot = xtemp | ytemp;
		position += step;
		*dest++ = colormap[source[spot]]; 
		count--;
	} 
} 
#endif


//
// Again..
//
void R_DrawSpanLow ( fixed_t xfrac,
				  fixed_t yfrac,
				  fixed_t ds_y,
				  int ds_x1,
				  int ds_x2,
				  fixed_t ds_xstep,
				  fixed_t ds_ystep,
				  lighttable_t * ds_colormap,
				  byte * ds_source ) 
{
	byte*		dest; 
	int			count;
	int			spot; 

#ifdef RANGECHECK 
	if (::g->ds_x2 < ::g->ds_x1
		|| ::g->ds_x1<0
		|| ::g->ds_x2>=SCREENWIDTH  
		|| (unsigned)::g->ds_y>SCREENHEIGHT)
	{
		I_Error( "R_DrawSpan: %i to %i at %i",
			::g->ds_x1,::g->ds_x2,::g->ds_y);
	}
	//	::g->dscount++; 
#endif 

	// Blocky mode, need to multiply by 2.
	::g->ds_x1 <<= 1;
	::g->ds_x2 <<= 1;

	dest = ::g->ylookup[::g->ds_y] + ::g->columnofs[::g->ds_x1];


	count = ::g->ds_x2 - ::g->ds_x1; 
	do 
	{ 
		spot = ((yfrac>>(16-6))&(63*64)) + ((xfrac>>16)&63);
		// Lowres/blocky mode does it twice,
		//  while scale is adjusted appropriately.
		*dest++ = ::g->ds_colormap[::g->ds_source[spot]]; 
		*dest++ = ::g->ds_colormap[::g->ds_source[spot]];

		xfrac += ::g->ds_xstep; 
		yfrac += ::g->ds_ystep; 

	} while (count--); 
}

//
// R_InitBuffer 
// Creats lookup tables that avoid
//  multiplies and other hazzles
//  for getting the framebuffer address
//  of a pixel to draw.
//
void
R_InitBuffer
( int		width,
 int		height ) 
{ 
	int		i; 

	// Handle resize,
	//  e.g. smaller view windows
	//  with border and/or status bar.
	::g->viewwindowx = (SCREENWIDTH-width) >> 1; 

	// Column offset. For windows.
	for (i=0 ; i<width ; i++) 
		::g->columnofs[i] = ::g->viewwindowx + i;

	// Samw with base row offset.
	if (width == SCREENWIDTH) 
		::g->viewwindowy = 0; 
	else 
		::g->viewwindowy = (SCREENHEIGHT-SBARHEIGHT-height) >> 1; 

	// Preclaculate all row offsets.
	for (i=0 ; i<height ; i++) 
		::g->ylookup[i] = ::g->screens[0] + (i+::g->viewwindowy)*SCREENWIDTH; 
} 




//
// R_FillBackScreen
// Fills the back screen with a pattern
//  for variable screen sizes
// Also draws a beveled edge.
//
void R_FillBackScreen (void) 
{ 
	byte*		src;
	byte*		dest; 
	int			x;
	int			y; 
	int			width, height, windowx, windowy;
	patch_t*	patch;

	// DOOM border patch.
	char	name1[] = "FLOOR7_2";
	// DOOM II border patch.
	char	name2[] = "GRNROCK";	

	char*	name;

	if (::g->scaledviewwidth == SCREENWIDTH)
		return;

	if ( ::g->gamemode == commercial)
		name = name2;
	else
		name = name1;

	src = (byte*)W_CacheLumpName (name, PU_CACHE_SHARED); 
	dest = ::g->screens[1]; 

	for (y=0 ; y<SCREENHEIGHT-SBARHEIGHT ; y++) { 
		for (x=0 ; x<SCREENWIDTH/64 ; x++) 	{ 
			memcpy(dest, src+((y&63)<<6), 64); 
			dest += 64; 
		} 
		if (SCREENWIDTH&63) 
		{ 
			memcpy(dest, src+((y&63)<<6), SCREENWIDTH&63); 
			dest += (SCREENWIDTH&63); 
		} 
	} 

	width = ::g->scaledviewwidth / GLOBAL_IMAGE_SCALER;
	height = ::g->viewheight / GLOBAL_IMAGE_SCALER;
	windowx = ::g->viewwindowx / GLOBAL_IMAGE_SCALER;
	windowy = ::g->viewwindowy / GLOBAL_IMAGE_SCALER;

	patch = (patch_t*)W_CacheLumpName ("brdr_t",PU_CACHE_SHARED);
	for (x=0 ; x<width ; x+=8) {
		V_DrawPatch (windowx+x,windowy-8,1,patch);
	}

	patch = (patch_t*)W_CacheLumpName ("brdr_b",PU_CACHE_SHARED);
	for (x=0 ; x<width ; x+=8) {
		V_DrawPatch (windowx+x,windowy+height,1,patch);
	}

	patch = (patch_t*)W_CacheLumpName ("brdr_l",PU_CACHE_SHARED);
	for (y=0 ; y<height ; y+=8) {
		V_DrawPatch (windowx-8,windowy+y,1,patch);
	}

	patch = (patch_t*)W_CacheLumpName ("brdr_r",PU_CACHE_SHARED);
	for (y=0 ; y<height ; y+=8) {
		V_DrawPatch (windowx+width,windowy+y,1,patch);
	}

	// Draw beveled edge. 
	V_DrawPatch(windowx-8, windowy-8, 1, (patch_t*)W_CacheLumpName ("brdr_tl",PU_CACHE_SHARED));
	V_DrawPatch(windowx+width, windowy-8, 1, (patch_t*)W_CacheLumpName ("brdr_tr",PU_CACHE_SHARED));
	V_DrawPatch(windowx-8, windowy+height, 1, (patch_t*)W_CacheLumpName ("brdr_bl",PU_CACHE_SHARED));
	V_DrawPatch (windowx+width, windowy+height, 1, (patch_t*)W_CacheLumpName ("brdr_br",PU_CACHE_SHARED));
} 


//
// Copy a screen buffer.
//
void
R_VideoErase
( unsigned	ofs,
 int		count ) 
{ 
	// LFB copy.
	// This might not be a good idea if memcpy
	//  is not optiomal, e.g. byte by byte on
	//  a 32bit CPU, as GNU GCC/Linux libc did
	//  at one point.
	memcpy(::g->screens[0]+ofs, ::g->screens[1]+ofs, count); 
} 


//
// R_DrawViewBorder
// Draws the border around the view
//  for different size windows?
//
void
V_MarkRect
( int		x,
 int		y,
 int		width,
 int		height ); 

void R_DrawViewBorder (void) 
{ 
	int		top;
	int		side;
	int		ofs;
	int		i; 

	if (::g->scaledviewwidth == SCREENWIDTH) 
		return; 

	top = ((SCREENHEIGHT-SBARHEIGHT)-::g->viewheight)/2; 
	side = (SCREENWIDTH-::g->scaledviewwidth)/2; 

	// copy top and one line of left side 
	R_VideoErase (0, top*SCREENWIDTH+side); 

	// copy one line of right side and bottom 
	ofs = (::g->viewheight+top)*SCREENWIDTH-side; 
	R_VideoErase (ofs, top*SCREENWIDTH+side); 

	// copy ::g->sides using wraparound 
	ofs = top*SCREENWIDTH + SCREENWIDTH-side; 
	side <<= 1;

	for (i=1 ; i < ::g->viewheight ; i++) 
	{ 
		R_VideoErase (ofs, side); 
		ofs += SCREENWIDTH; 
	} 

	// ? 
	V_MarkRect (0,0,SCREENWIDTH, SCREENHEIGHT-SBARHEIGHT); 
}