DOOM-3-BFG/doomclassic/doom/r_main.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 <stdlib.h>
#include <math.h>


#include "doomdef.h"
#include "d_net.h"

#include "m_bbox.h"

#include "r_local.h"
#include "r_sky.h"
#include "i_system.h"




// Fineangles in the SCREENWIDTH wide window.




// increment every time a check is made





// just for profiling purposes






// 0 = high, 1 = low

//
// precalculated math tables
//

// The ::g->viewangletox[::g->viewangle + FINEANGLES/4] lookup
// maps the visible view angles to screen X coordinates,
// flattening the arc to a flat ::g->projection plane.
// There will be many angles mapped to the same X. 

// The xtoviewangleangle[] table maps a screen pixel
// to the lowest ::g->viewangle that maps back to x ranges
// from ::g->clipangle to -::g->clipangle.


// UNUSED.
// The finetangentgent[angle+FINEANGLES/4] table
// holds the fixed_t tangent values for view angles,
// ranging from MININT to 0 to MAXINT.
// fixed_t		finetangent[FINEANGLES/2];

// fixed_t		finesine[5*FINEANGLES/4];
const fixed_t*		finecosine = &finesine[FINEANGLES/4];



// bumped light from gun blasts



void (*colfunc) (lighttable_t * dc_colormap,
				 byte * dc_source);
void (*basecolfunc) (lighttable_t * dc_colormap,
						byte * dc_source);
void (*fuzzcolfunc) (lighttable_t * dc_colormap,
						byte * dc_source);
void (*transcolfunc) (lighttable_t * dc_colormap,
						byte * dc_source);
void (*spanfunc) (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);



//
// R_AddPointToBox
// Expand a given bbox
// so that it encloses a given point.
//
void
R_AddPointToBox
( int		x,
 int		y,
 fixed_t*	box )
{
	if (x< box[BOXLEFT])
		box[BOXLEFT] = x;
	if (x> box[BOXRIGHT])
		box[BOXRIGHT] = x;
	if (y< box[BOXBOTTOM])
		box[BOXBOTTOM] = y;
	if (y> box[BOXTOP])
		box[BOXTOP] = y;
}


//
// R_PointOnSide
// Traverse BSP (sub) tree,
//  check point against partition plane.
// Returns side 0 (front) or 1 (back).
//
int
R_PointOnSide
( fixed_t	x,
 fixed_t	y,
 node_t*	node )
{
	fixed_t	dx;
	fixed_t	dy;
	fixed_t	left;
	fixed_t	right;

	if (!node->dx)
	{
		if (x <= node->x)
			return node->dy > 0;

		return node->dy < 0;
	}
	if (!node->dy)
	{
		if (y <= node->y)
			return node->dx < 0;

		return node->dx > 0;
	}

	dx = (x - node->x);
	dy = (y - node->y);

	// Try to quickly decide by looking at sign bits.
	if ( (node->dy ^ node->dx ^ dx ^ dy)&0x80000000 )
	{
		if  ( (node->dy ^ dx) & 0x80000000 )
		{
			// (left is negative)
			return 1;
		}
		return 0;
	}

	left = FixedMul ( node->dy>>FRACBITS , dx );
	right = FixedMul ( dy , node->dx>>FRACBITS );

	if (right < left)
	{
		// front side
		return 0;
	}
	// back side
	return 1;			
}


int
R_PointOnSegSide
( fixed_t	x,
 fixed_t	y,
 seg_t*	line )
{
	fixed_t	lx;
	fixed_t	ly;
	fixed_t	ldx;
	fixed_t	ldy;
	fixed_t	dx;
	fixed_t	dy;
	fixed_t	left;
	fixed_t	right;

	lx = line->v1->x;
	ly = line->v1->y;

	ldx = line->v2->x - lx;
	ldy = line->v2->y - ly;

	if (!ldx)
	{
		if (x <= lx)
			return ldy > 0;

		return ldy < 0;
	}
	if (!ldy)
	{
		if (y <= ly)
			return ldx < 0;

		return ldx > 0;
	}

	dx = (x - lx);
	dy = (y - ly);

	// Try to quickly decide by looking at sign bits.
	if ( (ldy ^ ldx ^ dx ^ dy)&0x80000000 )
	{
		if  ( (ldy ^ dx) & 0x80000000 )
		{
			// (left is negative)
			return 1;
		}
		return 0;
	}

	left = FixedMul ( ldy>>FRACBITS , dx );
	right = FixedMul ( dy , ldx>>FRACBITS );

	if (right < left)
	{
		// front side
		return 0;
	}
	// back side
	return 1;			
}


