MovementComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Engine/EngineTypes.h"
#include "Chaos/ChaosEngineInterface.h"
#include "Components/ActorComponent.h"
#include "Components/SceneComponent.h"
#include "MovementComponent.generated.h"
 
class AActor;
class APhysicsVolume;
class UPrimitiveComponent;
struct FCollisionQueryParams;
struct FCollisionResponseParams;
struct FCollisionShape;
 
 
 
namespace MovementComponentCVars
{
    // Typically we want to depenetrate regardless of direction, so we can get all the way out of penetration quickly.
    // Our rules for "moving with depenetration normal" only get us so far out of the object. We'd prefer to pop out by the full MTD amount.
    // Depenetration moves (in ResolvePenetration) then ignore blocking overlaps to be able to move out by the MTD amount.
    extern int32 MoveIgnoreFirstBlockingOverlap;
 
    extern float PenetrationOverlapCheckInflation;
 
    extern float PenetrationPullbackDistance;
}
 
 
UENUM(BlueprintType)
enum class EPlaneConstraintAxisSetting : uint8
{
    Custom,
    X,
    Y,
    Z,
    UseGlobalPhysicsSetting
};
 
 
UCLASS(ClassGroup=Movement, abstract, BlueprintType, MinimalAPI)
class UMovementComponent : public UActorComponent
{
    GENERATED_UCLASS_BODY()
 
    
    UPROPERTY(BlueprintReadOnly, Transient, DuplicateTransient, Category=MovementComponent)
    TObjectPtr<USceneComponent> UpdatedComponent;
 
    UPROPERTY(BlueprintReadOnly, Transient, DuplicateTransient, Category=MovementComponent)
    TObjectPtr<UPrimitiveComponent> UpdatedPrimitive;
 
    EMoveComponentFlags MoveComponentFlags;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Velocity)
    FVector Velocity;
 
protected:
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=PlanarMovement, meta=(editcondition=bConstrainToPlane))
    FVector PlaneConstraintNormal;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=PlanarMovement, meta=(editcondition=bConstrainToPlane))
    FVector PlaneConstraintOrigin;
 
    ENGINE_API FVector GetPlaneConstraintNormalFromAxisSetting(EPlaneConstraintAxisSetting AxisSetting) const;
 
public:
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=MovementComponent)
    uint8 bUpdateOnlyIfRendered:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=MovementComponent)
    uint8 bAutoUpdateTickRegistration:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=MovementComponent)
    uint8 bTickBeforeOwner:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=MovementComponent)
    uint8 bAutoRegisterUpdatedComponent:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=PlanarMovement)
    uint8 bConstrainToPlane:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=PlanarMovement, meta=(editcondition=bConstrainToPlane))
    uint8 bSnapToPlaneAtStart:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=MovementComponent)
    uint8 bAutoRegisterPhysicsVolumeUpdates:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=MovementComponent, meta=(editcondition=bAutoRegisterPhysicsVolumeUpdates))
    uint8 bComponentShouldUpdatePhysicsVolume:1;
 
private:
 
#if WITH_EDITOR
    // Warned about trying to move something with static mobility.
    uint8 bEditorWarnedStaticMobilityMove:1;
#endif
 
    bool bInOnRegister;
 
    bool bInInitializeComponent;
 
    UPROPERTY(EditAnywhere, Category=PlanarMovement, meta=(editcondition=bConstrainToPlane))
    EPlaneConstraintAxisSetting PlaneConstraintAxisSetting;
 
public:
    //~ Begin ActorComponent Interface 
    ENGINE_API virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction) override;
    ENGINE_API virtual void RegisterComponentTickFunctions(bool bRegister) override;
    ENGINE_API virtual void PostLoad() override;
    ENGINE_API virtual void Deactivate() override;
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
 
    ENGINE_API virtual void InitializeComponent() override;
 
    ENGINE_API virtual void OnRegister() override;
 
 
