TickManager.h

Go to the documentation of this file.

// Copyright (c) 2023 FrostBit Software Lab at the Lapland University of Applied Sciences
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#pragma once
 
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "UObject/Object.h"
#include "Delegates/IDelegateInstance.h"
#include "Async/TaskGraphInterfaces.h"
#include "GenericPlatform/GenericPlatformMisc.h"
#include "Engine/World.h"
 
#include <functional>
#include <algorithm>
#include <vector>
 
#include "TickManager.generated.h"
 
UENUM(BlueprintType)
enum class ETickType : uint8
{
    FullFrameTaskParallel UMETA(DisplayName = "FullFrameTaskParallel"),
 
    FullFrameTaskBeforeLateTickParallel UMETA(DisplayName = "FullFrameTaskBeforeLateTickParallel"),
 
    EarlyTickParallel UMETA(DisplayName = "EarlyTickParallel"),
 
    LateTickParallel UMETA(DisplayName = "LateTickParallel"),
 
    NONE UMETA(DisplayName = "NONE")
};
 
USTRUCT()
struct FTickEntry
{
    GENERATED_BODY()
 
    UPROPERTY()
    UObject* Owner;
 
    std::function<void(float)> Tick;
 
    ETickType TickType = ETickType::NONE;
 
    FTickEntry() : Owner(nullptr) {}
 
    FTickEntry(UObject* InOwner, std::function<void(float)> InTickFunction, ETickType InType)
        : Owner(InOwner), Tick(InTickFunction), TickType(InType) {}
 
    bool operator==(const FTickEntry& Other) const
    {
        return Owner == Other.Owner && TickType == Other.TickType;
    }
};
 
UCLASS()
class AGRARSENSE_API ATickManager : public AActor
{
    GENERATED_BODY()
 
public:
 
    static FTickEntry AddTick(UObject* Object, std::function<void(float)> Function, ETickType Type);
 
    static void RemoveTick(FTickEntry TickEntry);
 
private:
 
    virtual void BeginPlay() override;
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
 
    FDelegateHandle OnPreTickDelegate;
    void PreTick(UWorld* World, ELevelTick TickType, float DeltaSeconds);
 
    FDelegateHandle OnPostTickDelegate;
    void PostTick(UWorld* World, ELevelTick TickType, float DeltaSeconds);
 
    void FrameCleanup();
 
    inline void TickFunctionsParallel(std::vector<FTickEntry>& functions, const float DeltaTime);
 
    FGraphEventRef FullFrameTaskBeforeLateTick;
    FGraphEventRef FullFrameTask;
 
    static ATickManager* Instance;
    static std::vector<FTickEntry> FullFrameTaskFunctions;
    static std::vector<FTickEntry> FullFrameTaskBeforeLateTickFunctions;
    static std::vector<FTickEntry> EarlyTickFunctions;
    static std::vector<FTickEntry> LateTickFunctions;
    static std::vector<FTickEntry> TicksToRemove;
 
    inline static void AddTickInternal(std::vector<FTickEntry>& to, const FTickEntry& newTickEntry)
    {
        bool found = std::find_if(to.begin(), to.end(), [&](const FTickEntry& entry) {
            return (entry.Owner == newTickEntry.Owner && entry.TickType == newTickEntry.TickType);
        }) != to.end();
 
        if (!found)
        {
            to.emplace_back(newTickEntry);
        }
#if WITH_EDITOR
        else
        {
            UE_LOG(LogTemp, Warning, TEXT("TickManager.h: This entry already exists. Returning."));
        }
#endif
    }
 
    inline static void RemoveTickInternal(std::vector<FTickEntry>& from, FTickEntry tickEntry)
    {
        from.erase(std::remove(from.begin(), from.end(), tickEntry), from.end());
    }
};
 
template <typename ObjectType, typename FunctionType>
static auto BindTick(ObjectType* Object, FunctionType Function)
{
    return [Object, Function](float DeltaTime)
    {
        (Object->*Function)(DeltaTime);
    };
}