//
// R_PointToAngle
// To get a global angle from cartesian coordinates,
//  the coordinates are flipped until they are in
//  the first octant of the coordinate system, then
//  the y (<=x) is scaled and divided by x to get a
//  tangent (slope) value which is looked up in the
//  tantoangle[] table.

//




angle_t
R_PointToAngle
( fixed_t	x,
 fixed_t	y )
{	
	extern fixed_t GetViewX(); extern fixed_t GetViewY();
	x -= GetViewX();
	y -= GetViewY();

	if ( (!x) && (!y) )
		return 0;

	if (x>= 0)
	{
		// x >=0
		if (y>= 0)
		{
			// y>= 0

			if (x>y)
			{
				// octant 0
				return tantoangle[ SlopeDiv(y,x)];
			}
			else
			{
				// octant 1
				return ANG90-1-tantoangle[ SlopeDiv(x,y)];
			}
		}
		else
		{
			// y<0
			y = -y;

			if (x>y)
			{
				// octant 8
				return -tantoangle[SlopeDiv(y,x)]; // // ALANHACK UNSIGNED
			}
			else
			{
				// octant 7
				return ANG270+tantoangle[ SlopeDiv(x,y)];
			}
		}
	}
	else
	{
		// x<0
		x = -x;

		if (y>= 0)
		{
			// y>= 0
			if (x>y)
			{
				// octant 3
				return ANG180-1-tantoangle[ SlopeDiv(y,x)];
			}
			else
			{
				// octant 2
				return ANG90+ tantoangle[ SlopeDiv(x,y)];
			}
		}
		else
		{
			// y<0
			y = -y;

			if (x>y)
			{
				// octant 4
				return ANG180+tantoangle[ SlopeDiv(y,x)];
			}
			else
			{
				// octant 5
				return ANG270-1-tantoangle[ SlopeDiv(x,y)];
			}
		}
	}
	return 0;
}


angle_t
R_PointToAngle2
( fixed_t	x1,
 fixed_t	y1,
 fixed_t	x2,
 fixed_t	y2 )
{	
	extern void SetViewX( fixed_t ); extern void SetViewY( fixed_t );
	SetViewX( x1 );
	SetViewY( y1 );

	return R_PointToAngle (x2, y2);
}


fixed_t
R_PointToDist
( fixed_t	x,
 fixed_t	y )
{
	int		angle;
	fixed_t	dx;
	fixed_t	dy;
	fixed_t	temp;
	fixed_t	dist;

	extern fixed_t GetViewX(); extern fixed_t GetViewY();
	dx = abs(x - GetViewX());
	dy = abs(y - GetViewY());

	if (dy>dx)
	{
		temp = dx;
		dx = dy;
		dy = temp;
	}

	angle = (tantoangle[ FixedDiv(dy,dx)>>DBITS ]+ANG90) >> ANGLETOFINESHIFT;

	// use as cosine
	dist = FixedDiv (dx, finesine[angle] );	

	return dist;
}




//
// R_InitPointToAngle
//
void R_InitPointToAngle (void)
{
	// UNUSED - now getting from tables.c
#if 0
	int	i;
	long	t;
	float	f;
	//
	// slope (tangent) to angle lookup
	//
	for (i=0 ; i<=SLOPERANGE ; i++)
	{
		f = atan( (float)i/SLOPERANGE )/(3.141592657*2);
		t = 0xffffffff*f;
		tantoangle[i] = t;
	}
#endif
}


