RootMotionSource.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "HAL/IConsoleManager.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Class.h"
#include "Engine/NetSerialization.h"
#include "Animation/AnimationAsset.h"
#include "RootMotionSource.generated.h"
 
class ACharacter;
class UCharacterMovementComponent;
class UCurveFloat;
class UCurveVector;
 
#define ROOT_MOTION_DEBUG (1 && !(UE_BUILD_SHIPPING || UE_BUILD_TEST))
 
#if ROOT_MOTION_DEBUG
struct RootMotionSourceDebug
{
    static ENGINE_API TAutoConsoleVariable<int32> CVarDebugRootMotionSources;
    static ENGINE_API void PrintOnScreen(const ACharacter& InCharacter, const FString& InString);
    static ENGINE_API void PrintOnScreenServerMsg(const FString& InString);
};
#endif
 
UENUM()
enum class ERootMotionAccumulateMode : uint8
{
    // Sets velocity to this value directly
    Override    = 0, 
    // Gets added on top of existing velocity
    Additive    = 1
};
 
UENUM()
enum class ERootMotionSourceStatusFlags : uint8
{
    // Source has been Prepared and can contribute to root motion 
    Prepared                    = 0x01,
    // Source has timed out or otherwise reached a state where it is considered "done"
    Finished                    = 0x02,
    // Source has been queued for removal, will be removed next PrepareRootMotion() by the SourceGroup
    MarkedForRemoval            = 0x04
};
 
UENUM()
enum class ERootMotionSourceSettingsFlags : uint8
{
    // Source will switch character to Falling mode with any "Z up" velocity added.
    // Use this for jump-like root motion. If not enabled, uses default jump impulse
    // detection (which keeps you stuck on ground in Walking fairly strongly)
    UseSensitiveLiftoffCheck    = 0x01,
    // If Duration of Source would end partway through the last tick it is active,
    // do not reduce SimulationTime. Disabling this is useful for sources that
    // are more about providing velocity (like jumps), vs. sources that need
    // the precision of partial ticks for say ending up at an exact location (MoveTo)
    DisablePartialEndTick       = 0x02,
    // Whether to ignore impact to Z when accumulating output to Velocity
    // Setting this flag on override sources provides the same behavior as
    // animation root motion
    IgnoreZAccumulate           = 0x04
 
};
 
enum class ERootMotionSourceID : uint16 { Invalid = 0 };
 
struct FRootMotionServerToLocalIDMapping
{
    ENGINE_API FRootMotionServerToLocalIDMapping();
 
    uint16 ServerID; // ID of root motion source on server
    uint16 LocalID; // ID of root motion source on local client
    float TimeStamp; // Last time this ID mapping was updated/still valid
 
    // Given CurrentTimeStamp, returns whether this mapping is still valid (has expired yet)
    ENGINE_API bool IsStillValid(float CurrentTimeStamp);
};
 
USTRUCT()
struct FRootMotionSourceStatus
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    uint8 Flags;
 
    ENGINE_API FRootMotionSourceStatus();
 
    ENGINE_API void Clear();
 
    ENGINE_API void SetFlag(ERootMotionSourceStatusFlags Flag);
    ENGINE_API void UnSetFlag(ERootMotionSourceStatusFlags Flag);
    ENGINE_API bool HasFlag(ERootMotionSourceStatusFlags Flag) const;
};
 
USTRUCT()
struct FRootMotionSourceSettings
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    uint8 Flags;
 
    ENGINE_API FRootMotionSourceSettings();
 
    ENGINE_API void Clear();
 
    ENGINE_API void SetFlag(ERootMotionSourceSettingsFlags Flag);
    ENGINE_API void UnSetFlag(ERootMotionSourceSettingsFlags Flag);
    ENGINE_API bool HasFlag(ERootMotionSourceSettingsFlags Flag) const;
 
    // Accumulate settings with one another
    ENGINE_API FRootMotionSourceSettings& operator+=(const FRootMotionSourceSettings& Other);
};
 
