Code:
--------------------------------------------------------------------------------------------------------------------
//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "hud.h"
#include "kbutton.h"
#include "input.h"
#include <vgui/IInput.h>
#include "vgui_controls/controls.h"
#include "tier0/vprof.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#include "memdbgon.h"
//-------------------------------------------------- Constants
// #define CAM_MIN_DIST 30.0
#define CAM_ANGLE_MOVE .5
#define MAX_ANGLE_DIFF 10.0
#define PITCH_MAX 90.0
#define PITCH_MIN 0
#define YAW_MAX 135.0
#define YAW_MIN -135.0
#define CAM_MIN_DIST 8.0 // Don't let the camera get any closer than ...
#define CAM_MAX_DIST 96.0 // ... or any farther away than ...
#define CAM_SWITCH_DIST 96.0 // the default camera distance when switching 1st to 3rd person
#define CAM_HULL_OFFSET 6.0 // the size of the bounding hull used for collision checking
#define START_TRANS_DIST 40.0 // how close to player when it starts making model translucent
#define TRANS_DELTA 1.9921875 // Set to 255 / START_TRANS_DIST
#define dist 2
#define DIST 2
#define CAM_ANGLE_SPEED 10
#define CAM_ANGLE_DELTA 2.5
#define CAM_DIST_DELTA 1.0
#define camAngle 1
static Vector CAM_HULL_MIN(-CAM_HULL_OFFSET,-CAM_HULL_OFFSET,-CAM_HULL_OFFSET);
static Vector CAM_HULL_MAX( CAM_HULL_OFFSET, CAM_HULL_OFFSET, CAM_HULL_OFFSET);
//-------------------------------------------------- Global Variables
static ConVar cam_command( "cam_command", "0", FCVAR_CHEAT ); // tells camera to go to thirdperson
static ConVar cam_snapto( "cam_snapto", "0", FCVAR_ARCHIVE ); // snap to thirdperson view
static ConVar cam_ideallag( "cam_ideallag", "4.0", FCVAR_ARCHIVE, "Amount of lag used when matching offset to ideal angles in thirdperson view" );
static ConVar cam_idealdelta( "cam_idealdelta", "4.0", FCVAR_ARCHIVE, "Controls the speed when matching offset to ideal angles in thirdperson view" );
static ConVar cam_idealyaw( "cam_idealyaw", "0", FCVAR_ARCHIVE ); // thirdperson yaw
static ConVar cam_idealpitch( "cam_idealpitch", "0", FCVAR_ARCHIVE ); // thirperson pitch
static ConVar cam_idealdist( "cam_idealdist", "150", FCVAR_ARCHIVE ); // thirdperson distance
static ConVar cam_collision( "cam_collision", "1", FCVAR_ARCHIVE, "When in thirdperson and cam_collision is set to 1, an attempt is made to keep the camera from passing though walls." );
static ConVar cam_showangles( "cam_showangles", "0", FCVAR_CHEAT, "When in thirdperson, print viewangles/idealAngle/cameraoffsets to the console." );
static ConVar c_maxpitch( "c_maxpitch", "90", FCVAR_ARCHIVE );
static ConVar c_minpitch( "c_minpitch", "0", FCVAR_ARCHIVE );
static ConVar c_maxyaw( "c_maxyaw", "135", FCVAR_ARCHIVE );
static ConVar c_minyaw( "c_minyaw", "-135", FCVAR_ARCHIVE );
static ConVar c_maxdistance( "c_maxdistance", "200", FCVAR_ARCHIVE );
static ConVar c_mindistance( "c_mindistance", "30", FCVAR_ARCHIVE );
static ConVar c_orthowidth( "c_orthowidth", "100", FCVAR_ARCHIVE );
static ConVar c_orthoheight( "c_orthoheight", "100", FCVAR_ARCHIVE );
static kbutton_t cam_pitchup, cam_pitchdown, cam_yawleft, cam_yawright;
static kbutton_t cam_in, cam_out, cam_move; // -- "cam_move" is unused
float mf_NextSwitch;
extern const ConVar *sv_cheats;
// API Wrappers
/*
==============================
CAM_ToThirdPerson
==============================
*/
void CAM_ToThirdPerson(void)
{
input->CAM_ToThirdPerson();
// Let the local player know
C_BasePlayer *localPlayer = C_BasePlayer::GetLocalPlayer();
if ( localPlayer )
{
localPlayer->ThirdPersonSwitch( true );
}
}
/*
==============================
CAM_ToThirdPerson_MayaMode
==============================
*/
static bool & Is_CAM_ThirdPerson_MayaMode(void)
{
static bool s_b_CAM_ThirdPerson_MayaMode = false;
return s_b_CAM_ThirdPerson_MayaMode;
}
void CAM_ToThirdPerson_MayaMode(void)
{
bool &rb = Is_CAM_ThirdPerson_MayaMode();
rb = !rb;
}
/*
==============================
CAM_ToFirstPerson
==============================
*/
void CAM_ToFirstPerson(void)
{
input->CAM_ToFirstPerson();
// Let the local player know
C_BasePlayer *localPlayer = C_BasePlayer::GetLocalPlayer();
if ( localPlayer )
{
localPlayer->ThirdPersonSwitch( false );
}
}
/*
==============================
CAM_ToOrthographic
==============================
*/
void CAM_ToOrthographic(void)
{
input->CAM_ToOrthographic();
}
/*
==============================
CAM_StartMouseMove
==============================
*/
void CAM_StartMouseMove( void )
{
input->CAM_StartMouseMove();
}
/*
==============================
CAM_EndMouseMove
==============================
*/
void CAM_EndMouseMove( void )
{
input->CAM_EndMouseMove();
}
/*
==============================
CAM_StartDistance
==============================
*/
void CAM_StartDistance( void )
{
input->CAM_StartDistance();
}
/*
==============================
CAM_EndDistance
==============================
*/
void CAM_EndDistance( void )
{
input->CAM_EndDistance();
}
/*
==============================
CAM_ToggleSnapto
==============================
*/
void CAM_ToggleSnapto( void )
{
cam_snapto.SetValue( !cam_snapto.GetInt() );
}
/*
==============================
MoveToward
==============================
*/
float MoveToward( float cur, float goal, float lag )
{
if( cur != goal )
{
if( abs( cur - goal ) > 180.0 )
{
if( cur < goal )
cur += 360.0;
else
cur -= 360.0;
}
if( cur < goal )
{
if( cur < goal - 1.0 )
cur += ( goal - cur ) / lag;
else
cur = goal;
}
else
{
if( cur > goal + 1.0 )
cur -= ( cur - goal ) / lag;
else
cur = goal;
}
}
// bring cur back into range
if( cur < 0 )
cur += 360.0;
else if( cur >= 360 )
cur -= 360;
return cur;
}
/*
==============================
CAM_Think
==============================
*/
void CInput::CAM_Think( void )
{
VPROF("CAM_Think");
//
if ( m_pCameraThirdData )
{
return CAM_CameraThirdThink();
}
Vector idealAngle;
Vector camOffset;
float flSensitivity;
QAngle viewangles;
switch( cam_command.GetInt() )
{
case CAM_COMMAND_TOTHIRDPERSON:
CAM_ToThirdPerson();
break;
case CAM_COMMAND_TOFIRSTPERSON:
CAM_ToFirstPerson();
break;
case CAM_COMMAND_NONE:
default:
break;
}
// Toggle first/3rd person, check every 0.5 seconds
if(gpGlobals->curtime >= mf_NextSwitch) {
if(input->KeyState(&in_camchange))
{
mf_NextSwitch = gpGlobals->curtime + 0.5; /* Check if the key has been pressed every
0.5 seconds */
if(!m_fCameraInThirdPerson)
{
CAM_ToThirdPerson();
} else {
CAM_ToFirstPerson();
}
}
}
if( !m_fCameraInThirdPerson )
{
// If in FP mode, transparent
// This is sort of a hack since when the map first loads you ARE transparent...
// This is for when you switch from 3rd to 1st.
if(C_BasePlayer::GetLocalPlayer() ) {
C_BasePlayer::GetLocalPlayer()->SetRenderMode( kRenderTransColor );
C_BasePlayer::GetLocalPlayer()->SetRenderColorA(0);
}
return;
}
if ( !sv_cheats )
{
sv_cheats = cvar->FindVar( "sv_cheats" );
}
// If cheats have been disabled, pull us back out of third-person view.
/*if ( sv_cheats && !sv_cheats->GetBool() )
{
CAM_ToFirstPerson();
return;
}*/
// In Maya-mode
if ( Is_CAM_ThirdPerson_MayaMode() )
{
// Unless explicitly moving the camera, don't move it
m_fCameraInterceptingMouse = m_fCameraMovingWithMouse =
vgui::input()->IsKeyDown( KEY_LALT ) || vgui::input()->IsKeyDown( KEY_RALT );
if ( !m_fCameraMovingWithMouse )
return;
// Zero-out camera-control kbutton_t structures
memset( &cam_pitchup, 0, sizeof( cam_pitchup ) );
memset( &cam_pitchdown, 0, sizeof( cam_pitchdown ) );
memset( &cam_yawleft, 0, sizeof( cam_yawleft ) );
memset( &cam_yawright, 0, sizeof( cam_yawright ) );
memset( &cam_in, 0, sizeof( cam_in ) );
memset( &cam_out, 0, sizeof( cam_out ) );
// Unless left or right mouse button is down, don't do anything
#ifndef _XBOX
if ( /* Left+Middle Button Down */ vgui::input()->IsMouseDown( MOUSE_LEFT ) && vgui::input()->IsMouseDown( MOUSE_MIDDLE ) )
{
// Do only zoom in/out camera adjustment
m_fCameraDistanceMove = true;
}
else if ( /* Left Button Down */ vgui::input()->IsMouseDown( MOUSE_LEFT ) )
{
// Do only rotational camera movement
m_fCameraDistanceMove = false;
}
else if ( /* Right Button Down */ vgui::input()->IsMouseDown( MOUSE_RIGHT ) )
{
// Do only zoom in/out camera adjustment
m_fCameraDistanceMove = true;
}
else
{
// Neither left or right buttons down, don't do anything
ResetMouse();
return;
}
#endif
}
idealAngle[ PITCH ] = cam_idealpitch.GetFloat();
idealAngle[ YAW ] = cam_idealyaw.GetFloat();
idealAngle[ DIST ] = cam_idealdist.GetFloat();
//
//movement of the camera with the mouse
//
if ( m_fCameraMovingWithMouse )
{
int cpx, cpy;
#ifndef _XBOX
//get windows cursor position
GetMousePos (cpx, cpy);
#else
//xboxfixme
cpx = cpy = 0;
#endif
m_nCameraX = cpx;
m_nCameraY = cpy;
//check for X delta values and adjust accordingly
//eventually adjust YAW based on amount of movement
//don't do any movement of the cam using YAW/PITCH if we are zooming in/out the camera
if (!m_fCameraDistanceMove)
{
int x, y;
GetWindowCenter( x, y );
//keep the camera within certain limits around the player (ie avoid certain bad viewing angles)
if (m_nCameraX>x)
{
//if ((idealAngle[YAW]>=225.0)||(idealAngle[YAW]<135.0))
if (idealAngle[YAW]<c_maxyaw.GetFloat())
{
idealAngle[ YAW ] += (CAM_ANGLE_MOVE)*((m_nCameraX-x)/2);
}
if (idealAngle[YAW]>c_maxyaw.GetFloat())
{
idealAngle[YAW]=c_maxyaw.GetFloat();
}
}
else if (m_nCameraX<x)
{
//if ((idealAngle[YAW]<=135.0)||(idealAngle[YAW]>225.0))
if (idealAngle[YAW]>c_minyaw.GetFloat())
{
idealAngle[ YAW ] -= (CAM_ANGLE_MOVE)* ((x-m_nCameraX)/2);
}
if (idealAngle[YAW]<c_minyaw.GetFloat())
{
idealAngle[YAW]=c_minyaw.GetFloat();
}
}
//check for y delta values and adjust accordingly
//eventually adjust PITCH based on amount of movement
//also make sure camera is within bounds
if (m_nCameraY > y)
{
if(idealAngle[PITCH]<c_maxpitch.GetFloat())
{
idealAngle[PITCH] +=(CAM_ANGLE_MOVE)* ((m_nCameraY-y)/2);
}
if (idealAngle[PITCH]>c_maxpitch.GetFloat())
{
idealAngle[PITCH]=c_maxpitch.GetFloat();
}
}
else if (m_nCameraY<y)
{
if (idealAngle[PITCH]>c_minpitch.GetFloat())
{
idealAngle[PITCH] -= (CAM_ANGLE_MOVE)*((y-m_nCameraY)/2);
}
if (idealAngle[PITCH]<c_minpitch.GetFloat())
{
idealAngle[PITCH]=c_minpitch.GetFloat();
}
}
//set old mouse coordinates to current mouse coordinates
//since we are done with the mouse
if ( ( flSensitivity = gHUD.GetSensitivity() ) != 0 )
{
m_nCameraOldX=m_nCameraX*flSensitivity;
m_nCameraOldY=m_nCameraY*flSensitivity;
}
else
{
m_nCameraOldX=m_nCameraX;
m_nCameraOldY=m_nCameraY;
}
#ifndef _XBOX
ResetMouse();
#endif
}
}
//Nathan code here
if( input->KeyState( &cam_pitchup ) )
idealAngle[ PITCH ] += cam_idealdelta.GetFloat();
else if( input->KeyState( &cam_pitchdown ) )
idealAngle[ PITCH ] -= cam_idealdelta.GetFloat();
if( input->KeyState( &cam_yawleft ) )
idealAngle[ YAW ] -= cam_idealdelta.GetFloat();
else if( input->KeyState( &cam_yawright ) )
idealAngle[ YAW ] += cam_idealdelta.GetFloat();
if( input->KeyState( &cam_in ) )
{
idealAngle[ DIST ] -= 2*cam_idealdelta.GetFloat();
if( idealAngle[ DIST ] < CAM_MIN_DIST )
{
// If we go back into first person, reset the angle
idealAngle[ PITCH ] = 0;
idealAngle[ YAW ] = 0;
idealAngle[ DIST ] = 0;
}
}
else if( input->KeyState( &cam_out ) )
idealAngle[ 2 ] += 2*cam_idealdelta.GetFloat(); // Prevent the cam_out from going any further
// NOTE: Without this, it _appears_ it's not moving, but
// the transparency changes so it is... this fixes it.
if( dist > CAM_MAX_DIST )
dist == CAM_MIN_DIST;
if (m_fCameraDistanceMove)
{
int x, y;
GetWindowCenter( x, y );
if (m_nCameraY>y)
{
if(idealAngle[ DIST ]<c_maxdistance.GetFloat())
{
idealAngle[ DIST ] +=cam_idealdelta.GetFloat() * ((m_nCameraY-y)/2);
}
if (idealAngle[ DIST ]>c_maxdistance.GetFloat())
{
idealAngle[ DIST ]=c_maxdistance.GetFloat();
}
}
else if (m_nCameraY<y)
{
if (idealAngle[ DIST ]>c_mindistance.GetFloat())
{
idealAngle[ DIST ] -= (cam_idealdelta.GetFloat())*((y-m_nCameraY)/2);
}
if (idealAngle[ DIST ]<c_mindistance.GetFloat())
{
idealAngle[ DIST ]=c_mindistance.GetFloat();
}
}
//set old mouse coordinates to current mouse coordinates
//since we are done with the mouse
m_nCameraOldX=m_nCameraX*gHUD.GetSensitivity();
m_nCameraOldY=m_nCameraY*gHUD.GetSensitivity();
#ifndef _XBOX
ResetMouse();
#endif
}
// Obtain engine view angles and if they popped while the camera was static,
// fix the camera angles as well
engine->GetViewAngles( viewangles );
static QAngle s_oldAngles = viewangles;
if ( Is_CAM_ThirdPerson_MayaMode() && ( s_oldAngles != viewangles ) )
{
idealAngle[ PITCH ] += s_oldAngles[ PITCH ] - viewangles[ PITCH ];
idealAngle[ YAW ] += s_oldAngles[ YAW ] - viewangles[ YAW ];
s_oldAngles = viewangles;
}
// bring the pitch values back into a range that MoveToward can handle
if ( idealAngle[ PITCH ] > 180 )
idealAngle[ PITCH ] -= 360;
else if ( idealAngle[ PITCH ] < -180 )
idealAngle[ PITCH ] += 360;
// bring the yaw values back into a range that MoveToward can handle
// --
// Vitaliy: going with >= 180 and <= -180.
// This introduces a potential discontinuity when looking directly at model face
// as camera yaw will be jumping from +180 to -180 and back, but when working with
// the camera allows smooth rotational transitions from left to right and back.
// Otherwise one of the transitions that has ">"-comparison will be locked.
// --
if ( idealAngle[ YAW ] >= 180 )
idealAngle[ YAW ] -= 360;
else if ( idealAngle[ YAW ] <= -180 )
idealAngle[ YAW ] += 360;
// clamp pitch, yaw and dist...
idealAngle[ PITCH ] = clamp( idealAngle[ PITCH ], c_minpitch.GetFloat(), c_maxpitch.GetFloat() );
idealAngle[ YAW ] = clamp( idealAngle[ YAW ], c_minyaw.GetFloat(), c_maxyaw.GetFloat() );
idealAngle[ DIST ] = clamp( idealAngle[ DIST ], c_mindistance.GetFloat(), c_maxdistance.GetFloat() );
// update ideal angles
cam_idealpitch.SetValue( idealAngle[ PITCH ] );
cam_idealyaw.SetValue( idealAngle[ YAW ] );
cam_idealdist.SetValue( idealAngle[ DIST ] );
// Move the CameraOffset "towards" the idealAngle
// Note: CameraOffset = viewangle + idealAngle
VectorCopy( m_vecCameraOffset, idealAngle );
if( cam_snapto.GetInt() )
{
idealAngle [ YAW ] = cam_idealyaw.GetFloat() + viewangles[ YAW ];
idealAngle [ PITCH ] = cam_idealpitch.GetFloat() + viewangles[ PITCH ];
idealAngle [ DIST ] = cam_idealdist.GetFloat();
}
else
{
if( idealAngle[ YAW ] - viewangles[ YAW ] != cam_idealyaw.GetFloat() )
idealAngle[ YAW ] = MoveToward( idealAngle[ YAW ],
cam_idealyaw.GetFloat() + viewangles[ YAW ],
CAM_ANGLE_SPEED );
if( idealAngle[ PITCH ] - viewangles[ PITCH ] != cam_idealpitch.GetFloat() )
idealAngle[ PITCH ] = MoveToward( idealAngle[ PITCH ],
cam_idealpitch.GetFloat() + viewangles[ PITCH ],
CAM_ANGLE_SPEED );
if( !C_BasePlayer::GetLocalPlayer() ) {
// this code can be hit from the main menu, where it will crash
idealAngle[ 2 ] = dist; // if there's no localplayer to calc from
}
else {
trace_t tr;
float adjDist = dist;
C_BasePlayer* localPlayer = C_BasePlayer::GetLocalPlayer();
Vector origin = localPlayer->GetLocalOrigin(); // find our player's origin
origin += localPlayer->GetViewOffset(); // and from there, his eye position
AngleVectors( QAngle(idealAngle.x, idealAngle.y, idealAngle.z),
&idealAngle, NULL, NULL ); // get the forward vector
UTIL_TraceHull( origin, origin - (idealAngle * dist),
CAM_HULL_MIN, CAM_HULL_MAX,
MASK_SOLID, NULL, &tr ); /* use our previously #defined hull to
collision trace */
if( tr.fraction < 1.0 ) {
adjDist = dist * tr.fraction; // move the camera closer if it hit something
}
else {
adjDist = dist; // no trace hit, use cam_idealdist without adjusting it
}
if ( adjDist < START_TRANS_DIST ) {
localPlayer->SetRenderMode( kRenderTransColor ); // make him translucent
localPlayer->SetRenderColorA( (byte)(adjDist * TRANS_DELTA) ); // closer=less opacity
}
if( adjDist < CAM_MIN_DIST )
adjDist = CAM_MIN_DIST; // clamp up to minimum
if( adjDist > CAM_MAX_DIST )
adjDist = CAM_MAX_DIST; // clamp down to maximum
idealAngle[ 2 ] = adjDist;
}
}
if ( cam_showangles.GetInt() )
{
engine->Con_NPrintf( 4, "Pitch: %6.1f Yaw: %6.1f %38s", viewangles[ PITCH ], viewangles[ YAW ], "view angles" );
engine->Con_NPrintf( 6, "Pitch: %6.1f Yaw: %6.1f Dist: %6.1f %19s", cam_idealpitch.GetFloat(), cam_idealyaw.GetFloat(), cam_idealdist.GetFloat(), "ideal angles" );
engine->Con_NPrintf( 8, "Pitch: %6.1f Yaw: %6.1f Dist: %6.1f %16s", m_vecCameraOffset[ PITCH ], m_vecCameraOffset[ YAW ], m_vecCameraOffset[ DIST ], "camera offset" );
}
m_vecCameraOffset[ PITCH ] = camOffset[ PITCH ];
m_vecCameraOffset[ YAW ] = camOffset[ YAW ];
m_vecCameraOffset[ DIST ] = camOffset[ DIST ];
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void ClampRange180( float &value )
{
if ( value >= 180.0f )
{
value -= 360.0f;
}
else if ( value <= -180.0f )
{
value += 360.0f;
}
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void CInput::CAM_CameraThirdThink( void )
{
// Verify data.
if ( !m_pCameraThirdData )
return;
// Verify that we are in third person mode.
if( !m_fCameraInThirdPerson )
return;
// Obtain engine view angles and if they popped while the camera was static, fix the camera angles as well.
QAngle angView;
engine->GetViewAngles( angView );
// Move the CameraOffset "towards" the idealAngle, Note: CameraOffset = viewangle + idealAngle
Vector vecCamOffset;
VectorCopy( m_vecCameraOffset, vecCamOffset );
// Move the camera.
float flLag = max( 1, 1 + m_pCameraThirdData->m_flLag );
if( vecCamOffset[PITCH] - angView[PITCH] != m_pCameraThirdData->m_flPitch )
{
vecCamOffset[PITCH] = MoveToward( vecCamOffset[PITCH], ( m_pCameraThirdData->m_flPitch + angView[PITCH] ), flLag );
}
if( vecCamOffset[YAW] - angView[YAW] != m_pCameraThirdData->m_flYaw )
{
vecCamOffset[YAW] = MoveToward( vecCamOffset[YAW], ( m_pCameraThirdData->m_flYaw + angView[YAW] ), flLag );
}
if( abs( vecCamOffset[DIST] - m_pCameraThirdData->m_flDist ) < 2.0 )
{
vecCamOffset[DIST] = m_pCameraThirdData->m_flDist;
}
else
{
vecCamOffset[DIST] += ( m_pCameraThirdData->m_flDist - vecCamOffset[DIST] ) / flLag;
}
C_BasePlayer* pLocalPlayer = C_BasePlayer::GetLocalPlayer();
if ( pLocalPlayer )
{
Vector vecForward;
// Find our player's origin, and from there, the eye position.
Vector vecOrigin = pLocalPlayer->GetLocalOrigin();
vecOrigin += pLocalPlayer->GetViewOffset();
// Get the forward vector
AngleVectors( QAngle( vecCamOffset[PITCH], vecCamOffset[YAW], 0 ), &vecForward, NULL, NULL );
// Collision trace and move the camera closer if we hit something.
trace_t trace;
UTIL_TraceHull( vecOrigin, vecOrigin - ( vecForward * vecCamOffset[DIST] ), m_pCameraThirdData->m_vecHullMin,
m_pCameraThirdData->m_vecHullMax, MASK_SOLID, pLocalPlayer,
COLLISION_GROUP_NONE, &trace );
if( trace.fraction < 1.0 )
{
vecCamOffset[DIST] *= trace.fraction;
}
}
ClampRange180( vecCamOffset[PITCH] );
ClampRange180( vecCamOffset[YAW] );
m_vecCameraOffset[PITCH] = vecCamOffset[PITCH];
m_vecCameraOffset[YAW] = vecCamOffset[YAW];
m_vecCameraOffset[DIST] = vecCamOffset[DIST];
}
void CAM_PitchUpDown( const CCommand &args ) { KeyDown( &cam_pitchup, args[1] ); }
void CAM_PitchUpUp( const CCommand &args ) { KeyUp( &cam_pitchup, args[1] ); }
void CAM_PitchDownDown( const CCommand &args ) { KeyDown( &cam_pitchdown, args[1] ); }
void CAM_PitchDownUp( const CCommand &args ) { KeyUp( &cam_pitchdown, args[1] ); }
void CAM_YawLeftDown( const CCommand &args ) { KeyDown( &cam_yawleft, args[1] ); }
void CAM_YawLeftUp( const CCommand &args ) { KeyUp( &cam_yawleft, args[1] ); }
void CAM_YawRightDown( const CCommand &args ) { KeyDown( &cam_yawright, args[1] ); }
void CAM_YawRightUp( const CCommand &args ) { KeyUp( &cam_yawright, args[1] ); }
void CAM_InDown( const CCommand &args ) { KeyDown( &cam_in, args[1] ); }
void CAM_InUp( const CCommand &args ) { KeyUp( &cam_in, args[1] ); }
void CAM_OutDown( const CCommand &args ) { KeyDown( &cam_out, args[1] ); }
void CAM_OutUp( const CCommand &args ) { KeyUp( &cam_out, args[1] ); }
/*
==============================
CAM_ToThirdPerson
==============================
*/
void CInput::CAM_ToThirdPerson(void)
{
QAngle viewangles;
engine->GetViewAngles( viewangles );
if( !m_fCameraInThirdPerson )
{
m_fCameraInThirdPerson = true;
m_vecCameraOffset[ YAW ] = viewangles[ YAW ];
m_vecCameraOffset[ PITCH ] = viewangles[ PITCH ];
m_vecCameraOffset[ 2 ] = CAM_SWITCH_DIST;
// Set model to 'player' because when a map first loads
// it doesn't set the model... sort of a hack.
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
pPlayer->SetModel("player");
}
cam_command.SetValue( 0 );
}
/*
==============================
CAM_ToFirstPerson
==============================
*/
void CInput::CAM_ToFirstPerson(void)
{
m_fCameraInThirdPerson = false;
cam_command.SetValue( 0 );
}
/*
==============================
CAM_ToFirstPerson
==============================
*/
bool CInput::CAM_IsOrthographic(void) const
{
return m_CameraIsOrthographic;
}
/*
==============================
CAM_ToFirstPerson
==============================
*/
void CInput::CAM_OrthographicSize(float& w, float& h) const
{
w = c_orthowidth.GetFloat(); h = c_orthoheight.GetFloat();
}
/*
==============================
CAM_ToFirstPerson
==============================
*/
void CInput::CAM_ToOrthographic(void)
{
m_fCameraInThirdPerson = false;
m_CameraIsOrthographic = true;
cam_command.SetValue( 0 );
}
/*
==============================
CAM_StartMouseMove
==============================
*/
void CInput::CAM_StartMouseMove(void)
{
float flSensitivity;
//only move the cam with mouse if we are in third person.
if ( m_fCameraInThirdPerson )
{
//set appropriate flags and initialize the old mouse position
//variables for mouse camera movement
if (!m_fCameraMovingWithMouse)
{
int cpx, cpy;
m_fCameraMovingWithMouse=true;
m_fCameraInterceptingMouse=true;
#ifndef _XBOX
GetMousePos(cpx, cpy);
#else
// xboxfixme
cpx = cpy = 0;
#endif
m_nCameraX = cpx;
m_nCameraY = cpy;
if ( ( flSensitivity = gHUD.GetSensitivity() ) != 0 )
{
m_nCameraOldX=m_nCameraX*flSensitivity;
m_nCameraOldY=m_nCameraY*flSensitivity;
}
else
{
m_nCameraOldX=m_nCameraX;
m_nCameraOldY=m_nCameraY;
}
}
}
//we are not in 3rd person view..therefore do not allow camera movement
else
{
m_fCameraMovingWithMouse=false;
m_fCameraInterceptingMouse=false;
}
}
/*
==============================
CAM_EndMouseMove
the key has been released for camera movement
tell the engine that mouse camera movement is off
==============================
*/
void CInput::CAM_EndMouseMove(void)
{
m_fCameraMovingWithMouse=false;
m_fCameraInterceptingMouse=false;
}
/*
==============================
CAM_StartDistance
routines to start the process of moving the cam in or out
using the mouse
==============================
*/
void CInput::CAM_StartDistance(void)
{
//only move the cam with mouse if we are in third person.
if ( m_fCameraInThirdPerson )
{
//set appropriate flags and initialize the old mouse position
//variables for mouse camera movement
if (!m_fCameraDistanceMove)
{
int cpx, cpy;
m_fCameraDistanceMove=true;
m_fCameraMovingWithMouse=true;
m_fCameraInterceptingMouse=true;
#ifndef _XBOX
GetMousePos(cpx, cpy);
#else
// xboxfixme
cpx = cpy = 0;
#endif
m_nCameraX = cpx;
m_nCameraY = cpy;
m_nCameraOldX=m_nCameraX*gHUD.GetSensitivity();
m_nCameraOldY=m_nCameraY*gHUD.GetSensitivity();
}
}
//we are not in 3rd person view..therefore do not allow camera movement
else
{
m_fCameraDistanceMove=false;
m_fCameraMovingWithMouse=false;
m_fCameraInterceptingMouse=false;
}
}
/*
==============================
CAM_EndDistance
the key has been released for camera movement
tell the engine that mouse camera movement is off
==============================
*/
void CInput::CAM_EndDistance(void)
{
m_fCameraDistanceMove=false;
m_fCameraMovingWithMouse=false;
m_fCameraInterceptingMouse=false;
}
/*
==============================
CAM_IsThirdPerson
==============================
*/
int CInput::CAM_IsThirdPerson( void )
{
return m_fCameraInThirdPerson;
}
/*
==============================
CAM_GetCameraOffset
==============================
*/
void CInput::CAM_GetCameraOffset( Vector& ofs )
{
VectorCopy( m_vecCameraOffset, ofs );
}
/*
==============================
CAM_InterceptingMouse
==============================
*/
int CInput::CAM_InterceptingMouse( void )
{
return m_fCameraInterceptingMouse;
}
static ConCommand startpitchup( "+campitchup", CAM_PitchUpDown );
static ConCommand endpitcup( "-campitchup", CAM_PitchUpUp );
static ConCommand startpitchdown( "+campitchdown", CAM_PitchDownDown );
static ConCommand endpitchdown( "-campitchdown", CAM_PitchDownUp );
static ConCommand startcamyawleft( "+camyawleft", CAM_YawLeftDown );
static ConCommand endcamyawleft( "-camyawleft", CAM_YawLeftUp );
static ConCommand startcamyawright( "+camyawright", CAM_YawRightDown );
static ConCommand endcamyawright( "-camyawright", CAM_YawRightUp );
static ConCommand startcamin( "+camin", CAM_InDown );
static ConCommand endcamin( "-camin", CAM_InUp );
static ConCommand startcamout( "+camout", CAM_OutDown );
static ConCommand camout( "-camout", CAM_OutUp );
static ConCommand thirdperson( "thirdperson", ::CAM_ToThirdPerson, "Switch to thirdperson camera.", FCVAR_CHEAT );
static ConCommand thirdperson_mayamode( "thirdperson_mayamode", ::CAM_ToThirdPerson_MayaMode, "Switch to thirdperson Maya-like camera controls.", FCVAR_CHEAT );
static ConCommand firstperson( "firstperson", ::CAM_ToFirstPerson, "Switch to firstperson camera." );
static ConCommand camortho( "camortho", ::CAM_ToOrthographic, "Switch to orthographic camera.", FCVAR_CHEAT );
static ConCommand startcammousemove( "+cammousemove",::CAM_StartMouseMove);
static ConCommand endcammousemove( "-cammousemove",::CAM_EndMouseMove);
static ConCommand startcamdistance( "+camdistance", ::CAM_StartDistance );
static ConCommand endcamdistance( "-camdistance", ::CAM_EndDistance );
static ConCommand snapto( "snapto", CAM_ToggleSnapto );
/*
==============================
Init_Camera
==============================
*/
void CInput::Init_Camera( void )
{
m_CameraIsOrthographic = false;
}
--------------------------------------------------------------------------------------------------------------------
