UALSCharacterAnimInstance Class Reference

#include <ALSCharacterAnimInstance.h>

Inheritance diagram for UALSCharacterAnimInstance:

Public Member Functions
virtual void	NativeInitializeAnimation () override
virtual void	NativeBeginPlay () override
virtual void	NativeUpdateAnimation (float DeltaSeconds) override
virtual void	NativeThreadSafeUpdateAnimation (float DeltaSeconds) override
void	PlayTransition (const FALSDynamicMontageParams &Parameters)
void	PlayTransitionChecked (const FALSDynamicMontageParams &Parameters)
void	PlayDynamicTransition (float ReTriggerDelay, FALSDynamicMontageParams Parameters)
void	OnJumped ()
void	OnPivot ()
virtual void	SetFiringWeapon (const bool bValue) override
virtual void	SetRecoilTransform (const FTransform &Transform) override
virtual void	SetPivotPoint (const FTransform &Transform) override
virtual void	DisableFootIK (const float DelayTime) override
virtual void	SetInjured (const EBodyPartName BodyPartName, const float InjuredAmount) override
void	OnDisableFootIK (const float DelayTime)
void	OnInjured (const EBodyPartName BodyPartName, const float InjuredAmount)
bool	GetFiringWeapon () const
virtual void	SetEssentialInfo (const FALSAnimValues &Value) override
virtual void	SetOptimize (const bool bValue) override
virtual void	SetMovementState (const FALSMovementState &Value) override
virtual void	SetOverlayOverrideState (const int32 Value) override
virtual void	SetGait (const FALSGait &Value) override
virtual void	SetStance (const FALSStance &Value) override
virtual void	SetViewMode (const EALSViewMode Value) override
virtual void	SetOverlayState (const FALSOverlayState &Value) override
virtual void	SetNewGroundedEntryState (const FALSGroundedEntryState &Value) override
virtual void	SetRotationMode (const FALSRotationMode Value) override
FRotator	GetRecoilRotation () const
FVector	GetPivotPointLocation () const
bool	GetShouldOverlayStateUsePRASIK () const
	UPROPERTY (VisibleDefaultsOnly, BlueprintReadOnly, Category="Read Only Data|Character Information", Meta=(ShowOnlyInnerProperties)) FALSAnimCharacterInformation CharacterInformation
	UPROPERTY (VisibleDefaultsOnly, BlueprintReadOnly, Category="Read Only Data|Anim Graph - Grounded", Meta=(ShowOnlyInnerProperties)) FALSAnimGraphGrounded Grounded
	UPROPERTY (VisibleDefaultsOnly, BlueprintReadOnly, Category="Read Only Data|Anim Graph - In Air", Meta=(ShowOnlyInnerProperties)) FALSAnimGraphInAir InAir
	UPROPERTY (VisibleDefaultsOnly, BlueprintReadOnly, Category="Read Only Data|Anim Graph - Aiming Values", Meta=(ShowOnlyInnerProperties)) FALSAnimGraphAimingValues AimingValues
	UPROPERTY (VisibleDefaultsOnly, BlueprintReadOnly, Category="Read Only Data|Anim Graph - Layer Blending", Meta=(ShowOnlyInnerProperties)) FALSAnimGraphLayerBlending LayerBlendingValues
	UPROPERTY (VisibleDefaultsOnly, BlueprintReadOnly, Category="Read Only Data|Anim Graph - Foot IK", Meta=(ShowOnlyInnerProperties)) FALSAnimGraphFootIK FootIKValues
	UPROPERTY (EditDefaultsOnly, BlueprintReadOnly, Category="Configuration|Turn In Place", Meta=(ShowOnlyInnerProperties)) FALSAnimTurnInPlace TurnInPlaceValues
	UPROPERTY (EditDefaultsOnly, BlueprintReadOnly, Category="Configuration|Rotate In Place", Meta=(ShowOnlyInnerProperties)) FALSAnimRotateInPlace RotateInPlace
	UPROPERTY (EditDefaultsOnly, BlueprintReadOnly, Category="Configuration|Main Configuration", Meta=(ShowOnlyInnerProperties)) FALSAnimConfiguration Config

Public Attributes
bool	bOptimize = false
TObjectPtr< AALSBaseCharacter >	Character = nullptr
FALSMovementState	MovementState = EALSMovementState::None
FALSMovementAction	MovementAction = EALSMovementAction::None
FALSRotationMode	RotationMode = EALSRotationMode::VelocityDirection
FALSGait	Gait = EALSGait::Walking
FALSStance	Stance = EALSStance::Standing
FALSOverlayState	OverlayState = EALSOverlayState::Default
FALSVelocityBlend	VelocityBlend
FALSLeanAmount	LeanAmount
FVector	RelativeAccelerationAmount = FVector::ZeroVector
FALSGroundedEntryState	GroundedEntryState = EALSGroundedEntryState::None
FALSMovementDirection	MovementDirection = EALSMovementDirection::Forward
FVector2D	SmoothedAimingAngle = FVector2D::ZeroVector
float	FlailRate = 0.0f
TObjectPtr< UCurveFloat >	DiagonalScaleAmountCurve = nullptr
TObjectPtr< UCurveFloat >	StrideBlend_N_Walk = nullptr
TObjectPtr< UCurveFloat >	StrideBlend_N_Run = nullptr
TObjectPtr< UCurveFloat >	StrideBlend_C_Walk = nullptr
TObjectPtr< UCurveFloat >	LandPredictionCurve = nullptr
TObjectPtr< UCurveFloat >	LeanInAirCurve = nullptr
TObjectPtr< UCurveVector >	YawOffset_FB = nullptr
TObjectPtr< UCurveVector >	YawOffset_LR = nullptr
TObjectPtr< UAnimSequenceBase >	TransitionAnim_R = nullptr
TObjectPtr< UAnimSequenceBase >	TransitionAnim_L = nullptr
FName	IkFootL_BoneName = FName(TEXT("ik_foot_l"))
FName	IkFootR_BoneName = FName(TEXT("ik_foot_r"))
FVector	GunOffset = FVector::ZeroVector
FTransform	RecoilTransform
FTransform	PivotPoint
bool	bFiringWeapon = false
EBodyPartName	InjuredBodyPart = EBodyPartName::Pelvis
float	InjuredAlpha = 0.0f

Protected Member Functions
void	SetTrackedHipsDirection (EALSHipsDirection HipsDirection)
void	SetGroundedEntryState (EALSGroundedEntryState NewState)
bool	ShouldMoveCheck () const
bool	CanRotateInPlace () const
bool	CanTurnInPlace () const
bool	CanDynamicTransition () const

Private Member Functions
void	PlayDynamicTransitionDelay ()
void	OnJumpedDelay ()
void	OnPivotDelay ()
void	UpdateAimingValues (float DeltaSeconds)
void	UpdateLayerValues ()
void	UpdateFootIK (float DeltaSeconds)
void	UpdateMovementValues (float DeltaSeconds)
void	UpdateRotationValues ()
void	UpdateInAirValues (float DeltaSeconds)
void	UpdateRagdollValues ()
void	SetFootLocking (float DeltaSeconds, FName EnableFootIKCurve, FName FootLockCurve, FName IKFootBone, float &CurFootLockAlpha, bool &UseFootLockCurve, FVector &CurFootLockLoc, FRotator &CurFootLockRot) const
void	SetFootLockOffsets (float DeltaSeconds, FVector &LocalLoc, FRotator &LocalRot) const
void	SetPelvisIKOffset (float DeltaSeconds, FVector FootOffsetLTarget, FVector FootOffsetRTarget)
void	ResetIKOffsets (float DeltaSeconds)
void	SetFootOffsets (float DeltaSeconds, FName EnableFootIKCurve, FName IKFootBone, FName RootBone, FVector &CurLocationTarget, FVector &CurLocationOffset, FRotator &CurRotationOffset) const
void	RotateInPlaceCheck ()
void	TurnInPlaceCheck (float DeltaSeconds)
void	DynamicTransitionCheck ()
FALSVelocityBlend	CalculateVelocityBlend () const
void	TurnInPlace (FRotator TargetRotation, float PlayRateScale, float StartTime, bool OverrideCurrent)
FVector	CalculateRelativeAccelerationAmount () const
float	CalculateStrideBlend () const
float	CalculateWalkRunBlend () const
float	CalculateStandingPlayRate () const
float	CalculateDiagonalScaleAmount () const
float	CalculateCrouchingPlayRate () const
float	CalculateLandPrediction () const
FALSLeanAmount	CalculateAirLeanAmount () const
EALSMovementDirection	CalculateMovementDirection () const
float	GetAnimCurveClamped (const FName &Name, float Bias, float ClampMin, float ClampMax) const

Private Attributes
FTimerHandle	OnPivotTimer
FTimerHandle	PlayDynamicTransitionTimer
FTimerHandle	OnJumpedTimer
bool	bCanPlayDynamicTransition = true
TObjectPtr< UALSDebugComponent >	ALSDebugComponent = nullptr

Detailed Description

Main anim instance class for character

Member Function Documentation

CalculateAirLeanAmount()

FALSLeanAmount UALSCharacterAnimInstance::CalculateAirLeanAmount ( ) const

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::CalculateAirLeanAmount);
    // Use the relative Velocity direction and amount to determine how much the character should lean while in air.
    // The Lean In Air curve gets the Fall Speed and is used as a multiplier to smoothly reverse the leaning direction
    // when transitioning from moving upwards to moving downwards.
    FALSLeanAmount CalcLeanAmount;
    if(ensure(LeanInAirCurve))
    {
        const FVector& UnrotatedVel = CharacterInformation.CharacterActorRotation.UnrotateVector(
            CharacterInformation.Velocity) / 350.0f;
        FVector2D InversedVect(UnrotatedVel.Y, UnrotatedVel.X);
        InversedVect *= LeanInAirCurve->GetFloatValue(InAir.FallSpeed);
        CalcLeanAmount.LR = InversedVect.X;
        CalcLeanAmount.FB = InversedVect.Y;
    }
    return CalcLeanAmount;
}

