// Copyright Epic Games, Inc. All Rights Reserved.

/*=============================================================================
EditorLevelUtils.cpp: Editor-specific level management routines
=============================================================================*/

#include "EditorLevelUtils.h"
#include "Misc/MessageDialog.h"
#include "Misc/ScopedSlowTask.h"
#include "UObject/GarbageCollection.h"
#include "UObject/Class.h"
#include "UObject/Package.h"
#include "Engine/EngineTypes.h"
#include "GameFramework/Actor.h"
#include "Engine/World.h"
#include "Model.h"
#include "Engine/Brush.h"
#include "Editor/EditorEngine.h"
#include "Editor/UnrealEdEngine.h"
#include "Factories/WorldFactory.h"
#include "Editor/GroupActor.h"
#include "EngineGlobals.h"
#include "UObject/UObjectHash.h"
#include "UObject/UObjectIterator.h"
#include "UObject/ReferenceChainSearch.h"
#include "GameFramework/WorldSettings.h"
#include "Engine/LevelStreaming.h"
#include "Engine/Selection.h"
#include "Editor.h"
#include "EditorModeManager.h"
#include "EditorModes.h"
#include "FileHelpers.h"
#include "UnrealEdGlobals.h"
#include "EditorSupportDelegates.h"

#include "BusyCursor.h"
#include "LevelUtils.h"
#include "Layers/LayersSubsystem.h"

#include "ScopedTransaction.h"
#include "ActorEditorUtils.h"
#include "ContentStreaming.h"
#include "PackageTools.h"

#include "AssetRegistryModule.h"
#include "Engine/LevelStreamingVolume.h"
#include "Components/ModelComponent.h"
#include "Misc/RuntimeErrors.h"
#include "HAL/PlatformApplicationMisc.h"
#include "HAL/IConsoleManager.h"
#include "IAssetTools.h"
#include "AssetToolsModule.h"
#include "Dialogs/Dialogs.h"

DEFINE_LOG_CATEGORY(LogLevelTools);

#define LOCTEXT_NAMESPACE "EditorLevelUtils"

static TAutoConsoleVariable<int32> CVarReflectEditorLevelVisibilityWithGame(
    TEXT("Editor.ReflectEditorLevelVisibilityWithGame"),
    0,
    TEXT("Enables the transaction of game visibility state when editor visibility state changes.\n")
        TEXT("0 - game state is *not* reflected with editor.\n")
            TEXT("1 - game state is relfected with editor.\n"),
    ECVF_Default);

int32 UEditorLevelUtils::MoveActorsToLevel(const TArray<AActor*>& ActorsToMove, ULevelStreaming* DestStreamingLevel, bool bWarnAboutReferences, bool bWarnAboutRenaming)
{
    return MoveActorsToLevel(ActorsToMove, DestStreamingLevel ? DestStreamingLevel->GetLoadedLevel() : nullptr, bWarnAboutReferences, bWarnAboutRenaming);
}

int32 UEditorLevelUtils::MoveActorsToLevel(const TArray<AActor*>& ActorsToMove, ULevel* DestLevel, bool bWarnAboutReferences, bool bWarnAboutRenaming)
{
    int32 NumMovedActors = 0;

    if (DestLevel)
    {
        UWorld* OwningWorld = DestLevel->OwningWorld;

        // Backup the current contents of the clipboard string as we'll be using cut/paste features to move actors
        // between levels and this will trample over the clipboard data.
        FString OriginalClipboardContent;
        FPlatformApplicationMisc::ClipboardPaste(OriginalClipboardContent);

        // The final list of actors to move after invalid actors were removed
        TArray<AActor*> FinalMoveList;
        FinalMoveList.Reserve(ActorsToMove.Num());

        bool bIsDestLevelLocked = FLevelUtils::IsLevelLocked(DestLevel);
        if (!bIsDestLevelLocked)
        {
            for (AActor* CurActor: ActorsToMove)
            {
                if (!CurActor)
                {
                    continue;
                }

                bool bIsSourceLevelLocked = FLevelUtils::IsLevelLocked(CurActor);

                if (!bIsSourceLevelLocked)
                {
                    if (CurActor->GetLevel() != DestLevel)
                    {
                        FinalMoveList.Add(CurActor);
                    }
                    else
                    {
                        UE_LOG(LogLevelTools, Warning, TEXT("%s is already in the destination level so it was ignored"), *CurActor->GetName());
                    }
                }
                else
                {
                    UE_LOG(LogLevelTools, Error, TEXT("The source level '%s' is locked so actors could not be moved"), *CurActor->GetLevel()->GetName());
                }
            }
        }
        else
        {
            UE_LOG(LogLevelTools, Error, TEXT("The destination level '%s' is locked so actors could not be moved"), *DestLevel->GetName());
        }

        if (FinalMoveList.Num() > 0)
        {
            TMap<FSoftObjectPath, FSoftObjectPath> ActorPathMapping;
            GEditor->SelectNone(false, true, false);

            USelection* ActorSelection = GEditor->GetSelectedActors();
            ActorSelection->BeginBatchSelectOperation();
            for (AActor* Actor: FinalMoveList)
            {
                ActorPathMapping.Add(FSoftObjectPath(Actor), FSoftObjectPath());
                GEditor->SelectActor(Actor, true, false);
            }
            ActorSelection->EndBatchSelectOperation(false);

            if (GEditor->GetSelectedActorCount() > 0)
            {
                // Start the transaction
                FScopedTransaction Transaction(NSLOCTEXT("UnrealEd", "MoveSelectedActorsToSelectedLevel", "Move Actors To Level"));

                // Cache the old level
                ULevel* OldCurrentLevel = OwningWorld->GetCurrentLevel();

                // We are moving the actors so cut them to remove them from the existing level
                const bool bShoudCut = true;
                const bool bIsMove   = true;
                GEditor->CopySelectedActorsToClipboard(OwningWorld, bShoudCut, bIsMove, bWarnAboutReferences);

                const bool bLevelVisible = DestLevel->bIsVisible;
                if (!bLevelVisible)
                {
                    UEditorLevelUtils::SetLevelVisibility(DestLevel, true, false);
                }

                // Scope this so that Actors that have been pasted will have their final levels set before doing the actor mapping
                {
                    // Set the new level and force it visible while we do the paste
                    FLevelPartitionOperationScope LevelPartitionScope(DestLevel);
                    OwningWorld->SetCurrentLevel(LevelPartitionScope.GetLevel());

                    const bool bDuplicate       = false;
                    const bool bOffsetLocations = false;
                    const bool bWarnIfHidden    = false;
                    GEditor->edactPasteSelected(OwningWorld, bDuplicate, bOffsetLocations, bWarnIfHidden);

                    // Restore the original current level
                    OwningWorld->SetCurrentLevel(OldCurrentLevel);
                }

                // Build a remapping of old to new names so we can do a fixup
                for (FSelectionIterator It(GEditor->GetSelectedActorIterator()); It; ++It)
                {
                    AActor* Actor           = static_cast<AActor*>(*It);
                    FSoftObjectPath NewPath = FSoftObjectPath(Actor);

                    bool bFoundMatch        = false;

                    // First try exact match
                    for (TPair<FSoftObjectPath, FSoftObjectPath>& Pair: ActorPathMapping)
                    {
                        if (Pair.Value.IsNull() && NewPath.GetSubPathString() == Pair.Key.GetSubPathString())
                        {
                            bFoundMatch = true;
                            Pair.Value  = NewPath;
                            break;
                        }
                    }

                    if (!bFoundMatch)
                    {
                        // Remove numbers from end as it may have had to add some to disambiguate
                        FString PartialPath = NewPath.GetSubPathString();
                        int32 IgnoreNumber;
                        FActorLabelUtilities::SplitActorLabel(PartialPath, IgnoreNumber);

                        for (TPair<FSoftObjectPath, FSoftObjectPath>& Pair: ActorPathMapping)
                        {
                            if (Pair.Value.IsNull())
                            {
                                FString KeyPartialPath = Pair.Key.GetSubPathString();
                                FActorLabelUtilities::SplitActorLabel(KeyPartialPath, IgnoreNumber);
                                if (PartialPath == KeyPartialPath)
                                {
                                    bFoundMatch = true;
                                    Pair.Value  = NewPath;
                                    break;
                                }
                            }
                        }
                    }

                    if (!bFoundMatch)
                    {
                        UE_LOG(LogLevelTools, Error, TEXT("Cannot find remapping for moved actor ID %s, any soft references pointing to it will be broken!"), *Actor->GetPathName());
                    }
                }

                FAssetToolsModule& AssetToolsModule = FModuleManager::GetModuleChecked<FAssetToolsModule>(TEXT("AssetTools"));
                TArray<FAssetRenameData> RenameData;

                for (TPair<FSoftObjectPath, FSoftObjectPath>& Pair: ActorPathMapping)
                {
                    if (Pair.Value.IsValid())
                    {
                        RenameData.Add(FAssetRenameData(Pair.Key, Pair.Value, true));
                    }
                }

                if (RenameData.Num() > 0)
                {
                    if (bWarnAboutRenaming)
                    {
                        AssetToolsModule.Get().RenameAssetsWithDialog(RenameData);
                    }
                    else
                    {
                        AssetToolsModule.Get().RenameAssets(RenameData);
                    }
                }

                // Restore new level visibility to previous state
                if (!bLevelVisible)
                {
                    UEditorLevelUtils::SetLevelVisibility(DestLevel, false, false);
                }
            }

            // The moved (pasted) actors will now be selected
            NumMovedActors += FinalMoveList.Num();
        }

        // Restore the original clipboard contents
        FPlatformApplicationMisc::ClipboardCopy(*OriginalClipboardContent);
    }

    return NumMovedActors;
}

