TickManager.cpp

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>.
 
#include "TickManager.h"
 
#include "Engine/GameViewportClient.h"
#include "Engine.h"
 
#include "Async/ParallelFor.h"
 
ATickManager* ATickManager::Instance = nullptr;
std::vector<FTickEntry> ATickManager::FullFrameTaskFunctions;
std::vector<FTickEntry> ATickManager::FullFrameTaskBeforeLateTickFunctions;
std::vector<FTickEntry> ATickManager::EarlyTickFunctions;
std::vector<FTickEntry> ATickManager::LateTickFunctions;
std::vector<FTickEntry> ATickManager::TicksToRemove;
 
void ATickManager::BeginPlay()
{
    Super::BeginPlay();
 
    if (Instance == nullptr)
    {
        Instance = this;
 
        // Subscribe to pre and post tick actor delegates
        OnPreTickDelegate = FWorldDelegates::OnWorldPreActorTick.AddUObject(this, &ATickManager::PreTick);
        OnPostTickDelegate = FWorldDelegates::OnWorldPostActorTick.AddUObject(this, &ATickManager::PostTick);
    }
    else
    {
        Destroy();
    }
}
 
void ATickManager::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    Super::EndPlay(EndPlayReason);
 
    if (Instance == this)
    {
        FullFrameTaskFunctions.clear();
        FullFrameTaskBeforeLateTickFunctions.clear();
        EarlyTickFunctions.clear();
        LateTickFunctions.clear();
        TicksToRemove.clear();
        FWorldDelegates::OnWorldPreActorTick.Remove(OnPreTickDelegate);
        FWorldDelegates::OnWorldPostActorTick.Remove(OnPostTickDelegate);
        Instance = nullptr;
    }
}
 
FTickEntry ATickManager::AddTick(UObject* Object, std::function<void(float)> Function, ETickType Type)
{
    if (Instance == nullptr)
    {
        if (GEngine || GEngine->GameViewport)
        {
            UWorld* World = GEngine->GameViewport->GetWorld();
            World->SpawnActor<ATickManager>();
        }
    }
 
    FTickEntry TickEntry(Object, Function, Type);
 
    switch (Type)
    {
    case ETickType::FullFrameTaskParallel:
        AddTickInternal(FullFrameTaskFunctions, TickEntry);
        break;
    case ETickType::FullFrameTaskBeforeLateTickParallel:
        AddTickInternal(FullFrameTaskBeforeLateTickFunctions, TickEntry);
        break;
    case ETickType::EarlyTickParallel:
        AddTickInternal(EarlyTickFunctions, TickEntry);
        break;
    case ETickType::LateTickParallel:
        AddTickInternal(LateTickFunctions, TickEntry);
        break;
    default:
        UE_LOG(LogTemp, Warning, TEXT("TickManager.cpp: Unsupported ETickType in AddTick."));
        break;
    }
 
    return TickEntry;
}
 
void ATickManager::RemoveTick(FTickEntry TickEntry)
{
    // Add tick entry to remove into std::vector. These get deleted at the end of the frame.
    TicksToRemove.push_back(TickEntry);
}
 
void ATickManager::PreTick(UWorld* World, ELevelTick TickType, float DeltaSeconds)
{
    // Start FullFrameTask that runs the entire frame
    // if the task is small, it can finish at any time
    if (FullFrameTaskFunctions.size() != 0)
    {
        FullFrameTask = FFunctionGraphTask::CreateAndDispatchWhenReady([this, DeltaSeconds]()
            {
                TickFunctionsParallel(FullFrameTaskFunctions, DeltaSeconds);
            }, TStatId(), nullptr, ENamedThreads::AnyBackgroundHiPriTask);
    }
 
    // Start FullFrameTaskBeforeLateTick that finishes before calling LateTickFunctions 
    // if the task is small, it can finish at any time
    if (FullFrameTaskBeforeLateTickFunctions.size() != 0)
    {
        FullFrameTaskBeforeLateTick = FFunctionGraphTask::CreateAndDispatchWhenReady([this, DeltaSeconds]()
        {
            TickFunctionsParallel(FullFrameTaskBeforeLateTickFunctions, DeltaSeconds);
        }, TStatId(), nullptr, ENamedThreads::AnyBackgroundHiPriTask);
    }
 
    // Tick all added early ticks in parallel before continuing
    if (EarlyTickFunctions.size() != 0)
    {
        TickFunctionsParallel(EarlyTickFunctions, DeltaSeconds);
    }
}
 
void ATickManager::PostTick(UWorld* World, ELevelTick TickType, float DeltaSeconds)
{
    // Wait till all FullFrameTaskBeforeLateTick ticks are completed
    if (FullFrameTaskBeforeLateTick.IsValid())
    {
        FTaskGraphInterface::Get().WaitUntilTaskCompletes(FullFrameTaskBeforeLateTick);
    }
 
    // Tick all added late ticks in parallel
    if (LateTickFunctions.size() != 0)
    {
        TickFunctionsParallel(LateTickFunctions, DeltaSeconds);
    }
 
    // Wait till all FullFrameTask ticks are completed
    if (FullFrameTask.IsValid())
    {
        FTaskGraphInterface::Get().WaitUntilTaskCompletes(FullFrameTask);
    }
 
    FrameCleanup();
}
 
inline void ATickManager::TickFunctionsParallel(std::vector<FTickEntry>& functions, const float DeltaTime)
{
    bool foundNull = false;
    //std::vector<FTickEntry> functionsCopy = functions;
    const int size = functions.size();
    ParallelFor(size, [&](int32 index)
    {
        FTickEntry& tickEntry = functions[index];
        if (tickEntry.Owner != nullptr)
        {
            tickEntry.Tick(DeltaTime);
        }
        else
        {
            foundNull = true;
        }
    }, EParallelForFlags::Unbalanced);
 
    if (foundNull)
    {
        functions.erase(std::remove_if(functions.begin(), functions.end(), [](const FTickEntry& Entry) { return Entry.Owner == nullptr; }), functions.end());
    }
}
 
 
void ATickManager::FrameCleanup()
{
    if (TicksToRemove.size() != 0)
    {
        for (const FTickEntry& tickEntry : TicksToRemove)
        {
            ETickType Type = tickEntry.TickType;
            switch (Type)
            {
            case ETickType::FullFrameTaskParallel:
                RemoveTickInternal(FullFrameTaskFunctions, tickEntry);
                break;
            case ETickType::FullFrameTaskBeforeLateTickParallel:
                RemoveTickInternal(FullFrameTaskBeforeLateTickFunctions, tickEntry);
                break;
            case ETickType::EarlyTickParallel:
                RemoveTickInternal(EarlyTickFunctions, tickEntry);
                break;
            case ETickType::LateTickParallel:
                RemoveTickInternal(LateTickFunctions, tickEntry);
                break;
            default:
                UE_LOG(LogTemp, Warning, TEXT("TickManager.cpp: Unsupported ETickType in RemoveTick."));
                break;
            }
        }
        TicksToRemove.clear();
    }
 
    // Destroy this Actor if we have no ticks
    // TODO: Should we just keep this alive?
    if (FullFrameTaskFunctions.size() == 0 &&
        FullFrameTaskBeforeLateTickFunctions.size() == 0 &&
        EarlyTickFunctions.size() == 0 &&
        LateTickFunctions.size() == 0)
    {
        if (Instance != nullptr)
        {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("TickManager.cpp: Destroying as there are no more ticks."));
#endif
            Instance->Destroy();
            Instance = nullptr;
        }
    }
}