AnimNode_AnimDynamics.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Stats/Stats.h"
#include "UObject/ObjectMacros.h"
#include "BoneContainer.h"
#include "Animation/AnimPhysicsSolver.h"
#include "BonePose.h"
#include "BoneControllers/AnimNode_SkeletalControlBase.h"
#include "Animation/AnimInstanceProxy.h"
#include "CommonAnimationTypes.h"
#include "AnimNode_AnimDynamics.generated.h"
 
class UAnimInstance;
class USkeletalMeshComponent;
template <class T> class TAutoConsoleVariable;
 
extern TAutoConsoleVariable<int32> CVarEnableDynamics;
extern ANIMGRAPHRUNTIME_API TAutoConsoleVariable<int32> CVarLODThreshold;
extern TAutoConsoleVariable<int32> CVarEnableWind;
 
#if ENABLE_ANIM_DRAW_DEBUG
 
extern TAutoConsoleVariable<int32> CVarShowDebug;
extern TAutoConsoleVariable<FString> CVarDebugBone;
 
#endif
 
DECLARE_CYCLE_STAT_EXTERN(TEXT("Anim Dynamics Overall"), STAT_AnimDynamicsOverall, STATGROUP_Physics, ANIMGRAPHRUNTIME_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("Anim Dynamics Wind Data Update"), STAT_AnimDynamicsWindData, STATGROUP_Physics, ANIMGRAPHRUNTIME_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("Anim Dynamics Bone Evaluation"), STAT_AnimDynamicsBoneEval, STATGROUP_Physics, ANIMGRAPHRUNTIME_API);
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Anim Dynamics Sub-Steps"), STAT_AnimDynamicsSubSteps, STATGROUP_Physics, ANIMGRAPHRUNTIME_API);
 
UENUM()
enum class AnimPhysAngularConstraintType : uint8
{
    Angular,
    Cone
};
 
UENUM()
enum class AnimPhysLinearConstraintType : uint8
{
    Free,
    Limited,
};
 
UENUM(BlueprintType)
enum class AnimPhysSimSpaceType : uint8
{
    Component UMETA(ToolTip = "Sim origin is the location/orientation of the skeletal mesh component."),
    Actor UMETA(ToolTip = "Sim origin is the location/orientation of the actor containing the skeletal mesh component."),
    World UMETA(ToolTip = "Sim origin is the world origin. Teleporting characters is not recommended in this mode."),
    RootRelative UMETA(ToolTip = "Sim origin is the location/orientation of the root bone."),
    BoneRelative UMETA(ToolTip = "Sim origin is the location/orientation of the bone specified in RelativeSpaceBone"),
};
 
struct FAnimPhysBoneRigidBody
{
    FAnimPhysBoneRigidBody(TArray<FAnimPhysShape>& Shapes, const FVector& Position, const FBoneReference& LinkedBone)
    : PhysBody(Shapes, Position)
    , BoundBone(LinkedBone)
    {}
 
    FAnimPhysRigidBody PhysBody;
    FBoneReference BoundBone;
};
 
struct FAnimPhysLinkedBody
{
    FAnimPhysLinkedBody(TArray<FAnimPhysShape>& Shapes, const FVector& Position, const FBoneReference& LinkedBone)
    : RigidBody(Shapes, Position, LinkedBone)
    , ParentBody(nullptr)
    {}
 
    FAnimPhysBoneRigidBody RigidBody;
    FAnimPhysBoneRigidBody* ParentBody;
};
 
USTRUCT()
struct FAnimPhysConstraintSetup
{
    GENERATED_BODY()
 
    FAnimPhysConstraintSetup()
    : LinearXLimitType(AnimPhysLinearConstraintType::Limited)
    , LinearYLimitType(AnimPhysLinearConstraintType::Limited)
    , LinearZLimitType(AnimPhysLinearConstraintType::Limited)
    , bLinearFullyLocked(false)
    , LinearAxesMin(ForceInitToZero)
    , LinearAxesMax(ForceInitToZero)
    , AngularConstraintType(AnimPhysAngularConstraintType::Angular)
    , TwistAxis(AnimPhysTwistAxis::AxisX)
    , AngularTargetAxis(AnimPhysTwistAxis::AxisX)
    , ConeAngle(0.0f)
#if WITH_EDITORONLY_DATA
    , AngularXAngle_DEPRECATED(0.0f)
    , AngularYAngle_DEPRECATED(0.0f)
    , AngularZAngle_DEPRECATED(0.0f)
#endif
    , AngularLimitsMin(ForceInitToZero)
    , AngularLimitsMax(ForceInitToZero)
    , AngularTarget(ForceInitToZero)
    {}
 