UENUM()
enum class ERootMotionFinishVelocityMode : uint8
{
    // Maintain the last velocity root motion gave to the character
    MaintainLastRootMotionVelocity = 0,
    // Set Velocity to the specified value (for example, 0,0,0 to stop the character)
    SetVelocity,
    // Clamp velocity magnitude to the specified value. Note that it will not clamp Z if negative (falling). it will clamp Z positive though. 
    ClampVelocity,
};
 
USTRUCT()
struct FRootMotionFinishVelocitySettings
{
    GENERATED_USTRUCT_BODY()
 
    // Mode, see ERootMotionFinishVelocityMode
    UPROPERTY()
    ERootMotionFinishVelocityMode Mode;
 
    // Clamp Velocity if Move == ClampVelocity
    UPROPERTY()
    float ClampVelocity;
 
    // Set Velocity if Mode == SetVelocity
    UPROPERTY()
    FVector SetVelocity;
 
    FRootMotionFinishVelocitySettings()
        : Mode(ERootMotionFinishVelocityMode::MaintainLastRootMotionVelocity)
        , ClampVelocity(0.f)
        , SetVelocity(FVector::ZeroVector)
    {}
};
 
// Hacky base class to avoid 8 bytes of padding after the vtable
struct FRootMotionSourceFixLayout
{
    virtual ~FRootMotionSourceFixLayout() = default;
};
 
USTRUCT()
struct FRootMotionSource
#if CPP
    : public FRootMotionSourceFixLayout
#endif
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    uint16 Priority;
 
    UPROPERTY()
    uint16 LocalID;
 
    UPROPERTY()
    FName InstanceName;
 
    UPROPERTY(NotReplicated)
    float StartTime;
 
    UPROPERTY()
    float CurrentTime;
 
    UPROPERTY(NotReplicated)
    float PreviousTime;
 
    UPROPERTY()
    float Duration;
 
    UPROPERTY()
    FRootMotionSourceStatus Status;
 
    UPROPERTY(NotReplicated)
    FRootMotionSourceSettings Settings;
 
    UPROPERTY()
    ERootMotionAccumulateMode AccumulateMode;
 
    UPROPERTY()
    bool bInLocalSpace;
 
    bool bNeedsSimulatedCatchup;
 
    bool bSimulatedNeedsSmoothing;
 
    UPROPERTY(NotReplicated)
    FRootMotionMovementParams RootMotionParams;
 
    UPROPERTY(NotReplicated)
    FRootMotionFinishVelocitySettings FinishVelocityParams;
 
    ENGINE_API FRootMotionSource();
 
    virtual ~FRootMotionSource() {}
 
    ENGINE_API float GetTime() const;
 
    ENGINE_API float GetStartTime() const;
 
    ENGINE_API bool IsStartTimeValid() const;
 
    ENGINE_API float GetDuration() const;
 
    ENGINE_API virtual bool IsTimeOutEnabled() const;
 
    ENGINE_API virtual FRootMotionSource* Clone() const;
 
    ENGINE_API virtual bool Matches(const FRootMotionSource* Other) const;
 
    ENGINE_API virtual bool MatchesAndHasSameState(const FRootMotionSource* Other) const;
 
    ENGINE_API virtual bool UpdateStateFrom(const FRootMotionSource* SourceToTakeStateFrom, bool bMarkForSimulatedCatchup = false);
 
    ENGINE_API virtual bool IsActive() const;
 
    ENGINE_API virtual void SetTime(float NewTime);
 
    ENGINE_API virtual void CheckTimeOut();
 
    ENGINE_API virtual void PrepareRootMotion(
        float SimulationTime,
        float MovementTickTime,
        const ACharacter& Character, 
        const UCharacterMovementComponent& MoveComponent
        );
 
    ENGINE_API virtual bool NetSerialize(FArchive& Ar, UPackageMap* Map, bool& bOutSuccess);
 
    ENGINE_API virtual UScriptStruct* GetScriptStruct() const;
 
    ENGINE_API virtual FString ToSimpleString() const;
 
    virtual void AddReferencedObjects(class FReferenceCollector& Collector) {}
};
 
