InterpToMovementComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "CoreMinimal.h"
#include "Engine/HitResult.h"
#endif // UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "GameFramework/MovementComponent.h"
#include "UObject/ObjectMacros.h"
#include "InterpToMovementComponent.generated.h"
 
struct FHitResult;
 
UENUM(BlueprintType)
enum class EInterpToBehaviourType : uint8
{
    OneShot,
    OneShot_Reverse,
    Loop_Reset,
    PingPong
};
 
USTRUCT(BlueprintType)
struct FInterpControlPoint
{
    GENERATED_USTRUCT_BODY()
public:
    // The position of the point 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Location, meta=(MakeEditWidget=true))
    FVector PositionControlPoint;
    
    // Is the location relative to the root components initial location
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Location)
    bool bPositionIsRelative;
 
    FInterpControlPoint()
    {
        PositionControlPoint = FVector::ZeroVector;
        bPositionIsRelative = true;
    }
    FInterpControlPoint(FVector InPosition, bool bIsRelative)
    {
        PositionControlPoint = InPosition;
        bPositionIsRelative = bIsRelative;
    }
 
    float StartTime;
    float DistanceToNext;
    float Percentage;
};
 
UCLASS(ClassGroup=Movement, meta=(BlueprintSpawnableComponent),HideCategories=Velocity, MinimalAPI)
class UInterpToMovementComponent : public UMovementComponent 
{
    GENERATED_UCLASS_BODY()
 
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( FOnInterpToReverseDelegate, const FHitResult&, ImpactResult, float, Time  );
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( FOnInterpToStopDelegate, const FHitResult&, ImpactResult, float, Time );
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( FOnInterpToWaitBeginDelegate , const FHitResult&, ImpactResult, float, Time );
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( FOnInterpToWaitEndDelegate , const FHitResult&, ImpactResult, float, Time );
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( FOnInterpToResetDelegate , const FHitResult&, ImpactResult, float, Time );
 
    /* How long to take to move from the first point to the last (or vice versa) */
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Control,meta=(UIMin=0.1f, ClampMin=0.1f))
    float Duration;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Behaviour)
    uint32 bPauseOnImpact:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Behaviour)
    bool bSweep = true;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Behaviour)
    ETeleportType TeleportType = ETeleportType::None;
 
    /* Movement behaviour of the component */
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Behaviour)
    EInterpToBehaviourType BehaviourType;
 
    /* Do we want this comp to perform CheckStillInWorld checks? */
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Behaviour)
    bool bCheckIfStillInWorld = true;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Simulation)
    uint32 bForceSubStepping:1;
    
    UPROPERTY(BlueprintAssignable)
    FOnInterpToReverseDelegate OnInterpToReverse;
 
    UPROPERTY(BlueprintAssignable)
    FOnInterpToStopDelegate OnInterpToStop;
    
    UPROPERTY(BlueprintAssignable)
    FOnInterpToWaitBeginDelegate OnWaitBeginDelegate;
 
    UPROPERTY(BlueprintAssignable)
    FOnInterpToWaitEndDelegate OnWaitEndDelegate;
 
    UPROPERTY(BlueprintAssignable)
    FOnInterpToResetDelegate OnResetDelegate; 
 
    //Begin UActorComponent Interface
    ENGINE_API virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction) override;
    ENGINE_API virtual void BeginPlay() override;
    ENGINE_API virtual void ApplyWorldOffset(const FVector& InOffset, bool bWorldShift) override;
    //End UActorComponent Interface
 
    //Begin UMovementComponent Interface
    ENGINE_API virtual void StopMovementImmediately() override;
    //End UMovementComponent Interface
 
    ENGINE_API virtual bool CheckStillInWorld();
 
    UFUNCTION(BlueprintCallable, Category="Game|Components|InterpToMovement")
    ENGINE_API void StopSimulating(const FHitResult& HitResult);
 
    bool HasStoppedSimulation() { return UpdatedComponent == NULL; }
 
    ENGINE_API float GetSimulationTimeStep(float RemainingTime, int32 Iterations) const;
 
    ENGINE_API virtual bool ShouldUseSubStepping() const;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, meta=(ClampMin="0.0166", ClampMax="0.50", UIMin="0.0166", UIMax="0.50"), Category=Simulation)
    float MaxSimulationTimeStep;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Simulation)
    float SpeedMultiplier;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, meta=(ClampMin="1", ClampMax="25", UIMin="1", UIMax="25"), Category=Simulation)
    int32 MaxSimulationIterations;
    
    /* List of control points to visit. */
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Control)
    TArray<FInterpControlPoint> ControlPoints;
        
    /* Add a control point that represents a position. */
    UFUNCTION(BlueprintCallable, Category = "Control")
    ENGINE_API virtual void AddControlPointPosition(FVector Pos, bool bPositionIsRelative = true);
    
    /* Reset to start. Sets time to zero and direction to 1.  */
    UFUNCTION(BlueprintCallable, Category = "Control")
    ENGINE_API void RestartMovement(float InitialDirection = 1.0f);
 
    /* Initialise the control points array. Call after adding control points if they are add after begin play .  */
    UFUNCTION(BlueprintCallable, Category = "Control")
    ENGINE_API void FinaliseControlPoints();
 
    /* Clear the control points array and set to stopped. */
    UFUNCTION(BlueprintCallable, Category = "Control")
    ENGINE_API void ResetControlPoints();
 
#if WITH_EDITOR
    //~ Begin UObject Interface.
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    //~ End UObject Interface.
#endif // WITH_EDITOR
 
protected:
 
    ENGINE_API bool HandleHitWall(const FHitResult& Hit, float TimeTick, const FVector& MoveDelta);
 
    ENGINE_API virtual void HandleImpact(const FHitResult& Hit, float TimeSlice=0.f, const FVector& MoveDelta = FVector::ZeroVector) override;
 
    /* Reverse direction we are moving */
    ENGINE_API void ReverseDirection(const FHitResult& Hit, float Time, bool InBroadcastEvent);
 
    ENGINE_API virtual FVector ComputeMoveDelta(float Time) const;
 
    /* Current position on spline */
    float CurrentTime;
 
    /* User to */
    float TimeMultiplier;
 
    /* Current direction along spline timeline */
    float CurrentDirection;
 
    /* Have we hit something and are waiting for it to move to carry on moving */
    bool bIsWaiting;
 
    /* Have we stopped (because we hit something, or reached the end of the cycle */
    bool bStopped;
 
    /* Are there any actor control points in use*/
    bool bContainsActorControlPoints;
 
    static ENGINE_API const float MIN_TICK_TIME;
    
    /* Update the control points. Adjusts the positions of there are any actor control points as well as updating the spline type */
    ENGINE_API virtual void UpdateControlPoints(bool InForceUpdate);    
 
    /* Calculate the new current time */
    ENGINE_API float CalculateNewTime( float TimeNow, float Delta, FHitResult& HitResult, bool InBroadcastEvent, bool& OutStopped, float& OutTimeRemainder );
 
private:
    float TotalDistance;
 
    FVector StartLocation;
    bool bPointsFinalized;
};