Unreal TickFunc调度

int32 GuardedMain( const TCHAR* CmdLine )
{
    <初始化代码>

    BootTimingPoint("Tick loop starting");
    DumpBootTiming();

    while( !IsEngineExitRequested() )
    {
        EngineTick();
    }

    TRACE_BOOKMARK(TEXT("Tick loop end"));

    <其他代码>
}

GuardedMain(const wchar_t * CmdLine)
  EngineTick()
    FEngineLoop::Tick()
      UGameEngine::Tick(float DeltaSeconds, bool bIdleMode)
        UWorld::Tick(ELevelTick TickType, float DeltaSeconds)

void FEngineLoop::Tick()
{
    <其他代码>

    // set FApp::CurrentTime, FApp::DeltaTime and potentially wait to enforce max tick rate
    {
        QUICK_SCOPE_CYCLE_COUNTER(STAT_FEngineLoop_UpdateTimeAndHandleMaxTickRate);
        GEngine->UpdateTimeAndHandleMaxTickRate();
        GEngine->SetGameLatencyMarkerStart(CurrentFrameCounter);
    }

    <其他代码>  

    // main game engine tick (world, game objects, etc.)
    GEngine->Tick(FApp::GetDeltaTime(), bIdleMode);

    <其他代码>  

    // Increment global frame counter. Once for each engine tick.
    GFrameCounter++;

    <其他代码>  
}

void UWorld::Tick( ELevelTick TickType, float DeltaSeconds )
{
    <其他代码>

    {
        SCOPE_CYCLE_COUNTER(STAT_NetWorldTickTime);
        CSV_SCOPED_TIMING_STAT_EXCLUSIVE(NetworkIncoming);
        CSV_SCOPED_SET_WAIT_STAT(NetworkTick);
        SCOPE_TIME_GUARD(TEXT("UWorld::Tick - NetTick"));
        LLM_SCOPE(ELLMTag::Networking);
        // Update the net code and fetch all incoming packets.
        BroadcastTickDispatch(DeltaSeconds);
        BroadcastPostTickDispatch();

        if( NetDriver && NetDriver->ServerConnection )
        {
            TickNetClient( DeltaSeconds );
        }
    }

    <调用Actor Component等的Tick函数>

    // Update net and flush networking.
    // Tick all net drivers
    {
        SCOPE_CYCLE_COUNTER(STAT_NetBroadcastTickTime);
        LLM_SCOPE(ELLMTag::Networking);
        BroadcastTickFlush(RealDeltaSeconds); // note: undilated time is being used here
    }

UPROPERTY(EditDefaultsOnly, Category=Tick)
    struct FActorTickFunction PrimaryActorTick;

void AActor::InitializeDefaults()
{
    PrimaryActorTick.TickGroup = TG_PrePhysics;
    // Default to no tick function, but if we set 'never ticks' to false (so there is a tick function) it is enabled by default
    PrimaryActorTick.bCanEverTick = false;
    PrimaryActorTick.bStartWithTickEnabled = true;
    PrimaryActorTick.SetTickFunctionEnable(false); 
    <other-init-code>

AMyActor::AMyActor()
{
    // Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
    PrimaryActorTick.bCanEverTick = true;
}

#if !UE_SERVER  
    PrimaryActorTick.bCanEverTick = false;  // client tick. default disable
#else
    PrimaryActorTick.bCanEverTick = false;  // ds tick. default disble
#endif

void AActor::RegisterActorTickFunctions(bool bRegister)
{
    check(!IsTemplate());

    if(bRegister)
    {
        if(PrimaryActorTick.bCanEverTick)
        {
            PrimaryActorTick.Target = this;
            PrimaryActorTick.SetTickFunctionEnable(PrimaryActorTick.bStartWithTickEnabled || PrimaryActorTick.IsTickFunctionEnabled());
            PrimaryActorTick.RegisterTickFunction(GetLevel());
        }
    }
    else
    {
        if(PrimaryActorTick.IsTickFunctionRegistered())
        {
            PrimaryActorTick.UnRegisterTickFunction();          
        }
    }

    FActorThreadContext::Get().TestRegisterTickFunctions = this; // we will verify the super call chain is intact. Don't copy and paste this to another actor class!
}

void FActorTickFunction::ExecuteTick(float DeltaTime, enum ELevelTick TickType, ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent)
{
    if (Target && !Target->IsPendingKillOrUnreachable())
    {
        if (TickType != LEVELTICK_ViewportsOnly || Target->ShouldTickIfViewportsOnly())
        {
            FScopeCycleCounterUObject ActorScope(Target);
            Target->TickActor(DeltaTime*Target->CustomTimeDilation, TickType, *this);
        }
    }
}

void AActor::TickActor( float DeltaSeconds, ELevelTick TickType, FActorTickFunction& ThisTickFunction )
{
    //root of tick hierarchy

    // Non-player update.
    // If an Actor has been Destroyed or its level has been unloaded don't execute any queued ticks
    if (!IsPendingKill() && GetWorld())
    {
        Tick(DeltaSeconds); // perform any tick functions unique to an actor subclass
    }
}

UENUM(BlueprintType)
enum ETickingGroup
{
    /** Any item that needs to be executed before physics simulation starts. */
    TG_PrePhysics UMETA(DisplayName="Pre Physics"),

    /** Special tick group that starts physics simulation. */                           
    TG_StartPhysics UMETA(Hidden, DisplayName="Start Physics"),

    /** Any item that can be run in parallel with our physics simulation work. */
    TG_DuringPhysics UMETA(DisplayName="During Physics"),

    /** Special tick group that ends physics simulation. */
    TG_EndPhysics UMETA(Hidden, DisplayName="End Physics"),

    /** Any item that needs rigid body and cloth simulation to be complete before being executed. */
    TG_PostPhysics UMETA(DisplayName="Post Physics"),

    /** Any item that needs the update work to be done before being ticked. */
    TG_PostUpdateWork UMETA(DisplayName="Post Update Work"),

    /** Catchall for anything demoted to the end. */
    TG_LastDemotable UMETA(Hidden, DisplayName = "Last Demotable"),

    /** Special tick group that is not actually a tick group. After every tick group this is repeatedly re-run until there are no more newly spawned items to run. */
    TG_NewlySpawned UMETA(Hidden, DisplayName="Newly Spawned"),

    TG_MAX,
};