template<>
struct TStructOpsTypeTraits< FRootMotionSource > : public TStructOpsTypeTraitsBase2< FRootMotionSource >
{
    enum
    {
        WithNetSerializer = true,
        WithCopy = true
    };
};
 
USTRUCT()
struct FRootMotionSource_ConstantForce : public FRootMotionSource
{
    GENERATED_USTRUCT_BODY()
 
    ENGINE_API FRootMotionSource_ConstantForce();
 
    virtual ~FRootMotionSource_ConstantForce() {}
 
    UPROPERTY()
    FVector Force;
 
    UPROPERTY()
    TObjectPtr<UCurveFloat> StrengthOverTime;
 
    ENGINE_API virtual FRootMotionSource* Clone() const override;
 
    ENGINE_API virtual bool Matches(const FRootMotionSource* Other) const override;
 
    ENGINE_API virtual bool MatchesAndHasSameState(const FRootMotionSource* Other) const override;
 
    ENGINE_API virtual bool UpdateStateFrom(const FRootMotionSource* SourceToTakeStateFrom, bool bMarkForSimulatedCatchup = false) override;
 
    ENGINE_API virtual void PrepareRootMotion(
        float SimulationTime, 
        float MovementTickTime,
        const ACharacter& Character, 
        const UCharacterMovementComponent& MoveComponent
        ) override;
 
    ENGINE_API virtual bool NetSerialize(FArchive& Ar, UPackageMap* Map, bool& bOutSuccess) override;
 
    ENGINE_API virtual UScriptStruct* GetScriptStruct() const override;
 
    ENGINE_API virtual FString ToSimpleString() const override;
 
    ENGINE_API virtual void AddReferencedObjects(class FReferenceCollector& Collector) override;
};
 
template<>
struct TStructOpsTypeTraits< FRootMotionSource_ConstantForce > : public TStructOpsTypeTraitsBase2< FRootMotionSource_ConstantForce >
{
    enum
    {
        WithNetSerializer = true,
        WithCopy = true
    };
};
 
 
USTRUCT()
struct FRootMotionSource_RadialForce : public FRootMotionSource
{
    GENERATED_USTRUCT_BODY()
 
    ENGINE_API FRootMotionSource_RadialForce();
 
    virtual ~FRootMotionSource_RadialForce() {}
 
    UPROPERTY()
    FVector Location;
 
    UPROPERTY()
    TObjectPtr<AActor> LocationActor;
 
    UPROPERTY()
    float Radius;
 
    UPROPERTY()
    float Strength;
 
    UPROPERTY()
    bool bIsPush;
 
    UPROPERTY()
    bool bNoZForce;
 
    UPROPERTY()
    TObjectPtr<UCurveFloat> StrengthDistanceFalloff;
 
    UPROPERTY()
    TObjectPtr<UCurveFloat> StrengthOverTime;
 
    UPROPERTY()
    bool bUseFixedWorldDirection;
 
    UPROPERTY()
    FRotator FixedWorldDirection;
 
    ENGINE_API virtual FRootMotionSource* Clone() const override;
 
    ENGINE_API virtual bool Matches(const FRootMotionSource* Other) const override;
 
    ENGINE_API virtual bool MatchesAndHasSameState(const FRootMotionSource* Other) const override;
 
    ENGINE_API virtual bool UpdateStateFrom(const FRootMotionSource* SourceToTakeStateFrom, bool bMarkForSimulatedCatchup = false) override;
 
    ENGINE_API virtual void PrepareRootMotion(
        float SimulationTime, 
        float MovementTickTime,
        const ACharacter& Character, 
        const UCharacterMovementComponent& MoveComponent
        ) override;
 
    ENGINE_API virtual bool NetSerialize(FArchive& Ar, UPackageMap* Map, bool& bOutSuccess) override;
 
    ENGINE_API virtual UScriptStruct* GetScriptStruct() const override;
 
    ENGINE_API virtual FString ToSimpleString() const override;
 
    ENGINE_API virtual void AddReferencedObjects(class FReferenceCollector& Collector) override;
};
 