int32 UEditorLevelUtils::MoveSelectedActorsToLevel(ULevelStreaming* DestStreamingLevel, bool bWarnAboutReferences)
{
    ensureAsRuntimeWarning(DestStreamingLevel != nullptr);
    return DestStreamingLevel ? MoveSelectedActorsToLevel(DestStreamingLevel->GetLoadedLevel(), bWarnAboutReferences) : 0;
}

int32 UEditorLevelUtils::MoveSelectedActorsToLevel(ULevel* DestLevel, bool bWarnAboutReferences)
{
    if (ensureAsRuntimeWarning(DestLevel != nullptr))
    {
        TArray<AActor*> ActorsToMove;
        for (FSelectionIterator It(GEditor->GetSelectedActorIterator()); It; ++It)
        {
            if (AActor* Actor = Cast<AActor>(*It))
            {
                ActorsToMove.Add(Actor);
            }
        }

        return MoveActorsToLevel(ActorsToMove, DestLevel, bWarnAboutReferences);
    }

    return 0;
}

ULevel* UEditorLevelUtils::AddLevelsToWorld(UWorld* InWorld, TArray<FString> PackageNames, TSubclassOf<ULevelStreaming> LevelStreamingClass)
{
    if (!ensure(InWorld))
    {
        return nullptr;
    }

    FScopedSlowTask SlowTask(PackageNames.Num(), LOCTEXT("AddLevelsToWorldTask", "Adding Levels to World"));
    SlowTask.MakeDialog();

    // Sort the level packages alphabetically by name.
    PackageNames.Sort();

    // Fire ULevel::LevelDirtiedEvent when falling out of scope.
    FScopedLevelDirtied LevelDirtyCallback;

    // Try to add the levels that were specified in the dialog.
    ULevel* NewLevel = nullptr;
    for (const FString& PackageName: PackageNames)
    {
        SlowTask.EnterProgressFrame();

        if (ULevelStreaming* NewStreamingLevel = AddLevelToWorld_Internal(InWorld, *PackageName, LevelStreamingClass))
        {
            NewLevel = NewStreamingLevel->GetLoadedLevel();
            if (NewLevel)
            {
                LevelDirtyCallback.Request();
            }
        }
    }  // for each file

    // Set the last loaded level to be the current level
    if (NewLevel)
    {
        if (InWorld->SetCurrentLevel(NewLevel))
        {
            FEditorDelegates::NewCurrentLevel.Broadcast();
        }
    }

    // For safety
    if (GLevelEditorModeTools().IsModeActive(FBuiltinEditorModes::EM_Landscape))
    {
        GLevelEditorModeTools().ActivateDefaultMode();
    }

    // Broadcast the levels have changed (new style)
    InWorld->BroadcastLevelsChanged();
    FEditorDelegates::RefreshLevelBrowser.Broadcast();

    // Update volume actor visibility for each viewport since we loaded a level which could potentially contain volumes
    if (GUnrealEd)
    {
        GUnrealEd->UpdateVolumeActorVisibility(nullptr);
    }

    return NewLevel;
}

