697 lines
21 KiB
C++
697 lines
21 KiB
C++
//========= 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
|
|
|
|
|
|
|