TimerManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    TimerManager.h: Global gameplay timer facility
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "Stats/Stats.h"
#include "UObject/Object.h"
#include "Engine/TimerHandle.h"
#include "Misc/TVariant.h"
#include "Templates/Function.h"
 
class UGameInstance;
enum class ELevelCollectionType : uint8;
struct FTimerSourceList;
 
// using "not checked" user policy (means race detection is disabled) because this delegate is stored in a TSparseArray and causes its reallocation
// from inside delegate's execution. This is incompatible with race detection that needs to access the delegate instance after its execution
using FTimerDelegate = TDelegate<void(), FNotThreadSafeNotCheckedDelegateUserPolicy>;
using FTimerFunction = TFunction<void(void)>;
using FTimerDelegateVariant = TVariant<TYPE_OF_NULLPTR, FTimerDelegate, FTimerDynamicDelegate, FTimerFunction>;
 
#ifndef UE_ENABLE_TRACKING_TIMER_SOURCES
#define UE_ENABLE_TRACKING_TIMER_SOURCES !UE_BUILD_SHIPPING
#endif
 
struct FTimerUnifiedDelegate
{
    FTimerDelegateVariant VariantDelegate;
 
    FTimerUnifiedDelegate() {};
 
    FTimerUnifiedDelegate(FTimerDelegate const& D) : VariantDelegate(TInPlaceType<FTimerDelegate>(), D) {}
    FTimerUnifiedDelegate(FTimerDynamicDelegate const& D) : VariantDelegate(TInPlaceType<FTimerDynamicDelegate>(), D) {}
    FTimerUnifiedDelegate(FTimerFunction&& Callback) : VariantDelegate(TInPlaceType<FTimerFunction>(), MoveTemp(Callback)) {}
    
    void Execute() const;
 
    bool IsBound() const;
 
    const void* GetBoundObject() const;
 
    void Unbind()
    {
        VariantDelegate.Set<TYPE_OF_NULLPTR>(nullptr);
    }
 
    FString ToString() const;
 
    // Movable only
    FTimerUnifiedDelegate(FTimerUnifiedDelegate&&) = default;
    FTimerUnifiedDelegate(const FTimerUnifiedDelegate&) = delete;
    FTimerUnifiedDelegate& operator=(FTimerUnifiedDelegate&&) = default;
    FTimerUnifiedDelegate& operator=(const FTimerUnifiedDelegate&) = delete;
};
 
enum class ETimerStatus : uint8
{
    Pending,
    Active,
    Paused,
    Executing,
    ActivePendingRemoval
};
 
struct FTimerData
{
    uint8 bLoop : 1;
 
    uint8 bMaxOncePerFrame : 1;
 
    uint8 bRequiresDelegate : 1;
 
    ETimerStatus Status;
 
    ELevelCollectionType LevelCollection;
    
    float Rate;
 
    double ExpireTime;
 
    FTimerUnifiedDelegate TimerDelegate;
 
    FTimerHandle Handle;
 
    const void* TimerIndicesByObjectKey = nullptr;
 
    ENGINE_API FTimerData();
 
    // Movable only
    FTimerData(FTimerData&&) = default;
    FTimerData(const FTimerData&) = delete;
    FTimerData& operator=(FTimerData&&) = default;
    FTimerData& operator=(const FTimerData&) = delete;
};
 
struct FTimerManagerTimerParameters
{
    bool bLoop = false;
    bool bMaxOncePerFrame = false;
    float FirstDelay = -1.f;
};
 
class FTimerManager : public FNoncopyable
{
public:
 
    ENGINE_API void Tick(float DeltaTime);
    ENGINE_API TStatId GetStatId() const;
 
    // ----------------------------------
    // Timer API
 
    ENGINE_API explicit FTimerManager(UGameInstance* GameInstance = nullptr);
    ENGINE_API virtual ~FTimerManager();
 
    ENGINE_API virtual void OnCrash();
 
    template< class UserClass >
    inline void SetTimer(FTimerHandle& InOutHandle, UserClass* InObj, typename FTimerDelegate::TMethodPtr< UserClass > InTimerMethod, float InRate, bool InbLoop = false, float InFirstDelay = -1.f)
    {
        InternalSetTimer(InOutHandle, FTimerUnifiedDelegate( FTimerDelegate::CreateUObject(InObj, InTimerMethod) ), InRate, InbLoop, InFirstDelay);
    }
    template< class UserClass >
    inline void SetTimer(FTimerHandle& InOutHandle, UserClass* InObj, typename FTimerDelegate::TConstMethodPtr< UserClass > InTimerMethod, float InRate, bool InbLoop = false, float InFirstDelay = -1.f)
    {
        InternalSetTimer(InOutHandle, FTimerUnifiedDelegate( FTimerDelegate::CreateUObject(InObj, InTimerMethod) ), InRate, InbLoop, InFirstDelay);
    }
 