ULevelStreaming* UEditorLevelUtils::AddLevelToWorld(UWorld* InWorld, const TCHAR* LevelPackageName, TSubclassOf<ULevelStreaming> LevelStreamingClass, const FTransform& LevelTransform)
{
    if (!ensure(InWorld))
    {
        return nullptr;
    }

    FScopedSlowTask SlowTask(0, LOCTEXT("AddLevelToWorldTask", "Adding Level to World"));
    SlowTask.MakeDialog();

    // Fire ULevel::LevelDirtiedEvent when falling out of scope.
    FScopedLevelDirtied LevelDirtyCallback;

    // Try to add the levels that were specified in the dialog.
    ULevel* NewLevel                   = nullptr;

    ULevelStreaming* NewStreamingLevel = AddLevelToWorld_Internal(InWorld, LevelPackageName, LevelStreamingClass, LevelTransform);

    // Broadcast the levels have changed (new style)
    InWorld->BroadcastLevelsChanged();
    FEditorDelegates::RefreshLevelBrowser.Broadcast();

    if (NewStreamingLevel)
    {
        NewLevel = NewStreamingLevel->GetLoadedLevel();
        if (NewLevel)
        {
            LevelDirtyCallback.Request();

            // Set the loaded level to be the current level
            if (InWorld->SetCurrentLevel(NewLevel))
            {
                FEditorDelegates::NewCurrentLevel.Broadcast();
            }
        }
    }

    // For safety
    if (GLevelEditorModeTools().IsModeActive(FBuiltinEditorModes::EM_Landscape))
    {
        GLevelEditorModeTools().ActivateDefaultMode();
    }

    // Update volume actor visibility for each viewport since we loaded a level which could potentially contain volumes
    if (GUnrealEd)
    {
        GUnrealEd->UpdateVolumeActorVisibility(nullptr);
    }

    return NewStreamingLevel;
}

ULevelStreaming* UEditorLevelUtils::AddLevelToWorld_Internal(UWorld* InWorld, const TCHAR* LevelPackageName, TSubclassOf<ULevelStreaming> LevelStreamingClass, const FTransform& LevelTransform)
{
    ULevel* NewLevel                = nullptr;
    ULevelStreaming* StreamingLevel = nullptr;
    bool bIsPersistentLevel         = (InWorld->PersistentLevel->GetOutermost()->GetName() == FString(LevelPackageName));

    if (bIsPersistentLevel || FLevelUtils::FindStreamingLevel(InWorld, LevelPackageName))
    {
        // Do nothing if the level already exists in the world.
        const FString LevelName(LevelPackageName);
        const FText MessageText = FText::Format(NSLOCTEXT("UnrealEd", "LevelAlreadyExistsInWorld", "A level with that name ({0}) already exists in the world."), FText::FromString(LevelName));

        FSuppressableWarningDialog::FSetupInfo Info(MessageText, LOCTEXT("AddLevelToWorld_Title", "Add Level"), "LevelAlreadyExistsInWorldWarning");
        Info.ConfirmText = LOCTEXT("AlreadyExist_Ok", "Ok");
        FSuppressableWarningDialog RemoveLevelWarning(Info);
        RemoveLevelWarning.ShowModal();
    }
    else
    {
        // If the selected class is still NULL or the selected class is abstract, abort the operation.
        if (LevelStreamingClass == nullptr || LevelStreamingClass->HasAnyClassFlags(CLASS_Abstract))
        {
            return nullptr;
        }

        const FScopedBusyCursor BusyCursor;

        StreamingLevel = NewObject<ULevelStreaming>(InWorld, LevelStreamingClass, NAME_None, RF_NoFlags, NULL);

        // Associate a package name.
        StreamingLevel->SetWorldAssetByPackageName(LevelPackageName);

        StreamingLevel->LevelTransform = LevelTransform;

        // Seed the level's draw color.
        StreamingLevel->LevelColor = FLinearColor::MakeRandomColor();

        // Add the new level to world.
        InWorld->AddStreamingLevel(StreamingLevel);

        // Refresh just the newly created level.
        TArray<ULevelStreaming*> LevelsForRefresh;
        LevelsForRefresh.Add(StreamingLevel);
        InWorld->RefreshStreamingLevels(LevelsForRefresh);
        InWorld->MarkPackageDirty();

        NewLevel = StreamingLevel->GetLoadedLevel();
        if (NewLevel != nullptr)
        {
            EditorLevelUtils::SetLevelVisibility(NewLevel, true, true);

            // Levels migrated from other projects may fail to load their world settings
            // If so we create a new AWorldSettings actor here.
            if (NewLevel->GetWorldSettings(false) == nullptr)
            {
                UWorld* SubLevelWorld = CastChecked<UWorld>(NewLevel->GetOuter());

                FActorSpawnParameters SpawnInfo;
                SpawnInfo.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
                SpawnInfo.Name                           = GEngine->WorldSettingsClass->GetFName();
                AWorldSettings* NewWorldSettings         = SubLevelWorld->SpawnActor<AWorldSettings>(GEngine->WorldSettingsClass, SpawnInfo);

                NewLevel->SetWorldSettings(NewWorldSettings);
            }
        }
    }

    if (NewLevel)  // if the level was successfully added
    {
        FEditorDelegates::OnAddLevelToWorld.Broadcast(NewLevel);
    }

    return StreamingLevel;
}

ULevelStreaming* UEditorLevelUtils::SetStreamingClassForLevel(ULevelStreaming* InLevel, TSubclassOf<ULevelStreaming> LevelStreamingClass)
{
    check(InLevel);

    const FScopedBusyCursor BusyCursor;

    // Cache off the package name, as it will be lost when unloading the level
    const FName CachedPackageName = InLevel->GetWorldAssetPackageFName();

    // First hide and remove the level if it exists
    ULevel* Level = InLevel->GetLoadedLevel();
    check(Level);
    SetLevelVisibility(Level, false, false);
    check(Level->OwningWorld);
    UWorld* World = Level->OwningWorld;

    World->RemoveStreamingLevel(InLevel);

    // re-add the level with the desired streaming class
    AddLevelToWorld(World, *(CachedPackageName.ToString()), LevelStreamingClass);

    // Transfer level streaming settings
    ULevelStreaming* NewStreamingLevel = FLevelUtils::FindStreamingLevel(Level);
    if (NewStreamingLevel)
    {
        NewStreamingLevel->LevelTransform                     = InLevel->LevelTransform;
        NewStreamingLevel->EditorStreamingVolumes             = InLevel->EditorStreamingVolumes;
        NewStreamingLevel->MinTimeBetweenVolumeUnloadRequests = InLevel->MinTimeBetweenVolumeUnloadRequests;
        NewStreamingLevel->LevelColor                         = InLevel->LevelColor;
        NewStreamingLevel->Keywords                           = InLevel->Keywords;
        NewStreamingLevel->SetFolderPath(InLevel->GetFolderPath());
    }

    return NewStreamingLevel;
}

