Level.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/Object.h"
#include "Misc/Guid.h"
#include "Templates/SubclassOf.h"
#include "Engine/EngineBaseTypes.h"
#include "Interfaces/Interface_AssetUserData.h"
#include "RenderCommandFence.h"
#include "Templates/ScopedCallback.h"
#include "Misc/WorldCompositionUtility.h"
#include "Engine/MaterialMerging.h"
#include "Engine/TextureStreamingTypes.h"
#include "Misc/EditorPathObjectInterface.h"
#include "Components/ActorComponent.h"
 
// TODO: Internal headers should not be included
#include "Runtime/Engine/Internal/Streaming/AsyncRegisterLevelContext.h"
 
#include <atomic>
 
#include "Level.generated.h"
 
class AActor;
class ABrush;
class AInstancedFoliageActor;
class ALevelBounds;
class APlayerController;
class AWorldSettings;
class AWorldDataLayers;
class FSceneInterface;
class ITargetPlatform;
class UAssetUserData;
class UMapBuildDataRegistry;
class UNavigationDataChunk;
class UTexture2D;
struct FLevelCollection;
class ULevelActorContainer;
class FRegisterComponentContext;
class FUnregisterComponentContext;
class SNotificationItem;
class UActorFolder;
class IWorldPartitionCell;
class UWorldPartitionRuntimeCell;
struct FWorldRenameFromRootContext;
struct FFolder;
 
#if WITH_EDITOR
struct FLevelActorFoldersHelper
{
private:
    static ENGINE_API void SetUseActorFolders(ULevel* InLevel, bool bInEnabled);
    static ENGINE_API void AddActorFolder(ULevel* InLevel, UActorFolder* InActorFolder, bool bInShouldDirtyLevel, bool bInShouldBroadcast = true);
    static ENGINE_API void RenameFolder(ULevel* InLevel, const FFolder& InOldFolder, const FFolder& InNewFolder);
    static ENGINE_API void DeleteFolder(ULevel* InLevel, const FFolder& InFolder);
 
    friend class UWorld;
    friend class ULevel;
    friend class UActorFolder;
    friend class FWorldPartitionConverter;
    friend class UWorldPartitionConvertCommandlet;
    friend class FWorldPartitionLevelHelper;
    friend class UWorldPartitionLevelStreamingDynamic;
};
 
#endif
 
// Actor container class used to duplicate actors during cells streaming in PIE
UCLASS(MinimalAPI)
class UActorContainer : public UObject
{
    GENERATED_BODY()
 
public:
    UPROPERTY()
    TMap<FName, TObjectPtr<AActor>> Actors;
 
#if WITH_EDITORONLY_DATA
    // Can be used to resolve the Actor Level while they are outered to the UActorContainer in a PIE duplication
    UPROPERTY()
    TObjectPtr<ULevel> RuntimeLevel = nullptr;
#endif
};
 
USTRUCT()
struct FActorFolderSet
{
    GENERATED_BODY()
 
public:
 
    ENGINE_API void Add(UActorFolder* InActorFolder);
    int32 Remove(UActorFolder* InActorFolder) { return ActorFolders.Remove(InActorFolder); }
    bool IsEmpty() const { return ActorFolders.IsEmpty(); }
    const TSet<TObjectPtr<UActorFolder>>& GetActorFolders() const { return ActorFolders; }
 
private:
 
    UPROPERTY(Transient)
    TSet<TObjectPtr<UActorFolder>> ActorFolders;
};
 
USTRUCT()
struct FStreamableTextureInstance
{
    GENERATED_USTRUCT_BODY()
 
    
    FBoxSphereBounds  Bounds;
 
    float MinDistance;
    float MaxDistance;
 
    float   TexelFactor;
 
    friend FArchive& operator<<( FArchive& Ar, FStreamableTextureInstance& TextureInstance );
};
 
USTRUCT()
struct FDynamicTextureInstance : public FStreamableTextureInstance
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    TObjectPtr<UTexture2D>                  Texture = nullptr;
 
    UPROPERTY()
    bool                        bAttached = false;
    
    UPROPERTY()
    float                       OriginalRadius = 0.0f;
 
    friend FArchive& operator<<( FArchive& Ar, FDynamicTextureInstance& TextureInstance );
};
 
struct FPendingAutoReceiveInputActor
{
    TWeakObjectPtr<AActor> Actor;
    int32 PlayerIndex;
 
    FPendingAutoReceiveInputActor(AActor* InActor, const int32 InPlayerIndex);
    ~FPendingAutoReceiveInputActor();
};
 
class FPrecomputedVisibilityCell
{
public:
 
    FVector Min;
 
    uint16 ChunkIndex;
 
    uint16 DataOffset;
 
    friend FArchive& operator<<( FArchive& Ar, FPrecomputedVisibilityCell& D )
    {
        Ar << D.Min << D.ChunkIndex << D.DataOffset;
        return Ar;
    }
};
 
class FCompressedVisibilityChunk
{
public:
    bool bCompressed;
 
    int32 UncompressedSize;
 
    TArray<uint8> Data;
 
    friend FArchive& operator<<( FArchive& Ar, FCompressedVisibilityChunk& D )
    {
        Ar << D.bCompressed << D.UncompressedSize << D.Data;
        return Ar;
    }
};
 
class FPrecomputedVisibilityBucket
{
public:
    int32 CellDataSize;
 
    TArray<FPrecomputedVisibilityCell> Cells;
 
    TArray<FCompressedVisibilityChunk> CellDataChunks;
 
    friend FArchive& operator<<( FArchive& Ar, FPrecomputedVisibilityBucket& D )
    {
        Ar << D.CellDataSize << D.Cells << D.CellDataChunks;
        return Ar;
    }
};
 
class FPrecomputedVisibilityHandler
{
public:
 
    FPrecomputedVisibilityHandler() :
        Id(NextId)
    {
        NextId++;
    }
    
    ~FPrecomputedVisibilityHandler() 
    { 
        UpdateVisibilityStats(false);
    }
 
