tf2/tf2_src/game/shared/weapon_ifmsteadycam.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//===========================================================================//

#include "cbase.h"
#include "weapon_ifmsteadycam.h"
#include "in_buttons.h"
#include "usercmd.h"
#include "dt_shared.h"

#ifdef CLIENT_DLL
#include "vgui_controls/Controls.h"
#include "vgui/ISurface.h"
#include "vgui/IScheme.h"
#include "vgui/ILocalize.h"
#include "vgui/VGUI.h"
#include "tier1/KeyValues.h"
#include "toolframework/itoolframework.h"
#endif

//-----------------------------------------------------------------------------
// CWeaponIFMSteadyCam tables.
//-----------------------------------------------------------------------------
IMPLEMENT_NETWORKCLASS_ALIASED( WeaponIFMSteadyCam, DT_WeaponIFMSteadyCam )
LINK_ENTITY_TO_CLASS( weapon_ifm_steadycam, CWeaponIFMSteadyCam );
#if !( defined( TF_CLIENT_DLL ) || defined( TF_DLL ) )
PRECACHE_WEAPON_REGISTER( weapon_ifm_steadycam );
#endif

BEGIN_NETWORK_TABLE( CWeaponIFMSteadyCam, DT_WeaponIFMSteadyCam )	
END_NETWORK_TABLE()

#ifdef CLIENT_DLL

BEGIN_PREDICTION_DATA( CWeaponIFMSteadyCam ) 
	DEFINE_PRED_FIELD( m_bIsLocked, FIELD_BOOLEAN, 0 ),
	DEFINE_PRED_FIELD( m_bInSpringMode, FIELD_BOOLEAN, 0 ),
	DEFINE_PRED_FIELD( m_bInDirectMode, FIELD_BOOLEAN, 0 ),
	DEFINE_PRED_FIELD( m_vecOffset, FIELD_VECTOR, 0 ),
	DEFINE_PRED_FIELD( m_hLockTarget, FIELD_EHANDLE, 0 ),
	DEFINE_PRED_FIELD( m_vec2DVelocity, FIELD_VECTOR, 0 ),
	DEFINE_PRED_FIELD( m_vecActualViewOffset, FIELD_VECTOR, 0 ),
	DEFINE_PRED_FIELD( m_vecViewOffset, FIELD_VECTOR, 0 ),
	DEFINE_PRED_FIELD( m_flFOVOffsetY, FIELD_FLOAT, 0 ),
END_PREDICTION_DATA()

#endif


#ifdef GAME_DLL

BEGIN_DATADESC( CWeaponIFMSteadyCam )
	DEFINE_FIELD( m_hLockTarget, FIELD_EHANDLE ),
END_DATADESC()

#endif


//-----------------------------------------------------------------------------
// CWeaponIFMSteadyCam implementation. 
//-----------------------------------------------------------------------------
CWeaponIFMSteadyCam::CWeaponIFMSteadyCam()
{
#ifdef CLIENT_DLL
	m_bIsLocked = false;
	m_bInDirectMode = false;
	m_bInSpringMode = true;
	m_vec2DVelocity.Init();
	m_vecActualViewOffset.Init();
	m_vecViewOffset.Init();
	m_flFOVOffsetY = 0.0f;
	m_vecOffset.Init();
	m_hFont = vgui::INVALID_FONT;
	m_nTextureId = -1;
#endif
}

CWeaponIFMSteadyCam::~CWeaponIFMSteadyCam()
{
#ifdef CLIENT_DLL
	if ( vgui::surface() && m_nTextureId != -1 )
	{
		vgui::surface()->DestroyTextureID( m_nTextureId );
		m_nTextureId = -1;
	}
#endif
}


//-----------------------------------------------------------------------------
//
// Specific methods on the client 
//
//-----------------------------------------------------------------------------
#ifdef CLIENT_DLL


