Ticker.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "Containers/MpscQueue.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "Templates/Function.h"
#include "Templates/SharedPointer.h"
 
#include <atomic>
 
DECLARE_DELEGATE_RetVal_OneParam(bool, FTickerDelegate, float);
 
class FTSTicker
{
private:
    struct FElement;
 
public:
    using FDelegateHandle = TWeakPtr<FElement>;
 
    [[nodiscard]] static CORE_API FTSTicker& GetCoreTicker();
 
    CORE_API FDelegateHandle AddTicker(const FTickerDelegate & InDelegate, float InDelay = 0.0f);
 
    CORE_API FDelegateHandle AddTicker(const TCHAR* InName, float InDelay, TUniqueFunction<bool(float)>&& InFunction);
 
    static CORE_API void RemoveTicker(FDelegateHandle Handle);
 
    CORE_API void Tick(float DeltaTime);
 
    CORE_API void Reset();
 
private:
    struct FElement
    {
        double FireTime;
        float DelayTime;
        TUniqueFunction<bool(float)> Function;
 
        static constexpr uint64 DefaultState = 0;
        static constexpr uint64 RemovedState = 1;
        // The element can be in 4 states: "idle", "executing", "idle and removed" and "executing and removed"
        // Often right after `RemoveTicket()` call resources that are used by the delegate are destroyed. We must ensure that 
        // these resources are not accessed by the delegate after `RemoveTicket()` returns.
        // `State` is used to remove the element safely, if removal happens in the middle of the delegate execution, removal will not return
        // until the execution is finished.
        // `State` constists of two 32 bits parts: lower part is 1 if the delegate is removed, otherwise it's 0. the higher part contains thread id if the
        // delegate being executed, otherwise it's 0
        std::atomic<uint64> State{ DefaultState };
 
        [[nodiscard]] CORE_API FElement();
        [[nodiscard]] CORE_API FElement(double InFireTime, float InDelayTime, const FTickerDelegate& InDelegate);
        [[nodiscard]] CORE_API FElement(double InFireTime, float InDelayTime, TUniqueFunction<bool(float)>&& InFunction);
 
        CORE_API bool Fire(float DeltaTime);
    };
 
    using FElementPtr = TSharedPtr<FElement>;
 
    // all added delegates are initially stored in a separate thread-safe queue and then in the next Tick are moved to the main not thread-safe
    // container
    TMpscQueue<FElementPtr> AddedElements;
 
    std::atomic<double> CurrentTime{ 0.0 };
    TArray<FElementPtr> Elements;
};
 
class FTSTickerObjectBase
{
public:
    UE_NONCOPYABLE(FTSTickerObjectBase);
 
    [[nodiscard]] CORE_API FTSTickerObjectBase(float InDelay = 0.0f, FTSTicker& Ticker = FTSTicker::GetCoreTicker());
 
    CORE_API virtual ~FTSTickerObjectBase();
 
    virtual bool Tick(float DeltaTime) = 0;
 
private:
    FTSTicker::FDelegateHandle TickHandle;
};
 
// Schedules execution of the given functor on the game thread at a particular moment of a frame when interference with other systems 
// is minimal.
template<typename FunctorType>
void ExecuteOnGameThread(const TCHAR* DebugName, FunctorType&& Functor)
{
    FTSTicker::GetCoreTicker().AddTicker(DebugName, 0.0f,
        [Functor = MoveTemp(Functor)] (float) mutable
        {
            Functor();
            return false;
        }
    );
}