    ENGINE_API void UpdateVisibilityStats(bool bAllocating) const;
 
    ENGINE_API void UpdateScene(FSceneInterface* Scene) const;
 
    ENGINE_API void Invalidate(FSceneInterface* Scene);
 
    ENGINE_API void ApplyWorldOffset(const FVector& InOffset);
 
    int32 GetId() const { return Id; }
 
    friend FArchive& operator<<( FArchive& Ar, FPrecomputedVisibilityHandler& D );
    
private:
 
    FVector2D PrecomputedVisibilityCellBucketOriginXY;
 
    float PrecomputedVisibilityCellSizeXY;
 
    float PrecomputedVisibilityCellSizeZ;
 
    int32   PrecomputedVisibilityCellBucketSizeXY;
 
    int32   PrecomputedVisibilityNumCellBuckets;
 
    static int32 NextId;
 
    int32 Id;
 
    TArray<FPrecomputedVisibilityBucket> PrecomputedVisibilityCellBuckets;
 
    friend class FLightmassProcessor;
    friend class FSceneViewState;
};
 
class FPrecomputedVolumeDistanceField
{
public:
 
    ENGINE_API void UpdateScene(FSceneInterface* Scene) const;
 
    ENGINE_API void Invalidate(FSceneInterface* Scene);
 
    friend FArchive& operator<<( FArchive& Ar, FPrecomputedVolumeDistanceField& D );
 
private:
    float VolumeMaxDistance;
    FBox VolumeBox;
    int32 VolumeSizeX;
    int32 VolumeSizeY;
    int32 VolumeSizeZ;
    TArray<FColor> Data;
 
    friend class FScene;
    friend class FLightmassProcessor;
};
 
USTRUCT()
struct FLevelSimplificationDetails
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(Category=General, EditAnywhere)
    bool bCreatePackagePerAsset;
 
    UPROPERTY(Category=StaticMesh, EditAnywhere, meta=(DisplayName="Static Mesh Details Percentage", ClampMin = "0", ClampMax = "100", UIMin = "0", UIMax = "100")) 
    float DetailsPercentage;
 
    UPROPERTY(Category = Landscape, EditAnywhere)
    FMaterialProxySettings StaticMeshMaterialSettings;
 
    UPROPERTY(Category = Landscape, EditAnywhere, meta=(InlineEditConditionToggle))
    bool bOverrideLandscapeExportLOD;
 
    UPROPERTY(Category=Landscape, EditAnywhere, meta=(ClampMin = "0", ClampMax = "7", UIMin = "0", UIMax = "7", editcondition = "bOverrideLandscapeExportLOD"))
    int32 LandscapeExportLOD;
    
    UPROPERTY(Category = Landscape, EditAnywhere)
    FMaterialProxySettings LandscapeMaterialSettings;
 
    UPROPERTY(Category=Landscape, EditAnywhere)
    bool bBakeFoliageToLandscape;
 
    UPROPERTY(Category=Landscape, EditAnywhere)
    bool bBakeGrassToLandscape;
 
    ENGINE_API FLevelSimplificationDetails();
    ENGINE_API bool operator == (const FLevelSimplificationDetails& Other) const;
};
 
USTRUCT()
struct FReplicatedStaticActorDestructionInfo
{
    GENERATED_BODY()
 
    FName PathName;
    FString FullName;
    FVector DestroyedPosition;
    TWeakObjectPtr<UObject> ObjOuter;
    UPROPERTY()
    TObjectPtr<UClass> ObjClass = nullptr;
};
 
#if WITH_EDITORONLY_DATA
UENUM()
enum class EActorPackagingScheme : uint8
{
    Original,   // Original scheme: ZZ/ZZ/... (maximum 1679616 folders,  ~0.6 files per folder with 1000000 files)
    Reduced     //  Reduced scheme:  Z/ZZ/... (maximum   46656 folders, ~21.4 files per folder with 1000000 files)
};
#endif
 
// Whether the level is in the process of being made visible or invisible (refer to bIsVisible when None).
enum class ELevelPendingVisibilityState : uint8
{
    None,
    MakingVisible,
    MakingInvisible
};
 
//
// The level object.  Contains the level's actor list, BSP information, and brush list.
// Every Level has a World as its Outer and can be used as the PersistentLevel, however,
// when a Level has been streamed in the OwningWorld represents the World that it is a part of.
//
 
 
UCLASS(MinimalAPI)
class ULevel : public UObject, public IInterface_AssetUserData, public ITextureStreamingContainer, public IEditorPathObjectInterface
{
    GENERATED_BODY()
 
public:
 
    FURL                    URL;
 
    TArray<TObjectPtr<AActor>> Actors;
 
    TArray<TObjectPtr<AActor>> ActorsForGC;
 
    ENGINE_API bool TryAddActorToList(AActor* InActor, bool bAddUnique);
 
#if WITH_EDITORONLY_DATA
    AActor* PlayFromHereActor;
 
    UPROPERTY(EditInstanceOnly, Category=World)
    bool bUseExternalActors;
#endif
 
    ENGINE_API static TMap<FName, TWeakObjectPtr<UWorld> > StreamedLevelsOwningWorld;
        
    UPROPERTY(Transient)
    TObjectPtr<UWorld> OwningWorld;
 
    UPROPERTY()
    TObjectPtr<class UModel> Model;
 
    UPROPERTY()
    TArray<TObjectPtr<class UModelComponent>> ModelComponents;
 
    UPROPERTY(Transient, DuplicateTransient, NonTransactional)
    TObjectPtr<ULevelActorContainer> ActorCluster;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(NonTransactional)
    TObjectPtr<class ULevelScriptBlueprint> LevelScriptBlueprint;
 
    UPROPERTY(NonTransactional)
    TArray<FGuid> TextureStreamingResourceGuids;
#endif //WITH_EDITORONLY_DATA
 
    UPROPERTY(NonTransactional)
    int32 NumTextureStreamingUnbuiltComponents;
 
    UPROPERTY(NonTransactional)
    int32 NumTextureStreamingDirtyResources;
 
