ATickManager Class Reference

#include <TickManager.h>

Inheritance diagram for ATickManager:

Collaboration diagram for ATickManager:

Static Public Member Functions
static FTickEntry	AddTick (UObject *Object, std::function< void(float)> Function, ETickType Type)
static void	RemoveTick (FTickEntry TickEntry)

Private Member Functions
virtual void	BeginPlay () override
virtual void	EndPlay (const EEndPlayReason::Type EndPlayReason) override
void	PreTick (UWorld *World, ELevelTick TickType, float DeltaSeconds)
void	PostTick (UWorld *World, ELevelTick TickType, float DeltaSeconds)
void	FrameCleanup ()
void	TickFunctionsParallel (std::vector< FTickEntry > &functions, const float DeltaTime)

Static Private Member Functions
static void	AddTickInternal (std::vector< FTickEntry > &to, const FTickEntry &newTickEntry)
static void	RemoveTickInternal (std::vector< FTickEntry > &from, FTickEntry tickEntry)

Private Attributes
FDelegateHandle	OnPreTickDelegate
FDelegateHandle	OnPostTickDelegate
FGraphEventRef	FullFrameTask

Static Private Attributes
static ATickManager *	Instance = nullptr
static std::vector< FTickEntry >	FullFrameTaskFunctions
static std::vector< FTickEntry >	LateTickFunctions
static std::vector< FTickEntry >	TicksToRemove

Detailed Description

ATickManager is an actor class responsible for ticking of sensor actors (or any added Actor) in parallel. How this works:

– Start of a new frame –

1) OnWorldPreActorTick (PreTick):

• Starts FullFrameTaskParallel task.

2) Regular AActor::Tick occurs.

3) OnWorldPostActorTick (PostTick):

• Executes LateTickFunctions in parallel.
• Concludes FullFrameTaskParallel Task initiated in EarlyTick.

– End of the frame –

Usage (Note: "MyActor::MyFunction" must take a float parameter): FTickEntry entry = ATickManager::AddTick(this, &MyActor::MyFunction, ETickType::FullFrameTaskParallel); ATickManager::RemoveTick(entry);

Definition at line 88 of file TickManager.h.

Member Function Documentation

AddTick()

FTickEntry ATickManager::AddTick ( UObject *  Object, std::function< void(float)>  Function, ETickType  Type  )

static

Adds a tick function to the ATickManager.

Parameters

TickFunction	The tick function to be added. It should take a single float parameter representing DeltaTime.
Type	The type of tick to which the function should be added. Valid types are: ETickType::FullFrameTaskParallel: The function will be executed during FullFrameTaskParallel tick. ETickType::LateTickParallel: The function will be executed during LateTickParallel tick.

Definition at line 51 of file TickManager.cpp.

{
    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::LateTickParallel:
        AddTickInternal(LateTickFunctions, TickEntry);
        break;
    default:
        UE_LOG(LogTemp, Warning, TEXT("TickManager.cpp: Unsupported ETickType in AddTick."));
        break;
    }
 
    return TickEntry;
}

References AddTickInternal(), FullFrameTaskFunctions, Instance, and LateTickFunctions.

Referenced by ALidarManager::AddRaycastLidar(), ACamera::BeginPlay(), and ATransformSensor::BeginPlay().

AddTickInternal()

static void ATickManager::AddTickInternal ( std::vector< FTickEntry > &  to, const FTickEntry &  newTickEntry  )

inlinestaticprivate

Definition at line 137 of file TickManager.h.

    {
        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
    }

Referenced by AddTick().

BeginPlay()

void ATickManager::BeginPlay ( )

overrideprivatevirtual

Definition at line 18 of file TickManager.cpp.

{
    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();
    }
}

References Destroy, Instance, OnPostTickDelegate, OnPreTickDelegate, PostTick(), and PreTick().

EndPlay()

void ATickManager::EndPlay ( const EEndPlayReason::Type  EndPlayReason )

overrideprivatevirtual

Definition at line 36 of file TickManager.cpp.

{
    Super::EndPlay(EndPlayReason);
 
    if (Instance == this)
    {
        FullFrameTaskFunctions.clear();
        LateTickFunctions.clear();
        TicksToRemove.clear();
        FWorldDelegates::OnWorldPreActorTick.Remove(OnPreTickDelegate);
        FWorldDelegates::OnWorldPostActorTick.Remove(OnPostTickDelegate);
        Instance = nullptr;
    }
}

References FullFrameTaskFunctions, Instance, LateTickFunctions, OnPostTickDelegate, OnPreTickDelegate, and TicksToRemove.

FrameCleanup()

