/*
================
AdjustAngles
Moves the local angle positions
================
*/
void CInput::AdjustAngles ( float frametime )
{
float speed;
QAngle viewangles;
// Determine control scaling factor ( multiplies time )
speed = DetermineKeySpeed( frametime );
if ( speed <= 0.0f )
{
return;
}
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if (pPlayer && (pPlayer->GetFlags() & (FL_FREECAM | FL_REMOTECONTROLLED) || pPlayer->m_nButtons & IN_WALK))
return;
// Retrieve latest view direction from engine
engine->GetViewAngles( viewangles );
// Adjust YAW
AdjustYaw( speed, viewangles );
// Adjust PITCH if keyboard looking
AdjustPitch( speed, viewangles );
// Make sure values are legitimate
ClampAngles( viewangles );
// Store new view angles into engine view direction
engine->SetViewAngles( viewangles );
}
/*
================
AdjustAngles
Moves the local angle positions
================
*/
void CInput::AdjustAngles ( float frametime )
{
float speed;
QAngle viewangles;
// Determine control scaling factor ( multiplies time )
speed = DetermineKeySpeed( frametime );
if ( speed <= 0.0f )
{
return;
}
// Retrieve latest view direction from engine
engine->GetViewAngles( viewangles );
// Adjust YAW
AdjustYaw( speed, viewangles );
// Adjust PITCH if keyboard looking
AdjustPitch( speed, viewangles );
// Make sure values are legitimate
ClampAngles( viewangles );
// Store new view angles into engine view direction
engine->SetViewAngles( viewangles );
}
void CPlayerRotation::Process()
{
//FUNCTION_PROFILER(GetISystem(), PROFILE_GAME);
//
float forceLookLen2(m_player.m_stats.forceLookVector.len2());
if (forceLookLen2>0.001f && !g_vr->initialized()) // no forced look in VR please
{
float forceLookLen(cry_sqrtf(forceLookLen2));
Vec3 forceLook(m_player.m_stats.forceLookVector);
forceLook *= 1.0f/forceLookLen;
forceLook = m_player.m_viewQuatFinal.GetInverted() * forceLook;
float smoothSpeed(6.6f * forceLookLen);
m_deltaAngles.x += asin(forceLook.z) * min(1.0f,m_frameTime*smoothSpeed);
m_deltaAngles.z += cry_atan2f(-forceLook.x,forceLook.y) * min(1.0f,m_frameTime*smoothSpeed);
CHECKQNAN_VEC(m_deltaAngles);
}
ProcessAngularImpulses();
ProcessLean();
if (m_stats.inAir && m_stats.inZeroG)
ProcessFlyingZeroG();
else if (m_stats.inFreefall.Value()==1)
ProcessFreeFall();
else if (m_stats.inFreefall.Value()==2)
ProcessParachute();
else
{
if(!g_vr->initialized())
{
ProcessNormalRoll();
ClampAngles();
}
ProcessNormal();
}
//CHECKQNAN_MAT33(m_viewMtx);
//update freelook when linked to an entity
SLinkStats *pLinkStats = &m_player.m_linkStats;
if (pLinkStats->linkID)
{
IEntity *pLinked = pLinkStats->GetLinked();
if (pLinked)
{
//at this point m_baseQuat and m_viewQuat contain the previous frame rotation, I'm using them to calculate the delta rotation.
m_baseQuatLinked *= m_player.m_baseQuat.GetInverted() * m_baseQuat;
m_viewQuatLinked *= m_player.m_viewQuat.GetInverted() * m_viewQuat;
m_baseQuat = pLinked->GetRotation() * m_baseQuatLinked;
m_viewQuat = pLinked->GetRotation() * m_viewQuatLinked;
}
}
//
m_viewQuatFinal = m_viewQuat; //TEST: * Quat::CreateRotationXYZ(m_player.m_viewAnglesOffset);
}
/*
* @brief The angles are typically fetched from input, after factoring in client-side
* prediction, unless the client is watching a demo or chase camera.
*/
static void Cl_UpdateAngles(const player_state_t *ps, const player_state_t *ops) {
vec3_t old_angles, new_angles, angles;
// start with the predicted angles, or interpolate the server states
if (Cl_UsePrediction()) {
VectorCopy(cl.predicted_state.view_angles, r_view.angles);
} else {
UnpackAngles(ops->pm_state.view_angles, old_angles);
UnpackAngles(ps->pm_state.view_angles, new_angles);
AngleLerp(old_angles, new_angles, cl.lerp, r_view.angles);
}
// add in the kick angles
UnpackAngles(ops->pm_state.kick_angles, old_angles);
UnpackAngles(ps->pm_state.kick_angles, new_angles);
AngleLerp(old_angles, new_angles, cl.lerp, angles);
VectorAdd(r_view.angles, angles, r_view.angles);
// and lastly the delta angles
UnpackAngles(ops->pm_state.delta_angles, old_angles);
UnpackAngles(ps->pm_state.delta_angles, new_angles);
VectorCopy(new_angles, angles);
// check for small delta angles, and interpolate them
if (!VectorCompare(new_angles, new_angles)) {
VectorSubtract(old_angles, new_angles, angles);
vec_t f = VectorLength(angles);
if (f < 15.0) {
AngleLerp(old_angles, new_angles, cl.lerp, angles);
}
}
VectorAdd(r_view.angles, angles, r_view.angles);
ClampAngles(r_view.angles);
if (cl.frame.ps.pm_state.type == PM_DEAD) { // look only on x axis
r_view.angles[0] = 0.0;
r_view.angles[2] = 45.0;
}
// and finally set the view directional vectors
AngleVectors(r_view.angles, r_view.forward, r_view.right, r_view.up);
}
void CLink::Updateim1Ti(MDFloat ThetaX, MDFloat ThetaY, MDFloat ThetaZ){
/* **************************************************************************************************************************** */
if (ThetaX > 5.0) ThetaX = 5.0;
if (ThetaY > 5.0) ThetaY = 5.0;
if (ThetaZ > 5.0) ThetaZ = 5.0;
if (ThetaX < -5.0) ThetaX = -5.0;
if (ThetaY < -5.0) ThetaY = -5.0;
if (ThetaZ < -5.0) ThetaZ = -5.0;
/* **************************************************************************************************************************** */
Alpha += ThetaX;
Beta += ThetaY;
Gamma += ThetaZ;
/* **************************************************************************************************************************** */
ClampAngles();
/* **************************************************************************************************************************** */
Updateim1Ti();
/* **************************************************************************************************************************** */
}
void SetGamma(MDFloat t) { Gamma = t;
ClampAngles();
Updateim1Ti(); }
void SetBeta(MDFloat t) { Beta = t;
ClampAngles();
Updateim1Ti(); }
void SetAlpha(MDFloat t) { Alpha = t;
ClampAngles();
Updateim1Ti(); }
void CPlayerRotation::Process(IItem* pCurrentItem, const SActorFrameMovementParams& movement, const SAimAccelerationParams& verticalAcceleration, float frameTime)
{
FUNCTION_PROFILER(GetISystem(), PROFILE_GAME);
// reset to the new impulse.
m_angularImpulseDelta = m_angularImpulse;
m_deltaAngles = movement.deltaAngles;
PR_CHECKQNAN_FLT(m_deltaAngles);
// Store the previous rotation to get the correct rotation for linked actors.
const Quat previousBaseQuat = m_baseQuat;
const Quat previousViewQuat = m_viewQuat;
ProcessForcedLookDirection(m_viewQuatFinal, frameTime);
ProcessAngularImpulses( frameTime );
ProcessLeanAndPeek( movement );
ProcessNormalRoll( frameTime );
bool shouldProcessTargetAssistance = ShouldProcessTargetAssistance();
if (shouldProcessTargetAssistance)
{
ProcessTargetAssistance( pCurrentItem );
}
#if TALOS
if(stricmp(g_pGameCVars->pl_talos->GetString(), m_player.GetEntity()->GetName()) == 0)
{
IMovementController* pMovementController = m_player.GetMovementController();
CRY_ASSERT(pMovementController);
SMovementState moveState;
pMovementController->GetMovementState(moveState);
Vec3 playerView[4] =
{
m_viewQuat.GetColumn0(), // Right
m_viewQuat.GetColumn1(), // Forward
m_viewQuat.GetColumn2(), // Up
moveState.eyePosition // Pos
};
GetTalosInput(this, m_player, m_deltaAngles.x, m_deltaAngles.z, playerView, frameTime);
}
#endif
float minAngle,maxAngle;
GetStanceAngleLimits(verticalAcceleration, pCurrentItem, minAngle, maxAngle);
ClampAngles( minAngle, maxAngle );
ProcessNormal( frameTime );
if(shouldProcessTargetAssistance)
{
IVehicle* pVehicle = m_player.GetLinkedVehicle();
if (pVehicle && GetCurrentItem(true))
{
if (m_deltaAngles.x!=0.f)
pVehicle->OnAction(eVAI_RotatePitchAimAssist, eAAM_Always, m_deltaAngles.x, m_player.GetEntity()->GetId());
if (m_deltaAngles.z!=0.f)
pVehicle->OnAction(eVAI_RotateYawAimAssist, eAAM_Always, m_deltaAngles.z, m_player.GetEntity()->GetId());
}
}
//update freelook when linked to an entity
ProcessLinkedState(m_player.m_linkStats, previousBaseQuat, previousViewQuat);
//Recoil/Zoom sway offset for local player
ProcessFinalViewEffects( minAngle, maxAngle );
m_frameViewAnglesOffset.Set(0.0f, 0.0f, 0.0f);
m_forceLookVector.zero();
m_externalAngles.Set(0.f, 0.f, 0.f);
NormalizeQuats();
}