void UEditorLevelUtils::MakeLevelCurrent(ULevel* InLevel, bool bEvenIfLocked)
{
    if (ensureAsRuntimeWarning(InLevel != nullptr))
    {
        // Locked levels can't be made current.
        if (bEvenIfLocked || !FLevelUtils::IsLevelLocked(InLevel))
        {
            // Make current broadcast if it changed
            if (InLevel->OwningWorld->SetCurrentLevel(InLevel))
            {
                FEditorDelegates::NewCurrentLevel.Broadcast();
            }

            // Deselect all selected builder brushes.
            bool bDeselectedSomething = false;
            for (FSelectionIterator It(GEditor->GetSelectedActorIterator()); It; ++It)
            {
                AActor* Actor = static_cast<AActor*>(*It);
                checkSlow(Actor->IsA(AActor::StaticClass()));
                ABrush* Brush = Cast<ABrush>(Actor);
                if (Brush && FActorEditorUtils::IsABuilderBrush(Actor))
                {
                    GEditor->SelectActor(Actor, /*bInSelected=*/false, /*bNotify=*/false);
                    bDeselectedSomething = true;
                }
            }

            // Send a selection change callback if necessary.
            if (bDeselectedSomething)
            {
                GEditor->NoteSelectionChange();
            }

            // Force the current level to be visible.
            SetLevelVisibility(InLevel, true, false);
        }
        else
        {
            FMessageDialog::Open(EAppMsgType::Ok, NSLOCTEXT("UnrealEd", "Error_OperationDisallowedOnLockedLevelMakeLevelCurrent", "MakeLevelCurrent: The requested operation could not be completed because the level is locked."));
        }
    }
}

void UEditorLevelUtils::MakeLevelCurrent(ULevelStreaming* InStreamingLevel)
{
    if (ensureAsRuntimeWarning(InStreamingLevel != nullptr))
    {
        MakeLevelCurrent(InStreamingLevel->GetLoadedLevel());
    }
}

bool UEditorLevelUtils::PrivateRemoveInvalidLevelFromWorld(ULevelStreaming* InLevelStreaming)
{
    bool bRemovedLevelStreaming = false;
    if (InLevelStreaming)
    {
        check(InLevelStreaming->GetLoadedLevel() == NULL);  // This method is designed to be used to remove left over references to null levels

        InLevelStreaming->Modify();

        // Disassociate the level from the volume.
        for (ALevelStreamingVolume* LevelStreamingVolume: InLevelStreaming->EditorStreamingVolumes)
        {
            if (LevelStreamingVolume)
            {
                LevelStreamingVolume->Modify();
                LevelStreamingVolume->StreamingLevelNames.Remove(InLevelStreaming->GetWorldAssetPackageFName());
            }
        }

        // Disassociate the volumes from the level.
        InLevelStreaming->EditorStreamingVolumes.Empty();

        if (UWorld* OwningWorld = InLevelStreaming->GetWorld())
        {
            OwningWorld->RemoveStreamingLevel(InLevelStreaming);
            OwningWorld->RefreshStreamingLevels({});
            bRemovedLevelStreaming = true;
        }
    }
    return bRemovedLevelStreaming;
}

bool UEditorLevelUtils::RemoveInvalidLevelFromWorld(ULevelStreaming* InLevelStreaming)
{
    bool bRemoveSuccessful = PrivateRemoveInvalidLevelFromWorld(InLevelStreaming);
    if (bRemoveSuccessful)
    {
        // Redraw the main editor viewports.
        FEditorSupportDelegates::RedrawAllViewports.Broadcast();

        // Broadcast the levels have changed (new style)
        InLevelStreaming->GetWorld()->BroadcastLevelsChanged();
        FEditorDelegates::RefreshLevelBrowser.Broadcast();

        // Update selection for any selected actors that were in the level and are no longer valid
        GEditor->NoteSelectionChange();

        // Collect garbage to clear out the destroyed level
        CollectGarbage(GARBAGE_COLLECTION_KEEPFLAGS);
    }
    return bRemoveSuccessful;
}

ULevelStreaming* UEditorLevelUtils::CreateNewStreamingLevel(TSubclassOf<ULevelStreaming> LevelStreamingClass, const FString& PackagePath /*= TEXT("")*/, bool bMoveSelectedActorsIntoNewLevel /*= false*/)
{
    FString Filename;
    if (PackagePath.IsEmpty() || FPackageName::TryConvertLongPackageNameToFilename(PackagePath, Filename, FPackageName::GetMapPackageExtension()))
    {
        if (ensureAsRuntimeWarning(LevelStreamingClass.Get() != nullptr))
        {
            return CreateNewStreamingLevelForWorld(*GEditor->GetEditorWorldContext().World(), LevelStreamingClass, Filename, bMoveSelectedActorsIntoNewLevel);
        }
    }

    return nullptr;
}