CalculateCrouchingPlayRate()

float UALSCharacterAnimInstance::CalculateCrouchingPlayRate ( ) const

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::CalculateCrouchingPlayRate);
    // Calculate the Crouching Play Rate by dividing the Character's speed by the Animated Speed.
    // This value needs to be separate from the standing play rate to improve the blend from crouch to stand while in motion.
    return FMath::Clamp(
        CharacterInformation.Speed / Config.AnimatedCrouchSpeed / Grounded.StrideBlend / GetOwningComponent()->
        GetComponentScale().Z,
        0.0f, 2.0f);
}

CalculateDiagonalScaleAmount()

float UALSCharacterAnimInstance::CalculateDiagonalScaleAmount ( ) const

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::CalculateDiagonalScaleAmount);
    // Calculate the Diagonal Scale Amount. This value is used to scale the Foot IK Root bone to make the Foot IK bones
    // cover more distance on the diagonal blends. Without scaling, the feet would not move far enough on the diagonal
    // direction due to the linear translational blending of the IK bones. The curve is used to easily map the value.
    if (ensure(IsValid(DiagonalScaleAmountCurve)))
    {
        return DiagonalScaleAmountCurve->GetFloatValue(FMath::Abs(VelocityBlend.F + VelocityBlend.B));
    }
    return 0.0f;
}

CalculateLandPrediction()

float UALSCharacterAnimInstance::CalculateLandPrediction ( ) const

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::CalculateLandPrediction);
    // Calculate the land prediction weight by tracing in the velocity direction to find a walkable surface the character
    // is falling toward, and getting the 'Time' (range of 0-1, 1 being maximum, 0 being about to land) till impact.
    // The Land Prediction Curve is used to control how the time affects the final weight for a smooth blend.
    if (InAir.FallSpeed >= -200.0f)
    {
        return 0.0f;
    }
 
    const UCapsuleComponent* CapsuleComp = Character->GetCapsuleComponent();
    const FVector& CapsuleWorldLoc = CapsuleComp->GetComponentLocation();
    const float VelocityZ = CharacterInformation.Velocity.Z;
    FVector VelocityClamped = CharacterInformation.Velocity;
    VelocityClamped.Z = FMath::Clamp(VelocityZ, -4000.0f, -200.0f);
    VelocityClamped.Normalize();
 
    const FVector TraceLength = VelocityClamped * FMath::GetMappedRangeValueClamped<float, float>(
        {0.0f, -4000.0f}, {50.0f, 2000.0f}, VelocityZ);
 
    UWorld* World = GetWorld();
    check(World);
 
    FCollisionQueryParams Params;
    Params.AddIgnoredActor(Character);
 
    FHitResult HitResult;
    const FCollisionShape CapsuleCollisionShape = FCollisionShape::MakeCapsule(CapsuleComp->GetUnscaledCapsuleRadius(),
                                                                               CapsuleComp->GetUnscaledCapsuleHalfHeight());
    const bool bHit = World->SweepSingleByChannel(HitResult, CapsuleWorldLoc, CapsuleWorldLoc + TraceLength, FQuat::Identity,
                                                  ECC_Visibility, CapsuleCollisionShape, Params);
 
    if (ALSDebugComponent && ALSDebugComponent->GetShowTraces())
    {
        UALSDebugComponent::DrawDebugCapsuleTraceSingle(World,
                                                        CapsuleWorldLoc,
                                                        CapsuleWorldLoc + TraceLength,
                                                        CapsuleCollisionShape,
                                                        EDrawDebugTrace::Type::ForOneFrame,
                                                        bHit,
                                                        HitResult,
                                                        FLinearColor::Red,
                                                        FLinearColor::Green,
                                                        5.0f);
    }
 
    if (Character->GetCharacterMovement() != nullptr && Character->GetCharacterMovement()->IsWalkable(HitResult) && ensure(IsValid(LandPredictionCurve)))
    {
        return FMath::Lerp(LandPredictionCurve->GetFloatValue(HitResult.Time), 0.0f,GetCurveValue(NAME_Mask_LandPrediction));
    }
 
    return 0.0f;
}

CalculateMovementDirection()

EALSMovementDirection UALSCharacterAnimInstance::CalculateMovementDirection ( ) const

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::CalculateMovementDirection);
    // Calculate the Movement Direction. This value represents the direction the character is moving relative to the camera
    // during the Looking Direction / Aiming rotation modes, and is used in the Cycle Blending Anim Layers to blend to the
    // appropriate directional states.
    if (Gait.Sprinting() || RotationMode.VelocityDirection())
    {
        return EALSMovementDirection::Forward;
    }
 
    FRotator Delta = CharacterInformation.Velocity.ToOrientationRotator() - CharacterInformation.AimingRotation;
    Delta.Normalize();
    return UALSMathLibrary::CalculateQuadrant(MovementDirection, 70.0f, -70.0f, 110.0f, -110.0f, 5.0f, Delta.Yaw);
}

CalculateRelativeAccelerationAmount()

FVector UALSCharacterAnimInstance::CalculateRelativeAccelerationAmount ( ) const

private

Movement

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::CalculateRelativeAccelerationAmount);
    // Calculate the Relative Acceleration Amount. This value represents the current amount of acceleration / deceleration
    // relative to the actor rotation. It is normalized to a range of -1 to 1 so that -1 equals the Max Braking Deceleration,
    // and 1 equals the Max Acceleration of the Character Movement Component.
    if (FVector::DotProduct(CharacterInformation.Acceleration, CharacterInformation.Velocity) > 0.0f)
    {
        if(Character->GetCharacterMovement() != nullptr)
        {
            const float MaxAcc = Character->GetCharacterMovement()->GetMaxAcceleration();
            return CharacterInformation.CharacterActorRotation.UnrotateVector(
                CharacterInformation.Acceleration.GetClampedToMaxSize(MaxAcc) / MaxAcc);
        }
    }
    float MaxBrakingDec = 0.0f;
    if(Character->GetCharacterMovement() != nullptr)
    {
        MaxBrakingDec = Character->GetCharacterMovement()->GetMaxBrakingDeceleration();
    }
    return
        CharacterInformation.CharacterActorRotation.UnrotateVector(
            CharacterInformation.Acceleration.GetClampedToMaxSize(MaxBrakingDec) / MaxBrakingDec);
}

CalculateStandingPlayRate()

float UALSCharacterAnimInstance::CalculateStandingPlayRate ( ) const

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::CalculateStandingPlayRate);
    // Calculate the Play Rate by dividing the Character's speed by the Animated Speed for each gait.
    // The lerps are determined by the "W_Gait" anim curve that exists on every locomotion cycle so
    // that the play rate is always in sync with the currently blended animation.
    // The value is also divided by the Stride Blend and the mesh scale so that the play rate increases as the stride or scale gets smaller
    const float LerpedSpeed = FMath::Lerp(CharacterInformation.Speed / Config.AnimatedWalkSpeed,
                                          CharacterInformation.Speed / Config.AnimatedRunSpeed,
                                          GetAnimCurveClamped(NAME_W_Gait, -1.0f, 0.0f, 1.0f));
 
    const float SprintAffectedSpeed = FMath::Lerp(LerpedSpeed, CharacterInformation.Speed / Config.AnimatedSprintSpeed,
                                                  GetAnimCurveClamped(NAME_W_Gait, -2.0f, 0.0f, 1.0f));
 
    return FMath::Clamp((SprintAffectedSpeed / Grounded.StrideBlend) / GetOwningComponent()->GetComponentScale().Z,
                        0.0f, 3.0f);
}

CalculateStrideBlend()

float UALSCharacterAnimInstance::CalculateStrideBlend ( ) const

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::CalculateStrideBlend);
    // Calculate the Stride Blend. This value is used within the blendspaces to scale the stride (distance feet travel)
    // so that the character can walk or run at different movement speeds.
    // It also allows the walk or run gait animations to blend independently while still matching the animation speed to
    // the movement speed, preventing the character from needing to play a half walk+half run blend.
    // The curves are used to map the stride amount to the speed for maximum control.
    const float CurveTime = CharacterInformation.Speed / GetOwningComponent()->GetComponentScale().Z;
    const float ClampedGait = GetAnimCurveClamped(NAME_W_Gait, -1.0, 0.0f, 1.0f);
    const float LerpedStrideBlend =
        FMath::Lerp(StrideBlend_N_Walk->GetFloatValue(CurveTime), StrideBlend_N_Run->GetFloatValue(CurveTime),
                    ClampedGait);
    return FMath::Lerp(LerpedStrideBlend, StrideBlend_C_Walk->GetFloatValue(CharacterInformation.Speed),
                       GetCurveValue(NAME_BasePose_CLF));
}

CalculateVelocityBlend()

FALSVelocityBlend UALSCharacterAnimInstance::CalculateVelocityBlend ( ) const

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::CalculateVelocityBlend);
    // Calculate the Velocity Blend. This value represents the velocity amount of the actor in each direction (normalized so that
    // diagonals equal .5 for each direction), and is used in a BlendMulti node to produce better
    // directional blending than a standard blendspace.
    const FVector LocRelativeVelocityDir =
        CharacterInformation.CharacterActorRotation.UnrotateVector(CharacterInformation.Velocity.GetSafeNormal(0.1f));
    const float Sum = FMath::Abs(LocRelativeVelocityDir.X) + FMath::Abs(LocRelativeVelocityDir.Y) +
        FMath::Abs(LocRelativeVelocityDir.Z);
    const FVector RelativeDir = LocRelativeVelocityDir / Sum;
    FALSVelocityBlend Result;
    Result.F = FMath::Clamp(RelativeDir.X, 0.0f, 1.0f);
    Result.B = FMath::Abs(FMath::Clamp(RelativeDir.X, -1.0f, 0.0f));
    Result.L = FMath::Abs(FMath::Clamp(RelativeDir.Y, -1.0f, 0.0f));
    Result.R = FMath::Clamp(RelativeDir.Y, 0.0f, 1.0f);
    return Result;
}