    UPROPERTY(NonTransactional)
    TObjectPtr<class ALevelScriptActor> LevelScriptActor;
 
    UPROPERTY()
    TObjectPtr<class ANavigationObjectBase> NavListStart;
    UPROPERTY()
    TObjectPtr<class ANavigationObjectBase> NavListEnd;
    
    UPROPERTY()
    TArray<TObjectPtr<UNavigationDataChunk>> NavDataChunks;
    
    UPROPERTY(VisibleAnywhere, Category=Level)
    float LightmapTotalSize;
    UPROPERTY(VisibleAnywhere, Category=Level)
    float ShadowmapTotalSize;
 
    UPROPERTY()
    TArray<FVector> StaticNavigableGeometry;
 
    UPROPERTY()
    TArray<FGuid> StreamingTextureGuids;
 
    UPROPERTY()
    TArray<FName> StreamingTextures;
 
    UPROPERTY()
    uint32 PackedTextureStreamingQualityLevelFeatureLevel;
 
    class FTickTaskLevel*                       TickTaskLevel;
 
    class FPrecomputedLightVolume*              PrecomputedLightVolume;
 
    class FPrecomputedVolumetricLightmap*           PrecomputedVolumetricLightmap;
 
    FPrecomputedVisibilityHandler               PrecomputedVisibilityHandler;
 
    FPrecomputedVolumeDistanceField             PrecomputedVolumeDistanceField;
 
    FRenderCommandFence                         RemoveFromSceneFence;
 
    UPROPERTY()
    FGuid LevelBuildDataId;
 
    UPROPERTY(NonPIEDuplicateTransient)
    TObjectPtr<UMapBuildDataRegistry> MapBuildData;
 
    UPROPERTY()
    FIntVector LightBuildLevelOffset;
 
    class FVolumetricLightmapGridManager* VolumetricLightmapGridManager = nullptr;
 
    UPROPERTY()
    uint8 bIsLightingScenario:1;
 
    uint8                                       bAreComponentsCurrentlyRegistered:1;
 
    uint8                                       bGeometryDirtyForLighting:1;
 
    UPROPERTY()
    uint8                                       bTextureStreamingRotationChanged : 1;
 
    UPROPERTY(Transient, DuplicateTransient, NonTransactional)
    uint8                                       bStaticComponentsRegisteredInStreamingManager: 1;
 
    UPROPERTY(transient)
    uint8                                       bIsVisible:1;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    uint8                                       bLocked:1;
 
    uint8                                       bContainsStableActorGUIDs:1;
 
    uint8                                       bFixupActorFoldersAtLoad:1;
 
private:
    uint8                                       bForceCantReuseUnloadedButStillAround:1;
 
    uint8                                       bForcePackageTrashingAtCleanup:1;
#endif
 
    uint8                                       bIsMapBuildDataOwner:1;
    
public:
    uint8                                       bAlreadyMovedActors:1;
    uint8                                       bAlreadyShiftedActors:1;
    uint8                                       bAlreadyUpdatedComponents:1;
    uint8                                       bAlreadyAssociatedStreamableResources:1;
    uint8                                       bAlreadyInitializedNetworkActors:1;
    uint8                                       bAlreadyClearedActorsSeamlessTravelFlag:1;
    uint8                                       bAlreadySortedActorList:1;
    uint8                                       bIsAssociatingLevel:1;
    uint8                                       bIsDisassociatingLevel : 1;
    uint8                                       bRequireFullVisibilityToRender:1;
    uint8                                       bClientOnlyVisible:1;
    uint8                                       bWasDuplicated:1;
    uint8                                       bWasDuplicatedForPIE:1;
    uint8                                       bIsBeingRemoved:1;
    uint8                                       bIncrementalUnregisterComponentsCompleted:1;
    uint8                                       bHasRerunConstructionScripts:1;
    uint8                                       bActorClusterCreated : 1;
    uint8                                       bGarbageCollectionClusteringEnabled : 1;
 
    UPROPERTY()
    uint8                                       bIsPartitioned : 1;
 
    enum class EIncrementalComponentState : uint8
    {
        Init,
        PreRegisterInitialComponents,
        RegisterInitialComponents,
#if WITH_EDITOR
        RunConstructionScripts,
#endif
        Finalize
    };
 
    UE_DEPRECATED(5.5, "This property shouldn't be used anymore.")
    uint8                                       bHasCurrentActorCalledPreRegister:1;
 
private:
    ELevelPendingVisibilityState                PendingVisibilityState:2;
 
public:
    EIncrementalComponentState                  IncrementalComponentState;
    int32                                       CurrentActorIndexForIncrementalUpdate;
    int32                                       CurrentActorIndexForUnregisterComponents;
 
 
    ENGINE_API bool HasVisibilityChangeRequestPending() const;
 
    // Event on level transform changes
    DECLARE_MULTICAST_DELEGATE_OneParam(FLevelTransformEvent, const FTransform&);
    FLevelTransformEvent OnApplyLevelTransform;
 
    // Event on level cleanup
    DECLARE_MULTICAST_DELEGATE(FLevelCleanupEvent);
    FLevelCleanupEvent OnCleanupLevel;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FLevelSimplificationDetails LevelSimplification[WORLDTILE_LOD_MAX_INDEX];
 
    UPROPERTY()
    FLinearColor LevelColor;
 
    std::atomic<uint64> FixupOverrideVertexColorsTimeMS = 0;
    std::atomic<uint32> FixupOverrideVertexColorsCount = 0;
 
    UPROPERTY(transient)
    bool bPromptWhenAddingToLevelBeforeCheckout;
 
    UPROPERTY(transient)
    bool bPromptWhenAddingToLevelOutsideBounds;
 
    UPROPERTY()
    EActorPackagingScheme ActorPackagingScheme;
 
#endif //WITH_EDITORONLY_DATA
 
    TWeakObjectPtr<ALevelBounds>                LevelBoundsActor;
 
    TWeakObjectPtr<AInstancedFoliageActor>      InstancedFoliageActor;
 