ULevelStreaming* UEditorLevelUtils::CreateNewStreamingLevelForWorld(UWorld& InWorld, TSubclassOf<ULevelStreaming> LevelStreamingClass, const FString& DefaultFilename /* = TEXT( "" ) */, bool bMoveSelectedActorsIntoNewLevel /* = false */, UWorld* InTemplateWorld /* = nullptr */)
{
    // Editor modes cannot be active when any level saving occurs.
    GLevelEditorModeTools().DeactivateAllModes();

    // This is the world we are adding the new level to
    UWorld* WorldToAddLevelTo = &InWorld;

    // This is the new streaming level's world not the persistent level world
    UWorld* NewLevelWorld  = nullptr;
    bool bNewWorldSaved    = false;
    FString NewPackageName = DefaultFilename;

    if (InTemplateWorld)
    {
        // Copy and save the new world to disk.
        bNewWorldSaved = FEditorFileUtils::SaveLevelAs(InTemplateWorld->PersistentLevel, &NewPackageName);
        if (bNewWorldSaved && !NewPackageName.IsEmpty())
        {
            NewPackageName       = FPackageName::FilenameToLongPackageName(NewPackageName);
            UPackage* NewPackage = LoadPackage(nullptr, *NewPackageName, LOAD_None);
            if (NewPackage)
            {
                NewLevelWorld = UWorld::FindWorldInPackage(NewPackage);
            }
        }
    }
    else
    {
        // Create a new world
        UWorldFactory* Factory = NewObject<UWorldFactory>();
        Factory->WorldType     = EWorldType::Inactive;
        UPackage* Pkg          = CreatePackage(NULL);
        FName WorldName(TEXT("Untitled"));
        EObjectFlags Flags = RF_Public | RF_Standalone;
        NewLevelWorld      = CastChecked<UWorld>(Factory->FactoryCreateNew(UWorld::StaticClass(), Pkg, WorldName, Flags, NULL, GWarn));
        if (NewLevelWorld)
        {
            FAssetRegistryModule::AssetCreated(NewLevelWorld);
        }

        // Save the new world to disk.
        bNewWorldSaved = FEditorFileUtils::SaveLevel(NewLevelWorld->PersistentLevel, DefaultFilename);
        if (bNewWorldSaved)
        {
            NewPackageName = NewLevelWorld->GetOutermost()->GetName();
        }
    }

    // If the new world was saved successfully, import it as a streaming level.
    ULevelStreaming* NewStreamingLevel = nullptr;
    ULevel* NewLevel                   = nullptr;
    if (bNewWorldSaved)
    {
        NewStreamingLevel = AddLevelToWorld(WorldToAddLevelTo, *NewPackageName, LevelStreamingClass);
        if (NewStreamingLevel != nullptr)
        {
            NewLevel = NewStreamingLevel->GetLoadedLevel();
            // If we are moving the selected actors to the new level move them now
            if (bMoveSelectedActorsIntoNewLevel)
            {
                MoveSelectedActorsToLevel(NewStreamingLevel);
            }

            // Finally make the new level the current one
            if (WorldToAddLevelTo->SetCurrentLevel(NewLevel))
            {
                FEditorDelegates::NewCurrentLevel.Broadcast();
            }
        }
    }

    // Broadcast the levels have changed (new style)
    WorldToAddLevelTo->BroadcastLevelsChanged();
    FEditorDelegates::RefreshLevelBrowser.Broadcast();

    return NewStreamingLevel;
}

bool UEditorLevelUtils::RemoveLevelFromWorld(ULevel* InLevel)
{
    ULayersSubsystem* Layers = GEditor->GetEditorSubsystem<ULayersSubsystem>();
    Layers->RemoveLevelLayerInformation(InLevel);

    GEditor->CloseEditedWorldAssets(CastChecked<UWorld>(InLevel->GetOuter()));

    UWorld* OwningWorld              = InLevel->OwningWorld;
    const FName LevelPackageName     = InLevel->GetOutermost()->GetFName();
    const bool bRemovingCurrentLevel = InLevel->IsCurrentLevel();
    const bool bRemoveSuccessful     = PrivateRemoveLevelFromWorld(InLevel);
    if (bRemoveSuccessful)
    {
        if (bRemovingCurrentLevel)
        {
            // we must set a new level.  It must succeed
            bool bEvenIfLocked = true;
            MakeLevelCurrent(OwningWorld->PersistentLevel, bEvenIfLocked);
        }

        FEditorSupportDelegates::PrepareToCleanseEditorObject.Broadcast(InLevel);

        if (GEditor->Trans != nullptr)
        {
            GEditor->Trans->Reset(LOCTEXT("RemoveLevelTransReset", "Removing Levels from World"));
        }

        EditorDestroyLevel(InLevel);

        // Redraw the main editor viewports.
        FEditorSupportDelegates::RedrawAllViewports.Broadcast();

        // Broadcast the levels have changed (new style)
        OwningWorld->BroadcastLevelsChanged();
        FEditorDelegates::RefreshLevelBrowser.Broadcast();

        // Reset transaction buffer and run GC to clear out the destroyed level
        GEditor->Cleanse(true, false, LOCTEXT("RemoveLevelTransReset", "Removing Levels from World"));

        // Ensure that world was removed
        UPackage* LevelPackage = FindObjectFast<UPackage>(NULL, LevelPackageName);
        if (LevelPackage != nullptr)
        {
            UWorld* TheWorld = UWorld::FindWorldInPackage(LevelPackage->GetOutermost());
            if (TheWorld != nullptr)
            {
                FReferenceChainSearch RefChainSearch(TheWorld, EReferenceChainSearchMode::Shortest | EReferenceChainSearchMode::PrintResults);
                UE_LOG(LogStreaming, Fatal, TEXT("Removed world %s not cleaned up by garbage collection! Referenced by:") LINE_TERMINATOR TEXT("%s"), *TheWorld->GetPathName(), *RefChainSearch.GetRootPath());
            }
        }
    }
    return bRemoveSuccessful;
}

bool UEditorLevelUtils::PrivateRemoveLevelFromWorld(ULevel* InLevel)
{
    if (!InLevel || InLevel->IsPersistentLevel())
    {
        return false;
    }

    if (FLevelUtils::IsLevelLocked(InLevel))
    {
        FMessageDialog::Open(EAppMsgType::Ok, NSLOCTEXT("UnrealEd", "Error_OperationDisallowedOnLockedLevelRemoveLevelFromWorld", "RemoveLevelFromWorld: The requested operation could not be completed because the level is locked."));
        return false;
    }

    int32 StreamingLevelIndex = INDEX_NONE;

    for (int32 LevelIndex = 0; LevelIndex < InLevel->OwningWorld->GetStreamingLevels().Num(); ++LevelIndex)
    {
        ULevelStreaming* StreamingLevel = InLevel->OwningWorld->GetStreamingLevels()[LevelIndex];
        if (StreamingLevel && StreamingLevel->GetLoadedLevel() == InLevel)
        {
            StreamingLevelIndex = LevelIndex;
            break;
        }
    }

    if (StreamingLevelIndex != INDEX_NONE)
    {
        ULevelStreaming* StreamingLevel = InLevel->OwningWorld->GetStreamingLevels()[StreamingLevelIndex];
        StreamingLevel->MarkPendingKill();
        InLevel->OwningWorld->RemoveStreamingLevel(StreamingLevel);
        InLevel->OwningWorld->RefreshStreamingLevels({});
    }
    else if (InLevel->bIsVisible)
    {
        InLevel->OwningWorld->RemoveFromWorld(InLevel);
        check(InLevel->bIsVisible == false);
    }

    InLevel->ReleaseRenderingResources();

    IStreamingManager::Get().RemoveLevel(InLevel);
    UWorld* World = InLevel->OwningWorld;
    World->RemoveLevel(InLevel);
    if (InLevel->bIsLightingScenario)
    {
        World->PropagateLightingScenarioChange();
    }
    InLevel->ClearLevelComponents();

    // remove all group actors from the world in the level we are removing
    // otherwise, this will cause group actors to not be garbage collected
    for (int32 GroupIndex = World->ActiveGroupActors.Num() - 1; GroupIndex >= 0; --GroupIndex)
    {
        AGroupActor* GroupActor = Cast<AGroupActor>(World->ActiveGroupActors[GroupIndex]);
        if (GroupActor && GroupActor->IsInLevel(InLevel))
        {
            World->ActiveGroupActors.RemoveAt(GroupIndex);
        }
    }

    // Mark all model components as pending kill so GC deletes references to them.
    for (UModelComponent* ModelComponent: InLevel->ModelComponents)
    {
        if (ModelComponent != nullptr)
        {
            ModelComponent->MarkPendingKill();
        }
    }

    // Mark all actors and their components as pending kill so GC will delete references to them.
    for (AActor* Actor: InLevel->Actors)
    {
        if (Actor != nullptr)
        {
            Actor->MarkComponentsAsPendingKill();
            Actor->MarkPendingKill();
        }
    }

    World->MarkPackageDirty();
    World->BroadcastLevelsChanged();

    return true;
}