CalculateWalkRunBlend()

float UALSCharacterAnimInstance::CalculateWalkRunBlend ( ) const

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::CalculateWalkRunBlend);
    // Calculate the Walk Run Blend. This value is used within the Blendspaces to blend between walking and running.
    return Gait.Walking() ? 0.0f : 1.0;
}

CanDynamicTransition()

bool UALSCharacterAnimInstance::CanDynamicTransition ( ) const

protected

Only perform a Dynamic Transition check if the "Enable Transition" curve is fully weighted. The Enable_Transition curve is modified within certain states of the AnimBP so that the character can only transition while in those states.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::CanDynamicTransition);
    return GetCurveValue(NAME_Enable_Transition) >= 0.99f;
}

CanRotateInPlace()

bool UALSCharacterAnimInstance::CanRotateInPlace ( ) const

protected

Only perform a Rotate In Place Check if the character is Aiming or in First Person.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::CanRotateInPlace);
    return RotationMode.Aiming() ||
        CharacterInformation.ViewMode == EALSViewMode::FirstPerson;
}

CanTurnInPlace()

bool UALSCharacterAnimInstance::CanTurnInPlace ( ) const

protected

Only perform a Turn In Place check if the character is looking toward the camera in Third Person, and if the "Enable Transition" curve is fully weighted. The Enable_Transition curve is modified within certain states of the AnimBP so that the character can only turn while in those states..

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::CanTurnInPlace);
    return RotationMode.LookingDirection() &&
        CharacterInformation.ViewMode == EALSViewMode::ThirdPerson &&
        GetCurveValue(NAME_Enable_Transition) >= 0.99f;
}

DisableFootIK()

void UALSCharacterAnimInstance::DisableFootIK ( const float DelayTime )

overridevirtual

For When the feet get stuck and need disabling

Implements ICustomAnimInstance.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::DisableFootIK);
    OnDisableFootIK(DelayTime);
}

DynamicTransitionCheck()

void UALSCharacterAnimInstance::DynamicTransitionCheck ( )

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::DynamicTransitionCheck);
    DECLARE_SCOPE_CYCLE_COUNTER(TEXT("ALS DynamicTransitionCheck"), STAT_ALS_DynamicTransitionCheck, STATGROUP_ALS);
 
    // Check each foot to see if the location difference between the IK_Foot bone and its desired / target location
    // (determined via a virtual bone) exceeds a threshold. If it does, play an additive transition animation on that foot.
    // The currently set transition plays the second half of a 2 foot transition animation, so that only a single foot moves.
    // Because only the IK_Foot bone can be locked, the separate virtual bone allows the system to know its desired location when locked.
    FTransform SocketTransformA = GetOwningComponent()->GetSocketTransform(IkFootL_BoneName, RTS_Component);
    FTransform SocketTransformB = GetOwningComponent()->GetSocketTransform(
        NAME_VB___foot_target_l, RTS_Component);
    float Distance = (SocketTransformB.GetLocation() - SocketTransformA.GetLocation()).Size();
    if (Distance > Config.DynamicTransitionThreshold)
    {
        FALSDynamicMontageParams Params;
        Params.Animation = TransitionAnim_R;
        Params.BlendInTime = 0.2f;
        Params.BlendOutTime = 0.2f;
        Params.PlayRate = 1.5f;
        Params.StartTime = 0.8f;
        PlayDynamicTransition(0.1f, Params);
    }
 
    SocketTransformA = GetOwningComponent()->GetSocketTransform(IkFootR_BoneName, RTS_Component);
    SocketTransformB = GetOwningComponent()->GetSocketTransform(NAME_VB___foot_target_r, RTS_Component);
    Distance = (SocketTransformB.GetLocation() - SocketTransformA.GetLocation()).Size();
    if (Distance > Config.DynamicTransitionThreshold)
    {
        FALSDynamicMontageParams Params;
        Params.Animation = TransitionAnim_L;
        Params.BlendInTime = 0.2f;
        Params.BlendOutTime = 0.2f;
        Params.PlayRate = 1.5f;
        Params.StartTime = 0.8f;
        PlayDynamicTransition(0.1f, Params);
    }
}

GetAnimCurveClamped()

float UALSCharacterAnimInstance::GetAnimCurveClamped ( const FName & Name, float Bias, float ClampMin, float ClampMax ) const

private

Util

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::GetAnimCurveClamped);
    return FMath::Clamp(GetCurveValue(Name) + Bias, ClampMin, ClampMax);
}

GetFiringWeapon()

bool UALSCharacterAnimInstance::GetFiringWeapon ( ) const

inline

{return bFiringWeapon;};

GetPivotPointLocation()

FVector UALSCharacterAnimInstance::GetPivotPointLocation ( ) const

inline

{return PivotPoint.GetLocation() + GunOffset;};

GetRecoilRotation()

FRotator UALSCharacterAnimInstance::GetRecoilRotation ( ) const

inline

{return RecoilTransform.Rotator();};

GetShouldOverlayStateUsePRASIK()

bool UALSCharacterAnimInstance::GetShouldOverlayStateUsePRASIK

(

)

const

{
    switch (OverlayState) {
    case EALSOverlayState::Default:
    case EALSOverlayState::Masculine:
    case EALSOverlayState::Feminine:
    case EALSOverlayState::Injured:
    case EALSOverlayState::HandsTied:
    case EALSOverlayState::Torch:
    case EALSOverlayState::Binoculars:
    case EALSOverlayState::Box:
    case EALSOverlayState::Barrel:
        return false;
    case EALSOverlayState::Rifle:
    case EALSOverlayState::PistolOneHanded:
    case EALSOverlayState::PistolTwoHanded:
    case EALSOverlayState::Shotgun:
    case EALSOverlayState::Sniper:
    case EALSOverlayState::Launcher:
    case EALSOverlayState::Sword:
    case EALSOverlayState::Knife:
    case EALSOverlayState::Chainsaw:
    case EALSOverlayState::SwordShield:
    case EALSOverlayState::Melee:
    case EALSOverlayState::Bow:
    default:
        return true;
    }
}

NativeBeginPlay()

void UALSCharacterAnimInstance::NativeBeginPlay ( )

overridevirtual

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::NativeBeginPlay);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    // it seems to be that the player pawn components are not really initialized
    // when the call to NativeInitializeAnimation() happens.
    // This is the reason why it is tried here to get the ALS debug component.
    if (const APawn* Owner = TryGetPawnOwner())
    {
        ALSDebugComponent = Owner->FindComponentByClass<UALSDebugComponent>();
    }
 
}

NativeInitializeAnimation()

void UALSCharacterAnimInstance::NativeInitializeAnimation ( )

overridevirtual

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::NativeInitializeAnimation);
 
    Super::NativeInitializeAnimation();
    Character = Cast<AALSBaseCharacter>(TryGetPawnOwner());
    if (Character)
    {
        Character->OnJumpedDelegate.AddUniqueDynamic(this, &UALSCharacterAnimInstance::OnJumped);
    }
}

NativeThreadSafeUpdateAnimation()

void UALSCharacterAnimInstance::NativeThreadSafeUpdateAnimation ( float DeltaSeconds )

overridevirtual

{
    Super::NativeThreadSafeUpdateAnimation(DeltaSeconds);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    DECLARE_SCOPE_CYCLE_COUNTER(TEXT("ALS ThreadSafeUpdateAnimation"), STAT_ALS_NativeThreadSafeUpdateAnimation, STATGROUP_ALS)
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::NativeThreadSafeUpdateAnimation);
    if(bOptimize)
    {
        UpdateAimingValues(DeltaSeconds);
        UpdateLayerValues();
        
        if (MovementState.Grounded())
        {
            // Check If Moving Or Not & Enable Movement Animations if IsMoving and HasMovementInput, or if the Speed is greater than 150.
            const bool bPrevShouldMove = Grounded.bShouldMove;
            Grounded.bShouldMove = ShouldMoveCheck();
 
            if (bPrevShouldMove == false && Grounded.bShouldMove)
            {
                // Do When Starting To Move
                TurnInPlaceValues.ElapsedDelayTime = 0.0f;
                Grounded.bRotateL = false;
                Grounded.bRotateR = false;
            }
 
            if (Grounded.bShouldMove)
            {
                // Do While Moving
                UpdateMovementValues(DeltaSeconds);
                UpdateRotationValues();
            }
            else
            {
                // Do While Not Moving
                if (CanRotateInPlace())
                {
                    RotateInPlaceCheck();
                }
                else
                {
                    Grounded.bRotateL = false;
                    Grounded.bRotateR = false;
                }
                if (CanTurnInPlace())
                {
                    TurnInPlaceCheck(DeltaSeconds);
                }
                else
                {
                    TurnInPlaceValues.ElapsedDelayTime = 0.0f;
                }
                // if (CanDynamicTransition())
                // {
                //  DynamicTransitionCheck();
                // }
            }
        }
        else if (MovementState.InAir())
        {
            // Do While InAir
            UpdateInAirValues(DeltaSeconds);
        }
        else if (MovementState.Ragdoll())
        {
            // Do While Ragdolling
            UpdateRagdollValues();
        }
 
 
    }
    // UpdateFootIK(DeltaSeconds);
 
}

NativeUpdateAnimation()

void UALSCharacterAnimInstance::NativeUpdateAnimation ( float DeltaSeconds )