    DECLARE_EVENT( ULevel, FLevelBoundsActorUpdatedEvent );
    FLevelBoundsActorUpdatedEvent& LevelBoundsActorUpdated() { return LevelBoundsActorUpdatedEvent; }
    void BroadcastLevelBoundsActorUpdated() { LevelBoundsActorUpdatedEvent.Broadcast(); }
 
    ENGINE_API void MarkLevelBoundsDirty();
 
#if WITH_EDITOR
    ENGINE_API static bool GetLevelBoundsFromAsset(const FAssetData& Asset, FBox& OutLevelBounds);
    ENGINE_API static bool GetLevelBoundsFromPackage(FName LevelPackage, FBox& OutLevelBounds);
 
    ENGINE_API static bool GetWorldExternalActorsReferencesFromAsset(const FAssetData& Asset, TArray<FGuid>& OutWorldExternalActorsReferences);
    ENGINE_API static bool GetWorldExternalActorsReferencesFromPackage(FName LevelPackage, TArray<FGuid>& OutWorldExternalActorsReferences);
 
    ENGINE_API static bool GetIsLevelPartitionedFromAsset(const FAssetData& Asset);
    ENGINE_API static bool GetIsLevelPartitionedFromPackage(FName LevelPackage);
 
    ENGINE_API static bool GetIsLevelUsingExternalActorsFromAsset(const FAssetData& Asset);
    ENGINE_API static bool GetIsLevelUsingExternalActorsFromPackage(FName LevelPackage);
 
    ENGINE_API static bool GetIsLevelUsingActorsDescsFromAsset(const FAssetData& Asset);
    ENGINE_API static bool GetIsLevelUsingActorsDescsFromPackage(FName LevelPackage);
 
    ENGINE_API static bool GetIsUsingActorFoldersFromAsset(const FAssetData& Asset);
    ENGINE_API static bool GetIsUsingActorFoldersFromPackage(FName LevelPackage);
 
    ENGINE_API static bool GetIsStreamingDisabledFromAsset(const FAssetData& Asset);    
    ENGINE_API static bool GetIsStreamingDisabledFromPackage(FName LevelPackage);
 
    ENGINE_API static bool GetIsLevelCookedFromAsset(const FAssetData& Asset);
    ENGINE_API static bool GetIsLevelCookedFromPackage(FName LevelPackage);
 
    UE_DEPRECATED(5.3, "GetPartitionedLevelCanBeUsedByLevelInstanceFromAsset is deprecated.")
    static bool GetPartitionedLevelCanBeUsedByLevelInstanceFromAsset(const FAssetData& Asset) { return true; }
    UE_DEPRECATED(5.3, "GetPartitionedLevelCanBeUsedByLevelInstanceFromPackage is deprecated.")
    static bool GetPartitionedLevelCanBeUsedByLevelInstanceFromPackage(FName LevelPackage) { return true; }
    UE_DEPRECATED(5.4, "GetLevelScriptExternalActorsReferencesFromAsset is deprecated.")
    static bool GetLevelScriptExternalActorsReferencesFromAsset(const FAssetData& Asset, TArray<FGuid>& OutLevelScriptExternalActorsReferences) { return false;}
    UE_DEPRECATED(5.4, "GetLevelScriptExternalActorsReferencesFromPackageis deprecated.")
    static bool GetLevelScriptExternalActorsReferencesFromPackage(FName LevelPackage, TArray<FGuid>& OutLevelScriptExternalActorsReferences) { return false; }
 
    ENGINE_API static FVector GetLevelInstancePivotOffsetFromAsset(const FAssetData& Asset);
    ENGINE_API static FVector GetLevelInstancePivotOffsetFromPackage(FName LevelPackage);
 
    ENGINE_API static const FName LoadAllExternalObjectsTag;
    ENGINE_API static const FName DontLoadExternalObjectsTag;
    ENGINE_API static const FName DontLoadExternalFoldersTag;
 
    ENGINE_API bool GetPromptWhenAddingToLevelOutsideBounds() const;
    ENGINE_API bool GetPromptWhenAddingToLevelBeforeCheckout() const;
 
    void SetEditorPathOwner(UObject* InEditorPathOwner) { EditorPathOwner = InEditorPathOwner; }
    virtual UObject* GetEditorPathOwner() const override { return EditorPathOwner.Get(); }
 
    bool GetForceCantReuseUnloadedButStillAround() const { return bForceCantReuseUnloadedButStillAround; }
    void SetForceCantReuseUnloadedButStillAround(bool bNewValue) { bForceCantReuseUnloadedButStillAround = bNewValue; }
#endif
 
private:
    enum class EIncrementalUnregisterComponentState : uint8
    {
        Init,
        PreUnregisterComponents,
        UnregisterComponents,
        Finalize
    };
 
    EIncrementalUnregisterComponentState IncrementalUnregisterComponentState;
 
    FLevelBoundsActorUpdatedEvent LevelBoundsActorUpdatedEvent; 
 
    UPROPERTY()
    TObjectPtr<AWorldSettings> WorldSettings;
 
    UPROPERTY()
    TObjectPtr<AWorldDataLayers> WorldDataLayers;
 
    UPROPERTY()
    TSoftObjectPtr<UWorldPartitionRuntimeCell> WorldPartitionRuntimeCell;
 
    FLevelCollection* CachedLevelCollection;
 
    void OnPreRegisterComponent(UActorComponent* Component)
    {
        check(IsValid(Component));
        PreRegisteringActorComponents.Add(Component);
    }
 
    void OnRemovedPreRegisteringComponent(UActorComponent* Component)
    {
        check(IsValid(Component));
        verify(PreRegisteringActorComponents.Remove(Component));
    }
 
    void OnPreRegisteredComponent(UActorComponent* Component)
    {
        OnRemovedPreRegisteringComponent(Component);
    }
 
    bool HasPreRegisteringComponents() const
    {
        return PreRegisteringActorComponents.Num() > 0;
    }
 