bool UEditorLevelUtils::EditorDestroyLevel(ULevel* InLevel)
{
    UWorld* World  = InLevel->OwningWorld;

    UObject* Outer = InLevel->GetOuter();

    // Call cleanup on the outer world of the level so external hooks can be properly released, so that unloading the package isn't prevented.
    UWorld* OuterWorld = Cast<UWorld>(Outer);
    if (OuterWorld && OuterWorld != World)
    {
        OuterWorld->CleanupWorld();
    }

    Outer->MarkPendingKill();
    InLevel->MarkPendingKill();
    Outer->ClearFlags(RF_Public | RF_Standalone);

    UPackage* Package = InLevel->GetOutermost();
    // We want to unconditionally destroy the level, so clear the dirty flag here so it can be unloaded successfully
    Package->SetDirtyFlag(false);

    TArray<UPackage*> Packages;
    Packages.Add(Package);
    if (!UPackageTools::UnloadPackages(Packages))
    {
        FFormatNamedArguments Args;
        Args.Add(TEXT("Package"), FText::FromString(Package->GetName()));
        FMessageDialog::Open(EAppMsgType::Ok, FText::Format(LOCTEXT("UnloadPackagesFail", "Unable to unload package '{Package}'."), Args));
        return false;
    }

    return true;
}

ULevel* UEditorLevelUtils::CreateNewLevel(UWorld* InWorld, bool bMoveSelectedActorsIntoNewLevel, TSubclassOf<ULevelStreaming> LevelStreamingClass, const FString& DefaultFilename)
{
    ULevelStreaming* StreamingLevel = CreateNewStreamingLevelForWorld(*InWorld, LevelStreamingClass, DefaultFilename, bMoveSelectedActorsIntoNewLevel);
    return StreamingLevel->GetLoadedLevel();
}

void UEditorLevelUtils::DeselectAllSurfacesInLevel(ULevel* InLevel)
{
    if (InLevel)
    {
        UModel* Model = InLevel->Model;
        for (int32 SurfaceIndex = 0; SurfaceIndex < Model->Surfs.Num(); ++SurfaceIndex)
        {
            FBspSurf& Surf = Model->Surfs[SurfaceIndex];
            if (Surf.PolyFlags & PF_Selected)
            {
                Model->ModifySurf(SurfaceIndex, false);
                Surf.PolyFlags &= ~PF_Selected;
            }
        }
    }
}

void UEditorLevelUtils::SetLevelVisibilityTemporarily(ULevel* Level, bool bShouldBeVisible)
{
    // Nothing to do
    if (Level == NULL)
    {
        return;
    }

    // Set the visibility of each actor in the p-level
    for (TArray<AActor*>::TIterator ActorIter(Level->Actors); ActorIter; ++ActorIter)
    {
        AActor* CurActor = *ActorIter;
        if (CurActor && !FActorEditorUtils::IsABuilderBrush(CurActor) && CurActor->bHiddenEdLevel == bShouldBeVisible)
        {
            CurActor->bHiddenEdLevel = !bShouldBeVisible;
            CurActor->MarkComponentsRenderStateDirty();
        }
    }

    // Set the visibility of each BSP surface in the p-level
    UModel* CurLevelModel = Level->Model;
    if (CurLevelModel)
    {
        for (TArray<FBspSurf>::TIterator SurfaceIterator(CurLevelModel->Surfs); SurfaceIterator; ++SurfaceIterator)
        {
            FBspSurf& CurSurf      = *SurfaceIterator;
            CurSurf.bHiddenEdLevel = !bShouldBeVisible;
        }
    }

    // Add/remove model components from the scene
    for (int32 ComponentIndex = 0; ComponentIndex < Level->ModelComponents.Num(); ComponentIndex++)
    {
        UModelComponent* CurLevelModelCmp = Level->ModelComponents[ComponentIndex];
        if (CurLevelModelCmp)
        {
            CurLevelModelCmp->MarkRenderStateDirty();
        }
    }

    Level->GetWorld()->SendAllEndOfFrameUpdates();

    Level->bIsVisible = bShouldBeVisible;

    if (Level->bIsLightingScenario)
    {
        Level->OwningWorld->PropagateLightingScenarioChange();
    }
}