overridevirtual

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    DECLARE_SCOPE_CYCLE_COUNTER(TEXT("ALS NativeUpdateAnimation"), STAT_ALS_NativeUpdateAnimation, STATGROUP_ALS)
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::NativeUpdateAnimation);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    Super::NativeUpdateAnimation(DeltaSeconds);
 
    if(!Character || DeltaSeconds == 0.0f)
    {
        return;
    }
    if(bOptimize)
    {
        UpdateFootIK(DeltaSeconds);
        if (MovementState.Grounded())
        {
            const bool bPrevShouldMove = Grounded.bShouldMove;
            Grounded.bShouldMove = ShouldMoveCheck();
            if (bPrevShouldMove == false && Grounded.bShouldMove)
            {
                // Do When Starting To Move
                TurnInPlaceValues.ElapsedDelayTime = 0.0f;
                Grounded.bRotateL = false;
                Grounded.bRotateR = false;
            }
 
            if (Grounded.bShouldMove)
            {
            }
            else
            {
                if (CanDynamicTransition())
                {
                    DynamicTransitionCheck();
                }
            }
 
        }
    }
    else
    {
        // Update rest of character information. Others are reflected into anim bp when they're set inside character class
        CharacterInformation.MovementInputAmount = Character->GetMovementInputAmount();
        CharacterInformation.bHasMovementInput = Character->HasMovementInput();
        CharacterInformation.bIsMoving = Character->IsMoving();
        CharacterInformation.Acceleration = Character->GetAcceleration();
        CharacterInformation.AimYawRate = Character->GetAimYawRate();
        CharacterInformation.Speed = Character->GetSpeed();
        if(Character->GetCharacterMovement() != nullptr)
        {
            CharacterInformation.Velocity = Character->GetCharacterMovement()->Velocity;
        }
        CharacterInformation.MovementInput = Character->GetMovementInput();
        CharacterInformation.AimingRotation = Character->GetAimingRotation();
        CharacterInformation.CharacterActorRotation = Character->GetActorRotation();
        CharacterInformation.ViewMode = Character->GetViewMode();
        CharacterInformation.PrevMovementState = Character->GetPrevMovementState();
        LayerBlendingValues.OverlayOverrideState = Character->GetOverlayOverrideState();
        MovementState = Character->GetMovementState();
        MovementAction = Character->GetMovementAction();
        Stance = Character->GetStance();
        RotationMode = Character->GetRotationMode();
        Gait = Character->GetGait();
        OverlayState = Character->GetOverlayState();
        GroundedEntryState = Character->GetGroundedEntryState();
 
 
        UpdateAimingValues(DeltaSeconds);
        UpdateLayerValues();
        UpdateFootIK(DeltaSeconds);
 
        if (MovementState.Grounded())
        {
            // Check If Moving Or Not & Enable Movement Animations if IsMoving and HasMovementInput, or if the Speed is greater than 150.
            const bool bPrevShouldMove = Grounded.bShouldMove;
            Grounded.bShouldMove = ShouldMoveCheck();
 
            if (bPrevShouldMove == false && Grounded.bShouldMove)
            {
                // Do When Starting To Move
                TurnInPlaceValues.ElapsedDelayTime = 0.0f;
                Grounded.bRotateL = false;
                Grounded.bRotateR = false;
            }
            if (Grounded.bShouldMove)
            {
                // Do While Moving
                UpdateMovementValues(DeltaSeconds);
                UpdateRotationValues();
            }
            else
            {
                // Do While Not Moving
                if (CanRotateInPlace())
                {
                    RotateInPlaceCheck();
                }
                else
                {
                    Grounded.bRotateL = false;
                    Grounded.bRotateR = false;
                }
                if (CanTurnInPlace())
                {
                    TurnInPlaceCheck(DeltaSeconds);
                }
                else
                {
                    TurnInPlaceValues.ElapsedDelayTime = 0.0f;
                }
                if (CanDynamicTransition())
                {
                    DynamicTransitionCheck();
                }
            }
        }
        else if (MovementState.InAir())
        {
            // Do While InAir
            UpdateInAirValues(DeltaSeconds);
        }
        else if (MovementState.Ragdoll())
        {
            // Do While Ragdolling
            UpdateRagdollValues();
        }
    }
 
    
    // UpdateAimingValues(DeltaSeconds);
    // UpdateLayerValues();
    // UpdateFootIK(DeltaSeconds);
 
}

OnDisableFootIK()

void UALSCharacterAnimInstance::OnDisableFootIK

(

const float

DelayTime

)

OnInjured()

void UALSCharacterAnimInstance::OnInjured	(	const EBodyPartName	BodyPartName,
		const float	InjuredAmount )

OnJumped()

void UALSCharacterAnimInstance::OnJumped

(

)

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::OnJumped);
    InAir.bJumped = true;
    InAir.JumpPlayRate = FMath::GetMappedRangeValueClamped<float, float>({0.0f, 600.0f}, {1.2f, 1.5f}, CharacterInformation.Speed);
 
    GetWorld()->GetTimerManager().SetTimer(OnJumpedTimer, this,
                                      &UALSCharacterAnimInstance::OnJumpedDelay, 0.1f, false);
}

OnJumpedDelay()

void UALSCharacterAnimInstance::OnJumpedDelay ( )

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::OnJumpedDelay);
    InAir.bJumped = false;
}

OnPivot()

void UALSCharacterAnimInstance::OnPivot

(

)

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::OnPivot);
    Grounded.bPivot = CharacterInformation.Speed < Config.TriggerPivotSpeedLimit;
    GetWorld()->GetTimerManager().SetTimer(OnPivotTimer, this,
                                      &UALSCharacterAnimInstance::OnPivotDelay, 0.1f, false);
}

OnPivotDelay()

void UALSCharacterAnimInstance::OnPivotDelay ( )

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::OnPivotDelay);
    Grounded.bPivot = false;
}

PlayDynamicTransition()

void UALSCharacterAnimInstance::PlayDynamicTransition	(	float	ReTriggerDelay,
		FALSDynamicMontageParams	Parameters )

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::PlayDynamicTransition);
    if (bCanPlayDynamicTransition)
    {
        bCanPlayDynamicTransition = false;
 
        // Play Dynamic Additive Transition Animation
        PlayTransition(Parameters);
 
        UWorld* World = GetWorld();
        check(World);
        World->GetTimerManager().SetTimer(PlayDynamicTransitionTimer, this,
                                          &UALSCharacterAnimInstance::PlayDynamicTransitionDelay,
                                          ReTriggerDelay, false);
    }
}

PlayDynamicTransitionDelay()

void UALSCharacterAnimInstance::PlayDynamicTransitionDelay ( )

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::PlayDynamicTransitionDelay);
    bCanPlayDynamicTransition = true;
}

PlayTransition()

void UALSCharacterAnimInstance::PlayTransition

(

const FALSDynamicMontageParams &

Parameters

)

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::PlayTransition);
    PlaySlotAnimationAsDynamicMontage(Parameters.Animation, NAME_Grounded___Slot,
                                      Parameters.BlendInTime, Parameters.BlendOutTime, Parameters.PlayRate, 1,
                                      0.0f, Parameters.StartTime);
}

PlayTransitionChecked()

void UALSCharacterAnimInstance::PlayTransitionChecked

(

const FALSDynamicMontageParams &

Parameters

)

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::PlayTransitionChecked);
    if (Stance.Standing() && !Grounded.bShouldMove)
    {
        PlayTransition(Parameters);
    }
}

ResetIKOffsets()

void UALSCharacterAnimInstance::ResetIKOffsets ( float DeltaSeconds )

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::ResetIKOffsets);
    // Interp Foot IK offsets back to 0
    FootIKValues.FootOffset_L_Location = FMath::VInterpTo(FootIKValues.FootOffset_L_Location,
                                                          FVector::ZeroVector, DeltaSeconds, 15.0f);
    FootIKValues.FootOffset_R_Location = FMath::VInterpTo(FootIKValues.FootOffset_R_Location,
                                                          FVector::ZeroVector, DeltaSeconds, 15.0f);
    FootIKValues.FootOffset_L_Rotation = FMath::RInterpTo(FootIKValues.FootOffset_L_Rotation,
                                                          FRotator::ZeroRotator, DeltaSeconds, 15.0f);
    FootIKValues.FootOffset_R_Rotation = FMath::RInterpTo(FootIKValues.FootOffset_R_Rotation,
                                                          FRotator::ZeroRotator, DeltaSeconds, 15.0f);
}

RotateInPlaceCheck()

void UALSCharacterAnimInstance::RotateInPlaceCheck ( )

private

Grounded

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::RotateInPlaceCheck);
    // Step 1: Check if the character should rotate left or right by checking if the Aiming Angle exceeds the threshold.
    Grounded.bRotateL = AimingValues.AimingAngle.X < RotateInPlace.RotateMinThreshold;
    Grounded.bRotateR = AimingValues.AimingAngle.X > RotateInPlace.RotateMaxThreshold;
 
    // Step 2: If the character should be rotating, set the Rotate Rate to scale with the Aim Yaw Rate.
    // This makes the character rotate faster when moving the camera faster.
    if (Grounded.bRotateL || Grounded.bRotateR)
    {
        Grounded.RotateRate = FMath::GetMappedRangeValueClamped<float, float>(
            {RotateInPlace.AimYawRateMinRange, RotateInPlace.AimYawRateMaxRange},
            {RotateInPlace.MinPlayRate, RotateInPlace.MaxPlayRate},
            CharacterInformation.AimYawRate);
    }
}

SetEssentialInfo()

void UALSCharacterAnimInstance::SetEssentialInfo ( const FALSAnimValues & Value )

overridevirtual