    UPROPERTY(EditAnywhere, Category = Linear)
    AnimPhysLinearConstraintType LinearXLimitType;
 
    UPROPERTY(EditAnywhere, Category = Linear)
    AnimPhysLinearConstraintType LinearYLimitType;
 
    UPROPERTY(EditAnywhere, Category = Linear)
    AnimPhysLinearConstraintType LinearZLimitType;
 
    bool bLinearFullyLocked;
 
    UPROPERTY(EditAnywhere, Category = Linear, meta = (UIMax = "0", ClampMax = "0"))
    FVector LinearAxesMin;
 
    UPROPERTY(EditAnywhere, Category = Linear, meta = (UIMin = "0", ClampMin = "0"))
    FVector LinearAxesMax;
 
    UPROPERTY(EditAnywhere, Category = Angular)
    AnimPhysAngularConstraintType AngularConstraintType;
 
    UPROPERTY(EditAnywhere, Category = Angular)
    AnimPhysTwistAxis TwistAxis;
 
    UPROPERTY(EditAnywhere, Category = Angular, meta=(DisplayAfter=AngularLimitsMax))
    AnimPhysTwistAxis AngularTargetAxis;
 
    UPROPERTY(EditAnywhere, Category = Angular, meta = (UIMin = "0", UIMax = "90", ClampMin = "0", ClampMax = "90"))
    float ConeAngle;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    float AngularXAngle_DEPRECATED;
 
    UPROPERTY()
    float AngularYAngle_DEPRECATED;
 
    UPROPERTY()
    float AngularZAngle_DEPRECATED;
#endif
 
    UPROPERTY(EditAnywhere, Category = Angular, meta = (UIMin = "-180", UIMax = "180", ClampMin = "-180", ClampMax = "180"))
    FVector AngularLimitsMin;
 
    UPROPERTY(EditAnywhere, Category = Angular, meta = (UIMin = "-180", UIMax = "180", ClampMin = "-180", ClampMax = "180"))
    FVector AngularLimitsMax;
 
    UPROPERTY(EditAnywhere, Category = Angular)
    FVector AngularTarget;
};
 
USTRUCT()
struct FAnimPhysPlanarLimit
{
    GENERATED_BODY();
 
    UPROPERTY(EditAnywhere, Category=PlanarLimit)
    FBoneReference DrivingBone;
 
    UPROPERTY(EditAnywhere, Category=PlanarLimit)
    FTransform PlaneTransform;
};
 
UENUM()
enum class ESphericalLimitType : uint8
{
    Inner,
    Outer
};
 
USTRUCT()
struct FAnimPhysSphericalLimit
{
    GENERATED_BODY();
 
    FAnimPhysSphericalLimit()
        : SphereLocalOffset(FVector::ZeroVector)
        , LimitRadius(0.0f)
        , LimitType(ESphericalLimitType::Outer)
    {}
 
    UPROPERTY(EditAnywhere, Category = SphericalLimit)
    FBoneReference DrivingBone;
 
    UPROPERTY(EditAnywhere, Category = SphericalLimit)
    FVector SphereLocalOffset;
 
    UPROPERTY(EditAnywhere, Category = SphericalLimit)
    float LimitRadius;
 
    UPROPERTY(EditAnywhere, Category = SphericalLimit)
    ESphericalLimitType LimitType;
};
 
USTRUCT()
struct FAnimPhysBodyDefinition
{
    GENERATED_BODY();
 
    FAnimPhysBodyDefinition()
    : BoxExtents(10.0f, 10.0f, 10.0f)
    , LocalJointOffset(FVector::ZeroVector)
    , CollisionType(AnimPhysCollisionType::CoM)
    , SphereCollisionRadius(10.0f)
    {}
 
    FAnimPhysBodyDefinition& operator=(const FAnimPhysBodyDefinition& Other)
    {
        this->BoundBone = Other.BoundBone;
        this->BoxExtents = Other.BoxExtents;
        this->LocalJointOffset = Other.LocalJointOffset;
        this->ConstraintSetup = Other.ConstraintSetup;
        this->CollisionType = Other.CollisionType;
        this->SphereCollisionRadius = Other.SphereCollisionRadius;
 
        return *this;
    }
 
    UPROPERTY(VisibleAnywhere, Category = PhysicsBodyDefinition, meta = (EditCondition = "false"))
    FBoneReference BoundBone;
 