void ATickManager::FrameCleanup ( )

private

Definition at line 140 of file TickManager.cpp.

{
    if (TicksToRemove.size() != 0)
    {
        for (const FTickEntry& tickEntry : TicksToRemove)
        {
            ETickType Type = tickEntry.TickType;
            switch (Type)
            {
            case ETickType::FullFrameTaskParallel:
                RemoveTickInternal(FullFrameTaskFunctions, 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 &&
        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;
        }
    }
}

References FullFrameTaskFunctions, Instance, LateTickFunctions, RemoveTickInternal(), and TicksToRemove.

Referenced by PostTick().

PostTick()

void ATickManager::PostTick ( UWorld *  World, ELevelTick  TickType, float  DeltaSeconds  )

private

Definition at line 99 of file TickManager.cpp.

{
    // 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();
}

References FrameCleanup(), FullFrameTask, LateTickFunctions, and TickFunctionsParallel().

Referenced by BeginPlay().

PreTick()

void ATickManager::PreTick ( UWorld *  World, ELevelTick  TickType, float  DeltaSeconds  )

private

Definition at line 86 of file TickManager.cpp.

{
    // 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);
    }
}

References FullFrameTask, FullFrameTaskFunctions, and TickFunctionsParallel().

Referenced by BeginPlay().

RemoveTick()

void ATickManager::RemoveTick ( FTickEntry  TickEntry )

static

Removes a tick function from the ATickManager.

Parameters

TickFunction	The tick function to be removed. It should match the exact function previously added using AddTick.
Type	The type of tick from which the function should be removed. Valid types are the same as for AddTick: ETickType::FullFrameTaskParallel ETickType::LateTickParallel

Note

If the specified function was not previously added for the given tick type, this function has no effect.

Definition at line 80 of file TickManager.cpp.

{
    // Add tick entry to remove into std::vector. These get deleted at the end of the frame.
    TicksToRemove.push_back(TickEntry);
}

References TicksToRemove.

Referenced by ACamera::EndPlay(), ALidarManager::EndPlay(), ATransformSensor::EndPlay(), and ALidarManager::RemoveRaycastLidar().

RemoveTickInternal()

static void ATickManager::RemoveTickInternal ( std::vector< FTickEntry > &  from, FTickEntry  tickEntry  )

inlinestaticprivate

Definition at line 155 of file TickManager.h.

    {
        from.erase(std::remove(from.begin(), from.end(), tickEntry), from.end());
    }

Referenced by FrameCleanup().

TickFunctionsParallel()

void ATickManager::TickFunctionsParallel ( std::vector< FTickEntry > &  functions, const float  DeltaTime  )

inlineprivate

Definition at line 116 of file TickManager.cpp.

{
    bool foundNull = false;
    //std::vector<FTickEntry> functionsCopy = functions;
    const int32 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());
    }
}

References FTickEntry::Owner.

Referenced by PostTick(), and PreTick().

Member Data Documentation

FullFrameTask

FGraphEventRef ATickManager::FullFrameTask

private

Definition at line 130 of file TickManager.h.

Referenced by PostTick(), and PreTick().

FullFrameTaskFunctions

std::vector< FTickEntry > ATickManager::FullFrameTaskFunctions

staticprivate

Definition at line 133 of file TickManager.h.

Referenced by AddTick(), EndPlay(), FrameCleanup(), and PreTick().

Instance

ATickManager * ATickManager::Instance = nullptr

staticprivate

Definition at line 132 of file TickManager.h.

Referenced by AddTick(), BeginPlay(), EndPlay(), and FrameCleanup().

LateTickFunctions

std::vector< FTickEntry > ATickManager::LateTickFunctions

staticprivate

Definition at line 134 of file TickManager.h.

Referenced by AddTick(), EndPlay(), FrameCleanup(), and PostTick().

OnPostTickDelegate

FDelegateHandle ATickManager::OnPostTickDelegate

private

Definition at line 123 of file TickManager.h.

Referenced by BeginPlay(), and EndPlay().

OnPreTickDelegate

FDelegateHandle ATickManager::OnPreTickDelegate

private

Definition at line 120 of file TickManager.h.

Referenced by BeginPlay(), and EndPlay().

TicksToRemove

std::vector< FTickEntry > ATickManager::TicksToRemove

staticprivate

Definition at line 135 of file TickManager.h.

Referenced by EndPlay(), FrameCleanup(), and RemoveTick().

---

The documentation for this class was generated from the following files:

• Unreal/Agrarsense/Source/Agrarsense/Managers/TickManager.h
• Unreal/Agrarsense/Source/Agrarsense/Managers/TickManager.cpp