    void OnPreUnregisterComponent(UActorComponent* Component) 
    {
        check(IsValid(Component));
        PreUnregisteringActorComponents.Add(Component);
    }
 
    void OnRemovedPreUnregisteringComponent(UActorComponent* Component) 
    {
        check(IsValid(Component));
        verify(PreUnregisteringActorComponents.Remove(Component));
    }
 
    void OnPreUnregisteredComponent(UActorComponent* Component) 
    {
        OnRemovedPreUnregisteringComponent(Component);
    }
 
    bool HasPreUnregisteringComponents() const
    {
        return PreUnregisteringActorComponents.Num() > 0;
    }
 
    ENGINE_API void CreateAsyncRegisterLevelContext();
    ENGINE_API void DestroyAsyncRegisterLevelContext();
    
    TUniquePtr<FAsyncRegisterLevelContext> AsyncRegisterLevelContext;
    TSet<UActorComponent*> PreUnregisteringActorComponents;
    TSet<UActorComponent*> PreRegisteringActorComponents;
    friend struct FLevelRegistrationAccessor;
    friend struct FLevelPendingVisibilityStateAccessor;
    friend struct FLevelRemoveFromWorldAccessor;
 
protected:
 
    UPROPERTY()
    TArray<TObjectPtr<UAssetUserData>> AssetUserData;
 
private:
    // Actors awaiting input to be enabled once the appropriate PlayerController has been created
    TArray<FPendingAutoReceiveInputActor> PendingAutoReceiveInputActors;
 
    UPROPERTY(Transient)
    TArray<FReplicatedStaticActorDestructionInfo> DestroyedReplicatedStaticActors;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditInstanceOnly, Category = World)
    bool bUseActorFolders;
 
    UPROPERTY(Transient)
    TMap<FGuid, TObjectPtr<UActorFolder>> ActorFolders;
 
    UPROPERTY(Transient)
    TMap<FString, FActorFolderSet> FolderLabelToActorFolders;
 
    UPROPERTY(Transient)
    TArray<TObjectPtr<UActorFolder>> LoadedExternalActorFolders;
 
    UPROPERTY(Transient)
    TWeakObjectPtr<UObject> EditorPathOwner;
#endif // #if WITH_EDITORONLY_DATA
 
    enum class ERouteActorInitializationState : uint8
    {
        Preinitialize,
        Initialize,
        BeginPlay,
        Finished
    };
    ERouteActorInitializationState RouteActorInitializationState;
    int32 RouteActorInitializationIndex;
    int32 RouteActorEndPlayForRemoveFromWorldIndex;
 
