872 lines
19 KiB
C++
872 lines
19 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "hltvcamera.h"
|
|
#include "cdll_client_int.h"
|
|
#include "util_shared.h"
|
|
#include "prediction.h"
|
|
#include "movevars_shared.h"
|
|
#include "in_buttons.h"
|
|
#include "text_message.h"
|
|
#include "vgui_controls/Controls.h"
|
|
#include "vgui/ILocalize.h"
|
|
#include "vguicenterprint.h"
|
|
#include "game/client/iviewport.h"
|
|
#include <KeyValues.h>
|
|
|
|
#ifdef CSTRIKE_DLL
|
|
#include "c_cs_player.h"
|
|
#endif
|
|
|
|
ConVar spec_autodirector( "spec_autodirector", "1", FCVAR_CLIENTDLL | FCVAR_CLIENTCMD_CAN_EXECUTE, "Auto-director chooses best view modes while spectating" );
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
#define CHASE_CAM_DISTANCE 96.0f
|
|
#define WALL_OFFSET 6.0f
|
|
|
|
static Vector WALL_MIN(-WALL_OFFSET,-WALL_OFFSET,-WALL_OFFSET);
|
|
static Vector WALL_MAX(WALL_OFFSET,WALL_OFFSET,WALL_OFFSET);
|
|
static const ConVar *tv_transmitall = NULL;
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Construction/Destruction
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
// converts all '\r' characters to '\n', so that the engine can deal with the properly
|
|
// returns a pointer to str
|
|
static wchar_t* ConvertCRtoNL( wchar_t *str )
|
|
{
|
|
for ( wchar_t *ch = str; *ch != 0; ch++ )
|
|
if ( *ch == L'\r' )
|
|
*ch = L'\n';
|
|
return str;
|
|
}
|
|
|
|
static C_HLTVCamera s_HLTVCamera;
|
|
|
|
C_HLTVCamera *HLTVCamera() { return &s_HLTVCamera; }
|
|
|
|
C_HLTVCamera::C_HLTVCamera()
|
|
{
|
|
Reset();
|
|
|
|
m_nNumSpectators = 0;
|
|
m_szTitleText[0] = 0;
|
|
}
|
|
|
|
C_HLTVCamera::~C_HLTVCamera()
|
|
{
|
|
|
|
}
|
|
|
|
void C_HLTVCamera::Init()
|
|
{
|
|
ListenForGameEvent( "game_newmap" );
|
|
ListenForGameEvent( "hltv_cameraman" );
|
|
ListenForGameEvent( "hltv_fixed" );
|
|
ListenForGameEvent( "hltv_chase" );
|
|
ListenForGameEvent( "hltv_message" );
|
|
ListenForGameEvent( "hltv_title" );
|
|
ListenForGameEvent( "hltv_status" );
|
|
|
|
Reset();
|
|
|
|
m_nNumSpectators = 0;
|
|
m_szTitleText[0] = 0;
|
|
|
|
// get a handle to the engine convar
|
|
tv_transmitall = cvar->FindVar( "tv_transmitall" );
|
|
}
|
|
|
|
void C_HLTVCamera::Reset()
|
|
{
|
|
m_nCameraMode = OBS_MODE_FIXED;
|
|
m_iCameraMan = 0;
|
|
m_iTraget1 = m_iTraget2 = 0;
|
|
m_flFOV = 90;
|
|
m_flDistance = m_flLastDistance = 96.0f;
|
|
m_flInertia = 3.0f;
|
|
m_flPhi = 0;
|
|
m_flTheta = 0;
|
|
m_flOffset = 0;
|
|
m_bEntityPacketReceived = false;
|
|
|
|
m_vCamOrigin.Init();
|
|
m_aCamAngle.Init();
|
|
|
|
m_LastCmd.Reset();
|
|
m_vecVelocity.Init();
|
|
}
|
|
|
|
void C_HLTVCamera::CalcChaseCamView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov )
|
|
{
|
|
bool bManual = !spec_autodirector.GetBool(); // chase camera controlled manually
|
|
|
|
Vector targetOrigin1, targetOrigin2, cameraOrigin, forward;
|
|
|
|
if ( m_iTraget1 == 0 )
|
|
return;
|
|
|
|
// get primary target, also translates to ragdoll
|
|
C_BaseEntity *target1 = GetPrimaryTarget();
|
|
|
|
if ( !target1 )
|
|
return;
|
|
|
|
if ( target1->IsAlive() && target1->IsDormant() )
|
|
return;
|
|
|
|
targetOrigin1 = target1->GetRenderOrigin();
|
|
|
|
if ( !target1->IsAlive() )
|
|
{
|
|
targetOrigin1 += VEC_DEAD_VIEWHEIGHT;
|
|
}
|
|
else if ( target1->GetFlags() & FL_DUCKING )
|
|
{
|
|
targetOrigin1 += VEC_DUCK_VIEW;
|
|
}
|
|
else
|
|
{
|
|
targetOrigin1 += VEC_VIEW;
|
|
}
|
|
|
|
// get secondary target if set
|
|
C_BaseEntity *target2 = NULL;
|
|
|
|
if ( m_iTraget2 > 0 && (m_iTraget2 != m_iTraget1) && !bManual )
|
|
{
|
|
target2 = ClientEntityList().GetBaseEntity( m_iTraget2 );
|
|
|
|
// if target is out PVS and not dead, it's not valid
|
|
if ( target2 && target2->IsDormant() && target2->IsAlive() )
|
|
target2 = NULL;
|
|
|
|
if ( target2 )
|
|
{
|
|
targetOrigin2 = target2->GetRenderOrigin();
|
|
|
|
if ( !target2->IsAlive() )
|
|
{
|
|
targetOrigin2 += VEC_DEAD_VIEWHEIGHT;
|
|
}
|
|
else if ( target2->GetFlags() & FL_DUCKING )
|
|
{
|
|
targetOrigin2 += VEC_DUCK_VIEW;
|
|
}
|
|
else
|
|
{
|
|
targetOrigin2 += VEC_VIEW;
|
|
}
|
|
}
|
|
}
|
|
|
|
// apply angle offset & smoothing
|
|
QAngle angleOffset( m_flPhi, m_flTheta, 0 );
|
|
QAngle cameraAngles = m_aCamAngle;
|
|
|
|
if ( bManual )
|
|
{
|
|
// let spectator choose the view angles
|
|
engine->GetViewAngles( cameraAngles );
|
|
}
|
|
else if ( target2 )
|
|
{
|
|
// look into direction of second target
|
|
forward = targetOrigin2 - targetOrigin1;
|
|
VectorAngles( forward, cameraAngles );
|
|
cameraAngles.z = 0; // no ROLL
|
|
}
|
|
else if ( m_iTraget2 == 0 || m_iTraget2 == m_iTraget1)
|
|
{
|
|
// look into direction where primary target is looking
|
|
cameraAngles = target1->EyeAngles();
|
|
cameraAngles.x = 0; // no PITCH
|
|
cameraAngles.z = 0; // no ROLL
|
|
}
|
|
else
|
|
{
|
|
// target2 is missing, just keep angelsm, reset offset
|
|
angleOffset.Init();
|
|
}
|
|
|
|
if ( !bManual )
|
|
{
|
|
if ( !target1->IsAlive() )
|
|
{
|
|
angleOffset.x = 15;
|
|
}
|
|
|
|
cameraAngles += angleOffset;
|
|
}
|
|
|
|
AngleVectors( cameraAngles, &forward );
|
|
|
|
VectorNormalize( forward );
|
|
|
|
// calc optimal camera position
|
|
VectorMA(targetOrigin1, -m_flDistance, forward, cameraOrigin );
|
|
|
|
targetOrigin1.z += m_flOffset; // add offset
|
|
|
|
// clip against walls
|
|
trace_t trace;
|
|
C_BaseEntity::PushEnableAbsRecomputations( false ); // HACK don't recompute positions while doing RayTrace
|
|
UTIL_TraceHull( targetOrigin1, cameraOrigin, WALL_MIN, WALL_MAX, MASK_SOLID, target1, COLLISION_GROUP_NONE, &trace );
|
|
C_BaseEntity::PopEnableAbsRecomputations();
|
|
|
|
float dist = VectorLength( trace.endpos - targetOrigin1 );
|
|
|
|
// grow distance by 32 unit a second
|
|
m_flLastDistance += gpGlobals->frametime * 32.0f;
|
|
|
|
if ( dist > m_flLastDistance )
|
|
{
|
|
VectorMA(targetOrigin1, -m_flLastDistance, forward, cameraOrigin );
|
|
}
|
|
else
|
|
{
|
|
cameraOrigin = trace.endpos;
|
|
m_flLastDistance = dist;
|
|
}
|
|
|
|
if ( target2 )
|
|
{
|
|
// if we have 2 targets look at point between them
|
|
forward = (targetOrigin1+targetOrigin2)/2 - cameraOrigin;
|
|
QAngle angle;
|
|
VectorAngles( forward, angle );
|
|
cameraAngles.y = angle.y;
|
|
|
|
NormalizeAngles( cameraAngles );
|
|
cameraAngles.x = clamp( cameraAngles.x, -60.f, 60.f );
|
|
|
|
SmoothCameraAngle( cameraAngles );
|
|
}
|
|
else
|
|
{
|
|
SetCameraAngle( cameraAngles );
|
|
}
|
|
|
|
VectorCopy( cameraOrigin, m_vCamOrigin );
|
|
VectorCopy( m_aCamAngle, eyeAngles );
|
|
VectorCopy( m_vCamOrigin, eyeOrigin );
|
|
}
|
|
|
|
int C_HLTVCamera::GetMode()
|
|
{
|
|
if ( m_iCameraMan > 0 )
|
|
{
|
|
C_BasePlayer *pCameraMan = UTIL_PlayerByIndex( m_iCameraMan );
|
|
|
|
if ( pCameraMan )
|
|
return pCameraMan->GetObserverMode();
|
|
}
|
|
|
|
return m_nCameraMode;
|
|
}
|
|
|
|
C_BaseEntity* C_HLTVCamera::GetPrimaryTarget()
|
|
{
|
|
if ( m_iCameraMan > 0 )
|
|
{
|
|
C_BasePlayer *pCameraMan = UTIL_PlayerByIndex( m_iCameraMan );
|
|
|
|
if ( pCameraMan )
|
|
{
|
|
return pCameraMan->GetObserverTarget();
|
|
}
|
|
}
|
|
|
|
if ( m_iTraget1 <= 0 )
|
|
return NULL;
|
|
|
|
C_BaseEntity* target = ClientEntityList().GetEnt( m_iTraget1 );
|
|
|
|
return target;
|
|
}
|
|
|
|
C_BaseEntity *C_HLTVCamera::GetCameraMan()
|
|
{
|
|
return ClientEntityList().GetEnt( m_iCameraMan );
|
|
}
|
|
|
|
void C_HLTVCamera::CalcInEyeCamView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov )
|
|
{
|
|
C_BasePlayer *pPlayer = UTIL_PlayerByIndex( m_iTraget1 );
|
|
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
if ( !pPlayer->IsAlive() )
|
|
{
|
|
// if dead, show from 3rd person
|
|
CalcChaseCamView( eyeOrigin, eyeAngles, fov );
|
|
return;
|
|
}
|
|
|
|
m_aCamAngle = pPlayer->EyeAngles();
|
|
m_vCamOrigin = pPlayer->GetAbsOrigin();
|
|
m_flFOV = pPlayer->GetFOV();
|
|
|
|
if ( pPlayer->GetFlags() & FL_DUCKING )
|
|
{
|
|
m_vCamOrigin += VEC_DUCK_VIEW;
|
|
}
|
|
else
|
|
{
|
|
m_vCamOrigin += VEC_VIEW;
|
|
}
|
|
|
|
eyeOrigin = m_vCamOrigin;
|
|
eyeAngles = m_aCamAngle;
|
|
fov = m_flFOV;
|
|
|
|
pPlayer->CalcViewModelView( eyeOrigin, eyeAngles);
|
|
|
|
C_BaseViewModel *pViewModel = pPlayer->GetViewModel( 0 );
|
|
|
|
if ( pViewModel )
|
|
{
|
|
Assert( pViewModel->GetOwner() == pPlayer );
|
|
pViewModel->UpdateVisibility();
|
|
}
|
|
}
|
|
|
|
void C_HLTVCamera::Accelerate( Vector& wishdir, float wishspeed, float accel )
|
|
{
|
|
float addspeed, accelspeed, currentspeed;
|
|
|
|
// See if we are changing direction a bit
|
|
currentspeed =m_vecVelocity.Dot(wishdir);
|
|
|
|
// Reduce wishspeed by the amount of veer.
|
|
addspeed = wishspeed - currentspeed;
|
|
|
|
// If not going to add any speed, done.
|
|
if (addspeed <= 0)
|
|
return;
|
|
|
|
// Determine amount of acceleration.
|
|
accelspeed = accel * gpGlobals->frametime * wishspeed;
|
|
|
|
// Cap at addspeed
|
|
if (accelspeed > addspeed)
|
|
accelspeed = addspeed;
|
|
|
|
// Adjust velocity.
|
|
for (int i=0 ; i<3 ; i++)
|
|
{
|
|
m_vecVelocity[i] += accelspeed * wishdir[i];
|
|
}
|
|
}
|
|
|
|
|
|
// movement code is a copy of CGameMovement::FullNoClipMove()
|
|
void C_HLTVCamera::CalcRoamingView(Vector& eyeOrigin, QAngle& eyeAngles, float& fov)
|
|
{
|
|
// only if PVS isn't locked by auto-director
|
|
if ( !IsPVSLocked() )
|
|
{
|
|
|
|
Vector wishvel;
|
|
Vector forward, right, up;
|
|
Vector wishdir;
|
|
float wishspeed;
|
|
float factor = sv_specspeed.GetFloat();
|
|
float maxspeed = sv_maxspeed.GetFloat() * factor;
|
|
|
|
AngleVectors ( m_LastCmd.viewangles, &forward, &right, &up); // Determine movement angles
|
|
|
|
if ( m_LastCmd.buttons & IN_SPEED )
|
|
{
|
|
factor /= 2.0f;
|
|
}
|
|
|
|
// Copy movement amounts
|
|
float fmove = m_LastCmd.forwardmove * factor;
|
|
float smove = m_LastCmd.sidemove * factor;
|
|
|
|
VectorNormalize (forward); // Normalize remainder of vectors
|
|
VectorNormalize (right); //
|
|
|
|
for (int i=0 ; i<3 ; i++) // Determine x and y parts of velocity
|
|
wishvel[i] = forward[i]*fmove + right[i]*smove;
|
|
wishvel[2] += m_LastCmd.upmove * factor;
|
|
|
|
VectorCopy (wishvel, wishdir); // Determine magnitude of speed of move
|
|
wishspeed = VectorNormalize(wishdir);
|
|
|
|
//
|
|
// Clamp to server defined max speed
|
|
//
|
|
if (wishspeed > maxspeed )
|
|
{
|
|
VectorScale (wishvel, maxspeed/wishspeed, wishvel);
|
|
wishspeed = maxspeed;
|
|
}
|
|
|
|
if ( sv_specaccelerate.GetFloat() > 0.0 )
|
|
{
|
|
// Set move velocity
|
|
Accelerate ( wishdir, wishspeed, sv_specaccelerate.GetFloat() );
|
|
|
|
float spd = VectorLength( m_vecVelocity );
|
|
if (spd < 1.0f)
|
|
{
|
|
m_vecVelocity.Init();
|
|
}
|
|
else
|
|
{
|
|
// Bleed off some speed, but if we have less than the bleed
|
|
// threshold, bleed the threshold amount.
|
|
float control = (spd < maxspeed/4.0) ? maxspeed/4.0 : spd;
|
|
|
|
float friction = sv_friction.GetFloat();
|
|
|
|
// Add the amount to the drop amount.
|
|
float drop = control * friction * gpGlobals->frametime;
|
|
|
|
// scale the velocity
|
|
float newspeed = spd - drop;
|
|
if (newspeed < 0)
|
|
newspeed = 0;
|
|
|
|
// Determine proportion of old speed we are using.
|
|
newspeed /= spd;
|
|
VectorScale( m_vecVelocity, newspeed, m_vecVelocity );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
VectorCopy( wishvel, m_vecVelocity );
|
|
}
|
|
|
|
// Just move ( don't clip or anything )
|
|
VectorMA( m_vCamOrigin, gpGlobals->frametime, m_vecVelocity, m_vCamOrigin );
|
|
|
|
// get camera angle directly from engine
|
|
engine->GetViewAngles( m_aCamAngle );
|
|
|
|
// Zero out velocity if in noaccel mode
|
|
if ( sv_specaccelerate.GetFloat() < 0.0f )
|
|
{
|
|
m_vecVelocity.Init();
|
|
}
|
|
}
|
|
|
|
eyeOrigin = m_vCamOrigin;
|
|
eyeAngles = m_aCamAngle;
|
|
fov = m_flFOV;
|
|
}
|
|
|
|
void C_HLTVCamera::CalcFixedView(Vector& eyeOrigin, QAngle& eyeAngles, float& fov)
|
|
{
|
|
eyeOrigin = m_vCamOrigin;
|
|
eyeAngles = m_aCamAngle;
|
|
fov = m_flFOV;
|
|
|
|
if ( m_iTraget1 == 0 )
|
|
return;
|
|
|
|
C_BaseEntity * target = ClientEntityList().GetBaseEntity( m_iTraget1 );
|
|
|
|
if ( target && target->IsAlive() )
|
|
{
|
|
// if we're chasing a target, change viewangles
|
|
QAngle angle;
|
|
VectorAngles( (target->GetAbsOrigin()+VEC_VIEW) - m_vCamOrigin, angle );
|
|
SmoothCameraAngle( angle );
|
|
}
|
|
}
|
|
|
|
void C_HLTVCamera::PostEntityPacketReceived()
|
|
{
|
|
m_bEntityPacketReceived = true;
|
|
}
|
|
|
|
void C_HLTVCamera::FixupMovmentParents()
|
|
{
|
|
// Find resource zone
|
|
|
|
for ( ClientEntityHandle_t e = ClientEntityList().FirstHandle();
|
|
e != ClientEntityList().InvalidHandle(); e = ClientEntityList().NextHandle( e ) )
|
|
{
|
|
C_BaseEntity *ent = C_BaseEntity::Instance( e );
|
|
|
|
if ( !ent )
|
|
continue;
|
|
|
|
ent->HierarchyUpdateMoveParent();
|
|
}
|
|
}
|
|
|
|
void C_HLTVCamera::CalcView(Vector& origin, QAngle& angles, float& fov)
|
|
{
|
|
if ( m_bEntityPacketReceived )
|
|
{
|
|
// try to fixup movment pareents
|
|
FixupMovmentParents();
|
|
m_bEntityPacketReceived = false;
|
|
}
|
|
|
|
if ( m_iCameraMan > 0 )
|
|
{
|
|
C_BasePlayer *pCameraMan = UTIL_PlayerByIndex( m_iCameraMan );
|
|
if ( pCameraMan )
|
|
{
|
|
float zNear,zFar;
|
|
pCameraMan->CalcView( origin, angles, zNear, zFar, fov );
|
|
pCameraMan->CalcViewModelView( origin, angles );
|
|
return;
|
|
}
|
|
}
|
|
|
|
switch ( m_nCameraMode )
|
|
{
|
|
case OBS_MODE_ROAMING : CalcRoamingView( origin, angles, fov );
|
|
break;
|
|
|
|
case OBS_MODE_FIXED : CalcFixedView( origin, angles, fov );
|
|
break;
|
|
|
|
case OBS_MODE_IN_EYE : CalcInEyeCamView( origin, angles, fov );
|
|
break;
|
|
|
|
case OBS_MODE_CHASE : CalcChaseCamView( origin, angles, fov );
|
|
break;
|
|
}
|
|
}
|
|
|
|
void C_HLTVCamera::SetMode(int iMode)
|
|
{
|
|
if ( m_nCameraMode == iMode )
|
|
return;
|
|
|
|
Assert( iMode > OBS_MODE_NONE && iMode <= LAST_PLAYER_OBSERVERMODE );
|
|
|
|
int iOldMode = m_nCameraMode;
|
|
m_nCameraMode = iMode;
|
|
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "hltv_changed_mode" );
|
|
if ( event )
|
|
{
|
|
event->SetInt( "oldmode", iOldMode );
|
|
event->SetInt( "newmode", m_nCameraMode );
|
|
event->SetInt( "obs_target", m_iTraget1 );
|
|
gameeventmanager->FireEventClientSide( event );
|
|
}
|
|
}
|
|
|
|
void C_HLTVCamera::SetPrimaryTarget( int nEntity )
|
|
{
|
|
if ( m_iTraget1 == nEntity )
|
|
return;
|
|
|
|
int iOldTarget = m_iTraget1;
|
|
m_iTraget1 = nEntity;
|
|
|
|
if ( GetMode() == OBS_MODE_ROAMING )
|
|
{
|
|
Vector vOrigin;
|
|
QAngle aAngles;
|
|
float flFov;
|
|
|
|
CalcChaseCamView( vOrigin, aAngles, flFov );
|
|
}
|
|
else if ( GetMode() == OBS_MODE_CHASE )
|
|
{
|
|
C_BaseEntity* target = ClientEntityList().GetEnt( m_iTraget1 );
|
|
if ( target )
|
|
{
|
|
QAngle eyeAngle = target->EyeAngles();
|
|
prediction->SetViewAngles( eyeAngle );
|
|
}
|
|
}
|
|
|
|
m_flLastDistance = m_flDistance;
|
|
m_flLastAngleUpdateTime = -1;
|
|
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "hltv_changed_target" );
|
|
if ( event )
|
|
{
|
|
event->SetInt( "mode", m_nCameraMode );
|
|
event->SetInt( "old_target", iOldTarget );
|
|
event->SetInt( "obs_target", m_iTraget1 );
|
|
gameeventmanager->FireEventClientSide( event );
|
|
}
|
|
}
|
|
|
|
void C_HLTVCamera::SpecNextPlayer( bool bInverse )
|
|
{
|
|
int start = 1;
|
|
|
|
if ( m_iTraget1 > 0 && m_iTraget1 <= gpGlobals->maxClients )
|
|
start = m_iTraget1;
|
|
|
|
int index = start;
|
|
|
|
while ( true )
|
|
{
|
|
// got next/prev player
|
|
if ( bInverse )
|
|
index--;
|
|
else
|
|
index++;
|
|
|
|
// check bounds
|
|
if ( index < 1 )
|
|
index = gpGlobals->maxClients;
|
|
else if ( index > gpGlobals->maxClients )
|
|
index = 1;
|
|
|
|
if ( index == start )
|
|
break; // couldn't find a new valid player
|
|
|
|
C_BasePlayer *pPlayer = UTIL_PlayerByIndex( index );
|
|
|
|
if ( !pPlayer )
|
|
continue;
|
|
|
|
// only follow living players
|
|
if ( pPlayer->IsObserver() )
|
|
continue;
|
|
|
|
break; // found a new player
|
|
}
|
|
|
|
SetPrimaryTarget( index );
|
|
|
|
// turn off auto director once user tried to change view settings
|
|
SetAutoDirector( false );
|
|
}
|
|
|
|
void C_HLTVCamera::SpecPlayerByPredicate( const char *szSearch )
|
|
{
|
|
C_BasePlayer *pPlayer = UTIL_PlayerByCommandArg( szSearch );
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
// only follow living players or dedicated spectators
|
|
if ( pPlayer->IsObserver() && pPlayer->GetTeamNumber() != TEAM_SPECTATOR )
|
|
return;
|
|
|
|
SetPrimaryTarget( pPlayer->entindex() );
|
|
return;
|
|
}
|
|
|
|
void C_HLTVCamera::FireGameEvent( IGameEvent * event)
|
|
{
|
|
if ( !engine->IsHLTV() )
|
|
return; // not in HLTV mode
|
|
|
|
const char *type = event->GetName();
|
|
|
|
if ( Q_strcmp( "game_newmap", type ) == 0 )
|
|
{
|
|
Reset(); // reset all camera settings
|
|
|
|
// show spectator UI
|
|
if ( !gViewPortInterface )
|
|
return;
|
|
|
|
if ( engine->IsPlayingDemo() )
|
|
{
|
|
// for demo playback show full menu
|
|
gViewPortInterface->ShowPanel( PANEL_SPECMENU, true );
|
|
|
|
SetMode( OBS_MODE_ROAMING );
|
|
}
|
|
else
|
|
{
|
|
// during live broadcast only show black bars
|
|
gViewPortInterface->ShowPanel( PANEL_SPECGUI, true );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if ( Q_strcmp( "hltv_message", type ) == 0 )
|
|
{
|
|
wchar_t outputBuf[1024];
|
|
const char *pszText = event->GetString( "text", "" );
|
|
|
|
char *tmpStr = hudtextmessage->LookupString( pszText );
|
|
const wchar_t *pBuf = g_pVGuiLocalize->Find( tmpStr );
|
|
if ( pBuf )
|
|
{
|
|
// Copy pBuf into szBuf[i].
|
|
int nMaxChars = sizeof( outputBuf ) / sizeof( wchar_t );
|
|
wcsncpy( outputBuf, pBuf, nMaxChars );
|
|
outputBuf[nMaxChars-1] = 0;
|
|
}
|
|
else
|
|
{
|
|
g_pVGuiLocalize->ConvertANSIToUnicode( tmpStr, outputBuf, sizeof(outputBuf) );
|
|
}
|
|
|
|
internalCenterPrint->Print( ConvertCRtoNL( outputBuf ) );
|
|
return ;
|
|
}
|
|
|
|
if ( Q_strcmp( "hltv_title", type ) == 0 )
|
|
{
|
|
Q_strncpy( m_szTitleText, event->GetString( "text", "" ), sizeof(m_szTitleText) );
|
|
return;
|
|
}
|
|
|
|
if ( Q_strcmp( "hltv_status", type ) == 0 )
|
|
{
|
|
int nNumProxies = event->GetInt( "proxies" );
|
|
m_nNumSpectators = event->GetInt( "clients" ) - nNumProxies;
|
|
return;
|
|
}
|
|
|
|
// after this only auto-director commands follow
|
|
// don't execute them if autodirector is off and PVS is unlocked
|
|
if ( !spec_autodirector.GetBool() && !IsPVSLocked() )
|
|
return;
|
|
|
|
if ( Q_strcmp( "hltv_cameraman", type ) == 0 )
|
|
{
|
|
Reset();
|
|
|
|
m_nCameraMode = OBS_MODE_ROAMING;
|
|
m_iCameraMan = event->GetInt( "index" );
|
|
|
|
return;
|
|
}
|
|
|
|
if ( Q_strcmp( "hltv_fixed", type ) == 0 )
|
|
{
|
|
m_iCameraMan = 0;
|
|
|
|
m_vCamOrigin.x = event->GetInt( "posx" );
|
|
m_vCamOrigin.y = event->GetInt( "posy" );
|
|
m_vCamOrigin.z = event->GetInt( "posz" );
|
|
|
|
QAngle angle;
|
|
angle.x = event->GetInt( "theta" );
|
|
angle.y = event->GetInt( "phi" );
|
|
angle.z = 0; // no roll yet
|
|
|
|
if ( m_nCameraMode != OBS_MODE_FIXED )
|
|
{
|
|
SetMode( OBS_MODE_FIXED );
|
|
SetCameraAngle( angle );
|
|
m_flFOV = event->GetFloat( "fov", 90 );
|
|
}
|
|
|
|
SetPrimaryTarget( event->GetInt( "target" ) );
|
|
|
|
if ( m_iTraget1 == 0 )
|
|
{
|
|
SetCameraAngle( angle );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if ( Q_strcmp( "hltv_chase", type ) == 0 )
|
|
{
|
|
bool bInEye = event->GetInt( "ineye" );
|
|
|
|
// check if we are already in a player chase mode
|
|
bool bIsInChaseMode = (m_nCameraMode==OBS_MODE_IN_EYE)|| (m_nCameraMode==OBS_MODE_CHASE);
|
|
|
|
// if we are in auto director or not in a valid chase mode, set new mode now
|
|
if ( spec_autodirector.GetBool() || !bIsInChaseMode )
|
|
{
|
|
SetMode( bInEye?OBS_MODE_IN_EYE:OBS_MODE_CHASE );
|
|
}
|
|
|
|
m_iCameraMan = 0;
|
|
|
|
m_iTraget2 = event->GetInt( "target2" );
|
|
m_flDistance = event->GetFloat( "distance", m_flDistance );
|
|
m_flOffset = event->GetFloat( "offset", m_flOffset );
|
|
m_flTheta = event->GetFloat( "theta", m_flTheta );
|
|
m_flPhi = event->GetFloat( "phi", m_flPhi );
|
|
m_flFOV = event->GetFloat( "fov", 90 );
|
|
m_flInertia = event->GetFloat( "inertia", 30.f ) / 10.f;
|
|
|
|
// if inertia is not set use standard value
|
|
if ( m_flInertia <= 0 )
|
|
m_flInertia = 3.0f;
|
|
|
|
SetPrimaryTarget( event->GetInt( "target1" ) );
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
// this is a cheap version of FullNoClipMove():
|
|
void C_HLTVCamera::CreateMove( CUserCmd *cmd)
|
|
{
|
|
if ( cmd )
|
|
{
|
|
m_LastCmd = *cmd;
|
|
}
|
|
}
|
|
|
|
void C_HLTVCamera::SetCameraAngle( QAngle& targetAngle )
|
|
{
|
|
m_aCamAngle = targetAngle;
|
|
NormalizeAngles( m_aCamAngle );
|
|
m_flLastAngleUpdateTime = gpGlobals->realtime;
|
|
}
|
|
|
|
void C_HLTVCamera::SmoothCameraAngle( QAngle& targetAngle )
|
|
{
|
|
if ( m_flLastAngleUpdateTime > 0 )
|
|
{
|
|
float deltaTime = gpGlobals->realtime - m_flLastAngleUpdateTime;
|
|
|
|
deltaTime = clamp( deltaTime*m_flInertia, 0.01f, 1.f);
|
|
|
|
InterpolateAngles( m_aCamAngle, targetAngle, m_aCamAngle, deltaTime );
|
|
}
|
|
else
|
|
{
|
|
m_aCamAngle = targetAngle;
|
|
}
|
|
|
|
m_flLastAngleUpdateTime = gpGlobals->realtime;
|
|
}
|
|
|
|
void C_HLTVCamera::ToggleChaseAsFirstPerson()
|
|
{
|
|
if ( GetMode() == OBS_MODE_CHASE )
|
|
{
|
|
SetMode( OBS_MODE_IN_EYE );
|
|
}
|
|
else if ( GetMode() == OBS_MODE_IN_EYE )
|
|
{
|
|
SetMode( OBS_MODE_CHASE );
|
|
}
|
|
}
|
|
|
|
bool C_HLTVCamera::IsPVSLocked()
|
|
{
|
|
if ( tv_transmitall != NULL )
|
|
{
|
|
return !tv_transmitall->GetBool();
|
|
}
|
|
else
|
|
{
|
|
//old style, assume locked unless we playback a demo
|
|
return !engine->IsPlayingDemo();
|
|
}
|
|
}
|
|
|
|
void C_HLTVCamera::SetAutoDirector( bool bActive )
|
|
{
|
|
spec_autodirector.SetValue( bActive?1:0 );
|
|
}
|