void SetLevelVisibilityNoGlobalUpdateInternal(ULevel* Level, const bool bShouldBeVisible, const bool bForceLayersVisible, const ELevelVisibilityDirtyMode ModifyMode)
{
    // Nothing to do
    if (Level == NULL)
    {
        return;
    }

    // Handle the case of the p-level
    // The p-level can't be unloaded, so its actors/BSP should just be temporarily hidden/unhidden
    // Also, intentionally do not force layers visible for the p-level
    if (Level->IsPersistentLevel())
    {
        // Create a transaction so we can undo the visibility toggle
        const FScopedTransaction Transaction(LOCTEXT("ToggleLevelVisibility", "Toggle Level Visibility"));
        if (Level->bIsVisible != bShouldBeVisible && ModifyMode == ELevelVisibilityDirtyMode::ModifyOnChange)
        {
            Level->Modify();
        }
        // Set the visibility of each actor in the p-level
        for (TArray<AActor*>::TIterator PLevelActorIter(Level->Actors); PLevelActorIter; ++PLevelActorIter)
        {
            AActor* CurActor = *PLevelActorIter;
            if (CurActor && !FActorEditorUtils::IsABuilderBrush(CurActor) && CurActor->bHiddenEdLevel == bShouldBeVisible)
            {
                if (ModifyMode == ELevelVisibilityDirtyMode::ModifyOnChange)
                {
                    CurActor->Modify();
                }

                CurActor->bHiddenEdLevel = !bShouldBeVisible;
                CurActor->RegisterAllComponents();
                CurActor->MarkComponentsRenderStateDirty();
            }
        }

        // Set the visibility of each BSP surface in the p-level
        UModel* CurLevelModel = Level->Model;
        if (CurLevelModel)
        {
            if (ModifyMode == ELevelVisibilityDirtyMode::ModifyOnChange)
            {
                CurLevelModel->Modify();
            }

            for (TArray<FBspSurf>::TIterator SurfaceIterator(CurLevelModel->Surfs); SurfaceIterator; ++SurfaceIterator)
            {
                FBspSurf& CurSurf      = *SurfaceIterator;
                CurSurf.bHiddenEdLevel = !bShouldBeVisible;
            }
        }

        // Add/remove model components from the scene
        for (int32 ComponentIndex = 0; ComponentIndex < Level->ModelComponents.Num(); ComponentIndex++)
        {
            UModelComponent* CurLevelModelCmp = Level->ModelComponents[ComponentIndex];
            if (CurLevelModelCmp)
            {
                if (bShouldBeVisible)
                {
                    CurLevelModelCmp->RegisterComponentWithWorld(Level->OwningWorld);
                }
                else if (!bShouldBeVisible && CurLevelModelCmp->IsRegistered())
                {
                    CurLevelModelCmp->UnregisterComponent();
                }
            }
        }

        Level->GetWorld()->OnLevelsChanged().Broadcast();
    }
    else
    {
        const bool bReflectVisibilityToGame = CVarReflectEditorLevelVisibilityWithGame.GetValueOnGameThread() != 0;
        ULevelStreaming* StreamingLevel     = NULL;
        if (Level->OwningWorld == NULL || Level->OwningWorld->PersistentLevel != Level)
        {
            StreamingLevel = FLevelUtils::FindStreamingLevel(Level);
        }

        // Create a transaction so we can undo the visibility toggle
        const FScopedTransaction Transaction(LOCTEXT("ToggleLevelVisibility", "Toggle Level Visibility"));

        // Handle the case of a streaming level
        if (StreamingLevel)
        {
            if (ModifyMode == ELevelVisibilityDirtyMode::ModifyOnChange)
            {
                // We need to set the RF_Transactional to make a streaming level serialize itself. so store the original ones, set the flag, and put the original flags back when done
                EObjectFlags cachedFlags = StreamingLevel->GetFlags();
                StreamingLevel->SetFlags(RF_Transactional);
                StreamingLevel->Modify();
                StreamingLevel->SetFlags(cachedFlags);
            }

            // Set the visibility state for this streaming level.
            StreamingLevel->SetShouldBeVisibleInEditor(bShouldBeVisible);
            if (bReflectVisibilityToGame)
            {
                StreamingLevel->SetShouldBeVisible(bShouldBeVisible);
            }
        }

        ULayersSubsystem* Layers = GEditor->GetEditorSubsystem<ULayersSubsystem>();
        if (!bShouldBeVisible)
        {
            Layers->RemoveLevelLayerInformation(Level);
        }

        // UpdateLevelStreaming sets Level->bIsVisible directly, so we need to make sure it gets saved to the transaction buffer.
        if (Level->bIsVisible != bShouldBeVisible && ModifyMode == ELevelVisibilityDirtyMode::ModifyOnChange)
        {
            Level->Modify();
        }

        if (StreamingLevel)
        {
            Level->OwningWorld->FlushLevelStreaming();

            // In the Editor we expect this operation will complete in a single call
            check(Level->bIsVisible == bShouldBeVisible);
        }
        else if (Level->OwningWorld != NULL)
        {
            // In case we level has no associated StreamingLevel, remove or add to world directly
            if (bShouldBeVisible)
            {
                if (!Level->bIsVisible)
                {
                    Level->OwningWorld->AddToWorld(Level);
                }
            }
            else
            {
                Level->OwningWorld->RemoveFromWorld(Level);
            }

            // In the Editor we expect this operation will complete in a single call
            check(Level->bIsVisible == bShouldBeVisible);
        }

        if (bShouldBeVisible)
        {
            Layers->AddLevelLayerInformation(Level);
        }

        // Force the level's layers to be visible, if desired
        FEditorSupportDelegates::RedrawAllViewports.Broadcast();

        // Iterate over the level's actors, making a list of their layers and unhiding the layers.
        TArray<AActor*>& Actors = Level->Actors;
        for (int32 ActorIndex = 0; ActorIndex < Actors.Num(); ++ActorIndex)
        {
            AActor* Actor = Actors[ActorIndex];
            if (Actor)
            {
                bool bModified = false;
                if (bShouldBeVisible && bForceLayersVisible &&
                    Layers->IsActorValidForLayer(Actor))
                {
                    // Make the actor layer visible, if it's not already.
                    if (Actor->bHiddenEdLayer)
                    {
                        if (ModifyMode == ELevelVisibilityDirtyMode::ModifyOnChange)
                        {
                            bModified = Actor->Modify();
                        }
                        Actor->bHiddenEdLayer = false;
                    }

                    const bool bIsVisible = true;
                    Layers->SetLayersVisibility(Actor->Layers, bIsVisible);
                }

                // Set the visibility of each actor in the streaming level
                if (!FActorEditorUtils::IsABuilderBrush(Actor) && Actor->bHiddenEdLevel == bShouldBeVisible)
                {
                    if (!bModified && ModifyMode == ELevelVisibilityDirtyMode::ModifyOnChange)
                    {
                        bModified = Actor->Modify();
                    }
                    Actor->bHiddenEdLevel = !bShouldBeVisible;

                    if (bShouldBeVisible)
                    {
                        Actor->ReregisterAllComponents();
                    }
                    else
                    {
                        Actor->UnregisterAllComponents();
                    }
                }
                if (bReflectVisibilityToGame)
                {
                    Actor->SetHidden(Actor->bHiddenEdLevel);
                }
            }
        }
    }

    Level->bIsVisible = bShouldBeVisible;

    // If the level is being hidden, deselect actors and surfaces that belong to this level. (Part 1/2)
    if (!bShouldBeVisible && ModifyMode == ELevelVisibilityDirtyMode::ModifyOnChange)
    {
        USelection* SelectedActors = GEditor->GetSelectedActors();
        SelectedActors->Modify();
        const TArray<AActor*>& Actors = Level->Actors;
        for (int32 ActorIndex = 0; ActorIndex < Actors.Num(); ++ActorIndex)
        {
            AActor* Actor = Actors[ActorIndex];
            if (Actor)
            {
                SelectedActors->Deselect(Actor);
            }
        }

        UEditorLevelUtils::DeselectAllSurfacesInLevel(Level);
    }

    if (Level->bIsLightingScenario)
    {
        Level->OwningWorld->PropagateLightingScenarioChange();
    }
}

