File size: 6,802 Bytes
7fd553e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 | // Copyright Epic Games, Inc. All Rights Reserved.
#include "EditorValidator_Load.h"
#include "AssetCompilingManager.h"
#include "Engine/Engine.h"
#include "Engine/World.h"
#include "HAL/FileManager.h"
#include "Kismet2/BlueprintEditorUtils.h"
#include "Kismet2/KismetEditorUtilities.h"
#include "Misc/PackageName.h"
#include "Misc/Paths.h"
#include "Validation/EditorValidator.h"
#include UE_INLINE_GENERATED_CPP_BY_NAME(EditorValidator_Load)
#define LOCTEXT_NAMESPACE "EditorValidator"
// This list only ignores log messages that occur while we are reloading an asset that is already in memory
// Should only be used for warnings that occur as a result of having the asset in memory in two different packages
TArray<FString> UEditorValidator_Load::InMemoryReloadLogIgnoreList = { TEXT("Enum name collision: '") };
UEditorValidator_Load::UEditorValidator_Load()
: Super()
{
}
bool UEditorValidator_Load::IsEnabled() const
{
// Commandlets do not need this validation step as they loaded the content while running.
return !IsRunningCommandlet() && Super::IsEnabled();
}
bool UEditorValidator_Load::CanValidateAsset_Implementation(const FAssetData& InAssetData, UObject* InAsset, FDataValidationContext& InContext) const
{
return Super::CanValidateAsset_Implementation(InAsset) && InAsset != nullptr;
}
EDataValidationResult UEditorValidator_Load::ValidateLoadedAsset_Implementation(const FAssetData& InAssetData, UObject* InAsset, FDataValidationContext& Context)
{
check(InAsset);
TArray<FString> WarningsAndErrors;
if (GetLoadWarningsAndErrorsForPackage(InAsset->GetOutermost()->GetName(), WarningsAndErrors))
{
for (const FString& WarningOrError : WarningsAndErrors)
{
AssetFails(InAsset, FText::FromString(WarningOrError));
}
}
else
{
AssetFails(InAsset, LOCTEXT("Load_FailedLoad", "Failed to get package load warnings and errors"));
}
if (GetValidationResult() != EDataValidationResult::Invalid)
{
AssetPasses(InAsset);
}
return GetValidationResult();
}
bool UEditorValidator_Load::GetLoadWarningsAndErrorsForPackage(const FString& PackageName, TArray<FString>& OutWarningsAndErrors)
{
check(!PackageName.IsEmpty());
check(GEngine);
UPackage* const ExistingPackage = FindPackage(nullptr, *PackageName);
if (ExistingPackage == GetTransientPackage())
{
return true;
}
// Skip World or External Actor packages
if (ExistingPackage && UWorld::IsWorldOrWorldExternalPackage(ExistingPackage))
{
return true;
}
// Commandlets shouldnt load the temporary packages since it involves collecting garbage and may destroy objects higher in the callstack. Loading it the one time is probably good enough
// Also since commandlets dont use RF_Standalone, this could greatly increase commandlet execution time when loading the same assets over and over
if (ExistingPackage && !IsRunningCommandlet() && UEditorValidator::ShouldAllowFullValidation() && !ExistingPackage->ContainsMap() && !PackageName.EndsWith(TEXT("_BuiltData")))
{
// Copy the asset file to the temp directory and load it
const FString& SrcPackageName = PackageName;
FString SrcFilename;
const bool bSourceFileExists = FPackageName::DoesPackageExist(SrcPackageName, &SrcFilename);
if (bSourceFileExists)
{
static int32 PackageIdentifier = 0;
FString DestPackageName = FString::Printf(TEXT("/Temp/%s_%d"), *FPackageName::GetLongPackageAssetName(ExistingPackage->GetName()), PackageIdentifier++);
FString DestFilename = FPackageName::LongPackageNameToFilename(DestPackageName, FPaths::GetExtension(SrcFilename, true));
uint32 CopyResult = IFileManager::Get().Copy(*DestFilename, *SrcFilename);
if (ensure(CopyResult == COPY_OK))
{
// Gather all warnings and errors during the process to determine return value
UPackage* LoadedPackage = nullptr;
{
FLyraValidationMessageGatherer::AddIgnorePatterns(InMemoryReloadLogIgnoreList);
FLyraValidationMessageGatherer ScopedMessageGatherer;
// If we are loading a blueprint, compile the original and load the duplicate with DisableCompileOnLoad, since BPs loaded on the side may not compile if there are circular references involving self
int32 LoadFlags = LOAD_ForDiff;
{
TArray<UObject*> AllExistingObjects;
GetObjectsWithPackage(ExistingPackage, AllExistingObjects, false);
TArray<UBlueprint*> AllNonDOBPs;
for (UObject* Obj : AllExistingObjects)
{
UBlueprint* BP = Cast<UBlueprint>(Obj);
if (BP && !FBlueprintEditorUtils::IsDataOnlyBlueprint(BP))
{
AllNonDOBPs.Add(BP);
}
}
if (AllNonDOBPs.Num() > 0)
{
LoadFlags |= LOAD_DisableCompileOnLoad;
for (UBlueprint* BP : AllNonDOBPs)
{
check(BP);
FKismetEditorUtilities::CompileBlueprint(BP);
}
}
}
LoadedPackage = LoadPackage(NULL, *DestPackageName, LoadFlags);
// Make sure what we just loaded has finish compiling otherwise we won't be able
// to reset loaders for the package or verify if errors have been emitted.
FAssetCompilingManager::Get().FinishAllCompilation();
for (const FString& LoadWarningOrError : ScopedMessageGatherer.GetAllWarningsAndErrors())
{
FString SanitizedMessage = LoadWarningOrError.Replace(*DestFilename, *SrcFilename);
SanitizedMessage = SanitizedMessage.Replace(*DestPackageName, *SrcPackageName);
OutWarningsAndErrors.Add(SanitizedMessage);
}
FLyraValidationMessageGatherer::RemoveIgnorePatterns(InMemoryReloadLogIgnoreList);
}
if (LoadedPackage)
{
ResetLoaders(LoadedPackage);
IFileManager::Get().Delete(*DestFilename);
TArray<UObject*> AllLoadedObjects;
GetObjectsWithPackage(LoadedPackage, AllLoadedObjects, true);
for (UObject* Obj : AllLoadedObjects)
{
if (Obj->IsRooted())
{
continue;
}
Obj->ClearFlags(RF_Public | RF_Standalone);
Obj->SetFlags(RF_Transient);
if (UWorld* WorldToDestroy = Cast<UWorld>(Obj))
{
WorldToDestroy->DestroyWorld(true);
}
Obj->MarkAsGarbage();
}
GEngine->ForceGarbageCollection(true);
}
}
else
{
// Failed to copy the file to the temp folder
return false;
}
}
else
{
// It was in memory but not yet saved probably (no source file)
return false;
}
}
else
{
// Not in memory, just load it
FLyraValidationMessageGatherer ScopedMessageGatherer;
LoadPackage(nullptr, *PackageName, LOAD_None);
OutWarningsAndErrors = ScopedMessageGatherer.GetAllWarningsAndErrors();
}
return true;
}
#undef LOCTEXT_NAMESPACE
|