#if WITH_EDITOR
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    static ENGINE_API void PhysicsLockedAxisSettingChanged();
#endif // WITH_EDITOR
 
    //~ End ActorComponent Interface
 
    UFUNCTION(BlueprintCallable, Category="Components|Movement")
    ENGINE_API virtual float GetGravityZ() const;
 
    UFUNCTION(BlueprintCallable, Category="Components|Movement")
    virtual float GetMaxSpeed() const;
 
    UFUNCTION(BlueprintCallable, Category="Components|Movement")
    ENGINE_API virtual bool IsExceedingMaxSpeed(float MaxSpeed) const;
 
    UFUNCTION(BlueprintCallable, Category="Components|Movement")
    virtual void StopMovementImmediately();
 
    ENGINE_API virtual bool ShouldSkipUpdate(float DeltaTime) const;
 
    UFUNCTION(BlueprintCallable, Category="Components|Movement")
    ENGINE_API virtual APhysicsVolume* GetPhysicsVolume() const;
 
    UFUNCTION()
    ENGINE_API virtual void PhysicsVolumeChanged(class APhysicsVolume* NewVolume);
 
    UFUNCTION(BlueprintCallable, Category="Components|Movement")
    ENGINE_API virtual void SetUpdatedComponent(USceneComponent* NewUpdatedComponent);
 
    ENGINE_API virtual bool IsInWater() const;
 
    ENGINE_API virtual void UpdateTickRegistration();
 
    ENGINE_API virtual void HandleImpact(const FHitResult& Hit, float TimeSlice=0.f, const FVector& MoveDelta = FVector::ZeroVector);
 
    ENGINE_API virtual void UpdateComponentVelocity();
 
    ENGINE_API virtual void InitCollisionParams(FCollisionQueryParams &OutParams, FCollisionResponseParams& OutResponseParam) const;
 
    ENGINE_API virtual bool OverlapTest(const FVector& Location, const FQuat& RotationQuat, const ECollisionChannel CollisionChannel, const FCollisionShape& CollisionShape, const AActor* IgnoreActor) const;
 
    bool MoveUpdatedComponent(const FVector& Delta, const FQuat& NewRotation,    bool bSweep, FHitResult* OutHit = NULL, ETeleportType Teleport = ETeleportType::None);
    bool MoveUpdatedComponent(const FVector& Delta, const FRotator& NewRotation, bool bSweep, FHitResult* OutHit = NULL, ETeleportType Teleport = ETeleportType::None);
 
protected:
 
    ENGINE_API virtual bool MoveUpdatedComponentImpl(const FVector& Delta, const FQuat& NewRotation, bool bSweep, FHitResult* OutHit = NULL, ETeleportType Teleport = ETeleportType::None);
 
public:
    
    UFUNCTION(BlueprintCallable, Category="Components|Movement", meta=(DisplayName = "MoveUpdatedComponent", ScriptName = "MoveUpdatedComponent", AdvancedDisplay="bTeleport"))
    ENGINE_API bool K2_MoveUpdatedComponent(FVector Delta, FRotator NewRotation, FHitResult& OutHit, bool bSweep = true, bool bTeleport = false);
 
    ENGINE_API virtual bool SafeMoveUpdatedComponent(const FVector& Delta, const FQuat& NewRotation, bool bSweep, FHitResult& OutHit, ETeleportType Teleport = ETeleportType::None);
    bool SafeMoveUpdatedComponent(const FVector& Delta, const FRotator& NewRotation, bool bSweep, FHitResult& OutHit, ETeleportType Teleport = ETeleportType::None);
 
    ENGINE_API virtual FVector GetPenetrationAdjustment(const FHitResult& Hit) const;
    
    bool ResolvePenetration(const FVector& Adjustment, const FHitResult& Hit, const FQuat& NewRotation);
    bool ResolvePenetration(const FVector& Adjustment, const FHitResult& Hit, const FRotator& NewRotation);
 
protected:
 
    ENGINE_API virtual bool ResolvePenetrationImpl(const FVector& Adjustment, const FHitResult& Hit, const FQuat& NewRotation);
 
