ScopedMovementUpdate.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 "Engine/OverlapInfo.h"
 
struct FHitResult;
enum class ETeleportType : uint8;
 
namespace EScopedUpdate
{
    enum Type
    {
        ImmediateUpdates,
 
        DeferredUpdates,
 
        DeferredGroupUpdates,
    };
}
 
class FScopedMovementUpdate : private FNoncopyable
{
public:
    typedef TArray<FHitResult, TInlineAllocator<2>> TScopedBlockingHitArray;
    typedef TArray<FOverlapInfo, TInlineAllocator<3>> TScopedOverlapInfoArray;
 
    ENGINE_API FScopedMovementUpdate( USceneComponent* Component, EScopedUpdate::Type ScopeBehavior = EScopedUpdate::DeferredUpdates, bool bRequireOverlapsEventFlagToQueueOverlaps = true );
    ENGINE_API ~FScopedMovementUpdate();
 
    enum class EHasMovedTransformOption
    {
        eTestTransform,
        eIgnoreTransform
    };
 
    enum class EOverlapState
    {
        eUseParent,
        eUnknown,
        eIncludesOverlaps,
        eForceUpdate,
    };
 
    const FScopedMovementUpdate* GetOuterDeferredScope() const;
 
    bool IsDeferringUpdates() const;
 
    bool IsGroupUpdate() const;
    
    ENGINE_API void RevertMove();
 
    bool HasMoved(EHasMovedTransformOption CheckTransform) const;
 
    ENGINE_API bool IsTransformDirty() const;
 
    bool HasPendingOverlaps() const;
 
    bool RequiresOverlapsEventFlag() const;
 
    const TScopedOverlapInfoArray& GetPendingOverlaps() const;
 
    const TScopedBlockingHitArray& GetPendingBlockingHits() const;
 
    //--------------------------------------------------------------------------------------------------------//
    // These methods are intended only to be used by SceneComponent and derived classes.
 
    ENGINE_API void AppendOverlapsAfterMove(const TOverlapArrayView& NewPendingOverlaps, bool bSweep, bool bIncludesOverlapsAtEnd);
 
    void KeepCurrentOverlapsAfterRotation(bool bSweep);
 
    void AppendBlockingHitAfterMove(const FHitResult& Hit);
 
    void InvalidateCurrentOverlaps();
 
    void ForceOverlapUpdate();
 
    void SetHasTeleported(ETeleportType InTeleportType);
 
    ETeleportType GetTeleportType() const;
    
    bool GetHasMoved() const;
    
    int32 GetFinalOverlapCandidatesIndex() const;
    
    EOverlapState GetOverlapState() const;
    
    const FTransform& GetInitialTransform() const;
    
    USceneComponent* GetOwner() const;
 
protected:
    ENGINE_API TOptional<TOverlapArrayView> GetOverlapsAtEnd(class UPrimitiveComponent& PrimComponent, TInlineOverlapInfoArray& OutEndOverlaps, bool bTransformChanged) const;
 
    ENGINE_API bool SetWorldLocationAndRotation(FVector NewLocation, const FQuat& NewQuat, bool bNoPhysics, ETeleportType Teleport);
 
private:
    ENGINE_API void OnInnerScopeComplete(const FScopedMovementUpdate& InnerScope);
    
    // This class can only be created on the stack, otherwise the ordering constraints
    // of the constructor and destructor between encapsulated scopes could be violated.
    void* operator new (size_t) = delete;
    void* operator new[] (size_t) = delete;
    void operator delete (void *) = delete;
    void operator delete[] (void*) = delete;
 
protected:
    USceneComponent* Owner;
    FScopedMovementUpdate* OuterDeferredScope;
 
    EOverlapState CurrentOverlapState;
    ETeleportType TeleportType;
 
    FTransform InitialTransform;
    FVector InitialRelativeLocation;
    FRotator InitialRelativeRotation;
    FVector InitialRelativeScale;
 