//
// R_ScaleFromGlobalAngle
// Returns the texture mapping scale
//  for the current line (horizontal span)
//  at the given angle.
// ::g->rw_distance must be calculated first.
//
fixed_t R_ScaleFromGlobalAngle (angle_t visangle)
{
	fixed_t		scale;
	//int			anglea;
	//int			angleb;
	angle_t		anglea;
	angle_t		angleb;
	int			sinea;
	int			sineb;
	fixed_t		num;
	int			den;

	// UNUSED
#if 0
	{
		fixed_t		dist;
		fixed_t		z;
		fixed_t		sinv;
		fixed_t		cosv;

		sinv = finesine[(visangle-::g->rw_normalangle)>>ANGLETOFINESHIFT];	
		dist = FixedDiv (::g->rw_distance, sinv);
		cosv = finecosine[(::g->viewangle-visangle)>>ANGLETOFINESHIFT];
		z = abs(FixedMul (dist, cosv));
		scale = FixedDiv(::g->projection, z);
		return scale;
	}
#endif

	extern angle_t GetViewAngle();
	anglea = ANG90 + (visangle-GetViewAngle());
	angleb = ANG90 + (visangle-::g->rw_normalangle);

	// both sines are allways positive
	sinea = finesine[anglea>>ANGLETOFINESHIFT];	
	sineb = finesine[angleb>>ANGLETOFINESHIFT];
	num = FixedMul(::g->projection,sineb) << ::g->detailshift;
	den = FixedMul(::g->rw_distance,sinea);

	// DHM - Nerve :: If the den is pretty much 0, don't try the divide
	if (den>>8 > 0 && den > num>>16)
	{
		scale = FixedDiv (num, den);

		if (scale > 64*FRACUNIT)
			scale = 64*FRACUNIT;
		else if (scale < 256)
			scale = 256;
	}
	else
		scale = 64*FRACUNIT;

	return scale;
}



//
// R_InitTables
//
void R_InitTables (void)
{
	// UNUSED: now getting from tables.c
#if 0
	int		i;
	float	a;
	float	fv;
	int		t;

	// ::g->viewangle tangent table
	for (i=0 ; i<FINEANGLES/2 ; i++)
	{
		a = (i-FINEANGLES/4+0.5)*PI*2/FINEANGLES;
		fv = FRACUNIT*tan (a);
		t = fv;
		finetangent[i] = t;
	}

	// finesine table
	for (i=0 ; i<5*FINEANGLES/4 ; i++)
	{
		// OPTIMIZE: mirror...
		a = (i+0.5)*PI*2/FINEANGLES;
		t = FRACUNIT*sin (a);
		finesine[i] = t;
	}
#endif

}



//
// R_InitTextureMapping
//
void R_InitTextureMapping (void)
{
	int			i;
	int			x;
	int			t;
	fixed_t		focallength;

	// Use tangent table to generate viewangletox:
	//  ::g->viewangletox will give the next greatest x
	//  after the view angle.
	//
	// Calc focallength
	//  so FIELDOFVIEW angles covers SCREENWIDTH.
	focallength = FixedDiv (::g->centerxfrac,
		finetangent[FINEANGLES/4+FIELDOFVIEW/2] );

	for (i=0 ; i<FINEANGLES/2 ; i++)
	{
		if (finetangent[i] > FRACUNIT*2)
			t = -1;
		else if (finetangent[i] < -FRACUNIT*2)
			t = ::g->viewwidth+1;
		else
		{
			t = FixedMul (finetangent[i], focallength);
			t = (::g->centerxfrac - t+FRACUNIT-1)>>FRACBITS;

			if (t < -1)
				t = -1;
			else if (t>::g->viewwidth+1)
				t = ::g->viewwidth+1;
		}
		::g->viewangletox[i] = t;
	}

	// Scan ::g->viewangletox[] to generate ::g->xtoviewangle[]:
	//  ::g->xtoviewangle will give the smallest view angle
	//  that maps to x.	
	for (x=0;x<=::g->viewwidth;x++)
	{
		i = 0;
		while (::g->viewangletox[i]>x)
			i++;
		::g->xtoviewangle[x] = (i<<ANGLETOFINESHIFT)-ANG90;
	}

	// Take out the fencepost cases from ::g->viewangletox.
	for (i=0 ; i<FINEANGLES/2 ; i++)
	{
		t = FixedMul (finetangent[i], focallength);
		t = ::g->centerx - t;

		if (::g->viewangletox[i] == -1)
			::g->viewangletox[i] = 0;
		else if (::g->viewangletox[i] == ::g->viewwidth+1)
			::g->viewangletox[i]  = ::g->viewwidth;
	}

	::g->clipangle = ::g->xtoviewangle[0];
}