void UEditorLevelUtils::SetLevelVisibility(ULevel* Level, const bool bShouldBeVisible, const bool bForceLayersVisible, const ELevelVisibilityDirtyMode ModifyMode)
{
    TArray<ULevel*> Levels({Level});
    TArray<bool> bTheyShouldBeVisible({bShouldBeVisible});
    SetLevelsVisibility(Levels, bTheyShouldBeVisible, bForceLayersVisible, ModifyMode);
}

void UEditorLevelUtils::SetLevelsVisibility(const TArray<ULevel*>& Levels, const TArray<bool>& bTheyShouldBeVisible, const bool bForceLayersVisible, const ELevelVisibilityDirtyMode ModifyMode)
{
    // Nothing to do
    if (Levels.Num() == 0 || Levels.Num() != bTheyShouldBeVisible.Num())
    {
        return;
    }

    // Perform SetLevelVisibilityNoGlobalUpdateInternal for each Level
    for (int32 LevelIndex = 0; LevelIndex < Levels.Num(); ++LevelIndex)
    {
        ULevel* Level = Levels[LevelIndex];
        if (Level)
        {
            SetLevelVisibilityNoGlobalUpdateInternal(Level, bTheyShouldBeVisible[LevelIndex], bForceLayersVisible, ModifyMode);
        }
    }

    // If at least 1 persistent level, then RedrawAllViewports.Broadcast
    for (int32 LevelIndex = 0; LevelIndex < Levels.Num(); ++LevelIndex)
    {
        ULevel* Level = Levels[LevelIndex];
        if (Level && Level->IsPersistentLevel())
        {
            FEditorSupportDelegates::RedrawAllViewports.Broadcast();
            break;
        }
    }

    // If at least 1 level becomes visible, force layers to update their actor status
    // Otherwise, changes made on the layers for actors belonging to a non-visible level would not work
    {
        for (int32 LevelIndex = 0; LevelIndex < bTheyShouldBeVisible.Num(); ++LevelIndex)
        {
            if (bTheyShouldBeVisible[LevelIndex])
            {
                // Equivalent to GEditor->GetEditorSubsystem<ULayersSubsystem>()->UpdateAllActorsVisibilityDefault();
                FEditorDelegates::RefreshLayerBrowser.Broadcast();
                break;
            }
        }
    }

    // Notify the Scene Outliner, as new Actors may be present in the world.
    GEngine->BroadcastLevelActorListChanged();

    // If the level is being hidden, deselect actors and surfaces that belong to this level. (Part 2/2)
    if (ModifyMode == ELevelVisibilityDirtyMode::ModifyOnChange)
    {
        for (int32 LevelIndex = 0; LevelIndex < bTheyShouldBeVisible.Num(); ++LevelIndex)
        {
            if (!bTheyShouldBeVisible[LevelIndex])
            {
                // Tell the editor selection status was changed.
                GEditor->NoteSelectionChange();
                break;
            }
        }
    }
}

void UEditorLevelUtils::ForEachWorlds(UWorld* InWorld, TFunctionRef<bool(UWorld*)> Operation, bool bIncludeInWorld, bool bOnlyEditorVisible)
{
    if (!InWorld)
    {
        return;
    }

    if (bIncludeInWorld)
    {
        if (!Operation(InWorld))
        {
            return;
        }
    }

    // Iterate over the world's level array to find referenced levels ("worlds"). We don't
    for (ULevelStreaming* StreamingLevel: InWorld->GetStreamingLevels())
    {
        if (StreamingLevel)
        {
            // If we asked for only sub-levels that are editor-visible, then limit our results appropriately
            bool bShouldAlwaysBeLoaded = false;  // Cast< ULevelStreamingAlwaysLoaded >( StreamingLevel ) != NULL;
            if (!bOnlyEditorVisible || bShouldAlwaysBeLoaded || StreamingLevel->GetShouldBeVisibleInEditor())
            {
                const ULevel* Level = StreamingLevel->GetLoadedLevel();

                // This should always be the case for valid level names as the Editor preloads all packages.
                if (Level)
                {
                    // Newer levels have their packages' world as the outer.
                    UWorld* World = Cast<UWorld>(Level->GetOuter());
                    if (World)
                    {
                        if (!Operation(World))
                        {
                            return;
                        }
                    }
                }
            }
        }
    }

    // Levels can be loaded directly without StreamingLevel facilities
    for (ULevel* Level: InWorld->GetLevels())
    {
        if (Level)
        {
            // Newer levels have their packages' world as the outer.
            UWorld* World = Cast<UWorld>(Level->GetOuter());
            if (World)
            {
                if (!Operation(World))
                {
                    return;
                }
            }
        }
    }
}

void UEditorLevelUtils::GetWorlds(UWorld* InWorld, TArray<UWorld*>& OutWorlds, bool bIncludeInWorld, bool bOnlyEditorVisible)
{
    OutWorlds.Empty();
    ForEachWorlds(InWorld, [&OutWorlds](UWorld* World)
                  {
                      OutWorlds.AddUnique(World);
                      return true;
                  },
                  bIncludeInWorld, bOnlyEditorVisible);
}

const TArray<ULevel*> UEditorLevelUtils::GetLevels(UWorld* World)
{
    if (!World)
    {
        return TArray<ULevel*>();
    }
    return World->GetLevels();
}

#undef LOCTEXT_NAMESPACE