    UPROPERTY(EditAnywhere, Category = PhysicsBodyDefinition, meta = (UIMin = "1", ClampMin = "1"))
    FVector BoxExtents;
 
    UPROPERTY(EditAnywhere, Category = PhysicsBodyDefinition)
    FVector LocalJointOffset;
 
    UPROPERTY(EditAnywhere, Category = Constraint)
    FAnimPhysConstraintSetup ConstraintSetup;
 
    UPROPERTY(EditAnywhere, Category = Collision)
    AnimPhysCollisionType CollisionType;
 
    UPROPERTY(EditAnywhere, Category = PhysicsBodyDefinition, meta = (UIMin = "1", ClampMin = "1", EditCondition = "CollisionType == AnimPhysCollisionType::CustomSphere"))
    float SphereCollisionRadius;
};
 
struct FAnimConstraintOffsetPair
{
    FAnimConstraintOffsetPair(const FVector& InBody0Offset, const FVector InBody1Offset)
    : Body0Offset(InBody0Offset)
    , Body1Offset(InBody1Offset)
    {}
 
    FVector Body0Offset;
    FVector Body1Offset;
};
 
template <> struct TIsPODType<FAnimPhysSimSpaceSettings> { enum { Value = true }; };
 
USTRUCT(BlueprintType)
struct FAnimPhysSimSpaceSettings
{
    GENERATED_BODY()
 
    ANIMGRAPHRUNTIME_API FAnimPhysSimSpaceSettings();
 
    ~FAnimPhysSimSpaceSettings() = default;
    FAnimPhysSimSpaceSettings(FAnimPhysSimSpaceSettings const&) = default;
    FAnimPhysSimSpaceSettings& operator=(const FAnimPhysSimSpaceSettings&) = default;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Settings, meta = (ClampMin = "0.0", ClampMax = "1.0"))
    float SimSpaceAngularAlpha;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Settings, meta = (ClampMin = "0.0"))
    float MaxAngularVelocity;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Settings, meta = (ClampMin = "0.0"))
    float MaxAngularAcceleration;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Settings)
    FVector ExternalAngularVelocity;
 
};
 
 
USTRUCT(BlueprintInternalUseOnly)
struct FAnimNode_AnimDynamics : public FAnimNode_SkeletalControlBase
{
    GENERATED_BODY();
 