    inline void SetTimer(FTimerHandle& InOutHandle, FTimerDelegate const& InDelegate, float InRate, bool InbLoop, float InFirstDelay = -1.f)
    {
        InternalSetTimer(InOutHandle, FTimerUnifiedDelegate(InDelegate), InRate, InbLoop, InFirstDelay);
    }
    inline void SetTimer(FTimerHandle& InOutHandle, FTimerDynamicDelegate const& InDynDelegate, float InRate, bool InbLoop, float InFirstDelay = -1.f)
    {
        InternalSetTimer(InOutHandle, FTimerUnifiedDelegate(InDynDelegate), InRate, InbLoop, InFirstDelay);
    }
    /*** Version that doesn't take a delegate */
    inline void SetTimer(FTimerHandle& InOutHandle, float InRate, bool InbLoop, float InFirstDelay = -1.f)
    {
        InternalSetTimer(InOutHandle, FTimerUnifiedDelegate(), InRate, InbLoop, InFirstDelay);
    }
    inline void SetTimer(FTimerHandle& InOutHandle, TFunction<void(void)>&& Callback, float InRate, bool InbLoop, float InFirstDelay = -1.f )
    {
        InternalSetTimer(InOutHandle, FTimerUnifiedDelegate(MoveTemp(Callback)), InRate, InbLoop, InFirstDelay);
    }
 
    /* Preferred versions of the above methods that now take a more configurable structure that specifies timer looping and delay behavior. */
 
    template <class UserClass>
    inline void SetTimer(FTimerHandle& InOutHandle, UserClass* InObj, typename FTimerDelegate::TMethodPtr<UserClass> InTimerMethod, float InRate, const FTimerManagerTimerParameters& InTimerParameters)
    {
        InternalSetTimer(InOutHandle, FTimerUnifiedDelegate(FTimerDelegate::CreateUObject(InObj, InTimerMethod)), InRate, InTimerParameters);
    }
    template< class UserClass >
    inline void SetTimer(FTimerHandle& InOutHandle, UserClass* InObj, typename FTimerDelegate::TConstMethodPtr<UserClass> InTimerMethod, float InRate, const FTimerManagerTimerParameters& InTimerParameters)
    {
        InternalSetTimer(InOutHandle, FTimerUnifiedDelegate(FTimerDelegate::CreateUObject(InObj, InTimerMethod)), InRate, InTimerParameters);
    }
 
    inline void SetTimer(FTimerHandle& InOutHandle, FTimerDelegate const& InDelegate, float InRate, const FTimerManagerTimerParameters& InTimerParameters)
    {
        InternalSetTimer(InOutHandle, FTimerUnifiedDelegate(InDelegate), InRate, InTimerParameters);
    }
    inline void SetTimer(FTimerHandle& InOutHandle, FTimerDynamicDelegate const& InDynDelegate, float InRate, const FTimerManagerTimerParameters& InTimerParameters)
    {
        InternalSetTimer(InOutHandle, FTimerUnifiedDelegate(InDynDelegate), InRate, InTimerParameters);
    }
    /*** Version that doesn't take a delegate */
    inline void SetTimer(FTimerHandle& InOutHandle, float InRate, const FTimerManagerTimerParameters& InTimerParameters)
    {
        InternalSetTimer(InOutHandle, FTimerUnifiedDelegate(), InRate, InTimerParameters);
    }
    inline void SetTimer(FTimerHandle& InOutHandle, TFunction<void(void)>&& Callback, float InRate, const FTimerManagerTimerParameters& InTimerParameters)
    {
        InternalSetTimer(InOutHandle, FTimerUnifiedDelegate(MoveTemp(Callback)), InRate, InTimerParameters);
    }
 
    template< class UserClass >
    inline FTimerHandle SetTimerForNextTick(UserClass* inObj, typename FTimerDelegate::TMethodPtr< UserClass > inTimerMethod)
    {
        return InternalSetTimerForNextTick(FTimerUnifiedDelegate(FTimerDelegate::CreateUObject(inObj, inTimerMethod)));
    }
    template< class UserClass >
    inline FTimerHandle SetTimerForNextTick(UserClass* inObj, typename FTimerDelegate::TConstMethodPtr< UserClass > inTimerMethod)
    {
        return InternalSetTimerForNextTick(FTimerUnifiedDelegate(FTimerDelegate::CreateUObject(inObj, inTimerMethod)));
    }
 
    inline FTimerHandle SetTimerForNextTick(FTimerDelegate const& InDelegate)
    {
        return InternalSetTimerForNextTick(FTimerUnifiedDelegate(InDelegate));
    }
    inline FTimerHandle SetTimerForNextTick(FTimerDynamicDelegate const& InDynDelegate)
    {
        return InternalSetTimerForNextTick(FTimerUnifiedDelegate(InDynDelegate));
    }
    inline FTimerHandle SetTimerForNextTick(TFunction<void(void)>&& Callback)
    {
        return InternalSetTimerForNextTick(FTimerUnifiedDelegate(MoveTemp(Callback)));
    }
 