//-----------------------------------------------------------------------------
// Computes a matrix given a forward direction
//-----------------------------------------------------------------------------
void CWeaponIFMSteadyCam::MatrixFromForwardDirection( const Vector &vecForward, matrix3x4_t &mat )
{
	// Convert desired to quaternion
	Vector vecLeft( -vecForward.y, vecForward.x, 0.0f );
	if ( VectorNormalize( vecLeft ) < 1e-3 )
	{
		vecLeft.Init( 1.0f, 0.0f, 0.0f );
	}

	Vector vecUp;
	CrossProduct( vecForward, vecLeft, vecUp );
	MatrixInitialize( mat, m_vecRelativePosition, vecForward, vecLeft, vecUp );
}

	
//-----------------------------------------------------------------------------
// Updates the relative orientation of the camera, spring mode
//-----------------------------------------------------------------------------
void CWeaponIFMSteadyCam::ComputeMouseRay( const VMatrix &steadyCamToPlayer, Vector &vecForward )
{
	// Create a ray in steadycam space
	float flMaxD = 1.0f / tan( M_PI * m_flFOV / 360.0f );

	// Remap offsets into normalized space
	int w, h;
	GetViewportSize( w, h );

	float flViewX = ( w != 0 ) ? m_vecViewOffset.x / ( w / 2 ) : 0.0f;
	float flViewY = ( h != 0 ) ? m_vecViewOffset.y / ( h / 2 ) : 0.0f;

	flViewX *= flMaxD;
	flViewY *= flMaxD;
				    
	Vector vecSelectionDir( 1.0f, -flViewX, -flViewY );
	VectorNormalize( vecSelectionDir );

	// Rotate the ray into player coordinates
	Vector3DMultiply( steadyCamToPlayer, vecSelectionDir, vecForward );
}


//-----------------------------------------------------------------------------
// Updates the relative orientation of the camera, spring mode
//-----------------------------------------------------------------------------
void CWeaponIFMSteadyCam::UpdateDirectRelativeOrientation()
{
	// Compute a player to steadycam matrix
	VMatrix steadyCamToPlayer;
	MatrixFromAngles( m_angRelativeAngles, steadyCamToPlayer );
	MatrixSetColumn( steadyCamToPlayer, 3, m_vecRelativePosition );

	// Compute a forward direction
	Vector vecCurrentForward;
	MatrixGetColumn( steadyCamToPlayer, 0, &vecCurrentForward );

	// Before any updating occurs, sample the current 
	// world-space direction of the mouse
	Vector vecDesiredDirection;
	ComputeMouseRay( steadyCamToPlayer, vecDesiredDirection );

	// rebuild a roll-less orientation based on that direction vector
	matrix3x4_t mat;
	MatrixFromForwardDirection( vecDesiredDirection, mat );
	MatrixAngles( mat, m_angRelativeAngles );
	Assert( m_angRelativeAngles.IsValid() );

	m_vecActualViewOffset -= m_vecViewOffset;
	m_vecViewOffset.Init();
}

	
//-----------------------------------------------------------------------------
// Updates the relative orientation of the camera  when locked
//-----------------------------------------------------------------------------
void CWeaponIFMSteadyCam::UpdateLockedRelativeOrientation()
{
	CBasePlayer *pPlayer = GetPlayerOwner();
	if ( !pPlayer )
		return;
	
	Vector vecDesiredDirection = m_vecOffset;
	CBaseEntity *pLock = m_hLockTarget.Get();
	if ( pLock )
	{
		vecDesiredDirection += pLock->GetAbsOrigin();
	}

	Vector vecAbsOrigin;
	QAngle angAbsRotation;
	ComputeAbsCameraTransform( vecAbsOrigin, angAbsRotation );
	vecDesiredDirection -= vecAbsOrigin;
	VectorNormalize( vecDesiredDirection );

	matrix3x4_t mat;
	MatrixFromForwardDirection( vecDesiredDirection, mat );
	MatrixAngles( mat, m_angRelativeAngles );
}