Implements IALSAnimInterface.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations_SetValues);
 
    CharacterInformation.MovementInputAmount = Value.CharacterInfo.MovementInputAmount;
    CharacterInformation.bHasMovementInput = Value.CharacterInfo.bHasMovementInput;
    CharacterInformation.bIsMoving = Value.CharacterInfo.bIsMoving;
    CharacterInformation.Acceleration = Value.CharacterInfo.Acceleration;
    CharacterInformation.AimYawRate = Value.CharacterInfo.AimYawRate;
    CharacterInformation.Speed = Value.CharacterInfo.Speed;
    CharacterInformation.MovementInput = Value.CharacterInfo.MovementInput;
    CharacterInformation.AimingRotation = Value.CharacterInfo.AimingRotation;
    CharacterInformation.CharacterActorRotation = Value.ActorRotation;
    CharacterInformation.PrevMovementState = Value.CharacterInfo.PrevMovementState;
    CharacterInformation.Velocity = Value.CharacterInfo.Velocity;
    // MovementState = Value.MovementState;
    MovementAction = Value.MovementAction;
}

SetFiringWeapon()

void UALSCharacterAnimInstance::SetFiringWeapon ( const bool bValue )

overridevirtual

For Setting the characters blind fire

Implements ICustomAnimInstance.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::SetFiringWeapon);
    bFiringWeapon = bValue;
}

SetFootLocking()

void UALSCharacterAnimInstance::SetFootLocking ( float DeltaSeconds, FName EnableFootIKCurve, FName FootLockCurve, FName IKFootBone, float & CurFootLockAlpha, bool & UseFootLockCurve, FVector & CurFootLockLoc, FRotator & CurFootLockRot ) const

private

Foot IK

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::SetFootLocking);
    if (GetCurveValue(EnableFootIKCurve) <= 0.0f)
    {
        return;
    }
 
    // Step 1: Set Local FootLock Curve value
    float FootLockCurveVal;
 
    if (UseFootLockCurve)
    {
        UseFootLockCurve = FMath::Abs(GetCurveValue(NAME__ALSCharacterAnimInstance__RotationAmount)) <= 0.001f ||
            Character->GetLocalRole() != ROLE_AutonomousProxy;
        FootLockCurveVal = GetCurveValue(FootLockCurve) * (1.f / GetSkelMeshComponent()->AnimUpdateRateParams->UpdateRate);
    }
    else
    {
        UseFootLockCurve = GetCurveValue(FootLockCurve) >= 0.99f;
        FootLockCurveVal = 0.0f;
    }
 
    // Step 2: Only update the FootLock Alpha if the new value is less than the current, or it equals 1. This makes it
    // so that the foot can only blend out of the locked position or lock to a new position, and never blend in.
    if (FootLockCurveVal >= 0.99f || FootLockCurveVal < CurFootLockAlpha)
    {
        CurFootLockAlpha = FootLockCurveVal;
    }
 
    // Step 3: If the Foot Lock curve equals 1, save the new lock location and rotation in component space as the target.
    if (CurFootLockAlpha >= 0.99f)
    {
        const FTransform& OwnerTransform =
            GetOwningComponent()->GetSocketTransform(IKFootBone, RTS_Component);
        CurFootLockLoc = OwnerTransform.GetLocation();
        CurFootLockRot = OwnerTransform.Rotator();
    }
 
    // Step 4: If the Foot Lock Alpha has a weight,
    // update the Foot Lock offsets to keep the foot planted in place while the capsule moves.
    if (CurFootLockAlpha > 0.0f)
    {
        SetFootLockOffsets(DeltaSeconds, CurFootLockLoc, CurFootLockRot);
    }
}

SetFootLockOffsets()

void UALSCharacterAnimInstance::SetFootLockOffsets ( float DeltaSeconds, FVector & LocalLoc, FRotator & LocalRot ) const

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::SetFootLockOffsets);
    DECLARE_SCOPE_CYCLE_COUNTER(TEXT("ALS SetFootLockOffsets"), STAT_ALS_SetFootLockOffsets, STATGROUP_ALS)
 
    FRotator RotationDifference = FRotator::ZeroRotator;
    // Use the delta between the current and last updated rotation to find how much the foot should be rotated
    // to remain planted on the ground.
    if (Character->GetCharacterMovement() != nullptr && Character->GetCharacterMovement()->IsMovingOnGround())
    {
        RotationDifference = CharacterInformation.CharacterActorRotation - Character->GetCharacterMovement()->
            GetLastUpdateRotation();
        RotationDifference.Normalize();
    }
 
    // Get the distance traveled between frames relative to the mesh rotation
    // to find how much the foot should be offset to remain planted on the ground.
    const FVector& LocationDifference = GetOwningComponent()->GetComponentRotation().UnrotateVector(
        CharacterInformation.Velocity * DeltaSeconds);
 
    // Subtract the location difference from the current local location and rotate
    // it by the rotation difference to keep the foot planted in component space.
    LocalLoc = (LocalLoc - LocationDifference).RotateAngleAxis(RotationDifference.Yaw, FVector::DownVector);
 
    // Subtract the Rotation Difference from the current Local Rotation to get the new local rotation.
    FRotator Delta = LocalRot - RotationDifference;
    Delta.Normalize();
    LocalRot = Delta;
}

SetFootOffsets()

void UALSCharacterAnimInstance::SetFootOffsets ( float DeltaSeconds, FName EnableFootIKCurve, FName IKFootBone, FName RootBone, FVector & CurLocationTarget, FVector & CurLocationOffset, FRotator & CurRotationOffset ) const

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::SetFootOffsets);
    DECLARE_SCOPE_CYCLE_COUNTER(TEXT("ALS SetFootOffsets"), STAT_ALS_SetFootOffsets, STATGROUP_ALS)
 
    // Only update Foot IK offset values if the Foot IK curve has a weight. If it equals 0, clear the offset values.
    if (GetCurveValue(EnableFootIKCurve) <= 0)
    {
        CurLocationOffset = FVector::ZeroVector;
        CurRotationOffset = FRotator::ZeroRotator;
        return;
    }
 
    // Step 1: Trace downward from the foot location to find the geometry.
    // If the surface is walkable, save the Impact Location and Normal.
    USkeletalMeshComponent* OwnerComp = GetOwningComponent();
    FVector IKFootFloorLoc = OwnerComp->GetSocketLocation(IKFootBone);
    IKFootFloorLoc.Z = OwnerComp->GetSocketLocation(RootBone).Z;
 
    UWorld* World = GetWorld();
    check(World);
 
    FCollisionQueryParams Params;
    Params.AddIgnoredActor(Character);
 
    const FVector TraceStart = IKFootFloorLoc + FVector(0.0, 0.0, Config.IK_TraceDistanceAboveFoot);
    const FVector TraceEnd = IKFootFloorLoc - FVector(0.0, 0.0, Config.IK_TraceDistanceBelowFoot);
 
    FHitResult HitResult;
    const bool bHit = World->LineTraceSingleByChannel(HitResult,
                                                      TraceStart,
                                                      TraceEnd,
                                                      ECC_Visibility, Params);
 
    if (ALSDebugComponent && ALSDebugComponent->GetShowTraces())
    {
        UALSDebugComponent::DrawDebugLineTraceSingle(
            World,
            TraceStart,
            TraceEnd,
            EDrawDebugTrace::Type::ForOneFrame,
            bHit,
            HitResult,
            FLinearColor::Red,
            FLinearColor::Green,
            5.0f);
    }
 
    FRotator TargetRotOffset = FRotator::ZeroRotator;
    if (Character->GetCharacterMovement() != nullptr && Character->GetCharacterMovement()->IsWalkable(HitResult))
    {
        FVector ImpactPoint = HitResult.ImpactPoint;
        FVector ImpactNormal = HitResult.ImpactNormal;
 
        // Step 1.1: Find the difference in location from the Impact point and the expected (flat) floor location.
        // These values are offset by the normal multiplied by the
        // foot height to get better behavior on angled surfaces.
        CurLocationTarget = (ImpactPoint + ImpactNormal * Config.FootHeight) -
            (IKFootFloorLoc + FVector(0, 0, Config.FootHeight));
 
        // Step 1.2: Calculate the Rotation offset by getting the Atan2 of the Impact Normal.
        TargetRotOffset.Pitch = -FMath::RadiansToDegrees(FMath::Atan2(ImpactNormal.X, ImpactNormal.Z));
        TargetRotOffset.Roll = FMath::RadiansToDegrees(FMath::Atan2(ImpactNormal.Y, ImpactNormal.Z));
    }
 
    // Step 2: Interp the Current Location Offset to the new target value.
    // Interpolate at different speeds based on whether the new target is above or below the current one.
    const float InterpSpeed = CurLocationOffset.Z > CurLocationTarget.Z ? 30.f : 15.0f;
    CurLocationOffset = FMath::VInterpTo(CurLocationOffset, CurLocationTarget, DeltaSeconds, InterpSpeed);
 
    // Step 3: Interp the Current Rotation Offset to the new target value.
    CurRotationOffset = FMath::RInterpTo(CurRotationOffset, TargetRotOffset, DeltaSeconds, 30.0f);
}

SetGait()

void UALSCharacterAnimInstance::SetGait ( const FALSGait & Value )

overridevirtual

Implements IALSAnimInterface.

{
    Gait = Value;
}

SetGroundedEntryState()

void UALSCharacterAnimInstance::SetGroundedEntryState ( EALSGroundedEntryState NewState )

inlineprotected

    {
        GroundedEntryState = NewState;
    }

SetInjured()

void UALSCharacterAnimInstance::SetInjured ( const EBodyPartName BodyPartName, const float InjuredAmount )

overridevirtual

Sets the Injured body part

Implements ICustomAnimInstance.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::SetInjured);
    InjuredBodyPart = BodyPartName;
    InjuredAlpha = InjuredAmount;
    OnInjured(BodyPartName, InjuredAmount);
}

SetMovementState()

void UALSCharacterAnimInstance::SetMovementState ( const FALSMovementState & Value )

overridevirtual

Implements IALSAnimInterface.

{
    MovementState = Value;
}