    ANIMGRAPHRUNTIME_API FAnimNode_AnimDynamics();
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category = PhysicsParameters, meta = (PinHiddenByDefault, DisplayAfter = "NumSolverIterationsPostUpdate", EditCondition = bOverrideLinearDamping))
    float LinearDampingOverride;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category = PhysicsParameters, meta = (PinHiddenByDefault, DisplayAfter = "LinearDampingOverride", EditCondition = bOverrideAngularDamping))
    float AngularDampingOverride;
 
    // Previous component & actor transforms, used to account for teleports
    FTransform PreviousCompWorldSpaceTM;
    FTransform PreviousActorWorldSpaceTM;
    FTransform PreviousSimSpaceTM;
 
    UPROPERTY(EditAnywhere, Category = Setup, meta=(DisplayAfter="SimulationSpace", EditCondition = "SimulationSpace == AnimPhysSimSpaceType::BoneRelative"))
    FBoneReference RelativeSpaceBone;
 
    UPROPERTY(EditAnywhere, Category = Setup)
    FBoneReference BoundBone;
 
    UPROPERTY(EditAnywhere, Category = Setup, meta = (EditCondition = bChain, DisplayAfter = "BoundBone"))
    FBoneReference ChainEnd;
 
    UPROPERTY(EditAnywhere, EditFixedSize, Category = PhysicsParameters, meta = (DisplayName = "Body Definitions", EditFixedOrder, DisplayAfter = "ChainEnd"))
    TArray< FAnimPhysBodyDefinition > PhysicsBodyDefinitions;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = PhysicsParameters, meta = (PinHiddenByDefault, DisplayAfter = "bGravityOverrideInSimSpace", EditCondition = "!bUseGravityOverride"))
    float GravityScale;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = PhysicsParameters, meta = (PinHiddenByDefault, DisplayAfter = "bUseGravityOverride", EditCondition = "bUseGravityOverride"))
    FVector GravityOverride;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = PhysicsParameters, meta = (EditCondition = bLinearSpring, PinHiddenByDefault, DisplayAfter = "AngularSpringConstant"))
    float LinearSpringConstant;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = PhysicsParameters, meta = (DisplayAfter = "PhysicsBodyDefinitions", EditCondition = bAngularSpring, PinHiddenByDefault))
    float AngularSpringConstant;
 
    UPROPERTY(EditAnywhere, Category = Wind, meta=(DisplayAfter="bEnableWind"))
    float WindScale;
 
    UPROPERTY(EditAnywhere, Category = Settings, meta = (PinHiddenByDefault))
    FVector ComponentLinearAccScale;
 
    UPROPERTY(EditAnywhere, Category = Settings, meta = (PinHiddenByDefault))
    FVector ComponentLinearVelScale;
 
    UPROPERTY(EditAnywhere, Category = Settings)
    FVector ComponentAppliedLinearAccClamp;
 
    UPROPERTY(EditAnywhere, Category = Settings, meta = (PinHiddenByDefault))
    FAnimPhysSimSpaceSettings SimSpaceSettings;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category = PhysicsParameters, meta = (PinHiddenByDefault, DisplayAfter = "AngularDampingOverride", EditCondition = bOverrideAngularBias))
    float AngularBiasOverride;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = PhysicsParameters)
    int32 NumSolverIterationsPreUpdate;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = PhysicsParameters, meta = (PinHiddenByDefault, DisplayAfter = "NumSolverIterationsPreUpdate"))
    int32 NumSolverIterationsPostUpdate;
 
    UPROPERTY(EditAnywhere, Category = SphericalLimit, meta=(DisplayAfter="bUseSphericalLimits"))
    TArray<FAnimPhysSphericalLimit> SphericalLimits;
 
    UPROPERTY(EditAnywhere, Category = Forces, meta = (PinShownByDefault))
    FVector ExternalForce;
 
    UPROPERTY(EditAnywhere, Category=PlanarLimit, meta=(DisplayAfter="bUsePlanarLimit"))
    TArray<FAnimPhysPlanarLimit> PlanarLimits;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Setup, meta = (PinHiddenByDefault, DisplayPriority=0))
    AnimPhysSimSpaceType SimulationSpace;
 
    // Cached sim space that we last used
    AnimPhysSimSpaceType LastSimSpace;
 
    // We can't get clean bone positions unless we are in the evaluate step.
    // Requesting an init or reinit sets this flag for us to pick up during evaluate
    ETeleportType InitTeleportType;
 
    UPROPERTY(EditAnywhere, Category = SphericalLimit)
    uint8 bUseSphericalLimits:1;
 
    UPROPERTY(EditAnywhere, Category=PlanarLimit)
    uint8 bUsePlanarLimit:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = PhysicsParameters, meta = (DisplayAfter = "bDoEval"))
    uint8 bDoUpdate : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = PhysicsParameters, meta = (DisplayAfter = "AngularBiasOverride"))
    uint8 bDoEval : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = PhysicsParameters, meta=(InlineEditConditionToggle, DisplayAfter="AngularSpringConstraint"))
    uint8 bOverrideLinearDamping:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = PhysicsParameters, meta=(InlineEditConditionToggle, DisplayAfter="AngularDampingOverride"))
    uint8 bOverrideAngularBias:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = PhysicsParameters, meta=(InlineEditConditionToggle, DisplayAfter="LinearDampingOverride"))
    uint8 bOverrideAngularDamping:1;
 
    UPROPERTY(EditAnywhere, Category = Wind)
    uint8 bEnableWind:1;
 
    uint8 bWindWasEnabled:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = PhysicsParameters, meta = (DisplayAfter = "LinearSpringConstant"))
    uint8 bUseGravityOverride:1;
 
    UPROPERTY(EditAnywhere, Category = PhysicsParameters, meta=(DisplayAfter = "GravityOverride", DisplayName = "Gravity Override In Sim Space", EditCondition = "bUseGravityOverride"))
    uint8 bGravityOverrideInSimSpace : 1;
 
    UPROPERTY(EditAnywhere, Category = PhysicsParameters, meta = (InlineEditConditionToggle))
    uint8 bLinearSpring:1;
 
    UPROPERTY(EditAnywhere, Category = PhysicsParameters, meta = (InlineEditConditionToggle))
    uint8 bAngularSpring:1;
 
    UPROPERTY(EditAnywhere, Category = Setup, meta=(InlineEditConditionToggle))
    uint8 bChain:1;
 
    UPROPERTY(EditAnywhere, Category = Retargeting)
    FRotationRetargetingInfo RetargetingSettings;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
        FVector BoxExtents_DEPRECATED;
    UPROPERTY()
        FVector LocalJointOffset_DEPRECATED;
    UPROPERTY()
        FAnimPhysConstraintSetup ConstraintSetup_DEPRECATED;
    UPROPERTY()
        AnimPhysCollisionType CollisionType_DEPRECATED;
    UPROPERTY()
        float SphereCollisionRadius_DEPRECATED;
