quakeforge-old/common/view.c

/*
view.c - player eye positioning

Copyright (C) 1996-1997 Id Software, Inc.
Copyright (C) 1999,2000 contributors of the QuakeForge project
Please see the file "AUTHORS" for a list of contributors

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.

*/

#include <quakedef.h>
#include <r_local.h>
#include <draw.h>
#include <mathlib.h>
#include <qtypes.h>
#include <qstructs.h>
#include <cmd.h>
#include <screen.h>
#include <console.h>
#include <cvar.h>

extern int	onground;

cvar_t	*lcd_x;			// FIXME: make this work sometime...
cvar_t	*lcd_yaw;

cvar_t	*scr_ofsx;
cvar_t	*scr_ofsy;
cvar_t	*scr_ofsz;

cvar_t	*cl_rollspeed;
cvar_t	*cl_rollangle;

cvar_t	*cl_bob;
cvar_t	*cl_bobcycle;
cvar_t	*cl_bobup;

cvar_t	*v_kicktime;
cvar_t	*v_kickroll;
cvar_t	*v_kickpitch;

cvar_t	*v_iyaw_cycle;
cvar_t	*v_iroll_cycle;
cvar_t	*v_ipitch_cycle;
cvar_t	*v_iyaw_level;
cvar_t	*v_iroll_level;
cvar_t	*v_ipitch_level;

cvar_t	*v_idlescale;

cvar_t	*crosshair;
cvar_t	*crosshaircolor;

cvar_t	*cl_crossx;
cvar_t	*cl_crossy;

cvar_t	*gl_cshiftpercent;

cvar_t	*v_contentblend;

float	v_dmg_time, v_dmg_roll, v_dmg_pitch;

extern	int			in_forward, in_forward2, in_back;

frame_t				*view_frame;
player_state_t		*view_message;

/*
	V_CalcRoll

	The view is allowed to move slightly from it's true position for
	bobbing, but if it exceeds 8 pixels linear distance (spherical, not
	box), the list of entities sent from the server may not include
	everything in the pvs, especially when crossing a water boudnary.
*/
float
V_CalcRoll (vec3_t angles, vec3_t velocity)
{
	vec3_t	forward, right, up;
	float	sign;
	float	side;
	float	value;
	
	AngleVectors (angles, forward, right, up);
	side = DotProduct (velocity, right);
	sign = side < 0 ? -1 : 1;
	side = fabs(side);
	
	value = cl_rollangle->value;

	if (side < cl_rollspeed->value)
		side = side * value / cl_rollspeed->value;
	else
		side = value;
	
	return side*sign;
	
}


/*
	V_CalcBob

	(desc)
*/
float
V_CalcBob ( void )
{
	static double	bobtime;
	static float	bob;
	float	cycle;
	
#ifdef QUAKEWORLD
	if (cl.spectator)
		return 0;

	if (onground == -1)
		return bob;		// just use old value
#endif

	bobtime += host_frametime;
	cycle = bobtime - (int)(bobtime/cl_bobcycle->value)*cl_bobcycle->value;
	cycle /= cl_bobcycle->value;
	if (cycle < cl_bobup->value)
		cycle = M_PI * cycle / cl_bobup->value;
	else
		cycle = M_PI + M_PI*(cycle-cl_bobup->value)/(1.0 - cl_bobup->value);

	// bob is proportional to simulated velocity in the xy plane
	// (don't count Z, or jumping messes it up)

	bob = sqrt(cl.simvel[0]*cl.simvel[0] + cl.simvel[1]*cl.simvel[1]) * cl_bob->value;
	bob = bob*0.3 + bob*0.7*sin(cycle);
	bob = bound( -7, bob, 4);
	return bob;
	
}


//=============================================================================


cvar_t	*v_centermove;
cvar_t	*v_centerspeed;

void
V_StartPitchDrift ( void )
{
	if (cl.laststop == cl.time) {
		return;		// something else is keeping it from drifting
	}

	if (cl.nodrift || !cl.pitchvel) {
		cl.pitchvel = v_centerspeed->value;
		cl.nodrift = false;
		cl.driftmove = 0;
	}
}

void
V_StopPitchDrift (void)
{
	cl.laststop = cl.time;
	cl.nodrift = true;
	cl.pitchvel = 0;
}

