void UGatherTextFromAssetsCommandlet::ProcessPackages( const TArray< UPackage* >& PackagesToProcess )
{
for( int32 i = 0; i < PackagesToProcess.Num(); ++i )
{
UPackage* Package = PackagesToProcess[i];
TArray<UObject*> Objects;
GetObjectsWithOuter(Package, Objects);
for( int32 j = 0; j < Objects.Num(); ++j )
{
UObject* Object = Objects[j];
if ( Object->IsA( UBlueprint::StaticClass() ) )
{
UBlueprint* Blueprint = Cast<UBlueprint>( Object );
if( Blueprint->GeneratedClass != NULL )
{
ProcessObject( Blueprint->GeneratedClass->GetDefaultObject(), Package );
}
else
{
UE_LOG(LogGatherTextFromAssetsCommandlet, Warning, TEXT("%s - Invalid generated class!"), *Blueprint->GetFullName());
}
}
else if( Object->IsA( UDialogueWave::StaticClass() ) )
{
UDialogueWave* DialogueWave = Cast<UDialogueWave>( Object );
ProcessDialogueWave( DialogueWave );
}
ProcessObject( Object, Package );
}
}
}
void FNativeClassHierarchy::AddClassesForModule(const FName& InModuleName)
{
FAddClassMetrics AddClassMetrics;
// Find the class package for this module
UPackage* const ClassPackage = FindPackage(nullptr, *(FString("/Script/") + InModuleName.ToString()));
if(!ClassPackage)
{
return;
}
TSet<FName> GameModules = GetGameModules();
TMap<FName, FName> PluginModules = GetPluginModules();
TArray<UObject*> PackageObjects;
GetObjectsWithOuter(ClassPackage, PackageObjects, false);
for(UObject* Object : PackageObjects)
{
UClass* const CurrentClass = Cast<UClass>(Object);
if(CurrentClass)
{
AddClass(CurrentClass, GameModules, PluginModules, AddClassMetrics);
}
}
UE_LOG(LogContentBrowser, Log, TEXT("Native class hierarchy updated for '%s' in %0.4f seconds. Added %d classes and %d folders."), *InModuleName.ToString(), FPlatformTime::Seconds() - AddClassMetrics.StartTime, AddClassMetrics.NumClassesAdded, AddClassMetrics.NumFoldersAdded);
ClassHierarchyUpdatedDelegate.Broadcast();
}
void FAssetFixUpRedirectors::DeleteRedirectors(TArray<FRedirectorRefs>& RedirectorsToFix) const
{
TArray<UObject*> ObjectsToDelete;
for ( auto RedirectorIt = RedirectorsToFix.CreateIterator(); RedirectorIt; ++RedirectorIt )
{
FRedirectorRefs& RedirectorRefs = *RedirectorIt;
if ( RedirectorRefs.bRedirectorValidForFixup )
{
// Add all redirectors found in this package to the redirectors to delete list.
// All redirectors in this package should be fixed up.
UPackage* RedirectorPackage = RedirectorRefs.Redirector->GetOutermost();
TArray<UObject*> AssetsInRedirectorPackage;
GetObjectsWithOuter(RedirectorPackage, AssetsInRedirectorPackage, /*bIncludeNestedObjects=*/false);
UMetaData* PackageMetaData = NULL;
bool bContainsAtLeastOneOtherAsset = false;
for ( auto ObjIt = AssetsInRedirectorPackage.CreateConstIterator(); ObjIt; ++ObjIt )
{
if ( UObjectRedirector* Redirector = Cast<UObjectRedirector>(*ObjIt) )
{
Redirector->RemoveFromRoot();
ObjectsToDelete.Add(Redirector);
}
else if ( UMetaData* MetaData = Cast<UMetaData>(*ObjIt) )
{
PackageMetaData = MetaData;
}
else
{
bContainsAtLeastOneOtherAsset = true;
}
}
if ( !bContainsAtLeastOneOtherAsset )
{
RedirectorPackage->RemoveFromRoot();
ULinkerLoad* Linker = ULinkerLoad::FindExistingLinkerForPackage(RedirectorPackage);
if ( Linker )
{
Linker->RemoveFromRoot();
}
// @todo we shouldnt be worrying about metadata objects here, ObjectTools::CleanUpAfterSuccessfulDelete should
if ( PackageMetaData )
{
PackageMetaData->RemoveFromRoot();
ObjectsToDelete.Add(PackageMetaData);
}
}
// This redirector will be deleted, NULL the reference here
RedirectorRefs.Redirector = NULL;
}
}
if ( ObjectsToDelete.Num() > 0 )
{
ObjectTools::DeleteObjects(ObjectsToDelete);
}
}
int32 UObjectLibrary::LoadAssetsFromAssetData()
{
int32 Count = 0;
if (bIsFullyLoaded)
{
// We already ran this
return 0;
}
bIsFullyLoaded = true;
for(int32 AssetIdx=0; AssetIdx<AssetDataList.Num(); AssetIdx++)
{
FAssetData& Data = AssetDataList[AssetIdx];
UObject *LoadedObject = NULL;
if (!bHasBlueprintClasses)
{
LoadedObject = Data.GetAsset();
checkSlow(!LoadedObject || !ObjectBaseClass || LoadedObject->IsA(ObjectBaseClass));
}
else
{
UPackage* Package = Data.GetPackage();
if (Package)
{
TArray<UObject*> ObjectsInPackage;
GetObjectsWithOuter(Package, ObjectsInPackage);
for (UObject* PotentialBPGC : ObjectsInPackage)
{
if (auto LoadedBPGC = Cast<UBlueprintGeneratedClass>(PotentialBPGC))
{
checkSlow(!ObjectBaseClass || LoadedBPGC->IsChildOf(ObjectBaseClass));
LoadedObject = LoadedBPGC;
break; //there is usually only one BGPC in a package
}
}
}
}
if (LoadedObject)
{
AddObject(LoadedObject);
Count++;
}
}
return Count;
}
void UActorComponent::PostEditUndo()
{
// Objects marked pending kill don't call PostEditChange() from UObject::PostEditUndo(),
// so they can leave an EditReregisterContexts entry around if they are deleted by an undo action.
if( IsPendingKill() )
{
// The reregister context won't bother attaching components that are 'pending kill'.
FComponentReregisterContext* ReregisterContext = EditReregisterContexts.FindRef(this);
if(ReregisterContext)
{
delete ReregisterContext;
EditReregisterContexts.Remove(this);
}
}
else
{
Owner = GetTypedOuter<AActor>();
bCanUseCachedOwner = true;
// Let the component be properly registered, after it was restored.
if (Owner)
{
Owner->AddOwnedComponent(this);
}
TArray<UObject*> Children;
GetObjectsWithOuter(this, Children);
for (UObject* Child : Children)
{
if (UActorComponent* ChildComponent = Cast<UActorComponent>(Child))
{
if (ChildComponent->Owner)
{
ChildComponent->Owner->RemoveOwnedComponent(ChildComponent);
}
ChildComponent->Owner = Owner;
if (Owner)
{
Owner->AddOwnedComponent(ChildComponent);
}
}
}
if (GetWorld())
{
GetWorld()->UpdateActorComponentEndOfFrameUpdateState(this);
}
}
Super::PostEditUndo();
}
void USimpleConstructionScript::GenerateListOfExistingNames(TArray<FName>& CurrentNames) const
{
TArray<const USCS_Node*> ChildrenNodes = GetAllNodesConst();
const UBlueprintGeneratedClass* OwnerClass = Cast<const UBlueprintGeneratedClass>(GetOuter());
const UBlueprint* Blueprint = Cast<const UBlueprint>(OwnerClass ? OwnerClass->ClassGeneratedBy : NULL);
// >>> Backwards Compatibility: VER_UE4_EDITORONLY_BLUEPRINTS
if (!Blueprint)
{
Blueprint = Cast<UBlueprint>(GetOuter());
}
// <<< End Backwards Compatibility
check(Blueprint);
TArray<UObject*> NativeCDOChildren;
UClass* FirstNativeClass = FBlueprintEditorUtils::FindFirstNativeClass(Blueprint->ParentClass);
GetObjectsWithOuter(FirstNativeClass->GetDefaultObject(), NativeCDOChildren, false);
for (UObject* NativeCDOChild : NativeCDOChildren)
{
CurrentNames.Add(NativeCDOChild->GetFName());
}
if (Blueprint->SkeletonGeneratedClass)
{
// First add the class variables.
FBlueprintEditorUtils::GetClassVariableList(Blueprint, CurrentNames, true);
// Then the function names.
FBlueprintEditorUtils::GetFunctionNameList(Blueprint, CurrentNames);
}
// And add their names
for (int32 NodeIndex = 0; NodeIndex < ChildrenNodes.Num(); ++NodeIndex)
{
const USCS_Node* ChildNode = ChildrenNodes[NodeIndex];
if (ChildNode)
{
if (ChildNode->VariableName != NAME_None)
{
CurrentNames.Add(ChildNode->VariableName);
}
}
}
if (GetDefaultSceneRootNode())
{
CurrentNames.AddUnique(GetDefaultSceneRootNode()->GetVariableName());
}
}
void FAssetDeleteModel::PrepareToDelete(UObject* InObject)
{
if ( InObject->IsA<UObjectRedirector>() )
{
// Add all redirectors found in this package to the redirectors to delete list.
// All redirectors in this package should be fixed up.
UPackage* RedirectorPackage = InObject->GetOutermost();
TArray<UObject*> AssetsInRedirectorPackage;
GetObjectsWithOuter(RedirectorPackage, AssetsInRedirectorPackage, /*bIncludeNestedObjects=*/false);
UMetaData* PackageMetaData = NULL;
bool bContainsAtLeastOneOtherAsset = false;
for ( auto ObjIt = AssetsInRedirectorPackage.CreateConstIterator(); ObjIt; ++ObjIt )
{
if ( UObjectRedirector* Redirector = Cast<UObjectRedirector>(*ObjIt) )
{
Redirector->RemoveFromRoot();
}
else if ( UMetaData* MetaData = Cast<UMetaData>(*ObjIt) )
{
PackageMetaData = MetaData;
}
else
{
bContainsAtLeastOneOtherAsset = true;
}
}
if ( !bContainsAtLeastOneOtherAsset )
{
RedirectorPackage->RemoveFromRoot();
ULinkerLoad* Linker = ULinkerLoad::FindExistingLinkerForPackage(RedirectorPackage);
if ( Linker )
{
Linker->RemoveFromRoot();
}
// @todo we shouldnt be worrying about metadata objects here, ObjectTools::CleanUpAfterSuccessfulDelete should
if ( PackageMetaData )
{
PackageMetaData->RemoveFromRoot();
PendingDeletes.AddUnique(MakeShareable(new FPendingDelete(PackageMetaData)));
}
}
}
}
void UBlueprintCore::Serialize(FArchive& Ar)
{
Super::Serialize(Ar);
if (Ar.UE4Ver() >= VER_UE4_BLUEPRINT_NATIVE_SERIALIZATION)
{
if (Ar.UE4Ver() >= VER_UE4_BLUEPRINT_CDO_MIGRATION)
{
Ar << bLegacyGeneratedClassIsAuthoritative;
}
if ((Ar.UE4Ver() < VER_UE4_BLUEPRINT_SKEL_CLASS_TRANSIENT_AGAIN)
&& (Ar.UE4Ver() != VER_UE4_BLUEPRINT_SKEL_TEMPORARY_TRANSIENT))
{
Ar << SkeletonGeneratedClass;
if( SkeletonGeneratedClass )
{
// If we serialized in a skeleton class, make sure it and all its children are updated to be transient
SkeletonGeneratedClass->SetFlags(RF_Transient);
TArray<UObject*> SubObjs;
GetObjectsWithOuter(SkeletonGeneratedClass, SubObjs, true);
for(auto SubObjIt = SubObjs.CreateIterator(); SubObjIt; ++SubObjIt)
{
(*SubObjIt)->SetFlags(RF_Transient);
}
}
// We only want to serialize in the GeneratedClass if the SkeletonClass didn't trigger a recompile
bool bSerializeGeneratedClass = true;
if (UBlueprint* BP = Cast<UBlueprint>(this))
{
bSerializeGeneratedClass = !Ar.IsLoading() || !BP->bHasBeenRegenerated;
}
if (bSerializeGeneratedClass)
{
Ar << GeneratedClass;
}
else if (Ar.IsLoading())
{
UClass* DummyClass = NULL;
Ar << DummyClass;
}
}
}
}
void FMaterialEditorUtilities::InitExpressions(UMaterial* Material)
{
FString ParmName;
Material->EditorComments.Empty();
Material->Expressions.Empty();
TArray<UObject*> ChildObjects;
GetObjectsWithOuter(Material, ChildObjects, /*bIncludeNestedObjects=*/false);
for ( int32 ChildIdx = 0; ChildIdx < ChildObjects.Num(); ++ChildIdx )
{
UMaterialExpression* MaterialExpression = Cast<UMaterialExpression>(ChildObjects[ChildIdx]);
if( MaterialExpression != NULL && !MaterialExpression->IsPendingKill() )
{
// Comment expressions are stored in a separate list.
if ( MaterialExpression->IsA( UMaterialExpressionComment::StaticClass() ) )
{
Material->EditorComments.Add( static_cast<UMaterialExpressionComment*>(MaterialExpression) );
}
else
{
Material->Expressions.Add( MaterialExpression );
}
}
}
Material->BuildEditorParameterList();
// Propagate RF_Transactional to all referenced material expressions.
Material->SetFlags( RF_Transactional );
for( int32 MaterialExpressionIndex = 0 ; MaterialExpressionIndex < Material->Expressions.Num() ; ++MaterialExpressionIndex )
{
UMaterialExpression* MaterialExpression = Material->Expressions[ MaterialExpressionIndex ];
if(MaterialExpression)
{
MaterialExpression->SetFlags( RF_Transactional );
}
}
for( int32 MaterialExpressionIndex = 0 ; MaterialExpressionIndex < Material->EditorComments.Num() ; ++MaterialExpressionIndex )
{
UMaterialExpressionComment* Comment = Material->EditorComments[ MaterialExpressionIndex ];
Comment->SetFlags( RF_Transactional );
}
}
void UActorComponent::PostRename(UObject* OldOuter, const FName OldName)
{
Super::PostRename(OldOuter, OldName);
if (OldOuter != GetOuter())
{
Owner = GetTypedOuter<AActor>();
AActor* OldOwner = (OldOuter->IsA<AActor>() ? CastChecked<AActor>(OldOuter) : OldOuter->GetTypedOuter<AActor>());
if (Owner != OldOwner)
{
if (OldOwner)
{
OldOwner->RemoveOwnedComponent(this);
}
if (Owner)
{
Owner->AddOwnedComponent(this);
}
TArray<UObject*> Children;
GetObjectsWithOuter(this, Children);
for (UObject* Child : Children)
{
if (UActorComponent* ChildComponent = Cast<UActorComponent>(Child))
{
ChildComponent->Owner = Owner;
if (OldOwner)
{
OldOwner->RemoveOwnedComponent(ChildComponent);
}
if (Owner)
{
Owner->AddOwnedComponent(ChildComponent);
}
}
}
}
}
bRoutedPostRename = true;
}
static void CleanAndSanitizeStruct(UBlueprintGeneratedStruct* StructToClean)
{
check(StructToClean);
const FString TransientString = FString::Printf(TEXT("TRASHSTRUCT_%s"), *StructToClean->GetName());
const FName TransientName = MakeUniqueObjectName(GetTransientPackage(), UBlueprintGeneratedStruct::StaticClass(), FName(*TransientString));
UBlueprintGeneratedStruct* TransientStruct = NewNamedObject<UBlueprintGeneratedStruct>(GetTransientPackage(), TransientName, RF_Public|RF_Transient);
const bool bRecompilingOnLoad = StructToClean->StructGeneratedBy ? StructToClean->StructGeneratedBy->bIsRegeneratingOnLoad : false;
const ERenameFlags RenFlags = REN_DontCreateRedirectors | (bRecompilingOnLoad ? REN_ForceNoResetLoaders : 0);
TArray<UObject*> SubObjects;
GetObjectsWithOuter(StructToClean, SubObjects, true);
for( auto SubObjIt = SubObjects.CreateIterator(); SubObjIt; ++SubObjIt )
{
UObject* CurrSubObj = *SubObjIt;
CurrSubObj->Rename(NULL, TransientStruct, RenFlags);
if( UProperty* Prop = Cast<UProperty>(CurrSubObj) )
{
FKismetCompilerUtilities::InvalidatePropertyExport(Prop);
}
else
{
ULinkerLoad::InvalidateExport(CurrSubObj);
}
}
if(!bRecompilingOnLoad)
{
StructToClean->RemoveMetaData(TEXT("BlueprintType"));
}
StructToClean->SetSuperStruct(NULL);
StructToClean->Children = NULL;
StructToClean->Script.Empty();
StructToClean->MinAlignment = 0;
StructToClean->RefLink = NULL;
StructToClean->PropertyLink = NULL;
StructToClean->DestructorLink = NULL;
StructToClean->ScriptObjectReferences.Empty();
StructToClean->PropertyLink = NULL;
}
void UUserDefinedStruct::RecursivelyPreload()
{
ULinkerLoad* Linker = GetLinker();
if( Linker && (NULL == PropertyLink) )
{
TArray<UObject*> AllChildMembers;
GetObjectsWithOuter(this, AllChildMembers);
for (int32 Index = 0; Index < AllChildMembers.Num(); ++Index)
{
UObject* Member = AllChildMembers[Index];
Linker->Preload(Member);
}
Linker->Preload(this);
if (NULL == PropertyLink)
{
StaticLink(true);
}
}
}
static void CleanAndSanitizeStruct(UUserDefinedStruct* StructToClean)
{
check(StructToClean);
if (auto EditorData = Cast<UUserDefinedStructEditorData>(StructToClean->EditorData))
{
EditorData->CleanDefaultInstance();
}
const FString TransientString = FString::Printf(TEXT("TRASHSTRUCT_%s"), *StructToClean->GetName());
const FName TransientName = MakeUniqueObjectName(GetTransientPackage(), UUserDefinedStruct::StaticClass(), FName(*TransientString));
UUserDefinedStruct* TransientStruct = NewObject<UUserDefinedStruct>(GetTransientPackage(), TransientName, RF_Public | RF_Transient);
TArray<UObject*> SubObjects;
GetObjectsWithOuter(StructToClean, SubObjects, true);
SubObjects.Remove(StructToClean->EditorData);
for( auto SubObjIt = SubObjects.CreateIterator(); SubObjIt; ++SubObjIt )
{
UObject* CurrSubObj = *SubObjIt;
CurrSubObj->Rename(NULL, TransientStruct, REN_DontCreateRedirectors);
if( UProperty* Prop = Cast<UProperty>(CurrSubObj) )
{
FKismetCompilerUtilities::InvalidatePropertyExport(Prop);
}
else
{
FLinkerLoad::InvalidateExport(CurrSubObj);
}
}
StructToClean->SetSuperStruct(NULL);
StructToClean->Children = NULL;
StructToClean->Script.Empty();
StructToClean->MinAlignment = 0;
StructToClean->RefLink = NULL;
StructToClean->PropertyLink = NULL;
StructToClean->DestructorLink = NULL;
StructToClean->ScriptObjectReferences.Empty();
StructToClean->PropertyLink = NULL;
StructToClean->ErrorMessage.Empty();
}
void UAIGraph::RemoveOrphanedNodes()
{
TSet<UObject*> NodeInstances;
CollectAllNodeInstances(NodeInstances);
NodeInstances.Remove(nullptr);
// Obtain a list of all nodes actually in the asset and discard unused nodes
TArray<UObject*> AllInners;
const bool bIncludeNestedObjects = false;
GetObjectsWithOuter(GetOuter(), AllInners, bIncludeNestedObjects);
for (auto InnerIt = AllInners.CreateConstIterator(); InnerIt; ++InnerIt)
{
UObject* TestObject = *InnerIt;
if (!NodeInstances.Contains(TestObject) && CanRemoveNestedObject(TestObject))
{
TestObject->SetFlags(RF_Transient);
TestObject->Rename(NULL, GetTransientPackage(), REN_DontCreateRedirectors | REN_NonTransactional | REN_ForceNoResetLoaders);
}
}
}
UEdGraph* FGraphReference::GetGraph() const
{
if (MacroGraph == NULL)
{
if (GraphBlueprint)
{
TArray<UObject*> ObjectsInPackage;
GetObjectsWithOuter(GraphBlueprint, ObjectsInPackage);
for (int32 Index = 0; Index < ObjectsInPackage.Num(); ++Index)
{
UEdGraph* FoundGraph = Cast<UEdGraph>(ObjectsInPackage[Index]);
if (FoundGraph && FoundGraph->GraphGuid == GraphGuid)
{
MacroGraph = FoundGraph;
break;
}
}
}
}
return MacroGraph;
}
int32 UDerivedDataCacheCommandlet::Main( const FString& Params )
{
TArray<FString> Tokens, Switches;
ParseCommandLine(*Params, Tokens, Switches);
bool bFillCache = Switches.Contains("FILL"); // do the equivalent of a "loadpackage -all" to fill the DDC
bool bStartupOnly = Switches.Contains("STARTUPONLY"); // regardless of any other flags, do not iterate packages
// Subsets for parallel processing
uint32 SubsetMod = 0;
uint32 SubsetTarget = MAX_uint32;
FParse::Value(*Params, TEXT("SubsetMod="), SubsetMod);
FParse::Value(*Params, TEXT("SubsetTarget="), SubsetTarget);
bool bDoSubset = SubsetMod > 0 && SubsetTarget < SubsetMod;
double FindProcessedPackagesTime = 0.0;
double GCTime = 0.0;
if (!bStartupOnly && bFillCache)
{
FCoreDelegates::PackageCreatedForLoad.AddUObject(this, &UDerivedDataCacheCommandlet::MaybeMarkPackageAsAlreadyLoaded);
TArray<FString> FilesInPath;
Tokens.Empty(2);
Tokens.Add(FString("*") + FPackageName::GetAssetPackageExtension());
Tokens.Add(FString("*") + FPackageName::GetMapPackageExtension());
uint8 PackageFilter = NORMALIZE_DefaultFlags;
if ( Switches.Contains(TEXT("MAPSONLY")) )
{
PackageFilter |= NORMALIZE_ExcludeContentPackages;
}
if ( !Switches.Contains(TEXT("DEV")) )
{
PackageFilter |= NORMALIZE_ExcludeDeveloperPackages;
}
// assume the first token is the map wildcard/pathname
TArray<FString> Unused;
for ( int32 TokenIndex = 0; TokenIndex < Tokens.Num(); TokenIndex++ )
{
TArray<FString> TokenFiles;
if ( !NormalizePackageNames( Unused, TokenFiles, Tokens[TokenIndex], PackageFilter) )
{
UE_LOG(LogDerivedDataCacheCommandlet, Display, TEXT("No packages found for parameter %i: '%s'"), TokenIndex, *Tokens[TokenIndex]);
continue;
}
FilesInPath += TokenFiles;
}
if ( FilesInPath.Num() == 0 )
{
UE_LOG(LogDerivedDataCacheCommandlet, Warning, TEXT("No files found."));
}
ITargetPlatformManagerModule* TPM = GetTargetPlatformManager();
const TArray<ITargetPlatform*>& Platforms = TPM->GetActiveTargetPlatforms();
for (int32 Index = 0; Index < Platforms.Num(); Index++)
{
TArray<FName> DesiredShaderFormats;
Platforms[Index]->GetShaderFormats(DesiredShaderFormats);
for (int32 FormatIndex = 0; FormatIndex < DesiredShaderFormats.Num(); FormatIndex++)
{
const EShaderPlatform TargetPlatform = ShaderFormatToLegacyShaderPlatform(DesiredShaderFormats[FormatIndex]);
// Kick off global shader compiles for each target platform
GetGlobalShaderMap(TargetPlatform);
}
}
const int32 GCInterval = 100;
int32 NumProcessedSinceLastGC = GCInterval;
bool bLastPackageWasMap = true; // 'true' is to prime the ProcessedPackages list
TSet<FString> ProcessedPackages;
UE_LOG(LogDerivedDataCacheCommandlet, Display, TEXT("%d packages to load..."), FilesInPath.Num());
for( int32 FileIndex = FilesInPath.Num() - 1; ; FileIndex-- )
{
// Keep track of which packages have already been processed along with the map.
if (NumProcessedSinceLastGC >= GCInterval || bLastPackageWasMap || FileIndex == FilesInPath.Num() - 1)
{
const double FindProcessedPackagesStartTime = FPlatformTime::Seconds();
TArray<UObject *> ObjectsInOuter;
GetObjectsWithOuter(NULL, ObjectsInOuter, false);
for( int32 Index = 0; Index < ObjectsInOuter.Num(); Index++ )
{
UPackage* Pkg = Cast<UPackage>(ObjectsInOuter[Index]);
if (!Pkg)
{
continue;
}
FString Filename;
if (FPackageName::DoesPackageExist(Pkg->GetName(), NULL, &Filename))
{
if (!ProcessedPackages.Contains(Filename))
{
ProcessedPackages.Add(Filename);
PackagesToNotReload.Add(Pkg->GetName());
Pkg->PackageFlags |= PKG_ReloadingForCooker;
{
TArray<UObject *> ObjectsInPackage;
GetObjectsWithOuter(Pkg, ObjectsInPackage, true);
for( int32 IndexPackage = 0; IndexPackage < ObjectsInPackage.Num(); IndexPackage++ )
{
ObjectsInPackage[IndexPackage]->CookerWillNeverCookAgain();
}
}
}
}
}
FindProcessedPackagesTime += FPlatformTime::Seconds() - FindProcessedPackagesStartTime;
}
if (NumProcessedSinceLastGC >= GCInterval || FileIndex < 0 || bLastPackageWasMap)
{
const double StartGCTime = FPlatformTime::Seconds();
if (NumProcessedSinceLastGC >= GCInterval || FileIndex < 0)
{
UE_LOG(LogDerivedDataCacheCommandlet, Display, TEXT("GC (Full)..."));
CollectGarbage( RF_Native );
NumProcessedSinceLastGC = 0;
}
else
{
UE_LOG(LogDerivedDataCacheCommandlet, Display, TEXT("GC..."));
CollectGarbage( RF_Native | RF_Standalone );
}
GCTime += FPlatformTime::Seconds() - StartGCTime;
bLastPackageWasMap = false;
}
if (FileIndex < 0)
{
break;
}
const FString& Filename = FilesInPath[FileIndex];
if (ProcessedPackages.Contains(Filename))
{
continue;
}
if (bDoSubset)
{
const FString& PackageName = FPackageName::PackageFromPath(*Filename);
if (FCrc::StrCrc_DEPRECATED(*PackageName.ToUpper()) % SubsetMod != SubsetTarget)
{
continue;
}
}
UE_LOG(LogDerivedDataCacheCommandlet, Display, TEXT("Loading (%d) %s"), FilesInPath.Num() - FileIndex, *Filename );
UPackage* Package = LoadPackage( NULL, *Filename, LOAD_None );
if( Package == NULL )
{
UE_LOG(LogDerivedDataCacheCommandlet, Error, TEXT("Error loading %s!"), *Filename );
}
else
{
bLastPackageWasMap = Package->ContainsMap();
NumProcessedSinceLastGC++;
}
}
}
IConsoleManager::Get().ProcessUserConsoleInput(TEXT("Tex.DerivedDataTimings"), *GWarn, NULL);
UE_LOG(LogDerivedDataCacheCommandlet, Display, TEXT("Waiting for shaders to finish."));
GShaderCompilingManager->FinishAllCompilation();
UE_LOG(LogDerivedDataCacheCommandlet, Display, TEXT("Done waiting for shaders to finish."));
GetDerivedDataCacheRef().WaitForQuiescence(true);
UE_LOG(LogDerivedDataCacheCommandlet, Display, TEXT("%.2lfs spent looking for processed packages, %.2lfs spent on GC."), FindProcessedPackagesTime, GCTime);
return 0;
}
void UExporter::ExportObjectInner(const FExportObjectInnerContext* Context, UObject* Object, FOutputDevice& Ar, uint32 PortFlags)
{
// indent all the text in here
TextIndent += 3;
FExportObjectInnerContext::InnerList TempInners;
const FExportObjectInnerContext::InnerList* ContextInners = NULL;
if (Context)
{
ContextInners = Context->ObjectToInnerMap.Find(Object);
}
else
{
// NOTE: We ignore inner objects that have been tagged for death
GetObjectsWithOuter(Object, TempInners, false, RF_PendingKill);
}
FExportObjectInnerContext::InnerList const& UnsortedObjectInners = ContextInners ? *ContextInners : TempInners;
FExportObjectInnerContext::InnerList SortedObjectInners;
if (PortFlags & PPF_DebugDump)
{
SortedObjectInners = UnsortedObjectInners;
// optionally sort inners, which can be useful when comparing/diffing debug dumps
SortedObjectInners.Sort([](const UObject& A, const UObject& B) -> bool
{
return A.GetName() < B.GetName();
});
}
FExportObjectInnerContext::InnerList const& ObjectInners = (PortFlags & PPF_DebugDump) ? SortedObjectInners : UnsortedObjectInners;
if (!(PortFlags & PPF_SeparateDefine))
{
for (UObject* Obj : ObjectInners)
{
if (!Obj->HasAnyFlags(RF_TextExportTransient) && Obj->GetClass() != UModel::StaticClass())
{
// export the object
UExporter::ExportToOutputDevice( Context, Obj, NULL, Ar, (PortFlags & PPF_Copy) ? TEXT("Copy") : TEXT("T3D"), TextIndent, PortFlags | PPF_SeparateDeclare, false, ExportRootScope );
}
}
}
if (!(PortFlags & PPF_SeparateDeclare))
{
for (UObject* Obj : ObjectInners)
{
if (!Obj->HasAnyFlags(RF_TextExportTransient) && Obj->GetClass() != UModel::StaticClass())
{
// export the object
UExporter::ExportToOutputDevice( Context, Obj, NULL, Ar, (PortFlags & PPF_Copy) ? TEXT("Copy") : TEXT("T3D"), TextIndent, PortFlags | PPF_SeparateDefine, false, ExportRootScope );
// don't reexport below in ExportProperties
Obj->Mark(OBJECTMARK_TagImp);
}
}
// export the object's properties
// Note: we use archetype as the object to diff properties against before they exported. When object is created, they should create from archetype
// and using this system, it should recover all properties it needs to copy
uint8 *CompareObject;
if (Object->HasAnyFlags(RF_ClassDefaultObject))
{
CompareObject = (uint8*)Object;
}
else
{
CompareObject = (uint8*)Object->GetArchetype();
}
ExportProperties( Context, Ar, Object->GetClass(), (uint8*)Object, TextIndent, Object->GetClass(), CompareObject, Object, PortFlags, ExportRootScope );
if (AActor* Actor = Cast<AActor>(Object))
{
// Export anything extra for the components. Used for instanced foliage.
// This is done after the actor properties so these are set when regenerating the extra data objects.
TArray<UActorComponent*> Components;
Actor->GetComponents<UActorComponent, FDefaultAllocator>(Components);
ExportComponentExtra(Context, Components, Ar, PortFlags);
}
}
// remove indent
TextIndent -= 3;
}
void FAssetFixUpRedirectors::DeleteRedirectors(TArray<FRedirectorRefs>& RedirectorsToFix, const TArray<UPackage*>& FailedToSave) const
{
TArray<UObject*> ObjectsToDelete;
for ( auto RedirectorIt = RedirectorsToFix.CreateIterator(); RedirectorIt; ++RedirectorIt )
{
FRedirectorRefs& RedirectorRefs = *RedirectorIt;
if ( RedirectorRefs.bRedirectorValidForFixup )
{
bool bAllReferencersFixedUp = true;
for (const auto& ReferencingPackageName : RedirectorRefs.ReferencingPackageNames)
{
if (FailedToSave.ContainsByPredicate([&](UPackage* Package) { return Package->GetFName() == ReferencingPackageName; }))
{
bAllReferencersFixedUp = false;
break;
}
}
if (!bAllReferencersFixedUp)
{
continue;
}
// Add all redirectors found in this package to the redirectors to delete list.
// All redirectors in this package should be fixed up.
UPackage* RedirectorPackage = RedirectorRefs.Redirector->GetOutermost();
TArray<UObject*> AssetsInRedirectorPackage;
GetObjectsWithOuter(RedirectorPackage, AssetsInRedirectorPackage, /*bIncludeNestedObjects=*/false);
UMetaData* PackageMetaData = NULL;
bool bContainsAtLeastOneOtherAsset = false;
for ( auto ObjIt = AssetsInRedirectorPackage.CreateConstIterator(); ObjIt; ++ObjIt )
{
if ( UObjectRedirector* Redirector = Cast<UObjectRedirector>(*ObjIt) )
{
Redirector->RemoveFromRoot();
ObjectsToDelete.Add(Redirector);
}
else if ( UMetaData* MetaData = Cast<UMetaData>(*ObjIt) )
{
PackageMetaData = MetaData;
}
else
{
bContainsAtLeastOneOtherAsset = true;
}
}
if ( !bContainsAtLeastOneOtherAsset )
{
RedirectorPackage->RemoveFromRoot();
// @todo we shouldnt be worrying about metadata objects here, ObjectTools::CleanUpAfterSuccessfulDelete should
if ( PackageMetaData )
{
PackageMetaData->RemoveFromRoot();
ObjectsToDelete.Add(PackageMetaData);
}
}
// This redirector will be deleted, NULL the reference here
RedirectorRefs.Redirector = NULL;
}
}
if ( ObjectsToDelete.Num() > 0 )
{
ObjectTools::DeleteObjects(ObjectsToDelete, false);
}
}
void UBehaviorTreeGraph::RemoveOrphanedNodes()
{
UBehaviorTree* BTAsset = CastChecked<UBehaviorTree>(GetOuter());
// Obtain a list of all nodes that should be in the asset
TSet<UBTNode*> AllNodes;
for (int32 Index = 0; Index < Nodes.Num(); ++Index)
{
UBehaviorTreeGraphNode* MyNode = Cast<UBehaviorTreeGraphNode>(Nodes[Index]);
if (MyNode)
{
UBTNode* MyNodeInstance = Cast<UBTNode>(MyNode->NodeInstance);
if (MyNodeInstance)
{
AllNodes.Add(MyNodeInstance);
}
for (int32 iDecorator = 0; iDecorator < MyNode->Decorators.Num(); iDecorator++)
{
UBehaviorTreeGraphNode_CompositeDecorator* SubgraphNode = Cast<UBehaviorTreeGraphNode_CompositeDecorator>(MyNode->Decorators[iDecorator]);
if (SubgraphNode)
{
TArray<UBTDecorator*> NodeInstances;
TArray<FBTDecoratorLogic> DummyOps;
SubgraphNode->CollectDecoratorData(NodeInstances, DummyOps);
for (int32 SubIdx = 0; SubIdx < NodeInstances.Num(); SubIdx++)
{
AllNodes.Add(NodeInstances[SubIdx]);
}
}
else
{
UBTNode* MyDecoratorNodeInstance = MyNode->Decorators[iDecorator] ? Cast<UBTNode>(MyNode->Decorators[iDecorator]->NodeInstance) : NULL;
if (MyDecoratorNodeInstance)
{
AllNodes.Add(MyDecoratorNodeInstance);
}
}
}
for (int32 iService = 0; iService < MyNode->Services.Num(); iService++)
{
UBTNode* MyServiceNodeInstance = MyNode->Services[iService] ? Cast<UBTNode>(MyNode->Services[iService]->NodeInstance) : NULL;
if (MyServiceNodeInstance)
{
AllNodes.Add(MyServiceNodeInstance);
}
}
}
}
// Obtain a list of all nodes actually in the asset and discard unused nodes
TArray<UObject*> AllInners;
const bool bIncludeNestedObjects = false;
GetObjectsWithOuter(BTAsset, AllInners, bIncludeNestedObjects);
for (auto InnerIt = AllInners.CreateConstIterator(); InnerIt; ++InnerIt)
{
UBTNode* Node = Cast<UBTNode>(*InnerIt);
if (Node && !AllNodes.Contains(Node))
{
Node->SetFlags(RF_Transient);
Node->Rename(NULL, GetTransientPackage(), REN_DontCreateRedirectors | REN_NonTransactional | REN_ForceNoResetLoaders);
}
}
}
void UActorComponent::RegisterComponentWithWorld(UWorld* InWorld)
{
checkf(!HasAnyFlags(RF_Unreachable), 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 == NULL)
{
//UE_LOG(LogActorComponent, Log, TEXT("RegisterComponentWithWorld: (%s) NULL InWorld specified. Aborting."), *GetPathName());
return;
}
// If not registered, should not have a scene
checkf(World == NULL, 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->HasAnyFlags(RF_Unreachable), 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)
World = InWorld;
ExecuteRegisterEvents();
RegisterAllComponentTickFunctions(true);
if (MyOwner == nullptr || MyOwner->IsActorInitialized())
{
if (!bHasBeenInitialized && bWantsInitializeComponent)
{
InitializeComponent();
}
}
if (MyOwner && MyOwner->HasActorBegunPlay())
{
if (bWantsBeginPlay)
{
BeginPlay();
}
}
// 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_PendingKill);
for (UObject* Child : Children)
{
UActorComponent* ChildComponent = Cast<UActorComponent>(Child);
if (ChildComponent && !ChildComponent->IsRegistered())
{
ChildComponent->RegisterComponentWithWorld(InWorld);
}
}
}
}
int32 UGenerateDistillFileSetsCommandlet::Main( const FString& InParams )
{
// Parse command line.
TArray<FString> Tokens;
TArray<FString> Switches;
UCommandlet::ParseCommandLine(*InParams, Tokens, Switches);
TArray<FString> MapList;
for ( int32 MapIdx = 0; MapIdx < Tokens.Num(); ++MapIdx )
{
const FString& Map = Tokens[MapIdx];
if ( FPackageName::IsShortPackageName(Map) )
{
FString LongPackageName;
if ( FPackageName::SearchForPackageOnDisk(Map, &LongPackageName) )
{
MapList.Add(LongPackageName);
}
else
{
UE_LOG(LogGenerateDistillFileSetsCommandlet, Error, TEXT("Unable to find package for map %s."), *Map);
return 1;
}
}
else
{
MapList.Add(Map);
}
}
if ( MapList.Num() <= 0 )
{
// No map tokens were supplied on the command line, so assume all maps
TArray<FString> AllPackageFilenames;
FEditorFileUtils::FindAllPackageFiles(AllPackageFilenames);
for (int32 PackageIndex = 0; PackageIndex < AllPackageFilenames.Num(); PackageIndex++)
{
const FString& Filename = AllPackageFilenames[PackageIndex];
if (FPaths::GetExtension(Filename, true) == FPackageName::GetMapPackageExtension() )
{
FString LongPackageName;
if ( FPackageName::TryConvertFilenameToLongPackageName(Filename, LongPackageName) )
{
// Warn about maps in "NoShip" or "TestMaps" folders. Those should have been filtered out during the Distill process!
if( !Filename.Contains( "/NoShip/") && !Filename.Contains( "/TestMaps/"))
{
// @todo plugins add support for plugins?
if ( LongPackageName.StartsWith(TEXT("/Game")) )
{
UE_LOG(LogGenerateDistillFileSetsCommandlet, Display, TEXT( "Discovered map package %s..." ), *LongPackageName );
MapList.Add(LongPackageName);
}
}
else
{
UE_LOG(LogGenerateDistillFileSetsCommandlet, Display, TEXT("Skipping map package %s in TestMaps or NoShip folder"), *Filename);
}
}
else
{
UE_LOG(LogGenerateDistillFileSetsCommandlet, Warning, TEXT("Failed to determine package name for map file %s."), *Filename);
}
}
}
}
const FString TemplateFileSwitch = TEXT("Template=");
const FString OutputFileSwitch = TEXT("Output=");
const FString TemplateFolderSwitch = TEXT("TemplateFolder=");
const FString OutputFolderSwitch = TEXT("OutputFolder=");
FString TemplateFilename;
FString OutputFilename;
FString TemplateFolder;
FString OutputFolder;
for (int32 SwitchIdx = 0; SwitchIdx < Switches.Num(); ++SwitchIdx)
{
const FString& Switch = Switches[SwitchIdx];
if ( Switch.StartsWith(TemplateFileSwitch) )
{
Switch.Split(TEXT("="), NULL, &TemplateFilename);
TemplateFilename = TemplateFilename.TrimQuotes();
}
else if ( Switch.StartsWith(OutputFileSwitch) )
{
Switch.Split(TEXT("="), NULL, &OutputFilename);
OutputFilename = OutputFilename.TrimQuotes();
}
else if ( Switch.StartsWith(TemplateFolderSwitch) )
{
Switch.Split(TEXT("="), NULL, &TemplateFolder);
TemplateFolder = TemplateFolder.TrimQuotes();
FPaths::NormalizeFilename(TemplateFolder);
if ( !TemplateFolder.EndsWith(TEXT("/")) )
{
TemplateFolder += TEXT("/");
}
UE_LOG(LogGenerateDistillFileSetsCommandlet, Display, TEXT("Using template folder: "), *TemplateFolder);
}
else if ( Switch.StartsWith(OutputFolderSwitch) )
{
Switch.Split(TEXT("="), NULL, &OutputFolder);
OutputFolder = OutputFolder.TrimQuotes();
FPaths::NormalizeFilename(OutputFolder);
if ( !OutputFolder.EndsWith(TEXT("/")) )
{
OutputFolder += TEXT("/");
}
UE_LOG(LogGenerateDistillFileSetsCommandlet, Display, TEXT("Using output folder: "), *OutputFolder);
}
}
if ( OutputFilename.IsEmpty() )
{
UE_LOG(LogGenerateDistillFileSetsCommandlet, Error, TEXT("You must supply -Output=OutputFilename. These files are relative to the Game/Build directory."));
return 1;
}
if (OutputFolder.IsEmpty())
{
OutputFolder = FPaths::GameDir() + TEXT("Build/");
}
OutputFilename = OutputFolder + OutputFilename;
bool bSimpleTxtOutput = false;
// Load the template file
FString TemplateFileContents;
if (TemplateFilename.IsEmpty())
{
UE_LOG(LogGenerateDistillFileSetsCommandlet, Log, TEXT("No template specified, assuming a simple txt output."));
bSimpleTxtOutput = true;
}
// If no folder was specified, filenames are relative to the build dir.
else
{
if (TemplateFolder.IsEmpty())
{
TemplateFolder = FPaths::GameDir() + TEXT("Build/");
}
TemplateFilename = TemplateFolder + TemplateFilename;
if (!FFileHelper::LoadFileToString(TemplateFileContents, *TemplateFilename))
{
UE_LOG(LogGenerateDistillFileSetsCommandlet, Error, TEXT("Failed to load template file '%s'"), *TemplateFilename);
return 1;
}
}
// Form a full unique package list
TSet<FString> AllPackageNames;
//@todo SLATE: This is a hack to ensure all slate referenced assets get cooked.
// Slate needs to be refactored to properly identify required assets at cook time.
// Simply jamming everything in a given directory into the cook list is error-prone
// on many levels - assets not required getting cooked/shipped; assets not put under
// the correct folder; etc.
{
TArray<FString> UIContentPaths;
if (GConfig->GetArray(TEXT("UI"), TEXT("ContentDirectories"), UIContentPaths, GEditorIni) > 0)
{
for (int32 DirIdx = 0; DirIdx < UIContentPaths.Num(); DirIdx++)
{
FString ContentPath = FPackageName::LongPackageNameToFilename(UIContentPaths[DirIdx]);
TArray<FString> Files;
IFileManager::Get().FindFilesRecursive(Files, *ContentPath, *(FString(TEXT("*")) + FPackageName::GetAssetPackageExtension()), true, false);
for (int32 Index = 0; Index < Files.Num(); Index++)
{
FString StdFile = Files[Index];
FPaths::MakeStandardFilename(StdFile);
StdFile = FPackageName::FilenameToLongPackageName(StdFile);
AllPackageNames.Add(StdFile);
}
}
}
}
// Load all maps
{
for ( auto MapIt = MapList.CreateConstIterator(); MapIt; ++MapIt )
{
const FString& MapPackage = *MapIt;
UE_LOG(LogGenerateDistillFileSetsCommandlet, Display, TEXT( "Loading %s..." ), *MapPackage );
UPackage* Package = LoadPackage( NULL, *MapPackage, LOAD_None );
if( Package != NULL )
{
AllPackageNames.Add(Package->GetName());
UE_LOG(LogGenerateDistillFileSetsCommandlet, Display, TEXT( "Finding content referenced by %s..." ), *MapPackage );
TArray<UObject *> ObjectsInOuter;
GetObjectsWithOuter(NULL, ObjectsInOuter, false);
for (int32 Index = 0; Index < ObjectsInOuter.Num(); Index++)
{
FString OtherName = ObjectsInOuter[Index]->GetOutermost()->GetName();
if (!AllPackageNames.Contains(OtherName))
{
AllPackageNames.Add(OtherName);
UE_LOG(LogGenerateDistillFileSetsCommandlet, Log, TEXT("Package: %s"), *OtherName);
}
}
UE_LOG(LogGenerateDistillFileSetsCommandlet, Display, TEXT( "Collecting garbage..." ) );
CollectGarbage(RF_NoFlags);
}
}
}
// Sort the results to make it easier to diff files. No necessary but useful sometimes.
TArray<FString> SortedPackageNames = AllPackageNames.Array();
SortedPackageNames.Sort();
// For the list of FileSets to include in the distill
FString AllFileSets;
const FString FileSetPathRoot = TEXT("Content");
for (auto PackageIt = SortedPackageNames.CreateConstIterator(); PackageIt; ++PackageIt)
{
const FString& PackageName = *PackageIt;
// @todo plugins add support for plugins?
if ( PackageName.StartsWith(TEXT("/Game")) )
{
const FString PathWithoutRoot( PackageName.Mid( 5 ) );
const FString FileSetPath = FileSetPathRoot + PathWithoutRoot;
if (bSimpleTxtOutput)
{
FString ActualFile;
if (FPackageName::DoesPackageExist(PackageName, NULL, &ActualFile))
{
ActualFile = IFileManager::Get().ConvertToAbsolutePathForExternalAppForRead(*ActualFile);
AllFileSets += FString::Printf(TEXT("%s") LINE_TERMINATOR, *ActualFile);
UE_LOG(LogGenerateDistillFileSetsCommandlet, Log, TEXT("File: %s"), *ActualFile);
}
}
else
{
AllFileSets += FString::Printf(TEXT("<FileSet Path=\"%s.*\" bIsRecursive=\"false\"/>") LINE_TERMINATOR, *FileSetPath);
}
}
}
// Write the output file
FString OutputFileContents;
if (bSimpleTxtOutput)
{
OutputFileContents = AllFileSets;
}
else
{
OutputFileContents = TemplateFileContents.Replace(TEXT("%INSTALLEDCONTENTFILESETS%"), *AllFileSets, ESearchCase::CaseSensitive);
if (FApp::HasGameName())
{
UE_LOG(LogGenerateDistillFileSetsCommandlet, Display, TEXT("Replacing %%GAMENAME%% with (%s)..."), FApp::GetGameName());
OutputFileContents = OutputFileContents.Replace(TEXT("%GAMENAME%"), FApp::GetGameName(), ESearchCase::CaseSensitive);
}
else
{
UE_LOG(LogGenerateDistillFileSetsCommandlet, Warning, TEXT("Failed to replace %%GAMENAME%% since we are running without a game name."));
}
}
if ( !FFileHelper::SaveStringToFile(OutputFileContents, *OutputFilename) )
{
UE_LOG(LogGenerateDistillFileSetsCommandlet, Error, TEXT("Failed to save output file '%s'"), *OutputFilename);
return 1;
}
return 0;
}
/**
* Runs compile-on-load test against all unloaded, and optionally loaded, blueprints
* See the TestAllBlueprints config key in the [Automation.Blueprint] config sections
*/
bool FBlueprintCompileOnLoadTest::RunTest(const FString& BlueprintAssetPath)
{
FCompilerResultsLog Results;
UBlueprint* ExistingBP = nullptr;
// if this blueprint was already loaded, then these tests are invalidated
// (because dependencies have already been loaded)
if (FBlueprintAutomationTestUtilities::IsBlueprintLoaded(BlueprintAssetPath, &ExistingBP))
{
if (FBlueprintAutomationTestUtilities::IsAssetUnsaved(BlueprintAssetPath))
{
AddError(FString::Printf(TEXT("You have unsaved changes made to '%s', please save them before running this test."), *BlueprintAssetPath));
return false;
}
else
{
AddWarning(FString::Printf(TEXT("Test may be invalid (the blueprint is already loaded): '%s'"), *BlueprintAssetPath));
FBlueprintAutomationTestUtilities::UnloadBlueprint(ExistingBP);
}
}
// tracks blueprints that were already loaded (and cleans up any that were
// loaded in its lifetime, once it is destroyed)
FScopedBlueprintUnloader NewBlueprintUnloader(/*bAutoOpenScope =*/true, /*bRunGCOnCloseIn =*/true);
// We load the blueprint twice and compare the two for discrepancies. This is
// to bring dependency load issues to light (among other things). If a blueprint's
// dependencies are loaded too late, then this first object is the degenerate one.
UBlueprint* InitialBlueprint = Cast<UBlueprint>(StaticLoadObject(UBlueprint::StaticClass(), NULL, *BlueprintAssetPath));
// if we failed to load it the first time, then there is no need to make a
// second attempt, leave them to fix up this issue first
if (InitialBlueprint == NULL)
{
AddError(*FString::Printf(TEXT("Unable to load blueprint for: '%s'"), *BlueprintAssetPath));
return false;
}
if (!InitialBlueprint->SkeletonGeneratedClass || !InitialBlueprint->GeneratedClass)
{
AddError(*FString::Printf(TEXT("Unable to load blueprint for: '%s'. Probably it derives from an invalid class."), *BlueprintAssetPath));
return false;
}
// GATHER SUBOBJECTS
TArray<TWeakObjectPtr<UObject>> InitialBlueprintSubobjects;
{
TArray<UObject*> InitialBlueprintSubobjectsPtr;
GetObjectsWithOuter(InitialBlueprint, InitialBlueprintSubobjectsPtr);
for (auto Obj : InitialBlueprintSubobjectsPtr)
{
InitialBlueprintSubobjects.Add(Obj);
}
}
// GATHER DEPENDENCIES
TSet<TWeakObjectPtr<UBlueprint>> BlueprintDependencies;
{
TArray<UBlueprint*> DependentBlueprints;
FBlueprintEditorUtils::GetDependentBlueprints(InitialBlueprint, DependentBlueprints);
for (auto BP : DependentBlueprints)
{
BlueprintDependencies.Add(BP);
}
}
BlueprintDependencies.Add(InitialBlueprint);
// GATHER DEPENDENCIES PERSISTENT DATA
struct FReplaceInnerData
{
TWeakObjectPtr<UClass> Class;
FStringAssetReference BlueprintAsset;
};
TArray<FReplaceInnerData> ReplaceInnerData;
for (auto BPToUnloadWP : BlueprintDependencies)
{
auto BPToUnload = BPToUnloadWP.Get();
auto OldClass = BPToUnload ? *BPToUnload->GeneratedClass : NULL;
if (OldClass)
{
FReplaceInnerData Data;
Data.Class = OldClass;
Data.BlueprintAsset = FStringAssetReference(BPToUnload);
ReplaceInnerData.Add(Data);
}
}
// store off data for the initial blueprint so we can unload it (and reconstruct
// later to compare it with a second one)
TArray<uint8> InitialLoadData;
FObjectWriter(InitialBlueprint, InitialLoadData);
// grab the name before we unload the blueprint
FName const BlueprintName = InitialBlueprint->GetFName();
// unload the blueprint so we can reload it (to catch any differences, now
// that all its dependencies should be loaded as well)
//UNLOAD DEPENDENCIES, all circular dependencies will be loaded again
// unload the blueprint so we can reload it (to catch any differences, now
// that all its dependencies should be loaded as well)
for (auto BPToUnloadWP : BlueprintDependencies)
{
if (auto BPToUnload = BPToUnloadWP.Get())
{
FBlueprintAutomationTestUtilities::UnloadBlueprint(BPToUnload);
}
}
// this blueprint is now dead (will be destroyed next garbage-collection pass)
UBlueprint* UnloadedBlueprint = InitialBlueprint;
InitialBlueprint = NULL;
// load the blueprint a second time; if the two separately loaded blueprints
// are different, then this one is most likely the choice one (it has all its
// dependencies loaded)
UBlueprint* ReloadedBlueprint = Cast<UBlueprint>(StaticLoadObject(UBlueprint::StaticClass(), NULL, *BlueprintAssetPath));
UPackage* TransientPackage = GetTransientPackage();
FName ReconstructedName = MakeUniqueObjectName(TransientPackage, UBlueprint::StaticClass(), BlueprintName);
// reconstruct the initial blueprint (using the serialized data from its initial load)
EObjectFlags const StandardBlueprintFlags = RF_Public | RF_Standalone | RF_Transactional;
InitialBlueprint = ConstructObject<UBlueprint>(UBlueprint::StaticClass(), TransientPackage, ReconstructedName, StandardBlueprintFlags | RF_Transient);
FObjectReader(InitialBlueprint, InitialLoadData);
{
TMap<UObject*, UObject*> ClassRedirects;
for (auto& Data : ReplaceInnerData)
{
UClass* OriginalClass = Data.Class.Get();
UBlueprint* NewBlueprint = Cast<UBlueprint>(Data.BlueprintAsset.ResolveObject());
UClass* NewClass = NewBlueprint ? *NewBlueprint->GeneratedClass : NULL;
if (OriginalClass && NewClass)
{
ClassRedirects.Add(OriginalClass, NewClass);
}
}
// REPLACE OLD DATA
FArchiveReplaceObjectRef<UObject>(InitialBlueprint, ClassRedirects, /*bNullPrivateRefs=*/false, /*bIgnoreOuterRef=*/true, /*bIgnoreArchetypeRef=*/false);
for (auto SubobjWP : InitialBlueprintSubobjects)
{
if (auto Subobj = SubobjWP.Get())
{
FArchiveReplaceObjectRef<UObject>(Subobj, ClassRedirects, /*bNullPrivateRefs=*/false, /*bIgnoreOuterRef=*/true, /*bIgnoreArchetypeRef=*/false);
}
}
UPackage* AssetPackage = ReloadedBlueprint->GetOutermost();
bool bHasUnsavedChanges = AssetPackage->IsDirty();
FBlueprintEditorUtils::RefreshAllNodes(ReloadedBlueprint);
AssetPackage->SetDirtyFlag(bHasUnsavedChanges);
}
// look for diffs between subsequent loads and log them as errors
TArray<FDiffSingleResult> BlueprintDiffs;
bool bDiffsFound = FBlueprintAutomationTestUtilities::DiffBlueprints(InitialBlueprint, ReloadedBlueprint, BlueprintDiffs);
if (bDiffsFound)
{
FBlueprintAutomationTestUtilities::ResolveCircularDependencyDiffs(ReloadedBlueprint, BlueprintDiffs);
// if there are still diffs after resolving any the could have been from unloaded circular dependencies
if (BlueprintDiffs.Num() > 0)
{
AddError(FString::Printf(TEXT("Inconsistencies between subsequent blueprint loads for: '%s' (was a dependency not preloaded?)"), *BlueprintAssetPath));
}
else
{
bDiffsFound = false;
}
// list all the differences (so as to help identify what dependency was missing)
for (auto DiffIt(BlueprintDiffs.CreateIterator()); DiffIt; ++DiffIt)
{
// will be presented in the context of "what changed between the initial load and the second?"
FString DiffDescription = DiffIt->ToolTip;
if (DiffDescription != DiffIt->DisplayString)
{
DiffDescription = FString::Printf(TEXT("%s (%s)"), *DiffDescription, *DiffIt->DisplayString);
}
const UEdGraphNode* NodeFromPin = DiffIt->Pin1 ? Cast<const UEdGraphNode>(DiffIt->Pin1->GetOuter()) : NULL;
const UEdGraphNode* Node = DiffIt->Node1 ? DiffIt->Node1 : NodeFromPin;
const UEdGraph* Graph = Node ? Node->GetGraph() : NULL;
const FString GraphName = Graph ? Graph->GetName() : FString(TEXT("Unknown Graph"));
AddError(FString::Printf(TEXT("%s.%s differs between subsequent loads: %s"), *BlueprintName.ToString(), *GraphName, *DiffDescription));
}
}
// At the close of this function, the FScopedBlueprintUnloader should prep
// for following tests by unloading any blueprint dependencies that were
// loaded for this one (should catch InitialBlueprint and ReloadedBlueprint)
//
// The FScopedBlueprintUnloader should also run garbage-collection after,
// in hopes that the imports for this blueprint get destroyed so that they
// don't invalidate other tests that share the same dependencies
return !bDiffsFound;
}
int32 UFixupRedirectsCommandlet::Main( const FString& Params )
{
// Retrieve list of all packages in .ini paths.
TArray<FString> PackageList;
FEditorFileUtils::FindAllPackageFiles(PackageList);
if( !PackageList.Num() )
{
return 0;
}
// process the commandline
FString Token;
const TCHAR* CommandLine = *Params;
bool bIsQuietMode = false;
bool bIsTestOnly = false;
bool bShouldRestoreProgress= false;
bool bIsSCCDisabled = false;
bool bUpdateEnginePackages = false;
bool bDeleteRedirects = true;
bool bDeleteOnlyReferencedRedirects = false;
bool bAutoSubmit = false;
bool bSandboxed = IFileManager::Get().IsSandboxEnabled();
while (FParse::Token(CommandLine, Token, 1))
{
if (Token == TEXT("-nowarn"))
{
bIsQuietMode = true;
}
else if (Token == TEXT("-testonly"))
{
bIsTestOnly = true;
}
else if (Token == TEXT("-restore"))
{
bShouldRestoreProgress = true;
}
else if (Token == TEXT("-NoAutoCheckout"))
{
bIsSCCDisabled = true;
}
else if (Token == TEXT("-AutoSubmit"))
{
bAutoSubmit = true;
}
else if (Token == TEXT("-UpdateEnginePackages"))
{
bUpdateEnginePackages = true;
}
else if (Token == TEXT("-NoDelete"))
{
bDeleteRedirects = false;
}
else if (Token == TEXT("-NoDeleteUnreferenced"))
{
bDeleteOnlyReferencedRedirects = true;
}
else if ( Token.Left(1) != TEXT("-") )
{
FPackageName::SearchForPackageOnDisk(Token, &GRedirectCollector.FileToFixup);
}
}
if (bSandboxed)
{
UE_LOG(LogFixupRedirectsCommandlet, Display, TEXT("Running in a sandbox."));
bIsSCCDisabled = true;
bAutoSubmit = false;
bDeleteRedirects = false;
}
bool bShouldSkipErrors = false;
// Setup file Output log in the Saved Directory
const FString ProjectDir = FPaths::GetPath(FPaths::GetProjectFilePath());
const FString LogFilename = FPaths::Combine(*ProjectDir, TEXT("Saved"), TEXT("FixupRedirect"), TEXT("FixupRedirect.log"));
FArchive* LogOutputFile = IFileManager::Get().CreateFileWriter(*LogFilename);
LogOutputFile->Logf(TEXT("[Redirects]"));
/////////////////////////////////////////////////////////////////////
// Display any script code referenced redirects
/////////////////////////////////////////////////////////////////////
TArray<FString> UpdatePackages;
TArray<FString> RedirectorsThatCantBeCleaned;
if (!bShouldRestoreProgress)
{
// load all string asset reference targets, and add fake redirectors for them
GRedirectCollector.ResolveStringAssetReference();
for (int32 RedirIndex = 0; RedirIndex < GRedirectCollector.Redirections.Num(); RedirIndex++)
{
FRedirection& Redir = GRedirectCollector.Redirections[RedirIndex];
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("Boot redirector can't be cleaned: %s(%s) -> %s(%s)"), *Redir.RedirectorName, *Redir.RedirectorPackageFilename, *Redir.DestinationObjectName, *Redir.PackageFilename);
RedirectorsThatCantBeCleaned.AddUnique(Redir.RedirectorName);
}
/////////////////////////////////////////////////////////////////////
// Build a list of packages that need to be updated
/////////////////////////////////////////////////////////////////////
SET_WARN_COLOR(COLOR_WHITE);
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT(""));
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("Generating list of tasks:"));
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("-------------------------"));
CLEAR_WARN_COLOR();
int32 GCIndex = 0;
// process script code first pass, then everything else
for( int32 PackageIndex = 0; PackageIndex < PackageList.Num(); PackageIndex++ )
{
const FString& Filename = PackageList[PackageIndex];
// already loaded code, skip them, and skip autosave packages
if (Filename.StartsWith(AutoSaveUtils::GetAutoSaveDir(), ESearchCase::IgnoreCase))
{
continue;
}
UE_LOG(LogFixupRedirectsCommandlet, Display, TEXT("Looking for redirects in %s..."), *Filename);
// Assert if package couldn't be opened so we have no chance of messing up saving later packages.
UPackage* Package = Cast<UPackage>(LoadPackage(NULL, *Filename, 0));
// load all string asset reference targets, and add fake redirectors for them
GRedirectCollector.ResolveStringAssetReference();
if (!Package)
{
SET_WARN_COLOR(COLOR_RED);
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT(" ... failed to open %s"), *Filename);
CLEAR_WARN_COLOR();
// if we are not in quiet mode, and the user wants to continue, go on
const FText Message = FText::Format( NSLOCTEXT("Unreal", "PackageFailedToOpen", "The package '{0}' failed to open. Should this commandlet continue operation, ignoring further load errors? Continuing may have adverse effects (object references may be lost)."), FText::FromString( Filename ) );
if (bShouldSkipErrors || (!bIsQuietMode && GWarn->YesNof( Message )))
{
bShouldSkipErrors = true;
continue;
}
else
{
return 1;
}
}
// all notices here about redirects get this color
SET_WARN_COLOR(COLOR_DARK_GREEN);
// look for any redirects that were followed that are referenced by this package
// (may have been loaded earlier if this package was loaded by script code)
// any redirectors referenced by script code can't be cleaned up
for (int32 RedirIndex = 0; RedirIndex < GRedirectCollector.Redirections.Num(); RedirIndex++)
{
FRedirection& Redir = GRedirectCollector.Redirections[RedirIndex];
if (Redir.PackageFilename == Filename)
{
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT(" ... references %s [-> %s]"), *Redir.RedirectorName, *Redir.DestinationObjectName);
// put the source and dest packages in the list to be updated
UpdatePackages.AddUnique(Redir.PackageFilename);
UpdatePackages.AddUnique(Redir.RedirectorPackageFilename);
}
}
// clear the flag for needing to collect garbage
bool bNeedToCollectGarbage = false;
// if this package has any redirectors, make sure we update it
if (!GRedirectCollector.FileToFixup.Len() || GRedirectCollector.FileToFixup == FPackageName::FilenameToLongPackageName(Filename))
{
TArray<UObject *> ObjectsInOuter;
GetObjectsWithOuter(Package, ObjectsInOuter);
for( int32 Index = 0; Index < ObjectsInOuter.Num(); Index++ )
{
UObject* Obj = ObjectsInOuter[Index];
UObjectRedirector* Redir = Cast<UObjectRedirector>(Obj);
if (Redir)
{
// make sure this package is in the list of packages to update
UpdatePackages.AddUnique(Filename);
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT(" ... has redirect %s [-> %s]"), *Redir->GetPathName(), *Redir->DestinationObject->GetFullName());
LogOutputFile->Logf(TEXT("%s = %s"), *Redir->GetPathName(), *Redir->DestinationObject->GetFullName());
// make sure we GC if we found a redirector
bNeedToCollectGarbage = true;
}
}
}
CLEAR_WARN_COLOR();
// collect garbage every N packages, or if there was any redirectors in the package
// (to make sure that redirectors get reloaded properly and followed by the callback)
// also, GC after loading a map package, to make sure it's unloaded so that we can track
// other packages loading a map package as a dependency
if (((++GCIndex) % 50) == 0 || bNeedToCollectGarbage || Package->ContainsMap())
{
// collect garbage to close the package
CollectGarbage(RF_Native);
UE_LOG(LogFixupRedirectsCommandlet, Display, TEXT("GC..."));
// reset our counter
GCIndex = 0;
}
}
// save off restore point
FArchive* Ar = IFileManager::Get().CreateFileWriter(*(FPaths::GameSavedDir() + TEXT("Fixup.bin")));
*Ar << GRedirectCollector.Redirections;
*Ar << UpdatePackages;
*Ar << RedirectorsThatCantBeCleaned;
delete Ar;
}
else
{
// load restore point
FArchive* Ar = IFileManager::Get().CreateFileReader(*(FPaths::GameSavedDir() + TEXT("Fixup.bin")));
if( Ar != NULL )
{
*Ar << GRedirectCollector.Redirections;
*Ar << UpdatePackages;
*Ar << RedirectorsThatCantBeCleaned;
delete Ar;
}
}
// unregister the callback so we stop getting redirections added
FCoreUObjectDelegates::RedirectorFollowed.RemoveAll(&GRedirectCollector);
/////////////////////////////////////////////////////////////////////
// Explain to user what is happening
/////////////////////////////////////////////////////////////////////
SET_WARN_COLOR(COLOR_YELLOW);
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT(""));
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("Files that need to fixed up:"));
SET_WARN_COLOR(COLOR_DARK_YELLOW);
// print out the working set of packages
for (int32 PackageIndex = 0; PackageIndex < UpdatePackages.Num(); PackageIndex++)
{
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT(" %s"), *UpdatePackages[PackageIndex]);
}
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT(""));
CLEAR_WARN_COLOR();
// if we are only testing, just just quiet before actually doing anything
if (bIsTestOnly)
{
LogOutputFile->Close();
delete LogOutputFile;
LogOutputFile = NULL;
return 0;
}
/////////////////////////////////////////////////////////////////////
// Find redirectors that are referenced by packages we cant check out
/////////////////////////////////////////////////////////////////////
bool bEngineRedirectorCantBeCleaned = false;
ISourceControlProvider& SourceControlProvider = ISourceControlModule::Get().GetProvider();
// initialize source control if it hasn't been initialized yet
if(!bIsSCCDisabled)
{
SourceControlProvider.Init();
//Make sure we can check out all packages - update their state first
SourceControlProvider.Execute(ISourceControlOperation::Create<FUpdateStatus>(), UpdatePackages);
}
for( int32 PackageIndex = 0; PackageIndex < UpdatePackages.Num(); PackageIndex++ )
{
const FString& Filename = UpdatePackages[PackageIndex];
bool bCanEdit = true;
if(!bIsSCCDisabled)
{
FSourceControlStatePtr SourceControlState = SourceControlProvider.GetState(Filename, EStateCacheUsage::ForceUpdate);
if(SourceControlState.IsValid() && !SourceControlState->CanEdit())
{
bCanEdit = false;
}
}
else if(IFileManager::Get().IsReadOnly(*Filename))
{
bCanEdit = false;
}
if(!bCanEdit)
{
const bool bAllowCheckout = bUpdateEnginePackages || !Filename.StartsWith( FPaths::EngineDir() );
if (!bIsSCCDisabled && bAllowCheckout)
{
FString PackageName(FPackageName::FilenameToLongPackageName(Filename));
FSourceControlStatePtr SourceControlState = SourceControlProvider.GetState(Filename, EStateCacheUsage::ForceUpdate);
if (SourceControlState.IsValid() && SourceControlState->CanCheckout())
{
SourceControlProvider.Execute(ISourceControlOperation::Create<FCheckOut>(), SourceControlHelpers::PackageFilename(PackageName));
FSourceControlStatePtr NewSourceControlState = SourceControlProvider.GetState(Filename, EStateCacheUsage::ForceUpdate);
bCanEdit = NewSourceControlState.IsValid() && NewSourceControlState->CanEdit();
}
}
// if the checkout failed for any reason, we can't clean it up
if (bAllowCheckout && !bCanEdit)
{
SET_WARN_COLOR(COLOR_RED);
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("Couldn't check out/edit %s..."), *Filename);
CLEAR_WARN_COLOR();
// load all string asset reference targets, and add fake redirectors for them
GRedirectCollector.ResolveStringAssetReference();
// any redirectors that are pointed to by this read-only package can't be fixed up
for (int32 RedirIndex = 0; RedirIndex < GRedirectCollector.Redirections.Num(); RedirIndex++)
{
FRedirection& Redir = GRedirectCollector.Redirections[RedirIndex];
// any redirectors pointed to by this file we don't clean
if (Redir.PackageFilename == Filename)
{
RedirectorsThatCantBeCleaned.AddUnique(Redir.RedirectorName);
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT(" ... can't fixup references to %s"), *Redir.RedirectorName);
// if this redirector is in an Engine package, we need to alert the user, because
// Engine packages are shared between games, so if one game still needs the redirector
// to be valid, then we can't check in Engine packages after another game has
// run that could
if (!bEngineRedirectorCantBeCleaned)
{
FString PackagePath;
FPackageName::DoesPackageExist(Redir.RedirectorPackageFilename, NULL, &PackagePath);
if (PackagePath.StartsWith(FPaths::EngineDir()))
{
bEngineRedirectorCantBeCleaned = true;
}
}
}
// any redirectors in this file can't be deleted
else if (Redir.RedirectorPackageFilename == Filename)
{
RedirectorsThatCantBeCleaned.AddUnique(Redir.RedirectorName);
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT(" ... can't delete %s"), *Redir.RedirectorName);
}
}
}
else
{
SET_WARN_COLOR(COLOR_DARK_GREEN);
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("Checked out %s..."), *Filename);
CLEAR_WARN_COLOR();
}
}
}
// warn about an engine package that can't be cleaned up (may want to revert engine packages)
if (bEngineRedirectorCantBeCleaned)
{
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT(""));
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("Engine package redirectors are referenced by packages that can't be cleaned. If you have multiple games, it's recommended you revert any checked out Engine packages."));
bUpdateEnginePackages=false;
}
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT(""));
/////////////////////////////////////////////////////////////////////
// Load and save packages to save out the proper fixed up references
/////////////////////////////////////////////////////////////////////
SET_WARN_COLOR(COLOR_WHITE);
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("Fixing references to point to proper objects:"));
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("---------------------------------------------"));
CLEAR_WARN_COLOR();
// keep a list of all packages that have ObjectRedirects in them. This is not needed if we aren't deleting redirects
TArray<bool> PackagesWithRedirects;
// Delete these packages entirely because they are empty
TArray<bool> EmptyPackagesToDelete;
if ( bDeleteRedirects )
{
PackagesWithRedirects.AddZeroed(UpdatePackages.Num());
EmptyPackagesToDelete.AddZeroed(PackageList.Num());
}
bool bSCCEnabled = ISourceControlModule::Get().IsEnabled();
// Iterate over all packages, loading and saving to remove all references to ObjectRedirectors (can't delete the Redirects yet)
for( int32 PackageIndex = 0; PackageIndex < UpdatePackages.Num(); PackageIndex++ )
{
const FString& Filename = UpdatePackages[PackageIndex];
// we can't do anything with packages that are read-only or cant be edited due to source control (we don't want to fixup the redirects)
if(bSCCEnabled)
{
FSourceControlStatePtr SourceControlState = SourceControlProvider.GetState(SourceControlHelpers::PackageFilename(Filename), EStateCacheUsage::ForceUpdate);
if(SourceControlState.IsValid() && !SourceControlState->CanEdit())
{
continue;
}
}
else if(IFileManager::Get().IsReadOnly(*Filename))
{
continue;
}
// Assert if package couldn't be opened so we have no chance of messing up saving later packages.
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("Cleaning %s"), *Filename);
UPackage* Package = LoadPackage( NULL, *Filename, LOAD_NoVerify );
// load all string asset reference targets, and add fake redirectors for them
GRedirectCollector.ResolveStringAssetReference();
// if it failed to open, we have already dealt with quitting if we are going to, so just skip it
if (!Package)
{
continue;
}
if ( bDeleteOnlyReferencedRedirects && bDeleteRedirects )
{
TArray<UObject *> ObjectsInOuter;
GetObjectsWithOuter(Package, ObjectsInOuter);
for( int32 Index = 0; Index < ObjectsInOuter.Num(); Index++ )
{
UObject* Obj = ObjectsInOuter[Index];
UObjectRedirector* Redir = Cast<UObjectRedirector>(Obj);
if (Redir)
{
PackagesWithRedirects[PackageIndex] = 1;
break;
}
}
}
// Don't save packages in the engine directory if we did not opt to update engine packages
if( bUpdateEnginePackages || !Filename.StartsWith( FPaths::EngineDir() ) )
{
// save out the package
UWorld* World = UWorld::FindWorldInPackage(Package);
GEditor->SavePackage( Package, World, World ? RF_NoFlags : RF_Standalone, *Filename, GWarn );
}
// collect garbage to close the package
UE_LOG(LogFixupRedirectsCommandlet, Display, TEXT("Collecting Garbage..."));
CollectGarbage(RF_Native);
}
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT(""));
if ( bDeleteRedirects )
{
/////////////////////////////////////////////////////////////////////
// Delete all redirects that are no longer referenced
/////////////////////////////////////////////////////////////////////
SET_WARN_COLOR(COLOR_WHITE);
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("Deleting redirector objects:"));
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("----------------------------"));
CLEAR_WARN_COLOR();
const TArray<FString>& PackagesToCleaseOfRedirects = bDeleteOnlyReferencedRedirects ? UpdatePackages : PackageList;
int32 GCIndex = 0;
// Again, iterate over all packages, loading and saving to and this time deleting all
for( int32 PackageIndex = 0; PackageIndex < PackagesToCleaseOfRedirects.Num(); PackageIndex++ )
{
const FString& Filename = PackagesToCleaseOfRedirects[PackageIndex];
if (bDeleteOnlyReferencedRedirects && PackagesWithRedirects[PackageIndex] == 0)
{
continue;
}
// The file should have already been checked out/be writable
// If it is read only that means the checkout failed or we are not using source control and we can not write this file.
if(bSCCEnabled)
{
FSourceControlStatePtr SourceControlState = SourceControlProvider.GetState(SourceControlHelpers::PackageFilename(Filename), EStateCacheUsage::ForceUpdate);
if(SourceControlState.IsValid() && !SourceControlState->CanEdit())
{
UE_LOG(LogFixupRedirectsCommandlet, Display, TEXT("Skipping file: source control says we cant edit the file %s..."), *Filename);
continue;
}
}
else if( IFileManager::Get().IsReadOnly( *Filename ))
{
UE_LOG(LogFixupRedirectsCommandlet, Display, TEXT("Skipping read-only file %s..."), *Filename);
continue;
}
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("Wiping %s..."), *Filename);
UPackage* Package = LoadPackage( NULL, *Filename, 0 );
// load all string asset reference targets, and add fake redirectors for them
GRedirectCollector.ResolveStringAssetReference();
// if it failed to open, we have already dealt with quitting if we are going to, so just skip it
if (!Package)
{
continue;
}
// assume that all redirs in this file are still-referenced
bool bIsDirty = false;
// see if this package is completely empty other than purged redirectors and metadata
bool bIsEmpty = true;
// delete all ObjectRedirects now
TArray<UObjectRedirector*> Redirs;
// find all redirectors, put into an array so delete doesn't mess up the iterator
TArray<UObject *> ObjectsInOuter;
GetObjectsWithOuter(Package, ObjectsInOuter);
for( int32 Index = 0; Index < ObjectsInOuter.Num(); Index++ )
{
UObject* Obj = ObjectsInOuter[Index];
UObjectRedirector *Redir = Cast<UObjectRedirector>(Obj);
if (Redir)
{
int32 Dummy;
// if the redirector was marked as uncleanable, skip it
if (RedirectorsThatCantBeCleaned.Find(Redir->GetFullName(), Dummy))
{
SET_WARN_COLOR(COLOR_DARK_RED);
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT(" ... skipping still-referenced %s"), *Redir->GetFullName());
CLEAR_WARN_COLOR();
bIsEmpty = false;
continue;
}
bIsDirty = true;
SET_WARN_COLOR(COLOR_DARK_GREEN);
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT(" ... deleting %s"), *Redir->GetFullName());
CLEAR_WARN_COLOR();
Redirs.Add(Redir);
}
else if ( (!Obj->IsA(UMetaData::StaticClass()) && !Obj->IsA(UField::StaticClass()))
|| Obj->IsA(UUserDefinedEnum::StaticClass())) // UserDefinedEnum should not be deleted
{
// This package has a real object
bIsEmpty = false;
}
}
if (bIsEmpty && !bDeleteOnlyReferencedRedirects)
{
EmptyPackagesToDelete[PackageIndex] = 1;
}
// mark them for deletion.
for (int32 RedirIndex = 0; RedirIndex < Redirs.Num(); RedirIndex++)
{
UObjectRedirector* Redirector = Redirs[RedirIndex];
// Remove standalone flag and mark as pending kill.
Redirector->ClearFlags( RF_Standalone | RF_Public );
// We don't need redirectors in the root set, the references should already be fixed up
if ( Redirector->IsRooted() )
{
Redirector->RemoveFromRoot();
}
Redirector->MarkPendingKill();
}
Redirs.Empty();
if (bIsDirty)
{
// Don't save packages in the engine directory if we did not opt to update engine packages
if( bUpdateEnginePackages || !Filename.StartsWith( FPaths::EngineDir() ) )
{
// save the package
UWorld* World = UWorld::FindWorldInPackage(Package);
GEditor->SavePackage( Package, World, World ? RF_NoFlags : RF_Standalone, *Filename, GWarn );
}
}
// collect garbage every N packages, or if there was any redirectors in the package
if (((++GCIndex) % 50) == 0 || bIsDirty || Package->ContainsMap())
{
// collect garbage to close the package
CollectGarbage(RF_Native);
UE_LOG(LogFixupRedirectsCommandlet, Display, TEXT("GC..."));
// reset our counter
GCIndex = 0;
}
}
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT(""));
}
else
{
SET_WARN_COLOR(COLOR_WHITE);
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("----------------------------"));
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("Not deleting any redirector objects:"));
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("----------------------------"));
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT(""));
CLEAR_WARN_COLOR();
}
/////////////////////////////////////////////////////////////////////
// Clean up any unused trash
/////////////////////////////////////////////////////////////////////
SET_WARN_COLOR(COLOR_WHITE);
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("Deleting empty and unused packages:"));
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("---------------------------------------"));
CLEAR_WARN_COLOR();
LogOutputFile->Logf(TEXT(""));
LogOutputFile->Logf(TEXT("[Deleted]"));
// Iterate over packages, attempting to delete unreferenced packages
for( int32 PackageIndex = 0; PackageIndex < PackageList.Num(); PackageIndex++ )
{
bool bDelete = false;
const FString& Filename = PackageList[PackageIndex];
FString PackageName(FPackageName::FilenameToLongPackageName(Filename));
const bool bAllowDelete = bUpdateEnginePackages || !Filename.StartsWith( FPaths::EngineDir() );
if (bDeleteRedirects && !bDeleteOnlyReferencedRedirects && EmptyPackagesToDelete[PackageIndex] && bAllowDelete)
{
// this package is completely empty, delete it
bDelete = true;
}
if (bDelete == true)
{
struct Local
{
static bool DeleteFromDisk(const FString& InFilename, const FString& InMessage)
{
SET_WARN_COLOR(COLOR_GREEN);
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("%s"), *InMessage);
if (!IFileManager::Get().Delete(*InFilename, false, true))
{
SET_WARN_COLOR(COLOR_RED);
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT(" ... failed to delete from disk."), *InFilename);
CLEAR_WARN_COLOR();
return false;
}
CLEAR_WARN_COLOR();
return true;
}
};
if (!bIsSCCDisabled)
{
// get file SCC status
FString FileName = SourceControlHelpers::PackageFilename(PackageName);
FSourceControlStatePtr SourceControlState = SourceControlProvider.GetState(FileName, EStateCacheUsage::ForceUpdate);
if(SourceControlState.IsValid() && (SourceControlState->IsCheckedOut() || SourceControlState->IsAdded()) )
{
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("Revert '%s' from source control..."), *Filename);
SourceControlProvider.Execute(ISourceControlOperation::Create<FRevert>(), FileName);
SET_WARN_COLOR(COLOR_GREEN);
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("Deleting '%s' from source control..."), *Filename);
CLEAR_WARN_COLOR();
SourceControlProvider.Execute(ISourceControlOperation::Create<FDelete>(), FileName);
}
else if(SourceControlState.IsValid() && SourceControlState->CanCheckout())
{
SET_WARN_COLOR(COLOR_GREEN);
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("Deleting '%s' from source control..."), *Filename);
CLEAR_WARN_COLOR();
SourceControlProvider.Execute(ISourceControlOperation::Create<FDelete>(), FileName);
}
else if(SourceControlState.IsValid() && SourceControlState->IsCheckedOutOther())
{
SET_WARN_COLOR(COLOR_RED);
UE_LOG(LogFixupRedirectsCommandlet, Warning, TEXT("Couldn't delete '%s' from source control, someone has it checked out, skipping..."), *Filename);
CLEAR_WARN_COLOR();
}
else if(SourceControlState.IsValid() && !SourceControlState->IsSourceControlled())
{
if(Local::DeleteFromDisk(Filename, FString::Printf(TEXT("'%s' is not in source control, attempting to delete from disk..."), *Filename)))
{
LogOutputFile->Logf(*Filename);
}
}
else
{
if(Local::DeleteFromDisk(Filename, FString::Printf(TEXT("'%s' is in an unknown source control state, attempting to delete from disk..."), *Filename)))
{
LogOutputFile->Logf(*Filename);
}
}
}
else
{
if(Local::DeleteFromDisk(Filename, FString::Printf(TEXT("source control disabled while deleting '%s', attempting to delete from disk..."), *Filename)))
{
LogOutputFile->Logf(*Filename);
}
}
}
}
LogOutputFile->Close();
delete LogOutputFile;
LogOutputFile = NULL;
if (!bIsSCCDisabled && bAutoSubmit)
{
/////////////////////////////////////////////////////////////////////
// Submit the results to source control
/////////////////////////////////////////////////////////////////////
UE_LOG(LogFixupRedirectsCommandlet, Display, TEXT("Submiting the results to source control"));
// Work out the list of file to check in
TArray <FString> FilesToSubmit;
for( int32 PackageIndex = 0; PackageIndex < PackageList.Num(); PackageIndex++ )
{
const FString& Filename = PackageList[PackageIndex];
FString PackageName(FPackageName::FilenameToLongPackageName(Filename));
FSourceControlStatePtr SourceControlState = SourceControlProvider.GetState(SourceControlHelpers::PackageFilename(Filename), EStateCacheUsage::ForceUpdate);
if( SourceControlState.IsValid() && (SourceControlState->IsCheckedOut() || SourceControlState->IsAdded() || SourceControlState->IsDeleted()) )
{
// Only submit engine packages if we're requested to
if( bUpdateEnginePackages || !Filename.StartsWith( FPaths::EngineDir() ) )
{
FilesToSubmit.Add(*PackageName);
}
}
}
// Check in all changed files
const FText Description = NSLOCTEXT("FixupRedirectsCmdlet", "ChangelistDescription", "Fixed up Redirects");
TSharedRef<FCheckIn, ESPMode::ThreadSafe> CheckInOperation = ISourceControlOperation::Create<FCheckIn>();
CheckInOperation->SetDescription( Description );
SourceControlProvider.Execute(CheckInOperation, SourceControlHelpers::PackageFilenames(FilesToSubmit));
// toss the SCC manager
ISourceControlModule::Get().GetProvider().Close();
}
return 0;
}
void UActorComponent::PostEditUndo()
{
// Objects marked pending kill don't call PostEditChange() from UObject::PostEditUndo(),
// so they can leave an EditReregisterContexts entry around if they are deleted by an undo action.
if( IsPendingKill() )
{
// The reregister context won't bother attaching components that are 'pending kill'.
FComponentReregisterContext* ReregisterContext = nullptr;
if (EditReregisterContexts.RemoveAndCopyValue(this, ReregisterContext))
{
delete ReregisterContext;
}
else
{
// This means there are likely some stale elements left in there now, strip them out
for (auto It(EditReregisterContexts.CreateIterator()); It; ++It)
{
if (!It.Key().IsValid())
{
It.RemoveCurrent();
}
}
}
}
else
{
bIsBeingDestroyed = false;
Owner = GetTypedOuter<AActor>();
bCanUseCachedOwner = true;
// Let the component be properly registered, after it was restored.
if (Owner)
{
Owner->AddOwnedComponent(this);
}
TArray<UObject*> Children;
GetObjectsWithOuter(this, Children);
for (UObject* Child : Children)
{
if (UActorComponent* ChildComponent = Cast<UActorComponent>(Child))
{
if (ChildComponent->Owner)
{
ChildComponent->Owner->RemoveOwnedComponent(ChildComponent);
}
ChildComponent->Owner = Owner;
if (Owner)
{
Owner->AddOwnedComponent(ChildComponent);
}
}
}
if (GetWorld())
{
GetWorld()->UpdateActorComponentEndOfFrameUpdateState(this);
}
}
Super::PostEditUndo();
}
void UEnvironmentQueryGraph::RemoveOrphanedNodes()
{
UEnvQuery* QueryAsset = CastChecked<UEnvQuery>(GetOuter());
// Obtain a list of all nodes that should be in the asset
TSet<UObject*> AllNodes;
for (int32 Index = 0; Index < Nodes.Num(); ++Index)
{
UEnvironmentQueryGraphNode_Option* OptionNode = Cast<UEnvironmentQueryGraphNode_Option>(Nodes[Index]);
if (OptionNode)
{
UEnvQueryOption* OptionInstance = Cast<UEnvQueryOption>(OptionNode->NodeInstance);
if (OptionInstance)
{
AllNodes.Add(OptionInstance);
if (OptionInstance->Generator)
{
AllNodes.Add(OptionInstance->Generator);
}
}
for (int32 SubIdx = 0; SubIdx < OptionNode->Tests.Num(); SubIdx++)
{
if (OptionNode->Tests[SubIdx] && OptionNode->Tests[SubIdx]->NodeInstance)
{
AllNodes.Add(OptionNode->Tests[SubIdx]->NodeInstance);
}
}
}
}
// Obtain a list of all nodes actually in the asset and discard unused nodes
TArray<UObject*> AllInners;
const bool bIncludeNestedObjects = false;
GetObjectsWithOuter(QueryAsset, AllInners, bIncludeNestedObjects);
for (auto InnerIt = AllInners.CreateConstIterator(); InnerIt; ++InnerIt)
{
UObject* Node = *InnerIt;
const bool bEQSNode =
Node->IsA(UEnvQueryGenerator::StaticClass()) ||
Node->IsA(UEnvQueryTest::StaticClass()) ||
Node->IsA(UEnvQueryOption::StaticClass());
if (bEQSNode && !AllNodes.Contains(Node))
{
Node->SetFlags(RF_Transient);
Node->Rename(NULL, GetTransientPackage(), REN_DontCreateRedirectors | REN_NonTransactional | REN_ForceNoResetLoaders);
}
}
}
