FName MoveFolderTo(FName InPath, FName NewParent, UWorld& World)
{
FName NewPath = GetFolderLeafName(InPath);
if (!NewParent.IsNone())
{
NewPath = FName(*(NewParent.ToString() / NewPath.ToString()));
}
if (FActorFolders::Get().RenameFolderInWorld(World, InPath, NewPath))
{
return NewPath;
}
return FName();
}
bool FDataTableImporterJSON::ReadRow(const TSharedRef<FJsonObject>& InParsedTableRowObject, const int32 InRowIdx)
{
// Get row name
FName RowName = DataTableUtils::MakeValidName(InParsedTableRowObject->GetStringField(TEXT("Name")));
// Check its not 'none'
if (RowName.IsNone())
{
ImportProblems.Add(FString::Printf(TEXT("Row '%d' missing a name."), InRowIdx));
return false;
}
// Check its not a duplicate
if (DataTable->RowMap.Find(RowName) != nullptr)
{
ImportProblems.Add(FString::Printf(TEXT("Duplicate row name '%s'."), *RowName.ToString()));
return false;
}
// Allocate data to store information, using UScriptStruct to know its size
uint8* RowData = (uint8*)FMemory::Malloc(DataTable->RowStruct->PropertiesSize);
DataTable->RowStruct->InitializeStruct(RowData);
// And be sure to call DestroyScriptStruct later
if (auto UDStruct = Cast<const UUserDefinedStruct>(DataTable->RowStruct))
{
UDStruct->InitializeDefaultValue(RowData);
}
// Add to row map
DataTable->RowMap.Add(RowName, RowData);
return ReadStruct(InParsedTableRowObject, DataTable->RowStruct, RowName, RowData);
}
FName FClassIconFinder::FindIconNameImpl(const UClass* InClass, const FName& InDefaultName, const TCHAR* StyleRoot )
{
FName BrushName;
const FSlateBrush* Brush = nullptr;
if ( InClass )
{
// walk up class hierarchy until we find an icon
const UClass* CurrentClass = InClass;
while( !Brush && CurrentClass )
{
BrushName = *FString::Printf( TEXT( "%s.%s" ), StyleRoot, *CurrentClass->GetName() );
Brush = FClassIconFinder::LookupBrush( BrushName );
CurrentClass = CurrentClass->GetSuperClass();
}
}
if( !Brush )
{
// If we didn't supply an override name for the default icon use default class icon.
if( InDefaultName.IsNone() )
{
BrushName = *FString::Printf( TEXT( "%s.Default" ), StyleRoot);
}
else
{
BrushName = InDefaultName;
}
}
return BrushName;
}
FTreeItemPtr FActorTreeItem::FindParent(const FTreeItemMap& ExistingItems) const
{
AActor* ActorPtr = Actor.Get();
if (!ActorPtr)
{
return nullptr;
}
// Parents should have already been added to the tree
AActor* ParentActor = ActorPtr->GetAttachParentActor();
if (ParentActor)
{
return ExistingItems.FindRef(ParentActor);
}
else
{
const bool bShouldShowFolders = SharedData->Mode == ESceneOutlinerMode::ActorBrowsing || SharedData->bOnlyShowFolders;
const FName ActorFolder = ActorPtr->GetFolderPath();
if (bShouldShowFolders && !ActorFolder.IsNone())
{
return ExistingItems.FindRef(ActorFolder);
}
}
if (UWorld* World = ActorPtr->GetWorld())
{
return ExistingItems.FindRef(World);
}
return nullptr;
}
FTreeItemPtr FActorTreeItem::CreateParent() const
{
AActor* ActorPtr = Actor.Get();
if (!ActorPtr)
{
return nullptr;
}
AActor* ParentActor = ActorPtr->GetAttachParentActor();
if (ParentActor)
{
return MakeShareable(new FActorTreeItem(ParentActor));
}
else
{
const bool bShouldShowFolders = SharedData->Mode == ESceneOutlinerMode::ActorBrowsing || SharedData->bOnlyShowFolders;
const FName ActorFolder = ActorPtr->GetFolderPath();
if (bShouldShowFolders && !ActorFolder.IsNone())
{
return MakeShareable(new FFolderTreeItem(ActorFolder));
}
}
if (UWorld* World = ActorPtr->GetWorld())
{
return MakeShareable(new FWorldTreeItem(World));
}
return nullptr;
}
FName FActorFolders::GetDefaultFolderName(UWorld& InWorld, FName ParentPath)
{
// This is potentially very slow but necessary to find a unique name
const auto& ExistingFolders = GetFolderPropertiesForWorld(InWorld);
// Create a valid base name for this folder
uint32 Suffix = 1;
FText LeafName = FText::Format(LOCTEXT("DefaultFolderNamePattern", "NewFolder{0}"), FText::AsNumber(Suffix++));
FString ParentFolderPath = ParentPath.IsNone() ? TEXT("") : ParentPath.ToString();
if (!ParentFolderPath.IsEmpty())
{
ParentFolderPath += "/";
}
FName FolderName(*(ParentFolderPath + LeafName.ToString()));
while (ExistingFolders.Contains(FolderName))
{
LeafName = FText::Format(LOCTEXT("DefaultFolderNamePattern", "NewFolder{0}"), FText::AsNumber(Suffix++));
FolderName = FName(*(ParentFolderPath + LeafName.ToString()));
if (Suffix == 0)
{
// We've wrapped around a 32bit unsigned int - something must be seriously wrong!
return FName();
}
}
return FolderName;
}
FName FClassIconFinder::FindIconNameForActor( const TWeakObjectPtr<AActor>& InActor )
{
// Actor specific overrides to normal per-class icons
AActor* Actor = InActor.Get();
FName BrushName = NAME_None;
if ( Actor )
{
ABrush* Brush = Cast< ABrush >( Actor );
if ( Brush )
{
if (Brush_Add == Brush->BrushType)
{
BrushName = TEXT( "ClassIcon.BrushAdditive" );
}
else if (Brush_Subtract == Brush->BrushType)
{
BrushName = TEXT( "ClassIcon.BrushSubtractive" );
}
}
// Actor didn't specify an icon - fallback on the class icon
if ( BrushName.IsNone() )
{
BrushName = FindIconNameForClass( Actor->GetClass() );
}
}
else
{
// If the actor reference is NULL it must have been deleted
BrushName = TEXT( "ClassIcon.Deleted" );
}
return BrushName;
}
void FName::AutoTest()
{
const FName AutoTest_1("AutoTest_1");
const FName autoTest_1("autoTest_1");
const FName autoTeSt_1("autoTeSt_1");
const FName AutoTest1Find("autoTEST_1", EFindName::FNAME_Find);
const FName AutoTest_2(TEXT("AutoTest_2"));
const FName AutoTestB_2(TEXT("AutoTestB_2"));
const FName NullName(static_cast<ANSICHAR*>(nullptr));
check(AutoTest_1 != AutoTest_2);
check(AutoTest_1 == autoTest_1);
check(AutoTest_1 == autoTeSt_1);
#if WITH_CASE_PRESERVING_NAME
check(!FCString::Strcmp(*AutoTest_1.ToString(), TEXT("AutoTest_1")));
check(!FCString::Strcmp(*autoTest_1.ToString(), TEXT("autoTest_1")));
check(!FCString::Strcmp(*autoTeSt_1.ToString(), TEXT("autoTeSt_1")));
check(!FCString::Strcmp(*AutoTestB_2.ToString(), TEXT("AutoTestB_2")));
#endif
check(autoTest_1.GetComparisonIndex() == AutoTest_2.GetComparisonIndex());
check(autoTest_1.GetPlainNameString() == AutoTest_1.GetPlainNameString());
check(autoTest_1.GetPlainNameString() == AutoTest_2.GetPlainNameString());
check(*AutoTestB_2.GetPlainNameString() != *AutoTest_2.GetPlainNameString());
check(AutoTestB_2.GetNumber() == AutoTest_2.GetNumber());
check(autoTest_1.GetNumber() != AutoTest_2.GetNumber());
check(NullName.IsNone());
}
void UGAAbilityBase::OnLatentTaskAdded(FName InstanceName, class UAFTaskBase* TaskIn)
{
if (!InstanceName.IsNone())
{
AbilityTasks.Add(InstanceName, TaskIn);
}
};
void UARAttributeBaseComponent::SetFloatValue(float InValue, FName AttributeName)
{
if (AttributeName.IsNone())
return;
UNumericProperty* NumericProperty = CastChecked<UNumericProperty>(GetAttribute(AttributeName));
void* pValue = NumericProperty->ContainerPtrToValuePtr<void>(this);
NumericProperty->SetFloatingPointPropertyValue(pValue, InValue);
}
void FNativeClassHierarchy::AddClass(UClass* InClass, const TSet<FName>& InGameModules, const TMap<FName, FName>& InPluginModules, FAddClassMetrics& AddClassMetrics)
{
// Ignore deprecated and temporary classes
if(InClass->HasAnyClassFlags(CLASS_Deprecated | CLASS_NewerVersionExists) || FKismetEditorUtilities::IsClassABlueprintSkeleton(InClass))
{
return;
}
const FName ClassModuleName = GetClassModuleName(InClass);
if(ClassModuleName.IsNone())
{
return;
}
static const FName ModuleRelativePathMetaDataKey = "ModuleRelativePath";
const FString& ClassModuleRelativeIncludePath = InClass->GetMetaData(ModuleRelativePathMetaDataKey);
if(ClassModuleRelativeIncludePath.IsEmpty())
{
return;
}
// Work out which root this class should go under
const FName RootNodeName = GetClassPathRootForModule(ClassModuleName, InGameModules, InPluginModules);
// Work out the final path to this class within the hierarchy (which isn't the same as the path on disk)
const FString ClassModuleRelativePath = ClassModuleRelativeIncludePath.Left(ClassModuleRelativeIncludePath.Find(TEXT("/"), ESearchCase::CaseSensitive, ESearchDir::FromEnd));
const FString ClassHierarchyPath = ClassModuleName.ToString() + TEXT("/") + ClassModuleRelativePath;
// Ensure we've added a valid root node
TSharedPtr<FNativeClassHierarchyNode>& RootNode = RootNodes.FindOrAdd(RootNodeName);
if(!RootNode.IsValid())
{
RootNode = FNativeClassHierarchyNode::MakeFolderEntry(RootNodeName, TEXT("/") + RootNodeName.ToString());
++AddClassMetrics.NumFoldersAdded;
}
// Split the class path and ensure we have nodes for each part
TArray<FString> HierarchyPathParts;
ClassHierarchyPath.ParseIntoArray(HierarchyPathParts, TEXT("/"), true);
TSharedPtr<FNativeClassHierarchyNode> CurrentNode = RootNode;
for(const FString& HierarchyPathPart : HierarchyPathParts)
{
const FName HierarchyPathPartName = *HierarchyPathPart;
TSharedPtr<FNativeClassHierarchyNode>& ChildNode = CurrentNode->Children.FindOrAdd(FNativeClassHierarchyNodeKey(HierarchyPathPartName, ENativeClassHierarchyNodeType::Folder));
if(!ChildNode.IsValid())
{
ChildNode = FNativeClassHierarchyNode::MakeFolderEntry(HierarchyPathPartName, CurrentNode->EntryPath + TEXT("/") + HierarchyPathPart);
++AddClassMetrics.NumFoldersAdded;
}
CurrentNode = ChildNode;
}
// Now add the final entry for the class
CurrentNode->AddChild(FNativeClassHierarchyNode::MakeClassEntry(InClass, ClassModuleName, ClassModuleRelativePath, CurrentNode->EntryPath + TEXT("/") + InClass->GetName()));
++AddClassMetrics.NumClassesAdded;
}
void
CreatureCore::SetBluePrintRegionAlpha(FName region_name_in, uint8 alpha_in)
{
if (region_name_in.IsNone())
{
return;
}
region_alpha_map.Add(region_name_in, alpha_in);
}
int32 UARAttributeBaseComponent::GetIntValue(FName AttributeName)
{
if (AttributeName.IsNone())
return 0;
UIntProperty* intProperty = CastChecked<UIntProperty>(GetAttribute(AttributeName));
//UNumericProperty* NumericProperty = CastChecked<UNumericProperty>(GetAttribute(AttributeName));
void* pValue = intProperty->ContainerPtrToValuePtr<void>(this);
return intProperty->GetUnsignedIntPropertyValue(pValue);
}
void URPGAttributeComponent::SetNumericValue(float value, FName AttributeName)
{
if (!AttributeName.IsNone())
{
UNumericProperty* NumericProperty = CastChecked<UNumericProperty>(GetAttribute(AttributeName, this->GetClass()));
void* ValuePtr = NumericProperty->ContainerPtrToValuePtr<void>(this);
NumericProperty->SetFloatingPointPropertyValue(ValuePtr, value);
OnAttributeChange.Broadcast(AttributeName, value);
}
}
float URPGAttributeComponent::GetNumericValue(FName AttributeName)
{
if (!AttributeName.IsNone())
{
UNumericProperty* NumericProperty = CastChecked<UNumericProperty>(GetAttribute(AttributeName, this->GetClass()));
void* ValuePtr = NumericProperty->ContainerPtrToValuePtr<void>(this);
float tempVal = 0;
tempVal = NumericProperty->GetFloatingPointPropertyValue(ValuePtr);
return tempVal;
}
return 0;
}
bool FDataTableImporterJSON::ReadRow(const TSharedRef<FJsonObject>& ParsedTableRowObject, const int32 RowIdx)
{
// Get row name
FName RowName = DataTableUtils::MakeValidName(ParsedTableRowObject->GetStringField(TEXT("Name")));
// Check its not 'none'
if (RowName.IsNone())
{
ImportProblems.Add(FString::Printf(TEXT("Row '%d' missing a name."), RowIdx));
return false;
}
// Check its not a duplicate
if (DataTable->RowMap.Find(RowName) != nullptr)
{
ImportProblems.Add(FString::Printf(TEXT("Duplicate row name '%s'."), *RowName.ToString()));
return false;
}
// Allocate data to store information, using UScriptStruct to know its size
uint8* RowData = (uint8*)FMemory::Malloc(DataTable->RowStruct->PropertiesSize);
DataTable->RowStruct->InitializeStruct(RowData);
// And be sure to call DestroyScriptStruct later
if (auto UDStruct = Cast<const UUserDefinedStruct>(DataTable->RowStruct))
{
UDStruct->InitializeDefaultValue(RowData);
}
// Add to row map
DataTable->RowMap.Add(RowName, RowData);
// Now read in each property
for (TFieldIterator<UProperty> It(DataTable->RowStruct); It; ++It)
{
UProperty* BaseProp = *It;
check(BaseProp);
const FString PropertyName = BaseProp->GetName();
TSharedPtr<FJsonValue> ParsedPropertyValue = ParsedTableRowObject->TryGetField(PropertyName);
if (!ParsedPropertyValue.IsValid())
{
ImportProblems.Add(FString::Printf(TEXT("Row '%s' is missing an entry for '%s'."), *RowName.ToString(), *PropertyName));
continue;
}
void* Data = BaseProp->ContainerPtrToValuePtr<void>(RowData, 0);
ReadStructEntry(ParsedPropertyValue.ToSharedRef(), RowName, RowData, BaseProp, Data);
}
return true;
}
void USceneCaptureComponent::PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent)
{
Super::PostEditChangeProperty(PropertyChangedEvent);
const FName Name = (PropertyChangedEvent.Property != nullptr) ? PropertyChangedEvent.Property->GetFName() : NAME_None;
const FName MemberPropertyName = (PropertyChangedEvent.MemberProperty != NULL) ? PropertyChangedEvent.MemberProperty->GetFName() : NAME_None;
// If our ShowFlagSetting UStruct changed, (or if PostEditChange was called without specifying a property) update the actual show flags
if (MemberPropertyName.IsEqual("ShowFlagSettings") || MemberPropertyName.IsNone())
{
UpdateShowFlags();
}
}
void USignificanceManager::OnShowDebugInfo(AHUD* HUD, UCanvas* Canvas, const FDebugDisplayInfo& DisplayInfo, float& YL, float& YPos)
{
static const FName NAME_SignificanceManager("SignificanceManager");
if (Canvas && HUD->ShouldDisplayDebug(NAME_SignificanceManager))
{
if (HasAnyFlags(RF_ClassDefaultObject))
{
if (USignificanceManager* SignificanceManager = Get(HUD->GetWorld()))
{
SignificanceManager->OnShowDebugInfo(HUD, Canvas, DisplayInfo, YL, YPos);
}
}
else
{
FDisplayDebugManager& DisplayDebugManager = Canvas->DisplayDebugManager;
DisplayDebugManager.SetFont(GEngine->GetSmallFont());
DisplayDebugManager.SetDrawColor(FColor::Red);
DisplayDebugManager.DrawString(FString::Printf(TEXT("SIGNIFICANCE MANAGER - %d Managed Objects"), ManagedObjects.Num()));
const FName SignificanceManagerTag(*CVarSignificanceManagerFilterTag->GetString());
TArray<const FManagedObjectInfo*> AllObjects;
const TArray<const FManagedObjectInfo*>& ObjectsToShow = (SignificanceManagerTag.IsNone() ? AllObjects : GetManagedObjects(SignificanceManagerTag));
if (SignificanceManagerTag.IsNone())
{
GetManagedObjects(AllObjects, true);
}
DisplayDebugManager.SetDrawColor(FColor::White);
const int32 NumObjectsToShow = FMath::Min(GSignificanceManagerObjectsToShow, ObjectsToShow.Num());
for (int32 Index = 0; Index < NumObjectsToShow; ++Index)
{
const FManagedObjectInfo* ObjectInfo = ObjectsToShow[Index];
const FString Str = FString::Printf(TEXT("%6.3f - %s (%s)"), ObjectInfo->GetSignificance(), *ObjectInfo->GetObject()->GetName(), *ObjectInfo->GetTag().ToString());
DisplayDebugManager.DrawString(Str);
}
}
}
}
FName GetOnlineIdentifier(UWorld* World, const FName Subsystem = NAME_None) override
{
#if WITH_EDITOR
if (const FWorldContext* WorldContext = GEngine->GetWorldContextFromWorld(World))
{
return FName(
*FString::Printf(TEXT("%s:%s"), !Subsystem.IsNone() ? *Subsystem.ToString() : TEXT(""), *WorldContext->ContextHandle.ToString()));
}
return NAME_None;
#else
return Subsystem;
#endif
}
bool FActorFolders::AddFolderToWorld(UWorld& InWorld, FName Path)
{
if (!Path.IsNone())
{
UEditorActorFolders& Folders = GetOrCreateFoldersForWorld(InWorld);
if (!Folders.Folders.Contains(Path))
{
// Add the parent as well
const FName ParentPath(*FPaths::GetPath(Path.ToString()));
if (!ParentPath.IsNone())
{
AddFolderToWorld(InWorld, ParentPath);
}
Folders.Modify();
Folders.Folders.Add(Path);
return true;
}
}
return false;
}
// ソケットのTransformを取得
FTransform USsPlayerComponent::GetSocketTransform(FName InSocketName, ERelativeTransformSpace TransformSpace) const
{
if(InSocketName.IsNone())
{
return Super::GetSocketTransform(InSocketName, TransformSpace);
}
if(RenderMode != ESsPlayerComponentRenderMode::OffScreenOnly)
{
int32 PartIndex = Player.GetPartIndexFromName(InSocketName);
FTransform Trans;
if(GetPartAttachTransform(PartIndex, Trans))
{
switch(TransformSpace)
{
case ERelativeTransformSpace::RTS_World:
{
return Trans * GetComponentTransform();
} break;
case ERelativeTransformSpace::RTS_Actor:
{
AActor* Actor = GetOwner();
return (NULL == Actor) ? Trans : (GetComponentTransform() * Trans).GetRelativeTransform(Actor->GetTransform());
} break;
case ERelativeTransformSpace::RTS_Component:
{
return Trans;
} break;
}
}
}
if(RenderMode == ESsPlayerComponentRenderMode::OffScreenOnly)
{
UE_LOG(LogSpriteStudio, Warning, TEXT("SsPlayerComponent::GetSocketTransform() Can't Attach. RenderMode is OffScreenOnly"), *(InSocketName.ToString()));
}
else
{
UE_LOG(LogSpriteStudio, Warning, TEXT("SsPlayerComponent::GetSocketTransform() Invalid Socket Name (%s)"), *(InSocketName.ToString()));
}
return Super::GetSocketTransform(InSocketName, TransformSpace);
}
FName FActorFolders::GetDefaultFolderNameForSelection(UWorld& InWorld)
{
// Find a common parent folder, or put it at the root
FName CommonParentFolder;
for( FSelectionIterator SelectionIt( *GEditor->GetSelectedActors() ); SelectionIt; ++SelectionIt )
{
AActor* Actor = CastChecked<AActor>(*SelectionIt);
if (CommonParentFolder.IsNone())
{
CommonParentFolder = Actor->GetFolderPath();
}
else if (Actor->GetFolderPath() != CommonParentFolder)
{
CommonParentFolder = NAME_None;
break;
}
}
return GetDefaultFolderName(InWorld, CommonParentFolder);
}
TSharedPtr<const FCompositeFont> FLegacySlateFontInfoCache::GetCompositeFont(const FName& InLegacyFontName, const EFontHinting InLegacyFontHinting)
{
if (InLegacyFontName.IsNone())
{
return nullptr;
}
FString LegacyFontPath = InLegacyFontName.ToString();
// Work out what the given path is supposed to be relative to
if (!FPaths::FileExists(LegacyFontPath))
{
// UMG assets specify the path either relative to the game or engine content directories - test both
LegacyFontPath = FPaths::GameContentDir() / InLegacyFontName.ToString();
if (!FPaths::FileExists(LegacyFontPath))
{
LegacyFontPath = FPaths::EngineContentDir() / InLegacyFontName.ToString();
if (!FPaths::FileExists(LegacyFontPath))
{
// Missing font file - just use what we were given
LegacyFontPath = InLegacyFontName.ToString();
}
}
}
const FLegacyFontKey LegacyFontKey(*LegacyFontPath, InLegacyFontHinting);
{
TSharedPtr<const FCompositeFont>* const ExistingCompositeFont = LegacyFontNameToCompositeFont.Find(LegacyFontKey);
if(ExistingCompositeFont)
{
return *ExistingCompositeFont;
}
}
UFontBulkData* FontBulkData = NewObject<UFontBulkData>();
FontBulkData->Initialize(LegacyFontPath);
TSharedRef<const FCompositeFont> NewCompositeFont = MakeShareable(new FStandaloneCompositeFont(NAME_None, LegacyFontPath, FontBulkData, InLegacyFontHinting));
LegacyFontNameToCompositeFont.Add(LegacyFontKey, NewCompositeFont);
return NewCompositeFont;
}
bool FNativeClassHierarchy::GetClassPath(UClass* InClass, FString& OutClassPath, const bool bIncludeClassName) const
{
const FName ClassModuleName = GetClassModuleName(InClass);
if(ClassModuleName.IsNone())
{
return false;
}
static const FName ModuleRelativePathMetaDataKey = "ModuleRelativePath";
const FString& ClassModuleRelativeIncludePath = InClass->GetMetaData(ModuleRelativePathMetaDataKey);
if(ClassModuleRelativeIncludePath.IsEmpty())
{
return false;
}
TSet<FName> GameModules = GetGameModules();
TMap<FName, FName> PluginModules = GetPluginModules();
// Work out which root this class should go under
const FName RootNodeName = GetClassPathRootForModule(ClassModuleName, GameModules, PluginModules);
// Work out the final path to this class within the hierarchy (which isn't the same as the path on disk)
const FString ClassModuleRelativePath = ClassModuleRelativeIncludePath.Left(ClassModuleRelativeIncludePath.Find(TEXT("/"), ESearchCase::CaseSensitive, ESearchDir::FromEnd));
OutClassPath = FString(TEXT("/")) + RootNodeName.ToString() + TEXT("/") + ClassModuleName.ToString();
if(!ClassModuleRelativePath.IsEmpty())
{
OutClassPath += TEXT("/") + ClassModuleRelativePath;
}
if(bIncludeClassName)
{
OutClassPath += TEXT("/") + InClass->GetName();
}
return true;
}
bool FActorFolders::RenameFolderInWorld(UWorld& World, FName OldPath, FName NewPath)
{
if (OldPath.IsNone() || OldPath == NewPath || PathIsChildOf(NewPath.ToString(), OldPath.ToString()))
{
return false;
}
const FScopedTransaction Transaction(LOCTEXT("UndoAction_RenameFolder", "Rename Folder"));
const FString OldPathString = OldPath.ToString();
const FString NewPathString = NewPath.ToString();
TSet<FName> RenamedFolders;
// Move any folders we currently hold - old ones will be deleted later
UEditorActorFolders& FoldersInWorld = GetOrCreateFoldersForWorld(World);
FoldersInWorld.Modify();
auto ExistingFoldersCopy = FoldersInWorld.Folders;
for (const auto& Pair : ExistingFoldersCopy)
{
auto Path = Pair.Key;
const FString FolderPath = Path.ToString();
if (OldPath == Path || PathIsChildOf(FolderPath, OldPathString))
{
const FName NewFolder = OldPathToNewPath(OldPathString, NewPathString, FolderPath);
if (!FoldersInWorld.Folders.Contains(NewFolder))
{
// Use the existing properties for the folder if we have them
if (FActorFolderProps* ExistingProperties = FoldersInWorld.Folders.Find(Path))
{
FoldersInWorld.Folders.Add(NewFolder, *ExistingProperties);
}
else
{
// Otherwise use default properties
FoldersInWorld.Folders.Add(NewFolder);
}
OnFolderMove.Broadcast(World, Path, NewFolder);
OnFolderCreate.Broadcast(World, NewFolder);
}
RenamedFolders.Add(Path);
}
}
// Now that we have folders created, move any actors that ultimately reside in that folder too
for (auto ActorIt = FActorIterator(&World); ActorIt; ++ActorIt)
{
const FName& OldActorPath = ActorIt->GetFolderPath();
AActor* Actor = *ActorIt;
if (OldActorPath.IsNone())
{
continue;
}
if (Actor->GetFolderPath() == OldPath || PathIsChildOf(OldActorPath.ToString(), OldPathString))
{
RenamedFolders.Add(OldActorPath);
ActorIt->SetFolderPath_Recursively(OldPathToNewPath(OldPathString, NewPathString, OldActorPath.ToString()));
}
}
// Cleanup any old folders
for (const auto& Path : RenamedFolders)
{
FoldersInWorld.Folders.Remove(Path);
OnFolderDelete.Broadcast(World, Path);
}
return RenamedFolders.Num() != 0;
}
AActor* UWorld::SpawnActor( UClass* Class, FTransform const* Transform, const FActorSpawnParameters& SpawnParameters )
{
SCOPE_CYCLE_COUNTER(STAT_SpawnActorTime);
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( 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 (Transform && Transform->ContainsNaN())
{
UE_LOG(LogSpawn, Warning, TEXT("SpawnActor failed because the given transform (%s) is invalid"), *Transform->ToString());
return NULL;
}
ULevel* LevelToSpawnIn = SpawnParameters.OverrideLevel;
if (LevelToSpawnIn == NULL)
{
// Spawn in the same level as the owner if we have one. @warning: this relies on the outer of an actor being the level.
LevelToSpawnIn = (SpawnParameters.Owner != NULL) ? CastChecked<ULevel>(SpawnParameters.Owner->GetOuter()) : CurrentLevel;
}
FName NewActorName = SpawnParameters.Name;
AActor* Template = SpawnParameters.Template;
// Use class's default actor as a template.
if( !Template )
{
Template = Class->GetDefaultObject<AActor>();
}
else if (NewActorName.IsNone() && !Template->HasAnyFlags(RF_ClassDefaultObject))
{
NewActorName = MakeUniqueObjectName(LevelToSpawnIn, Template->GetClass(), *Template->GetFName().GetPlainNameString());
}
check(Template!=NULL);
// 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;
}
FVector NewLocation = Transform ? Transform->GetLocation() : (Template->GetRootComponent() ? Template->GetRootComponent()->RelativeLocation : FVector::ZeroVector);
FRotator NewRotation = Transform ? Transform->GetRotation().Rotator() : (Template->GetRootComponent() ? Template->GetRootComponent()->RelativeRotation : FRotator::ZeroRotator);
FVector NewScale = Transform ? Transform->GetScale3D() : (Template->GetRootComponent() ? Template->GetRootComponent()->RelativeScale3D : FVector(1.f) );
PRAGMA_DISABLE_DEPRECATION_WARNINGS;
// handle existing (but deprecated) uses of bNoCollisionFail where user set it to true
ESpawnActorCollisionHandlingMethod CollisionHandlingOverride = SpawnParameters.SpawnCollisionHandlingOverride;
if ((CollisionHandlingOverride == ESpawnActorCollisionHandlingMethod::Undefined) && SpawnParameters.bNoCollisionFail)
{
CollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
}
PRAGMA_ENABLE_DEPRECATION_WARNINGS;
// "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)
{
if (EncroachingBlockingGeometry(Template, NewLocation, NewRotation))
{
// a native component is colliding, that's enough to reject spawning
UE_LOG(LogSpawn, Warning, TEXT("SpawnActor failed because of collision at the spawn location [%s] for [%s]"), *NewLocation.ToString(), *Class->GetName());
return nullptr;
}
}
// actually make the actor object
AActor* const Actor = NewObject<AActor>(LevelToSpawnIn, Class, NewActorName, SpawnParameters.ObjectFlags, Template);
check(Actor);
#if WITH_EDITOR
Actor->ClearActorLabel(); // Clear label on newly spawned actors
#endif // WITH_EDITOR
if ( GUndo )
{
ModifyLevel( LevelToSpawnIn );
}
LevelToSpawnIn->Actors.Add( Actor );
// Add this newly spawned actor to the network actor list
AddNetworkActor( 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;
Actor->PostSpawnInitialize(FTransform(NewRotation, NewLocation, NewScale), SpawnParameters.Owner, SpawnParameters.Instigator, SpawnParameters.bRemoteOwned, SpawnParameters.bNoFail, SpawnParameters.bDeferConstruction);
if (Actor->IsPendingKill() && !SpawnParameters.bNoFail)
{
UE_LOG(LogSpawn, Warning, TEXT("SpawnActor failed because the spawned actor IsPendingKill"));
return NULL;
}
//
// // actor should have all of its components now, do any collision checking and handling that we need to do
// switch (CollisionHandlingMethod)
// {
// case ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButAlwaysSpawn:
// // Try to find a spawn position
// {
// FVector AdjustedLocation = NewLocation;
// FRotator AdjustedRotation = NewRotation;
// if (FindTeleportSpot(Actor, AdjustedLocation, AdjustedRotation))
// {
// Actor->SetActorLocationAndRotation(AdjustedLocation, AdjustedRotation);
// }
// }
// break;
// case ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButDontSpawnIfColliding:
// // Try to find a spawn position
// {
// FVector AdjustedLocation = NewLocation;
// FRotator AdjustedRotation = NewRotation;
// if (FindTeleportSpot(Actor, AdjustedLocation, AdjustedRotation))
// {
// Actor->SetActorLocationAndRotation(AdjustedLocation, AdjustedRotation);
// }
// else
// {
// UE_LOG(LogSpawn, Warning, TEXT("SpawnActor failed because of collision at the spawn location [%s] for [%s]"), *NewLocation.ToString(), *Class->GetName());
// DestroyActor(Actor);
// return nullptr;
// }
// }
// break;
// case ESpawnActorCollisionHandlingMethod::DontSpawnIfColliding:
// // #todo: don't recheck components checked above?
// if (EncroachingBlockingGeometry(Actor, NewLocation, NewRotation))
// {
// UE_LOG(LogSpawn, Warning, TEXT("SpawnActor failed because of collision at the spawn location [%s] for [%s]"), *NewLocation.ToString(), *Class->GetName());
// DestroyActor(Actor);
// return nullptr;
// }
// break;
// // note we use "always spawn" as default, so treat undefined as that
// case ESpawnActorCollisionHandlingMethod::Undefined:
// case ESpawnActorCollisionHandlingMethod::AlwaysSpawn:
// default:
// // nothing to do, just proceed as normal
// break;
// }
Actor->CheckDefaultSubobjects();
// Broadcast notification of spawn
OnActorSpawned.Broadcast(Actor);
#if WITH_EDITOR
if (GIsEditor)
{
GEngine->BroadcastLevelActorAdded(Actor);
}
#endif
return Actor;
}
/**
* Construct this widget. Called by the SNew() Slate macro.
*
* @param InArgs Declaration used by the SNew() macro to construct this widget
* @param Factory The factory this menu entry represents
*/
void Construct( const FArguments& InArgs, UFactory* Factory )
{
const FName ClassThumbnailBrushOverride = Factory->GetNewAssetThumbnailOverride();
const FSlateBrush* ClassThumbnail = nullptr;
if (ClassThumbnailBrushOverride.IsNone())
{
ClassThumbnail = FClassIconFinder::FindThumbnailForClass(Factory->GetSupportedClass());
}
else
{
// Instead of getting the override thumbnail directly from the editor style here get it from the
// ClassIconFinder since it may have additional styles registered which can be searched by passing
// it as a default with no class to search for.
ClassThumbnail = FClassIconFinder::FindThumbnailForClass(nullptr, ClassThumbnailBrushOverride);
}
FAssetToolsModule& AssetToolsModule = FAssetToolsModule::GetModule();
TWeakPtr<IAssetTypeActions> AssetTypeActions = AssetToolsModule.Get().GetAssetTypeActionsForClass(Factory->GetSupportedClass());
FLinearColor AssetColor = FLinearColor::White;
if ( AssetTypeActions.IsValid() )
{
AssetColor = AssetTypeActions.Pin()->GetTypeColor();
}
ChildSlot
[
SNew( SHorizontalBox )
+SHorizontalBox::Slot()
.Padding( 4, 0, 0, 0 )
.VAlign(VAlign_Center)
.AutoWidth()
[
SNew( SOverlay )
+SOverlay::Slot()
[
SNew( SBox )
.WidthOverride( InArgs._Width + 4 )
.HeightOverride( InArgs._Height + 4 )
[
SNew( SBorder )
.BorderImage( FEditorStyle::GetBrush("AssetThumbnail.AssetBackground") )
.BorderBackgroundColor(AssetColor.CopyWithNewOpacity(0.3f))
.Padding( 2.0f )
.VAlign( VAlign_Center )
.HAlign( HAlign_Center )
[
SNew( SImage )
.Image( ClassThumbnail )
]
]
]
+SOverlay::Slot()
.HAlign(HAlign_Fill)
.VAlign(VAlign_Bottom)
[
SNew( SBorder )
.BorderImage( FEditorStyle::GetBrush("WhiteBrush") )
.BorderBackgroundColor( AssetColor )
.Padding( FMargin(0, FMath::Max(FMath::CeilToFloat(InArgs._Width*0.025f), 3.0f), 0, 0) )
]
]
+SHorizontalBox::Slot()
.VAlign(VAlign_Center)
.Padding(4, 0, 4, 0)
[
SNew( SVerticalBox )
+SVerticalBox::Slot()
.Padding(0, 0, 0, 1)
.AutoHeight()
[
SNew(STextBlock)
.Font( FEditorStyle::GetFontStyle("LevelViewportContextMenu.AssetLabel.Text.Font") )
.Text( Factory->GetDisplayName() )
]
]
];
SetToolTip(IDocumentation::Get()->CreateToolTip(Factory->GetToolTip(), nullptr, Factory->GetToolTipDocumentationPage(), Factory->GetToolTipDocumentationExcerpt()));
}
virtual bool FixupObject(const FName& InObjectPath, FName& OutNewObjectPath) override
{
OutNewObjectPath = NAME_None;
if (InObjectPath.ToString().StartsWith(TEXT("/Script/")))
{
// We can't use FindObject while we're saving
if (!GIsSavingPackage)
{
const FString ClassPathStr = InObjectPath.ToString();
UClass* FoundClass = FindObject<UClass>(ANY_PACKAGE, *ClassPathStr);
if (!FoundClass)
{
// Use the linker to search for class name redirects (from the loaded ActiveClassRedirects)
const FString ClassName = FPackageName::ObjectPathToObjectName(ClassPathStr);
const FName NewClassName = FLinkerLoad::FindNewNameForClass(*ClassName, false);
if (!NewClassName.IsNone())
{
// Our new class name might be lacking the path, so try and find it so we can use the full path in the collection
FoundClass = FindObject<UClass>(ANY_PACKAGE, *NewClassName.ToString());
if (FoundClass)
{
OutNewObjectPath = *FoundClass->GetPathName();
}
}
}
}
}
else
{
// Keep track of visted redirectors in case we loop.
TSet<FName> VisitedRedirectors;
// Use the asset registry to avoid loading the object
FAssetData ObjectAssetData = AssetRegistryModule.Get().GetAssetByObjectPath(InObjectPath);
while (ObjectAssetData.IsValid() && ObjectAssetData.IsRedirector())
{
// Check to see if we've already seen this path before, it's possible we might have found a redirector loop.
if ( VisitedRedirectors.Contains(ObjectAssetData.ObjectPath) )
{
UE_LOG(LogContentBrowser, Error, TEXT("Redirector Loop Found!"));
for ( FName Redirector : VisitedRedirectors )
{
UE_LOG(LogContentBrowser, Error, TEXT("Redirector: %s"), *Redirector.ToString());
}
ObjectAssetData = FAssetData();
break;
}
VisitedRedirectors.Add(ObjectAssetData.ObjectPath);
// Get the destination object from the meta-data rather than load the redirector object, as
// loading a redirector will also load the object it points to, which could cause a large hitch
FString DestinationObjectPath;
if (ObjectAssetData.GetTagValue("DestinationObject", DestinationObjectPath))
{
ConstructorHelpers::StripObjectClass(DestinationObjectPath);
ObjectAssetData = AssetRegistryModule.Get().GetAssetByObjectPath(*DestinationObjectPath);
}
else
{
ObjectAssetData = FAssetData();
}
}
OutNewObjectPath = ObjectAssetData.ObjectPath;
}
return OutNewObjectPath != NAME_None && InObjectPath != OutNewObjectPath;
}
