本文整理汇总了C++中USceneComponent::AttachTo方法的典型用法代码示例。如果您正苦于以下问题:C++ USceneComponent::AttachTo方法的具体用法?C++ USceneComponent::AttachTo怎么用?C++ USceneComponent::AttachTo使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类USceneComponent
的用法示例。
在下文中一共展示了USceneComponent::AttachTo方法的10个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: OnRegister
void UChildActorComponent::OnRegister()
{
Super::OnRegister();
if (ChildActor)
{
if (ChildActor->GetClass() != ChildActorClass)
{
DestroyChildActor();
CreateChildActor();
}
else
{
ChildActorName = ChildActor->GetFName();
USceneComponent* ChildRoot = ChildActor->GetRootComponent();
if (ChildRoot && ChildRoot->GetAttachParent() != this)
{
// attach new actor to this component
// we can't attach in CreateChildActor since it has intermediate Mobility set up
// causing spam with inconsistent mobility set up
// so moving Attach to happen in Register
ChildRoot->AttachTo(this, NAME_None, EAttachLocation::SnapToTarget);
}
}
}
else if (ChildActorClass)
{
CreateChildActor();
}
}
示例2: AddComponent
UActorComponent* AActor::AddComponent(FName TemplateName, bool bManualAttachment, const FTransform& RelativeTransform, const UObject* ComponentTemplateContext)
{
UActorComponent* Template = nullptr;
UBlueprintGeneratedClass* BlueprintGeneratedClass = Cast<UBlueprintGeneratedClass>((ComponentTemplateContext != nullptr) ? ComponentTemplateContext->GetClass() : GetClass());
while(BlueprintGeneratedClass != nullptr)
{
Template = BlueprintGeneratedClass->FindComponentTemplateByName(TemplateName);
if(nullptr != Template)
{
break;
}
BlueprintGeneratedClass = Cast<UBlueprintGeneratedClass>(BlueprintGeneratedClass->GetSuperClass());
}
bool bIsSceneComponent = false;
UActorComponent* NewActorComp = CreateComponentFromTemplate(Template);
if(NewActorComp != nullptr)
{
// Call function to notify component it has been created
NewActorComp->OnComponentCreated();
// The user has the option of doing attachment manually where they have complete control or via the automatic rule
// that the first component added becomes the root component, with subsequent components attached to the root.
USceneComponent* NewSceneComp = Cast<USceneComponent>(NewActorComp);
if(NewSceneComp != nullptr)
{
if (!bManualAttachment)
{
if (RootComponent == nullptr)
{
RootComponent = NewSceneComp;
}
else
{
NewSceneComp->AttachTo(RootComponent);
}
}
NewSceneComp->SetRelativeTransform(RelativeTransform);
bIsSceneComponent = true;
}
// Register component, which will create physics/rendering state, now component is in correct position
NewActorComp->RegisterComponent();
UWorld* World = GetWorld();
if (!bRunningUserConstructionScript && World && bIsSceneComponent)
{
UPrimitiveComponent* NewPrimitiveComponent = Cast<UPrimitiveComponent>(NewActorComp);
if (NewPrimitiveComponent && ACullDistanceVolume::CanBeAffectedByVolumes(NewPrimitiveComponent))
{
World->UpdateCullDistanceVolumes(this, NewPrimitiveComponent);
}
}
}
return NewActorComp;
}
示例3: DuplicateComponent
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;
}
示例4: ApplyComponentInstanceData
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->AttachTo(ChildActorRoot, AttachInfo.SocketName, EAttachLocation::KeepWorldPosition);
AttachedRootComponent->SetRelativeTransform(AttachInfo.RelativeTransform);
AttachedRootComponent->UpdateComponentToWorld();
}
}
}
}
}
}
示例5: ApplyAttachments
void FActorReplacementHelper::ApplyAttachments(const TMap<UObject*, UObject*>& OldToNewInstanceMap)
{
USceneComponent* NewRootComponent = NewActor->GetRootComponent();
if (NewRootComponent == nullptr)
{
return;
}
// attach the new instance to original parent
if (TargetAttachParent != nullptr)
{
if (TargetParentComponent == nullptr)
{
TargetParentComponent = TargetAttachParent->GetRootComponent();
}
else
{
NewRootComponent->AttachTo(TargetParentComponent, TargetAttachSocket, EAttachLocation::KeepWorldPosition);
}
}
AttachChildActors(NewRootComponent, OldToNewInstanceMap);
}
示例6: AttachChildActors
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();
}
}
}
}
示例7: RerunConstructionScripts
//.........这里部分代码省略.........
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;
}
}
}
示例8: ExecuteNodeOnActor
UActorComponent* USCS_Node::ExecuteNodeOnActor(AActor* Actor, USceneComponent* ParentComponent, const FTransform* RootTransform, bool bIsDefaultTransform)
{
check(Actor != nullptr);
check((ParentComponent != nullptr && !ParentComponent->IsPendingKill()) || (RootTransform != nullptr)); // must specify either a parent component or a world transform
auto ActualBPGC = Cast<UBlueprintGeneratedClass>(Actor->GetClass());
UActorComponent* ActualComponentTemplate = GetActualComponentTemplate(ActualBPGC);
// Create a new component instance based on the template
UActorComponent* NewActorComp = Actor->CreateComponentFromTemplate(ActualComponentTemplate, VariableName.ToString());
if(NewActorComp != nullptr)
{
NewActorComp->CreationMethod = EComponentCreationMethod::SimpleConstructionScript;
// SCS created components are net addressable
NewActorComp->SetNetAddressable();
// Special handling for scene components
USceneComponent* NewSceneComp = Cast<USceneComponent>(NewActorComp);
if (NewSceneComp != nullptr)
{
// If NULL is passed in, we are the root, so set transform and assign as RootComponent on Actor
if (ParentComponent == nullptr || (ParentComponent && ParentComponent->IsPendingKill()))
{
FTransform WorldTransform = *RootTransform;
if(bIsDefaultTransform)
{
// Note: We use the scale vector from the component template when spawning (to match what happens with a native root)
WorldTransform.SetScale3D(NewSceneComp->RelativeScale3D);
}
NewSceneComp->SetWorldTransform(WorldTransform);
Actor->SetRootComponent(NewSceneComp);
}
// Otherwise, attach to parent component passed in
else
{
NewSceneComp->AttachTo(ParentComponent, AttachToName);
}
}
// Call function to notify component it has been created
NewActorComp->OnComponentCreated();
if (NewActorComp->GetIsReplicated())
{
// Make sure this component is added to owning actor's replicated list.
NewActorComp->SetIsReplicated(true);
}
// If we want to save this to a property, do it here
FName VarName = GetVariableName();
if (VarName != NAME_None)
{
UClass* ActorClass = Actor->GetClass();
if (UObjectPropertyBase* Prop = FindField<UObjectPropertyBase>(ActorClass, VarName))
{
Prop->SetObjectPropertyValue_InContainer(Actor, NewActorComp);
}
else
{
UE_LOG(LogBlueprint, Log, TEXT("ExecuteNodeOnActor: Couldn't find property '%s' on '%s"), *VarName.ToString(), *Actor->GetName());
#if WITH_EDITOR
// If we're constructing editable components in the SCS editor, set the component instance corresponding to this node for editing purposes
USimpleConstructionScript* SCS = GetSCS();
if(SCS != nullptr && (SCS->IsConstructingEditorComponents() || SCS->GetComponentEditorActorInstance() == Actor))
{
EditorComponentInstance = NewSceneComp;
}
#endif
}
}
// Determine the parent component for our children (it's still our parent if we're a non-scene component)
USceneComponent* ParentSceneComponentOfChildren = (NewSceneComp != nullptr) ? NewSceneComp : ParentComponent;
// If we made a component, go ahead and process our children
for (int32 NodeIdx = 0; NodeIdx < ChildNodes.Num(); NodeIdx++)
{
USCS_Node* Node = ChildNodes[NodeIdx];
check(Node != nullptr);
Node->ExecuteNodeOnActor(Actor, ParentSceneComponentOfChildren, nullptr, false);
}
}
return NewActorComp;
}
示例9: AddComponent
UActorComponent* AActor::AddComponent(FName TemplateName, bool bManualAttachment, const FTransform& RelativeTransform, const UObject* ComponentTemplateContext)
{
UActorComponent* Template = NULL;
UBlueprintGeneratedClass* BlueprintGeneratedClass = Cast<UBlueprintGeneratedClass>((ComponentTemplateContext != NULL) ? ComponentTemplateContext->GetClass() : GetClass());
while(BlueprintGeneratedClass != NULL)
{
Template = BlueprintGeneratedClass->FindComponentTemplateByName(TemplateName);
if(NULL != Template)
{
break;
}
BlueprintGeneratedClass = Cast<UBlueprintGeneratedClass>(BlueprintGeneratedClass->GetSuperClass());
}
UActorComponent* NewActorComp = CreateComponentFromTemplate(Template);
if(NewActorComp != NULL)
{
// The user has the option of doing attachment manually where they have complete control or via the automatic rule
// that the first component added becomes the root component, with subsequent components attached to the root.
USceneComponent* NewSceneComp = Cast<USceneComponent>(NewActorComp);
bool bDeferRegisterStaticComponent = false;
EComponentMobility::Type OriginalMobility = EComponentMobility::Movable;
if(NewSceneComp != NULL)
{
// Components with Mobility set to EComponentMobility::Static or EComponentMobility::Stationary can't be properly set up in UCS (all changes will be rejected
// due to EComponentMobility::Static flag) so we're going to temporarily change the flag and defer the registration until UCS has finished.
bDeferRegisterStaticComponent = bRunningUserConstructionScript && NewSceneComp->Mobility != EComponentMobility::Movable;
OriginalMobility = NewSceneComp->Mobility;
if (bDeferRegisterStaticComponent)
{
NewSceneComp->Mobility = EComponentMobility::Movable;
}
if (!bManualAttachment)
{
if (RootComponent == NULL)
{
RootComponent = NewSceneComp;
}
else
{
NewSceneComp->AttachTo(RootComponent);
}
}
NewSceneComp->SetRelativeTransform(RelativeTransform);
}
// Call function to notify component it has been created
NewActorComp->OnComponentCreated();
if (bDeferRegisterStaticComponent)
{
// Defer registration until after UCS has completed.
FDeferRegisterStaticComponents::Get().DeferStaticComponent(this, NewSceneComp, OriginalMobility);
}
else
{
// Register component, which will create physics/rendering state, now component is in correct position
NewActorComp->RegisterComponent();
}
}
return NewActorComp;
}
示例10: RerunConstructionScripts
//.........这里部分代码省略.........
// 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;
}
}