SetNewGroundedEntryState()

void UALSCharacterAnimInstance::SetNewGroundedEntryState ( const FALSGroundedEntryState & Value )

overridevirtual

Implements IALSAnimInterface.

{
    GroundedEntryState = Value;
}

SetOptimize()

void UALSCharacterAnimInstance::SetOptimize ( const bool bValue )

overridevirtual

Implements IALSAnimInterface.

{
    bOptimize = bValue;
}

SetOverlayOverrideState()

void UALSCharacterAnimInstance::SetOverlayOverrideState ( const int32 Value )

overridevirtual

Implements IALSAnimInterface.

{
    LayerBlendingValues.OverlayOverrideState = Value;
}

SetOverlayState()

void UALSCharacterAnimInstance::SetOverlayState ( const FALSOverlayState & Value )

overridevirtual

Implements IALSAnimInterface.

{
    OverlayState = Value;
}

SetPelvisIKOffset()

void UALSCharacterAnimInstance::SetPelvisIKOffset ( float DeltaSeconds, FVector FootOffsetLTarget, FVector FootOffsetRTarget )

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::SetPelvisIKOffset);
    // Calculate the Pelvis Alpha by finding the average Foot IK weight. If the alpha is 0, clear the offset.
    FootIKValues.PelvisAlpha =
        (GetCurveValue(NAME_Enable_FootIK_L) + GetCurveValue(NAME_Enable_FootIK_R)) / 2.0f;
 
    if (FootIKValues.PelvisAlpha > 0.0f)
    {
        // Step 1: Set the new Pelvis Target to be the lowest Foot Offset
        const FVector PelvisTarget = FootOffsetLTarget.Z < FootOffsetRTarget.Z ? FootOffsetLTarget : FootOffsetRTarget;
 
        // Step 2: Interp the Current Pelvis Offset to the new target value.
        //Interpolate at different speeds based on whether the new target is above or below the current one.
        const float InterpSpeed = PelvisTarget.Z > FootIKValues.PelvisOffset.Z ? 10.0f : 15.0f;
        FootIKValues.PelvisOffset =
            FMath::VInterpTo(FootIKValues.PelvisOffset, PelvisTarget, DeltaSeconds, InterpSpeed);
    }
    else
    {
        FootIKValues.PelvisOffset = FVector::ZeroVector;
    }
}

SetPivotPoint()

void UALSCharacterAnimInstance::SetPivotPoint ( const FTransform & Transform )

overridevirtual

Setting the Pivot Point for the Gun to Rotate Around when Recoiling

Implements ICustomAnimInstance.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::SetPivotPoint);
    PivotPoint = Transform;
}

SetRecoilTransform()

void UALSCharacterAnimInstance::SetRecoilTransform ( const FTransform & Transform )

overridevirtual

Setting The Location and Rotation of the Recoil

Implements ICustomAnimInstance.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::SetRecoilTransform);
    RecoilTransform.SetLocation(Transform.GetLocation());
    RecoilTransform.SetRotation(Transform.GetRotation());
}

SetRotationMode()

void UALSCharacterAnimInstance::SetRotationMode ( const FALSRotationMode Value )

overridevirtual

Implements IALSAnimInterface.

{
    RotationMode = Value;
}

SetStance()

void UALSCharacterAnimInstance::SetStance ( const FALSStance & Value )

overridevirtual

Implements IALSAnimInterface.

{
    Stance = Value;
}

SetTrackedHipsDirection()

void UALSCharacterAnimInstance::SetTrackedHipsDirection ( EALSHipsDirection HipsDirection )

inlineprotected

    {
        Grounded.TrackedHipsDirection = HipsDirection;
    }

SetViewMode()

void UALSCharacterAnimInstance::SetViewMode ( const EALSViewMode Value )

overridevirtual

Implements IALSAnimInterface.

{
    CharacterInformation.ViewMode = Value;
}

ShouldMoveCheck()

bool UALSCharacterAnimInstance::ShouldMoveCheck ( ) const

protected

Enable Movement Animations if IsMoving and HasMovementInput, or if the Speed is greater than 150.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::ShouldMoveCheck);
    return (CharacterInformation.bIsMoving && CharacterInformation.bHasMovementInput) ||
        CharacterInformation.Speed > 150.0f;
}

TurnInPlace()

void UALSCharacterAnimInstance::TurnInPlace ( FRotator TargetRotation, float PlayRateScale, float StartTime, bool OverrideCurrent )

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::TurnInPlace);
    // Step 1: Set Turn Angle
    FRotator Delta = TargetRotation - CharacterInformation.CharacterActorRotation;
    Delta.Normalize();
    const float TurnAngle = Delta.Yaw;
 
    // Step 2: Choose Turn Asset based on the Turn Angle and Stance
    FALSTurnInPlaceAsset TargetTurnAsset;
    if (Stance.Standing())
    {
        if (FMath::Abs(TurnAngle) < TurnInPlaceValues.Turn180Threshold)
        {
            TargetTurnAsset = TurnAngle < 0.0f
                                  ? TurnInPlaceValues.N_TurnIP_L90
                                  : TurnInPlaceValues.N_TurnIP_R90;
        }
        else
        {
            TargetTurnAsset = TurnAngle < 0.0f
                                  ? TurnInPlaceValues.N_TurnIP_L180
                                  : TurnInPlaceValues.N_TurnIP_R180;
        }
    }
    else
    {
        if (FMath::Abs(TurnAngle) < TurnInPlaceValues.Turn180Threshold)
        {
            TargetTurnAsset = TurnAngle < 0.0f
                                  ? TurnInPlaceValues.CLF_TurnIP_L90
                                  : TurnInPlaceValues.CLF_TurnIP_R90;
        }
        else
        {
            TargetTurnAsset = TurnAngle < 0.0f
                                  ? TurnInPlaceValues.CLF_TurnIP_L180
                                  : TurnInPlaceValues.CLF_TurnIP_R180;
        }
    }
 
    // Step 3: If the Target Turn Animation is not playing or set to be overriden, play the turn animation as a dynamic montage.
    if (!OverrideCurrent && IsPlayingSlotAnimation(TargetTurnAsset.Animation, TargetTurnAsset.SlotName))
    {
        return;
    }
    PlaySlotAnimationAsDynamicMontage(TargetTurnAsset.Animation, TargetTurnAsset.SlotName, 0.2f, 0.2f,
                                      TargetTurnAsset.PlayRate * PlayRateScale, 1, 0.0f, StartTime);
 
    // Step 4: Scale the rotation amount (gets scaled in AnimGraph) to compensate for turn angle (If Allowed) and play rate.
    if (TargetTurnAsset.ScaleTurnAngle)
    {
        Grounded.RotationScale = (TurnAngle / TargetTurnAsset.AnimatedAngle) * TargetTurnAsset.PlayRate * PlayRateScale;
    }
    else
    {
        Grounded.RotationScale = TargetTurnAsset.PlayRate * PlayRateScale;
    }
}

TurnInPlaceCheck()

void UALSCharacterAnimInstance::TurnInPlaceCheck ( float DeltaSeconds )

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::TurnInPlaceCheck);
    // Step 1: Check if Aiming angle is outside of the Turn Check Min Angle, and if the Aim Yaw Rate is below the Aim Yaw Rate Limit.
    // If so, begin counting the Elapsed Delay Time. If not, reset the Elapsed Delay Time.
    // This ensures the conditions remain true for a sustained period of time before turning in place.
    if (FMath::Abs(AimingValues.AimingAngle.X) <= TurnInPlaceValues.TurnCheckMinAngle ||
        CharacterInformation.AimYawRate >= TurnInPlaceValues.AimYawRateLimit)
    {
        TurnInPlaceValues.ElapsedDelayTime = 0.0f;
        return;
    }
 
    TurnInPlaceValues.ElapsedDelayTime += DeltaSeconds;
    const float ClampedAimAngle = FMath::GetMappedRangeValueClamped<float, float>({TurnInPlaceValues.TurnCheckMinAngle, 180.0f},
                                                                    {
                                                                        TurnInPlaceValues.MinAngleDelay,
                                                                        TurnInPlaceValues.MaxAngleDelay
                                                                    },
                                                                    AimingValues.AimingAngle.X);
 
    // Step 2: Check if the Elapsed Delay time exceeds the set delay (mapped to the turn angle range). If so, trigger a Turn In Place.
    if (TurnInPlaceValues.ElapsedDelayTime > ClampedAimAngle)
    {
        FRotator TurnInPlaceYawRot = CharacterInformation.AimingRotation;
        TurnInPlaceYawRot.Roll = 0.0f;
        TurnInPlaceYawRot.Pitch = 0.0f;
        TurnInPlace(TurnInPlaceYawRot, 1.0f, 0.0f, false);
    }
}

UpdateAimingValues()

void UALSCharacterAnimInstance::UpdateAimingValues ( float DeltaSeconds )

private