template<>
struct TStructOpsTypeTraits< FRootMotionSource_RadialForce > : public TStructOpsTypeTraitsBase2< FRootMotionSource_RadialForce >
{
    enum
    {
        WithNetSerializer = true,
        WithCopy = true
    };
};
 
 
USTRUCT()
struct FRootMotionSource_MoveToForce : public FRootMotionSource
{
    GENERATED_USTRUCT_BODY()
 
    ENGINE_API FRootMotionSource_MoveToForce();
 
    virtual ~FRootMotionSource_MoveToForce() {}
 
    UPROPERTY()
    FVector StartLocation;
 
    UPROPERTY()
    FVector TargetLocation;
 
    UPROPERTY()
    bool bRestrictSpeedToExpected;
 
    UPROPERTY()
    TObjectPtr<UCurveVector> PathOffsetCurve;
 
    ENGINE_API FVector GetPathOffsetInWorldSpace(const float MoveFraction) const;
 
    ENGINE_API virtual FRootMotionSource* Clone() const override;
 
    ENGINE_API virtual bool Matches(const FRootMotionSource* Other) const override;
 
    ENGINE_API virtual bool MatchesAndHasSameState(const FRootMotionSource* Other) const override;
 
    ENGINE_API virtual bool UpdateStateFrom(const FRootMotionSource* SourceToTakeStateFrom, bool bMarkForSimulatedCatchup = false) override;
 
    ENGINE_API virtual void SetTime(float NewTime) override;
 
    ENGINE_API virtual void PrepareRootMotion(
        float SimulationTime, 
        float MovementTickTime,
        const ACharacter& Character, 
        const UCharacterMovementComponent& MoveComponent
        ) override;
 
    ENGINE_API virtual bool NetSerialize(FArchive& Ar, UPackageMap* Map, bool& bOutSuccess) override;
 
    ENGINE_API virtual UScriptStruct* GetScriptStruct() const override;
 
    ENGINE_API virtual FString ToSimpleString() const override;
 
    ENGINE_API virtual void AddReferencedObjects(class FReferenceCollector& Collector) override;
};
 
template<>
struct TStructOpsTypeTraits< FRootMotionSource_MoveToForce > : public TStructOpsTypeTraitsBase2< FRootMotionSource_MoveToForce >
{
    enum
    {
        WithNetSerializer = true,
        WithCopy = true
    };
};
 
 
USTRUCT()
struct FRootMotionSource_MoveToDynamicForce : public FRootMotionSource
{
    GENERATED_USTRUCT_BODY()
 
    ENGINE_API FRootMotionSource_MoveToDynamicForce();
 
    virtual ~FRootMotionSource_MoveToDynamicForce() {}
 
    UPROPERTY()
    FVector StartLocation;
 
    UPROPERTY()
    FVector InitialTargetLocation;
 
    // Dynamically-changing location of target, which may be altered while this movement is ongoing 
    UPROPERTY()
    FVector TargetLocation;
 
    UPROPERTY()
    bool bRestrictSpeedToExpected;
 
    UPROPERTY()
    TObjectPtr<UCurveVector> PathOffsetCurve;
 
    UPROPERTY()
    TObjectPtr<UCurveFloat> TimeMappingCurve;
 
    ENGINE_API void SetTargetLocation(FVector NewTargetLocation);
 
    ENGINE_API FVector GetPathOffsetInWorldSpace(const float MoveFraction) const;
 
    ENGINE_API virtual FRootMotionSource* Clone() const override;
 
    ENGINE_API virtual bool Matches(const FRootMotionSource* Other) const override;
 
    ENGINE_API virtual bool MatchesAndHasSameState(const FRootMotionSource* Other) const override;
 
    ENGINE_API virtual bool UpdateStateFrom(const FRootMotionSource* SourceToTakeStateFrom, bool bMarkForSimulatedCatchup = false) override;
 
    ENGINE_API virtual void SetTime(float NewTime) override;
 
    ENGINE_API virtual void PrepareRootMotion(
        float SimulationTime, 
        float MovementTickTime,
        const ACharacter& Character, 
        const UCharacterMovementComponent& MoveComponent
        ) override;
 
    ENGINE_API virtual bool NetSerialize(FArchive& Ar, UPackageMap* Map, bool& bOutSuccess) override;
 