    int32 FinalOverlapCandidatesIndex;      // If not INDEX_NONE, overlaps at this index and beyond in PendingOverlaps are at the final destination
    TScopedOverlapInfoArray PendingOverlaps;    // All overlaps encountered during the scope of moves.
    TScopedBlockingHitArray BlockingHits;       // All blocking hits encountered during the scope of moves.
 
    uint8 bDeferUpdates:1;
    uint8 bHasMoved:1;
    uint8 bRequireOverlapsEventFlag:1;
    
    uint8 bIsGroupDeferedUpdate : 1;
 
    friend class USceneComponent;
};
 
// FScopedMovementUpdate inlines
 
inline const FScopedMovementUpdate* FScopedMovementUpdate::GetOuterDeferredScope() const
{
    return OuterDeferredScope;
}
 
inline bool FScopedMovementUpdate::IsDeferringUpdates() const
{
    return bDeferUpdates;
}
 
inline bool FScopedMovementUpdate::IsGroupUpdate() const
{
    return bIsGroupDeferedUpdate;
}
 
inline bool FScopedMovementUpdate::HasMoved(EHasMovedTransformOption CheckTransform) const
{
    return bHasMoved || (CheckTransform == EHasMovedTransformOption::eTestTransform && IsTransformDirty());
}
 
inline bool FScopedMovementUpdate::HasPendingOverlaps() const
{
    return PendingOverlaps.Num() > 0;
}
 
inline bool FScopedMovementUpdate::RequiresOverlapsEventFlag() const
{
    return bRequireOverlapsEventFlag;
}
 
inline const FScopedMovementUpdate::TScopedOverlapInfoArray& FScopedMovementUpdate::GetPendingOverlaps() const
{
    return PendingOverlaps;
}
 
inline const FScopedMovementUpdate::TScopedBlockingHitArray& FScopedMovementUpdate::GetPendingBlockingHits() const
{
    return BlockingHits;
}
 
inline void FScopedMovementUpdate::AppendBlockingHitAfterMove(const FHitResult& Hit)
{
    BlockingHits.Add(Hit);
}
 
inline void FScopedMovementUpdate::KeepCurrentOverlapsAfterRotation(bool bSweep)
{
    bHasMoved = true;
    // CurrentOverlapState is unchanged
}
 
inline void FScopedMovementUpdate::InvalidateCurrentOverlaps()
{
    bHasMoved = true;
    CurrentOverlapState = EOverlapState::eUnknown;
    FinalOverlapCandidatesIndex = INDEX_NONE;
}
 
inline void FScopedMovementUpdate::ForceOverlapUpdate()
{
    bHasMoved = true;
    CurrentOverlapState = EOverlapState::eForceUpdate;
    FinalOverlapCandidatesIndex = INDEX_NONE;
}
 
inline void FScopedMovementUpdate::SetHasTeleported(ETeleportType InTeleportType)
{
    // Request an initialization. Teleport type can only go higher - i.e. if we have requested a reset, then a teleport will still reset fully
    TeleportType = ((InTeleportType > TeleportType) ? InTeleportType : TeleportType); 
}
 
inline ETeleportType FScopedMovementUpdate::GetTeleportType() const
{
    return TeleportType;
}
 
inline bool FScopedMovementUpdate::GetHasMoved() const
{
    return bHasMoved;
}
 
inline int32 FScopedMovementUpdate::GetFinalOverlapCandidatesIndex() const
{
    return FinalOverlapCandidatesIndex;
}
 
inline FScopedMovementUpdate::EOverlapState FScopedMovementUpdate::GetOverlapState() const
{
    return CurrentOverlapState;
}
 
inline const FTransform& FScopedMovementUpdate::GetInitialTransform() const
{
    return InitialTransform;
}
 
inline USceneComponent* FScopedMovementUpdate::GetOwner() const
{
    return Owner;
}