void ULevelStreaming::AsyncLevelLoadComplete(const FName& InPackageName, UPackage* InLoadedPackage, EAsyncLoadingResult::Type Result)
{
bHasLoadRequestPending = false;
if( InLoadedPackage )
{
UPackage* LevelPackage = InLoadedPackage;
// Try to find a UWorld object in the level package.
UWorld* World = UWorld::FindWorldInPackage(LevelPackage);
if ( World )
{
ULevel* Level = World->PersistentLevel;
if( Level )
{
check(PendingUnloadLevel == NULL);
SetLoadedLevel(Level);
// Broadcast level loaded event to blueprints
OnLevelLoaded.Broadcast(this);
// Make sure this level will start to render only when it will be fully added to the world
if (LODPackageNames.Num() > 0)
{
Level->bRequireFullVisibilityToRender = true;
// LOD levels should not be visible on server
Level->bClientOnlyVisible = LODPackageNames.Contains(InLoadedPackage->GetFName());
}
// In the editor levels must be in the levels array regardless of whether they are visible or not
if (ensure(Level->OwningWorld) && Level->OwningWorld->WorldType == EWorldType::Editor)
{
Level->OwningWorld->AddLevel(Level);
#if WITH_EDITOR
// We should also at this point, apply the level's editor transform
if (!Level->bAlreadyMovedActors)
{
FLevelUtils::ApplyEditorTransform(this, false);
Level->bAlreadyMovedActors = true;
}
#endif // WITH_EDITOR
}
}
else
{
UE_LOG(LogLevelStreaming, Warning, TEXT("Couldn't find ULevel object in package '%s'"), *InPackageName.ToString() );
}
}
else
{
// There could have been a redirector in the package. Attempt to follow it.
UObjectRedirector* WorldRedirector = nullptr;
UWorld* DestinationWorld = UWorld::FollowWorldRedirectorInPackage(LevelPackage, &WorldRedirector);
if (DestinationWorld)
{
// To follow the world redirector for level streaming...
// 1) Update all globals that refer to the redirector package by name
// 2) Update the PackageNameToLoad to refer to the new package location
// 3) If the package name to load was the same as the destination package name...
// ... update the package name to the new package and let the next RequestLevel try this process again.
// If the package name to load was different...
// ... it means the specified package name was explicit and we will just load from another file.
FName OldDesiredPackageName = InPackageName;
TWeakObjectPtr<UWorld>* OwningWorldPtr = ULevel::StreamedLevelsOwningWorld.Find(OldDesiredPackageName);
UWorld* OwningWorld = OwningWorldPtr ? OwningWorldPtr->Get() : NULL;
ULevel::StreamedLevelsOwningWorld.Remove(OldDesiredPackageName);
// Try again with the destination package to load.
// IMPORTANT: check this BEFORE changing PackageNameToLoad, otherwise you wont know if the package name was supposed to be different.
const bool bLoadingIntoDifferentPackage = (GetWorldAssetPackageFName() != PackageNameToLoad) && (PackageNameToLoad != NAME_None);
// ... now set PackageNameToLoad
PackageNameToLoad = DestinationWorld->GetOutermost()->GetFName();
if ( PackageNameToLoad != OldDesiredPackageName )
{
EWorldType::Type* OldPackageWorldType = UWorld::WorldTypePreLoadMap.Find(OldDesiredPackageName);
if ( OldPackageWorldType )
{
UWorld::WorldTypePreLoadMap.FindOrAdd(PackageNameToLoad) = *OldPackageWorldType;
UWorld::WorldTypePreLoadMap.Remove(OldDesiredPackageName);
}
}
// Now determine if we are loading into the package explicitly or if it is okay to just load the other package.
if ( bLoadingIntoDifferentPackage )
{
// Loading into a new custom package explicitly. Load the destination world directly into the package.
// Detach the linker to load from a new file into the same package.
FLinkerLoad* PackageLinker = FLinkerLoad::FindExistingLinkerForPackage(LevelPackage);
if (PackageLinker)
{
PackageLinker->Detach();
DeleteLoader(PackageLinker);
PackageLinker = nullptr;
}
// Make sure the redirector is not in the way of the new world.
// Pass NULL as the name to make a new unique name and GetTransientPackage() for the outer to remove it from the package.
WorldRedirector->Rename(NULL, GetTransientPackage(), REN_DoNotDirty | REN_DontCreateRedirectors | REN_ForceNoResetLoaders | REN_NonTransactional);
// Change the loaded world's type back to inactive since it won't be used.
DestinationWorld->WorldType = EWorldType::Inactive;
}
else
{
// Loading the requested package normally. Fix up the destination world then update the requested package to the destination.
if (OwningWorld)
{
if (DestinationWorld->PersistentLevel)
{
DestinationWorld->PersistentLevel->OwningWorld = OwningWorld;
}
// In some cases, BSP render data is not created because the OwningWorld was not set correctly.
// Regenerate that render data here
DestinationWorld->PersistentLevel->InvalidateModelSurface();
DestinationWorld->PersistentLevel->CommitModelSurfaces();
}
WorldAsset = DestinationWorld;
}
}
}
}
else if (Result == EAsyncLoadingResult::Canceled)
{
// Cancel level streaming
bHasLoadRequestPending = false;
bShouldBeLoaded = false;
}
else
{
UE_LOG(LogLevelStreaming, Warning, TEXT("Failed to load package '%s'"), *InPackageName.ToString() );
}
// Clean up the world type list and owning world list now that PostLoad has occurred
UWorld::WorldTypePreLoadMap.Remove(InPackageName);
ULevel::StreamedLevelsOwningWorld.Remove(InPackageName);
STAT_ADD_CUSTOMMESSAGE_NAME( STAT_NamedMarker, *(FString( TEXT( "RequestLevelComplete - " ) + InPackageName.ToString() )) );
}