//-----------------------------------------------------------------------------
// Updates the relative orientation of the camera
//-----------------------------------------------------------------------------
static ConVar ifm_steadycam_rotaterate( "ifm_steadycam_rotaterate", "60", FCVAR_ARCHIVE );
static ConVar ifm_steadycam_zoomspeed( "ifm_steadycam_zoomspeed", "1.0", FCVAR_ARCHIVE );
static ConVar ifm_steadycam_zoomdamp( "ifm_steadycam_zoomdamp", "0.95", FCVAR_ARCHIVE );
static ConVar ifm_steadycam_armspeed( "ifm_steadycam_armspeed", "0.5", FCVAR_ARCHIVE );
static ConVar ifm_steadycam_rotatedamp( "ifm_steadycam_rotatedamp", "0.95", FCVAR_ARCHIVE );
static ConVar ifm_steadycam_mousefactor( "ifm_steadycam_mousefactor", "1.0", FCVAR_ARCHIVE );
static ConVar ifm_steadycam_mousepower( "ifm_steadycam_mousepower", "1.0", FCVAR_ARCHIVE );

void CWeaponIFMSteadyCam::UpdateRelativeOrientation()
{
	if ( m_bIsLocked )
		return;

	if ( m_bInDirectMode )
	{
		UpdateDirectRelativeOrientation();
		return;
	}

	if ( ( m_vecViewOffset.x == 0.0f ) && ( m_vecViewOffset.y == 0.0f ) )
		return;

	// Compute a player to steadycam matrix
	VMatrix steadyCamToPlayer;
	MatrixFromAngles( m_angRelativeAngles, steadyCamToPlayer );
	MatrixSetColumn( steadyCamToPlayer, 3, m_vecRelativePosition );

	Vector vecCurrentForward;
	MatrixGetColumn( steadyCamToPlayer, 0, &vecCurrentForward );

	// Create a ray in steadycam space
	float flMaxD = 1.0f / tan( M_PI * m_flFOV / 360.0f );

	// Remap offsets into normalized space
	float flViewX = m_vecViewOffset.x / ( 384 / 2 );
	float flViewY = m_vecViewOffset.y / ( 288 / 2 );

	flViewX *= flMaxD * ifm_steadycam_mousefactor.GetFloat();
	flViewY *= flMaxD * ifm_steadycam_mousefactor.GetFloat();
				    
	Vector vecSelectionDir( 1.0f, -flViewX, -flViewY );
	VectorNormalize( vecSelectionDir );

	// Rotate the ray into player coordinates
	Vector vecDesiredDirection;
	Vector3DMultiply( steadyCamToPlayer, vecSelectionDir, vecDesiredDirection );

	float flDot = DotProduct( vecDesiredDirection, vecCurrentForward );
	flDot = clamp( flDot, -1.0f, 1.0f );
	float flAngle = 180.0f * acos( flDot ) / M_PI;
	if ( flAngle < 1e-3 )
	{
		matrix3x4_t mat;
		MatrixFromForwardDirection( vecDesiredDirection, mat );
		MatrixAngles( mat, m_angRelativeAngles );
		return;
	}

	Vector vecAxis;
	CrossProduct( vecCurrentForward, vecDesiredDirection, vecAxis );
	VectorNormalize( vecAxis );
	
	float flRotateRate = ifm_steadycam_rotaterate.GetFloat();
	if ( flRotateRate < 1.0f )
	{
		flRotateRate = 1.0f;
	}

	float flRateFactor = flAngle / flRotateRate;
	flRateFactor *= flRateFactor * flRateFactor;
	float flRate = flRateFactor * 30.0f;
	float flMaxAngle = gpGlobals->frametime * flRate;
	flAngle = clamp( flAngle, 0.0f, flMaxAngle );

	Vector vecNewForard;
	VMatrix rotation;
	MatrixBuildRotationAboutAxis( rotation, vecAxis, flAngle ); 
	Vector3DMultiply( rotation, vecCurrentForward, vecNewForard );

	matrix3x4_t mat;
	MatrixFromForwardDirection( vecNewForard, mat );
	MatrixAngles( mat, m_angRelativeAngles );

	Assert( m_angRelativeAngles.IsValid() );
}
	
	
//-----------------------------------------------------------------------------
// Toggles to springy camera
//-----------------------------------------------------------------------------
void CWeaponIFMSteadyCam::ToggleDirectMode()
{
	m_vecViewOffset.Init();
	m_vecActualViewOffset.Init();
	m_vec2DVelocity.Init();
	m_bInDirectMode = !m_bInDirectMode;
}

	
//-----------------------------------------------------------------------------
// Targets the camera to always look at a point
//-----------------------------------------------------------------------------
void CWeaponIFMSteadyCam::LockCamera()
{
	m_vecViewOffset.Init();
	m_vecActualViewOffset.Init();
	m_vec2DVelocity.Init();

	m_bIsLocked = !m_bIsLocked;
	if ( !m_bIsLocked )
	{
		UpdateLockedRelativeOrientation();
		return;
	}

	CBasePlayer *pPlayer = GetPlayerOwner();
	if ( !pPlayer )
		return;
	
	Vector vTraceStart, vTraceEnd, vTraceDir;
	QAngle angles;
	BaseClass::ComputeAbsCameraTransform( vTraceStart, angles );
	AngleVectors( angles, &vTraceDir );
	VectorMA( vTraceStart, 10000.0f, vTraceDir, vTraceEnd);

	trace_t tr;
	UTIL_TraceLine( vTraceStart, vTraceEnd, MASK_ALL, GetPlayerOwner(), COLLISION_GROUP_NONE, &tr );
	if ( tr.fraction == 1.0f )
	{
		m_bIsLocked = false;
		UpdateLockedRelativeOrientation();
		return;
	}

	m_hLockTarget = tr.m_pEnt;
	m_vecOffset = tr.endpos;
	if ( tr.m_pEnt )
	{
		m_vecOffset -= tr.m_pEnt->GetAbsOrigin();
	}
}


