在https://docs.unrealengine.com/en-us/Programming/UnrealArchitecture/Actors/ActorLifecycle 官方的编程文档中，UE4官方给出了有关Actor生命周期的宝贵资料.
这里我就跟着资料追着源码剖解一遍游戏运行时产生Actor的函数-----------------SpawnActor和SpawnActorDeferred的产生Actor调用各种函数的流程
在UE4中我们一般调用来自于 World.h 的各种SpawnActor<T>(....),如下面的
template< class T >
T* SpawnActor( UClass* Class, FVector const& Location, FRotator const& Rotation, const FActorSpawnParameters& SpawnParameters = FActorSpawnParameters() )
{
return CastChecked<T>(SpawnActor(Class, &Location, &Rotation, SpawnParameters),ECastCheckedType::NullAllowed);
}SpawnActor<T>各种模板函数的SpawnActor来源于LevelActor.cpp,所以我们来到LevelActor.cpp。
上面在 Wolrd.h 的各种 SpawnActor 的模板函数都来源于LevelActor.cpp的SpawnActor函数，贴出小部分代码：
在LevelActor.cpp 299 行
AActor* UWorld::SpawnActor( UClass* Class, FTransform const* UserTransformPtr, const FActorSpawnParameters& SpawnParameters )
{
SCOPE_CYCLE_COUNTER(STAT_SpawnActorTime);
SCOPE_TIME_GUARD_NAMED_MS(TEXT("SpawnActor Of Type"), Class->GetFName(), 2);
check( CurrentLevel );
check(GIsEditor || (CurrentLevel == PersistentLevel));
// Make sure this class is spawnable.
if( !Class )
{
UE_LOG(LogSpawn, Warning, TEXT("SpawnActor failed because no class was specified") );
return NULL;
}
#if ENABLE_SPAWNACTORTIMER
FScopedSpawnActorTimer SpawnTimer(Class->GetFName(), SpawnParameters.bDeferConstruction ? ESpawnActorTimingType::SpawnActorDeferred : ESpawnActorTimingType::SpawnActorNonDeferred);
#endif
往下看来到 LevelActor.cpp 432 行, 可以看到我们的Actor创建其实也是通过NewObject
AActor* const Actor = NewObject<AActor>(LevelToSpawnIn, Class, NewActorName, SpawnParameters.ObjectFlags, Template);往下看到 LevelActor.cpp 465 行，看到对应Actor生命周期图----Actor的PostSpawnInitialize函数执行
Actor->PostSpawnInitialize(UserTransform, SpawnParameters.Owner, SpawnParameters.Instigator, SpawnParameters.IsRemoteOwned(), SpawnParameters.bNoFail, SpawnParameters.bDeferConstruction);下面追寻到 Actor.cpp 中去。
上面说到Actor的PostSpawnInitialize函数执行，PostSpawnInitialize在 Actor.cpp 的 2816 行
看下面函数小部分源码
void AActor::PostSpawnInitialize(FTransform const& UserSpawnTransform, AActor* InOwner, APawn* InInstigator, bool bRemoteOwned, bool bNoFail, bool bDeferConstruction)
{
// General flow here is like so
// - Actor sets up the basics.
// - Actor gets PreInitializeComponents()
// - Actor constructs itself, after which its components should be fully assembled
// - Actor components get OnComponentCreated
// - Actor components get InitializeComponent
// - Actor gets PostInitializeComponents() once everything is set up
//
// This should be the same sequence for deferred or nondeferred spawning.
// It's not safe to call UWorld accessor functions till the world info has been spawned.
UWorld* const World = GetWorld();
bool const bActorsInitialized = World && World->AreActorsInitialized();
CreationTime = (World ? World->GetTimeSeconds() : 0.f);
// Set network role.
check(Role == ROLE_Authority);
ExchangeNetRoles(bRemoteOwned);
USceneComponent* const SceneRootComponent = FixupNativeActorComponents(this);往下面看，来到 2910 行，看见 PostActorCreated函数
// Send messages. We've fully spawned
PostActorCreated();看下PostActorCreated在 类Actor的声明和定义：
/**
* Called when an actor is done spawning into the world (from UWorld::SpawnActor).
* For actors with a root component, the location and rotation will have already been set.
* Takes place after any construction scripts have been called
*/
void AActor::PostActorCreated()
{
// nothing at the moment
}
protected 的virtual 函数，这个是我们在AActor类构造函数之后的第一个可以Override的
忘下面看，然后我们到 2914行 的 FinishSpawning 函数执行，比较注意的是这里有个if (!bDeferConstruction) 判断，我们用
SpawnActor<T>时，bDeferConstruction = false,因此可以执行FinishSpawning
// Executes native and BP construction scripts.
// After this, we can assume all components are created and assembled.
if (!bDeferConstruction)
{
FinishSpawning(UserSpawnTransform, true);
}来到 FinishSpawning 函数的执行代码，贴出一小部分
void AActor::FinishSpawning(const FTransform& UserTransform, bool bIsDefaultTransform, const FComponentInstanceDataCache* InstanceDataCache)
{
#if ENABLE_SPAWNACTORTIMER
FScopedSpawnActorTimer SpawnTimer(GetClass()->GetFName(), ESpawnActorTimingType::FinishSpawning);
SpawnTimer.SetActorName(GetFName());
#endif
if (ensure(!bHasFinishedSpawning))
{
bHasFinishedSpawning = true;来到 2970行，看到ExecuteConstruction函数的执行
ExecuteConstruction(FinalRootComponentTransform, nullptr, InstanceDataCache, bIsDefaultTransform);ExecuteConstruction是声明在AActor的函数，但是定义 在ActorConstruction.cpp函数，下面我们到ActorConstruction.cpp去
来到 ActorConstruction.cpp的647行，看到ExecuteConstruction函数，贴出小部分代码
bool AActor::ExecuteConstruction(const FTransform& Transform, const FRotationConversionCache* TransformRotationCache, const FComponentInstanceDataCache* InstanceDataCache, bool bIsDefaultTransform)
{
check(!IsPendingKill());
check(!HasAnyFlags(RF_BeginDestroyed|RF_FinishDestroyed));
// ensure that any existing native root component gets this new transform
// we can skip this in the default case as the given transform will be the root component's transform
if (RootComponent && !bIsDefaultTransform)
{来到839行，看到OnConstruction执行
// Now run virtual notification
OnConstruction(Transform);OnConstruction 是声明在 AActor.h 定的 protected 的 virtual 函数, 这个接口我们可以考虑在AActor的子类进行override。
virtual void OnConstruction(const FTransform& Transform) {}然后再次回到AActor.cpp 的 2974行，看到PostActorConstruction函数的执行
AActor.cpp 的 2974行
PostActorConstruction();PostActorConstruction函数代码在AActor.cpp的2979行开始，贴出小部分代码:
void AActor::PostActorConstruction()
{
UWorld* const World = GetWorld();
bool const bActorsInitialized = World && World->AreActorsInitialized();
if (bActorsInitialized)
{
PreInitializeComponents();
}
来到 2986行 的，看到 PreInitializeComponents函数的执行
PreInitializeComponents();PreInitializeComponents 是声明在 AActor.h, 定义在 AActor.cpp 的 protected virtual 函数
virtual void PreInitializeComponents();
void AActor::PreInitializeComponents()
{
if (AutoReceiveInput != EAutoReceiveInput::Disabled)
{
const int32 PlayerIndex = int32(AutoReceiveInput.GetValue()) - 1;
APlayerController* PC = UGameplayStatics::GetPlayerController(this, PlayerIndex);
if (PC)
{
EnableInput(PC);
}
else
{
GetWorld()->PersistentLevel->RegisterActorForAutoReceiveInput(this, PlayerIndex);
}
}
}
下面来到 2995行，看到 InitializeComponents 的执行
// Call InitializeComponent on components
InitializeComponents();看InitializeComponents函数声明
/** Iterate over components array and call InitializeComponent */
void InitializeComponents();很可惜的一点是 InitializeComponents 并不是protected virtual 函数，因此无法在 AActor.h 子类中Override
往下面看，来到 3047 行，看到PostInitializeComponents函数的执行， PostInitializeComponents是AActor的protected virtual 函数，可以考虑在 AActor 子类中Override
/** Allow actors to initialize themselves on the C++ side */
virtual void PostInitializeComponents();void AActor::PostInitializeComponents()
{
if( !IsPendingKill() )
{
bActorInitialized = true;
FNavigationSystem::OnActorRegistered(*this);
UpdateAllReplicatedComponents();
}
}继续往下面走，看到DispatchBeginPlay函数的执行
DispatchBeginPlay();void AActor::DispatchBeginPlay()
{
UWorld* World = (!HasActorBegunPlay() && !IsPendingKill() ? GetWorld() : nullptr);
if (World)
{
const uint32 CurrentCallDepth = BeginPlayCallDepth++;
BeginPlay();
ensure(BeginPlayCallDepth - 1 == CurrentCallDepth);
BeginPlayCallDepth = CurrentCallDepth;
if (bActorWantsDestroyDuringBeginPlay)
{
// Pass true for bNetForce as either it doesn't matter or it was true the first time to even
// get to the point we set bActorWantsDestroyDuringBeginPlay to true
World->DestroyActor(this, true);
}
}
}我们最终可以看到 BeginPlay 函数 的，BeginPlay函数也是AActor的protected virtual函数,可以考虑在AAcctor子类override
/** Overridable native event for when play begins for this actor. */
virtual void BeginPlay();void AActor::BeginPlay()
{
ensureMsgf(ActorHasBegunPlay == EActorBeginPlayState::HasNotBegunPlay, TEXT("BeginPlay was called on actor %s which was in state %d"), *GetPathName(), (int32)ActorHasBegunPlay);
SetLifeSpan( InitialLifeSpan );
RegisterAllActorTickFunctions(true, false); // Components are done below.
TInlineComponentArray<UActorComponent*> Components;
GetComponents(Components);
ActorHasBegunPlay = EActorBeginPlayState::BeginningPlay;
for (UActorComponent* Component : Components)
{
// bHasBegunPlay will be true for the component if the component was renamed and moved to a new outer during initialization
if (Component->IsRegistered() && !Component->HasBegunPlay())
{
Component->RegisterAllComponentTickFunctions(true);
Component->BeginPlay();
ensureMsgf(Component->HasBegunPlay(), TEXT("Failed to route BeginPlay (%s)"), *Component->GetFullName());
}
else
{
// When an Actor begins play we expect only the not bAutoRegister false components to not be registered
//check(!Component->bAutoRegister);
}
}
ReceiveBeginPlay();
ActorHasBegunPlay = EActorBeginPlayState::HasBegunPlay;
}好吧，整天SpawnActor函数的产生AActor，AActor初始化的流程就差不多走了大概，下面总结下SpawnActor和Actor的初始化流程
棕色标注的函数的AActor可改写的，我们可以在AActor的子类中override的。
得注意一点的我，我在追源码并发现“OnActorSpawn”这个并不是函数，而是一个委托，用来通知AActor已经Spawn。在PostSpawnInitialize函数执行之后，位于LevelActor.cpp的 476 行
// Broadcast notification of spawn
OnActorSpawned.Broadcast(Actor);这个委托是UWorld的委托, 定义在Wolrd.h的1063行
DECLARE_MULTICAST_DELEGATE_OneParam(FOnActorSpawned, AActor*);
/** a delegate that broadcasts a notification whenever an actor is spawned */
FOnActorSpawned OnActorSpawned;不是函数的话我就不添加到流程图了。
其实在AActor.h就有类似的说明了“AActor初始化顺序”注释
class ENGINE_API AActor : public UObject
{
/**
* The functions of interest to initialization order for an Actor is roughly as follows:
* PostLoad/PostActorCreated - Do any setup of the actor required for construction. PostLoad for serialized actors, PostActorCreated for spawned.
* AActor::OnConstruction - The construction of the actor, this is where Blueprint actors have their components created and blueprint variables are initialized
* AActor::PreInitializeComponents - Called before InitializeComponent is called on the actor's components
* UActorComponent::InitializeComponent - Each component in the actor's components array gets an initialize call (if bWantsInitializeComponent is true for that component)
* AActor::PostInitializeComponents - Called after the actor's components have been initialized
* AActor::BeginPlay - Called when the level is started
*/
UCLASS()
class MYPROJECT4_API ATestActor : public AActor
{
GENERATED_BODY()
ATestActor();
protected:
// Called when the game starts or when spawned
virtual void PostActorCreated() override;
virtual void OnConstruction(const FTransform& Transform) override;
virtual void PreInitializeComponents() override;
virtual void PostInitializeComponents() override;
virtual void BeginPlay() override;
}ATestActor::ATestActor()
{
UE_LOG(LogTemp, Error, TEXT("ATestActor Construction"));
}
void ATestActor::PostActorCreated()
{
Super::PostActorCreated();
UE_LOG(LogTemp, Error, TEXT("ATestActor::PostActorCreated"));
}
void ATestActor::OnConstruction(const FTransform& Transform)
{
Super::OnConstruction(Transform);
UE_LOG(LogTemp, Error, TEXT("ATestActor::OnConstruction"));
}
void ATestActor::PreInitializeComponents()
{
Super::PreInitializeComponents();
UE_LOG(LogTemp, Error, TEXT("ATestActor::PreInitializeComponents"));
}
void ATestActor::PostInitializeComponents()
{
Super::PostInitializeComponents();
UE_LOG(LogTemp, Error, TEXT("ATestActor::PostInitializeComponents"));
}
void ATestActor::BeginPlay()
{
Super::BeginPlay();
UE_LOG(LogTemp, Error, TEXT("ATestActor::BeginPlay"));
}
在UE4中我们一般调用来自于 World.h 的各种SpawnActorDeferred<T>(....), 如下面的
template< class T >
T* SpawnActorDeferred(
UClass* Class,
FTransform const& Transform,
AActor* Owner = nullptr,
APawn* Instigator = nullptr,
ESpawnActorCollisionHandlingMethod CollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::Undefined
)
{
if( Owner )
{
check(this==Owner->GetWorld());
}
FActorSpawnParameters SpawnInfo;
SpawnInfo.SpawnCollisionHandlingOverride = CollisionHandlingOverride;
SpawnInfo.Owner = Owner;
SpawnInfo.Instigator = Instigator;
SpawnInfo.bDeferConstruction = true;
return (Class != nullptr) ? Cast<T>(SpawnActor(Class, &Transform, SpawnInfo)) : nullptr;
}SpawnActorDeferred前面流程和SpawnActor是差不多的(PostActorCreated函数执行前面的流程包括PostActorCreated）
有再次来到AActor.cpp 的 2914行
if (!bDeferConstruction)
{
FinishSpawning(UserSpawnTransform, true);
}这个bDeferConstruction来自于FActorSpawnParameters结构体的bDeferConstruction
Actor->PostSpawnInitialize(UserTransform, SpawnParameters.Owner, SpawnParameters.Instigator, SpawnParameters.IsRemoteOwned(), SpawnParameters.bNoFail, SpawnParameters.bDeferConstruction);看SpawnActorDeferredActor<T> 函数的
SpawnInfo.bDeferConstruction = true;因此SpawnActorDeferred无法执行FinishSpawning(UserSpawnTransform, true);
代码上上面的一样
void AMyProject4Character::SpawnTestActor()
{
ATestActor* testActor = GetWorld()->SpawnActorDeferred<ATestActor>(ATestActor::StaticClass(), GetTransform());
UE_LOG(LogTemp, Error, TEXT("xxxxxxxxxxxxxxxxxxxxxxxx"));
}
上面这么多protected virtual 函数就执行了PostActorCreated，BeginPlay这个在业务逻辑中常用的初始化函数也不执行。
【1】https://docs.unrealengine.com/en-us/Programming/UnrealArchitecture/Actors/ActorLifecycle