//
// R_InitLightTables
// Only inits the ::g->zlight table,
//  because the ::g->scalelight table changes with view size.
//

void R_InitLightTables (void)
{
	int		i;
	int		j;
	int		level;
	int		nocollide_startmap; 	
	int		scale;

	// Calculate the light levels to use
	//  for each level / distance combination.
	for (i=0 ; i< LIGHTLEVELS ; i++)
	{
		nocollide_startmap = ((LIGHTLEVELS-1-i)*2)*NUMCOLORMAPS/LIGHTLEVELS;
		for (j=0 ; j<MAXLIGHTZ ; j++)
		{
			scale = FixedDiv ((SCREENWIDTH/2*FRACUNIT), (j+1)<<LIGHTZSHIFT);
			scale >>= LIGHTSCALESHIFT;
			level = nocollide_startmap - scale/DISTMAP;

			if (level < 0)
				level = 0;

			if (level >= NUMCOLORMAPS)
				level = NUMCOLORMAPS-1;

			::g->zlight[i][j] = ::g->colormaps + level*256;
		}
	}
}



//
// R_SetViewSize
// Do not really change anything here,
//  because it might be in the middle of a refresh.
// The change will take effect next refresh.
//


void
R_SetViewSize
( int		blocks,
 int		detail )
{
	::g->setsizeneeded = true;
	::g->setblocks = blocks;
	::g->setdetail = detail;
}


//
// R_ExecuteSetViewSize
//
void R_ExecuteSetViewSize (void)
{
	fixed_t	cosadj;
	fixed_t	dy;
	int		i;
	int		j;
	int		level;
	int		nocollide_startmap; 	

	::g->setsizeneeded = false;

	if (::g->setblocks == 11)
	{
		::g->scaledviewwidth = ORIGINAL_WIDTH;
		::g->viewheight = ORIGINAL_HEIGHT;
	}
	else
	{
		::g->scaledviewwidth = ::g->setblocks*32;
		::g->viewheight = (::g->setblocks*168/10)&~7;
	}

	// SMF - temp
	::g->scaledviewwidth *= GLOBAL_IMAGE_SCALER;
	::g->viewheight *= GLOBAL_IMAGE_SCALER;

	::g->detailshift = ::g->setdetail;
	::g->viewwidth = ::g->scaledviewwidth>>::g->detailshift;

	::g->centery = ::g->viewheight/2;
	::g->centerx = ::g->viewwidth/2;
	::g->centerxfrac = ::g->centerx<<FRACBITS;
	::g->centeryfrac = ::g->centery<<FRACBITS;
	::g->projection = ::g->centerxfrac;

	if (!::g->detailshift)
	{
		colfunc = basecolfunc = R_DrawColumn;
		fuzzcolfunc = R_DrawFuzzColumn;
		transcolfunc = R_DrawTranslatedColumn;
		spanfunc = R_DrawSpan;
	}
	else
	{
		colfunc = basecolfunc = R_DrawColumnLow;
		fuzzcolfunc = R_DrawFuzzColumn;
		transcolfunc = R_DrawTranslatedColumn;
		spanfunc = R_DrawSpanLow;
	}

	R_InitBuffer (::g->scaledviewwidth, ::g->viewheight);

	R_InitTextureMapping ();

	// psprite scales
	::g->pspritescale = FRACUNIT*::g->viewwidth/ORIGINAL_WIDTH;
	::g->pspriteiscale = FRACUNIT*ORIGINAL_WIDTH/::g->viewwidth;

	// thing clipping
	for (i=0 ; i < ::g->viewwidth ; i++)
		::g->screenheightarray[i] = ::g->viewheight;

	// planes
	for (i=0 ; i < ::g->viewheight ; i++)
	{
		dy = ((i-::g->viewheight/2)<<FRACBITS)+FRACUNIT/2;
		dy = abs(dy);
		::g->yslope[i] = FixedDiv ( (::g->viewwidth << ::g->detailshift)/2*FRACUNIT, dy);
	}

	for (i=0 ; i < ::g->viewwidth ; i++)
	{
		cosadj = abs(finecosine[::g->xtoviewangle[i]>>ANGLETOFINESHIFT]);
		::g->distscale[i] = FixedDiv (FRACUNIT,cosadj);
	}

	// Calculate the light levels to use
	//  for each level / scale combination.
	for (i=0 ; i< LIGHTLEVELS ; i++)
	{
		nocollide_startmap = ((LIGHTLEVELS-1-i)*2)*NUMCOLORMAPS/LIGHTLEVELS;
		for (j=0 ; j<MAXLIGHTSCALE ; j++)
		{
			level = nocollide_startmap - j*SCREENWIDTH/(::g->viewwidth << ::g->detailshift)/DISTMAP;

			if (level < 0)
				level = 0;

			if (level >= NUMCOLORMAPS)
				level = NUMCOLORMAPS-1;

			::g->scalelight[i][j] = ::g->colormaps + level*256;
		}
	}
}