public:
    // Used internally to determine which actors should go on the world's NetworkActor list
    ENGINE_API static bool IsNetActor(const AActor* Actor);
 
    void CreateReplicatedDestructionInfo(AActor* const Actor);
 
    const TArray<FReplicatedStaticActorDestructionInfo>& GetDestroyedReplicatedStaticActors() const;
 
    //** DO NOT USE - Part of internal networking implentation iteration. */
    ENGINE_API void AddReplicatedDestructionInfo(AActor* const Actor);
 
    ENGINE_API static FSimpleMulticastDelegate LevelDirtiedEvent;
 
    // Constructor.
    ENGINE_API void Initialize(const FURL& InURL);
    ULevel(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
 
    ULevel(FVTableHelper& Helper)
        : Super(Helper)
        , Actors()
    {}
 
    ~ULevel();
 
    //~ Begin UObject Interface.
    virtual void PostInitProperties() override; 
    virtual void Serialize( FArchive& Ar ) override;
    virtual void BeginDestroy() override;
    virtual bool IsReadyForFinishDestroy() override;
    virtual void FinishDestroy() override;
    ENGINE_API virtual UWorld* GetWorld() const override final;
 
#if WITH_EDITOR
    virtual void PreEditUndo() override;
    virtual void PostEditUndo() override;   
    virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    virtual void BeginCacheForCookedPlatformData(const ITargetPlatform *TargetPlatform) override;
#endif // WITH_EDITOR
    virtual bool ResolveSubobject(const TCHAR* SubObjectPath, UObject*& OutObject, bool bLoadIfExists) override;
    virtual void PostLoad() override;
    virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
    virtual void PreDuplicate(FObjectDuplicationParameters& DupParams) override;
    virtual bool CanBeClusterRoot() const override;
    virtual void CreateCluster() override;
    static void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
    //~ End UObject Interface.
 
    void PreSaveFromRoot(FObjectPreSaveRootContext ObjectSaveContext);
    void PostSaveFromRoot(FObjectPostSaveRootContext ObjectSaveContext);
 
#if WITH_EDITOR
    void PreRenameFromRoot(const FWorldRenameFromRootContext& RenameContext);
    void PostRenameFromRoot(const FWorldRenameFromRootContext& RenameContext);
 
    //~Begin ITextureStreamingContainer Interface.
    virtual void InitializeTextureStreamingContainer(uint32 InPackedTextureStreamingQualityLevelFeatureLevel) override;
    virtual uint16 RegisterStreamableTexture(UTexture* InTexture) override;
    //~End ITextureStreamingContainer Interface.
    ENGINE_API uint16 RegisterStreamableTexture(const FString& InTextureName, const FGuid& InTextureGuid);
#endif
 
    ENGINE_API void CleanupLevel(bool bCleanupResources = true, bool bUnloadFromEditor = true);
 
    ENGINE_API void ClearLevelComponents();
 
    ENGINE_API void UpdateLevelComponents(bool bRerunConstructionScripts, FRegisterComponentContext* Context = nullptr);
 
    void IncrementalUpdateComponents( int32 NumComponentsToUpdate, bool bRerunConstructionScripts, FRegisterComponentContext* Context = nullptr);
 
    bool IncrementalUnregisterComponents(int32 NumComponentsToUnregister, FUnregisterComponentContext* Context = nullptr);
 
 
    void InvalidateModelGeometry();
    
    ENGINE_API void MarkLevelComponentsRenderStateDirty();
 
#if WITH_EDITOR
    void CreateModelComponents();
#endif // WITH_EDITOR
 
    ENGINE_API void UpdateModelComponents();
 
    ENGINE_API void CommitModelSurfaces();
 
    void InvalidateModelSurface();
 
    ENGINE_API void SortActorList();
 
#if WITH_EDITOR
    ENGINE_API void AddLoadedActor(AActor* Actor, const FTransform* TransformToApply = nullptr);
    ENGINE_API void AddLoadedActors(const TArray<AActor*>& ActorList, const FTransform* TransformToApply = nullptr);
 
    ENGINE_API void RemoveLoadedActor(AActor* Actor, const FTransform* TransformToRemove = nullptr);
    ENGINE_API void RemoveLoadedActors(const TArray<AActor*>& ActorList, const FTransform* TransformToRemove = nullptr);
 
    DECLARE_EVENT_OneParam(ULevel, FLoadedActorAddedToLevelPreEvent, const TArray<AActor*>&);
    FLoadedActorAddedToLevelPreEvent OnLoadedActorAddedToLevelPreEvent;
 
    DECLARE_EVENT_OneParam(ULevel, FLoadedActorAddedToLevelEvent, AActor&);
    FLoadedActorAddedToLevelEvent OnLoadedActorAddedToLevelEvent;
 
    DECLARE_EVENT_OneParam(ULevel, FLoadedActorAddedToLevelPostEvent, const TArray<AActor*>&);
    FLoadedActorAddedToLevelPostEvent OnLoadedActorAddedToLevelPostEvent;
 
    DECLARE_EVENT_OneParam(ULevel, FLoadedActorRemovedFromLevelPreEvent, const TArray<AActor*>&);
    FLoadedActorRemovedFromLevelPreEvent OnLoadedActorRemovedFromLevelPreEvent;
 
    DECLARE_EVENT_OneParam(ULevel, FLoadedActorRemovedFromLevelEvent, AActor&);
    FLoadedActorRemovedFromLevelEvent OnLoadedActorRemovedFromLevelEvent;
 
    DECLARE_EVENT_OneParam(ULevel, FLoadedActorRemovedFromLevelPostEvent, const TArray<AActor*>&);
    FLoadedActorRemovedFromLevelPostEvent OnLoadedActorRemovedFromLevelPostEvent;
#endif
 
    /* Called when level is loaded. */
    ENGINE_API void OnLevelLoaded();
 
    virtual bool IsNameStableForNetworking() const override { return true; }        // For now, assume all levels have stable net names
 
    void InitializeNetworkActors();
 
    void ClearActorsSeamlessTraveledFlag();
 
    ENGINE_API void InitializeRenderingResources();
 
    ENGINE_API void ReleaseRenderingResources();
 
    bool IsFinishedRouteActorInitialization() const { return RouteActorInitializationState == ERouteActorInitializationState::Finished; }
 
    void ResetRouteActorInitializationState();
 
    void RouteActorInitialize(int32 NumActorsToProcess);
 
    ENGINE_API static void BuildStreamingData(UWorld* World, ULevel* TargetLevel=NULL, UTexture2D* TargetTexture=NULL);
 
    ENGINE_API ABrush* GetDefaultBrush() const;
 
    ENGINE_API AWorldSettings* GetWorldSettings(bool bChecked = true) const;
 
    ENGINE_API void SetWorldSettings(AWorldSettings* NewWorldSettings);
 
    ENGINE_API AWorldDataLayers* GetWorldDataLayers() const;
 
    ENGINE_API void SetWorldDataLayers(AWorldDataLayers* NewWorldDataLayers);
 
    ENGINE_API const IWorldPartitionCell* GetWorldPartitionRuntimeCell() const;
 
    bool IsWorldPartitionRuntimeCell() const { return !WorldPartitionRuntimeCell.GetUniqueID().IsNull(); }
 
    ENGINE_API class UWorldPartition* GetWorldPartition() const;
 
    ENGINE_API class ALevelScriptActor* GetLevelScriptActor() const;
 
    FLevelCollection* GetCachedLevelCollection() const { return CachedLevelCollection; }
 
    void SetCachedLevelCollection(FLevelCollection* const InCachedLevelCollection) { CachedLevelCollection = InCachedLevelCollection; }
 
    bool HasAnyActorsOfType(UClass *SearchType);
 
    ENGINE_API void ResetNavList();
 
    ENGINE_API UPackage* CreateMapBuildDataPackage() const;
 
    ENGINE_API UMapBuildDataRegistry* GetOrCreateMapBuildData();
 
    ENGINE_API bool IsMapBuildDataOwner() const;
 
    ENGINE_API ELevelPendingVisibilityState GetPendingVisibilityState() const;
 
    ENGINE_API void SetLightingScenario(bool bNewIsLightingScenario);
 
    ENGINE_API void HandleLegacyMapBuildData();
 
#if WITH_EDITOR
    static ENGINE_API FString GetActorPackageName(UPackage* InLevelPackage, EActorPackagingScheme InActorPackagingScheme, const FString& InActorPath, const UObject* InLevelMountPointContext = nullptr);
 
    static ENGINE_API FString ResolveRootPath(const FString& LevelPackageName, const UObject* InLevelMountPointContext = nullptr);
 
    static ENGINE_API FString GetActorPackageName(const FString& InBaseDir, EActorPackagingScheme InActorPackagingScheme, const FString& InActorPath);
 
    static ENGINE_API FString GetExternalActorsPath(const FString& InLevelPackageName, const FString& InPackageShortName = FString());
 
    static ENGINE_API TArray<FString> GetExternalActorsPaths(const FString& InLevelPackageName, const FString& InPackageShortName = FString());
 
    static ENGINE_API FString GetExternalActorsPath(UPackage* InLevelPackage, const FString& InPackageShortName = FString());
 
    static ENGINE_API EActorPackagingScheme GetActorPackagingSchemeFromActorPackageName(const FStringView InActorPackageName);
 
    static ENGINE_API void ScanLevelAssets(const FString& InLevelPackageName);
 
    static ENGINE_API const TCHAR* GetExternalActorsFolderName();
 
    ENGINE_API bool IsUsingExternalActors() const;
 
    ENGINE_API void SetUseExternalActors(bool bEnable);
 
    static ENGINE_API TArray<FString> GetExternalObjectsPaths(const FString& InLevelPackageName, const FString& InPackageShortName = FString());
 
    ENGINE_API bool IsUsingExternalObjects() const;
 
    ENGINE_API bool IsUsingActorFolders() const;
 
    ENGINE_API void CreateOrUpdateActorFolders();
 
    ENGINE_API void CleanupDeletedAndUnreferencedActorFolders();
 
    ENGINE_API bool SetUseActorFolders(bool bEnabled, bool bInteractive = false);
 
    ENGINE_API UActorFolder* GetActorFolder(const FGuid& InGuid, bool bSkipDeleted = true) const;
 
    ENGINE_API UActorFolder* GetActorFolder(const FName& InPath) const;
 
    ENGINE_API void ForEachActorFolder(TFunctionRef<bool(UActorFolder*)> Operation, bool bSkipDeleted = false);
 
    ENGINE_API bool ShouldCreateNewExternalActors() const;
 
    EActorPackagingScheme GetActorPackagingScheme() const { return ActorPackagingScheme; }
 
    ENGINE_API void ConvertAllActorsToPackaging(bool bExternal);
 
    static ENGINE_API FString GetExternalActorPackageInstanceName(const FString& LevelPackageName, const FString& ActorPackageName);
 
    static ENGINE_API TArray<FString> GetOnDiskExternalActorPackages(const FString& ExternalActorsPath);
 
    ENGINE_API TArray<FString> GetOnDiskExternalActorPackages(bool bTryUsingPackageLoadedPath = false) const;
 
    ENGINE_API TArray<UPackage*> GetLoadedExternalObjectPackages() const;
 
    static ENGINE_API UPackage* CreateActorPackage(UPackage* InLevelPackage, EActorPackagingScheme InActorPackagingScheme, const FString& InActorPath, const UObject* InMountPointContext = nullptr);
 
    ENGINE_API void OnApplyNewLightingData(bool bLightingSuccessful);
 
    ENGINE_API class ULevelScriptBlueprint* GetLevelScriptBlueprint(bool bDontCreate=false);
 
    ENGINE_API void CleanupLevelScriptBlueprint();
 
    ENGINE_API void OnLevelScriptBlueprintChanged(class ULevelScriptBlueprint* InBlueprint);
 
    ENGINE_API void FixupForPIE(int32 PIEInstanceID);
    ENGINE_API void FixupForPIE(int32 PIEInstanceID, TFunctionRef<void(int32, FSoftObjectPath&)> CustomFixupFunction);
 
    ENGINE_API bool HasStaticMeshCompilationPending();
#endif
 
    TArray<FVector> const* GetStaticNavigableGeometry() const { return &StaticNavigableGeometry;}
 
    ENGINE_API bool IsPersistentLevel() const;
 
    ENGINE_API bool IsCurrentLevel() const;
    
    ENGINE_API bool IsInstancedLevel() const;
 
    ENGINE_API void ApplyWorldOffset(const FVector& InWorldOffset, bool bWorldShift);
 
    void RegisterActorForAutoReceiveInput(AActor* Actor, const int32 PlayerIndex);
 
    void PushPendingAutoReceiveInput(APlayerController* PC);
    
    //~ Begin IInterface_AssetUserData Interface
    virtual void AddAssetUserData(UAssetUserData* InUserData) override;
    virtual void RemoveUserDataOfClass(TSubclassOf<UAssetUserData> InUserDataClass) override;
    virtual UAssetUserData* GetAssetUserDataOfClass(TSubclassOf<UAssetUserData> InUserDataClass) override;
    //~ End IInterface_AssetUserData Interface
 
    int32 GetEstimatedAddToWorldWorkUnitsRemaining() const;
    int32 GetEstimatedAddToWorldWorkUnitsTotal() const;
 
#if WITH_EDITOR
    DECLARE_DELEGATE_ThreeParams(FLevelExternalActorsPathsProviderDelegate, const FString&, const FString&, TArray<FString>&);
    static ENGINE_API FDelegateHandle RegisterLevelExternalActorsPathsProvider(const FLevelExternalActorsPathsProviderDelegate& Provider);
    static ENGINE_API void UnregisterLevelExternalActorsPathsProvider(const FDelegateHandle& ProviderDelegateHandle);
 
    DECLARE_DELEGATE_RetVal_ThreeParams(bool, FLevelMountPointResolverDelegate, const FString&, const UObject*, FString&);
    static ENGINE_API FDelegateHandle RegisterLevelMountPointResolver(const FLevelMountPointResolverDelegate& Resolver);
    static ENGINE_API void UnregisterLevelMountPointResolver(const FDelegateHandle& ResolverDelegateHandle);
    static const UObject* GetOverrideSpawningLevelMountPointObject() { return ULevel::OverrideSpawningLevelMountPointObject.Get(); }
#endif
 
private:
    void RouteActorEndPlayForRemoveFromWorld(int32 NumActorsToProcess);
    void ResetRouteActorEndPlayForRemoveFromWorld();
    bool IsFinishedRouteActorEndPlayForRemoveFromWorld() const;
 
    bool IncrementalPreRegisterComponents(FRegisterComponentContext& Context);
    bool IncrementalRegisterComponents(FRegisterComponentContext& Context);
    bool IncrementalPreUnregisterComponents(FUnregisterComponentContext& Context);
#if WITH_EDITOR
    bool IncrementalRunConstructionScripts(bool bProcessAllActors);
    TOptional<bool> bCachedHasStaticMeshCompilationPending;
 
    static TArray<FLevelExternalActorsPathsProviderDelegate> LevelExternalActorsPathsProviders;
 
    static TArray<FLevelMountPointResolverDelegate> LevelMountPointResolvers;
 
    static ENGINE_API TWeakObjectPtr<const UObject> OverrideSpawningLevelMountPointObject;
private:
    bool DeferRunningConstructionScripts(AActor* InActor);
 
    void RepairLevelScript();
 
    void FixupActorFolders();
 
    void AddActorFolder(UActorFolder* InActorFolder);
    void RemoveActorFolder(UActorFolder* InActorFolder);
    void OnFolderMarkAsDeleted(UActorFolder* InActorFolder);
    void OnFolderLabelChanged(UActorFolder* InActorFolder, const FString& InOldFolderLabel);
 
    void SetUseActorFoldersInternal(bool bInEnabled);
 
    TSet<FGuid> GetDeletedAndUnreferencedActorFolders() const;
 
    friend struct FScopedOverrideSpawningLevelMountPointObject;
    friend struct FLevelActorFoldersHelper;
    friend struct FSetWorldPartitionRuntimeCell;
    friend class FWorldPartitionLevelHelper;
    friend class UActorFolder;
    friend class AWorldDataLayers;
    friend class UWorldPartitionRuntimeHashSet;
 
    void RegenerateLevelScriptActor();
 
    void RemoveExtraLevelScriptActors();
 
    TWeakPtr<SNotificationItem> MultipleLSAsNotification;
    void OnMultipleLSAsPopupClicked();
    void OnMultipleLSAsPopupDismissed();
 
#endif // WITH_EDITOR
};
 