/*
	V_DriftPitch

	Move client pitch angle towards cl.idealpitch sent by the server.

	If user is adjusting pitch manually, either with lookup/lookdown,
	mlook and mouse, or klook and keyboard, pitch drifting is constantly
	stopped.

	Drifting is enabled when the center view key is hit, mlook is released
	and lookspring is nonzero, or when 
*/
void
V_DriftPitch ( void )
{
	float	delta, move;

#ifdef QUAKEWORLD
	if (view_message->onground == -1 || cls.demoplayback ) {
#elif UQUAKE
	if (noclip_anglehack || !cl.onground || cls.demoplayback ) {
#endif
		cl.driftmove = 0;
		cl.pitchvel = 0;
		return;
	}

	// don't count small mouse motion
	if ( cl.nodrift ) {
#ifdef QUAKEWORLD
		if ( fabs(cl.frames[(cls.netchan.outgoing_sequence-1)&UPDATE_MASK].cmd.forwardmove) < 200)
#elif UQUAKE
		if ( fabs(cl.cmd.forwardmove) < cl_forwardspeed->value)
#endif
			cl.driftmove = 0;
		else
			cl.driftmove += host_frametime;
	
		if ( cl.driftmove > v_centermove->value) {
			V_StartPitchDrift ();
		}
		return;
	}

	delta = cl.idealpitch - cl.viewangles[PITCH];

	if ( !delta ) {
		cl.pitchvel = 0;
		return;
	}

	move = host_frametime * cl.pitchvel;
	cl.pitchvel += host_frametime * v_centerspeed->value;
	
	//Con_Printf ("move: %f (%f)\n", move, host_frametime);

	if (delta > 0) {
		if (move > delta)
		{
			cl.pitchvel = 0;
			move = delta;
		}
		cl.viewangles[PITCH] += move;
	} else if (delta < 0) {
		if (move > -delta) {
			cl.pitchvel = 0;
			move = -delta;
		}
		cl.viewangles[PITCH] -= move;
	}
}


/*
============================================================================== 
 
						PALETTE FLASHES 
 
============================================================================== 
*/ 
 
 
cshift_t	cshift_empty = { {130,80,50}, 0 };
cshift_t	cshift_water = { {130,80,50}, 128 };
cshift_t	cshift_slime = { {0,25,5}, 150 };
cshift_t	cshift_lava = { {255,80,0}, 150 };

cvar_t		*v_gamma;

byte		gammatable[256];	// palette is sent through this

byte		ramps[3][256];
float		v_blend[4];		// rgba 0.0 - 1.0

void
BuildGammaTable ( float g )
{
	int		i, inf;
	
	if (g == 1.0) {
		for (i=0 ; i<256 ; i++)
			gammatable[i] = i;
		return;
	}
	
	for (i=0 ; i<256 ; i++) {
		inf = 255 * pow ( (i+0.5)/255.5 , g ) + 0.5;
		inf = bound(0, inf, 255);
		gammatable[i] = inf;
	}
}

/*
	V_CheckGamma

	(desc)
*/
qboolean
V_CheckGamma ( void )
{
	static float oldgammavalue;
	
	if (v_gamma->value == oldgammavalue)
		return false;
	oldgammavalue = v_gamma->value;
	
	BuildGammaTable (v_gamma->value);
	vid.recalc_refdef = 1;				// force a surface cache flush
	
	return true;
}


/*
	V_ParseDamage

	(desc)
*/
void
V_ParseDamage ( void )
{
	int		armor, blood;
	vec3_t	from;
	int		i;
	vec3_t	forward, right, up;
	float	side;
	float	count;
	
	armor = MSG_ReadByte ();
	blood = MSG_ReadByte ();
	for (i=0 ; i<3 ; i++)
		from[i] = MSG_ReadCoord ();

	count = blood*0.5 + armor*0.5;
	count = min(10, count);

	cl.faceanimtime = cl.time + 0.2;		// but sbar face into pain frame

	cl.cshifts[CSHIFT_DAMAGE].percent += 3*count;
	cl.cshifts[CSHIFT_DAMAGE].percent = bound(0, cl.cshifts[CSHIFT_DAMAGE].percent, 150);

	if ( armor > blood ) {
		cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 200;
		cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = 100;
		cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 100;
	} else if ( armor ) {
		cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 220;
		cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = 50;
		cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 50;
	} else {
		cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 255;
		cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = 0;
		cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 0;
	}

	// calculate view angle kicks
	VectorSubtract (from, cl.simorg, from);
	VectorNormalize (from);
	
	AngleVectors (cl.simangles, forward, right, up);

	side = DotProduct (from, right);
	v_dmg_roll = count*side*v_kickroll->value;
	
	side = DotProduct (from, forward);
	v_dmg_pitch = count*side*v_kickpitch->value;

	v_dmg_time = v_kicktime->value;
}


/*
	V_cshift_f

	(desc)
*/
void
V_cshift_f ( void )
{
	int i;
	
	for ( i=0 ; i<3 ; i++ )
		cshift_empty.destcolor[i] = atoi(Cmd_Argv(i+1));
	cshift_empty.percent = atoi(Cmd_Argv(4));
}


/*
	V_BonusFlash_f

	When you run over an item, the server sends this command
*/
void
V_BonusFlash_f ( void )
{
	cl.cshifts[CSHIFT_BONUS].destcolor[0] = 215;
	cl.cshifts[CSHIFT_BONUS].destcolor[1] = 186;
	cl.cshifts[CSHIFT_BONUS].destcolor[2] = 69;
	cl.cshifts[CSHIFT_BONUS].percent = 50;
}

/*
	V_SetContentsColor

	Underwater, lava, etc each has a color shift
*/
void
V_SetContentsColor (int contents)
{
	if (!v_contentblend->value) {
		cl.cshifts[CSHIFT_CONTENTS] = cshift_empty;
		return;
	}

	switch (contents) {
		case CONTENTS_EMPTY:
			cl.cshifts[CSHIFT_CONTENTS] = cshift_empty;
			break;
		case CONTENTS_LAVA:
			cl.cshifts[CSHIFT_CONTENTS] = cshift_lava;
			break;
		case CONTENTS_SOLID:
#ifdef UQUAKE
			cl.cshifts[CSHIFT_CONTENTS] = cshift_empty;
#endif
		case CONTENTS_SLIME:
			cl.cshifts[CSHIFT_CONTENTS] = cshift_slime;
			break;
		default:
			cl.cshifts[CSHIFT_CONTENTS] = cshift_water;
	}
}

/*
	V_CalcPowerupCshift

	Calculate the color to shade the view under powerups.
*/
void
V_CalcPowerupCshift ( void )
{
	if (cl.stats[STAT_ITEMS] & IT_QUAD) {
		cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 0;
		cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 0;
		cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 255;
		cl.cshifts[CSHIFT_POWERUP].percent = 30;
	} else if (cl.stats[STAT_ITEMS] & IT_SUIT) {
		cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 0;
		cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 255;
		cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 0;
		cl.cshifts[CSHIFT_POWERUP].percent = 20;
	} else if (cl.stats[STAT_ITEMS] & IT_INVISIBILITY) {
		cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 100;
		cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 100;
		cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 100;
		cl.cshifts[CSHIFT_POWERUP].percent = 100;
	} else if (cl.stats[STAT_ITEMS] & IT_INVULNERABILITY) {
		cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 255;
		cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 255;
		cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 0;
		cl.cshifts[CSHIFT_POWERUP].percent = 30;
	} else {
		cl.cshifts[CSHIFT_POWERUP].percent = 0;
	}
}

/*
	V_CalcBlend
*/
void
V_CalcBlend ( void )
{
	float	r, g, b, a, a2;
	int		j;

	r = 0;
	g = 0;
	b = 0;
	a = 0;

	for (j=0 ; j<NUM_CSHIFTS ; j++) {
		if (!gl_cshiftpercent->value)
			continue;

		a2 = ((cl.cshifts[j].percent * gl_cshiftpercent->value) / 100.0) / 255.0;

		if (!a2)
			continue;
		a = a + a2*(1-a);
//		Con_Printf ("j:%i a:%f\n", j, a);
		a2 = a2/a;
		r = r*(1-a2) + cl.cshifts[j].destcolor[0]*a2;
		g = g*(1-a2) + cl.cshifts[j].destcolor[1]*a2;
		b = b*(1-a2) + cl.cshifts[j].destcolor[2]*a2;
	}

	v_blend[0] = r/255.0;
	v_blend[1] = g/255.0;
	v_blend[2] = b/255.0;
	v_blend[3] = bound(0.0, a, 1.0);
}

/* 
============================================================================== 
 
						VIEW RENDERING 
 
============================================================================== 
*/ 

float
angledelta ( float a )
{
	a = anglemod(a);
	if (a > 180)
		a -= 360;
	return a;
}

/*
	CalcGunAngle

	Calculate gun angle. :)
*/
void
CalcGunAngle ( void )
{	
	float	yaw, pitch, move;
	static float oldyaw = 0;
	static float oldpitch = 0;
	
	yaw = r_refdef.viewangles[YAW];
	pitch = -r_refdef.viewangles[PITCH];

	yaw = angledelta(yaw - r_refdef.viewangles[YAW]) * 0.4;
	yaw = bound(-10, yaw, 10);

	pitch = angledelta(-pitch - r_refdef.viewangles[PITCH]) * 0.4;
	pitch = bound(-10, pitch, 10);

	move = host_frametime*20;
	if ( yaw > oldyaw ) {
		if (oldyaw + move < yaw)
			yaw = oldyaw + move;
	} else {
		if (oldyaw - move > yaw)
			yaw = oldyaw - move;
	}
	
	if ( pitch > oldpitch ) {
		if (oldpitch + move < pitch)
			pitch = oldpitch + move;
	} else {
		if (oldpitch - move > pitch)
			pitch = oldpitch - move;
	}
	
	oldyaw = yaw;
	oldpitch = pitch;

	cl.viewent.angles[YAW] = r_refdef.viewangles[YAW] + yaw;
	cl.viewent.angles[PITCH] = - (r_refdef.viewangles[PITCH] + pitch);
}


/*
	V_BoundOffsets

	absolutely bound refresh reletive to entity clipping hull so view can
	never be inside a solid wall
*/
void
V_BoundOffsets ( void )
{
	if (r_refdef.vieworg[0] < cl.simorg[0] - 14)
		r_refdef.vieworg[0] = cl.simorg[0] - 14;
	else if (r_refdef.vieworg[0] > cl.simorg[0] + 14)
		r_refdef.vieworg[0] = cl.simorg[0] + 14;
	if (r_refdef.vieworg[1] < cl.simorg[1] - 14)
		r_refdef.vieworg[1] = cl.simorg[1] - 14;
	else if (r_refdef.vieworg[1] > cl.simorg[1] + 14)
		r_refdef.vieworg[1] = cl.simorg[1] + 14;
	if (r_refdef.vieworg[2] < cl.simorg[2] - 22)
		r_refdef.vieworg[2] = cl.simorg[2] - 22;
	else if (r_refdef.vieworg[2] > cl.simorg[2] + 30)
		r_refdef.vieworg[2] = cl.simorg[2] + 30;
}


/*
	V_AddIdle

	Idle swaying
*/
void
V_AddIdle ( void )
{
	r_refdef.viewangles[ROLL] += v_idlescale->value * sin(cl.time*v_iroll_cycle->value) * v_iroll_level->value;
	r_refdef.viewangles[PITCH] += v_idlescale->value * sin(cl.time*v_ipitch_cycle->value) * v_ipitch_level->value;
	r_refdef.viewangles[YAW] += v_idlescale->value * sin(cl.time*v_iyaw_cycle->value) * v_iyaw_level->value;

	cl.viewent.angles[ROLL] -= v_idlescale->value * sin(cl.time*v_iroll_cycle->value) * v_iroll_level->value;
	cl.viewent.angles[PITCH] -= v_idlescale->value * sin(cl.time*v_ipitch_cycle->value) * v_ipitch_level->value;
	cl.viewent.angles[YAW] -= v_idlescale->value * sin(cl.time*v_iyaw_cycle->value) * v_iyaw_level->value;
}


/*
	V_CalcViewRoll

	Roll is induced by movement and damage
*/
void
V_CalcViewRoll (void)
{
	float		side;
		
	side = V_CalcRoll (cl.simangles, cl.simvel);
	r_refdef.viewangles[ROLL] += side;

	if (v_dmg_time > 0) {
		r_refdef.viewangles[ROLL] += v_dmg_time/v_kicktime->value*v_dmg_roll;
		r_refdef.viewangles[PITCH] += v_dmg_time/v_kicktime->value*v_dmg_pitch;
		v_dmg_time -= host_frametime;
	}

#ifdef UQUAKE
	if (cl.stats[STAT_HEALTH] <= 0)
	{
		r_refdef.viewangles[ROLL] = 80;	// dead view angle
		return;
	}
#endif
}


/*
	V_CalcIntermissionRefdef

	(desc)
*/
void
V_CalcIntermissionRefdef ( void )
{
	entity_t	*view;
	float		old;

	// view is the weapon model
	view = &cl.viewent;

	VectorCopy (cl.simorg, r_refdef.vieworg);
	VectorCopy (cl.simangles, r_refdef.viewangles);
	view->model = NULL;

	// allways idle in intermission
	old = v_idlescale->value;
	v_idlescale->value = 1;
	V_AddIdle ();
	v_idlescale->value = old;
}


/*
	V_CalcRefdef

	(desc)
*/
void
V_CalcRefdef ( void )
{
	entity_t		*view;
	int				i;
	vec3_t			forward, right, up;
#ifdef UQUAKE
	vec3_t			angles;
#endif
	float			bob;
	static float	oldz = 0;
	int 			vh;

	// Set up view height
#ifdef QUAKEWORLD
	vh = cl.qfserver ? cl.stats[STAT_VIEWHEIGHT] : 22;
#elif UQUAKE
	vh = cl.viewheight;
#endif

	V_DriftPitch ();

	// view is the weapon model (only visible from inside body)
	view = &cl.viewent;

	bob = V_CalcBob ();
	
	// refresh position from simulated origin
	VectorCopy (cl.simorg, r_refdef.vieworg);
#ifdef QUAKEWORLD
	r_refdef.vieworg[2] += bob;
#elif UQUAKE
	r_refdef.vieworg[2] += vh + bob;
#endif

	/*
		never let it sit exactly on a node line, because a water plane can
		dissapear when viewed with the eye exactly on it. the server protocol
		only specifies to 1/N pixel, so add VIEWORG_PIXADJUST in each axis
	*/
#ifdef QUAKEWORLD
#define VIEWORG_PIXADJUST	16
#elif UQUAKE
#define VIEWORG_PIXADJUST	32
#endif

	for ( i = 0 ; i < 3 ; i++ ) {
		r_refdef.vieworg[i] += 1.0/VIEWORG_PIXADJUST;
	}
	
	VectorCopy (cl.simangles, r_refdef.viewangles);
	V_CalcViewRoll ();
	V_AddIdle ();

	// offsets
#ifdef QUAKEWORLD
	if (view_message->flags & PF_GIB)
		r_refdef.vieworg[2] += 8;	// gib view height
	else if (view_message->flags & PF_DEAD)
		r_refdef.vieworg[2] -= 16;	// corpse view height
	else
		r_refdef.vieworg[2] += vh;	// view height

	if (view_message->flags & PF_DEAD)		// PF_GIB will also set PF_DEAD
		r_refdef.viewangles[ROLL] = 80;	// dead view angle

	AngleVectors ( cl.simangles, forward, right, up );
#elif UQUAKE
	angles[PITCH] = -cl.simangles[PITCH];	// because entity pitches are
											//  actually backward FIXME?
	angles[YAW] = cl.simangles[YAW];
	angles[ROLL] = cl.simangles[ROLL];

	AngleVectors (angles, forward, right, up);
	
	for (i=0 ; i<3 ; i++) {
		r_refdef.vieworg[i] += scr_ofsx->value*forward[i]
			+ scr_ofsy->value*right[i]
			+ scr_ofsz->value*up[i];
	}

	V_BoundOffsets ();
#endif

	// set up gun position
	VectorCopy (cl.simangles, view->angles);
	
	CalcGunAngle ();

	VectorCopy (cl.simorg, view->origin);
	view->origin[2] += vh;

	for ( i=0 ; i<3 ; i++ ) {
		view->origin[i] += forward[i]*bob*0.4;
//		view->origin[i] += right[i]*bob*0.4;
//		view->origin[i] += up[i]*bob*0.8;
	}
	view->origin[2] += bob;

	// fudge position around to keep amount of weapon visible
	// roughly equal with different FOV
	if (scr_viewsize->value == 110)
		view->origin[2] += 1;
	else if (scr_viewsize->value == 100)
		view->origin[2] += 2;
	else if (scr_viewsize->value == 90)
		view->origin[2] += 1;
	else if (scr_viewsize->value == 80)
		view->origin[2] += 0.5;

#ifdef QUAKEWORLD
	if (view_message->flags & (PF_GIB|PF_DEAD) )
 		view->model = NULL;
 	else
		view->model = cl.model_precache[cl.stats[STAT_WEAPON]];
	view->frame = view_message->weaponframe;
#elif UQUAKE
	view->model = cl.model_precache[cl.stats[STAT_WEAPON]];
	view->frame = cl.stats[STAT_WEAPONFRAME];
#endif
	view->colormap = vid.colormap;

	// set up the refresh position
	r_refdef.viewangles[PITCH] += cl.punchangle;

	// smooth out stair step ups
#ifdef QUAKEWORLD
	if ( (view_message->onground != -1) && (cl.simorg[2] - oldz > 0) ) {
#elif UQUAKE
	if ( cl.onground && (cl.simorg[2] - oldz > 0) ) {
#endif
		float steptime;
		
		steptime = host_frametime;
	
		oldz += steptime * 80;
		oldz = min(oldz, cl.simorg[2]);
		if (cl.simorg[2] - oldz > 12)
			oldz = cl.simorg[2] - 12;
		r_refdef.vieworg[2] += oldz - cl.simorg[2];
		view->origin[2] += oldz - cl.simorg[2];
	} else {
		oldz = cl.simorg[2];
	}
#ifdef UQUAKE
	if ( cl_chasecam->value )
		Chase_Update ();
#endif
}

/*
	DropPunchAngle

	(desc)
*/
#ifdef QUAKEWORLD
void
DropPunchAngle ( void )
{
	cl.punchangle -= 10*host_frametime;
	cl.punchangle = max(cl.punchangle, 0);
}
#endif

/*
	V_RenderView

	The player's clipping box goes from (-16 -16 -24) to (16 16 32) from
	the entity origin, so any view position inside that will be valid
*/
extern vrect_t scr_vrect;

void 
V_RenderView ( void )
{
#ifdef QUAKEWORLD
	if (cl.simangles[ROLL])
		Sys_Printf ("cl.simangles[ROLL] != 0");	// DEBUG
	cl.simangles[ROLL] = 0;	// FIXME
#endif

	if (cls.state != ca_active)
		return;

#ifdef QUAKEWORLD
	view_frame = &cl.frames[cls.netchan.incoming_sequence & UPDATE_MASK];
	view_message = &view_frame->playerstate[cl.playernum];
#elif UQUAKE
	// don't allow cheats in multiplayer
	if (cl.maxclients > 1) {
		Cvar_Set ("scr_ofsx", "0");
		Cvar_Set ("scr_ofsy", "0");
		Cvar_Set ("scr_ofsz", "0");
	}
#endif

#ifdef QUAKEWORLD
	DropPunchAngle ();
#endif
	if (cl.intermission) {	// intermission / finale rendering
		V_CalcIntermissionRefdef ();	
	} else {
		if (!cl.paused /* && (sv.maxclients > 1 || key_dest == key_game) */ )
			V_CalcRefdef ();
	}

	R_PushDlights ();
#if 0
	if (lcd_x->value) {
		/*
			render two interleaved views
		*/
		int		i;

		vid.rowbytes <<= 1;
		vid.aspect *= 0.5;

		r_refdef.viewangles[YAW] -= lcd_yaw->value;
		for (i=0 ; i<3 ; i++)
			r_refdef.vieworg[i] -= right[i]*lcd_x->value;
		R_RenderView ();

		vid.buffer += vid.rowbytes>>1;

		R_PushDlights ();

		r_refdef.viewangles[YAW] += lcd_yaw->value*2;
		for (i=0 ; i<3 ; i++)
			r_refdef.vieworg[i] += 2*right[i]*lcd_x->value;
		R_RenderView ();

		vid.buffer -= vid.rowbytes>>1;

		r_refdef.vrect.height <<= 1;

		vid.rowbytes >>= 1;
		vid.aspect *= 2;
	} else {
		R_RenderView ();
	}
#else
	R_RenderView ();
#endif
	
	if (crosshair->value)
		Draw_Crosshair();
}

//============================================================================

/*
	V_Init
	
	Create and initialize view cvars and console commands
*/
void
V_Init ( void )
{
	Cmd_AddCommand ("v_cshift", V_cshift_f);	
	Cmd_AddCommand ("bf", V_BonusFlash_f);
	Cmd_AddCommand ("centerview", V_StartPitchDrift);

	lcd_x = Cvar_Get ("lcd_x", "0", CVAR_NONE, "None");
	lcd_yaw = Cvar_Get ("lcd_yaw", "0", CVAR_NONE, "None");

	v_centermove	= Cvar_Get ("v_centermove", "0.15", CVAR_NONE, "None");
	v_centerspeed	= Cvar_Get ("v_centerspeed", "500", CVAR_NONE, "None");

	v_iyaw_cycle	= Cvar_Get ("v_iyaw_cycle", "2", CVAR_NONE, "None");
	v_iroll_cycle	= Cvar_Get ("v_iroll_cycle", "0.5", CVAR_NONE, "None");
	v_ipitch_cycle	= Cvar_Get ("v_ipitch_cycle", "1", CVAR_NONE, "None");
	v_iyaw_level	= Cvar_Get ("v_iyaw_level", "0.3", CVAR_NONE, "None");
	v_iroll_level	= Cvar_Get ("v_iroll_level", "0.1", CVAR_NONE, "None");
	v_ipitch_level	= Cvar_Get ("v_ipitch_level", "0.3", CVAR_NONE, "None");

	v_contentblend	= Cvar_Get ("v_contentblend", "1", CVAR_NONE, "Shift color in liquids");

	v_idlescale 	= Cvar_Get ("v_idlescale", "0", CVAR_NONE, "None");
	crosshaircolor	= Cvar_Get ("crosshaircolor", "79", CVAR_ARCHIVE, "Crosshair Color");
	crosshair		= Cvar_Get ("crosshair", "0", CVAR_ARCHIVE, "Crosshair selection");
	cl_crossx		= Cvar_Get ("cl_crossx", "0", CVAR_ARCHIVE, "Crosshair X location"); 
	cl_crossy		= Cvar_Get ("cl_crossy", "0", CVAR_ARCHIVE, "Crosshair Y location");
	gl_cshiftpercent = Cvar_Get ("gl_cshiftpercent", "100", CVAR_NONE, "Percentage of color shifting");

	scr_ofsx = Cvar_Get ("scr_ofsx", "0", CVAR_NONE, "None");
	scr_ofsy = Cvar_Get ("scr_ofsy", "0", CVAR_NONE, "None");
	scr_ofsz = Cvar_Get ("scr_ofsz", "0", CVAR_NONE, "None");

	cl_rollspeed = Cvar_Get ("cl_rollspeed", "200", CVAR_NONE, "None");
	cl_rollangle = Cvar_Get ("cl_rollangle", "2.0", CVAR_NONE, "None");
	cl_bob = Cvar_Get ("cl_bob", "0.02", CVAR_NONE, "None");
	cl_bobcycle = Cvar_Get ("cl_bobcycle", "0.6", CVAR_NONE, "None");
	cl_bobup = Cvar_Get ("cl_bobup", "0.5", CVAR_NONE, "None");

	v_kicktime = Cvar_Get ("v_kicktime", "0.5", CVAR_NONE, "None");
	v_kickroll = Cvar_Get ("v_kickroll", "0.6", CVAR_NONE, "None");
	v_kickpitch = Cvar_Get ("v_kickpitch", "0.6", CVAR_NONE, "None");
	v_gamma = Cvar_Get ("v_gamma", "1.0", CVAR_ARCHIVE, "Monitor gamma");

	BuildGammaTable (v_gamma->value);	// no gamma yet
}