    inline void ClearTimer(FTimerHandle& InHandle)
    {
        if (const FTimerData* TimerData = FindTimer(InHandle))
        {
            InternalClearTimer(InHandle);
        }
        InHandle.Invalidate();
    }
 
    inline void ClearAllTimersForObject(void const* Object)
    {
        if (Object)
        {
            InternalClearAllTimers( Object );
        }
    }
 
    ENGINE_API void PauseTimer(FTimerHandle InHandle);
 
    ENGINE_API void UnPauseTimer(FTimerHandle InHandle);
 
    inline float GetTimerRate(FTimerHandle InHandle) const
    {
        FTimerData const* const TimerData = FindTimer(InHandle);
        return InternalGetTimerRate(TimerData);
    }
 
    inline bool IsTimerActive(FTimerHandle InHandle) const
    {
        FTimerData const* const TimerData = FindTimer( InHandle );
        return TimerData && TimerData->Status != ETimerStatus::Paused;
    }
 
    inline bool IsTimerPaused(FTimerHandle InHandle) const
    {
        FTimerData const* const TimerData = FindTimer(InHandle);
        return TimerData && TimerData->Status == ETimerStatus::Paused;
    }
 
    inline bool IsTimerPending(FTimerHandle InHandle) const
    {
        FTimerData const* const TimerData = FindTimer(InHandle);
        return TimerData && TimerData->Status == ETimerStatus::Pending;
    }
 
    inline bool TimerExists(FTimerHandle InHandle) const
    {
        return FindTimer(InHandle) != nullptr;
    }
 
    inline float GetTimerElapsed(FTimerHandle InHandle) const
    {
        FTimerData const* const TimerData = FindTimer(InHandle);
        return InternalGetTimerElapsed(TimerData);
    }
 
    inline float GetTimerRemaining(FTimerHandle InHandle) const
    {
        FTimerData const* const TimerData = FindTimer(InHandle);
        return InternalGetTimerRemaining(TimerData);
    }
 
    bool inline HasBeenTickedThisFrame() const
    {
        return (LastTickedFrame == GFrameCounter);
    }
 
    ENGINE_API FTimerHandle K2_FindDynamicTimerHandle(FTimerDynamicDelegate InDynamicDelegate) const;
 
    ENGINE_API void ListTimers() const;
 
private:
    ENGINE_API void SetGameInstance(UGameInstance* InGameInstance);
 
// This should be private, but needs to be public for testing.
public:
    ENGINE_API FTimerHandle GenerateHandle(int32 Index);
 
// These should be private, but need to be protected so IMPLEMENT_GET_PROTECTED_FUNC works for testing.
protected:
    inline FTimerData const* FindTimer(FTimerHandle const& InHandle) const
    {
        return const_cast<FTimerManager*>(this)->FindTimer(InHandle);
    }
    ENGINE_API FTimerData* FindTimer( FTimerHandle const& InHandle );
 
private:
    ENGINE_API void InternalSetTimer( FTimerHandle& InOutHandle, FTimerUnifiedDelegate&& InDelegate, float InRate, bool bInLoop, float InFirstDelay );
    ENGINE_API void InternalSetTimer( FTimerHandle& InOutHandle, FTimerUnifiedDelegate&& InDelegate, float InRate, const FTimerManagerTimerParameters& InTimerParameters );
    ENGINE_API FTimerHandle InternalSetTimerForNextTick( FTimerUnifiedDelegate&& InDelegate );
    ENGINE_API void InternalClearTimer( FTimerHandle InDelegate );
    ENGINE_API void InternalClearAllTimers( void const* Object );
    ENGINE_API float InternalGetTimerRate( FTimerData const* const TimerData ) const;
    ENGINE_API float InternalGetTimerElapsed( FTimerData const* const TimerData ) const;
    ENGINE_API float InternalGetTimerRemaining( FTimerData const* const TimerData ) const;
 
    inline const FTimerData& GetTimer(const FTimerHandle& InHandle) const
    {
        return const_cast<FTimerManager*>(this)->GetTimer(InHandle);
    }
    ENGINE_API FTimerData& GetTimer(FTimerHandle const& InHandle);
 
    ENGINE_API FTimerHandle AddTimer(FTimerData&& TimerData);
    ENGINE_API void RemoveTimer(FTimerHandle Handle);
    ENGINE_API bool WillRemoveTimerAssert(FTimerHandle Handle) const;
 
    TSparseArray<FTimerData> Timers;
    TArray<FTimerHandle> ActiveTimerHeap;
    TSet<FTimerHandle> PausedTimerSet;
    TSet<FTimerHandle> PendingTimerSet;
    TMap<const void*, TSet<FTimerHandle>> ObjectToTimers;
 
    double InternalTime;
 
    FTimerHandle CurrentlyExecutingTimer;
 
    uint64 LastTickedFrame;
 
    static ENGINE_API uint64 LastAssignedSerialNumber;
 
    UGameInstance* OwningGameInstance;
 
#if UE_ENABLE_TRACKING_TIMER_SOURCES
    TUniquePtr<FTimerSourceList> TimerSourceList;
#endif
};