//-----------------------------------------------------------------------------
// Gets the abs orientation of the camera
//-----------------------------------------------------------------------------
void CWeaponIFMSteadyCam::ComputeAbsCameraTransform( Vector &vecAbsOrigin, QAngle &angAbsRotation )
{
	CBaseEntity *pLock = m_bIsLocked ? m_hLockTarget.Get() : NULL;
	CBasePlayer *pPlayer = GetPlayerOwner();
	if ( !pLock || !pPlayer )
	{
		BaseClass::ComputeAbsCameraTransform( vecAbsOrigin, angAbsRotation );
		return;
	}
	
	Vector vecDesiredDirection = m_vecOffset;
	if ( pLock )
	{
		vecDesiredDirection += pLock->GetAbsOrigin();
	}

	BaseClass::ComputeAbsCameraTransform( vecAbsOrigin, angAbsRotation );
	vecDesiredDirection -= vecAbsOrigin;
	VectorNormalize( vecDesiredDirection );

	matrix3x4_t mat;
	MatrixFromForwardDirection( vecDesiredDirection, mat );
	MatrixAngles( mat, angAbsRotation );
}


//-----------------------------------------------------------------------------
// Computes the view offset from the actual view offset
//-----------------------------------------------------------------------------
static ConVar ifm_steadycam_2dspringconstant( "ifm_steadycam_2dspringconstant", "33.0", FCVAR_ARCHIVE );
static ConVar ifm_steadycam_2ddragconstant( "ifm_steadycam_2ddragconstant", "11.0", FCVAR_ARCHIVE );