public:
 
    ENGINE_API virtual FVector ComputeSlideVector(const FVector& Delta, const float Time, const FVector& Normal, const FHitResult& Hit) const;
 
    ENGINE_API virtual float SlideAlongSurface(const FVector& Delta, float Time, const FVector& Normal, FHitResult &Hit, bool bHandleImpact = false);
 
    ENGINE_API virtual void TwoWallAdjust(FVector &Delta, const FHitResult& Hit, const FVector &OldHitNormal) const;
 
    ENGINE_API virtual void AddRadialForce(const FVector& Origin, float Radius, float Strength, ERadialImpulseFalloff Falloff);
 
    ENGINE_API virtual void AddRadialImpulse(const FVector& Origin, float Radius, float Strength, ERadialImpulseFalloff Falloff, bool bVelChange);
 
    UFUNCTION(BlueprintCallable, Category="Components|Movement|Planar")
    ENGINE_API virtual void SetPlaneConstraintAxisSetting(EPlaneConstraintAxisSetting NewAxisSetting);
 
    UFUNCTION(BlueprintCallable, Category="Components|Movement|Planar")
    EPlaneConstraintAxisSetting GetPlaneConstraintAxisSetting() const;
 
    UFUNCTION(BlueprintCallable, Category="Components|Movement|Planar")
    ENGINE_API virtual void SetPlaneConstraintNormal(FVector PlaneNormal);
 
    UFUNCTION(BlueprintCallable, Category="Components|Movement|Planar")
    ENGINE_API virtual void SetPlaneConstraintFromVectors(FVector Forward, FVector Up);
 
    UFUNCTION(BlueprintCallable, Category="Components|Movement|Planar")
    ENGINE_API virtual void SetPlaneConstraintOrigin(FVector PlaneOrigin);
    
    UFUNCTION(BlueprintCallable, Category = "Components|Movement|Planar")
    ENGINE_API virtual void SetPlaneConstraintEnabled(bool bEnabled);
 
    UFUNCTION(BlueprintCallable, Category="Components|Movement|Planar")
    ENGINE_API const FVector& GetPlaneConstraintNormal() const;
 
    UFUNCTION(BlueprintCallable, Category="Components|Movement|Planar")
    ENGINE_API const FVector& GetPlaneConstraintOrigin() const;
 
    UFUNCTION(BlueprintCallable, Category="Components|Movement|Planar")
    ENGINE_API virtual FVector ConstrainDirectionToPlane(FVector Direction) const;
 
    UFUNCTION(BlueprintCallable, Category="Components|Movement|Planar")
    ENGINE_API virtual FVector ConstrainLocationToPlane(FVector Location) const;
 
    UFUNCTION(BlueprintCallable, Category="Components|Movement|Planar")
    ENGINE_API virtual FVector ConstrainNormalToPlane(FVector Normal) const;
 
    UFUNCTION(BlueprintCallable, Category="Components|Movement|Planar")
    ENGINE_API virtual void SnapUpdatedComponentToPlane();
 
    virtual void OnTeleported() {};
};
 
 
// Inlines
 
inline float UMovementComponent::GetMaxSpeed() const
{
    return 0.f;
}
 
inline void UMovementComponent::StopMovementImmediately()
{
    Velocity = FVector::ZeroVector;
    UpdateComponentVelocity();
}
 
inline EPlaneConstraintAxisSetting UMovementComponent::GetPlaneConstraintAxisSetting() const
{
    return PlaneConstraintAxisSetting;
}
 
inline bool UMovementComponent::SafeMoveUpdatedComponent(const FVector& Delta, const FRotator& NewRotation, bool bSweep, FHitResult& OutHit, ETeleportType Teleport)
{
    return SafeMoveUpdatedComponent(Delta, NewRotation.Quaternion(), bSweep, OutHit, Teleport);
}
 
inline bool UMovementComponent::MoveUpdatedComponent(const FVector& Delta, const FQuat& NewRotation, bool bSweep, FHitResult* OutHit, ETeleportType Teleport)
{
    return MoveUpdatedComponentImpl(Delta, NewRotation, bSweep, OutHit, Teleport);
}
 
inline bool UMovementComponent::MoveUpdatedComponent(const FVector& Delta, const FRotator& NewRotation, bool bSweep, FHitResult* OutHit, ETeleportType Teleport)
{
    return MoveUpdatedComponentImpl(Delta, NewRotation.Quaternion(), bSweep, OutHit, Teleport);
}
 
inline bool UMovementComponent::ResolvePenetration(const FVector& Adjustment, const FHitResult& Hit, const FQuat& NewRotation)
{
    return ResolvePenetrationImpl(Adjustment, Hit, NewRotation);
}
 
inline bool UMovementComponent::ResolvePenetration(const FVector& Adjustment, const FHitResult& Hit, const FRotator& NewRotation)
{
    return ResolvePenetrationImpl(Adjustment, Hit, NewRotation.Quaternion());
}