结构图：
一种生成Actor的方式
TArray<AActor*> FLevelEditorViewportClient::TryPlacingActorFromObject( ULevel* InLevel, UObject* ObjToUse, bool bSelectActors, EObjectFlags ObjectFlags, UActorFactory* FactoryToUse, const FName Name, const FViewportCursorLocation* Cursor )
{
TArray<AActor*> PlacedActors;
UClass* ObjectClass = Cast<UClass>(ObjToUse);
if ( ObjectClass == NULL )
{
ObjectClass = ObjToUse->GetClass();
check(ObjectClass);
}
AActor* PlacedActor = NULL;
if ( ObjectClass->IsChildOf( AActor::StaticClass() ) )
{
//Attempting to drop a UClass object
UActorFactory* ActorFactory = FactoryToUse;
if ( ActorFactory == NULL )
{
ActorFactory = GEditor->FindActorFactoryForActorClass( ObjectClass );
}
if ( ActorFactory != NULL )
{
PlacedActor = FActorFactoryAssetProxy::AddActorFromSelection( ObjectClass, NULL, bSelectActors, ObjectFlags, ActorFactory, Name );
}
if ( PlacedActor == NULL && ActorFactory != NULL )
{
PlacedActor = FActorFactoryAssetProxy::AddActorForAsset( ObjToUse, bSelectActors, ObjectFlags, ActorFactory, Name );
}
if ( PlacedActor == NULL && !ObjectClass->HasAnyClassFlags(CLASS_NotPlaceable | CLASS_Abstract) )
{
// If no actor factory was found or failed, add the actor directly.
const FTransform ActorTransform = FActorPositioning::GetCurrentViewportPlacementTransform(*ObjectClass->GetDefaultObject<AActor>(), /*bSnap=*/true, Cursor);
PlacedActor = GEditor->AddActor( InLevel, ObjectClass, ActorTransform, /*bSilent=*/false, ObjectFlags );
}
if ( PlacedActor != NULL )
{
FVector Collision = ObjectClass->GetDefaultObject<AActor>()->GetPlacementExtent();
PlacedActors.Add(PlacedActor);
}
}
if ( (NULL == PlacedActor) && ObjToUse->IsA( UExportTextContainer::StaticClass() ) )
{
UExportTextContainer* ExportContainer = CastChecked<UExportTextContainer>(ObjToUse);
const TArray<AActor*> NewActors = GEditor->AddExportTextActors( ExportContainer->ExportText, /*bSilent*/false, ObjectFlags);
PlacedActors.Append(NewActors);
}
else if ( (NULL == PlacedActor) && ObjToUse->IsA( UBrushBuilder::StaticClass() ) )
{
UBrushBuilder* BrushBuilder = CastChecked<UBrushBuilder>(ObjToUse);
UWorld* World = InLevel->OwningWorld;
BrushBuilder->Build(World);
ABrush* DefaultBrush = World->GetDefaultBrush();
if (DefaultBrush != NULL)
{
FVector ActorLoc = GEditor->ClickLocation + GEditor->ClickPlane * (FVector::BoxPushOut(GEditor->ClickPlane, DefaultBrush->GetPlacementExtent()));
FSnappingUtils::SnapPointToGrid(ActorLoc, FVector::ZeroVector);
DefaultBrush->SetActorLocation(ActorLoc);
PlacedActor = DefaultBrush;
PlacedActors.Add(DefaultBrush);
}
}
else if (NULL == PlacedActor)
{
bool bPlace = true;
if (ObjectClass->IsChildOf(UBlueprint::StaticClass()))
{
UBlueprint* BlueprintObj = StaticCast<UBlueprint*>(ObjToUse);
bPlace = BlueprintObj->GeneratedClass != NULL;
if(bPlace)
{
check(BlueprintObj->ParentClass == BlueprintObj->GeneratedClass->GetSuperClass());
if (BlueprintObj->GeneratedClass->HasAnyClassFlags(CLASS_NotPlaceable | CLASS_Abstract))
{
bPlace = false;
}
}
}
if (bPlace)
{
PlacedActor = FActorFactoryAssetProxy::AddActorForAsset( ObjToUse, bSelectActors, ObjectFlags, FactoryToUse, Name );
if ( PlacedActor != NULL )
{
PlacedActors.Add(PlacedActor);
PlacedActor->PostEditMove(true);
}
}
}
return PlacedActors;
}最后还是SpawnActor：
AActor* UActorFactory::SpawnActor( UObject* Asset, ULevel* InLevel, const FTransform& Transform, EObjectFlags InObjectFlags, const FName Name )
{
AActor* DefaultActor = GetDefaultActor( FAssetData( Asset ) );
if ( DefaultActor )
{
FActorSpawnParameters SpawnInfo;
SpawnInfo.OverrideLevel = InLevel;
SpawnInfo.ObjectFlags = InObjectFlags;
SpawnInfo.bCreateActorPackage = true;
SpawnInfo.Name = Name;
#if WITH_EDITOR
SpawnInfo.bTemporaryEditorActor = FLevelEditorViewportClient::IsDroppingPreviewActor();
#endif
return InLevel->OwningWorld->SpawnActor( DefaultActor->GetClass(), &Transform, SpawnInfo );
}
return NULL;
}所以重点是SpwanActor
World.h LevelActor.cpp
AActor* UWorld::SpawnActor( UClass* Class, FTransform const* UserTransformPtr, const FActorSpawnParameters& SpawnParameters )
{
SCOPE_CYCLE_COUNTER(STAT_SpawnActorTime);
CSV_SCOPED_TIMING_STAT_EXCLUSIVE(ActorSpawning);
#if WITH_EDITORONLY_DATA
check( CurrentLevel );
check(GIsEditor || (CurrentLevel == PersistentLevel));
#else
ULevel* CurrentLevel = PersistentLevel;
#endif
// Make sure this class is spawnable.
if( !Class )
{
UE_LOG(LogSpawn, Warning, TEXT("SpawnActor failed because no class was specified") );
return NULL;
}
SCOPE_TIME_GUARD_NAMED_MS(TEXT("SpawnActor Of Type"), Class->GetFName(), 2);
#if ENABLE_SPAWNACTORTIMER
FScopedSpawnActorTimer SpawnTimer(Class->GetFName(), SpawnParameters.bDeferConstruction ? ESpawnActorTimingType::SpawnActorDeferred : ESpawnActorTimingType::SpawnActorNonDeferred);
#endif
if( Class->HasAnyClassFlags(CLASS_Deprecated) )
{
UE_LOG(LogSpawn, Warning, TEXT("SpawnActor failed because class %s is deprecated"), *Class->GetName() );
return NULL;
}
if( Class->HasAnyClassFlags(CLASS_Abstract) )
{
UE_LOG(LogSpawn, Warning, TEXT("SpawnActor failed because class %s is abstract"), *Class->GetName() );
return NULL;
}
else if( !Class->IsChildOf(AActor::StaticClass()) )
{
UE_LOG(LogSpawn, Warning, TEXT("SpawnActor failed because %s is not an actor class"), *Class->GetName() );
return NULL;
}
else if (SpawnParameters.Template != NULL && SpawnParameters.Template->GetClass() != Class)
{
UE_LOG(LogSpawn, Warning, TEXT("SpawnActor failed because template class (%s) does not match spawn class (%s)"), *SpawnParameters.Template->GetClass()->GetName(), *Class->GetName());
if (!SpawnParameters.bNoFail)
{
return NULL;
}
}
else if (bIsRunningConstructionScript && !SpawnParameters.bAllowDuringConstructionScript)
{
UE_LOG(LogSpawn, Warning, TEXT("SpawnActor failed because we are running a ConstructionScript (%s)"), *Class->GetName() );
return NULL;
}
else if (bIsTearingDown)
{
UE_LOG(LogSpawn, Warning, TEXT("SpawnActor failed because we are in the process of tearing down the world"));
return NULL;
}
else if (UserTransformPtr && UserTransformPtr->ContainsNaN())
{
UE_LOG(LogSpawn, Warning, TEXT("SpawnActor failed because the given transform (%s) is invalid"), *(UserTransformPtr->ToString()));
return NULL;
}
#if WITH_EDITOR
if (SpawnParameters.OverridePackage && SpawnParameters.bCreateActorPackage)
{
UE_LOG(LogSpawn, Warning, TEXT("SpawnActor failed because both the OverridePackage and bCreateActorPackage are set"));
return nullptr;
}
#endif
ULevel* LevelToSpawnIn = SpawnParameters.OverrideLevel;
if (LevelToSpawnIn == NULL)
{
// Spawn in the same level as the owner if we have one.
LevelToSpawnIn = (SpawnParameters.Owner != NULL) ? SpawnParameters.Owner->GetLevel() : CurrentLevel;
}
FName NewActorName = SpawnParameters.Name;
AActor* Template = SpawnParameters.Template;
if( !Template )
{
// Use class's default actor as a template.
Template = Class->GetDefaultObject<AActor>();
}
check(Template);
if (NewActorName.IsNone())
{
// If we are using a template object and haven't specified a name, create a name relative to the template, otherwise let the default object naming behavior in Stat
if (!Template->HasAnyFlags(RF_ClassDefaultObject))
{
NewActorName = MakeUniqueObjectName(LevelToSpawnIn, Template->GetClass(), *Template->GetFName().GetPlainNameString());
}
}
else if (StaticFindObjectFast(nullptr, LevelToSpawnIn, NewActorName))
{
// If the supplied name is already in use, then either fail in the requested manner or determine a new name to use if the caller indicates that's ok
if (SpawnParameters.NameMode == FActorSpawnParameters::ESpawnActorNameMode::Requested)
{
NewActorName = MakeUniqueObjectName(LevelToSpawnIn, Template->GetClass(), *NewActorName.GetPlainNameString());
}
else
{
if (SpawnParameters.NameMode == FActorSpawnParameters::ESpawnActorNameMode::Required_Fatal)
{
UE_LOG(LogSpawn, Fatal, TEXT("An actor of name '%s' already exists in level '%s'."), *NewActorName.ToString(), *LevelToSpawnIn->GetFullName());
}
else if (SpawnParameters.NameMode == FActorSpawnParameters::ESpawnActorNameMode::Required_ErrorAndReturnNull)
{
UE_LOG(LogSpawn, Error, TEXT("An actor of name '%s' already exists in level '%s'."), *NewActorName.ToString(), *LevelToSpawnIn->GetFullName());
}
return nullptr;
}
}
// See if we can spawn on ded.server/client only etc (check NeedsLoadForClient & NeedsLoadForServer)
if(!CanCreateInCurrentContext(Template))
{
UE_LOG(LogSpawn, Warning, TEXT("Unable to spawn class '%s' due to client/server context."), *Class->GetName() );
return NULL;
}
FTransform const UserTransform = UserTransformPtr ? *UserTransformPtr : FTransform::Identity;
ESpawnActorCollisionHandlingMethod CollisionHandlingOverride = SpawnParameters.SpawnCollisionHandlingOverride;
// "no fail" take preedence over collision handling settings that include fails
if (SpawnParameters.bNoFail)
{
// maybe upgrade to disallow fail
if (CollisionHandlingOverride == ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButDontSpawnIfColliding)
{
CollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButAlwaysSpawn;
}
else if (CollisionHandlingOverride == ESpawnActorCollisionHandlingMethod::DontSpawnIfColliding)
{
CollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
}
}
// use override if set, else fall back to actor's preference
ESpawnActorCollisionHandlingMethod const CollisionHandlingMethod = (CollisionHandlingOverride == ESpawnActorCollisionHandlingMethod::Undefined) ? Template->SpawnCollisionHandlingMethod : CollisionHandlingOverride;
// see if we can avoid spawning altogether by checking native components
// note: we can't handle all cases here, since we don't know the full component hierarchy until after the actor is spawned
if (CollisionHandlingMethod == ESpawnActorCollisionHandlingMethod::DontSpawnIfColliding)
{
USceneComponent* const TemplateRootComponent = Template->GetRootComponent();
// Note that we respect any initial transformation the root component may have from the CDO, so the final transform
// might necessarily be exactly the passed-in UserTransform.
FTransform const FinalRootComponentTransform =
TemplateRootComponent
? FTransform(TemplateRootComponent->GetRelativeRotation(), TemplateRootComponent->GetRelativeLocation(), TemplateRootComponent->GetRelativeScale3D()) * UserTransform
: UserTransform;
FVector const FinalRootLocation = FinalRootComponentTransform.GetLocation();
FRotator const FinalRootRotation = FinalRootComponentTransform.Rotator();
if (EncroachingBlockingGeometry(Template, FinalRootLocation, FinalRootRotation))
{
// a native component is colliding, that's enough to reject spawning
UE_LOG(LogSpawn, Log, TEXT("SpawnActor failed because of collision at the spawn location [%s] for [%s]"), *FinalRootLocation.ToString(), *Class->GetName());
return nullptr;
}
}
EObjectFlags ActorFlags = SpawnParameters.ObjectFlags;
UPackage* ExternalPackage = nullptr;
#if WITH_EDITOR
// Generate the actor's Guid
FGuid ActorGuid;
if (SpawnParameters.OverrideActorGuid.IsValid())
{
ActorGuid = SpawnParameters.OverrideActorGuid;
}
else
{
ActorGuid = FGuid::NewGuid();
}
// Generate and set the actor's external package if needed
// Set actor's package
if (SpawnParameters.OverridePackage)
{
ExternalPackage = SpawnParameters.OverridePackage;
}
else if (LevelToSpawnIn->IsUsingExternalActors() && SpawnParameters.bCreateActorPackage && !(SpawnParameters.ObjectFlags & RF_Transient))
{
// @todo FH: needs to handle mark package dirty and asset creation notification
ExternalPackage = ULevel::CreateActorPackage(LevelToSpawnIn->GetPackage(), ActorGuid);
}
#endif
// actually make the actor object
AActor* const Actor = NewObject<AActor>(LevelToSpawnIn, Class, NewActorName, ActorFlags, Template, false/*bCopyTransientsFromClassDefaults*/, nullptr/*InInstanceGraph*/, ExternalPackage);
check(Actor);
check(Actor->GetLevel() == LevelToSpawnIn);
#if ENABLE_SPAWNACTORTIMER
SpawnTimer.SetActorName(Actor->GetFName());
#endif
#if WITH_EDITOR
Actor->ClearActorLabel(); // Clear label on newly spawned actors
// Set the actor's guid
FSetActorGuid SetActorGuid(Actor, ActorGuid);
if (SpawnParameters.OverrideParentComponent)
{
FActorParentComponentSetter::Set(Actor, SpawnParameters.OverrideParentComponent);
}
#endif // WITH_EDITOR
if ( GUndo )
{
// if we are spawning an external actor, clear the dirty flag without capturing in the transaction beforehand
// This allows the transaction to capture the package as not being dirty when capturing its current state, which is what we need for proper external actor behavior
if (ExternalPackage)
{
LevelToSpawnIn->GetPackage()->ClearDirtyFlag();
}
ModifyLevel( LevelToSpawnIn );
}
LevelToSpawnIn->Actors.Add( Actor );
LevelToSpawnIn->ActorsForGC.Add(Actor);
#if PERF_SHOW_MULTI_PAWN_SPAWN_FRAMES
if( Cast<APawn>(Actor) )
{
FString PawnName = FString::Printf(TEXT("%d: %s"), ThisFramePawnSpawns.Num(), *Actor->GetPathName());
ThisFramePawnSpawns.Add(PawnName);
}
#endif
// tell the actor what method to use, in case it was overridden
Actor->SpawnCollisionHandlingMethod = CollisionHandlingMethod;
#if WITH_EDITOR
if (SpawnParameters.bHideFromSceneOutliner)
{
FSetActorHiddenInSceneOutliner SetActorHidden(Actor);
}
Actor->bIsEditorPreviewActor = SpawnParameters.bTemporaryEditorActor;
#endif //WITH_EDITOR
// Broadcast delegate before the actor and its contained components are initialized
OnActorPreSpawnInitialization.Broadcast(Actor);
Actor->PostSpawnInitialize(UserTransform, SpawnParameters.Owner, SpawnParameters.Instigator, SpawnParameters.IsRemoteOwned(), SpawnParameters.bNoFail, SpawnParameters.bDeferConstruction);
// if we are spawning an external actor, clear the dirty flag after post spawn initialize which might have dirtied the level package through running construction scripts
if (ExternalPackage)
{
LevelToSpawnIn->GetPackage()->ClearDirtyFlag();
}
if (Actor->IsPendingKill() && !SpawnParameters.bNoFail)
{
UE_LOG(LogSpawn, Log, TEXT("SpawnActor failed because the spawned actor %s IsPendingKill"), *Actor->GetPathName());
return NULL;
}
Actor->CheckDefaultSubobjects();
// Broadcast notification of spawn
OnActorSpawned.Broadcast(Actor);
#if WITH_EDITOR
if (GIsEditor)
{
GEngine->BroadcastLevelActorAdded(Actor);
}
#endif
// Add this newly spawned actor to the network actor list. Do this after PostSpawnInitialize so that actor has "finished" spawning.
AddNetworkActor( Actor );
return Actor;
}world.cpp
FActorSpawnParameters::FActorSpawnParameters()
: Name(NAME_None)
, Template(NULL)
, Owner(NULL)
, Instigator(NULL)
, OverrideLevel(NULL)
#if WITH_EDITOR
, OverridePackage(nullptr)
, OverrideParentComponent(nullptr)
#endif
, SpawnCollisionHandlingOverride(ESpawnActorCollisionHandlingMethod::Undefined)
, bRemoteOwned(false)
, bNoFail(false)
, bDeferConstruction(false)
, bAllowDuringConstructionScript(false)
#if WITH_EDITOR
, bTemporaryEditorActor(false)
, bHideFromSceneOutliner(false)
, bCreateActorPackage(false)
#endif
, NameMode(ESpawnActorNameMode::Required_Fatal)
, ObjectFlags(RF_Transactional)
{
}Actor.cpp
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(GetLocalRole() == ROLE_Authority);
ExchangeNetRoles(bRemoteOwned);
// Set owner.
SetOwner(InOwner);
// Set instigator
SetInstigator(InInstigator);
// Set the actor's world transform if it has a native rootcomponent.
USceneComponent* const SceneRootComponent = FixupNativeActorComponents(this);
if (SceneRootComponent != nullptr)
{
check(SceneRootComponent->GetOwner() == this);
// Determine if the native root component's archetype originates from a converted (nativized) Blueprint class.
UObject* RootComponentArchetype = SceneRootComponent->GetArchetype();
UClass* ArchetypeOwnerClass = RootComponentArchetype->GetOuter()->GetClass();
if (UBlueprintGeneratedClass* ArchetypeOwnerClassAsBPGC = Cast<UBlueprintGeneratedClass>(ArchetypeOwnerClass))
{
// In this case, the Actor CDO is a non-nativized Blueprint class (e.g. a child class) and the component's archetype
// is an instanced default subobject within the non-nativized Blueprint's CDO. If the owner class also has a nativized
// parent class somewhere in its inheritance hierarchy, we must redirect the query by walking up the archetype chain.
if (ArchetypeOwnerClassAsBPGC->bHasNativizedParent)
{
do
{
RootComponentArchetype = RootComponentArchetype->GetArchetype();
ArchetypeOwnerClass = RootComponentArchetype->GetOuter()->GetClass();
} while (Cast<UBlueprintGeneratedClass>(ArchetypeOwnerClass) != nullptr);
}
}
if (Cast<UDynamicClass>(ArchetypeOwnerClass) != nullptr)
{
// For native root components either belonging to or inherited from a converted (nativized) Blueprint class, we currently do not use
// the transformation that's set on the root component in the CDO. The reason is that in the non-nativized case, we ignore the default
// transform when we instance a Blueprint-owned scene component that will also become the root (see USCS_Node::ExecuteNodeOnActor; in
// the case of dynamically-spawned Blueprint instances, 'bIsDefaultTransform' will be false, and the scale from the SCS node's template
// will not be applied in that code path in that case). Once a Blueprint class is nativized, we no longer run through that code path
// when we spawn new instances of that class dynamically, but for consistency, we need to keep the same transform as in the non-
// nativized case. We used to ignore any non-default transform value set on the root component at cook (nativization) time, but that
// doesn't work because existing placements of the Blueprint component in a scene may rely on the value that's stored in the CDO,
// and as a result the instance-specific override value doesn't get serialized out to the instance as a result of delta serialization.
SceneRootComponent->SetWorldTransform(UserSpawnTransform, false, nullptr, ETeleportType::ResetPhysics);
}
else
{
// In the "normal" case we do respect any non-default transform value that the root component may have received from the archetype
// that's owned by the native CDO, so the final transform might not always necessarily equate to the passed-in UserSpawnTransform.
const FTransform RootTransform(SceneRootComponent->GetRelativeRotation(), SceneRootComponent->GetRelativeLocation(), SceneRootComponent->GetRelativeScale3D());
const FTransform FinalRootComponentTransform = RootTransform * UserSpawnTransform;
SceneRootComponent->SetWorldTransform(FinalRootComponentTransform, false, nullptr, ETeleportType::ResetPhysics);
}
}
// Call OnComponentCreated on all default (native) components
DispatchOnComponentsCreated(this);
// Register the actor's default (native) components, but only if we have a native scene root. If we don't, it implies that there could be only non-scene components
// at the native class level. In that case, if this is a Blueprint instance, we need to defer native registration until after SCS execution can establish a scene root.
// Note: This API will also call PostRegisterAllComponents() on the actor instance. If deferred, PostRegisterAllComponents() won't be called until the root is set by SCS.
bHasDeferredComponentRegistration = (SceneRootComponent == nullptr && Cast<UBlueprintGeneratedClass>(GetClass()) != nullptr);
if (!bHasDeferredComponentRegistration && GetWorld())
{
RegisterAllComponents();
}
#if WITH_EDITOR
// When placing actors in the editor, init any random streams
if (!bActorsInitialized)
{
SeedAllRandomStreams();
}
#endif
// See if anything has deleted us
if( IsPendingKill() && !bNoFail )
{
return;
}
// Send messages. We've fully spawned
PostActorCreated();
// Executes native and BP construction scripts.
// After this, we can assume all components are created and assembled.
if (!bDeferConstruction)
{
FinishSpawning(UserSpawnTransform, true);
}
else if (SceneRootComponent != nullptr)
{
// we have a native root component and are deferring construction, store our original UserSpawnTransform
// so we can do the proper thing if the user passes in a different transform during FinishSpawning
GSpawnActorDeferredTransformCache.Emplace(this, UserSpawnTransform);
}
}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;
FTransform FinalRootComponentTransform = (RootComponent ? RootComponent->GetComponentTransform() : UserTransform);
// see if we need to adjust the transform (i.e. in deferred cases where the caller passes in a different transform here
// than was passed in during the original SpawnActor call)
if (RootComponent && !bIsDefaultTransform)
{
FTransform const* const OriginalSpawnTransform = GSpawnActorDeferredTransformCache.Find(this);
if (OriginalSpawnTransform)
{
GSpawnActorDeferredTransformCache.Remove(this);
if (OriginalSpawnTransform->Equals(UserTransform) == false)
{
UserTransform.GetLocation().DiagnosticCheckNaN(TEXT("AActor::FinishSpawning: UserTransform.GetLocation()"));
UserTransform.GetRotation().DiagnosticCheckNaN(TEXT("AActor::FinishSpawning: UserTransform.GetRotation()"));
// caller passed a different transform!
// undo the original spawn transform to get back to the template transform, so we can recompute a good
// final transform that takes into account the template's transform
FTransform const TemplateTransform = RootComponent->GetComponentTransform() * OriginalSpawnTransform->Inverse();
FinalRootComponentTransform = TemplateTransform * UserTransform;
}
}
// should be fast and relatively rare
ValidateDeferredTransformCache();
}
FinalRootComponentTransform.GetLocation().DiagnosticCheckNaN(TEXT("AActor::FinishSpawning: FinalRootComponentTransform.GetLocation()"));
FinalRootComponentTransform.GetRotation().DiagnosticCheckNaN(TEXT("AActor::FinishSpawning: FinalRootComponentTransform.GetRotation()"));
{
FEditorScriptExecutionGuard ScriptGuard;
ExecuteConstruction(FinalRootComponentTransform, nullptr, InstanceDataCache, bIsDefaultTransform);
}
{
SCOPE_CYCLE_COUNTER(STAT_PostActorConstruction);
PostActorConstruction();
}
}
}ActorContruction.cpp
bool AActor::ExecuteConstruction(const FTransform& Transform, const FRotationConversionCache* TransformRotationCache, const FComponentInstanceDataCache* InstanceDataCache, bool bIsDefaultTransform)
{
check(!IsPendingKill());
check(!HasAnyFlags(RF_BeginDestroyed|RF_FinishDestroyed));
#if WITH_EDITOR
// Guard against reentrancy due to attribute editing at construction time.
// @see RerunConstructionScripts()
checkf(!bActorIsBeingConstructed, TEXT("Actor construction is not reentrant"));
#endif
bActorIsBeingConstructed = true;
ON_SCOPE_EXIT
{
bActorIsBeingConstructed = false;
UCSBlueprintComponentArchetypeCounts.Remove(this);
};
// 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)
{
if (TransformRotationCache)
{
RootComponent->SetRelativeRotationCache(*TransformRotationCache);
}
RootComponent->SetWorldTransform(Transform, /*bSweep=*/false, /*OutSweepHitResult=*/nullptr, ETeleportType::TeleportPhysics);
}
// Generate the parent blueprint hierarchy for this actor, so we can run all the construction scripts sequentially
TArray<const UBlueprintGeneratedClass*> ParentBPClassStack;
const bool bErrorFree = UBlueprintGeneratedClass::GetGeneratedClassesHierarchy(GetClass(), ParentBPClassStack);
TArray<const UDynamicClass*> ParentDynamicClassStack;
for (UClass* ClassIt = GetClass(); ClassIt; ClassIt = ClassIt->GetSuperClass())
{
if (UDynamicClass* DynamicClass = Cast<UDynamicClass>(ClassIt))
{
ParentDynamicClassStack.Add(DynamicClass);
}
}
for (int32 i = ParentDynamicClassStack.Num() - 1; i >= 0; i--)
{
UBlueprintGeneratedClass::CreateComponentsForActor(ParentDynamicClassStack[i], this);
}
// If this actor has a blueprint lineage, go ahead and run the construction scripts from least derived to most
if( (ParentBPClassStack.Num() > 0) )
{
if (bErrorFree)
{
// Get all components owned by the given actor prior to SCS execution.
// Note: GetComponents() internally does a NULL check, so we can assume here that all entries are valid.
TInlineComponentArray<UActorComponent*> PreSCSComponents;
GetComponents(PreSCSComponents);
// Determine the set of native scene components that SCS nodes can attach to.
TInlineComponentArray<USceneComponent*> NativeSceneComponents;
for (UActorComponent* ActorComponent : PreSCSComponents)
{
if (USceneComponent* SceneComponent = Cast<USceneComponent>(ActorComponent))
{
// Exclude subcomponents of native components, as these could unintentionally be matched by name during SCS execution. Also exclude instance-only components.
if (SceneComponent->CreationMethod == EComponentCreationMethod::Native && SceneComponent->GetOuter()->IsA<AActor>())
{
// If RootComponent is not set, the first unattached native scene component will be used as root. This matches what's done in FixupNativeActorComponents().
// @TODO - consider removing this; keeping here as a fallback just in case it wasn't set prior to SCS execution, but in most cases now this should be valid.
if (RootComponent == nullptr && SceneComponent->GetAttachParent() == nullptr)
{
// Note: All native scene components should already have been registered at this point, so we don't need to register the component here.
SetRootComponent(SceneComponent);
}
NativeSceneComponents.Add(SceneComponent);
}
}
}
// Prevent user from spawning actors in User Construction Script
FGuardValue_Bitfield(GetWorld()->bIsRunningConstructionScript, true);
for (int32 i = ParentBPClassStack.Num() - 1; i >= 0; i--)
{
const UBlueprintGeneratedClass* CurrentBPGClass = ParentBPClassStack[i];
check(CurrentBPGClass);
USimpleConstructionScript* SCS = CurrentBPGClass->SimpleConstructionScript;
if (SCS)
{
SCS->CreateNameToSCSNodeMap();
SCS->ExecuteScriptOnActor(this, NativeSceneComponents, Transform, TransformRotationCache, bIsDefaultTransform);
}
// Now that the construction scripts have been run, we can create timelines and hook them up
UBlueprintGeneratedClass::CreateComponentsForActor(CurrentBPGClass, this);
}
// Ensure that we've called RegisterAllComponents(), in case it was deferred and the SCS could not be fully executed.
if (HasDeferredComponentRegistration())
{
RegisterAllComponents();
}
// Once SCS execution has finished, we do a final pass to register any new components that may have been deferred or were otherwise left unregistered after SCS execution.
TInlineComponentArray<UActorComponent*> PostSCSComponents;
GetComponents(PostSCSComponents);
for (UActorComponent* ActorComponent : PostSCSComponents)
{
// Limit registration to components that are known to have been created during SCS execution
if (!ActorComponent->IsRegistered() && ActorComponent->bAutoRegister && !ActorComponent->IsPendingKill()
&& (ActorComponent->CreationMethod == EComponentCreationMethod::SimpleConstructionScript || !PreSCSComponents.Contains(ActorComponent)))
{
USimpleConstructionScript::RegisterInstancedComponent(ActorComponent);
}
}
// If we passed in cached data, we apply it now, so that the UserConstructionScript can use the updated values
if (InstanceDataCache)
{
InstanceDataCache->ApplyToActor(this, ECacheApplyPhase::PostSimpleConstructionScript);
}
#if WITH_EDITOR
bool bDoUserConstructionScript;
GConfig->GetBool(TEXT("Kismet"), TEXT("bTurnOffEditorConstructionScript"), bDoUserConstructionScript, GEngineIni);
if (!GIsEditor || !bDoUserConstructionScript)
#endif
{
// Then run the user script, which is responsible for calling its own super, if desired
ProcessUserConstructionScript();
}
// Since re-run construction scripts will never be run and we want to keep dynamic spawning fast, don't spend time
// determining the UCS modified properties in game worlds
if (!GetWorld()->IsGameWorld())
{
for (UActorComponent* Component : GetComponents())
{
if (Component)
{
Component->DetermineUCSModifiedProperties();
}
}
}
// Bind any delegates on components
UBlueprintGeneratedClass::BindDynamicDelegates(GetClass(), this); // We have a BP stack, we must have a UBlueprintGeneratedClass...
// Apply any cached data procedural components
// @TODO Don't re-apply to components we already applied to above
if (InstanceDataCache)
{
InstanceDataCache->ApplyToActor(this, ECacheApplyPhase::PostUserConstructionScript);
}
// Remove name to SCS_Node cached map
for (const UBlueprintGeneratedClass* CurrentBPGClass : ParentBPClassStack)
{
check(CurrentBPGClass);
USimpleConstructionScript* SCS = CurrentBPGClass->SimpleConstructionScript;
if (SCS)
{
SCS->RemoveNameToSCSNodeMap();
}
}
}
else
{
// Disaster recovery mode; create a dummy billboard component to retain the actor location
// until the compile error can be fixed
if (RootComponent == nullptr)
{
UBillboardComponent* BillboardComponent = NewObject<UBillboardComponent>(this);
BillboardComponent->SetFlags(RF_Transactional);
BillboardComponent->CreationMethod = EComponentCreationMethod::SimpleConstructionScript;
#if WITH_EDITOR
BillboardComponent->Sprite = (UTexture2D*)(StaticLoadObject(UTexture2D::StaticClass(), nullptr, TEXT("/Engine/EditorResources/BadBlueprintSprite.BadBlueprintSprite")));
#endif
BillboardComponent->SetRelativeTransform(Transform);
SetRootComponent(BillboardComponent);
FinishAndRegisterComponent(BillboardComponent);
}
// Ensure that we've called RegisterAllComponents(), in case it was deferred and the SCS could not be executed (due to error).
if (HasDeferredComponentRegistration())
{
RegisterAllComponents();
}
}
}
else
{
#if WITH_EDITOR
bool bDoUserConstructionScript;
GConfig->GetBool(TEXT("Kismet"), TEXT("bTurnOffEditorConstructionScript"), bDoUserConstructionScript, GEngineIni);
if (!GIsEditor || !bDoUserConstructionScript)
#endif
{
// Then run the user script, which is responsible for calling its own super, if desired
ProcessUserConstructionScript();
}
UBlueprintGeneratedClass::BindDynamicDelegates(GetClass(), this);
}
GetWorld()->UpdateCullDistanceVolumes(this);
// Now run virtual notification
OnConstruction(Transform);
return bErrorFree;
}SimpleConstructionScript.cpp
void USimpleConstructionScript::RegisterInstancedComponent(UActorComponent* InstancedComponent)
{
// If this is a scene component, recursively register parent attachments within the actor's scene hierarchy first.
if (USceneComponent* SceneComponent = Cast<USceneComponent>(InstancedComponent))
{
USceneComponent* ParentComponent = SceneComponent->GetAttachParent();
if (ParentComponent != nullptr
&& ParentComponent->GetOwner() == SceneComponent->GetOwner()
&& !ParentComponent->IsRegistered())
{
RegisterInstancedComponent(ParentComponent);
}
}
if (InstancedComponent != nullptr && !InstancedComponent->IsRegistered() && InstancedComponent->bAutoRegister && !InstancedComponent->IsPendingKill())
{
InstancedComponent->RegisterComponent();
}
}ActorComponent.cpp
void UActorComponent::RegisterComponent()
{
AActor* MyOwner = GetOwner();
UWorld* MyOwnerWorld = (MyOwner ? MyOwner->GetWorld() : nullptr);
if (ensure(MyOwnerWorld))
{
RegisterComponentWithWorld(MyOwnerWorld);
}
}
void UActorComponent::RegisterComponentWithWorld(UWorld* InWorld, FRegisterComponentContext* Context)
{
SCOPE_CYCLE_COUNTER(STAT_RegisterComponent);
FScopeCycleCounterUObject ComponentScope(this);
checkf(!IsUnreachable(), TEXT("%s"), *GetFullName());
if(IsPendingKill())
{
UE_LOG(LogActorComponent, Log, TEXT("RegisterComponentWithWorld: (%s) Trying to register component with IsPendingKill() == true. Aborting."), *GetPathName());
return;
}
// If the component was already registered, do nothing
if(IsRegistered())
{
UE_LOG(LogActorComponent, Log, TEXT("RegisterComponentWithWorld: (%s) Already registered. Aborting."), *GetPathName());
return;
}
if(InWorld == nullptr)
{
//UE_LOG(LogActorComponent, Log, TEXT("RegisterComponentWithWorld: (%s) NULL InWorld specified. Aborting."), *GetPathName());
return;
}
// If not registered, should not have a scene
checkf(WorldPrivate == nullptr, TEXT("%s"), *GetFullName());
AActor* MyOwner = GetOwner();
checkSlow(MyOwner == nullptr || MyOwner->OwnsComponent(this));
if (MyOwner && MyOwner->GetClass()->HasAnyClassFlags(CLASS_NewerVersionExists))
{
UE_LOG(LogActorComponent, Log, TEXT("RegisterComponentWithWorld: Owner belongs to a DEADCLASS"));
return;
}
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
// Can only register with an Actor if we are created within one
if(MyOwner)
{
checkf(!MyOwner->IsUnreachable(), TEXT("%s"), *GetFullName());
// can happen with undo because the owner will be restored "next"
//checkf(!MyOwner->IsPendingKill(), TEXT("%s"), *GetFullName());
if(InWorld != MyOwner->GetWorld())
{
// The only time you should specify a scene that is not Owner->GetWorld() is when you don't have an Actor
UE_LOG(LogActorComponent, Log, TEXT("RegisterComponentWithWorld: (%s) Specifying a world, but an Owner Actor found, and InWorld is not GetOwner()->GetWorld()"), *GetPathName());
}
}
#endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
if (!bHasBeenCreated)
{
OnComponentCreated();
}
WorldPrivate = InWorld;
ExecuteRegisterEvents(Context);
// If not in a game world register ticks now, otherwise defer until BeginPlay. If no owner we won't trigger BeginPlay either so register now in that case as well.
if (!InWorld->IsGameWorld())
{
RegisterAllComponentTickFunctions(true);
}
else if (MyOwner == nullptr)
{
if (!bHasBeenInitialized && bWantsInitializeComponent)
{
InitializeComponent();
}
RegisterAllComponentTickFunctions(true);
}
else
{
if (!bHasBeenInitialized && bWantsInitializeComponent && MyOwner->IsActorInitialized())
{
InitializeComponent();
}
if (MyOwner->HasActorBegunPlay() || MyOwner->IsActorBeginningPlay())
{
RegisterAllComponentTickFunctions(true);
if (!bHasBegunPlay)
{
BeginPlay();
ensureMsgf(bHasBegunPlay, TEXT("Failed to route BeginPlay (%s)"), *GetFullName());
}
}
}
// If this is a blueprint created component and it has component children they can miss getting registered in some scenarios
if (IsCreatedByConstructionScript())
{
TArray<UObject*> Children;
GetObjectsWithOuter(this, Children, true, RF_NoFlags, EInternalObjectFlags::PendingKill);
for (UObject* Child : Children)
{
if (UActorComponent* ChildComponent = Cast<UActorComponent>(Child))
{
if (ChildComponent->bAutoRegister && !ChildComponent->IsRegistered() && ChildComponent->GetOwner() == MyOwner)
{
ChildComponent->RegisterComponentWithWorld(InWorld);
}
}
}
}
}
void UActorComponent::ExecuteRegisterEvents(FRegisterComponentContext* Context)
{
if(!bRegistered)
{
SCOPE_CYCLE_COUNTER(STAT_ComponentOnRegister);
OnRegister();
checkf(bRegistered, TEXT("Failed to route OnRegister (%s)"), *GetFullName());
}
if(FApp::CanEverRender() && !bRenderStateCreated && WorldPrivate->Scene && ShouldCreateRenderState())
{
SCOPE_CYCLE_COUNTER(STAT_ComponentCreateRenderState);
LLM_SCOPE(ELLMTag::SceneRender);
CreateRenderState_Concurrent(Context);
checkf(bRenderStateCreated, TEXT("Failed to route CreateRenderState_Concurrent (%s)"), *GetFullName());
}
CreatePhysicsState(/*bAllowDeferral=*/true);
}
void UActorComponent::CreateRenderState_Concurrent(FRegisterComponentContext* Context)
{
check(IsRegistered());
check(WorldPrivate->Scene);
check(!bRenderStateCreated);
bRenderStateCreated = true;
bRenderStateDirty = false;
bRenderTransformDirty = false;
bRenderDynamicDataDirty = false;
#if LOG_RENDER_STATE
UE_LOG(LogActorComponent, Log, TEXT("CreateRenderState_Concurrent: %s"), *GetPathName());
#endif
}
ActorComponent.h
/**
* Used to create any rendering thread information for this component
* @warning This is called concurrently on multiple threads (but never the same component concurrently)
*/
virtual void CreateRenderState_Concurrent(FRegisterComponentContext* Context);https://docs.unrealengine.com/4.26/en-US/API/Runtime/Engine/Components/ULocalLightComponent/
UObjectBase
UObjectBaseUtility
UObject
UActorComponent
USceneComponent
ULightComponentBase
ULightComponent
ULocalLightComponent
UPointLightComponent
USpotLightComponent
URectLightComponent
UDirectionalLightComponentLightComponent.cp
void ULightComponent::CreateRenderState_Concurrent(FRegisterComponentContext* Context)
{
Super::CreateRenderState_Concurrent(Context);
if (bAffectsWorld)
{
UWorld* World = GetWorld();
const bool bHidden = !ShouldComponentAddToScene() || !ShouldRender() || Intensity <= 0.f;
if (!bHidden)
{
InitializeStaticShadowDepthMap();
// Add the light to the scene.
World->Scene->AddLight(this);
bAddedToSceneVisible = true;
}
// Add invisible stationary lights to the scene in the editor
// Even invisible stationary lights consume a shadowmap channel so they must be included in the stationary light overlap preview
else if (GIsEditor
&& !World->IsGameWorld()
&& CastShadows
&& CastStaticShadows
&& HasStaticShadowing()
&& !HasStaticLighting())
{
InitializeStaticShadowDepthMap();
World->Scene->AddInvisibleLight(this);
}
}
}RenderScene.cpp
void FScene::AddLight(ULightComponent* Light)
{
LLM_SCOPE(ELLMTag::SceneRender);
// Create the light's scene proxy.
FLightSceneProxy* Proxy = Light->CreateSceneProxy();
if(Proxy)
{
// Associate the proxy with the light.
Light->SceneProxy = Proxy;
// Update the light's transform and position.
Proxy->SetTransform(Light->GetComponentTransform().ToMatrixNoScale(), Light->GetLightPosition());
// Create the light scene info.
Proxy->LightSceneInfo = new FLightSceneInfo(Proxy, true);
INC_DWORD_STAT(STAT_SceneLights);
// Adding a new light
++NumVisibleLights_GameThread;
// Send a command to the rendering thread to add the light to the scene.
FScene* Scene = this;
FLightSceneInfo* LightSceneInfo = Proxy->LightSceneInfo;
ENQUEUE_RENDER_COMMAND(FAddLightCommand)(
[Scene, LightSceneInfo](FRHICommandListImmediate& RHICmdList)
{
CSV_SCOPED_TIMING_STAT_EXCLUSIVE(Scene_AddLight);
FScopeCycleCounter Context(LightSceneInfo->Proxy->GetStatId());
Scene->AddLightSceneInfo_RenderThread(LightSceneInfo);
});
}
}
pointlightcomponent.cpp
FLightSceneProxy* UPointLightComponent::CreateSceneProxy() const
{
if (IsPointLightSupported(this))
{
return new FPointLightSceneProxy(this);
}
return nullptr;
}
/** Accesses parameters needed for rendering the light. */
void FPointLightSceneProxy::GetLightShaderParameters(FLightShaderParameters& LightParameters) const
{
LightParameters.Position = GetOrigin();
LightParameters.InvRadius = InvRadius;
LightParameters.Color = FVector(GetColor());
LightParameters.FalloffExponent = FalloffExponent;
LightParameters.Direction = -GetDirection();
LightParameters.Tangent = FVector(WorldToLight.M[0][2], WorldToLight.M[1][2], WorldToLight.M[2][2]);
LightParameters.SpotAngles = FVector2D( -2.0f, 1.0f );
LightParameters.SpecularScale = SpecularScale;
LightParameters.SourceRadius = SourceRadius;
LightParameters.SoftSourceRadius = SoftSourceRadius;
LightParameters.SourceLength = SourceLength;
LightParameters.SourceTexture = GWhiteTexture->TextureRHI;
LightParameters.RectLightBarnCosAngle = 0.0f;
LightParameters.RectLightBarnLength = -2.0f;
}
/**
* Sets up a projected shadow initializer for shadows from the entire scene.
* @return True if the whole-scene projected shadow should be used.
*/
bool FPointLightSceneProxy::GetWholeSceneProjectedShadowInitializer(const FSceneViewFamily& ViewFamily, TArray<FWholeSceneProjectedShadowInitializer, TInlineAllocator<6> >& OutInitializers) const
{
if (ViewFamily.GetFeatureLevel() >= ERHIFeatureLevel::SM5
&& GAllowPointLightCubemapShadows != 0)
{
FWholeSceneProjectedShadowInitializer& OutInitializer = *new(OutInitializers) FWholeSceneProjectedShadowInitializer;
OutInitializer.PreShadowTranslation = -GetLightToWorld().GetOrigin();
OutInitializer.WorldToLight = GetWorldToLight().RemoveTranslation();
OutInitializer.Scales = FVector(1, 1, 1);
OutInitializer.FaceDirection = FVector(0,0,1);
OutInitializer.SubjectBounds = FBoxSphereBounds(FVector(0, 0, 0),FVector(Radius,Radius,Radius),Radius);
OutInitializer.WAxis = FVector4(0,0,1,0);
OutInitializer.MinLightW = 0.1f;
OutInitializer.MaxDistanceToCastInLightW = Radius;
bool bSupportsGeometryShaders = RHISupportsGeometryShaders(GShaderPlatformForFeatureLevel[ViewFamily.GetFeatureLevel()]) || RHISupportsVertexShaderLayer(ViewFamily.GetShaderPlatform());
OutInitializer.bOnePassPointLightShadow = bSupportsGeometryShaders;
OutInitializer.bRayTracedDistanceField = UseRayTracedDistanceFieldShadows() && DoesPlatformSupportDistanceFieldShadowing(ViewFamily.GetShaderPlatform());
return true;
}
return false;
}pointlightsceneproxy.h
class FPointLightSceneProxy : public FLocalLightSceneProxy
{
public:
/** The light falloff exponent. */
float FalloffExponent;
/** Radius of light source shape */
float SourceRadius;
/** Soft radius of light source shape */
float SoftSourceRadius;
/** Length of light source shape */
float SourceLength;
/** Whether light uses inverse squared falloff. */
const uint32 bInverseSquared : 1;
/** Initialization constructor. */
FPointLightSceneProxy(const UPointLightComponent* Component)
: FLocalLightSceneProxy(Component)
, FalloffExponent(Component->LightFalloffExponent)
, SourceRadius(Component->SourceRadius)
, SoftSourceRadius(Component->SoftSourceRadius)
, SourceLength(Component->SourceLength)
, bInverseSquared(Component->bUseInverseSquaredFalloff)
{
UpdateRadius(Component->AttenuationRadius);
// tiled deferred only supported for point/spot lights with 0 length
bTiledDeferredLightingSupported = (SourceLength == 0.0f);
}
virtual float GetSourceRadius() const override
{
return SourceRadius;
}
virtual bool IsInverseSquared() const override
{
return bInverseSquared;
}
virtual void GetLightShaderParameters(FLightShaderParameters& PathTracingLightParameters) const override;
virtual FVector GetPerObjectProjectedShadowProjectionPoint(const FBoxSphereBounds& SubjectBounds) const override
{
return FMath::ClosestPointOnSegment(SubjectBounds.Origin, GetOrigin() - GetDirection() * SourceLength * 0.5f, GetOrigin() + GetDirection() * SourceLength * 0.5f);
}
virtual bool GetWholeSceneProjectedShadowInitializer(const FSceneViewFamily& ViewFamily, TArray<FWholeSceneProjectedShadowInitializer, TInlineAllocator<6> >& OutInitializers) const;
};