void CWeaponIFMSteadyCam::ComputeViewOffset()
{
	// Update 2D spring
	if ( !m_bInSpringMode )
	{
		m_vecViewOffset = m_vecActualViewOffset;
		return;
	}

	Vector2D dir;
	Vector2DSubtract( m_vecViewOffset.AsVector2D(), m_vecActualViewOffset.AsVector2D(), dir );
	float flDist = Vector2DNormalize( dir );

	Vector2D vecForce;
	Vector2DMultiply( dir, -flDist * ifm_steadycam_2dspringconstant.GetFloat(), vecForce );
	Vector2DMA( vecForce, -ifm_steadycam_2ddragconstant.GetFloat(), m_vec2DVelocity.AsVector2D(), vecForce ); 

	Vector2DMA( m_vecViewOffset.AsVector2D(), gpGlobals->frametime, m_vec2DVelocity.AsVector2D(), m_vecViewOffset.AsVector2D() ); 
	Vector2DMA( m_vec2DVelocity.AsVector2D(), gpGlobals->frametime, vecForce, m_vec2DVelocity.AsVector2D() ); 
}


//-----------------------------------------------------------------------------
// Camera control
//-----------------------------------------------------------------------------
static ConVar ifm_steadycam_noise( "ifm_steadycam_noise", "0.0", FCVAR_ARCHIVE | FCVAR_REPLICATED );
static ConVar ifm_steadycam_sensitivity( "ifm_steadycam_sensitivity", "1.0", FCVAR_ARCHIVE | FCVAR_REPLICATED );

void CWeaponIFMSteadyCam::ItemPostFrame()
{
	CBasePlayer *pPlayer = GetPlayerOwner();
	if ( !pPlayer )
		return;
	
	float flSensitivity = ifm_steadycam_sensitivity.GetFloat();

	Vector2D vecOldActualViewOffset = m_vecActualViewOffset.AsVector2D();
	if ( pPlayer->m_nButtons & IN_ATTACK )
	{
		const CUserCmd *pUserCmd = pPlayer->GetCurrentUserCommand();
		m_vecActualViewOffset.x += pUserCmd->mousedx * flSensitivity;
		m_vecActualViewOffset.y += pUserCmd->mousedy * flSensitivity;
	}
	else
	{
		if ( !m_bIsLocked && !m_bInDirectMode )
		{
			float flDamp = ifm_steadycam_rotatedamp.GetFloat();
			m_vecActualViewOffset.x *= flDamp;
			m_vecActualViewOffset.y *= flDamp;
		}
	}
	
	// Add noise
	if ( !m_bIsLocked )
	{
		float flNoise = ifm_steadycam_noise.GetFloat();
		if ( flNoise > 0.0f )
		{
			CUniformRandomStream stream;
			stream.SetSeed( (int)(gpGlobals->curtime * 100) );

			CGaussianRandomStream gauss( &stream );
			float dx = gauss.RandomFloat( 0.0f, flNoise );
			float dy = gauss.RandomFloat( 0.0f, flNoise );

			m_vecActualViewOffset.x += dx;
			m_vecActualViewOffset.y += dy;
		}
	}

	ComputeViewOffset();

	if ( pPlayer->m_nButtons & IN_ZOOM )
	{
		const CUserCmd *pUserCmd = pPlayer->GetCurrentUserCommand();
		m_flFOVOffsetY += pUserCmd->mousedy * flSensitivity;
	}
	else
	{
		float flDamp = ifm_steadycam_zoomdamp.GetFloat();
		m_flFOVOffsetY *= flDamp;
	}			    
	m_flFOV += m_flFOVOffsetY * ifm_steadycam_zoomspeed.GetFloat() / 1000.0f;
	m_flFOV = clamp( m_flFOV, 0.5f, 160.0f ); 

	if ( pPlayer->m_nButtons & IN_WALK )
	{
		const CUserCmd *pUserCmd = pPlayer->GetCurrentUserCommand();
		m_flArmLength -= ifm_steadycam_armspeed.GetFloat() * pUserCmd->mousedy;
	}

	if ( pPlayer->GetImpulse() == 87 )
	{
		ToggleDirectMode();
	}

	if ( pPlayer->GetImpulse() == 89 )
	{
		m_bInSpringMode = !m_bInSpringMode;
	}

	if ( pPlayer->m_afButtonPressed & IN_USE )
	{
		LockCamera();
	}

	if ( pPlayer->m_afButtonPressed & IN_ATTACK2 )
	{
		m_bFullScreen = !m_bFullScreen;
	}

	if ( pPlayer->GetImpulse() == 88 )
	{
		// Make the view angles exactly match the player
		m_vecViewOffset.Init();
		m_vecActualViewOffset.Init();
		m_vecOffset.Init();
		m_vec2DVelocity.Init();
		m_hLockTarget.Set( NULL );
		m_flArmLength = 0.0f;
		if ( m_bIsLocked )
		{
			LockCamera();
		}
		m_angRelativeAngles = pPlayer->EyeAngles();
		m_flFOV = pPlayer->GetFOV();
	}

	UpdateRelativeOrientation();
	TransmitRenderInfo();
}