//
// R_Init
//



void R_Init (void)
{
	R_InitData ();
	I_Printf ("\nR_InitData");
	R_InitPointToAngle ();
	I_Printf ("\nR_InitPointToAngle");
	R_InitTables ();
	// ::g->viewwidth / ::g->viewheight / ::g->detailLevel are set by the defaults
	I_Printf ("\nR_InitTables");

	R_SetViewSize (::g->screenblocks, ::g->detailLevel);
	R_InitPlanes ();
	I_Printf ("\nR_InitPlanes");
	R_InitLightTables ();
	I_Printf ("\nR_InitLightTables");
	R_InitSkyMap ();
	I_Printf ("\nR_InitSkyMap");
	R_InitTranslationTables ();
	I_Printf ("\nR_InitTranslationsTables");

	::g->framecount = 0;
}


//
// R_PointInSubsector
//
subsector_t*
R_PointInSubsector
( fixed_t	x,
 fixed_t	y )
{
	node_t*	node;
	int		side;
	int		nodenum;

	// single subsector is a special case
	if (!::g->numnodes)				
		return ::g->subsectors;

	nodenum = ::g->numnodes-1;

	while (! (nodenum & NF_SUBSECTOR) )
	{
		node = &::g->nodes[nodenum];
		side = R_PointOnSide (x, y, node);
		nodenum = node->children[side];
	}

	return &::g->subsectors[nodenum & ~NF_SUBSECTOR];
}



//
// R_SetupFrame
//
void R_SetupFrame (player_t* player)
{		
	int		i;

	::g->viewplayer = player;
	extern void SetViewX( fixed_t ); extern void SetViewY( fixed_t ); extern void SetViewAngle( angle_t );
	SetViewX( player->mo->x );
	SetViewY( player->mo->y );
	SetViewAngle( player->mo->angle + ::g->viewangleoffset );
	::g->extralight = player->extralight;

	::g->viewz = player->viewz;

	extern angle_t GetViewAngle();

	::g->viewsin = finesine[GetViewAngle()>>ANGLETOFINESHIFT];
	::g->viewcos = finecosine[GetViewAngle()>>ANGLETOFINESHIFT];

	::g->sscount = 0;

	if (player->fixedcolormap)
	{
		::g->fixedcolormap =
			::g->colormaps
			+ player->fixedcolormap*256*sizeof(lighttable_t);

		::g->walllights = ::g->scalelightfixed;

		for (i=0 ; i<MAXLIGHTSCALE ; i++)
			::g->scalelightfixed[i] = ::g->fixedcolormap;
	}
	else
		::g->fixedcolormap = 0;

	::g->framecount++;
	::g->validcount++;
}



//
// R_RenderView
//
void R_RenderPlayerView (player_t* player)
{
	if ( player->mo == NULL ) {
		return;
	}

	R_SetupFrame (player);

	// Clear buffers.
	R_ClearClipSegs ();
	R_ClearDrawSegs ();
	R_ClearPlanes ();
	R_ClearSprites ();

	// check for new console commands.
	NetUpdate ( NULL );

	// The head node is the last node output.
	R_RenderBSPNode (::g->numnodes-1);

	// Check for new console commands.
	NetUpdate ( NULL );

	R_DrawPlanes ();

	// Check for new console commands.
	NetUpdate ( NULL );

	R_DrawMasked ();

	// Check for new console commands.
	NetUpdate ( NULL );				
}