#endif
 
    // FAnimNode_SkeletalControlBase interface
    ANIMGRAPHRUNTIME_API virtual void Initialize_AnyThread(const FAnimationInitializeContext& Context) override;
    ANIMGRAPHRUNTIME_API virtual void UpdateInternal(const FAnimationUpdateContext& Context) override;
    ANIMGRAPHRUNTIME_API virtual void EvaluateSkeletalControl_AnyThread(FComponentSpacePoseContext& Output, TArray<FBoneTransform>& OutBoneTransforms) override;
    ANIMGRAPHRUNTIME_API virtual void GatherDebugData(FNodeDebugData& DebugData) override;
    ANIMGRAPHRUNTIME_API virtual bool HasPreUpdate() const override;
    ANIMGRAPHRUNTIME_API virtual void PreUpdate(const UAnimInstance* InAnimInstance) override;
    virtual bool NeedsDynamicReset() const override { return true; }
    virtual void ResetDynamics(ETeleportType InTeleportType) override { RequestInitialise(InTeleportType); }
    ANIMGRAPHRUNTIME_API virtual int32 GetLODThreshold() const override;
    // End of FAnimNode_SkeletalControlBase interface
 
    ANIMGRAPHRUNTIME_API void RequestInitialise(ETeleportType InTeleportType);
    ANIMGRAPHRUNTIME_API void InitPhysics(FComponentSpacePoseContext& Output);
    ANIMGRAPHRUNTIME_API void TermPhysics();
 
    ANIMGRAPHRUNTIME_API void UpdateChainPhysicsBodyDefinitions(const FReferenceSkeleton& ReferenceSkeleton);
    ANIMGRAPHRUNTIME_API void ValidateChainPhysicsBodyDefinitions(const FReferenceSkeleton& ReferenceSkeleton);
    ANIMGRAPHRUNTIME_API void FindChainBoneNames(const FReferenceSkeleton& ReferenceSkeleton, TArray<FName>& ChainBoneNames);
    ANIMGRAPHRUNTIME_API void UpdateLimits(FComponentSpacePoseContext& Output);
 
    ANIMGRAPHRUNTIME_API int32 GetNumBodies() const;
    ANIMGRAPHRUNTIME_API const FAnimPhysRigidBody& GetPhysBody(int32 BodyIndex) const;
 
    ANIMGRAPHRUNTIME_API FTransform GetBodyComponentSpaceTransform(const FAnimPhysRigidBody& Body, const USkeletalMeshComponent* const SkelComp) const;
 
#if WITH_EDITOR
 
    // Accessors for editor code (mainly for visualization functions)
    ANIMGRAPHRUNTIME_API FVector GetBodyLocalJointOffset(const int32 BodyIndex) const;
 
    // True by default, if false physics simulation will not update this frame. Used to prevent the rig moving whilst interactively editing parameters with a widget in the viewport.
    bool bDoPhysicsUpdateInEditor;
 
#endif
 
    ANIMGRAPHRUNTIME_API bool ShouldDoPhysicsUpdate() const;
 
protected:
 
    // FAnimNode_SkeletalControlBase protected interface
    ANIMGRAPHRUNTIME_API virtual void InitializeBoneReferences(const FBoneContainer& RequiredBones) override;
    ANIMGRAPHRUNTIME_API virtual bool IsValidToEvaluate(const USkeleton* Skeleton, const FBoneContainer& RequiredBones);
    // End of FAnimNode_SkeletalControlBase protected interface
 