Update Values

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::UpdateAimingValues);
    // Interp the Aiming Rotation value to achieve smooth aiming rotation changes.
    // Interpolating the rotation before calculating the angle ensures the value is not affected by changes
    // in actor rotation, allowing slow aiming rotation changes with fast actor rotation changes.
 
    AimingValues.SmoothedAimingRotation = FMath::RInterpTo(AimingValues.SmoothedAimingRotation,
                                                           CharacterInformation.AimingRotation, DeltaSeconds,
                                                           Config.SmoothedAimingRotationInterpSpeed);
 
    // Calculate the Aiming angle and Smoothed Aiming Angle by getting
    // the delta between the aiming rotation and the actor rotation.
    FRotator Delta = CharacterInformation.AimingRotation - CharacterInformation.CharacterActorRotation;
    Delta.Normalize();
    AimingValues.AimingAngle.X = Delta.Yaw;
    AimingValues.AimingAngle.Y = Delta.Pitch;
 
    Delta = AimingValues.SmoothedAimingRotation - CharacterInformation.CharacterActorRotation;
    Delta.Normalize();
    SmoothedAimingAngle.X = Delta.Yaw;
    SmoothedAimingAngle.Y = Delta.Pitch;
 
    if (!RotationMode.VelocityDirection())
    {
        // Clamp the Aiming Pitch Angle to a range of 1 to 0 for use in the vertical aim sweeps.
        AimingValues.AimSweepTime = FMath::GetMappedRangeValueClamped<float, float>({-90.0f, 90.0f}, {1.0f, 0.0f},
                                                                      AimingValues.AimingAngle.Y);
 
        // Use the Aiming Yaw Angle divided by the number of spine+pelvis bones to get the amount of spine rotation
        // needed to remain facing the camera direction.
        AimingValues.SpineRotation.Roll = 0.0f;
        AimingValues.SpineRotation.Pitch = 0.0f;
        AimingValues.SpineRotation.Yaw = AimingValues.AimingAngle.X / 4.0f;
    }
    else if (CharacterInformation.bHasMovementInput)
    {
        // Get the delta between the Movement Input rotation and Actor rotation and map it to a range of 0-1.
        // This value is used in the aim offset behavior to make the character look toward the Movement Input.
        Delta = CharacterInformation.MovementInput.ToOrientationRotator() - CharacterInformation.CharacterActorRotation;
        Delta.Normalize();
        const float InterpTarget = FMath::GetMappedRangeValueClamped<float, float>({-180.0f, 180.0f}, {0.0f, 1.0f}, Delta.Yaw);
 
        AimingValues.InputYawOffsetTime = FMath::FInterpTo(AimingValues.InputYawOffsetTime, InterpTarget,
                                                           DeltaSeconds, Config.InputYawOffsetInterpSpeed);
    }
 
    // Separate the Aiming Yaw Angle into 3 separate Yaw Times. These 3 values are used in the Aim Offset behavior
    // to improve the blending of the aim offset when rotating completely around the character.
    // This allows you to keep the aiming responsive but still smoothly blend from left to right or right to left.
    AimingValues.LeftYawTime = FMath::GetMappedRangeValueClamped<float, float>({0.0f, 180.0f}, {0.5f, 0.0f},
                                                                 FMath::Abs(SmoothedAimingAngle.X));
    AimingValues.RightYawTime = FMath::GetMappedRangeValueClamped<float, float>({0.0f, 180.0f}, {0.5f, 1.0f},
                                                                  FMath::Abs(SmoothedAimingAngle.X));
    AimingValues.ForwardYawTime = FMath::GetMappedRangeValueClamped<float, float>({-180.0f, 180.0f}, {0.0f, 1.0f},
                                                                    SmoothedAimingAngle.X);
}

UpdateFootIK()

void UALSCharacterAnimInstance::UpdateFootIK ( float DeltaSeconds )

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::UpdateFootIK);
    DECLARE_SCOPE_CYCLE_COUNTER(TEXT("ALS UpdateFootIK"), STAT_ALS_UpdateFootIK, STATGROUP_ALS)
    FVector FootOffsetLTarget = FVector::ZeroVector;
    FVector FootOffsetRTarget = FVector::ZeroVector;
 
    // Update Foot Locking values.
    SetFootLocking(DeltaSeconds, NAME_Enable_FootIK_L, NAME_FootLock_L,
                   IkFootL_BoneName, FootIKValues.FootLock_L_Alpha, FootIKValues.UseFootLockCurve_L,
                   FootIKValues.FootLock_L_Location, FootIKValues.FootLock_L_Rotation);
    SetFootLocking(DeltaSeconds, NAME_Enable_FootIK_R, NAME_FootLock_R,
                   IkFootR_BoneName, FootIKValues.FootLock_R_Alpha, FootIKValues.UseFootLockCurve_R,
                   FootIKValues.FootLock_R_Location, FootIKValues.FootLock_R_Rotation);
 
    if (MovementState.InAir())
    {
        // Reset IK Offsets if In Air
        SetPelvisIKOffset(DeltaSeconds, FVector::ZeroVector, FVector::ZeroVector);
        ResetIKOffsets(DeltaSeconds);
    }
    else if (!MovementState.Ragdoll())
    {
        // Update all Foot Lock and Foot Offset values when not In Air
        SetFootOffsets(DeltaSeconds, NAME_Enable_FootIK_L, IkFootL_BoneName, NAME__ALSCharacterAnimInstance__root,
                       FootOffsetLTarget,
                       FootIKValues.FootOffset_L_Location, FootIKValues.FootOffset_L_Rotation);
        SetFootOffsets(DeltaSeconds, NAME_Enable_FootIK_R, IkFootR_BoneName, NAME__ALSCharacterAnimInstance__root,
                       FootOffsetRTarget,
                       FootIKValues.FootOffset_R_Location, FootIKValues.FootOffset_R_Rotation);
        SetPelvisIKOffset(DeltaSeconds, FootOffsetLTarget, FootOffsetRTarget);
    }
}

UpdateInAirValues()

void UALSCharacterAnimInstance::UpdateInAirValues ( float DeltaSeconds )

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::UpdateInAirValues);
    // Update the fall speed. Setting this value only while in the air allows you to use it within the AnimGraph for the landing strength.
    // If not, the Z velocity would return to 0 on landing.
    InAir.FallSpeed = CharacterInformation.Velocity.Z;
 
    // Set the Land Prediction weight.
    InAir.LandPrediction = CalculateLandPrediction();
 
    // Interp and set the In Air Lean Amount
    const FALSLeanAmount& InAirLeanAmount = CalculateAirLeanAmount();
    LeanAmount.LR = FMath::FInterpTo(LeanAmount.LR, InAirLeanAmount.LR, DeltaSeconds, Config.GroundedLeanInterpSpeed);
    LeanAmount.FB = FMath::FInterpTo(LeanAmount.FB, InAirLeanAmount.FB, DeltaSeconds, Config.GroundedLeanInterpSpeed);
}

UpdateLayerValues()

void UALSCharacterAnimInstance::UpdateLayerValues ( )

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::UpdateLayerValues);
    // Get the Aim Offset weight by getting the opposite of the Aim Offset Mask.
    LayerBlendingValues.EnableAimOffset = FMath::Lerp(1.0f, 0.0f, GetCurveValue(NAME_Mask_AimOffset));
    // Set the Base Pose weights
    LayerBlendingValues.BasePose_N = GetCurveValue(NAME_BasePose_N);
    LayerBlendingValues.BasePose_CLF = GetCurveValue(NAME_BasePose_CLF);
    // Set the Additive amount weights for each body part
    LayerBlendingValues.Spine_Add = GetCurveValue(NAME_Layering_Spine_Add);
    LayerBlendingValues.Head_Add = GetCurveValue(NAME_Layering_Head_Add);
    LayerBlendingValues.Arm_L_Add = GetCurveValue(NAME_Layering_Arm_L_Add);
    LayerBlendingValues.Arm_R_Add = GetCurveValue(NAME_Layering_Arm_R_Add);
    // Set the Hand Override weights
    LayerBlendingValues.Hand_R = GetCurveValue(NAME_Layering_Hand_R);
    LayerBlendingValues.Hand_L = GetCurveValue(NAME_Layering_Hand_L);
    // Blend and set the Hand IK weights to ensure they only are weighted if allowed by the Arm layers.
    LayerBlendingValues.EnableHandIK_L = FMath::Lerp(0.0f, GetCurveValue(NAME_Enable_HandIK_L),
                                                     GetCurveValue(NAME_Layering_Arm_L));
    LayerBlendingValues.EnableHandIK_R = FMath::Lerp(0.0f, GetCurveValue(NAME_Enable_HandIK_R),
                                                     GetCurveValue(NAME_Layering_Arm_R));
    // Set whether the arms should blend in mesh space or local space.
    // The Mesh space weight will always be 1 unless the Local Space (LS) curve is fully weighted.
    LayerBlendingValues.Arm_L_LS = GetCurveValue(NAME_Layering_Arm_L_LS);
    LayerBlendingValues.Arm_L_MS = static_cast<float>(1 - FMath::FloorToInt(LayerBlendingValues.Arm_L_LS));
    LayerBlendingValues.Arm_R_LS = GetCurveValue(NAME_Layering_Arm_R_LS);
    LayerBlendingValues.Arm_R_MS = static_cast<float>(1 - FMath::FloorToInt(LayerBlendingValues.Arm_R_LS));
}

UpdateMovementValues()

void UALSCharacterAnimInstance::UpdateMovementValues ( float DeltaSeconds )

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::UpdateMovementValues);
    // Interp and set the Velocity Blend.
    const FALSVelocityBlend& TargetBlend = CalculateVelocityBlend();
    VelocityBlend.F = FMath::FInterpTo(VelocityBlend.F, TargetBlend.F, DeltaSeconds, Config.VelocityBlendInterpSpeed);
    VelocityBlend.B = FMath::FInterpTo(VelocityBlend.B, TargetBlend.B, DeltaSeconds, Config.VelocityBlendInterpSpeed);
    VelocityBlend.L = FMath::FInterpTo(VelocityBlend.L, TargetBlend.L, DeltaSeconds, Config.VelocityBlendInterpSpeed);
    VelocityBlend.R = FMath::FInterpTo(VelocityBlend.R, TargetBlend.R, DeltaSeconds, Config.VelocityBlendInterpSpeed);
 
    // Set the Diagonal Scale Amount.
    Grounded.DiagonalScaleAmount = CalculateDiagonalScaleAmount();
 
    // Set the Relative Acceleration Amount and Interp the Lean Amount.
    RelativeAccelerationAmount = CalculateRelativeAccelerationAmount();
    LeanAmount.LR = FMath::FInterpTo(LeanAmount.LR, RelativeAccelerationAmount.Y, DeltaSeconds,
                                     Config.GroundedLeanInterpSpeed);
    LeanAmount.FB = FMath::FInterpTo(LeanAmount.FB, RelativeAccelerationAmount.X, DeltaSeconds,
                                     Config.GroundedLeanInterpSpeed);
 
    // Set the Walk Run Blend
    Grounded.WalkRunBlend = CalculateWalkRunBlend();
 
    // Set the Stride Blend
    Grounded.StrideBlend = CalculateStrideBlend();
 
    // Set the Standing and Crouching Play Rates
    Grounded.StandingPlayRate = CalculateStandingPlayRate();
    Grounded.CrouchingPlayRate = CalculateCrouchingPlayRate();
}