    ENGINE_API virtual UScriptStruct* GetScriptStruct() const override;
 
    ENGINE_API virtual FString ToSimpleString() const override;
 
    ENGINE_API virtual void AddReferencedObjects(class FReferenceCollector& Collector) override;
};
 
template<>
struct TStructOpsTypeTraits< FRootMotionSource_MoveToDynamicForce > : public TStructOpsTypeTraitsBase2< FRootMotionSource_MoveToDynamicForce >
{
    enum
    {
        WithNetSerializer = true,
        WithCopy = true
    };
};
 
 
USTRUCT()
struct FRootMotionSource_JumpForce : public FRootMotionSource
{
    GENERATED_USTRUCT_BODY()
 
    ENGINE_API FRootMotionSource_JumpForce();
 
    virtual ~FRootMotionSource_JumpForce() {}
 
    UPROPERTY()
    FRotator Rotation;
 
    UPROPERTY()
    float Distance;
 
    UPROPERTY()
    float Height;
 
    UPROPERTY()
    bool bDisableTimeout;
 
    UPROPERTY()
    TObjectPtr<UCurveVector> PathOffsetCurve;
 
    UPROPERTY()
    TObjectPtr<UCurveFloat> TimeMappingCurve;
 
    FVector SavedHalfwayLocation;
 
    ENGINE_API FVector GetPathOffset(float MoveFraction) const;
 
    ENGINE_API FVector GetRelativeLocation(float MoveFraction) const;
 
    ENGINE_API virtual bool IsTimeOutEnabled() const override;
 
    ENGINE_API virtual FRootMotionSource* Clone() const override;
 
    ENGINE_API virtual bool Matches(const FRootMotionSource* Other) const override;
 
    ENGINE_API virtual bool MatchesAndHasSameState(const FRootMotionSource* Other) const override;
 
    ENGINE_API virtual bool UpdateStateFrom(const FRootMotionSource* SourceToTakeStateFrom, bool bMarkForSimulatedCatchup = false) override;
 
    ENGINE_API virtual void PrepareRootMotion(
        float SimulationTime, 
        float MovementTickTime,
        const ACharacter& Character, 
        const UCharacterMovementComponent& MoveComponent
        ) override;
 
    ENGINE_API virtual bool NetSerialize(FArchive& Ar, UPackageMap* Map, bool& bOutSuccess) override;
 
    ENGINE_API virtual UScriptStruct* GetScriptStruct() const override;
 
    ENGINE_API virtual FString ToSimpleString() const override;
 
    ENGINE_API virtual void AddReferencedObjects(class FReferenceCollector& Collector) override;
};
 
template<>
struct TStructOpsTypeTraits< FRootMotionSource_JumpForce > : public TStructOpsTypeTraitsBase2< FRootMotionSource_JumpForce >
{
    enum
    {
        WithNetSerializer = true,
        WithCopy = true
    };
};
 
USTRUCT()
struct FRootMotionSourceGroup
{
    GENERATED_USTRUCT_BODY()
 
    ENGINE_API FRootMotionSourceGroup();
 
    virtual ~FRootMotionSourceGroup() {}
 
    TArray< TSharedPtr<FRootMotionSource> > RootMotionSources;
 
    TArray< TSharedPtr<FRootMotionSource> > PendingAddRootMotionSources;
 
    UPROPERTY()
    uint8 bHasAdditiveSources:1;
 
    UPROPERTY()
    uint8 bHasOverrideSources:1;
 
    UPROPERTY()
    uint8 bHasOverrideSourcesWithIgnoreZAccumulate:1;
 
    UPROPERTY()
    uint8 bIsAdditiveVelocityApplied:1;
 
    UPROPERTY()
    FRootMotionSourceSettings LastAccumulatedSettings;
 
    UPROPERTY()
    FVector_NetQuantize10 LastPreAdditiveVelocity;
 
    ENGINE_API void CleanUpInvalidRootMotion(float DeltaTime, const ACharacter& Character, UCharacterMovementComponent& MoveComponent);
 