//-----------------------------------------------------------------------------
// Records the state for the IFM
//-----------------------------------------------------------------------------
void CWeaponIFMSteadyCam::GetToolRecordingState( KeyValues *msg )
{
	BaseClass::GetToolRecordingState( msg );

	static CameraRecordingState_t state;
	state.m_flFOV = m_flFOV;
	ComputeAbsCameraTransform( state.m_vecEyePosition, state.m_vecEyeAngles );
	msg->SetPtr( "camera", &state );
}


//-----------------------------------------------------------------------------
// Slams view angles if the mouse is down
//-----------------------------------------------------------------------------
void CWeaponIFMSteadyCam::CreateMove( float flInputSampleTime, CUserCmd *pCmd, const QAngle &vecOldViewAngles )
{
	BaseClass::CreateMove( flInputSampleTime, pCmd, vecOldViewAngles );
	
	// Block angular movement when IN_ATTACK is pressed
	if ( pCmd->buttons & (IN_ATTACK | IN_WALK | IN_ZOOM) )
	{
		VectorCopy( vecOldViewAngles, pCmd->viewangles );
	}
}

	
//-----------------------------------------------------------------------------
// Purpose: Draw the weapon's crosshair
//-----------------------------------------------------------------------------
void CWeaponIFMSteadyCam::DrawArmLength( int x, int y, int w, int h, Color clr )
{
	// Draw a readout for the arm length
	if ( m_hFont == vgui::INVALID_FONT )
	{
		vgui::HScheme hScheme = vgui::scheme()->GetScheme( "ClientScheme" );
		vgui::IScheme *pScheme = vgui::scheme()->GetIScheme( hScheme );
		m_hFont	= pScheme->GetFont("DefaultVerySmall", false );	
		Assert( m_hFont != vgui::INVALID_FONT );
	}
	
	// Create our string
	char szString[256];
	Q_snprintf( szString, sizeof(szString), "Arm Length: %.2f\n", m_flArmLength );

	// Convert it to localize friendly unicode
	wchar_t wcString[256];
	g_pVGuiLocalize->ConvertANSIToUnicode( szString, wcString, sizeof(wcString) );

	int tw, th;
	vgui::surface()->GetTextSize( m_hFont, wcString, tw, th );

	vgui::surface()->DrawSetTextFont( m_hFont ); // set the font	
	vgui::surface()->DrawSetTextColor( clr ); // white
	vgui::surface()->DrawSetTextPos( x + w - tw - 10, y + 10 ); // x,y position

	vgui::surface()->DrawPrintText( wcString, wcslen(wcString) ); // print text
}