UpdateRagdollValues()

void UALSCharacterAnimInstance::UpdateRagdollValues ( )

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::UpdateRagdollValues);
    // Scale the Flail Rate by the velocity length. The faster the ragdoll moves, the faster the character will flail.
    const float VelocityLength = GetOwningComponent()->GetPhysicsLinearVelocity(NAME__ALSCharacterAnimInstance__root).Size();
    FlailRate = FMath::GetMappedRangeValueClamped<float, float>({0.0f, 1000.0f}, {0.0f, 1.0f}, VelocityLength);
}

UpdateRotationValues()

void UALSCharacterAnimInstance::UpdateRotationValues ( )

private

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Animations);
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterAnimInstance::UpdateRotationValues);
    // Set the Movement Direction
    MovementDirection = CalculateMovementDirection();
 
    // Set the Yaw Offsets. These values influence the "YawOffset" curve in the AnimGraph and are used to offset
    // the characters rotation for more natural movement. The curves allow for fine control over how the offset
    // behaves for each movement direction.
    FRotator Delta = CharacterInformation.Velocity.ToOrientationRotator() - CharacterInformation.AimingRotation;
    Delta.Normalize();
    const FVector& FBOffset = YawOffset_FB->GetVectorValue(Delta.Yaw);
    Grounded.FYaw = FBOffset.X;
    Grounded.BYaw = FBOffset.Y;
    const FVector& LROffset = YawOffset_LR->GetVectorValue(Delta.Yaw);
    Grounded.LYaw = LROffset.X;
    Grounded.RYaw = LROffset.Y;
}

UPROPERTY() [1/9]

UALSCharacterAnimInstance::UPROPERTY	(	EditDefaultsOnly	,
		BlueprintReadOnly	,
		Category	= "Configuration|Main Configuration",
		Meta	= (ShowOnlyInnerProperties) )

Configuration

UPROPERTY() [2/9]

UALSCharacterAnimInstance::UPROPERTY	(	EditDefaultsOnly	,
		BlueprintReadOnly	,
		Category	= "Configuration|Rotate In Place",
		Meta	= (ShowOnlyInnerProperties) )

Rotate In Place

UPROPERTY() [3/9]

UALSCharacterAnimInstance::UPROPERTY	(	EditDefaultsOnly	,
		BlueprintReadOnly	,
		Category	= "Configuration|Turn In Place",
		Meta	= (ShowOnlyInnerProperties) )

Turn In Place

UPROPERTY() [4/9]

UALSCharacterAnimInstance::UPROPERTY	(	VisibleDefaultsOnly	,
		BlueprintReadOnly	,
		Category	= "Read Only Data|Anim Graph - Aiming Values",
		Meta	= (ShowOnlyInnerProperties) )

Anim Graph - Aiming Values

UPROPERTY() [5/9]

UALSCharacterAnimInstance::UPROPERTY	(	VisibleDefaultsOnly	,
		BlueprintReadOnly	,
		Category	= "Read Only Data|Anim Graph - Foot IK",
		Meta	= (ShowOnlyInnerProperties) )

Anim Graph - Foot IK

UPROPERTY() [6/9]

UALSCharacterAnimInstance::UPROPERTY	(	VisibleDefaultsOnly	,
		BlueprintReadOnly	,
		Category	= "Read Only Data|Anim Graph - Grounded",
		Meta	= (ShowOnlyInnerProperties) )

Anim Graph - Grounded

UPROPERTY() [7/9]

UALSCharacterAnimInstance::UPROPERTY	(	VisibleDefaultsOnly	,
		BlueprintReadOnly	,
		Category	= "Read Only Data|Anim Graph - In Air",
		Meta	= (ShowOnlyInnerProperties) )

Anim Graph - In Air

UPROPERTY() [8/9]

UALSCharacterAnimInstance::UPROPERTY	(	VisibleDefaultsOnly	,
		BlueprintReadOnly	,
		Category	= "Read Only Data|Anim Graph - Layer Blending",
		Meta	= (ShowOnlyInnerProperties) )

Anim Graph - Layer Blending

UPROPERTY() [9/9]

UALSCharacterAnimInstance::UPROPERTY	(	VisibleDefaultsOnly	,
		BlueprintReadOnly	,
		Category	= "Read Only Data|Character Information",
		Meta	= (ShowOnlyInnerProperties) )

Character Information

Member Data Documentation

ALSDebugComponent

TObjectPtr<UALSDebugComponent> UALSCharacterAnimInstance::ALSDebugComponent = nullptr

private

bCanPlayDynamicTransition

bool UALSCharacterAnimInstance::bCanPlayDynamicTransition = true

private

bFiringWeapon

bool UALSCharacterAnimInstance::bFiringWeapon = false

bOptimize

bool UALSCharacterAnimInstance::bOptimize = false

Character

TObjectPtr<AALSBaseCharacter> UALSCharacterAnimInstance::Character = nullptr

References

DiagonalScaleAmountCurve

TObjectPtr<UCurveFloat> UALSCharacterAnimInstance::DiagonalScaleAmountCurve = nullptr

Blend Curves

FlailRate

float UALSCharacterAnimInstance::FlailRate = 0.0f

Anim Graph - Ragdoll

Gait

FALSGait UALSCharacterAnimInstance::Gait = EALSGait::Walking

GroundedEntryState

FALSGroundedEntryState UALSCharacterAnimInstance::GroundedEntryState = EALSGroundedEntryState::None

GunOffset

FVector UALSCharacterAnimInstance::GunOffset = FVector::ZeroVector

IkFootL_BoneName

FName UALSCharacterAnimInstance::IkFootL_BoneName = FName(TEXT("ik_foot_l"))

IK Bone Names

IkFootR_BoneName

FName UALSCharacterAnimInstance::IkFootR_BoneName = FName(TEXT("ik_foot_r"))

InjuredAlpha

float UALSCharacterAnimInstance::InjuredAlpha = 0.0f

InjuredBodyPart

EBodyPartName UALSCharacterAnimInstance::InjuredBodyPart = EBodyPartName::Pelvis

LandPredictionCurve

TObjectPtr<UCurveFloat> UALSCharacterAnimInstance::LandPredictionCurve = nullptr

LeanAmount

FALSLeanAmount UALSCharacterAnimInstance::LeanAmount

LeanInAirCurve

TObjectPtr<UCurveFloat> UALSCharacterAnimInstance::LeanInAirCurve = nullptr

MovementAction

FALSMovementAction UALSCharacterAnimInstance::MovementAction = EALSMovementAction::None

MovementDirection

FALSMovementDirection UALSCharacterAnimInstance::MovementDirection = EALSMovementDirection::Forward

MovementState

FALSMovementState UALSCharacterAnimInstance::MovementState = EALSMovementState::None

OnJumpedTimer

FTimerHandle UALSCharacterAnimInstance::OnJumpedTimer

private

OnPivotTimer

FTimerHandle UALSCharacterAnimInstance::OnPivotTimer

private

OverlayState

FALSOverlayState UALSCharacterAnimInstance::OverlayState = EALSOverlayState::Default

PivotPoint

FTransform UALSCharacterAnimInstance::PivotPoint

PlayDynamicTransitionTimer

FTimerHandle UALSCharacterAnimInstance::PlayDynamicTransitionTimer

private

RecoilTransform

FTransform UALSCharacterAnimInstance::RecoilTransform

RelativeAccelerationAmount

FVector UALSCharacterAnimInstance::RelativeAccelerationAmount = FVector::ZeroVector

RotationMode

FALSRotationMode UALSCharacterAnimInstance::RotationMode = EALSRotationMode::VelocityDirection

SmoothedAimingAngle

FVector2D UALSCharacterAnimInstance::SmoothedAimingAngle = FVector2D::ZeroVector

Stance

FALSStance UALSCharacterAnimInstance::Stance = EALSStance::Standing

StrideBlend_C_Walk

TObjectPtr<UCurveFloat> UALSCharacterAnimInstance::StrideBlend_C_Walk = nullptr

StrideBlend_N_Run

TObjectPtr<UCurveFloat> UALSCharacterAnimInstance::StrideBlend_N_Run = nullptr

StrideBlend_N_Walk

TObjectPtr<UCurveFloat> UALSCharacterAnimInstance::StrideBlend_N_Walk = nullptr

TransitionAnim_L

TObjectPtr<UAnimSequenceBase> UALSCharacterAnimInstance::TransitionAnim_L = nullptr

TransitionAnim_R

TObjectPtr<UAnimSequenceBase> UALSCharacterAnimInstance::TransitionAnim_R = nullptr

VelocityBlend

FALSVelocityBlend UALSCharacterAnimInstance::VelocityBlend

YawOffset_FB

TObjectPtr<UCurveVector> UALSCharacterAnimInstance::YawOffset_FB = nullptr

YawOffset_LR

TObjectPtr<UCurveVector> UALSCharacterAnimInstance::YawOffset_LR = nullptr

---

The documentation for this class was generated from the following files:

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/ALS-Community-main/Source/ALSV4_CPP/Public/Character/Animation/ALSCharacterAnimInstance.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/ALS-Community-main/Source/ALSV4_CPP/Private/Character/Animation/ALSCharacterAnimInstance.cpp