    ENGINE_API void PrepareRootMotion(float DeltaTime, const ACharacter& Character, const UCharacterMovementComponent& InMoveComponent, bool bForcePrepareAll = false);
 
    ENGINE_API void AccumulateOverrideRootMotionVelocity(float DeltaTime, const ACharacter& Character, const UCharacterMovementComponent& MoveComponent, FVector& InOutVelocity) const;
 
    ENGINE_API void AccumulateAdditiveRootMotionVelocity(float DeltaTime, const ACharacter& Character, const UCharacterMovementComponent& MoveComponent, FVector& InOutVelocity) const;
 
    ENGINE_API bool GetOverrideRootMotionRotation(float DeltaTime, const ACharacter& Character, const UCharacterMovementComponent& MoveComponent, FQuat& OutRotation) const;
 
    ENGINE_API bool NeedsSimulatedSmoothing() const;
 
    ENGINE_API void SetPendingRootMotionSourceMinStartTimes(float NewStartTime);
 
    ENGINE_API void ApplyTimeStampReset(float DeltaTime);
 
    ENGINE_API bool HasOverrideVelocity() const;
 
    ENGINE_API bool HasOverrideVelocityWithIgnoreZAccumulate() const;
 
    ENGINE_API bool HasAdditiveVelocity() const;
 
    ENGINE_API bool HasVelocity() const;
 
    ENGINE_API bool HasActiveRootMotionSources() const;
 
    ENGINE_API bool HasRootMotionToApply() const;
 
    ENGINE_API uint16 ApplyRootMotionSource(TSharedPtr<FRootMotionSource> SourcePtr);
 
    ENGINE_API TSharedPtr<FRootMotionSource> GetRootMotionSource(FName InstanceName);
 
    ENGINE_API TSharedPtr<FRootMotionSource> GetRootMotionSourceByID(uint16 RootMotionSourceID);
 
    ENGINE_API void RemoveRootMotionSource(FName InstanceName);
 
    ENGINE_API void RemoveRootMotionSourceByID(uint16 RootMotionSourceID);
 
    ENGINE_API void UpdateStateFrom(const FRootMotionSourceGroup& GroupToTakeStateFrom, bool bMarkForSimulatedCatchup = false);
 
    ENGINE_API bool NetSerialize(FArchive& Ar, class UPackageMap* Map, bool& bOutSuccess, uint8 MaxNumRootMotionSourcesToSerialize = MAX_uint8);
 
    ENGINE_API void Clear();
 
    ENGINE_API void CullInvalidSources();
 
    ENGINE_API FRootMotionSourceGroup& operator=(const FRootMotionSourceGroup& Other);
 
    ENGINE_API bool operator==(const FRootMotionSourceGroup& Other) const;
 
    ENGINE_API bool operator!=(const FRootMotionSourceGroup& Other) const;
 
    ENGINE_API void AddStructReferencedObjects(FReferenceCollector& Collector) const;
 
protected:
 
    ENGINE_API void AccumulateRootMotionVelocity(ERootMotionAccumulateMode RootMotionType, float DeltaTime, const ACharacter& Character, const UCharacterMovementComponent& MoveComponent, FVector& InOutVelocity) const;
 
    ENGINE_API void AccumulateRootMotionVelocityFromSource(const FRootMotionSource& RootMotionSource, float DeltaTime, const ACharacter& Character, const UCharacterMovementComponent& MoveComponent, FVector& InOutVelocity) const;
 
    static ENGINE_API void NetSerializeRMSArray(FArchive& Ar, class UPackageMap* Map, bool& bOutSuccess, TArray< TSharedPtr<FRootMotionSource> >& RootMotionSourceArray, uint8 MaxNumRootMotionSourcesToSerialize = MAX_uint8);
 
};
 
template<>
struct TStructOpsTypeTraits<FRootMotionSourceGroup> : public TStructOpsTypeTraitsBase2<FRootMotionSourceGroup>
{
    enum
    {
        WithCopy = true,        // Necessary so that TSharedPtr<FRootMotionSource> Data is copied around
        WithNetSerializer = true,
        WithIdenticalViaEquality = true,
        WithAddStructReferencedObjects = true,
    };
};