struct FLevelRemoveFromWorldAccessor
{
private:
    static void RouteActorEndPlayForRemoveFromWorld(ULevel* InLevel, int32 InNumActorsToProcess)
    {
        InLevel->RouteActorEndPlayForRemoveFromWorld(InNumActorsToProcess);
    }
 
    static void ResetRouteActorEndPlayForRemoveFromWorld(ULevel* InLevel)
    {
        InLevel->ResetRouteActorEndPlayForRemoveFromWorld();
    }
 
    static bool IsFinishedRouteActorEndPlayForRemoveFromWorld(ULevel* InLevel)
    { 
        return InLevel->IsFinishedRouteActorEndPlayForRemoveFromWorld();
    }
 
    friend class UWorld;
};
 
struct FLevelRegistrationAccessor
{
private:
    static void OnPreRegisterComponent(ULevel* InLevel, UActorComponent* InComponent)
    {
        InLevel->OnPreRegisterComponent(InComponent);
    }
 
    static void OnPreRegisteredComponent(ULevel* InLevel, UActorComponent* InComponent)
    {
        InLevel->OnPreRegisteredComponent(InComponent);
    }
 
    static void OnRemovedPreRegisteringComponent(ULevel* InLevel, UActorComponent* InComponent)
    {
        InLevel->OnRemovedPreRegisteringComponent(InComponent);
    }
 