//-----------------------------------------------------------------------------
// Purpose: Draw the FOV
//-----------------------------------------------------------------------------
void CWeaponIFMSteadyCam::DrawFOV( int x, int y, int w, int h, Color clrEdges, Color clrTriangle )
{
	if ( m_nTextureId == -1 )
	{
		m_nTextureId = vgui::surface()->CreateNewTextureID();
		vgui::surface()->DrawSetTextureFile( m_nTextureId, "vgui/white", true, false );
	}

	// This is the fov
	int nSize = 30;
	int fx = x + w - 10 - nSize;
	int fy = y + h - 10;
	int fh = nSize * cos( M_PI * m_flFOV / 360.0f );
	int fw = nSize * sin( M_PI * m_flFOV / 360.0f );
		  
	vgui::Vertex_t v[3];
	v[0].m_Position.Init( fx, fy );
	v[0].m_TexCoord.Init( 0.0f, 0.0f );
	v[1].m_Position.Init( fx-fw, fy-fh );
	v[1].m_TexCoord.Init( 0.0f, 0.0f );
	v[2].m_Position.Init( fx+fw, fy-fh );
	v[2].m_TexCoord.Init( 0.0f, 0.0f );

	vgui::surface()->DrawSetTexture( m_nTextureId );
	vgui::surface()->DrawSetColor( clrTriangle );
	vgui::surface()->DrawTexturedPolygon( 3, v );

	vgui::surface()->DrawSetColor( clrEdges );
	vgui::surface()->DrawLine( fx, fy, fx - fw, fy - fh );
	vgui::surface()->DrawLine( fx, fy, fx + fw, fy - fh );
}


//-----------------------------------------------------------------------------
// Purpose: Draw the weapon's crosshair
//-----------------------------------------------------------------------------
void CWeaponIFMSteadyCam::DrawCrosshair( void )
{
	BaseClass::DrawCrosshair();

	int x, y, w, h;
	GetOverlayBounds( x, y, w, h );

	// Draw the targeting zone around the crosshair
	int r, g, b, a;
	gHUD.m_clrYellowish.GetColor( r, g, b, a );
		 
	Color gray( 255, 255, 255, 192 );
	Color light( r, g, b, 255 );
	Color dark( r, g, b, 128 );
	Color red( 255, 0, 0, 128 );
	
	DrawArmLength( x, y, w, h, light );
	DrawFOV( x, y, w, h, light, dark );

	int cx, cy;
	cx = x + ( w / 2 );
	cy = y + ( h / 2 );

	// This is the crosshair
	vgui::surface()->DrawSetColor( gray );
	vgui::surface()->DrawFilledRect( cx-10, cy-1, cx-3, cy+1 );
	vgui::surface()->DrawFilledRect( cx+3, cy-1, cx+10, cy+1 );
	vgui::surface()->DrawFilledRect( cx-1, cy-10, cx+1, cy-3 );
	vgui::surface()->DrawFilledRect( cx-1, cy+3, cx+1, cy+10 );

	// This is the yellow aiming dot
	if ( ( m_vecViewOffset.x != 0.0f ) || ( m_vecViewOffset.y != 0.0f ) )
	{
		int ax, ay;
		ax = cx + m_vecViewOffset.x;
		ay = cy + m_vecViewOffset.y;
		vgui::surface()->DrawSetColor( light );
		vgui::surface()->DrawFilledRect( ax-2, ay-2, ax+2, ay+2 );
	}

	// This is the red actual dot
	if ( ( m_vecActualViewOffset.x != 0.0f ) || ( m_vecActualViewOffset.y != 0.0f ) )
	{
		int ax, ay;
		ax = cx + m_vecActualViewOffset.x;
		ay = cy + m_vecActualViewOffset.y;
		vgui::surface()->DrawSetColor( red );
		vgui::surface()->DrawFilledRect( ax-2, ay-2, ax+2, ay+2 );
	}

	// This is the purple fov dot
	if ( m_flFOVOffsetY != 0.0f )
	{
		Color purple( 255, 0, 255, 255 );
		int vy = cy + m_flFOVOffsetY;
		vgui::surface()->DrawSetColor( purple );
		vgui::surface()->DrawFilledRect( cx-2, vy-2, cx+2, vy+2 );
	}
}

#endif // CLIENT_DLL


//-----------------------------------------------------------------------------
//
// Specific methods on the server 
//
//-----------------------------------------------------------------------------
#ifdef GAME_DLL
	
void CWeaponIFMSteadyCam::ItemPostFrame()
{
}

#endif   // GAME_DLL