Over the Shoulder View
Jump to navigation
Jump to search
Note:At this point you are actually not supposed to access the view data, it still works fine, though.
This tutorial will elaborate on how to create an over-the-shoulder camera view with collision detection. It has been created for the template and HL2:MP SDK on the source 2007 engine branch, therefore additional modifications might be necessary to allow functionality with a different SDK.
Step 1: separating view and aiming angle
To allow correct aiming in this mode, the actual viewangle and the angle the player will shoot along have to be split up first. To compensate the difference between the angles of viewsetup and player, the movement input will be translated before it is being sent to the server and clientside prediction system.
client.dll: iinput.h
Expand the input interface with these functions:
virtual void const GetCamViewangles( QAngle &view ) = 0;
virtual void SetCamViewangles( QAngle const &view ) = 0;
client.dll: input.h
Add these to the public area of the actual input implementation:
virtual void const GetCamViewangles( QAngle &view ){ view = m_angViewAngle; };
virtual void SetCamViewangles( QAngle const &view );
And these as private members:
QAngle m_angViewAngle;
void CalcPlayerAngle( CUserCmd *cmd );
client.dll: in_main.cpp
Add these includes at the top somewhere between cbase.h and tier0/memdbgon.h:
#include "view.h"
#include "hud_macros.h"
Look for the function named:
void CInput::Init_All (void)
Add these lines to the end:
m_angViewAngle = vec3_angle;
HOOK_MESSAGE( SetThirdpersonAngle );
Above that function add this snippet:
static void __MsgFunc_SetThirdpersonAngle( bf_read &msg )
{
bool bFPOnly;
msg.ReadBits( &bFPOnly, 1 );
if ( bFPOnly && ::input->CAM_IsThirdPerson() )
return;
QAngle angAbs;
msg.ReadBitAngles( angAbs );
::input->SetCamViewangles( angAbs );
}
Define the functions that you have declared previously in the header:
// Update the actual eyeangles of the player entity and translate the movement input
void CInput::CalcPlayerAngle( CUserCmd *cmd )
{
C_BasePlayer *pl = C_BasePlayer::GetLocalPlayer();
if ( !pl || !pl->AllowOvertheShoulderView() )
{
engine->SetViewAngles( m_angViewAngle );
return;
}
trace_t tr;
const Vector eyePos = pl->EyePosition();
UTIL_TraceLine( MainViewOrigin(), MainViewOrigin() + MainViewForward() * MAX_TRACE_LENGTH, MASK_SHOT, pl, COLLISION_GROUP_NONE, &tr );
// ensure that the player entity does not shoot towards the camera, get dist to plane where the player is on and add a constant
float flMinForward = abs( DotProduct( MainViewForward(), eyePos - MainViewOrigin() ) ) + 32.0f;
Vector vecTrace = tr.endpos - tr.startpos;
float flLenOld = vecTrace.NormalizeInPlace();
float flLen = max( flMinForward, flLenOld );
vecTrace *= flLen;
Vector vecFinalDir = MainViewOrigin() + vecTrace - eyePos; //eyePos;
QAngle playerangles;
VectorAngles( vecFinalDir, playerangles );
engine->SetViewAngles( playerangles );
QAngle angCam = m_angViewAngle;
playerangles.z = angCam.z = 0;
playerangles.x = angCam.x = 0;
Vector cFwd, cRight, pFwd, pRight;
AngleVectors( angCam, &cFwd, &cRight, NULL );
AngleVectors( playerangles, &pFwd, &pRight, NULL );
float flMove[2] = { cmd->forwardmove, cmd->sidemove };
cmd->forwardmove = DotProduct( cFwd, pFwd ) * flMove[ 0 ] + DotProduct( cRight, pFwd ) * flMove[ 1 ];
cmd->sidemove = DotProduct( cRight, pRight ) * flMove[ 1 ] + DotProduct( cFwd, pRight ) * flMove[ 0 ];
}
void CInput::SetCamViewangles( QAngle const &view )
{
m_angViewAngle = view;
if ( m_angViewAngle.x > 180.0f )
m_angViewAngle.x -= 360.0f;
if ( m_angViewAngle.x < -180.0f )
m_angViewAngle.x += 360.0f;
}
Note:At this point you are actually not supposed to access the view data, it still works fine, though.Search for the functions
void CInput::ExtraMouseSample( float frametime, bool active )
void CInput::CreateMove ( int sequence_number, float input_sample_frametime, bool active )
In both of them add the following line after the conditional block that starts with if ( active [...] right before engine->GetViewAngles( viewangles );
CalcPlayerAngle( cmd );
client.dll: in_mouse.cpp
Search for the function:
void CInput::MouseMove( CUserCmd *cmd )
Now comment or remove these lines:
QAngle viewangles;
engine->GetViewAngles( viewangles );
engine->SetViewAngles( viewangles );
And change the call to ApplyMouse(...) to read this:
ApplyMouse( m_angViewAngle, cmd, mouse_x, mouse_y );
Open sdk_usermessages.cpp for the template mod or hl2_usermessages.cpp for HL2:MP and add this line:
usermessages->Register( "SetThirdpersonAngle", -1 );
to the bottom of the function:
void RegisterUserMessages()
server.dll: player.h
Change this declaration:
void SnapEyeAngles( const QAngle &viewAngles );
To look like this:
void SnapEyeAngles( const QAngle &viewAngles, bool bFirstPersonOnly = false );
server.dll: player.cpp
Find the function:
void CBasePlayer::SnapEyeAngles( const QAngle &viewAngles )
Change it to look like this:
void CBasePlayer::SnapEyeAngles( const QAngle &viewAngles, bool bFirstPersonOnly )
{
pl.v_angle = viewAngles;
pl.fixangle = FIXANGLE_ABSOLUTE;
CSingleUserRecipientFilter user( this );
user.MakeReliable();
UserMessageBegin( user, "SetThirdpersonAngle" );
WRITE_BOOL( bFirstPersonOnly );
WRITE_ANGLES( viewAngles );
MessageEnd();
}
HL2:MP SDK:
Go to this function:
void CWeapon357::PrimaryAttack( void )
change this line:
pPlayer->SnapEyeAngles( angles );
To read this:
pPlayer->SnapEyeAngles( angles, true );
Step 2: Setting up the new view mode
The camera will be made to default to thirdperson mode and code will be added to calculate the view transformations.
client.dll: in_camera.cpp
Comment or remove this snippet:
// If cheats have been disabled, pull us back out of third-person view.
if ( sv_cheats && !sv_cheats->GetBool() )
{
CAM_ToFirstPerson();
return;
}
In the function:
void CInput::Init_Camera( void )
add this line to the end:
m_fCameraInThirdPerson = true;
Remove the FCVAR_CHEAT flag from ConCommand thirdperson at the end of the file, so it looks like this:
static ConCommand thirdperson( "thirdperson", ::CAM_ToThirdPerson, "Switch to thirdperson camera." );
Define these cvars near the top:
static ConVar cam_ots_offset( "cam_ots_offset", "20 -75 20", FCVAR_ARCHIVE );
static ConVar cam_ots_offsetlag( "cam_ots_offset_lag", "64.0", FCVAR_ARCHIVE );
static ConVar cam_ots_originlag( "cam_ots_origin_lag", "38.0", FCVAR_ARCHIVE );
static ConVar cam_ots_translucencythreshold( "cam_ots_translucencyThreshold", "32.0", FCVAR_ARCHIVE );
static ConVar cam_ots_shake_enable( "cam_ots_shake_enable", "1", FCVAR_ARCHIVE );
static ConVar cam_ots_shake_speed( "cam_ots_shake_speed", "400", FCVAR_ARCHIVE );
static ConVar cam_ots_shake_amount( "cam_ots_shake_amount", "2", FCVAR_ARCHIVE );
static ConVar cam_ots_shake_interpspeed( "cam_ots_shake_interpspeed", "5", FCVAR_ARCHIVE );
Find the function named:
void ClientModeShared::OverrideView( CViewSetup *pSetup )
Replace its content with this:
{
QAngle camAngles;
// Let the player override the view.
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if(!pPlayer)
return;
pPlayer->OverrideView( pSetup );
float flPlayerTranslucency = 0;
if( ::input->CAM_IsThirdPerson() )
{
if ( pPlayer->AllowOvertheShoulderView() )
{
// hack to hide weird interpolation issue for the origin of the listenserver host
static ConVarRef fakelag( "net_fakelag" );
if ( fakelag.GetInt() != 1 )
fakelag.SetValue( 1 );
enum // for readability
{
CAM_RIGHT = 0,
CAM_FORWARD,
CAM_UP
};
const Vector camHull( 10, 10, 10 ); // collision test hull
float idealcamShoulderOffset[3] = { 20, -75, 20 }; // ideal local offset; right, fwd, up
float idealcamShoulderOffset_ColTest[3] = { 30, -75, 20 }; // ideal local offset; right, fwd, up
const float camLag = cam_ots_offsetlag.GetFloat(); // smoothing speed
const float camOriginLag = cam_ots_originlag.GetFloat();
const bool bDoShake = cam_ots_shake_enable.GetBool();
QAngle angPunch = pPlayer->GetPunchAngle();
Vector velo;
const float flShake_Speed = cam_ots_shake_speed.GetFloat();
float flShake_Amt = cam_ots_shake_amount.GetFloat();
float flPlayerGroundSpeed = 0;
static float flInterpolate_GroundState = 1;
static float flInterpolate_AirSpeed = 0;
static float flTimer = 0;
float add = gpGlobals->frametime * flShake_Speed;
flTimer += add;
if ( flTimer > 360.0f )
flTimer -= 360.0f;
pPlayer->EstimateAbsVelocity(velo);
flInterpolate_AirSpeed = Approach( velo.z, flInterpolate_AirSpeed, gpGlobals->frametime * 1000.0f );
flPlayerGroundSpeed = velo.Length2DSqr() / 90000.0f;
bool bOnGround = (pPlayer->GetFlags() & FL_ONGROUND);
flInterpolate_GroundState = Approach( (bOnGround ? 1.0f : 0.0f), flInterpolate_GroundState, gpGlobals->frametime * cam_ots_shake_interpspeed.GetFloat() );
const float flInterpolate_AirState = 1.0f - flInterpolate_GroundState;
if ( Q_strlen( cam_ots_offset.GetString() ) > 1 )
{
CCommand cmd;
cmd.Tokenize( cam_ots_offset.GetString() );
if ( cmd.ArgC() >= 3 )
{
for ( int i = 0; i < 3; i++ )
idealcamShoulderOffset_ColTest[ i ] = idealcamShoulderOffset[ i ] = atoi( cmd[ i ] );
idealcamShoulderOffset_ColTest[ CAM_RIGHT ] += 10 * Sign( idealcamShoulderOffset_ColTest[ CAM_RIGHT ] );
}
}
flShake_Amt *= Vector( idealcamShoulderOffset[0], idealcamShoulderOffset[1], idealcamShoulderOffset[2] ).Length2DSqr()
/ 6425; // scale by difference to default length
const float eyeposlag_snap_threshold = 128;
static Vector eyepos_lag = vec3_origin;
const Vector eyepos = pPlayer->EyePosition();
float eyeposDist = (eyepos - eyepos_lag).Length();
if ( eyeposDist > eyeposlag_snap_threshold )
eyepos_lag = eyepos;
float speedVariety = eyeposDist / eyeposlag_snap_threshold;
if ( speedVariety )
{
Vector delta = eyepos - eyepos_lag;
float maxLength = delta.NormalizeInPlace();
delta *= min( maxLength, gpGlobals->frametime * (camOriginLag + camOriginLag * camOriginLag * speedVariety) );
eyepos_lag += delta;
}
QAngle viewAng;
Vector directions[ 3 ];
Vector idealCamPos;
static Vector lastLocalCamPos = vec3_origin;
trace_t tr;
::input->GetCamViewangles( viewAng );
if ( bDoShake )
{
viewAng.y += flInterpolate_GroundState * flPlayerGroundSpeed * FastCos( DEG2RAD( flTimer ) ) * flShake_Amt;
viewAng.x += flInterpolate_GroundState * flPlayerGroundSpeed * sin( DEG2RAD( flTimer ) * 2.0f ) * flShake_Amt * 0.5f;
viewAng.x -= flInterpolate_AirState * clamp( flInterpolate_AirSpeed, -1000.0f, 1000.0f ) / 25.0f;
}
AngleVectors( viewAng, &directions[CAM_FORWARD], &directions[CAM_RIGHT], &directions[CAM_UP] );
idealCamPos = eyepos_lag;
// set up possible cam positions to test for
Vector camPositions[3] = { idealCamPos, idealCamPos, idealCamPos };
const float idealPos_Dir[3][3] = { 1, 1, 1,
-1, 1, 1,
0, 1, 1 }; // three possible offsets
for ( int x = 0; x < 3; x++ )
for ( int y = 0; y < 3; y++ )
{
UTIL_TraceHull( camPositions[x], camPositions[x] + idealcamShoulderOffset_ColTest[ y ] * directions[y] * idealPos_Dir[x][y],
-camHull, camHull, MASK_SOLID, pPlayer, COLLISION_GROUP_DEBRIS, &tr );
camPositions[x] = tr.endpos;
}
// choose the camoffsets that give us the furthest distance
int bestDirection = 0;
float maxBack = (camPositions[ 0 ] - eyepos_lag).Length();
for ( int i = 1; i < 3; i++ )
{
float curBack = abs( (camPositions[ i ] - eyepos_lag).Length() ) - 5.0f * i;
if ( maxBack < curBack )
{
maxBack = curBack;
bestDirection = i;
}
}
const float sortFinalCollisionTest[3] = { CAM_FORWARD, CAM_UP, CAM_RIGHT }; // do collisiontest to the side at the end
// get the final cam position
Vector tmpidealCamPos = idealCamPos;
for ( int i = 0; i < 3; i++ )
{
int colTest = sortFinalCollisionTest[ i ];
// first check how far we can go actually
float maxShoulderOffset = idealcamShoulderOffset[colTest] * idealPos_Dir[ bestDirection ][ colTest ];
UTIL_TraceHull( tmpidealCamPos, tmpidealCamPos + maxShoulderOffset * directions[colTest],
-camHull, camHull, MASK_SOLID, pPlayer, COLLISION_GROUP_DEBRIS, &tr );
maxShoulderOffset = Sign( maxShoulderOffset ) * ( tr.endpos - tr.startpos ).Length();
tmpidealCamPos = tr.endpos;
// approach this position
float idealOffset = maxShoulderOffset;
if ( idealOffset != lastLocalCamPos[colTest] )
lastLocalCamPos[ colTest ] = Approach( idealOffset, lastLocalCamPos[ colTest ],
gpGlobals->frametime * camLag * abs(idealcamShoulderOffset[colTest] / idealcamShoulderOffset[CAM_RIGHT]) );
// don't punch through walls due to interpolation
UTIL_TraceHull( idealCamPos, idealCamPos + lastLocalCamPos[ colTest ] * directions[colTest],
-camHull, camHull, MASK_SOLID, pPlayer, COLLISION_GROUP_DEBRIS, &tr );
idealCamPos = tr.endpos;
}
// get rid of other unintended cam shaking
Vector localCamOffset = idealCamPos - eyepos_lag;
for ( int i = 0; i < 3; i++ )
{
float dot = DotProduct( directions[i], localCamOffset );
lastLocalCamPos[ i ] = ( min( idealPos_Dir[ bestDirection ][ i ], idealcamShoulderOffset[ i ] ) < 0) ?
max( lastLocalCamPos[i], dot ) : min( lastLocalCamPos[i], dot );
}
pSetup->origin = idealCamPos;
pSetup->angles = viewAng + angPunch;
const float zLimits_Norm[2] = { VEC_HULL_MIN.z, VEC_HULL_MAX.z };
const float zLimits_Ducked[2] = { VEC_DUCK_HULL_MIN.z, VEC_DUCK_HULL_MAX.z };
const float *zLimits = pPlayer->m_Local.m_bDucking ? zLimits_Ducked : zLimits_Norm;
Vector orig = pPlayer->GetAbsOrigin();
orig += zLimits[0];
const float minOpaqueDistSquared = cam_ots_translucencythreshold.GetFloat() * cam_ots_translucencythreshold.GetFloat();
Vector camDelta = idealCamPos - orig;
camDelta.z -= min( zLimits[1], max(0,camDelta.z) );
float distSqr = (camDelta).LengthSqr();
flPlayerTranslucency = 1.0f - ( minOpaqueDistSquared ? min( 1, distSqr / minOpaqueDistSquared ) : 1.0f );
}
else
{
Vector cam_ofs;
::input->CAM_GetCameraOffset( cam_ofs );
camAngles[ PITCH ] = cam_ofs[ PITCH ];
camAngles[ YAW ] = cam_ofs[ YAW ];
camAngles[ ROLL ] = 0;
Vector camForward, camRight, camUp;
AngleVectors( camAngles, &camForward, &camRight, &camUp );
VectorMA( pSetup->origin, -cam_ofs[ ROLL ], camForward, pSetup->origin );
// Override angles from third person camera
VectorCopy( camAngles, pSetup->angles );
}
}
else if (::input->CAM_IsOrthographic())
{
pSetup->m_bOrtho = true;
float w, h;
::input->CAM_OrthographicSize( w, h );
w *= 0.5f;
h *= 0.5f;
pSetup->m_OrthoLeft = -w;
pSetup->m_OrthoTop = -h;
pSetup->m_OrthoRight = w;
pSetup->m_OrthoBottom = h;
}
// translucency will not work flawlessly on player models that use one of the eyeshaders
// since those shaders do not support alpha blending by default
bool bWasTransulcent = pPlayer->GetRenderMode() != kRenderNormal ||
( pPlayer->GetActiveWeapon() && pPlayer->GetActiveWeapon()->GetRenderMode() != kRenderNormal );
bool bShouldBeTranslucent = !!flPlayerTranslucency;
if ( bWasTransulcent != bShouldBeTranslucent || bShouldBeTranslucent )
{
if ( bShouldBeTranslucent )
{
unsigned char alpha = ( 1.0f - flPlayerTranslucency ) * 255;
pPlayer->SetRenderMode( kRenderTransTexture, true );
pPlayer->SetRenderColorA( alpha );
if ( pPlayer->GetActiveWeapon() )
{
pPlayer->GetActiveWeapon()->SetRenderMode( kRenderTransTexture, true );
pPlayer->GetActiveWeapon()->SetRenderColorA( alpha );
}
}
else // not really required because this will be reset due to networking anyway
// disabling networking for those may cause other issues though
{
pPlayer->SetRenderMode( kRenderNormal, true );
pPlayer->SetRenderColorA( 255 );
if ( pPlayer->GetActiveWeapon() )
{
pPlayer->GetActiveWeapon()->SetRenderMode( kRenderNormal, true );
pPlayer->GetActiveWeapon()->SetRenderColorA( 255 );
}
}
}
}
client.dll: c_baseplayer.h
Only allow this mode when we're alive and spawned; declare this function as public:
virtual bool AllowOvertheShoulderView();
template SDK:
To enable stencil shadows for the player again, find virtual ShadowType_t ShadowCastType() and change the return value to SHADOWS_RENDER_TO_TEXTURE_DYNAMIC.
client.dll: c_baseplayer.cpp
Implement the function above:
bool C_BasePlayer::AllowOvertheShoulderView()
{
if ( !IsAlive() )
return false;
if ( GetTeamNumber() == TEAM_SPECTATOR )
return false;
return ::input->CAM_IsThirdPerson();
}
template SDK:
To fix the flashlight in the template mod, find this function:
void C_BasePlayer::UpdateFlashlight()
and replace its content with:
{
// The dim light is the flashlight.
if ( IsEffectActive( EF_DIMLIGHT ) )
{
if (!m_pFlashlight)
{
// Turned on the headlight; create it.
m_pFlashlight = new CFlashlightEffect(index);
if (!m_pFlashlight)
return;
m_pFlashlight->TurnOn();
}
Vector vec_origin = EyePosition();
QAngle ang_FlashlightAngle = EyeAngles();
int dist = FLASHLIGHT_DISTANCE;
if ( GetActiveWeapon() && ::input->CAM_IsThirdPerson() )
{
C_BaseCombatWeapon *pWeap = GetActiveWeapon();
int iAttachment = pWeap->LookupAttachment( "muzzle_flash" );
if ( iAttachment > 0 )
pWeap->GetAttachment( iAttachment, vec_origin, ang_FlashlightAngle );
else
{
Vector aimFwd;
AngleVectors( ang_FlashlightAngle, &aimFwd );
vec_origin += aimFwd * (VEC_HULL_MAX).Length2D();
}
dist = 0;
}
Vector vecForward, vecRight, vecUp;
AngleVectors( ang_FlashlightAngle, &vecForward, &vecRight, &vecUp );
// Update the light with the new position and direction.
m_pFlashlight->UpdateLight( vec_origin, vecForward, vecRight, vecUp, dist );
}
else if (m_pFlashlight)
{
// Turned off the flashlight; delete it.
delete m_pFlashlight;
m_pFlashlight = NULL;
}
}
HL2:MP SDK:
Declare this variable as private in CHL2MPPlayerAnimState:
QAngle m_angAiming;
HL2:MP SDK:
Search for the function named:
void CHL2MPPlayerAnimState::InitHL2MPAnimState( CHL2MP_Player *pPlayer )
Add this line to the end:
m_angAiming.Init();
Search for the function:
void CHL2MPPlayerAnimState::ComputePoseParam_AimPitch( CStudioHdr *pStudioHdr )
Replace this line:
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iAimPitch, flAimPitch );
with these:
m_angAiming.x = Approach( flAimPitch, m_angAiming.x, gpGlobals->frametime * 110.0f );
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iAimPitch, m_angAiming.x );
Go to:
void CHL2MPPlayerAnimState::ComputePoseParam_AimYaw( CStudioHdr *pStudioHdr )
Replace this line:
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iAimYaw, flAimYaw );
with these:
m_angAiming.y = Approach( flAimYaw, m_angAiming.y, gpGlobals->frametime * 110.0f );
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iAimYaw, m_angAiming.y );
Find this function:
void CHL2MPPlayerAnimState::Update( float eyeYaw, float eyePitch )
Replace this block at the end:
#ifdef CLIENT_DLL
if ( C_BasePlayer::ShouldDrawLocalPlayer() )
{
m_pHL2MPPlayer->SetPlaybackRate( 1.0f );
}
#endif
With this snippet:
#ifdef CLIENT_DLL
//if ( !m_pPlayer->IsLocalPlayer() || C_BasePlayer::ShouldDrawLocalPlayer() )
{
float flSeqSpeed = m_pPlayer->GetSequenceGroundSpeed( m_pPlayer->GetSequence() );
Vector vecVelocity;
GetOuterAbsVelocity( vecVelocity );
float flSpeed = vecVelocity.Length2DSqr();
bool bMoving_OnGround = flSpeed > 0.01f && m_pPlayer->GetGroundEntity();
flSpeed = bMoving_OnGround ? clamp( (vecVelocity.Length2DSqr() / (flSeqSpeed*flSeqSpeed)), 0.2f, 2.0f ) : 1.0f;
m_pHL2MPPlayer->SetPlaybackRate( flSpeed );
}
#endif
Search for the function named:
bool CHL2MPPlayerAnimState::HandleDucking( Activity &idealActivity )
Replace this line:
if ( m_pHL2MPPlayer->GetFlags() & FL_DUCKING )
with these:
if ( m_pHL2MPPlayer->GetFlags() & FL_DUCKING
#ifdef CLIENT_DLL
|| ( m_pHL2MPPlayer->IsLocalPlayer() && m_pHL2MPPlayer->m_Local.m_bDucking )
#endif
)
Look for this function:
void CHL2MPPlayerAnimState::ComputePoseParam_MoveYaw( CStudioHdr *pStudioHdr )
After this line:
QAngle angles = GetBasePlayer()->GetLocalAngles();
Add this snippet:
#ifdef CLIENT_DLL
if ( !m_pPlayer->IsLocalPlayer() )
angles = GetBasePlayer()->EyeAngles();
#endif
client.dll: fx_tracer.cpp
HL2:MP SDK:
Add this include:
#include "iinput.h"
Find this function:
Vector GetTracerOrigin( const CEffectData &data )
Replace the line:
if ( pWpn && pWpn->IsCarriedByLocalPlayer() )
with this one:
if ( pWpn && pWpn->IsCarriedByLocalPlayer() && !::input->CAM_IsThirdPerson() )
client.dll: c_hl2mp_player.cpp
HL2:MP SDK:
To fix the flashlight in a HL2:MP mod, find the function named:
void C_HL2MP_Player::UpdateFlashlight()
Replace its content with:
{
// The dim light is the flashlight.
if ( IsEffectActive( EF_DIMLIGHT ) )
{
if (!m_pHL2MPFlashLightEffect)
{
// Turned on the headlight; create it.
m_pHL2MPFlashLightEffect = new CHL2MPFlashlightEffect(index);
if (!m_pHL2MPFlashLightEffect)
return;
m_pHL2MPFlashLightEffect->TurnOn();
}
Vector vecForward, vecRight, vecUp;
Vector position = EyePosition();
if ( ::input->CAM_IsThirdPerson() )
{
if ( GetActiveWeapon() )
{
C_BaseCombatWeapon *pWeap = GetActiveWeapon();
int iAttachment = pWeap->LookupAttachment( "muzzle" );
if ( iAttachment > 0 )
{
QAngle ang;
pWeap->GetAttachment( iAttachment, position, ang );
AngleVectors( ang, &vecForward, &vecRight, &vecUp );
position += vecForward * 6.0f;
}
else
{
EyeVectors( &vecForward, &vecRight, &vecUp );
position += vecForward * (VEC_HULL_MAX).Length2D();
}
}
}
else
EyeVectors( &vecForward, &vecRight, &vecUp );
// Update the light with the new position and direction.
m_pHL2MPFlashLightEffect->UpdateLight( position, vecForward, vecRight, vecUp, FLASHLIGHT_DISTANCE );
}
else if (m_pHL2MPFlashLightEffect)
{
// Turned off the flashlight; delete it.
delete m_pHL2MPFlashLightEffect;
m_pHL2MPFlashLightEffect = NULL;
}
}
Go to the function named:
void C_HL2MP_Player::AddEntity( void )
Replace these lines:
else if( this != C_BasePlayer::GetLocalPlayer() || ::input->CAM_IsThirdPerson() )
{
int iAttachment = LookupAttachment( "anim_attachment_RH" );
if ( iAttachment < 0 )
return;
Vector vecOrigin;
//Tony; EyeAngles will return proper whether it's local player or not.
QAngle eyeAngles = EyeAngles();
GetAttachment( iAttachment, vecOrigin, eyeAngles );
Vector vForward;
AngleVectors( eyeAngles, &vForward );
trace_t tr;
UTIL_TraceLine( vecOrigin, vecOrigin + (vForward * 200), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
With this snippet:
else if( this != C_BasePlayer::GetLocalPlayer() || ::input->CAM_IsThirdPerson() )
{
C_BaseCombatWeapon *pWeap = GetActiveWeapon();
int iAttachment = pWeap ? pWeap->LookupAttachment( "muzzle" ) : LookupAttachment( "anim_attachment_RH" );
if ( iAttachment < 0 )
return;
Vector vecOrigin;
//Tony; EyeAngles will return proper whether it's local player or not.
QAngle eyeAngles = EyeAngles();
if ( pWeap )
{
if ( iAttachment < 1 )
vecOrigin = EyePosition() - Vector( 0, 0, 32 );
else
pWeap->GetAttachment( iAttachment, vecOrigin, eyeAngles );
}
else
GetAttachment( iAttachment, vecOrigin, eyeAngles );
Vector vForward;
AngleVectors( eyeAngles, &vForward );
trace_t tr;
UTIL_TraceLine( vecOrigin, vecOrigin + (vForward * 200), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
client.dll: flashlighteffect.cpp
HL2:MP SDK:
Add this include:
#include "iinput.h"
Find the function named:
void CFlashlightEffect::UpdateLightNew(const Vector &vecPos, const Vector &vecForward, const Vector &vecRight, const Vector &vecUp )
Now search for the line:
float flDist = (pmDirectionTrace.endpos - vOrigin).Length();
Replace the following block with this:
float flDist = (pmDirectionTrace.endpos - vOrigin).Length();
float flFov = r_flashlightfov.GetFloat();
if ( flDist < flDistCutoff )
{
// We have an intersection with our cutoff range
// Determine how far to pull back, then trace to see if we are clear
float flPullBackDist = bPlayerOnLadder ? r_flashlightladderdist.GetFloat() : flDistCutoff - flDist; // Fixed pull-back distance if on ladder
float flDistModTmp = Lerp( flDistDrag, m_flDistMod, flPullBackDist );
if ( !bPlayerOnLadder )
{
trace_t pmBackTrace;
UTIL_TraceHull( vOrigin, vOrigin - vDir*(flPullBackDist-flEpsilon), Vector( -4, -4, -4 ), Vector( 4, 4, 4 ), iMask, &traceFilter, &pmBackTrace );
if( pmBackTrace.DidHit() )
{
// We have an intersection behind us as well, so limit our m_flDistMod
float flMaxDist = (pmBackTrace.endpos - vOrigin).Length() - flEpsilon;
if( flDistModTmp > flMaxDist )
flDistModTmp = flMaxDist;
}
}
if ( ::input->CAM_IsThirdPerson() )
{
flFov += min( 100, (abs( flDistModTmp ) * 4) );
m_flDistMod = Lerp( flDistDrag, m_flDistMod, 0.0f );
}
else
m_flDistMod = flDistModTmp;
}
else
{
m_flDistMod = Lerp( flDistDrag, m_flDistMod, 0.0f );
}
vOrigin = vOrigin - vDir * m_flDistMod;
Replace this part:
if ( bFlicker == false )
{
state.m_fLinearAtten = r_flashlightlinear.GetFloat();
state.m_fHorizontalFOVDegrees = r_flashlightfov.GetFloat();
state.m_fVerticalFOVDegrees = r_flashlightfov.GetFloat();
}
with these lines:
if ( bFlicker == false )
{
state.m_fLinearAtten = r_flashlightlinear.GetFloat();
state.m_fHorizontalFOVDegrees = flFov;
state.m_fVerticalFOVDegrees = flFov;
}
client.dll: c_baseanimating.cpp
template SDK:
Muzzleflash particles are broken for thirdperson in the template mod; to disable them find this function:
void C_BaseAnimating::FireObsoleteEvent( const Vector& origin, const QAngle& angles, int event, const char *options )
Right after this snippet:
case CL_EVENT_MUZZLEFLASH0:
case CL_EVENT_MUZZLEFLASH1:
case CL_EVENT_MUZZLEFLASH2:
case CL_EVENT_MUZZLEFLASH3:
case CL_EVENT_NPC_MUZZLEFLASH0:
case CL_EVENT_NPC_MUZZLEFLASH1:
case CL_EVENT_NPC_MUZZLEFLASH2:
case CL_EVENT_NPC_MUZZLEFLASH3:
{
add these lines:
C_BaseEntity *follow = GetFollowedEntity();
if ( follow && follow->IsPlayer() && ::input->CAM_IsThirdPerson() )
break;
HL2:MP SDK:
Go to the function named:
void CallbackPhyscannonImpact( const CEffectData &data )
Search for these lines:
if ( pPlayer )
{
pEnt = pPlayer->GetViewModel();
}
// Format attachment for first-person view!
::FormatViewModelAttachment( vecAttachment, true );
Replace them with this snippet:
if ( pPlayer && !::input->CAM_IsThirdPerson() )
{
pEnt = pPlayer->GetViewModel();
// Format attachment for first-person view!
::FormatViewModelAttachment( vecAttachment, true );
}
client.dll: c_sprite.cpp
HL2:MP SDK:
Add this include:
#include "iinput.h"
Find this function:
int C_SpriteRenderer::DrawSprite(...)
Find the block that begins with if ( attachedto ) and replace it with this snippet:
if ( attachedto )
{
C_BaseEntity *ent = attachedto->GetBaseEntity();
if ( ent )
{
if ( ent->GetBaseAnimating() && ent->GetBaseAnimating()->IsViewModel() && ::input->CAM_IsThirdPerson() )
{
C_BaseViewModel *pVm = (C_BaseViewModel*)ent;
C_BasePlayer *pOwner = ( pVm->GetOwner() && pVm->GetOwner()->IsPlayer() ) ? (C_BasePlayer*)pVm->GetOwner() : NULL;
if ( pOwner && pOwner->GetActiveWeapon() )
return 0; //worldmodels don't have the same attachments, so just get out (crossbow)
}
// don't draw viewmodel effects in reflections
if ( CurrentViewID() == VIEW_REFLECTION )
{
int group = ent->GetRenderGroup();
if ( group == RENDER_GROUP_VIEW_MODEL_TRANSLUCENT || group == RENDER_GROUP_VIEW_MODEL_OPAQUE )
return 0;
}
QAngle temp;
ent->GetAttachment( attachmentindex, effect_origin, temp );
}
}
OPTIONAL: Adding free aim
The following code can be added to allow for toggleable free aiming. The mouse input will move the crosshair on the screen instead of rotating the view; moving the crosshair outside of a certain circular area will turn the view instead. The cvar cam_ots_freeaim_interval_enable will enable the use of an interval for view turning.
client.dll: iinput.h
Add these methods to the interface:
virtual bool CAM_IsFreeAiming() = 0;
virtual Vector2D CAM_GetFreeAimCursor() = 0;
virtual void CAM_UpdateAngleByFreeAiming( bool bUser = false ) = 0;
virtual void CAM_UpdateAngle180() = 0;
client.dll: input.h
Declare them in the implementation as public:
virtual bool CAM_IsFreeAiming();
virtual Vector2D CAM_GetFreeAimCursor();
virtual void CAM_UpdateAngleByFreeAiming( bool bUser );
virtual void CAM_UpdateAngle180();
Declare these members in a private block:
QAngle m_angViewAngle_Delta;
Vector2D m_vecFreeAimPos;
Vector2D m_vecFreeAimPos_Delta;
void TryCursorMove( QAngle& viewangles, CUserCmd *cmd, float x, float y );
client.dll: in_main.cpp
Add these lines near the top of the file:
static ConVar cam_ots_freeaim( "cam_ots_freeaim_enable", "1", FCVAR_ARCHIVE );
static ConVar cam_ots_freeaim_use_interval( "cam_ots_freeaim_interval_enable", "0", FCVAR_ARCHIVE ); // use an interval for view turning
static ConVar cam_ots_freeaim_movethreshold( "cam_ots_freeaim_move_threshold", "0.7", FCVAR_ARCHIVE );
static ConVar cam_ots_freeaim_movemax( "cam_ots_freeaim_move_max", "0.85", FCVAR_ARCHIVE );
static ConVar cam_ots_freeaim_speedturn( "cam_ots_freeaim_speed_turn", "1", FCVAR_ARCHIVE );
static ConVar cam_ots_freeaim_speed_evenyaw( "cam_ots_freeaim_speed_evenYawSpeed", "1", FCVAR_ARCHIVE );
static ConVar cam_ots_freeaim_autoturn_speed( "cam_ots_freeaim_autoturn_speed", "250", FCVAR_ARCHIVE );
extern void ScreenToWorld( int mousex, int mousey, float fov, const Vector& vecRenderOrigin, const QAngle& vecRenderAngles, Vector& vecPickingRay );
Add these ConCommands:
CON_COMMAND( cam_ots_TurnAuto, "" )
{
::input->CAM_UpdateAngleByFreeAiming(true);
}
CON_COMMAND( cam_ots_Turn180, "" )
{
::input->CAM_UpdateAngle180();
}
Find this function:
void CInput::Init_All (void)
Add these lines to the end:
m_vecFreeAimPos.Init();
m_vecFreeAimPos_Delta.Init();
m_angViewAngle_Delta.Init();
Define the methods above:
void CInput::CAM_UpdateAngle180()
{
m_angViewAngle_Delta.y = 180.0f;
if ( CAM_IsFreeAiming() )
m_angViewAngle_Delta.y *= -Sign( m_vecFreeAimPos.x );
}
bool CInput::CAM_IsFreeAiming()
{
C_BasePlayer *pl = C_BasePlayer::GetLocalPlayer();
return cam_ots_freeaim.GetBool() && pl && pl->AllowOvertheShoulderView();
}
Vector2D CInput::CAM_GetFreeAimCursor()
{
return m_vecFreeAimPos;
}
// Allows code to manipulate the view angles
void CInput::CAM_UpdateAngleByFreeAiming( bool bUser )
{
if ( prediction->InPrediction() && !prediction->IsFirstTimePredicted() )
return;
if ( !CAM_IsFreeAiming() )
return;
C_BasePlayer *pl = C_BasePlayer::GetLocalPlayer();
if ( !pl )
return;
Vector vecForward, vecForwardCam;
int screen_x, screen_y;
engine->GetScreenSize( screen_x, screen_y );
screen_x *= m_vecFreeAimPos.x * 0.5f + 0.5f;
screen_y *= m_vecFreeAimPos.y * 0.5f + 0.5f;
ScreenToWorld( screen_x, screen_y, pl->GetFOV(), MainViewOrigin(), MainViewAngles(), vecForward );
trace_t tr;
UTIL_TraceLine( MainViewOrigin(), MainViewOrigin() + vecForward * MAX_TRACE_LENGTH, MASK_SHOT, pl, COLLISION_GROUP_NONE, &tr );
Vector vecWorldTarget = tr.endpos;
Vector vecDir_PlayerViewTarget = vecWorldTarget - pl->EyePosition();
AngleVectors( m_angViewAngle, &vecForwardCam, 0, 0 );
Vector vecDir_PlayerCamPlane = MainViewOrigin() - pl->EyePosition();
float flPlaneFwdComponent = DotProduct( vecDir_PlayerCamPlane, vecForwardCam );
vecDir_PlayerCamPlane -= flPlaneFwdComponent * vecForwardCam;
const float lengthCamToImaginaryTarget = FastSqrt( vecDir_PlayerViewTarget.LengthSqr() - vecDir_PlayerCamPlane.LengthSqr() );
Vector vecDir_PlayerTmpViewTarget = vecDir_PlayerCamPlane + vecForwardCam * lengthCamToImaginaryTarget;
Vector vecDir_PlayerCamPlaneDst;
QAngle ang1, ang2, angDelta;
VectorAngles( vecDir_PlayerTmpViewTarget, ang1 );
VectorAngles( vecDir_PlayerViewTarget, ang2 );
RotationDelta( ang1, ang2, &angDelta );
VectorRotate( vecDir_PlayerCamPlane, angDelta, vecDir_PlayerCamPlaneDst );
Vector vecDstDirImaginaryTarget_NoOffset = vecWorldTarget - vecDir_PlayerCamPlaneDst;
vecDstDirImaginaryTarget_NoOffset -= pl->EyePosition();
if ( !bUser )
{
m_angViewAngle_Delta.Init();
m_vecFreeAimPos_Delta.Init();
QAngle tmp;
VectorAngles( vecDstDirImaginaryTarget_NoOffset, tmp );
if ( tmp.IsValid() )
{
m_angViewAngle = tmp;
if ( m_angViewAngle.x > 180.0f )
m_angViewAngle.x -= 360.0f;
else if ( m_angViewAngle.x < -180.0f )
m_angViewAngle.x += 360.0f;
m_vecFreeAimPos.Init();
}
}
else
{
QAngle angTarget;
VectorAngles( vecDstDirImaginaryTarget_NoOffset, angTarget );
for ( int i = 0; i < 2; i++ )
m_angViewAngle_Delta[i] = AngleDiff( angTarget[i], m_angViewAngle[i] );
m_angViewAngle_Delta.z = 0;
if ( m_angViewAngle_Delta.y > 180.0f )
m_angViewAngle_Delta.y = 180.0f;
else if ( m_angViewAngle_Delta.y < -180.0f )
m_angViewAngle_Delta.y = -180.0f;
if ( !m_angViewAngle_Delta.IsValid() )
m_angViewAngle_Delta.Init();
else
m_vecFreeAimPos_Delta = -m_vecFreeAimPos;
}
}
// Defines crosshair position and rotates the view if appropriate
void CInput::TryCursorMove( QAngle& viewangles, CUserCmd *cmd, float x, float y )
{
static ConVarRef m_yaw( "m_yaw" );
static ConVarRef m_pitch( "m_pitch" );
C_BasePlayer *pl = C_BasePlayer::GetLocalPlayer();
float flFOV = ( pl ? pl->GetFOV() : 1.0f );
float flScaleNormalizedRange_Yaw = m_yaw.GetFloat() / flFOV;
float flScaleNormalizedRange_Pitch = m_pitch.GetFloat() / flFOV;
float flScale_Pitch = 1;
if ( cam_ots_freeaim_speed_evenyaw.GetInt() )
flScale_Pitch = engine->GetScreenAspectRatio();
m_vecFreeAimPos += Vector2D( x * flScaleNormalizedRange_Yaw, y * flScale_Pitch * flScaleNormalizedRange_Pitch );
float flLength = m_vecFreeAimPos.NormalizeInPlace();
float flMoveVars[ 2 ] = { cam_ots_freeaim_movethreshold.GetFloat(), cam_ots_freeaim_movemax.GetFloat() };
float flTurnSpeed;
Vector2D moveDir = m_vecFreeAimPos;
moveDir.NormalizeInPlace();
if ( cam_ots_freeaim_use_interval.GetInt() )
{
flTurnSpeed = cam_ots_freeaim_speedturn.GetFloat() * max( 0, (
(flLength - flMoveVars[0]) / (flMoveVars[1] - flMoveVars[0])
) );
viewangles += QAngle( moveDir.y * flTurnSpeed, moveDir.x * -flTurnSpeed, 0 );
}
else
{
flTurnSpeed = max( 0, ( flLength - flMoveVars[ 1 ] ) );
viewangles += QAngle( moveDir.y * flTurnSpeed * flFOV, moveDir.x * -flTurnSpeed * flFOV, 0 );
}
if ( viewangles.x > 89.0f )
viewangles.x = 89.0f;
else if ( viewangles.x < -89.0f )
viewangles.x = -89.0f;
if ( viewangles.y > 180.0f )
viewangles.y -= 360.0f;
else if ( viewangles.y < -180.0f )
viewangles.y += 360.0f;
flLength = min( flMoveVars[1], flLength );
m_vecFreeAimPos *= flLength;
cmd->mousedx = (int)x;
cmd->mousedy = (int)y;
}
Change our previously defined function named:
void CInput::CalcPlayerAngle( CUserCmd *cmd )
to look like this:
void CInput::CalcPlayerAngle( CUserCmd *cmd )
{
C_BasePlayer *pl = C_BasePlayer::GetLocalPlayer();
if ( !pl || !pl->AllowOvertheShoulderView() )
{
engine->SetViewAngles( m_angViewAngle );
m_angViewAngle_Delta.Init();
return;
}
float deltaLen = m_angViewAngle_Delta.Length();
if ( deltaLen )
{
QAngle angDelta_New = m_angViewAngle_Delta;
for ( int i = 0; i < 2; i++ )
angDelta_New[i] = angDelta_New[i] - Approach( 0, angDelta_New[i],
gpGlobals->frametime * cam_ots_freeaim_autoturn_speed.GetFloat() * abs(m_angViewAngle_Delta[i]/deltaLen)
);
m_angViewAngle += angDelta_New;
m_angViewAngle_Delta -= angDelta_New;
}
float deltaCursor = m_vecFreeAimPos_Delta.Length();
if ( deltaCursor )
{
Vector2D vecAimPos_New = m_vecFreeAimPos_Delta;
for ( int i = 0; i < 2; i++ )
vecAimPos_New[i] = vecAimPos_New[i] - Approach( 0, vecAimPos_New[i],
gpGlobals->frametime * cam_ots_freeaim_autoturn_speed.GetFloat() *
abs(m_vecFreeAimPos_Delta[i]/deltaCursor) * (engine->GetScreenAspectRatio() / pl->GetFOV())
);
m_vecFreeAimPos += vecAimPos_New;
m_vecFreeAimPos_Delta -= vecAimPos_New;
}
trace_t tr;
const Vector eyePos = pl->EyePosition();
Vector vecForward = MainViewForward();
QAngle angCam = m_angViewAngle; //MainViewAngles();
if ( CAM_IsFreeAiming() )
{
int screen_x, screen_y;
engine->GetScreenSize( screen_x, screen_y );
screen_x *= m_vecFreeAimPos.x * 0.5f + 0.5f;
screen_y *= m_vecFreeAimPos.y * 0.5f + 0.5f;
ScreenToWorld( screen_x, screen_y, pl->GetFOV(), MainViewOrigin(), angCam, vecForward );
}
UTIL_TraceLine( MainViewOrigin(), MainViewOrigin() + vecForward * MAX_TRACE_LENGTH, MASK_SHOT, pl, COLLISION_GROUP_NONE, &tr );
// ensure that the player entity does not shoot towards the camera, get dist to plane where the player is on and add a constant
float flMinForward = abs( DotProduct( MainViewForward(), eyePos - MainViewOrigin() ) ) + 32.0f;
Vector vecTrace = tr.endpos - tr.startpos;
float flLenOld = vecTrace.NormalizeInPlace();
float flLen = max( flMinForward, flLenOld );
vecTrace *= flLen;
Vector vecFinalDir = MainViewOrigin() + vecTrace - eyePos; //eyePos;
QAngle playerangles;
VectorAngles( vecFinalDir, playerangles );
engine->SetViewAngles( playerangles );
playerangles.z = angCam.z = 0;
playerangles.x = angCam.x = 0;
Vector cFwd, cRight, pFwd, pRight;
AngleVectors( angCam, &cFwd, &cRight, NULL );
AngleVectors( playerangles, &pFwd, &pRight, NULL );
float flMove[2] = { cmd->forwardmove, cmd->sidemove };
cmd->forwardmove = DotProduct( cFwd, pFwd ) * flMove[ 0 ] + DotProduct( cRight, pFwd ) * flMove[ 1 ];
cmd->sidemove = DotProduct( cRight, pRight ) * flMove[ 1 ] + DotProduct( cFwd, pRight ) * flMove[ 0 ];
}
Find the function named:
void CInput::SetCamViewangles( QAngle const &view )
Add this line to the end:
m_vecFreeAimPos.Init();
client.dll: in_mouse.cpp
Go to
void CInput::MouseMove( CUserCmd *cmd )
Replace this line:
ApplyMouse( m_angViewAngle, cmd, mouse_x, mouse_y );
with these:
if ( CAM_IsFreeAiming() )
TryCursorMove( m_angViewAngle, cmd, mouse_x, mouse_y );
else
ApplyMouse( m_angViewAngle, cmd, mouse_x, mouse_y );
client.dll: hud_crosshair.cpp
This code actually moves the crosshair by the mouse input we evaluated in TryCursorMove().
Add this include:
#include "iinput.h"
Find the function named:
void CHudCrosshair::Paint( void )
Right after this snippet:
float x, y;
x = ScreenWidth()/2;
y = ScreenHeight()/2;
add these lines:
if ( ::input->CAM_IsFreeAiming() )
{
Vector2D vec_AimPos = ::input->CAM_GetFreeAimCursor();
x *= vec_AimPos.x + 1.0f;
y *= vec_AimPos.y + 1.0f;
}
client.dll: hud_quickinfo.cpp
HL2:MP SDK:
The following modifications ensure that the quickinfo icons move along with the crosshair.
Add this include:
#include "iinput.h"
Find this function:
void CHUDQuickInfo::Paint()
Search for these lines:
int xCenter = ( ScreenWidth() - m_icon_c->Width() ) / 2;
int yCenter = ( ScreenHeight() - m_icon_c->Height() ) / 2;
float scalar = 138.0f/255.0f;
Add this snippet below:
if ( ::input->CAM_IsFreeAiming() )
{
Vector2D vec_AimPos = ::input->CAM_GetFreeAimCursor();
xCenter = (ScreenWidth() / 2) * ( vec_AimPos.x + 1.0f );
xCenter -= m_icon_lb->Width() * 0.5f;
yCenter = (ScreenHeight() / 2) * ( vec_AimPos.y + 1.0f );
yCenter -= m_icon_lb->Height() * 0.5f;
}
Scroll down to these lines:
xCenter = ScreenWidth() / 2;
yCenter = ( ScreenHeight() - m_icon_lb->Height() ) / 2;
Add these below:
if ( ::input->CAM_IsFreeAiming() )
{
Vector2D vec_AimPos = ::input->CAM_GetFreeAimCursor();
xCenter *= ( vec_AimPos.x + 1.0f );
yCenter = (ScreenHeight() / 2) * ( vec_AimPos.y + 1.0f );
yCenter -= m_icon_lb->Height() * 0.5f;
}
HL2:MP SDK:
Reorient the aiming angle while using free aim and zooming; find the function named:
void CWeaponCrossbow::ToggleZoom( void )
Before #endif add this:
#else
::input->CAM_UpdateAngleByFreeAiming();