    static bool HasPreRegisteringComponents(const ULevel* InLevel)
    {
        return InLevel->HasPreRegisteringComponents();
    }
 
    static void OnPreUnregisterComponent(ULevel* InLevel, UActorComponent* InComponent)
    {
        InLevel->OnPreUnregisterComponent(InComponent);
    }
 
    static void OnPreUnregisteredComponent(ULevel* InLevel, UActorComponent* InComponent)
    {
        InLevel->OnPreUnregisteredComponent(InComponent);
    }
 
    static void OnRemovedPreUnregisteringComponent(ULevel* InLevel, UActorComponent* InComponent)
    {
        InLevel->OnRemovedPreUnregisteringComponent(InComponent);
    }
 
    static bool HasPreUnregisteringComponents(const ULevel* InLevel)
    {
        return InLevel->HasPreUnregisteringComponents();
    }
 
    static void CreateAsyncRegisterLevelContext(ULevel* InLevel)
    {
        InLevel->CreateAsyncRegisterLevelContext();
    }
 
    static void DestroyAsyncRegisterLevelContext(ULevel* InLevel)
    {
        InLevel->DestroyAsyncRegisterLevelContext();
    }
 
    static FAsyncRegisterLevelContext* GetAsyncRegisterLevelContext(ULevel* InLevel)
    {
        return InLevel ? InLevel->AsyncRegisterLevelContext.Get() : nullptr;
    }
 
    friend class FRegisterComponentContext;
    friend class UActorComponent;
    friend class UWorld;
};
 
struct FLevelPendingVisibilityStateAccessor
{
private:
    static void SetPendingVisibilityState(ULevel* InLevel, ELevelPendingVisibilityState InState)
    {
        InLevel->PendingVisibilityState = InState;
    }
 
    friend class UWorld;
};
 
#if WITH_EDITOR
struct FScopedOverrideSpawningLevelMountPointObject
{
    FScopedOverrideSpawningLevelMountPointObject(const UObject* InObject)
    {
        PreviousValue = ULevel::OverrideSpawningLevelMountPointObject;
        ULevel::OverrideSpawningLevelMountPointObject = InObject;
    }
    ~FScopedOverrideSpawningLevelMountPointObject()
    {
        ULevel::OverrideSpawningLevelMountPointObject = PreviousValue;
    }
private:
    TWeakObjectPtr<const UObject> PreviousValue;
};
 
struct FSetWorldPartitionRuntimeCell
{
private:
    FSetWorldPartitionRuntimeCell(ULevel* InLevel, const FSoftObjectPath& InWorldPartitionRuntimeCell)
    {
        InLevel->WorldPartitionRuntimeCell = InWorldPartitionRuntimeCell;
    }
    friend class FWorldPartitionLevelHelper;
    friend class UWorldPartition;
};
#endif 
 
 #define DECLARE_SCOPED_DELEGATE( CallbackName, TriggerFunc )                       \
    class FScoped##CallbackName##Impl                                               \
    {                                                                               \
    public:                                                                         \
        static void FireCallback() { TriggerFunc; }                                 \
    };                                                                              \
                                                                                    \
    typedef TScopedCallback<FScoped##CallbackName##Impl> FScoped##CallbackName;
 
DECLARE_SCOPED_DELEGATE( LevelDirtied, ULevel::LevelDirtiedEvent.Broadcast() );
 
#undef DECLARE_SCOPED_DELEGATE