private:
    // Given a bone index, get it's transform in the currently selected simulation space
    ANIMGRAPHRUNTIME_API FTransform GetBoneTransformInSimSpace(FComponentSpacePoseContext& Output, const FCompactPoseBoneIndex& BoneIndex) const;
 
    // Given a transform in simulation space, convert it back to component space
    ANIMGRAPHRUNTIME_API FTransform GetComponentSpaceTransformFromSimSpace(AnimPhysSimSpaceType SimSpace, FComponentSpacePoseContext& Output, const FTransform& InSimTransform) const;
    ANIMGRAPHRUNTIME_API FTransform GetComponentSpaceTransformFromSimSpace(AnimPhysSimSpaceType SimSpace, FComponentSpacePoseContext& Output, const FTransform& InSimTransform, const FTransform& InCompWorldSpaceTM, const FTransform& InActorWorldSpaceTM) const;
    ANIMGRAPHRUNTIME_API FTransform GetComponentSpaceTransformFromSimSpace(AnimPhysSimSpaceType SimSpace, const USkeletalMeshComponent* const SkelComp, const FTransform& InSimTransform) const;
 
    FTransform GetSimToWorldSpaceTransform(AnimPhysSimSpaceType SimSpace, FComponentSpacePoseContext& Output) const;
 
    // Given a transform in component space, convert it to the current sim space
    ANIMGRAPHRUNTIME_API FTransform GetSimSpaceTransformFromComponentSpace(AnimPhysSimSpaceType SimSpace, FComponentSpacePoseContext& Output, const FTransform& InComponentTransform) const;
 
    // Given a world-space vector, convert it into the current simulation space
    ANIMGRAPHRUNTIME_API FVector TransformWorldVectorToSimSpace(FComponentSpacePoseContext& Output, const FVector& InVec) const;
 
    ANIMGRAPHRUNTIME_API FVector TransformWorldVectorToSimSpaceScaled(FComponentSpacePoseContext& Output, const FVector& InVec) const;
 
    ANIMGRAPHRUNTIME_API void ConvertSimulationSpace(FComponentSpacePoseContext& Output, AnimPhysSimSpaceType From, AnimPhysSimSpaceType To) const;
 
    void CalculateSimulationSpaceMotion(AnimPhysSimSpaceType Space, FAnimPhysSimSpaceSettings Settings, FComponentSpacePoseContext& Output, const float Dt,
        FVector& SpaceAngularVel, FVector& SpaceAngularAcc);
 
    // Maximum time to consider when accumulating time debt to avoid spiraling
    static ANIMGRAPHRUNTIME_API const float MaxTimeDebt;
 
    // Cached timestep from the update phase (needed in evaluate phase)
    float NextTimeStep;
 
    // Current amount of time debt
    float TimeDebt;
 
    // Cached physics settings. We cache these on initialise to avoid the cost of accessing UPhysicsSettings a lot each frame
    float AnimPhysicsMinDeltaTime;
    float MaxPhysicsDeltaTime;
    float MaxSubstepDeltaTime;
    int32 MaxSubsteps;
 
    // Active body list
    TArray<FAnimPhysLinkedBody> Bodies;
 
    // Pointers to bodies that need to be reset to their bound bone.
    // This happens on LOD change so we don't make the simulation unstable
    TArray<FAnimPhysLinkedBody*> BodiesToReset;
 
    // Pointers back to the base bodies to pass to the simulation
    TArray<FAnimPhysRigidBody*> BaseBodyPtrs;
 
    // List of current linear limits built for the current frame
    TArray<FAnimPhysLinearLimit> LinearLimits;
 
    // List of current angular limits built for the current frame
    TArray<FAnimPhysAngularLimit> AngularLimits;
 
    // List of spring force generators created for this frame
    TArray<FAnimPhysSpring> Springs;
 
    // Position of the physics object relative to the transform if its bound bone.
    TArray<FVector> PhysicsBodyJointOffsets;
 
    // A pair of positions (relative to their associated physics bodies) for each pair of bodies in a chain. These positions should be driven to match each other in sim space by the physics contstraints - See UpdateLimits() fns.
    TArray<FAnimConstraintOffsetPair> ConstraintOffsets;
    
    // Depending on the LOD we might not be running all of the bound bodies (for chains)
    // this tracks the active bodies.
    TArray<int32> ActiveBoneIndices;
 
    // Gravity direction in sim space
    FVector SimSpaceGravityDirection;
 
    // Previous linear velocity to resolve world accelerations when not using world space simulation
    FVector PreviousComponentLinearVelocity;
 
    // Previous angular velocity to resolve world angular acceleration when not using world space simulation
    FVector PreviousSimSpaceAngularVelocity;
 
    // Live debug
#if ENABLE_ANIM_DRAW_DEBUG
    ANIMGRAPHRUNTIME_API void DrawBodies(FComponentSpacePoseContext& InContext, const TArray<FAnimPhysRigidBody*>& InBodies);
 
    int32 FilteredBoneIndex;
#endif
public: 
    static ANIMGRAPHRUNTIME_API bool IsAnimDynamicsSystemEnabledFor(int32 InLOD);
};