void CIKTorsoAim_Helper::Update( CIKTorsoAim_Helper::SIKTorsoParams& ikTorsoParams )
{
if (!m_initialized)
{
Init(ikTorsoParams);
}
const int STAPLayer = GetGameConstCVar(g_stapLayer);
const bool justTurnedOn = (m_blendFactor == 0.0f) && m_enabled;
const float frameTime = gEnv->pTimer->GetFrameTime();
const float delta = (frameTime * ikTorsoParams.blendRate);
const float newBlendFactor = m_enabled ? m_blendFactor + delta : m_blendFactor - delta;
m_blendFactor = clamp(newBlendFactor, 0.0f, 1.0f);
const bool blendPosition = ikTorsoParams.needsSTAPPosition;
if (justTurnedOn)
{
m_blendFactorPosition = blendPosition ? 1.0f : 0.0f;
}
else
{
const float newBlendFactorPos = blendPosition ? m_blendFactorPosition + delta : m_blendFactorPosition - delta;
m_blendFactorPosition = clamp(newBlendFactorPos, 0.0f, 1.0f);
}
//const float XPOS = 200.0f;
//const float YPOS = 110.0f;
//const float FONT_SIZE = 4.0f;
//const float FONT_COLOUR[4] = {1,1,1,1};
//gEnv->pRenderer->Draw2dLabel(XPOS, YPOS, FONT_SIZE, FONT_COLOUR, false, "CIKTorsoAim_Helper::Update: %s", m_blendTime > 0.0f ? "update" : "dont update");
if (m_blendFactor <= 0.0f)
return;
CIKTorsoAim *torsoAim = m_ikTorsoAim.get();
torsoAim->SetBlendWeight(m_blendFactor);
torsoAim->SetBlendWeightPosition(m_blendFactorPosition);
torsoAim->SetTargetDirection(ikTorsoParams.aimDirection);
torsoAim->SetViewOffset(ikTorsoParams.viewOffset);
torsoAim->SetAbsoluteTargetPosition(ikTorsoParams.targetPosition);
ikTorsoParams.character->GetISkeletonAnim()->PushPoseModifier(STAPLayer, cryinterface_cast<IAnimationPoseModifier>(m_ikTorsoAim), "IKTorsoAimHelper");
if (ikTorsoParams.shadowCharacter)
{
m_transformationPin->SetBlendWeight(ikTorsoParams.updateTranslationPinning ? m_blendFactor : 0.0f);
ikTorsoParams.character->GetISkeletonAnim()->PushPoseModifier(15, cryinterface_cast<IAnimationPoseModifier>(m_transformationPin), "IKTorsoAimHelper");
}
}
void CProceduralWeaponAnimationContext::Update(float timePassed)
{
ICharacterInstance* pCharacter = m_pScope->GetCharInst();
if (m_instanceCount <= 0 || pCharacter == 0)
return;
m_weaponSway.Update(timePassed);
const QuatT rightOffset = m_weaponSway.GetRightOffset();
const QuatT leftOffset = m_weaponSway.GetLeftOffset();
const int PWALayer = GetGameConstCVar(g_pwaLayer);
pCharacter->GetISkeletonAnim()->PushPoseModifier(PWALayer, cryinterface_cast<IAnimationPoseModifier>(m_pPoseModifier), "ProceduralWeapon");
m_pPoseModifier->Clear();
const IAnimationOperatorQueue::EOp set = IAnimationOperatorQueue::eOp_OverrideRelative;
const IAnimationOperatorQueue::EOp additive = IAnimationOperatorQueue::eOp_Additive;
ISkeletonPose* pPose = pCharacter->GetISkeletonPose();
Vec3 relBlendPos = Vec3(1.0f, 0.0f, 0.0f);
m_pPoseModifier->PushPosition(m_params.m_rightBlendIkIdx, set, relBlendPos);
Quat view = Quat::CreateRotationVDir(m_aimDirection);
Quat invView = view.GetInverted();
QuatT rightHand;
rightHand.t = view * rightOffset.t;
rightHand.q = view * (rightOffset.q * invView);
m_pPoseModifier->PushPosition(m_params.m_weaponTargetIdx, additive, rightHand.t);
m_pPoseModifier->PushOrientation(m_params.m_weaponTargetIdx, additive, rightHand.q);
QuatT leftHand;
leftHand.t = view * leftOffset.t;
leftHand.q = view * (leftOffset.q * invView);
m_pPoseModifier->PushPosition(m_params.m_leftHandTargetIdx, additive, leftHand.t);
m_pPoseModifier->PushOrientation(m_params.m_leftHandTargetIdx, additive, leftHand.q);
}
void CDoorPanel::Update( SEntityUpdateContext& ctx, int slot )
{
if (m_bHasDelayedStateEvent)
{
if (m_fDelayedStateEventTimeDelay > FLT_EPSILON)
{
m_fDelayedStateEventTimeDelay -= ctx.fFrameTime;
}
else
{
m_fDelayedStateEventTimeDelay = -1.0f;
m_bHasDelayedStateEvent = false;
const EDoorPanelBehaviorState delayedState = m_delayedState;
m_delayedState = eDoorPanelBehaviorState_Invalid;
SetStateById(delayedState);
}
}
// Check visible distance
if (m_fVisibleDistanceSq > 0.0f)
{
const float fCurTime = ctx.fCurrTime;
if ((fCurTime - m_fLastVisibleDistanceCheckTime) >= GetGameConstCVar(g_flashdoorpanel_distancecheckinterval))
{
m_fLastVisibleDistanceCheckTime = fCurTime;
const Vec3& clientPos = CHUDUtils::GetClientPos();
const float fDistSqFromClientToObject = clientPos.GetSquaredDistance(GetEntity()->GetWorldPos());
const bool bVisible = fDistSqFromClientToObject <= m_fVisibleDistanceSq;
if (bVisible != m_bFlashVisible)
{
m_bFlashVisible = bVisible;
SDoorPanelVisibleEvent visibleEvent( bVisible );
StateMachineHandleEventBehavior( visibleEvent );
}
}
}
}
bool CLocalPlayerComponent::ShouldUpdateTranslationPinning() const
{
return !m_rPlayer.IsSliding() && !m_rPlayer.IsExitingSlide()
&& (GetGameConstCVar(g_translationPinningEnable) != 0)
&& !m_rPlayer.GetActorStats()->bDisableTranslationPinning;
}
//------------------------------------------------------------------------
bool CTracer::Update(float frameTime, const Vec3 &camera, const float fovScale)
{
frameTime = (float)__fsel(-m_age, 0.002f, frameTime);
const float tracerAge = (float)__fsel(-m_age, 0.002f, m_age+frameTime);
m_age = tracerAge;
if (tracerAge >= m_lifeTime)
return false;
Vec3 currentLimitDestination;
if (gEnv->bMultiplayer)
{
if(m_tracerFlags & kTracerFlag_updateDestFromBullet)
{
IEntity* pBulletEntity = gEnv->pEntitySystem->GetEntity(m_boundToBulletId);
if(pBulletEntity)
{
m_dest = pBulletEntity->GetPos();
}
}
currentLimitDestination = m_dest;
}
else
{
IEntity* pBulletEntity = gEnv->pEntitySystem->GetEntity(m_boundToBulletId);
currentLimitDestination = pBulletEntity ? pBulletEntity->GetPos() : m_dest;
}
const Vec3 maxTravelledDistance = m_dest - m_startingPos;
const float maxTravelledDistanceSqr = maxTravelledDistance.len2();
float dist = sqrt_tpl(maxTravelledDistanceSqr);
if (dist <= 0.001f)
return false;
const Vec3 dir = maxTravelledDistance * (float)__fres(dist);
Vec3 pos = m_pos;
float lengthScale = 1.f;
Vec3 newPos = m_pos;
if (!(m_tracerFlags & kTracerFlag_dontTranslate))
{
const float sqrRadius = GetGameConstCVar(g_tracers_slowDownAtCameraDistance) * GetGameConstCVar(g_tracers_slowDownAtCameraDistance);
const float cameraDistance = (m_pos-camera).len2();
const float speed = m_speed * (float)__fsel(sqrRadius - cameraDistance, 0.35f + (cameraDistance/(sqrRadius*2)), 1.0f); //Slow down tracer when near the player
newPos += dir * min(speed*frameTime, dist);
pos = newPos;
if(m_slideFrac > 0.f)
{
pos += (((2.f * cry_frand()) - 0.5f) * m_slideFrac * speed * frameTime * dir);
}
}
// Now update visuals...
if (IEntity *pEntity = gEnv->pEntitySystem->GetEntity(m_entityId))
{
AABB tracerBbox;
pEntity->GetWorldBounds(tracerBbox);
float tracerHalfLength = !tracerBbox.IsEmpty() ? tracerBbox.GetRadius() : 0.0f;
const Vec3 frontOfTracerPos = pos + (dir * tracerHalfLength);
if((frontOfTracerPos-m_startingPos).len2() > maxTravelledDistanceSqr)
{
return false;
}
if (!(m_tracerFlags & kTracerFlag_dontTranslate) && tracerHalfLength > 0.f)
{
//Ensure that never goes in front of the bullet
const Vec3 dirFromFrontOfTracerToDestination = currentLimitDestination - frontOfTracerPos;
if (dir.dot(dirFromFrontOfTracerToDestination) < 0)
{
pos += dirFromFrontOfTracerToDestination;
}
// ... and check if back of tracer is behind starting point, so adjust length.
const Vec3 backOfTracerPos = pos - (dir * tracerHalfLength);
const Vec3 dirFromBackOfTracerToStart = m_startingPos - backOfTracerPos;
if (dir.dot(dirFromBackOfTracerToStart) > 0)
{
if(dir.dot((m_startingPos - pos)) > 0)
{
pos = m_startingPos + (dir * cry_frand() * tracerHalfLength);
}
lengthScale = ((pos - m_startingPos).GetLength() / tracerHalfLength);
}
}
m_pos = newPos;
Matrix34 tm(Matrix33::CreateRotationVDir(dir));
tm.AddTranslation(pos);
pEntity->SetWorldTM(tm);
//Do not scale effects
if((m_tracerFlags & kTracerFlag_useGeometry))
{
float finalFovScale = fovScale;
if((m_tracerFlags & kTracerFlag_scaleToDistance) != 0)
{
lengthScale = dist * 0.5f;
}
else
{
const float cameraDistanceSqr = (m_pos-camera).len2();
const float minScale = GetGameConstCVar(g_tracers_minScale);
const float maxScale = GetGameConstCVar(g_tracers_maxScale);
const float minDistanceRange = GetGameConstCVar(g_tracers_minScaleAtDistance) * GetGameConstCVar(g_tracers_minScaleAtDistance);
const float maxDistanceRange = max(GetGameConstCVar(g_tracers_maxScaleAtDistance) * GetGameConstCVar(g_tracers_maxScaleAtDistance), minDistanceRange + 1.0f);
const float currentRefDistance = clamp(cameraDistanceSqr, minDistanceRange, maxDistanceRange);
const float distanceToCameraFactor = ((currentRefDistance - minDistanceRange) / (maxDistanceRange - minDistanceRange));
const float distanceToCameraScale = LERP(minScale, maxScale, distanceToCameraFactor);
lengthScale = m_scale * distanceToCameraScale;
finalFovScale *= distanceToCameraScale;
}
const float widthScale = fovScale;
tm.SetIdentity();
tm.SetScale(Vec3(m_scale * finalFovScale, lengthScale, m_scale * finalFovScale));
pEntity->SetSlotLocalTM(m_geometrySlot,tm);
}
}
return true;
}
