UActorComponent* FComponentEditorUtils::DuplicateComponent(UActorComponent* TemplateComponent)
{
check(TemplateComponent);
UActorComponent* NewCloneComponent = nullptr;
AActor* Actor = TemplateComponent->GetOwner();
if (!TemplateComponent->IsEditorOnly() && Actor)
{
Actor->Modify();
UClass* ComponentClass = TemplateComponent->GetClass();
FName NewComponentName = *FComponentEditorUtils::GenerateValidVariableName(ComponentClass, Actor);
bool bKeepWorldLocationOnAttach = false;
const bool bTemplateTransactional = TemplateComponent->HasAllFlags(RF_Transactional);
TemplateComponent->SetFlags(RF_Transactional);
NewCloneComponent = DuplicateObject<UActorComponent>(TemplateComponent, Actor, NewComponentName );
if (!bTemplateTransactional)
{
TemplateComponent->ClearFlags(RF_Transactional);
}
USceneComponent* NewSceneComponent = Cast<USceneComponent>(NewCloneComponent);
if (NewSceneComponent)
{
// Ensure the clone doesn't think it has children
NewSceneComponent->AttachChildren.Empty();
// If the clone is a scene component without an attach parent, attach it to the root (can happen when duplicating the root component)
if (!NewSceneComponent->GetAttachParent())
{
USceneComponent* RootComponent = Actor->GetRootComponent();
check(RootComponent);
// ComponentToWorld is not a UPROPERTY, so make sure the clone has calculated it properly before attachment
NewSceneComponent->UpdateComponentToWorld();
NewSceneComponent->AttachTo(RootComponent, NAME_None, EAttachLocation::KeepWorldPosition);
}
}
NewCloneComponent->OnComponentCreated();
// Add to SerializedComponents array so it gets saved
Actor->AddInstanceComponent(NewCloneComponent);
// Register the new component
NewCloneComponent->RegisterComponent();
// Rerun construction scripts
Actor->RerunConstructionScripts();
}
return NewCloneComponent;
}
void UChildActorComponent::ApplyComponentInstanceData(FChildActorComponentInstanceData* ChildActorInstanceData, const ECacheApplyPhase CacheApplyPhase)
{
check(ChildActorInstanceData);
ChildActorName = ChildActorInstanceData->ChildActorName;
if (ChildActor)
{
// Only rename if it is safe to
if(ChildActorName != NAME_None)
{
const FString ChildActorNameString = ChildActorName.ToString();
if (ChildActor->Rename(*ChildActorNameString, nullptr, REN_Test))
{
ChildActor->Rename(*ChildActorNameString, nullptr, REN_DoNotDirty | (IsLoading() ? REN_ForceNoResetLoaders : REN_None));
}
}
if (ChildActorInstanceData->ComponentInstanceData)
{
ChildActorInstanceData->ComponentInstanceData->ApplyToActor(ChildActor, CacheApplyPhase);
}
USceneComponent* ChildActorRoot = ChildActor->GetRootComponent();
if (ChildActorRoot)
{
for (const auto& AttachInfo : ChildActorInstanceData->AttachedActors)
{
AActor* AttachedActor = AttachInfo.Actor.Get();
if (AttachedActor)
{
USceneComponent* AttachedRootComponent = AttachedActor->GetRootComponent();
if (AttachedRootComponent)
{
AttachedActor->DetachRootComponentFromParent();
AttachedRootComponent->AttachToComponent(ChildActorRoot, FAttachmentTransformRules::KeepWorldTransform, AttachInfo.SocketName);
AttachedRootComponent->SetRelativeTransform(AttachInfo.RelativeTransform);
AttachedRootComponent->UpdateComponentToWorld();
}
}
}
}
}
}
void UChildActorComponent::ApplyComponentInstanceData(FChildActorComponentInstanceData* ChildActorInstanceData)
{
check(ChildActorInstanceData);
ChildActorName = ChildActorInstanceData->ChildActorName;
if (ChildActor)
{
// Only rename if it is safe to
if(ChildActorName != NAME_None)
{
const FString ChildActorNameString = ChildActorName.ToString();
if (ChildActor->Rename(*ChildActorNameString, nullptr, REN_Test))
{
ChildActor->Rename(*ChildActorNameString, nullptr, REN_DoNotDirty);
}
}
USceneComponent* ChildActorRoot = ChildActor->GetRootComponent();
if (ChildActorRoot)
{
for (const auto& AttachInfo : ChildActorInstanceData->AttachedActors)
{
AActor* AttachedActor = AttachInfo.Actor.Get();
if (AttachedActor)
{
USceneComponent* AttachedRootComponent = AttachedActor->GetRootComponent();
if (AttachedRootComponent)
{
AttachedActor->DetachRootComponentFromParent();
AttachedRootComponent->AttachTo(ChildActorRoot, AttachInfo.SocketName, EAttachLocation::KeepWorldPosition);
AttachedRootComponent->SetRelativeTransform(AttachInfo.RelativeTransform);
AttachedRootComponent->UpdateComponentToWorld();
}
}
}
}
}
}
void FActorReplacementHelper::AttachChildActors(USceneComponent* RootComponent, const TMap<UObject*, UObject*>& OldToNewInstanceMap)
{
// if we had attached children reattach them now - unless they are already attached
for (FAttachedActorInfo& Info : PendingChildAttachments)
{
// Check for a reinstanced attachment, and redirect to the new instance if found
AActor* NewAttachedActor = Cast<AActor>(OldToNewInstanceMap.FindRef(Info.AttachedActor));
if (NewAttachedActor)
{
Info.AttachedActor = NewAttachedActor;
}
// If this actor is no longer attached to anything, reattach
if (!Info.AttachedActor->IsPendingKill() && Info.AttachedActor->GetAttachParentActor() == nullptr)
{
USceneComponent* ChildRoot = Info.AttachedActor->GetRootComponent();
if (ChildRoot && ChildRoot->AttachParent != RootComponent)
{
ChildRoot->AttachTo(RootComponent, Info.AttachedToSocket, EAttachLocation::KeepWorldPosition);
ChildRoot->UpdateComponentToWorld();
}
}
}
}
void AActor::RerunConstructionScripts()
{
checkf(!HasAnyFlags(RF_ClassDefaultObject), TEXT("RerunConstructionScripts should never be called on a CDO as it can mutate the transient data on the CDO which then propagates to instances!"));
FEditorScriptExecutionGuard ScriptGuard;
// don't allow (re)running construction scripts on dying actors
bool bAllowReconstruction = !IsPendingKill() && !HasAnyFlags(RF_BeginDestroyed|RF_FinishDestroyed);
#if WITH_EDITOR
if(bAllowReconstruction && GIsEditor)
{
// Generate the blueprint hierarchy for this actor
TArray<UBlueprint*> ParentBPStack;
bAllowReconstruction = UBlueprint::GetBlueprintHierarchyFromClass(GetClass(), ParentBPStack);
if(bAllowReconstruction)
{
for(int i = ParentBPStack.Num() - 1; i > 0 && bAllowReconstruction; --i)
{
const UBlueprint* ParentBP = ParentBPStack[i];
if(ParentBP && ParentBP->bBeingCompiled)
{
// don't allow (re)running construction scripts if a parent BP is being compiled
bAllowReconstruction = false;
}
}
}
}
#endif
if(bAllowReconstruction)
{
// Set global flag to let system know we are reconstructing blueprint instances
TGuardValue<bool> GuardTemplateNameFlag(GIsReconstructingBlueprintInstances, true);
// Temporarily suspend the undo buffer; we don't need to record reconstructed component objects into the current transaction
ITransaction* CurrentTransaction = GUndo;
GUndo = NULL;
// Create cache to store component data across rerunning construction scripts
#if WITH_EDITOR
FActorTransactionAnnotation* ActorTransactionAnnotation = CurrentTransactionAnnotation.Get();
#endif
FComponentInstanceDataCache* InstanceDataCache;
FTransform OldTransform = FTransform::Identity;
FName SocketName;
AActor* Parent = NULL;
USceneComponent* ParentComponent = NULL;
bool bUseRootComponentProperties = true;
// Struct to store info about attached actors
struct FAttachedActorInfo
{
AActor* AttachedActor;
FName AttachedToSocket;
bool bSetRelativeTransform;
FTransform RelativeTransform;
};
// Save info about attached actors
TArray<FAttachedActorInfo> AttachedActorInfos;
#if WITH_EDITOR
if (ActorTransactionAnnotation)
{
InstanceDataCache = &ActorTransactionAnnotation->ComponentInstanceData;
if (ActorTransactionAnnotation->bRootComponentDataCached)
{
OldTransform = ActorTransactionAnnotation->RootComponentData.Transform;
Parent = ActorTransactionAnnotation->RootComponentData.AttachedParentInfo.Actor.Get();
if (Parent)
{
USceneComponent* AttachParent = ActorTransactionAnnotation->RootComponentData.AttachedParentInfo.AttachParent.Get();
ParentComponent = (AttachParent ? AttachParent : FindObjectFast<USceneComponent>(Parent, ActorTransactionAnnotation->RootComponentData.AttachedParentInfo.AttachParentName));
SocketName = ActorTransactionAnnotation->RootComponentData.AttachedParentInfo.SocketName;
DetachRootComponentFromParent();
}
for (const auto& CachedAttachInfo : ActorTransactionAnnotation->RootComponentData.AttachedToInfo)
{
AActor* AttachedActor = CachedAttachInfo.Actor.Get();
if (AttachedActor)
{
FAttachedActorInfo Info;
Info.AttachedActor = AttachedActor;
Info.AttachedToSocket = CachedAttachInfo.SocketName;
Info.bSetRelativeTransform = true;
Info.RelativeTransform = CachedAttachInfo.RelativeTransform;
AttachedActorInfos.Add(Info);
AttachedActor->DetachRootComponentFromParent();
}
}
bUseRootComponentProperties = false;
}
}
else
#endif
{
InstanceDataCache = new FComponentInstanceDataCache(this);
// If there are attached objects detach them and store the socket names
TArray<AActor*> AttachedActors;
GetAttachedActors(AttachedActors);
for (AActor* AttachedActor : AttachedActors)
{
USceneComponent* EachRoot = AttachedActor->GetRootComponent();
// If the component we are attached to is about to go away...
if (EachRoot && EachRoot->AttachParent && EachRoot->AttachParent->IsCreatedByConstructionScript())
{
// Save info about actor to reattach
FAttachedActorInfo Info;
Info.AttachedActor = AttachedActor;
Info.AttachedToSocket = EachRoot->AttachSocketName;
Info.bSetRelativeTransform = false;
AttachedActorInfos.Add(Info);
// Now detach it
AttachedActor->Modify();
EachRoot->DetachFromParent(true);
}
}
}
if (bUseRootComponentProperties && RootComponent != nullptr)
{
// Do not need to detach if root component is not going away
if (RootComponent->AttachParent != NULL && RootComponent->IsCreatedByConstructionScript())
{
Parent = RootComponent->AttachParent->GetOwner();
// Root component should never be attached to another component in the same actor!
if (Parent == this)
{
UE_LOG(LogActor, Warning, TEXT("RerunConstructionScripts: RootComponent (%s) attached to another component in this Actor (%s)."), *RootComponent->GetPathName(), *Parent->GetPathName());
Parent = NULL;
}
ParentComponent = RootComponent->AttachParent;
SocketName = RootComponent->AttachSocketName;
//detach it to remove any scaling
RootComponent->DetachFromParent(true);
}
OldTransform = RootComponent->ComponentToWorld;
OldTransform.SetTranslation(RootComponent->GetComponentLocation()); // take into account any custom location
}
#if WITH_EDITOR
// Save the current construction script-created components by name
TMap<const FName, UObject*> DestroyedComponentsByName;
TInlineComponentArray<UActorComponent*> PreviouslyAttachedComponents;
GetComponents(PreviouslyAttachedComponents);
for (auto Component : PreviouslyAttachedComponents)
{
if (Component)
{
if (Component->IsCreatedByConstructionScript())
{
DestroyedComponentsByName.Add(Component->GetFName(), Component);
}
else
{
UActorComponent* OuterComponent = Component->GetTypedOuter<UActorComponent>();
while (OuterComponent)
{
if (OuterComponent->IsCreatedByConstructionScript())
{
DestroyedComponentsByName.Add(Component->GetFName(), Component);
break;
}
OuterComponent = OuterComponent->GetTypedOuter<UActorComponent>();
}
}
}
}
#endif
// Destroy existing components
DestroyConstructedComponents();
// Reset random streams
ResetPropertiesForConstruction();
// Exchange net roles before running construction scripts
UWorld *OwningWorld = GetWorld();
if (OwningWorld && !OwningWorld->IsServer())
{
ExchangeNetRoles(true);
}
// Run the construction scripts
ExecuteConstruction(OldTransform, InstanceDataCache);
if(Parent)
{
USceneComponent* ChildRoot = GetRootComponent();
if (ParentComponent == NULL)
{
ParentComponent = Parent->GetRootComponent();
}
if (ChildRoot != NULL && ParentComponent != NULL)
{
ChildRoot->AttachTo(ParentComponent, SocketName, EAttachLocation::KeepWorldPosition);
}
}
// If we had attached children reattach them now - unless they are already attached
for(FAttachedActorInfo& Info : AttachedActorInfos)
{
// If this actor is no longer attached to anything, reattach
if (!Info.AttachedActor->IsPendingKill() && Info.AttachedActor->GetAttachParentActor() == NULL)
{
USceneComponent* ChildRoot = Info.AttachedActor->GetRootComponent();
if (ChildRoot && ChildRoot->AttachParent != RootComponent)
{
ChildRoot->AttachTo(RootComponent, Info.AttachedToSocket, EAttachLocation::KeepWorldPosition);
if (Info.bSetRelativeTransform)
{
ChildRoot->SetRelativeTransform(Info.RelativeTransform);
}
ChildRoot->UpdateComponentToWorld();
}
}
}
// Restore the undo buffer
GUndo = CurrentTransaction;
#if WITH_EDITOR
// Create the mapping of old->new components and notify the editor of the replacements
TMap<UObject*, UObject*> OldToNewComponentMapping;
TInlineComponentArray<UActorComponent*> NewComponents;
GetComponents(NewComponents);
for (auto NewComp : NewComponents)
{
const FName NewCompName = NewComp->GetFName();
if (DestroyedComponentsByName.Contains(NewCompName))
{
OldToNewComponentMapping.Add(DestroyedComponentsByName[NewCompName], NewComp);
}
}
if (GEditor && (OldToNewComponentMapping.Num() > 0))
{
GEditor->NotifyToolsOfObjectReplacement(OldToNewComponentMapping);
}
if (ActorTransactionAnnotation)
{
CurrentTransactionAnnotation = NULL;
}
else
#endif
{
delete InstanceDataCache;
}
}
}
void AActor::RerunConstructionScripts()
{
// don't allow (re)running construction scripts on dying actors
bool bAllowReconstruction = !IsPendingKill() && !HasAnyFlags(RF_BeginDestroyed|RF_FinishDestroyed);
#if WITH_EDITOR
if(bAllowReconstruction && GIsEditor)
{
// Generate the blueprint hierarchy for this actor
TArray<UBlueprint*> ParentBPStack;
bAllowReconstruction = UBlueprint::GetBlueprintHierarchyFromClass(GetClass(), ParentBPStack);
if(bAllowReconstruction)
{
for(int i = ParentBPStack.Num() - 1; i > 0 && bAllowReconstruction; --i)
{
const UBlueprint* ParentBP = ParentBPStack[i];
if(ParentBP && ParentBP->bBeingCompiled)
{
// don't allow (re)running construction scripts if a parent BP is being compiled
bAllowReconstruction = false;
}
}
}
}
#endif
if(bAllowReconstruction)
{
// Temporarily suspend the undo buffer; we don't need to record reconstructed component objects into the current transaction
ITransaction* CurrentTransaction = GUndo;
GUndo = NULL;
// Create cache to store component data across rerunning construction scripts
FComponentInstanceDataCache InstanceDataCache(this);
// If there are attached objects detach them and store the socket names
TArray<AActor*> AttachedActors;
GetAttachedActors(AttachedActors);
// Struct to store info about attached actors
struct FAttachedActorInfo
{
AActor* AttachedActor;
FName AttachedToSocket;
};
// Save info about attached actors
TArray<FAttachedActorInfo> AttachedActorInfos;
for( AActor* AttachedActor : AttachedActors)
{
USceneComponent* EachRoot = AttachedActor->GetRootComponent();
// If the component we are attached to is about to go away...
if( EachRoot && EachRoot->AttachParent && EachRoot->AttachParent->bCreatedByConstructionScript )
{
// Save info about actor to reattach
FAttachedActorInfo Info;
Info.AttachedActor = AttachedActor;
Info.AttachedToSocket = EachRoot->AttachSocketName;
AttachedActorInfos.Add(Info);
// Now detach it
AttachedActor->Modify();
EachRoot->DetachFromParent(true);
}
}
// Save off original pose of the actor
FTransform OldTransform = FTransform::Identity;
FName SocketName;
AActor* Parent = NULL;
if (RootComponent != NULL)
{
// Do not need to detach if root component is not going away
if(RootComponent->AttachParent != NULL && RootComponent->bCreatedByConstructionScript)
{
Parent = RootComponent->AttachParent->GetOwner();
// Root component should never be attached to another component in the same actor!
if(Parent == this)
{
UE_LOG(LogActor, Warning, TEXT("RerunConstructionScripts: RootComponent (%s) attached to another component in this Actor (%s)."), *RootComponent->GetPathName(), *Parent->GetPathName());
Parent = NULL;
}
SocketName = RootComponent->AttachSocketName;
//detach it to remove any scaling
RootComponent->DetachFromParent(true);
}
OldTransform = RootComponent->ComponentToWorld;
}
// Destroy existing components
DestroyConstructedComponents();
// Reset random streams
ResetPropertiesForConstruction();
// Run the construction scripts
OnConstruction(OldTransform);
if(Parent)
{
USceneComponent* ChildRoot = GetRootComponent();
USceneComponent* ParentRoot = Parent->GetRootComponent();
if(ChildRoot != NULL && ParentRoot != NULL)
{
ChildRoot->AttachTo( ParentRoot, SocketName, EAttachLocation::KeepWorldPosition );
}
}
// Apply per-instance data.
InstanceDataCache.ApplyToActor(this);
// If we had attached children reattach them now - unless they are already attached
for(FAttachedActorInfo& Info : AttachedActorInfos)
{
// If this actor is no longer attached to anything, reattach
if (Info.AttachedActor->GetAttachParentActor() == NULL)
{
USceneComponent* ChildRoot = Info.AttachedActor->GetRootComponent();
if (ChildRoot && ChildRoot->AttachParent != RootComponent)
{
ChildRoot->AttachTo(RootComponent, Info.AttachedToSocket, EAttachLocation::KeepWorldPosition);
ChildRoot->UpdateComponentToWorld();
}
}
}
// Restore the undo buffer
GUndo = CurrentTransaction;
}
}
