World.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "HAL/ThreadSafeCounter.h"
#include "Online/CoreOnlineFwd.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/Object.h"
#include "Misc/Guid.h"
#include "UObject/Class.h"
#include "Delegates/IDelegateInstance.h"
#include "Engine/EngineTypes.h"
#include "Engine/EngineBaseTypes.h"
#include "GameTime.h"
#include "CollisionQueryParams.h"
#include "WorldCollision.h"
#include "GameFramework/UpdateLevelVisibilityLevelInfo.h"
#include "EngineDefines.h"
#include "Engine/PendingNetGame.h"
#include "Engine/LatentActionManager.h"
#include "Physics/PhysicsQueryHandler.h"
#include "Physics/PhysicsInterfaceDeclares.h"
#include "Particles/WorldPSCPool.h"
#include "Containers/SortedMap.h"
#include "AudioDeviceHandle.h"
#include "Subsystems/WorldSubsystem.h"
#include "Subsystems/SubsystemCollection.h"
#include "CollisionProfile.h"
#include "RHIFeatureLevel.h"
#include "Engine/WorldInitializationValues.h"
#include "Misc/TransactionallySafeRWLock.h"
#include "Engine/ScopedMovementUpdate.h"
#include "PSOPrecacheFwd.h"
#include "World.generated.h"
 
#define UE_API ENGINE_API
 
class ABrush;
class ACameraActor;
class AController;
class AGameModeBase;
class AGameStateBase;
class APhysicsVolume;
class APlayerController;
class AServerStreamingLevelsVisibility;
class AWorldDataLayers;
class AWorldSettings;
class UWorldPartition;
class UDataLayerManager;
class Error;
class FConstPawnIterator;
class FRegisterComponentContext;
class FTimerManager;
class FWorldInGamePerformanceTrackers;
class IInterface_PostProcessVolume;
class IStateStreamManager;
class UAISystemBase;
class UChaosEventRelay;
class UCanvas;
class UDemoNetDriver;
class UGameViewportClient;
class ULevel;
class ULevelStreaming;
class ULocalPlayer;
class UMaterialParameterCollection;
class UMaterialParameterCollectionInstance;
class UModel;
class UNavigationSystemBase;
class UNetConnection;
class UNetDriver;
class UPrimitiveComponent;
class UTexture2D;
class FPhysScene_Chaos;
class FSceneView;
struct FUniqueNetIdRepl;
struct FEncryptionKeyResponse;
struct FParticlePerfStats;
enum class ELevelPendingVisibilityState : uint8;
 
template<typename,typename> class TOctree2;
 
template <typename ActorType> class TActorIterator;
typedef TArray<TWeakObjectPtr<AController> >::TConstIterator FConstControllerIterator;
typedef TArray<TWeakObjectPtr<APlayerController> >::TConstIterator FConstPlayerControllerIterator;
typedef TArray<TWeakObjectPtr<ACameraActor> >::TConstIterator FConstCameraActorIterator;
typedef TArray<ULevel*>::TConstIterator FConstLevelIterator;
typedef TArray<TWeakObjectPtr<APhysicsVolume> >::TConstIterator FConstPhysicsVolumeIterator;
 
ENGINE_API DECLARE_LOG_CATEGORY_EXTERN(LogSpawn, Warning, All);
 
DECLARE_MULTICAST_DELEGATE_OneParam(FOnActorSpawned, AActor*);
DECLARE_MULTICAST_DELEGATE_OneParam(FOnActorDestroyed, AActor*);
DECLARE_MULTICAST_DELEGATE_OneParam(FOnPostRegisterAllActorComponents, AActor*);
DECLARE_MULTICAST_DELEGATE_OneParam(FOnPreUnregisterAllActorComponents, AActor*);
DECLARE_MULTICAST_DELEGATE_OneParam(FOnActorRemovedFromWorld, AActor*);
DECLARE_MULTICAST_DELEGATE_OneParam(FOnFeatureLevelChanged, ERHIFeatureLevel::Type);
DECLARE_MULTICAST_DELEGATE_OneParam(FOnMovieSceneSequenceTick, float);
 
class UWorldProxy
{
public:
 
    UWorldProxy() :
        World(NULL)
    {}
 
    inline UWorld* operator->()
    {
        // GWorld is changed often on the game thread when in PIE, accessing on any other thread is going to be a race condition
        // In general, the rendering thread should not dereference UObjects, unless there is a mechanism in place to make it safe   
        checkSlow(IsInGameThread());                            
        return World;
    }
 
    inline const UWorld* operator->() const
    {
        checkSlow(IsInGameThread());
        return World;
    }
 
    inline UWorld& operator*()
    {
        checkSlow(IsInGameThread());
        return *World;
    }
 
    inline const UWorld& operator*() const
    {
        checkSlow(IsInGameThread());
        return *World;
    }
 
    inline UWorldProxy& operator=(UWorld* InWorld)
    {
        World = InWorld;
        return *this;
    }
 
    inline UWorldProxy& operator=(const UWorldProxy& InProxy)
    {
        World = InProxy.World;
        return *this;
    }
 
    inline bool operator==(const UWorldProxy& Other) const
    {
        return World == Other.World;
    }
 
    inline operator UWorld*() const
    {
        checkSlow(IsInGameThread());
        return World;
    }
 
    inline UWorld* GetReference() 
    {
        checkSlow(IsInGameThread());
        return World;
    }
 
private:
 
    UWorld* World;
};
 
// List of delegates for the world being registered to an audio device.
class FAudioDeviceWorldDelegates
{
public:
    // Called whenever a world is registered to an audio device. UWorlds are not guaranteed to be registered to the same
    // audio device throughout their lifecycle, and there is no guarantee on the lifespan of both the UWorld and the Audio
    // Device registered in this callback.
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnWorldRegisteredToAudioDevice, const UWorld* /*InWorld */, Audio::FDeviceId /* AudioDeviceId*/);
    static UE_API FOnWorldRegisteredToAudioDevice OnWorldRegisteredToAudioDevice;
 
    // Called whenever a world is unregistered from an audio device. UWorlds are not guaranteed to be registered to the same
    // audio device throughout their lifecycle, and there is no guarantee on the lifespan of both the UWorld and the Audio
    // Device registered in this callback.
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnWorldUnregisteredWithAudioDevice, const UWorld* /*InWorld */, Audio::FDeviceId /* AudioDeviceId*/);
    static UE_API FOnWorldUnregisteredWithAudioDevice OnWorldUnregisteredWithAudioDevice;
};
 
class FSeamlessTravelHandler
{
private:
    FURL PendingTravelURL;
    UObject* LoadedPackage;
    UWorld* CurrentWorld;
    UWorld* LoadedWorld;
    bool bTransitionInProgress;
    bool bSwitchedToDefaultMap;
    bool bPauseAtMidpoint;
    bool bNeedCancelCleanUp;
    FName WorldContextHandle;
    double SeamlessTravelStartTime = 0.0;
 
    void CopyWorldData();
 
    void SeamlessTravelLoadCallback(const FName& PackageName, UPackage* LevelPackage, EAsyncLoadingResult::Type Result);
 
    void SetHandlerLoadedData(UObject* InLevelPackage, UWorld* InLoadedWorld);
 
    bool StartLoadingMap(FString MapPackageToLoadFrom);
 
    void StartLoadingDestination();
 
public:
    FSeamlessTravelHandler()
        : PendingTravelURL(NoInit)
        , LoadedPackage(NULL)
        , CurrentWorld(NULL)
        , LoadedWorld(NULL)
        , bTransitionInProgress(false)
        , bSwitchedToDefaultMap(false)
        , bPauseAtMidpoint(false)
        , bNeedCancelCleanUp(false)
    {}
 
    bool StartTravel(UWorld* InCurrentWorld, const FURL& InURL);
 
    inline bool IsInTransition() const
    {
        return bTransitionInProgress;
    }
    inline bool HasSwitchedToDefaultMap() const
    {
        return IsInTransition() && bSwitchedToDefaultMap;
    }
 
    inline FString GetDestinationMapName() const
    {
        return (IsInTransition() ? PendingTravelURL.Map : TEXT(""));
    }
 
    inline const UWorld* GetLoadedWorld() const
    {
        return LoadedWorld;
    }
 
    void CancelTravel();
 
    void SetPauseAtMidpoint(bool bNowPaused);
 
    ENGINE_API UWorld* Tick();
};
 
 
USTRUCT()
struct FLevelViewportInfo
{
    GENERATED_BODY()
 
    
    UPROPERTY()
    FVector CamPosition;
 
    UPROPERTY()
    FRotator CamRotation;
 
    UPROPERTY()
    float CamOrthoZoom;
 
    UPROPERTY()
    bool CamUpdated;
 
    FLevelViewportInfo()
        : CamPosition(FVector::ZeroVector)
        , CamRotation(FRotator::ZeroRotator)
        , CamOrthoZoom(DEFAULT_ORTHOZOOM)
        , CamUpdated(false)
    {
    }
 
    FLevelViewportInfo(const FVector& InCamPosition, const FRotator& InCamRotation, float InCamOrthoZoom)
        : CamPosition(InCamPosition)
        , CamRotation(InCamRotation)
        , CamOrthoZoom(InCamOrthoZoom)
        , CamUpdated(false)
    {
    }
    
    // Needed for backwards compatibility for VER_UE4_ADD_EDITOR_VIEWS, can be removed along with it
    friend FArchive& operator<<( FArchive& Ar, FLevelViewportInfo& I )
    {
        Ar << I.CamPosition;
        Ar << I.CamRotation;
        Ar << I.CamOrthoZoom;
 
        if ( Ar.IsLoading() )
        {
            I.CamUpdated = true;
 
            if ( I.CamOrthoZoom < MIN_ORTHOZOOM || I.CamOrthoZoom > MAX_ORTHOZOOM )
            {
                I.CamOrthoZoom = DEFAULT_ORTHOZOOM;
            }
        }
 
        return Ar;
    }
};
 
USTRUCT()
struct FStartPhysicsTickFunction : public FTickFunction
{
    GENERATED_USTRUCT_BODY()
 
    
    class UWorld*   Target;
 
    virtual void ExecuteTick(float DeltaTime, enum ELevelTick TickType, ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent) override;
    virtual FString DiagnosticMessage() override;
    virtual FName DiagnosticContext(bool bDetailed) override;
};
 
template<>
struct TStructOpsTypeTraits<FStartPhysicsTickFunction> : public TStructOpsTypeTraitsBase2<FStartPhysicsTickFunction>
{
    enum
    {
        WithCopy = false
    };
};
 
USTRUCT()
struct FEndPhysicsTickFunction : public FTickFunction
{
    GENERATED_USTRUCT_BODY()
 
    
    class UWorld*   Target;
 
    virtual void ExecuteTick(float DeltaTime, enum ELevelTick TickType, ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent) override;
    virtual FString DiagnosticMessage() override;
    virtual FName DiagnosticContext(bool bDetailed) override;
};
 
template<>
struct TStructOpsTypeTraits<FEndPhysicsTickFunction> : public TStructOpsTypeTraitsBase2<FEndPhysicsTickFunction>
{
    enum
    {
        WithCopy = false
    };
};
 
/* Struct of optional parameters passed to SpawnActor function(s). */
struct FActorSpawnParameters
{
    UE_API FActorSpawnParameters();
 
    /* A name to assign as the Name of the Actor being spawned. If no value is specified, the name of the spawned Actor will be automatically generated using the form [Class]_[Number]. */
    FName Name;
 
    /* An Actor to use as a template when spawning the new Actor. The spawned Actor will be initialized using the property values of the template Actor. If left NULL the class default object (CDO) will be used to initialize the spawned Actor. */
    AActor* Template;
 
    /* The Actor that spawned this Actor. (Can be left as NULL). */
    AActor* Owner;
 
    /* The APawn that is responsible for damage done by the spawned Actor. (Can be left as NULL). */
    APawn*  Instigator;
 
    /* The ULevel to spawn the Actor in, i.e. the Outer of the Actor. If left as NULL the Outer of the Owner is used. If the Owner is NULL the persistent level is used. */
    class   ULevel* OverrideLevel;
 
#if WITH_EDITOR
    /* The UPackage to set the Actor in. If left as NULL the Package will not be set and the actor will be saved in the same package as the persistent level. */
    class   UPackage* OverridePackage;
 
    FStringView InitialActorLabel;
 
    FGuid   OverrideActorGuid;
#endif
 
    /* The parent component to set the Actor in. */
    class   UChildActorComponent* OverrideParentComponent;
 
    ESpawnActorCollisionHandlingMethod SpawnCollisionHandlingOverride;
 
    ESpawnActorScaleMethod TransformScaleMethod = ESpawnActorScaleMethod::MultiplyWithRoot;
 
private:
 
    friend class UPackageMapClient;
 
    friend class UNetActorFactory;
 
    /* Is the actor remotely owned. This should only be set true by the package map when it is creating an actor on a client that was replicated from the server. */
    uint8   bRemoteOwned:1;
    
public:
 
    bool IsRemoteOwned() const { return bRemoteOwned; }
 
    /* Determines whether spawning will not fail if certain conditions are not met. If true, spawning will not fail because the class being spawned is `bStatic=true` or because the class of the template Actor is not the same as the class of the Actor being spawned. */
    uint8   bNoFail:1;
 
    /* Determines whether the construction script will be run. If true, the construction script will not be run on the spawned Actor. Only applicable if the Actor is being spawned from a Blueprint. */
    uint8   bDeferConstruction:1;
    
    /* Determines whether or not the actor may be spawned when running a construction script. If true spawning will fail if a construction script is being run. */
    uint8   bAllowDuringConstructionScript:1;
 
#if !WITH_EDITOR
    /* Force the spawned actor to use a globally unique name (provided name should be none). */
    uint8   bForceGloballyUniqueName:1;
#else
    /* Determines whether the begin play cycle will run on the spawned actor when in the editor. */
    uint8   bTemporaryEditorActor:1;
 
    /* Determines whether or not the actor should be hidden from the Scene Outliner */
    uint8   bHideFromSceneOutliner:1;
 
    uint16  bCreateActorPackage:1;
#endif
 
    /* Modes that SpawnActor can use the supplied name when it is not None. */
    enum class ESpawnActorNameMode : uint8
    {
        /* Fatal if unavailable, application will assert */
        Required_Fatal,
 
        /* Report an error return null if unavailable */
        Required_ErrorAndReturnNull,
 
        /* Return null if unavailable */
        Required_ReturnNull,
 
        /* If the supplied Name is already in use the generate an unused one using the supplied version as a base */
        Requested
    };
 
    /* In which way should SpawnActor should treat the supplied Name if not none. */
    ESpawnActorNameMode NameMode;
 
    /* Flags used to describe the spawned actor/object instance. */
    EObjectFlags ObjectFlags;
 
    /* Custom function allowing the caller to specific a function to execute post actor construction but before other systems see this actor spawn. */
    TFunction<void(AActor*)> CustomPreSpawnInitalization;
};
 
/* World actors spawmning helper functions */
struct FActorSpawnUtils
{
    static UE_API FName MakeUniqueActorName(ULevel* Level, const UClass* Class, FName BaseName, bool bGloballyUnique);
 
    static UE_API bool IsGloballyUniqueName(FName Name);
 
    static UE_API FName GetBaseName(FName Name);
};
 
struct FActorsInitializedParams
{
    FActorsInitializedParams(UWorld* InWorld, bool InResetTime) : World(InWorld), ResetTime(InResetTime) {}
    UWorld* World;
    bool ResetTime;
};
 
struct FWorldAsyncTraceState
{
    UE_API FWorldAsyncTraceState();
 
    inline AsyncTraceData& GetBufferForFrame        (int32 Frame) { return DataBuffer[ Frame             % 2]; }
    inline AsyncTraceData& GetBufferForCurrentFrame ()            { return DataBuffer[ CurrentFrame      % 2]; }
    inline AsyncTraceData& GetBufferForPreviousFrame()            { return DataBuffer[(CurrentFrame + 1) % 2]; }
 
    AsyncTraceData DataBuffer[2];
 
    int32 CurrentFrame;
};
 
#if WITH_EDITOR
struct FWorldRenameFromRootContext
{
    FName Name;
 
    UObject* Outer = nullptr;
 
    ERenameFlags Flags = REN_None;
};
 
/* FAsyncPreRegisterDDCRequest - info about an async DDC request that we're going to wait on before registering components */
class FAsyncPreRegisterDDCRequest
{
    /* DDC Key used for the request */
    FString DDCKey;
 
    /* Handle for Async DDC request. 0 if no longer invalid. */
    uint32 Handle;
public:
    FAsyncPreRegisterDDCRequest(const FString& InKey, uint32 InHandle)
    : DDCKey(InKey)
    , Handle(InHandle)
    {}
 
    UE_API ~FAsyncPreRegisterDDCRequest();
 
    UE_API bool PollAsynchronousCompletion();
 
    UE_API void WaitAsynchronousCompletion();
 
    UE_API bool GetAsynchronousResults(TArray<uint8>& OutData);
 
    const FString& GetKey() const { return DDCKey; }
};
#endif
 
USTRUCT()
struct FLevelCollection
{
    GENERATED_BODY()
 
    UE_API FLevelCollection();
 
    FLevelCollection(const FLevelCollection&) = delete;
    FLevelCollection& operator=(const FLevelCollection&) = delete;
 
    UE_API FLevelCollection(FLevelCollection&& Other);
    UE_API FLevelCollection& operator=(FLevelCollection&& Other);
 
    UE_API ~FLevelCollection();
 
    ELevelCollectionType GetType() const { return CollectionType; }
 
    void SetType(const ELevelCollectionType InType) { CollectionType = InType; }
 
    AGameStateBase* GetGameState() const { return GameState; }
 
    void SetGameState(AGameStateBase* const InGameState) { GameState = InGameState; }
 
    UNetDriver* GetNetDriver() const { return NetDriver; }
    
    void SetNetDriver(UNetDriver* const InNetDriver) { NetDriver = InNetDriver; }
 
    UDemoNetDriver* GetDemoNetDriver() const { return DemoNetDriver; }
 
    void SetDemoNetDriver(UDemoNetDriver* const InDemoNetDriver) { DemoNetDriver = InDemoNetDriver; }
 
    const TSet<TObjectPtr<ULevel>>& GetLevels() const { return Levels; }
 
    UE_API void AddLevel(ULevel* const Level);
 
    UE_API void RemoveLevel(ULevel* const Level);
 
    UE_API void SetPersistentLevel(ULevel* const Level);
 
    ULevel* GetPersistentLevel() const { return PersistentLevel; }
 
    bool IsVisible() const { return bIsVisible; }
 
    void SetIsVisible(const bool bInIsVisible) { bIsVisible = bInIsVisible; }
 
private:
    ELevelCollectionType CollectionType;
 
    bool bIsVisible;
 
    UPROPERTY()
    TObjectPtr<class AGameStateBase> GameState;
 
    UPROPERTY()
    TObjectPtr<class UNetDriver> NetDriver;
 
    UPROPERTY()
    TObjectPtr<class UDemoNetDriver> DemoNetDriver;
 
    UPROPERTY()
    TObjectPtr<class ULevel> PersistentLevel;
 
    UPROPERTY()
    TSet<TObjectPtr<ULevel>> Levels;
};
 
template<>
struct TStructOpsTypeTraits<FLevelCollection> : public TStructOpsTypeTraitsBase2<FLevelCollection>
{
    enum
    {
        WithCopy = false
    };
};
 
class FScopedLevelCollectionContextSwitch
{
public:
    UE_API FScopedLevelCollectionContextSwitch(const FLevelCollection* const InLevelCollection, UWorld* const InWorld);
 
    UE_API FScopedLevelCollectionContextSwitch(int32 InLevelCollectionIndex, UWorld* const InWorld);
 
    UE_API ~FScopedLevelCollectionContextSwitch();
 
private:
    class UWorld* World;
    int32 SavedTickingCollectionIndex;
};
 
USTRUCT()
struct FStreamingLevelsToConsider
{
    GENERATED_BODY()
 
    FStreamingLevelsToConsider()
        : StreamingLevelsBeingConsidered(0)
    {}
 
private:
 
    UPROPERTY()
    TArray<TObjectPtr<ULevelStreaming>> StreamingLevels;
 
    enum class EProcessReason : uint8
    {
        Add,
        Reevaluate
    };
 
    TSortedMap<TObjectPtr<ULevelStreaming>, EProcessReason> LevelsToProcess;
 
    int32 StreamingLevelsBeingConsidered;
 
    UE_API void Add_Internal(ULevelStreaming* StreamingLevel, bool bGuaranteedNotInContainer);
 
public:
 
    const TArray<TObjectPtr<ULevelStreaming>>& GetStreamingLevels() const { return StreamingLevels; }
 
    UE_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
 
    UE_API void BeginConsideration();
    UE_API void EndConsideration();
    bool AreStreamingLevelsBeingConsidered() { return StreamingLevelsBeingConsidered > 0; }
 
    void Add(ULevelStreaming* StreamingLevel) { Add_Internal(StreamingLevel, false); }
 
    /* Remove an element from the container. */
    UE_API bool Remove(ULevelStreaming* StreamingLevel);
 
    /* Remove the element at a given index from the container. */
    UE_API void RemoveAt(int32 Index);
 
    /* Returns if an element is in the container. */
    UE_API bool Contains(ULevelStreaming* StreamingLevel) const;
 
    /* Resets the container to an empty state without freeing array memory. */
    UE_API void Reset();
 
    /* Instructs the container that state changed such that the position in the priority sorted array the level may no longer be correct. */
    UE_API void Reevaluate(ULevelStreaming* StreamingLevel);
};
 
struct FWorldCachedViewInfo
{
    FMatrix ViewMatrix;
    FMatrix ProjectionMatrix;
    FMatrix ViewProjectionMatrix;
    FMatrix ViewToWorld;
};
 
struct FWorldPartitionEvents
{
    friend UWorldPartition;
 
private:
    static void BroadcastWorldPartitionInitialized(UWorld* InWorld, UWorldPartition* InWorldPartition);
    static void BroadcastWorldPartitionUninitialized(UWorld* InWorld, UWorldPartition* InWorldPartition);
};
 
struct FDeferredComponentMoveData
{
    FDeferredComponentMoveData() = default;
    
    TWeakObjectPtr<USceneComponent> ComponentToMove = nullptr;
    
    FTransform InitialTransform;
 
    FScopedMovementUpdate::TScopedOverlapInfoArray PendingOverlaps;
    
    FScopedMovementUpdate::TScopedBlockingHitArray BlockingHits;
    
    bool bHasTransformMovedForGroupUpdate = false;
 
    bool bHasMoved = false;
    
    FScopedMovementUpdate::EOverlapState OverlapState = FScopedMovementUpdate::EOverlapState::eUnknown;
        
    ETeleportType TeleportType = ETeleportType::None;
 
    // If not INDEX_NONE, overlaps at this index and beyond in PendingOverlaps are at the final destination
    int32 FinalOverlapCandidatesIndex = INDEX_NONE;
};
 
 
UCLASS(MinimalAPI, customConstructor, config=Engine)
class UWorld final : public UObject, public FNetworkNotify
{
    GENERATED_UCLASS_BODY()
 
    UE_API ~UWorld();
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(Transient)
    TArray< TObjectPtr<class ULayer> > Layers; 
 
    // Group actors currently "active"
    UPROPERTY(Transient)
    TArray<TObjectPtr<AActor>> ActiveGroupActors;
 
    UPROPERTY(VisibleAnywhere, Instanced, Category=Thumbnail)
    TObjectPtr<class UThumbnailInfo> ThumbnailInfo;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY(Transient)
    TObjectPtr<class ULevel>                                PersistentLevel;
 
    UPROPERTY(Transient)
    TObjectPtr<class UNetDriver>                            NetDriver;
 
    UE_DEPRECATED(5.6, "Please use GetLineBatcher(UWorld::ELineBatcherType::World")
    UPROPERTY(Transient)
    TObjectPtr<class ULineBatchComponent>                   LineBatcher_DEPRECATED;
 
    UE_DEPRECATED(5.6, "Please use GetLineBatcher(UWorld::ELineBatcherType::WorldPersistent")
    UPROPERTY(Transient)
    TObjectPtr<class ULineBatchComponent>                   PersistentLineBatcher_DEPRECATED;
 
    UE_DEPRECATED(5.6, "Please use GetLineBatcher(UWorld::ELineBatcherType::Foreground")
    UPROPERTY(Transient)
    TObjectPtr<class ULineBatchComponent>                   ForegroundLineBatcher_DEPRECATED;
 
    UPROPERTY(Transient)
    TObjectPtr<class AGameNetworkManager>                   NetworkManager;
 
    UPROPERTY(Transient)
    TObjectPtr<class UPhysicsCollisionHandler>              PhysicsCollisionHandler;
 
    UPROPERTY(Transient)
    TObjectPtr<class UPhysicsQueryHandler>                  PhysicsQueryHandler;
 
    UPROPERTY(Transient)
    TArray<TObjectPtr<UObject>>                         ExtraReferencedObjects;
 
    UPROPERTY(Transient)
    TArray<TObjectPtr<UObject>>                         PerModuleDataObjects;
 
private:
    UPROPERTY(Transient)
    TArray<TObjectPtr<ULevelStreaming>> StreamingLevels;
 
    UPROPERTY(Transient, DuplicateTransient)
    FStreamingLevelsToConsider StreamingLevelsToConsider;
 
    UPROPERTY(Transient, DuplicateTransient)
    TObjectPtr<AServerStreamingLevelsVisibility> ServerStreamingLevelsVisibility;
 
public:
    enum class ELineBatcherType : uint8
    {
        World = 0,
        WorldPersistent,
        Foreground,
        ForegroundPersistent,
        // --- ---
        NUM,
        Invalid = NUM
    };
 
    UE_API ULineBatchComponent* GetLineBatcher(ELineBatcherType Type) const;
    
    UE_API void FlushLineBatchers(const TArrayView<const UWorld::ELineBatcherType>& TypesToFlush);
 
    UE_API bool SupportsMakingVisibleTransactionRequests() const;
 
    UE_API bool SupportsMakingInvisibleTransactionRequests() const;
 
    UE_API const AServerStreamingLevelsVisibility* GetServerStreamingLevelsVisibility() const;
 
    const TArray<ULevelStreaming*>& GetStreamingLevels() const { return StreamingLevels; }
 
    uint16 GetNumStreamingLevelsBeingLoaded() const { return NumStreamingLevelsBeingLoaded; }
 
    bool IsStreamingLevelBeingConsidered(ULevelStreaming* StreamingLevel) const { return StreamingLevelsToConsider.Contains(StreamingLevel); }
    
    bool HasStreamingLevelsToConsider() const { return StreamingLevelsToConsider.GetStreamingLevels().Num() > 0; }
 
    UE_DEPRECATED(5.6, "Use IsLevelMakingVisible instead.")
    ULevel* GetCurrentLevelPendingVisibility() const { return nullptr; }
 
    UE_API bool IsLevelMakingVisible(const ULevel* InLevel) const;
 
    UE_API bool HasAnyLevelMakingVisible() const;
 
    UE_DEPRECATED(5.6, "Use IsLevelMakingInvisible instead.")
    ULevel* GetCurrentLevelPendingInvisibility() const { return nullptr; }
 
    UE_API bool IsLevelMakingInvisible(const ULevel* InLevel) const;
 
    UE_API bool HasAnyLevelMakingInvisible() const;
 
    UE_API void AddStreamingLevel(ULevelStreaming* StreamingLevelToAdd);
 
    UE_API void AddStreamingLevels(TArrayView<ULevelStreaming* const> StreamingLevelsToAdd);    
 
    UE_API void AddUniqueStreamingLevel(ULevelStreaming* StreamingLevelToAdd);
 
    UE_API void AddUniqueStreamingLevels(TArrayView<ULevelStreaming* const> StreamingLevelsToAdd);
 
    UE_API void SetStreamingLevels(TArray<ULevelStreaming*>&& StreamingLevels);
 
    UE_API void SetStreamingLevels(TArrayView<ULevelStreaming* const> StreamingLevels);
 
    UE_API bool RemoveStreamingLevel(ULevelStreaming* StreamingLevelToRemove);
 
    UE_API bool RemoveStreamingLevelAt(int32 IndexToRemove);
 
    UE_API int32 RemoveStreamingLevels(TArrayView<ULevelStreaming* const> StreamingLevelsToRemove);
 
    UE_API void ClearStreamingLevels();
 
    UE_API void UpdateStreamingLevelShouldBeConsidered(ULevelStreaming* StreamingLevelToConsider);
 
    UE_API void UpdateStreamingLevelPriority(ULevelStreaming* StreamingLevel);
 
    UE_API void PopulateStreamingLevelsToConsider();
 
    bool GetIsInBlockTillLevelStreamingCompleted() const { return IsInBlockTillLevelStreamingCompleted > 0; }
 
    int32 GetBlockTillLevelStreamingCompletedEpoch() const { return BlockTillLevelStreamingCompletedEpoch; }
 
    UPROPERTY()
    FString                                     StreamingLevelsPrefix;
 
#if UE_SUPPORT_FOR_ACTOR_TICK_DISABLE
    UE_API void EnableActorTickAndUserCallbacks(bool bEnable);
    bool IsActorTickAndUserCallbacksEnabled() const { return bEnableActorTickAndUserCallbacks; };
#endif
 
    UE_API void PushComponentGroupMove(const FScopedMovementUpdate* Scope);
 
    UE_API void ProcessPendingGroupMoves(bool bProcessAllMoves = true);
 
private:
    TArray<FDeferredComponentMoveData> DeferredComponentMoves;
    
    UPROPERTY(Transient)
    TObjectPtr<class ULineBatchComponent> LineBatchers[(int32)ELineBatcherType::NUM];
 
    UE_API void SetLevelPendingVisibilityState(ULevel* InLevel, ELevelPendingVisibilityState InState);
 
    UE_API bool CanAddLoadedLevelToWorld(ULevel* Level) const;
 
    void SpawnAndSetNoPawnPlayerController(UNetConnection* Connection, uint8 NetPlayerIndex, int32 LocalPlayerIdentifier);
 
    mutable TOptional<bool> bSupportsMakingVisibleTransactionRequests;
 
    mutable TOptional<bool> bSupportsMakingInvisibleTransactionRequests;
 
    mutable FTransactionallySafeRWLock PendingVisibilityLock;
 
    UPROPERTY(Transient)
    TArray<TObjectPtr<class ULevel>>                        MakingVisibleLevels;
 
    UPROPERTY(Transient)
    TArray<TObjectPtr<class ULevel>>                        MakingInvisibleLevels;
 
    UPROPERTY()
    TObjectPtr<class UDemoNetDriver>                        DemoNetDriver;
 
#if UE_SUPPORT_FOR_ACTOR_TICK_DISABLE
    bool bEnableActorTickAndUserCallbacks = true;
#endif
 
public:
    UDemoNetDriver* GetDemoNetDriver() const { return DemoNetDriver; }
 
    void SetDemoNetDriver(UDemoNetDriver* const InDemoNetDriver) { DemoNetDriver = InDemoNetDriver; }
 
    UPROPERTY()
    TObjectPtr<class AParticleEventManager>             MyParticleEventManager;
 
private:
    UPROPERTY(Transient)
    TObjectPtr<APhysicsVolume>                              DefaultPhysicsVolume;
 
    // Flag for allowing physics state creation deferall during load 
    bool bAllowDeferredPhysicsStateCreation;
 
public:
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    inline ERHIFeatureLevel::Type GetFeatureLevel() const{ return FeatureLevel; }
    inline void SetFeatureLevel(ERHIFeatureLevel::Type InFeatureLevel) { FeatureLevel = InFeatureLevel; }
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    TArray<FVector>                             ViewLocationsRenderedLastFrame;
 
    TArray<FWorldCachedViewInfo>                CachedViewInfoRenderedLastFrame;
    double                                      LastRenderTime = 0.0;
 
    UE_DEPRECATED(5.3, "FeatureLevel will be removed in the future from UWorld. Please use GetFeatureLevel or SetFeatureLevel instead")
    TEnumAsByte<ERHIFeatureLevel::Type> FeatureLevel;
 
    TEnumAsByte<ETickingGroup> TickGroup;
 
    TEnumAsByte<EWorldType::Type> WorldType;
 
    uint8 bWorldWasLoadedThisTick:1;
 
    uint8 bTriggerPostLoadMap:1;
 
    uint8 bInTick:1;
 
    uint8 bIsBuilt:1;
 
    uint8 bTickNewlySpawned:1;
 
    uint8 bPostTickComponentUpdate:1;
 
    uint8 bIsWorldInitialized:1;
    
    uint8 bIsLevelStreamingFrozen:1;
 
    uint8 bDoDelayedUpdateCullDistanceVolumes:1;
 
    uint8 bIsRunningConstructionScript:1;
 
    uint8 bShouldSimulatePhysics:1;
 
#if !UE_BUILD_SHIPPING || WITH_EDITOR
    uint8 bCreateRenderStateForHiddenComponentsWithCollsion:1;
#endif // !UE_BUILD_SHIPPING
 
#if WITH_EDITOR
    uint8 bEnableTraceCollision:1;
 
    uint8 bForceUseMovementComponentInNonGameWorld:1;
 
    uint8 bIsNameStableForNetworking:1;
#endif
 
    uint8 bDropDetail:1;
 
    uint8 bAggressiveLOD:1;
 
    uint8 bIsDefaultLevel:1;
    
    uint8 bRequestedBlockOnAsyncLoading:1;
 
    uint8 bActorsInitialized:1;
 
    UE_DEPRECATED(5.4, "Public access to bBegunPlay is deprecated. Please update your code to use the public accessors GetBegunPlay() & SetBegunPlay().")
    uint8 bBegunPlay:1;
 
    UE_API void SetBegunPlay(bool bHasBegunPlay);
 
    UE_API bool GetBegunPlay() const;
 
    DECLARE_EVENT_OneParam(UWorld, FOnBeginPlay, bool);
    FOnBeginPlay& GetOnBeginPlayEvent() { return OnBeginPlay; }
 
    uint8 bMatchStarted:1;
 
    uint8 bPlayersOnly:1;
 
    uint8 bPlayersOnlyPending:1;
 
    uint8 bStartup:1;
 
    uint8 bIsTearingDown:1;
 
    uint8 bKismetScriptError:1;
 
    // Kismet debugging flags - they can be only editor only, but they're uint32, so it doesn't make much difference
    uint8 bDebugPauseExecution:1;
 
    uint8 bIsCameraMoveableWhenPaused:1;
 
    uint8 bAllowAudioPlayback:1;
 
#if WITH_EDITOR
    uint8 bDebugFrameStepExecution:1;
 
    uint8 bDebugFrameStepExecutedThisFrame : 1;
 
    uint8 bToggledBetweenPIEandSIEThisFrame : 1;
 
    uint8 bPurgedScene : 1;
#endif
 
    UPROPERTY(transient)
    uint8 bAreConstraintsDirty:1;
 
private:
    uint8 bRequiresHitProxies:1;
 
    uint8 bShouldTick:1;
 
    uint8 bStreamingDataDirty : 1;
 
    uint8 bShouldForceUnloadStreamingLevels:1;
 
    uint8 bShouldForceVisibleStreamingLevels:1;
 
    uint8 bMaterialParameterCollectionInstanceNeedsDeferredUpdate : 1;
 
    uint8 bHasEverBeenInitialized: 1;
 
    bool bIsBeingCleanedUp;
    
    uint32 IsInBlockTillLevelStreamingCompleted;
 
    int32 BlockTillLevelStreamingCompletedEpoch;
 
    UPROPERTY(Transient)
    TObjectPtr<class UNavigationSystemBase>             NavigationSystem;
 
    UPROPERTY(Transient)
    TObjectPtr<class AGameModeBase>                     AuthorityGameMode;
 
    UPROPERTY(Transient)
    TObjectPtr<class AGameStateBase>                        GameState;
 
    UPROPERTY(Transient)
    TObjectPtr<class UAISystemBase>                     AISystem;
    
    UPROPERTY(Transient)
    TObjectPtr<class UAvoidanceManager>                 AvoidanceManager;
 
    UPROPERTY(Transient)
    TArray<TObjectPtr<class ULevel>>                        Levels;
 
    UPROPERTY(Transient, NonTransactional, Setter = None, Getter = None)
    TArray<FLevelCollection>                    LevelCollections;
 
    int32                                       ActiveLevelCollectionIndex;
 
    UE_API void ConditionallyCreateDefaultLevelCollections();
    
    FOnBeginPlay OnBeginPlay;
public:
 
    FAudioDeviceHandle AudioDeviceHandle;
 
#if WITH_EDITOR
    struct FHierarchicalLODBuilder*             HierarchicalLODBuilder;
 
    FName OriginalWorldName;
#endif // WITH_EDITOR
 
    UFUNCTION()
    UE_API void HandleTimelineScrubbed();
 
private:
 
    FDelegateHandle AudioDeviceDestroyedHandle;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(Transient)
    TObjectPtr<class ULevel>                                CurrentLevel;
#endif
 
    UPROPERTY(Transient)
    TObjectPtr<class UGameInstance>                     OwningGameInstance;
 
    UPROPERTY(Transient)
    TArray<TObjectPtr<class UMaterialParameterCollectionInstance>> ParameterCollectionInstances;
 
    UPROPERTY(Transient)
    TObjectPtr<UCanvas> CanvasForRenderingToTarget;
 
    UPROPERTY(Transient)
    TObjectPtr<UCanvas> CanvasForDrawMaterialToRenderTarget;
 
public:
    UE_API void SetNavigationSystem(UNavigationSystemBase* InNavigationSystem);
 
    class FSceneInterface*                      Scene;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(NonTransactional)
    TArray<FLevelViewportInfo>                  EditorViews;
#endif
 
#if WITH_EDITORONLY_DATA
    UE_API bool SetCurrentLevel( class ULevel* InLevel );
#endif
 
    UE_API class ULevel* GetCurrentLevel() const;
 
    static UE_API TMap<FName, EWorldType::Type> WorldTypePreLoadMap;
 
#if WITH_EDITOR
    typedef TMap<TWeakObjectPtr<class UBlueprint>, TWeakObjectPtr<UObject> > FBlueprintToDebuggedObjectMap;
 
    const FBlueprintToDebuggedObjectMap& GetBlueprintObjectsBeingDebugged() const{ return BlueprintObjectsBeingDebugged; };
#endif
 
    UE_API void CreateFXSystem();
 
    UE_API void InitializeSubsystems();
 
    UE_API void PostInitializeSubsystems();
 
#if WITH_EDITOR
 
    UE_API void ChangeFeatureLevel(ERHIFeatureLevel::Type InFeatureLevel, bool bShowSlowProgressDialog = true, bool bForceUpdate = false);
 
    UE_API void ShaderPlatformChanged();
 
    UE_API void RecreateScene(ERHIFeatureLevel::Type InFeatureLevel, bool bBroadcastChange = true);
 
    UE_API void PurgeScene();
 
    UE_API void RestoreScene();
 
    static UE_API void OnAddExtraObjectsToDelete(const TArray<UObject*>& InObjectsToDelete, TSet<UObject*>& OutSecondaryObjects);
 
#endif // WITH_EDITOR
 
    void SetShouldTick(const bool bInShouldTick) { bShouldTick = bInShouldTick; }
 
    bool ShouldTick() const { return bShouldTick; }
 
private:
    TArray<TWeakObjectPtr<class AController> > ControllerList;
 
    TArray<TWeakObjectPtr<class APlayerController> > PlayerControllerList;
 
    TArray<TWeakObjectPtr<ACameraActor> > AutoCameraActorList;
 
    TArray<TWeakObjectPtr<APhysicsVolume> > NonDefaultPhysicsVolumeList;
 
    FPhysScene*                                 PhysicsScene;
    // Note that this should be merged with PhysScene going forward but is needed for now.
 
#if WITH_STATE_STREAM
    IStateStreamManager* StateStreamManager = nullptr;
#endif
 
public:
 
    TSharedPtr<FPhysScene_Chaos> PhysicsScene_Chaos;
 
    TSharedPtr<FPhysScene_Chaos> DefaultPhysicsScene_Chaos;
 
    UE_API UChaosEventRelay* GetChaosEventRelay();
 
    UPROPERTY(Transient)
    TObjectPtr<class UPhysicsFieldComponent> PhysicsField;
 
 
#if WITH_STATE_STREAM
    template<typename T> T& GetStateStream() { return *static_cast<T*>(InternalGetStateStream(T::Id)); }
 
    IStateStreamManager* GetStateStreamManager() { return StateStreamManager; }
 
#endif
 
private:
    enum class EEndOfFrameUpdateLocation
    {
        Immediate,
        Async
    };
 
    inline TArray<TObjectPtr<UActorComponent>>& GetComponentsThatNeedEndOfFrameUpdate(UActorComponent* Component)
    {
        return Component->IsReadyForEarlyEndOfFrameUpdate() ? ComponentsThatNeedEndOfFrameUpdate_AsyncTick : ComponentsThatNeedEndOfFrameUpdate;
    }
 
    inline const TArray<TObjectPtr<UActorComponent>>& GetComponentsThatNeedEndOfFrameUpdate(UActorComponent* Component) const
    {
        return Component->IsReadyForEarlyEndOfFrameUpdate() ? ComponentsThatNeedEndOfFrameUpdate_AsyncTick : ComponentsThatNeedEndOfFrameUpdate;
    }
 
    inline TSet<TObjectPtr<UActorComponent>>& GetComponentsThatNeedEndOfFrameSync(UActorComponent* Component)
    {
        return Component->IsReadyForEarlyEndOfFrameUpdate() ? ComponentsThatNeedPreEndOfFrameSync_AsyncTick : ComponentsThatNeedPreEndOfFrameSync;
    }
 
    UPROPERTY(Transient, NonTransactional)
    TSet<TObjectPtr<UActorComponent>> ComponentsThatNeedPreEndOfFrameSync;
 
    UPROPERTY(Transient, NonTransactional)
    TSet<TObjectPtr<UActorComponent>> ComponentsThatNeedPreEndOfFrameSync_AsyncTick;
 
    UPROPERTY(Transient, NonTransactional)
    TArray<TObjectPtr<UActorComponent>> ComponentsThatNeedEndOfFrameUpdate;
 
    UPROPERTY(Transient, NonTransactional)
    TArray<TObjectPtr<UActorComponent>> ComponentsThatNeedEndOfFrameUpdate_AsyncTick;
 
    UPROPERTY(Transient, NonTransactional)
    TArray<TObjectPtr<UActorComponent>> ComponentsThatNeedEndOfFrameUpdate_OnGameThread;
 
    UPROPERTY(Transient, NonTransactional)
    TArray<TObjectPtr<UActorComponent>> ComponentsThatNeedEndOfFrameMarkRenderStateDirty;
 
    struct FEndOfFrameUpdateContext;
    TArray<FEndOfFrameUpdateContext*> EndOfFrameUpdateContexts;
    TArray<UE::Tasks::FTask> EndOfFrameUpdateTasks;
    UE::Tasks::FTask EndOfFrameUpdatePrerequisiteTask;
 
    void SendAllEndOfFrameUpdatesInternal(EEndOfFrameUpdateLocation Location);
 
    FWorldAsyncTraceState AsyncTraceState;
 
#if !UE_BUILD_SHIPPING
    double AsyncDelegateHitchLoggingLastTimestamp = 0.0;
#endif 
 
#if WITH_EDITOR
    FBlueprintToDebuggedObjectMap BlueprintObjectsBeingDebugged;
#endif
 
    mutable FOnActorSpawned OnActorSpawned;
 
    mutable FOnActorSpawned OnActorPreSpawnInitialization;
 
    mutable FOnActorDestroyed OnActorDestroyed;
 
    mutable FOnPostRegisterAllActorComponents OnPostRegisterAllActorComponents;
 
    mutable FOnPreUnregisterAllActorComponents OnPreUnregisterAllActorComponents;
 
    mutable FOnActorRemovedFromWorld OnActorRemovedFromWorld;
 
    UE_API void ResetAsyncTrace();
 
    UE_API void WaitForAllAsyncTraceTasks();
 
    UE_API void FinishAsyncTrace();
 
    UE_API void RepairSingletonActorOfClass(TSubclassOf<AActor> ActorClass);    
    template <class T> void RepairSingletonActorOfClass() { RepairSingletonActorOfClass(T::StaticClass()); }
 
    UE_API void RepairWorldSettings();
 
    UE_API void RepairSingletonActors();
 
    UE_API void RepairStreamingLevels();
 
    UE_API void RepairChaosActors();
 
#if WITH_EDITOR
    UE_API void RepairDefaultBrush();
#endif
 
    class FTimerManager* TimerManager;
 
    struct FLatentActionManager LatentActionManager;
 
    double BuildStreamingDataTimer;
 
    using FOnNetTickEvent UE_DEPRECATED(5.5, "The FOnNetTickEvent typedef has been deprecated - use TMulticastDelegateRegistration<void(float)> instead.") = TMulticastDelegate<void(float)>;
    using FOnTickFlushEvent UE_DEPRECATED(5.5, "The FOnTickFlushEvent typedef has been deprecated - use TMulticastDelegateRegistration<void()> instead.") = TMulticastDelegate<void()>;
 
    UE_DEPRECATED_FORGAME(5.5, "Public access to TickDispatchEvent has been deprecated - use OnTickDispatch() instead.")
    TMulticastDelegate<void(float)> TickDispatchEvent;
 
    UE_DEPRECATED_FORGAME(5.5, "Public access to PostTickDispatchEvent has been deprecated - use OnPostTickDispatch() instead.")
    TMulticastDelegate<void()> PostTickDispatchEvent;
 
    UE_DEPRECATED_FORGAME(5.5, "Public access to PreTickFlushEvent has been deprecated - use OnPreTickFlush() instead.")
    TMulticastDelegate<void(float)> PreTickFlushEvent;
 
    UE_DEPRECATED_FORGAME(5.5, "Public access to TickFlushEvent has been deprecated - use OnTickFlush() instead.")
    TMulticastDelegate<void(float)> TickFlushEvent;
    
    UE_DEPRECATED_FORGAME(5.5, "Public access to PostTickFlushEvent has been deprecated - use OnPostTickFlush() instead.")
    TMulticastDelegate<void()> PostTickFlushEvent;
 
    UE_API void BroadcastTickDispatch(float DeltaTime);
 
    UE_API void BroadcastPostTickDispatch();
 
    UE_API void BroadcastPreTickFlush(float DeltaTime);
 
    UE_API void BroadcastTickFlush(float DeltaTime);
 
    UE_API void BroadcastPostTickFlush(float DeltaTime);
 
    DECLARE_EVENT(UWorld, FOnLevelsChangedEvent);
    
    FOnLevelsChangedEvent LevelsChangedEvent;
 
    DECLARE_EVENT(UWorld, FOnAllLevelsChangedEvent);
 
    FOnAllLevelsChangedEvent AllLevelsChangedEvent;
 
    DECLARE_EVENT_OneParam(UWorld, FWorldPartitionInitializedEvent, UWorldPartition*);
    
    FWorldPartitionInitializedEvent OnWorldPartitionInitializedEvent;
 
    void BroadcastWorldPartitionInitialized(UWorldPartition* InWorldPartition)
    {
        OnWorldPartitionInitializedEvent.Broadcast(InWorldPartition);
    }
 
    DECLARE_EVENT_OneParam(UWorld, FWorldPartitionUninitializedEvent, UWorldPartition*);
 
    FWorldPartitionUninitializedEvent OnWorldPartitionUninitializedEvent;
 
    void BroadcastWorldPartitionUninitialized(UWorldPartition* InWorldPartition)
    {
        OnWorldPartitionUninitializedEvent.Broadcast(InWorldPartition);
    }
 
    DECLARE_EVENT_ThreeParams(UWorld, FAddLevelToWorldExtensionEvent, ULevel* /*InLevel*/, const bool /*bWaitForCompletion*/, bool& /*bOutHasCompleted*/);
    FAddLevelToWorldExtensionEvent AddLevelToWorldExtensionEvent;
 
    DECLARE_EVENT_ThreeParams(UWorld, FRemoveLevelFromWorldExtensionEvent, ULevel* /*InLevel*/, const bool /*bWaitForCompletion*/, bool& /*bOutHasCompleted*/);
    FRemoveLevelFromWorldExtensionEvent RemoveLevelFromWorldExtensionEvent;
 
    friend FWorldPartitionEvents;
 
#if WITH_EDITOR
 
    UE_API void BroadcastSelectedLevelsChanged();
 
#endif // WITH_EDITOR
 
#if WITH_EDITORONLY_DATA
    DECLARE_EVENT( UWorld, FOnSelectedLevelsChangedEvent);
 
    FOnSelectedLevelsChangedEvent               SelectedLevelsChangedEvent;
 
    UPROPERTY(Transient)
    TArray<TObjectPtr<class ULevel>>                        SelectedLevels;
 
    uint32 bBroadcastSelectionChange:1;
 
    FOnFeatureLevelChanged OnFeatureLevelChanged;
#endif //WITH_EDITORONLY_DATA
 
    FOnMovieSceneSequenceTick MovieSceneSequenceTick;
 
public:
    FURL                                        URL;
 
    class FFXSystemInterface*                   FXSystem;
 
    FStartPhysicsTickFunction StartPhysicsTickFunction;
    FEndPhysicsTickFunction EndPhysicsTickFunction;
 
    int32                                       PlayerNum;
    
    int32                                       StreamingVolumeUpdateDelay;
 
    bool GetShouldForceUnloadStreamingLevels() const { return bShouldForceUnloadStreamingLevels; }
    UE_API void SetShouldForceUnloadStreamingLevels(bool bInShouldForceUnloadStreamingLevels);
 
    bool GetShouldForceVisibleStreamingLevels() const { return bShouldForceVisibleStreamingLevels; }
    UE_API void SetShouldForceVisibleStreamingLevels(bool bInShouldForceVisibleStreamingLevels);
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    FName    DebugDrawTraceTag;
 
    bool bDebugDrawAllTraceTags;
 
    bool DebugDrawSceneQueries(const FName& UsedTraceTag) const
    {
        return (bDebugDrawAllTraceTags || ((DebugDrawTraceTag != NAME_None) && (DebugDrawTraceTag == UsedTraceTag))) && IsInGameThread();
    }
#endif
 
    DECLARE_EVENT_TwoParams(UWorld, FOnBeginPostProcessSettings, FVector, FSceneView*);
    FOnBeginPostProcessSettings OnBeginPostProcessSettings;
 
    UE_API void InsertPostProcessVolume(IInterface_PostProcessVolume* InVolume);
 
    UE_API bool RemovePostProcessVolume(IInterface_PostProcessVolume* InVolume);
 
    UE_API void AddPostProcessingSettings(FVector ViewLocation, FSceneView* SceneView);
 
    TArray< IInterface_PostProcessVolume * > PostProcessVolumes;
 
private:
    TArray<double> PostProcessVolumeCachedSizes;
public:
 
    // TODO: Make this be property UPROPERTY(Transient)
    TArray<class AAudioVolume*> AudioVolumes;
 
    double LastTimeUnbuiltLightingWasEncountered;
 
    double TimeSeconds;
 
    double UnpausedTimeSeconds;
 
    double RealTimeSeconds;
 
    double AudioTimeSeconds;
 
    float DeltaRealTimeSeconds;
 
    float DeltaTimeSeconds;
 
    double PauseDelay;
 
    FIntVector OriginLocation;
 
    FIntVector RequestedOriginLocation;
 
    FVector OriginOffsetThisFrame;
 
    float NextSwitchCountdown;
 
    UPROPERTY()
    TObjectPtr<class UWorldComposition> WorldComposition;
 
    UPROPERTY()
    TObjectPtr<class UContentBundleManager> ContentBundleManager;
    
    EFlushLevelStreamingType FlushLevelStreamingType;
 
    TEnumAsByte<ETravelType> NextTravelType;
 
private:
    uint16 NumStreamingLevelsBeingLoaded; // Move this somewhere better
 
    friend struct FWorldNotifyStreamingLevelLoading;
 
public:
    FString NextURL;
 
    TArray<FName> PreparingLevelNames;
 
    FName CommittedPersistentLevelName;
 
#if !UE_BUILD_SHIPPING || WITH_EDITOR
    uint32 NumLightingUnbuiltObjects;
    
    uint32 NumUnbuiltReflectionCaptures;
 
    int32 NumTextureStreamingUnbuiltComponents;
 
    int32 NumTextureStreamingDirtyResources;
#endif
 
    bool HasMarkedObjectsPendingKill() const { return bMarkedObjectsPendingKill; }
private:
    uint32 bMarkedObjectsPendingKill:1;
 
#if WITH_EDITOR
    uint32 bWorldWasCleanedUp: 1;
#endif
 
    uint32 CleanupWorldTag;
    static UE_API uint32 CleanupWorldGlobalTag;
 
public:
#if WITH_EDITOR
    TArray<TSharedPtr<FAsyncPreRegisterDDCRequest>> AsyncPreRegisterDDCRequests;
#endif
 
    //Experimental: In game performance tracking.
    FWorldInGamePerformanceTrackers* PerfTrackers;
 
    //Tracking for VFX cost for this world.
    mutable FParticlePerfStats* ParticlePerfStats = nullptr;
 
    UE_API UWorld(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
    
    // LINE TRACE
 
    UE_API bool LineTraceTestByChannel(const FVector& Start,const FVector& End,ECollisionChannel TraceChannel, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam, const FCollisionResponseParams& ResponseParam = FCollisionResponseParams::DefaultResponseParam) const;
    
 
    UE_API bool LineTraceTestByObjectType(const FVector& Start,const FVector& End,const FCollisionObjectQueryParams& ObjectQueryParams, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam) const;
 
    UE_API bool LineTraceTestByProfile(const FVector& Start, const FVector& End, FName ProfileName, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam) const;
 
    UE_API bool LineTraceSingleByChannel(struct FHitResult& OutHit,const FVector& Start,const FVector& End,ECollisionChannel TraceChannel,const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam, const FCollisionResponseParams& ResponseParam = FCollisionResponseParams::DefaultResponseParam) const;
 
    UE_API bool LineTraceSingleByObjectType(struct FHitResult& OutHit,const FVector& Start,const FVector& End,const FCollisionObjectQueryParams& ObjectQueryParams, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam) const;
 
    UE_API bool LineTraceSingleByProfile(struct FHitResult& OutHit, const FVector& Start, const FVector& End, FName ProfileName, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam) const;
 
    UE_API bool LineTraceMultiByChannel(TArray<struct FHitResult>& OutHits,const FVector& Start,const FVector& End,ECollisionChannel TraceChannel,const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam, const FCollisionResponseParams& ResponseParam = FCollisionResponseParams::DefaultResponseParam) const;
 
 
    UE_API bool LineTraceMultiByObjectType(TArray<struct FHitResult>& OutHits,const FVector& Start,const FVector& End,const FCollisionObjectQueryParams& ObjectQueryParams, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam) const;
 
 
    UE_API bool LineTraceMultiByProfile(TArray<struct FHitResult>& OutHits, const FVector& Start, const FVector& End, FName ProfileName, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam) const;
 
    UE_API bool SweepTestByChannel(const FVector& Start, const FVector& End, const FQuat& Rot, ECollisionChannel TraceChannel, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam, const FCollisionResponseParams& ResponseParam = FCollisionResponseParams::DefaultResponseParam) const;
 
    UE_API bool SweepTestByObjectType(const FVector& Start, const FVector& End, const FQuat& Rot, const FCollisionObjectQueryParams& ObjectQueryParams, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam) const;
 
 
    UE_API bool SweepTestByProfile(const FVector& Start, const FVector& End, const FQuat& Rot, FName ProfileName, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params) const;
 
    UE_API bool SweepSingleByChannel(struct FHitResult& OutHit, const FVector& Start, const FVector& End, const FQuat& Rot, ECollisionChannel TraceChannel, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam, const FCollisionResponseParams& ResponseParam = FCollisionResponseParams::DefaultResponseParam) const;
 
    UE_API bool SweepSingleByObjectType(struct FHitResult& OutHit, const FVector& Start, const FVector& End, const FQuat& Rot, const FCollisionObjectQueryParams& ObjectQueryParams, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam) const;
 
    UE_API bool SweepSingleByProfile(struct FHitResult& OutHit, const FVector& Start, const FVector& End, const FQuat& Rot, FName ProfileName, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam) const;
 
    UE_API bool SweepMultiByChannel(TArray<struct FHitResult>& OutHits, const FVector& Start, const FVector& End, const FQuat& Rot, ECollisionChannel TraceChannel, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam, const FCollisionResponseParams& ResponseParam = FCollisionResponseParams::DefaultResponseParam) const;
 
    UE_API bool SweepMultiByObjectType(TArray<struct FHitResult>& OutHits, const FVector& Start, const FVector& End, const FQuat& Rot, const FCollisionObjectQueryParams& ObjectQueryParams, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam) const;
 
    UE_API bool SweepMultiByProfile(TArray<FHitResult>& OutHits, const FVector& Start, const FVector& End, const FQuat& Rot, FName ProfileName, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam) const;
 
    UE_API bool OverlapBlockingTestByChannel(const FVector& Pos, const FQuat& Rot, ECollisionChannel TraceChannel, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam, const FCollisionResponseParams& ResponseParam = FCollisionResponseParams::DefaultResponseParam) const;
 
    UE_API bool OverlapAnyTestByChannel(const FVector& Pos, const FQuat& Rot, ECollisionChannel TraceChannel, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam, const FCollisionResponseParams& ResponseParam = FCollisionResponseParams::DefaultResponseParam) const;
 
    UE_API bool OverlapAnyTestByObjectType(const FVector& Pos, const FQuat& Rot, const FCollisionObjectQueryParams& ObjectQueryParams, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam) const;
 
    UE_API bool OverlapBlockingTestByProfile(const FVector& Pos, const FQuat& Rot, FName ProfileName, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam) const;
 
    UE_API bool OverlapAnyTestByProfile(const FVector& Pos, const FQuat& Rot, FName ProfileName, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam) const;
 
    
    UE_API bool OverlapMultiByChannel(TArray<struct FOverlapResult>& OutOverlaps, const FVector& Pos, const FQuat& Rot, ECollisionChannel TraceChannel, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam, const FCollisionResponseParams& ResponseParam = FCollisionResponseParams::DefaultResponseParam) const;
 
 
    UE_API bool OverlapMultiByObjectType(TArray<struct FOverlapResult>& OutOverlaps, const FVector& Pos, const FQuat& Rot, const FCollisionObjectQueryParams& ObjectQueryParams, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam) const;
 
    UE_API bool OverlapMultiByProfile(TArray<struct FOverlapResult>& OutOverlaps, const FVector& Pos, const FQuat& Rot, FName ProfileName, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam) const;
 
    // COMPONENT SWEEP
 
    UE_API bool ComponentSweepMulti(TArray<struct FHitResult>& OutHits, class UPrimitiveComponent* PrimComp, const FVector& Start, const FVector& End, const FQuat& Rot,    const FComponentQueryParams& Params) const;
    bool ComponentSweepMulti(TArray<struct FHitResult>& OutHits, class UPrimitiveComponent* PrimComp, const FVector& Start, const FVector& End, const FRotator& Rot, const FComponentQueryParams& Params) const;
 
    UE_API bool ComponentSweepMultiByChannel(TArray<struct FHitResult>& OutHits, class UPrimitiveComponent* PrimComp, const FVector& Start, const FVector& End, const FQuat& Rot, ECollisionChannel TraceChannel, const FComponentQueryParams& Params) const;
    bool ComponentSweepMultiByChannel(TArray<struct FHitResult>& OutHits, class UPrimitiveComponent* PrimComp, const FVector& Start, const FVector& End, const FRotator& Rot, ECollisionChannel TraceChannel, const FComponentQueryParams& Params) const;
 
    // COMPONENT OVERLAP
 
    UE_API bool ComponentOverlapMulti(TArray<struct FOverlapResult>& OutOverlaps, const class UPrimitiveComponent* PrimComp, const FVector& Pos, const FQuat& Rot,    const FComponentQueryParams& Params = FComponentQueryParams::DefaultComponentQueryParams, const FCollisionObjectQueryParams& ObjectQueryParams=FCollisionObjectQueryParams::DefaultObjectQueryParam) const;
    bool ComponentOverlapMulti(TArray<struct FOverlapResult>& OutOverlaps, const class UPrimitiveComponent* PrimComp, const FVector& Pos, const FRotator& Rot, const FComponentQueryParams& Params = FComponentQueryParams::DefaultComponentQueryParams, const FCollisionObjectQueryParams& ObjectQueryParams=FCollisionObjectQueryParams::DefaultObjectQueryParam) const;
 
    UE_API bool ComponentOverlapMultiByChannel(TArray<struct FOverlapResult>& OutOverlaps, const class UPrimitiveComponent* PrimComp, const FVector& Pos, const FQuat& Rot,    ECollisionChannel TraceChannel, const FComponentQueryParams& Params = FComponentQueryParams::DefaultComponentQueryParams, const FCollisionObjectQueryParams& ObjectQueryParams=FCollisionObjectQueryParams::DefaultObjectQueryParam) const;
    bool ComponentOverlapMultiByChannel(TArray<struct FOverlapResult>& OutOverlaps, const class UPrimitiveComponent* PrimComp, const FVector& Pos, const FRotator& Rot, ECollisionChannel TraceChannel, const FComponentQueryParams& Params = FComponentQueryParams::DefaultComponentQueryParams, const FCollisionObjectQueryParams& ObjectQueryParams=FCollisionObjectQueryParams::DefaultObjectQueryParam) const;
 
 
    UE_API FTraceHandle AsyncLineTraceByChannel(EAsyncTraceType InTraceType, const FVector& Start,const FVector& End, ECollisionChannel TraceChannel, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam, const FCollisionResponseParams& ResponseParam = FCollisionResponseParams::DefaultResponseParam, const FTraceDelegate* InDelegate = nullptr, uint32 UserData = 0 );
 
    UE_API FTraceHandle AsyncLineTraceByObjectType(EAsyncTraceType InTraceType, const FVector& Start,const FVector& End, const FCollisionObjectQueryParams& ObjectQueryParams, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam, const FTraceDelegate* InDelegate = nullptr, uint32 UserData = 0 );
 
    UE_API FTraceHandle AsyncLineTraceByProfile(EAsyncTraceType InTraceType, const FVector& Start, const FVector& End, FName ProfileName, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam, const FTraceDelegate* InDelegate = nullptr, uint32 UserData = 0);
 
    UE_API FTraceHandle AsyncSweepByChannel(EAsyncTraceType InTraceType, const FVector& Start, const FVector& End, const FQuat& Rot, ECollisionChannel TraceChannel, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam, const FCollisionResponseParams& ResponseParam = FCollisionResponseParams::DefaultResponseParam, const FTraceDelegate* InDelegate = nullptr, uint32 UserData = 0);
 
    UE_API FTraceHandle AsyncSweepByObjectType(EAsyncTraceType InTraceType, const FVector& Start, const FVector& End, const FQuat& Rot, const FCollisionObjectQueryParams& ObjectQueryParams, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam, const FTraceDelegate* InDelegate = nullptr, uint32 UserData = 0);
 
    UE_API FTraceHandle AsyncSweepByProfile(EAsyncTraceType InTraceType, const FVector& Start, const FVector& End, const FQuat& Rot, FName ProfileName, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam, const FTraceDelegate* InDelegate = nullptr, uint32 UserData = 0);
 
    // overlap functions
 
    UE_API FTraceHandle AsyncOverlapByChannel(const FVector& Pos, const FQuat& Rot, ECollisionChannel TraceChannel, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam, const FCollisionResponseParams& ResponseParam = FCollisionResponseParams::DefaultResponseParam, const FOverlapDelegate* InDelegate = nullptr, uint32 UserData = 0);
 
    UE_API FTraceHandle AsyncOverlapByObjectType(const FVector& Pos, const FQuat& Rot, const FCollisionObjectQueryParams& ObjectQueryParams, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam, const FOverlapDelegate* InDelegate = nullptr, uint32 UserData = 0);
 
    UE_API FTraceHandle AsyncOverlapByProfile(const FVector& Pos, const FQuat& Rot, FName ProfileName, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Params = FCollisionQueryParams::DefaultQueryParam, const FOverlapDelegate* InDelegate = nullptr, uint32 UserData = 0);
 
    UE_API bool QueryTraceData(const FTraceHandle& Handle, FTraceDatum& OutData);
 
    UE_API bool QueryOverlapData(const FTraceHandle& Handle, FOverlapDatum& OutData);
    UE_API bool IsTraceHandleValid(const FTraceHandle& Handle, bool bOverlapTrace);
 
private:
    friend class FPhysicsAsyncQueryReporter;
    UE_API void AddTraceData(const FTraceHandle& Handle, const TArray<FHitResult>& Results);
    UE_API void AddOverlapData(const FTraceHandle& Handle, const TArray<FOverlapResult>& Results);
    
    static UE_API void GetCollisionProfileChannelAndResponseParams(FName ProfileName, ECollisionChannel& CollisionChannel, FCollisionResponseParams& ResponseParams);
 
public:
 
    inline UNavigationSystemBase* GetNavigationSystem() { return NavigationSystem; }
    inline const UNavigationSystemBase* GetNavigationSystem() const { return NavigationSystem; }
 
    UE_API UAISystemBase* CreateAISystem();
 
    inline UAISystemBase* GetAISystem() { return AISystem; }
    inline const UAISystemBase* GetAISystem() const { return AISystem; }
    
    inline class UAvoidanceManager* GetAvoidanceManager() { return AvoidanceManager; }
    inline const class UAvoidanceManager* GetAvoidanceManager() const { return AvoidanceManager; }
 
    UE_API FConstControllerIterator GetControllerIterator() const;
 
    UE_API int32 GetNumControllers() const;
    
    UE_API FConstPlayerControllerIterator GetPlayerControllerIterator() const;
 
    UE_API int32 GetNumPlayerControllers() const;
    
    template< class T >
    T* GetFirstPlayerController() const
    {
        return Cast<T>(GetFirstPlayerController());
    }
    
    UE_API APlayerController* GetFirstPlayerController() const;
    
    /*
     *  Get the first valid local player via the first player controller.
     *
     *  @return Pointer to the first valid ULocalPlayer cast to the template type, or NULL if there is not one.
     *
     *  May Return NULL if the cast fails.
     */ 
    template< class T >
    T* GetFirstLocalPlayerFromController() const
    {
        return Cast<T>(GetFirstLocalPlayerFromController());
    }
 
    /*
     *  Get the first valid local player via the first player controller.
     *
     *  @return Pointer to the first valid ULocalPlayer, or NULL if there is not one.
     */ 
    UE_API ULocalPlayer* GetFirstLocalPlayerFromController() const;
 
    UE_API void RegisterAutoActivateCamera(ACameraActor* CameraActor, int32 PlayerIndex);
 
    UE_API FConstCameraActorIterator GetAutoActivateCameraIterator() const;
    
    UE_API UGameViewportClient* GetGameViewport() const;
 
public:
 
    UE_API ABrush* GetDefaultBrush() const;
 
    UE_API bool AreActorsInitialized() const;
 
    using FActorsInitializedParams = ::FActorsInitializedParams;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnWorldInitializedActors, const FActorsInitializedParams&);
    FOnWorldInitializedActors OnActorsInitialized;
 
    DECLARE_MULTICAST_DELEGATE(FOnWorldBeginPlay);
    FOnWorldBeginPlay OnWorldBeginPlay;
 
    DECLARE_MULTICAST_DELEGATE(FOnMatchStarting);
    FOnMatchStarting OnWorldMatchStarting;
 
    DECLARE_MULTICAST_DELEGATE(FOnWorldPreBeginPlay);
    FOnWorldPreBeginPlay OnWorldPreBeginPlay;
 
    UE_API bool HasBegunPlay() const;
 
    double GetTimeSeconds() const;
 
    double GetUnpausedTimeSeconds() const;
 
    double GetRealTimeSeconds() const;
 
    double GetAudioTimeSeconds() const;
 
    float GetDeltaSeconds() const;
    
    FGameTime GetTime() const;
 
    double TimeSince(double Time) const;
 
    UE_API void CreatePhysicsScene(const AWorldSettings* Settings = nullptr);
 
    FPhysScene* GetPhysicsScene() const { return PhysicsScene; }
 
    UE_API void SetPhysicsScene(FPhysScene* InScene);
 
    APhysicsVolume* GetDefaultPhysicsVolume() const { return DefaultPhysicsVolume ? ToRawPtr(DefaultPhysicsVolume) : InternalGetDefaultPhysicsVolume(); }
 
    bool HasDefaultPhysicsVolume() const { return DefaultPhysicsVolume != nullptr; }
 
    UE_API void AddPhysicsVolume(APhysicsVolume* Volume);
 
    UE_API void RemovePhysicsVolume(APhysicsVolume* Volume);
 
    FConstPhysicsVolumeIterator GetNonDefaultPhysicsVolumeIterator() const;
 
    int32 GetNonDefaultPhysicsVolumeCount() const;
 
    UE_API void SetAllowDeferredPhysicsStateCreation(bool bAllow);
    UE_API bool GetAllowDeferredPhysicsStateCreation() const;
 
    UE_API class ALevelScriptActor* GetLevelScriptActor( class ULevel* OwnerLevel=NULL ) const;
 
    UFUNCTION(BlueprintCallable, Category="Utilities|World", meta=(DisplayName="GetWorldSettings", ScriptName="GetWorldSettings"))
    UE_API AWorldSettings* K2_GetWorldSettings();
    UE_API AWorldSettings* GetWorldSettings( bool bCheckStreamingPersistent = false, bool bChecked = true ) const;
 
    UE_API AWorldDataLayers* GetWorldDataLayers() const;
    UE_API void SetWorldDataLayers(AWorldDataLayers* NewWorldDataLayers);
 
    UE_API FString GetDebugDisplayName() const;
    UE_API UWorldPartition* GetWorldPartition() const;
 
    UFUNCTION(BlueprintCallable, Category = "Utilities|WorldPartition")
    UE_API UDataLayerManager* GetDataLayerManager() const;
 
    bool IsPartitionedWorld() const { return GetWorldPartition() != nullptr; }
 
    static bool IsPartitionedWorld(const UWorld* InWorld)
    {
        if (InWorld)
        {
            return InWorld->IsPartitionedWorld();
        }
 
        return false;
    }
 
    FWorldPartitionInitializedEvent& OnWorldPartitionInitialized() { return OnWorldPartitionInitializedEvent; }
    FWorldPartitionUninitializedEvent& OnWorldPartitionUninitialized() { return OnWorldPartitionUninitializedEvent; }
        
    UE_API UModel* GetModel() const;
 
    UE_API float GetGravityZ() const;
 
    UE_API float GetDefaultGravityZ() const;
 
    UE_API const FString GetMapName() const;
    
    bool RequiresHitProxies() const 
    {
        return bRequiresHitProxies;
    }
 
    UE_API void AddController( AController* Controller );
    
    UE_API void RemoveController( AController* Controller );
    
    UE_API void AddNetworkActor( AActor* Actor );
    
    UE_API void RemoveNetworkActor( AActor* Actor ) const;
 
    UE_API FDelegateHandle AddOnActorSpawnedHandler( const FOnActorSpawned::FDelegate& InHandler ) const;
 
    UE_API void RemoveOnActorSpawnedHandler( FDelegateHandle InHandle ) const;
 
    UE_API void OnActorFinishedSpawning(AActor* Actor);
 
    UE_API FDelegateHandle AddOnActorPreSpawnInitialization(const FOnActorSpawned::FDelegate& InHandler) const;
 
    UE_API void RemoveOnActorPreSpawnInitialization(FDelegateHandle InHandle) const;
 
    UE_API FDelegateHandle AddOnActorDestroyedHandler(const FOnActorDestroyed::FDelegate& InHandler) const;
 
    UE_DEPRECATED(5.5, "Use the typo corrected version RemoveOnActorDestroyedHandler")
    UE_API void RemoveOnActorDestroyededHandler(FDelegateHandle InHandle) const;
    UE_API void RemoveOnActorDestroyedHandler(FDelegateHandle InHandle) const;
 
    UE_API FDelegateHandle AddOnPostRegisterAllActorComponentsHandler(const FOnPostRegisterAllActorComponents::FDelegate& InHandler) const;
 
    UE_API void RemoveOnPostRegisterAllActorComponentsHandler(FDelegateHandle InHandle) const;
 
    UE_API void NotifyPostRegisterAllActorComponents(AActor* Actor);
 
    UE_API FDelegateHandle AddOnPreUnregisterAllActorComponentsHandler(const FOnPreUnregisterAllActorComponents::FDelegate& InHandler) const;
 
    UE_API void RemoveOnPreUnregisterAllActorComponentsHandler(FDelegateHandle InHandle) const;
 
    UE_API void NotifyPreUnregisterAllActorComponents(AActor* Actor);
 
    UE_API FDelegateHandle AddOnActorRemovedFromWorldHandler(const FOnActorRemovedFromWorld::FDelegate& InHandler) const;
 
    UE_API void RemoveOnActorRemovedFromWorldHandler(FDelegateHandle InHandle) const;
 
    UE_API bool ContainsActor( AActor* Actor ) const;
 
    UE_API bool AllowAudioPlayback() const;
 
    UE_API FDelegateHandle AddMovieSceneSequenceTickHandler(const FOnMovieSceneSequenceTick::FDelegate& InHandler);
    UE_API void RemoveMovieSceneSequenceTickHandler(FDelegateHandle InHandle);
    UE_API bool IsMovieSceneSequenceTickHandlerBound() const;
 
    //~ Begin UObject Interface
    UE_API virtual void Serialize( FArchive& Ar ) override;
    UE_API virtual void BeginDestroy() override;
    UE_API virtual void FinishDestroy() override;
    UE_API virtual bool IsReadyForFinishDestroy() override;
    UE_API virtual void PostLoad() override;
#if WITH_EDITORONLY_DATA
    static UE_API void DeclareConstructClasses(TArray<FTopLevelAssetPath>& OutConstructClasses, const UClass* SpecificSubclass);
#endif
    UE_API virtual void PreDuplicate(FObjectDuplicationParameters& DupParams) override;
    UE_API virtual void PreSaveRoot(FObjectPreSaveRootContext ObjectSaveContext) override;
    UE_API virtual void PostSaveRoot(FObjectPostSaveRootContext ObjectSaveContext) override;
    UE_API virtual UWorld* GetWorld() const override;
    UE_API virtual FPrimaryAssetId GetPrimaryAssetId() const override;
    static UE_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
#if WITH_EDITOR
    UE_API virtual EDataValidationResult IsDataValid(FDataValidationContext& Context) const override;
    UE_API virtual bool Rename(const TCHAR* NewName = NULL, UObject* NewOuter = NULL, ERenameFlags Flags = REN_None) override;
    UE_API virtual void GetAssetRegistryTags(FAssetRegistryTagsContext Context) const override;
    UE_DEPRECATED(5.4, "Implement the version that takes FAssetRegistryTagsContext instead.")
    UE_API virtual void GetAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const override;
    UE_API virtual void GetAssetRegistryTagMetadata(TMap<FName, FAssetRegistryTagMetadata>& OutMetadata) const override;
    UE_API virtual void GetExtendedAssetRegistryTagsForSave(const ITargetPlatform* TargetPlatform, TArray<FAssetRegistryTag>& OutTags) const override;
protected:
    UE_API virtual void ThreadedPostLoadAssetRegistryTagsOverride(FPostLoadAssetRegistryTagsContext& Context) const;
public:
    UE_API virtual bool IsNameStableForNetworking() const override;
#endif
    UE_API virtual bool ResolveSubobject(const TCHAR* SubObjectPath, UObject*& OutObject, bool bLoadIfExists) override;
    UE_API virtual void PostDuplicate(bool bDuplicateForPIE) override;
    //~ End UObject Interface
    
    UE_API void ClearWorldComponents();
 
    UE_API void UpdateWorldComponents(bool bRerunConstructionScripts, bool bCurrentLevelOnly, FRegisterComponentContext* Context = nullptr);
 
    UE_API bool UpdateCullDistanceVolumes(AActor* ActorToUpdate = nullptr, UPrimitiveComponent* ComponentToUpdate = nullptr);
 
    UE_API void CleanupWorld(bool bSessionEnded = true, bool bCleanupResources = true, UWorld* NewWorld = nullptr);
    
    UE_API void InvalidateModelGeometry( ULevel* InLevel );
 
    UE_API void InvalidateModelSurface(bool bCurrentLevelOnly);
 
    UE_API void CommitModelSurfaces();
 
    UE_API void InvalidateAllSkyCaptures();
 
    UE_API void UpdateAllSkyCaptures();
 
    UE_API ULevel* GetActiveLightingScenario() const;
 
    UE_API void PropagateLightingScenarioChange();
 
    UE_API void AddToWorld(ULevel* Level, const FTransform& LevelTransform = FTransform::Identity, bool bConsiderTimeLimit = false, const TOptional<const UE::FTimeout>& ExternalTimeout = TOptional<const UE::FTimeout>(), FNetLevelVisibilityTransactionId TransactionId = FNetLevelVisibilityTransactionId(), ULevelStreaming* OwningLevelStreaming = nullptr);
 
    UE_DEPRECATED(5.6, "Use version that requires passing the ExternalTimout, bConsiderTimeLimit now defaults to false to match common usage")
    void AddToWorld(ULevel* Level, const FTransform& LevelTransform, bool bConsiderTimeLimit, FNetLevelVisibilityTransactionId TransactionId, ULevelStreaming* OwningLevelStreaming = nullptr)
    {
        AddToWorld(Level, LevelTransform, bConsiderTimeLimit, TOptional<const UE::FTimeout>(), TransactionId, OwningLevelStreaming);
    }
 
    UE_API void RemoveFromWorld(ULevel* Level, bool bAllowIncrementalRemoval = false, const TOptional<const UE::FTimeout>& ExternalTimeout = TOptional<const UE::FTimeout>(), FNetLevelVisibilityTransactionId TransactionId = FNetLevelVisibilityTransactionId(), ULevelStreaming* OwningLevelStreaming = nullptr);
 
    UE_DEPRECATED(5.6, "Use version that requires passing the optional ExternalTimout")
    void RemoveFromWorld(ULevel* Level, bool bAllowIncrementalRemoval, FNetLevelVisibilityTransactionId TransactionId, ULevelStreaming* OwningLevelStreaming = nullptr)
    {
        RemoveFromWorld(Level, bAllowIncrementalRemoval, TOptional<const UE::FTimeout>(), TransactionId, OwningLevelStreaming);
    }
    UE_API void UpdateLevelStreaming(const TOptional<const UE::FTimeout>& ExternalTimeout = TOptional<const UE::FTimeout>());
 
    UE_API void ReleasePhysicsScene();
public:
    UE_API void FlushLevelStreaming(EFlushLevelStreamingType FlushType = EFlushLevelStreamingType::Full);
 
    UE_API void TriggerStreamingDataRebuild();
 
    UE_API void ConditionallyBuildStreamingData();
 
    UE_API bool IsVisibilityRequestPending() const;
 
    UE_API bool AreAlwaysLoadedLevelsLoaded() const;
 
    UE_API void AsyncLoadAlwaysLoadedLevelsForSeamlessTravel();
 
    UE_API bool AllowLevelLoadRequests() const;
 
    UE_API void SetupParameterCollectionInstances();
 
    UE_API void AddParameterCollectionInstance(class UMaterialParameterCollection* Collection, bool bUpdateScene);
 
    UE_API UMaterialParameterCollectionInstance* GetParameterCollectionInstance(const UMaterialParameterCollection* Collection) const;
 
    UE_API void UpdateParameterCollectionInstances(bool bUpdateInstanceUniformBuffers, bool bRecreateUniformBuffer);
 
    /* clean up any material parameter collection instances which have had their collections destroyed */
    UE_API void OnPostGC(); 
 
private:
    UE_API UMaterialParameterCollectionInstance* CreateParameterCollectionInstance(int32 ExistingIndex, UMaterialParameterCollection* Collection, bool bUpdateScene);
 
    UE_API bool HasAsyncLevelRequests();
 
    UE_API void FlushAsyncLevelRequests();
 
public:
 
    UE_API UCanvas* GetCanvasForRenderingToTarget();
    UE_API UCanvas* GetCanvasForDrawMaterialToRenderTarget();
 
    // Legacy for backwards compatibility
    using InitializationValues = FWorldInitializationValues;
 
    UE_API void InitWorld(const FWorldInitializationValues IVS = FWorldInitializationValues());
#if WITH_EDITOR
    static UE_API const FName KeepInitializedDuringLoadTag;
    UE_DEPRECATED(5.2, "Call IsInitialized instead.")
    bool IsInitializedAndNeedsCleanup() const { return bIsWorldInitialized; }
    bool HasEverBeenInitialized() const { return bHasEverBeenInitialized; }
 
    UE_API void ReInitWorld();
#endif
 
    bool IsInitialized() const { return bIsWorldInitialized; }
 
    UE_API void InitializeNewWorld(const InitializationValues IVS = InitializationValues(), bool bInSkipInitWorld = false);
    
    static UE_API UWorld* CreateWorld( const EWorldType::Type InWorldType, bool bInformEngineOfWorld, FName WorldName = NAME_None, UPackage* InWorldPackage = NULL, bool bAddToRoot = true, ERHIFeatureLevel::Type InFeatureLevel = ERHIFeatureLevel::Num, const InitializationValues* InIVS = nullptr, bool bInSkipInitWorld = false);
 
    UE_API void DestroyWorld( bool bInformEngineOfWorld, UWorld* NewWorld = nullptr );
 
    bool IsBeingCleanedUp() const { return bIsBeingCleanedUp; }
 
    bool IsCleanedUp() const { return CleanupWorldTag != 0; }
 
#if WITH_EDITOR
    void ResetCleanedUpState() { CleanupWorldTag = 0; }
#endif
 
 
    UE_API void MarkObjectsPendingKill();
 
    UE_API void CleanupActors();    
 
public:
 
    UE_API TMulticastDelegateRegistration<void(float)>& OnTickDispatch();
    UE_API TMulticastDelegateRegistration<void()>& OnPostTickDispatch();
    UE_API TMulticastDelegateRegistration<void(float)>& OnPreTickFlush();
    UE_API TMulticastDelegateRegistration<void(float)>& OnTickFlush();
    UE_API TMulticastDelegateRegistration<void()>& OnPostTickFlush();
 
    UE_API void Tick( ELevelTick TickType, float DeltaSeconds );
 
    UE_API void SetupPhysicsTickFunctions(float DeltaSeconds);
 
    UE_API void RunTickGroup(ETickingGroup Group, bool bBlockTillComplete);
 
#if UE_WITH_PSO_PRECACHING
    UE_API void AddPrimitiveComponentPSOPrecacheCompleted(UPrimitiveComponent* Component);
#endif
 
    UE_API void MarkActorComponentForNeededEndOfFrameUpdate(UActorComponent* Component, bool bForceGameThread);
 
    UE_API void ClearActorComponentEndOfFrameUpdate(UActorComponent* Component);
 
#if WITH_EDITOR
    UE_API void UpdateActorComponentEndOfFrameUpdateState(UActorComponent* Component) const;
#endif
 
    UE_API void SetMaterialParameterCollectionInstanceNeedsUpdate();
 
    UE_API bool HasEndOfFrameUpdates() const;
 
    UE_API void SendAllEndOfFrameUpdates();
 
    UE_API void StartAsyncSendAllEndOfFrameUpdates();
 
    UE_API void FinishAsyncSendAllEndOfFrameUpdates();
 
    UE_API void FlushDeferredParameterCollectionInstanceUpdates();
 
    UE_API void TickNetClient( float DeltaSeconds );
 
    UE_API void ProcessLevelStreamingVolumes(FVector* OverrideViewLocation=NULL);
 
    /*
     * Updates world's level streaming state using active game players view and blocks until all sub - levels are loaded / visible / hidden
     * so further calls to UpdateLevelStreaming won't do any work unless state changes.
     */
    UE_API void BlockTillLevelStreamingCompleted();
 
    UE_API void ModifyLevel(ULevel* Level) const;
 
    UE_API void EnsureCollisionTreeIsBuilt();
 
    FAddLevelToWorldExtensionEvent& OnAddLevelToWorldExtension()
    {
        return AddLevelToWorldExtensionEvent;
    }
 
    FRemoveLevelFromWorldExtensionEvent& OnRemoveLevelFromWorldExtension()
    {
        return RemoveLevelFromWorldExtensionEvent;
    }
 
#if WITH_EDITOR 
    FOnSelectedLevelsChangedEvent& OnSelectedLevelsChanged() { return SelectedLevelsChangedEvent; }
 
    UE_API void SelectLevel( ULevel* InLevel );
    
    UE_API void DeSelectLevel( ULevel* InLevel );
 
    UE_API bool IsLevelSelected( ULevel* InLevel ) const;
 
    UE_API void SetSelectedLevels( const TArray<class ULevel*>& InLevels );
 
    UE_API int32 GetNumSelectedLevels() const;
    
    UE_API ULevel* GetSelectedLevel( int32 InLevelIndex ) const;
 
    UE_API TArray<TObjectPtr<class ULevel>>& GetSelectedLevels();
 
    UE_API void ShrinkLevel();
 
    UE_API FDelegateHandle AddOnFeatureLevelChangedHandler(const FOnFeatureLevelChanged::FDelegate& InHandler);
 
    UE_API void RemoveOnFeatureLevelChangedHandler(FDelegateHandle InHandle);
#endif // WITH_EDITOR
    
    UE_API FConstLevelIterator      GetLevelIterator() const;
 
    UE_API ULevel* GetLevel( int32 InLevelIndex ) const;
 
    UE_API bool ContainsLevel( ULevel* InLevel ) const;
 
    UE_API int32 GetNumLevels() const;
 
    UE_API const TArray<class ULevel*>& GetLevels() const;
 
    UE_API bool AddLevel( ULevel* InLevel );
    
    UE_API bool RemoveLevel( ULevel* InLevel );
 
    UE_API FLevelCollection& FindOrAddCollectionForLevelStreaming(const ULevelStreaming* Level);
 
    UE_API FLevelCollection& FindOrAddCollectionByType(const ELevelCollectionType InType);
 
    UE_API int32 FindOrAddCollectionByType_Index(const ELevelCollectionType InType);
 
    UE_API FLevelCollection* FindCollectionByType(const ELevelCollectionType InType);
 
    UE_API const FLevelCollection* FindCollectionByType(const ELevelCollectionType InType) const;
 
    UE_API int32 FindCollectionIndexByType(const ELevelCollectionType InType) const;
    
    UE_API const FLevelCollection* GetActiveLevelCollection() const;
 
    int32 GetActiveLevelCollectionIndex() const { return ActiveLevelCollectionIndex; }
 
    UE_API void SetActiveLevelCollection(int32 LevelCollectionIndex);
 
    const TArray<FLevelCollection>& GetLevelCollections() const { return LevelCollections; }
 
    UE_API void DuplicateRequestedLevels(const FName MapName);
 
    UE_API bool Exec( UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar=*GLog );
 
private:
    void ReleaseScene();
 
    UE_API void CleanupWorldInternal(bool bSessionEnded, bool bCleanupResources, bool bWorldChanged);
 
    UE_API bool HandleTraceTagCommand( const TCHAR* Cmd, FOutputDevice& Ar );
 
    UE_API bool HandleFlushPersistentDebugLinesCommand( const TCHAR* Cmd, FOutputDevice& Ar );
 
    UE_API bool HandleLogActorCountsCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
 
    UE_API bool HandleDemoRecordCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
 
    UE_API bool HandleDemoPlayCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
 
    UE_API bool HandleDemoStopCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
 
    UE_API bool HandleDemoScrubCommand(const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld);
 
    UE_API bool HandleDemoPauseCommand(const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld);
 
    UE_API bool HandleDemoSpeedCommand(const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld);
 
    UE_API bool HandleDemoCheckpointCommand(const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld);
 
public:
 
    // Destroys the current demo net driver
    UE_API void DestroyDemoNetDriver();
 
    // Remove internal references to pending demo net driver when starting a replay, but do not destroy it
    UE_API void ClearDemoNetDriver();
 
    // Remove all internal references to this net driver, but do not destroy it. Called by the engine when destroying the driver.
    UE_API void ClearNetDriver(UNetDriver* Driver);
 
    UE_API bool IsPlayingReplay() const;
 
    UE_API bool IsRecordingReplay() const;
 
    // Start listening for connections.
    UE_API bool Listen( FURL& InURL );
 
    UE_API bool IsPaused() const;
 
    UE_API bool IsCameraMoveable() const;
 
    UE_API bool EditorDestroyActor( AActor* Actor, bool bShouldModifyLevel );
 
    UE_API bool DestroyActor( AActor* Actor, bool bNetForce=false, bool bShouldModifyLevel=true );
 
    UE_API void RemoveActor( AActor* Actor, bool bShouldModifyLevel ) const;
 
    UE_API AActor* SpawnActor( UClass* InClass, FVector const* Location=NULL, FRotator const* Rotation=NULL, const FActorSpawnParameters& SpawnParameters = FActorSpawnParameters() );
    UE_API AActor* SpawnActor( UClass* Class, FTransform const* Transform, const FActorSpawnParameters& SpawnParameters = FActorSpawnParameters());
 
    UE_API AActor* SpawnActorAbsolute( UClass* Class, FTransform const& AbsoluteTransform, const FActorSpawnParameters& SpawnParameters = FActorSpawnParameters());
 
    template< class T >
    T* SpawnActor( const FActorSpawnParameters& SpawnParameters = FActorSpawnParameters() )
    {
        return CastChecked<T>(SpawnActor(T::StaticClass(), NULL, NULL, SpawnParameters),ECastCheckedType::NullAllowed);
    }
 
    template< class T >
    T* SpawnActor( FVector const& Location, FRotator const& Rotation, const FActorSpawnParameters& SpawnParameters = FActorSpawnParameters() )
    {
        return CastChecked<T>(SpawnActor(T::StaticClass(), &Location, &Rotation, SpawnParameters),ECastCheckedType::NullAllowed);
    }
    
    template< class T >
    T* SpawnActor( UClass* Class, const FActorSpawnParameters& SpawnParameters = FActorSpawnParameters() )
    {
        return CastChecked<T>(SpawnActor(Class, NULL, NULL, SpawnParameters),ECastCheckedType::NullAllowed);
    }
 
    template< class T >
    T* SpawnActor( UClass* Class, FVector const& Location, FRotator const& Rotation, const FActorSpawnParameters& SpawnParameters = FActorSpawnParameters() )
    {
        return CastChecked<T>(SpawnActor(Class, &Location, &Rotation, SpawnParameters),ECastCheckedType::NullAllowed);
    }
    template< class T >
    T* SpawnActor(UClass* Class, FTransform const& Transform,const FActorSpawnParameters& SpawnParameters = FActorSpawnParameters())
    {
        return CastChecked<T>(SpawnActor(Class, &Transform, SpawnParameters), ECastCheckedType::NullAllowed);
    }
 
    template< class T >
    T* SpawnActorAbsolute(FVector const& AbsoluteLocation, FRotator const& AbsoluteRotation, const FActorSpawnParameters& SpawnParameters = FActorSpawnParameters())
    {
        return CastChecked<T>(SpawnActorAbsolute(T::StaticClass(), FTransform(AbsoluteRotation, AbsoluteLocation), SpawnParameters), ECastCheckedType::NullAllowed);
    }
 
    template< class T >
    T* SpawnActorAbsolute(UClass* Class, FTransform const& Transform,const FActorSpawnParameters& SpawnParameters = FActorSpawnParameters())
    {
        return CastChecked<T>(SpawnActorAbsolute(Class, Transform, SpawnParameters), ECastCheckedType::NullAllowed);
    }
 
    template< class T >
    T* SpawnActorDeferred(
        UClass* Class,
        FTransform const& Transform,
        AActor* Owner = nullptr,
        APawn* Instigator = nullptr,
        ESpawnActorCollisionHandlingMethod CollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::Undefined,
        ESpawnActorScaleMethod TransformScaleMethod = ESpawnActorScaleMethod::MultiplyWithRoot
        )
    {
        if( Owner )
        {
            check(this==Owner->GetWorld());
        }
        FActorSpawnParameters SpawnInfo;
        SpawnInfo.SpawnCollisionHandlingOverride = CollisionHandlingOverride;
        SpawnInfo.TransformScaleMethod = TransformScaleMethod;
        SpawnInfo.Owner = Owner;
        SpawnInfo.Instigator = Instigator;
        SpawnInfo.bDeferConstruction = true;
        return (Class != nullptr) ? Cast<T>(SpawnActor(Class, &Transform, SpawnInfo)) : nullptr;
    }
 
    template< class T >
    T* GetAuthGameMode() const
    {
        return Cast<T>(AuthorityGameMode);
    }
 
    AGameModeBase* GetAuthGameMode() const { return AuthorityGameMode; }
    
    template< class T >
    T* GetGameState() const
    {
        return Cast<T>(GameState);
    }
 
    template<class T>
    T* GetGameStateChecked() const
    {
        return CastChecked<T>(GameState);
    }
 
    AGameStateBase* GetGameState() const { return GameState; }
 
    UE_API void SetGameState(AGameStateBase* NewGameState);
 
    UE_API void CopyGameState(AGameModeBase* FromGameMode, AGameStateBase* FromGameState);
 
    DECLARE_EVENT_OneParam(UWorld, FOnGameStateSetEvent, AGameStateBase*);
    FOnGameStateSetEvent GameStateSetEvent;
 
 
    UE_API ABrush*  SpawnBrush();
 
    UE_API APlayerController* SpawnPlayActor(class UPlayer* Player, ENetRole RemoteRole, const FURL& InURL, const FUniqueNetIdRepl& UniqueId, FString& Error, uint8 InNetPlayerIndex = 0, int32 InLocalPlayerIdentifier = 0);
    
    UE_API bool FindTeleportSpot( const AActor* TestActor, FVector& PlaceLocation, FRotator PlaceRotation );
 
    UE_API bool EncroachingBlockingGeometry( const AActor* TestActor, FVector TestLocation, FRotator TestRotation, FVector* ProposedAdjustment = NULL );
 
    UE_API void StartPhysicsSim();
 
    UE_API void FinishPhysicsSim();
 
    UE_API bool SetGameMode(const FURL& InURL);
 
    UE_API void InitializeActorsForPlay(const FURL& InURL, bool bResetTime = true, FRegisterComponentContext* Context = nullptr);
 
    UE_API void BeginTearingDown();
 
    UE_API void BeginPlay();
 
    UE_API bool EndPlay(EEndPlayReason::Type EndPlayReason);
 
    UE_API bool DestroySwappedPC(UNetConnection* Connection);
 
    //~ Begin FNetworkNotify Interface
    UE_API virtual EAcceptConnection::Type NotifyAcceptingConnection() override;
    UE_API virtual void NotifyAcceptedConnection( class UNetConnection* Connection ) override;
    UE_API virtual bool NotifyAcceptingChannel( class UChannel* Channel ) override;
    UE_API virtual void NotifyControlMessage(UNetConnection* Connection, uint8 MessageType, class FInBunch& Bunch) override;
    //~ End FNetworkNotify Interface
 
    UE_API bool PreLoginCheckError(UNetConnection* Connection, const FString& ErrorMsg);
 
    UE_API void PreLoginComplete(const FString& ErrorMsg, TWeakObjectPtr<UNetConnection> WeakConnection);
 
    UE_API void PreLoginCompleteSplit(const FString& ErrorMsg, TWeakObjectPtr<UNetConnection> WeakConnection, FUniqueNetIdRepl SplitRequestUniqueIdRepl, FString SplitRequestURL);
 
    UE_API void WelcomePlayer(UNetConnection* Connection);
 
    inline UNetDriver* GetNetDriver() const
    {
        return NetDriver;
    }
 
    ENetMode GetNetMode() const;
 
    bool IsNetMode(ENetMode Mode) const;
 
private:
 
    UE_API ENetMode InternalGetNetMode() const;
 
    UE_API ENetMode AttemptDeriveFromURL() const;
 
    UE_API APhysicsVolume* InternalGetDefaultPhysicsVolume() const;
 
    UE_API void InternalUpdateStreamingState();
 
#if WITH_STATE_STREAM
    UE_API void* InternalGetStateStream(uint32 Id);
#endif
 
#if WITH_EDITOR
public:
    void SetPlayInEditorInitialNetMode(ENetMode InNetMode)
    {
        PlayInEditorNetMode = InNetMode;
 
        // Disable audio playback on PIE dedicated server
        bAllowAudioPlayback = bAllowAudioPlayback && PlayInEditorNetMode != NM_DedicatedServer;
    }
 
private:
    ENetMode PlayInEditorNetMode;
#endif
 
public:
 
    void SetNetDriver(UNetDriver* NewDriver)
    {
        NetDriver = NewDriver;
    }
 
    UE_API bool IsRecordingClientReplay() const;
 
    UE_API bool IsPlayingClientReplay() const;
 
    void DelayStreamingVolumeUpdates(int32 InFrameDelay)
    {
        StreamingVolumeUpdateDelay = InFrameDelay;
    }
 
    UE_API void TransferBlueprintDebugReferences(UWorld* NewWorld);
 
    UE_API void NotifyOfBlueprintDebuggingAssociation(class UBlueprint* Blueprint, UObject* DebugObject);
 
    UE_API void BroadcastLevelsChanged();
 
    FOnLevelsChangedEvent& OnLevelsChanged() { return LevelsChangedEvent; }
 
    FOnAllLevelsChangedEvent& OnAllLevelsChanged() { return AllLevelsChangedEvent; }
 
    UE_API int32 GetProgressDenominator() const;
    
    UE_API int32 GetActorCount() const;
    
public:
 
    UE_API class AAudioVolume* GetAudioSettings( const FVector& ViewLocation, struct FReverbSettings* OutReverbSettings, struct FInteriorSettings* OutInteriorSettings ) const;
 
    UE_API void SetAudioDevice(const FAudioDeviceHandle& InHandle);
 
    UE_API FAudioDeviceHandle GetAudioDevice() const;
 
    UE_API class FAudioDevice* GetAudioDeviceRaw() const;
 
    UE_API FString GetLocalURL() const;
 
    UE_API bool IsPlayInEditor() const;
 
    UE_API bool IsPlayInPreview() const;
 
    UE_API bool IsPlayInMobilePreview() const;
 
    UE_DEPRECATED(5.7, "PlayInVulkanPreview is no longer supported, please use PlayInMobilePreview instead")
    bool IsPlayInVulkanPreview() const { return false; };
 
    UE_API bool IsGameWorld() const;
 
    UE_API bool IsEditorWorld() const;
 
    UE_API bool IsPreviewWorld() const;
 
    UE_API bool UsesGameHiddenFlags() const;
 
    // Return the URL of this level, which may possibly
    // exist on a remote machine.
    UE_API FString GetAddressURL() const;
 
    UE_API void LoadSecondaryLevels(bool bForce = false, TSet<FName>* PackageNamesToSkip = nullptr);
 
    UE_API ULevelStreaming* GetLevelStreamingForPackageName(FName PackageName);
 
#if WITH_EDITOR
    UE_API void RefreshStreamingLevels();
 
    UE_API void RefreshStreamingLevels( const TArray<class ULevelStreaming*>& InLevelsToRefresh );
        
private:
    bool bIsRefreshingStreamingLevels;
 
public:
 
    bool IsRefreshingStreamingLevels() const { return bIsRefreshingStreamingLevels; }
 
    UE_API void IssueEditorLoadWarnings();
 
#endif
 
    UE_API bool ServerTravel(const FString& InURL, bool bAbsolute = false, bool bShouldSkipGameNotify = false);
 
    UE_API void SeamlessTravel(const FString& InURL, bool bAbsolute = false);
 
    UE_API bool IsInSeamlessTravel() const;
 
    UE_API void SetSeamlessTravelMidpointPause(bool bNowPaused);
 
    UE_API int32 GetDetailMode() const;
 
    UE_API void PrepareMapChange(const TArray<FName>& LevelNames);
 
    UE_API bool IsPreparingMapChange() const;
 
    UE_API bool IsMapChangeReady() const;
 
    UE_API void CancelPendingMapChange();
 
    UE_API void CommitMapChange();
 
    UE_API void SetMapNeedsLightingFullyRebuilt(int32 InNumLightingUnbuiltObjects, int32 InNumUnbuiltReflectionCaptures);
 
    UE_API FTimerManager& GetTimerManager() const;
 
    UE_API FLatentActionManager& GetLatentActionManager();
 
    UWorldSubsystem* GetSubsystemBase(TSubclassOf<UWorldSubsystem> SubsystemClass) const
    {
        return SubsystemCollection.GetSubsystem<UWorldSubsystem>(SubsystemClass);
    }
 
    template <typename TSubsystemClass>
    TSubsystemClass* GetSubsystem() const
    {
        return SubsystemCollection.GetSubsystem<TSubsystemClass>(TSubsystemClass::StaticClass());
    }
 
    template <typename TSubsystemClass>
    TNotNull<TSubsystemClass*> GetSubsystemChecked() const
    {
        return GetSubsystem<TSubsystemClass>();
    }
 
    template <typename TSubsystemClass>
    static inline TSubsystemClass* GetSubsystem(const UWorld* World)
    {
        if (World)
        {
            return World->GetSubsystem<TSubsystemClass>();
        }
        return nullptr;
    }
 
    template <typename TSubsystemClass>
    bool HasSubsystem() const
    {
        return GetSubsystem<TSubsystemClass>() != nullptr;
    }
 
    template <typename TSubsystemClass>
    static inline bool HasSubsystem(const UWorld* World)
    {
        return GetSubsystem<TSubsystemClass>(World) != nullptr;
    }
 
    template <typename TSubsystemClass>
    TArray<TSubsystemClass*> GetSubsystemArrayCopy() const
    {
        return SubsystemCollection.GetSubsystemArrayCopy<TSubsystemClass>(TSubsystemClass::StaticClass());
    }
 
    template <typename TSubsystemClass>
    void ForEachSubsystem(TFunctionRef<void(TSubsystemClass*)> Operation) const
    {
        static_assert(TIsDerivedFrom<TSubsystemClass, UWorldSubsystem>::IsDerived, "TSubsystemClass must be derived from UWorldSubsystem");
        return SubsystemCollection.ForEachSubsystem([Operation=MoveTemp(Operation)](UWorldSubsystem* Subsystem){
            Operation(CastChecked<TSubsystemClass>(Subsystem));
        }, TSubsystemClass::StaticClass());
    }
 
    inline void SetGameInstance(UGameInstance* NewGI)
    {
        OwningGameInstance = NewGI;
    }
    inline UGameInstance* GetGameInstance() const
    {
        return OwningGameInstance;
    }
 
    template<class T>
    T* GetGameInstance() const
    {
        return Cast<T>(OwningGameInstance);
    }
 
    template<class T>
    T* GetGameInstanceChecked() const
    {
        return CastChecked<T>(OwningGameInstance);
    }
 
    UE_API bool IsNavigationRebuilt() const;
 
    UE_API void RequestNewWorldOrigin(FIntVector InNewOriginLocation);
    
    UE_API bool SetNewWorldOrigin(FIntVector InNewOriginLocation);
 
    UE_API void NavigateTo(FIntVector InLocation);
 
    UE_API void UpdateConstraintActors();
 
    UE_API void GetLightMapsAndShadowMaps(ULevel* Level, TArray<UTexture2D*>& OutLightMapsAndShadowMaps, bool bForceLazyLoad = true);
 
public:
    UE_API void RenameToPIEWorld(int32 PIEInstanceID);
 
    UE_API bool RemapCompiledScriptActor(FString& Str) const;
 
    UE_API bool IsInstanced() const;
 
    UE_API bool GetSoftObjectPathMapping(FString& OutSourceWorldPath, FString& OutRemappedWorldPath) const;
 
    static UE_API FString ConvertToPIEPackageName(const FString& PackageName, int32 PIEInstanceID);
 
    static UE_API FString StripPIEPrefixFromPackageName(const FString& PackageName, const FString& Prefix);
 
    static UE_API FString BuildPIEPackagePrefix(int32 PIEInstanceID);
 
    static UE_API UWorld* GetDuplicatedWorldForPIE(UWorld* InWorld, UPackage* InPIEackage, int32 PIEInstanceID);
 
    static UE_API UWorld* DuplicateWorldForPIE(const FString& PackageName, UWorld* OwningWorld);
 
    static UE_API FString RemovePIEPrefix(const FString &Source, int32* OutPIEInstanceID = nullptr);
 
    static UE_API UWorld* FindWorldInPackage(UPackage* Package);
 
    static UE_API bool IsWorldOrWorldExternalPackage(UPackage* Package);
 
    static UE_API UWorld* FollowWorldRedirectorInPackage(UPackage* Package, UObjectRedirector** OptionalOutRedirector = nullptr);
 
    inline FWorldPSCPool& GetPSCPool() { return PSCPool; }
 
    private:
 
    UPROPERTY()
    FWorldPSCPool PSCPool;
 
    //PSC Pooling END
    FObjectSubsystemCollection<UWorldSubsystem> SubsystemCollection;
};
 
extern ENGINE_API class UWorldProxy GWorld;
 
class FWorldDelegates
{
public:
    DECLARE_MULTICAST_DELEGATE_TwoParams(FWorldInitializationEvent, UWorld* /*World*/, const UWorld::InitializationValues /*IVS*/);
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FWorldCleanupEvent, UWorld* /*World*/, bool /*bSessionEnded*/, bool /*bCleanupResources*/);
    DECLARE_TS_MULTICAST_DELEGATE_OneParam(FWorldEvent, UWorld* /*World*/);
 
    typedef TMap<UObject*, UObject*> FReplacementMap; // Typedef needed so the macro below can properly digest comma in template parameters.
    DECLARE_MULTICAST_DELEGATE_FourParams(FWorldPostDuplicateEvent, UWorld* /*World*/, bool /*bDuplicateForPIE*/, FReplacementMap& /*ReplacementMap*/, TArray<UObject*>& /*ObjectsToFixReferences*/);
 
#if WITH_EDITOR
    DECLARE_MULTICAST_DELEGATE_FiveParams(FWorldPreRenameEvent, UWorld* /*World*/, const TCHAR* /*InName*/, UObject* /*NewOuter*/, ERenameFlags /*Flags*/, bool& /*bShouldFailRename*/);
    DECLARE_MULTICAST_DELEGATE_OneParam(FWorldPostRenameEvent, UWorld*);
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FWorldCurrentLevelChangedEvent, ULevel* /*NewLevel*/, ULevel* /*OldLevel*/, UWorld* /*World*/);
#endif // WITH_EDITOR
 
    // Delegate type for level change events
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnLevelChanged, ULevel*, UWorld*);
 
    // delegate for generating world asset registry tags so project/game scope can add additional tags for filtering levels in their UI, etc
    DECLARE_MULTICAST_DELEGATE_TwoParams(FWorldGetAssetTagsWithContext, const UWorld*, FAssetRegistryTagsContext);
    DECLARE_MULTICAST_DELEGATE_TwoParams(FWorldGetAssetTags, const UWorld*, TArray<UObject::FAssetRegistryTag>&);
 
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnWorldTickStart, UWorld*, ELevelTick, float);
    static UE_API FOnWorldTickStart OnWorldTickStart;
 
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnWorldTickEnd, UWorld*, ELevelTick, float);
    static UE_API FOnWorldTickEnd OnWorldTickEnd;
 
    // Delegate called before actors are ticked for each world. Delta seconds is already dilated and clamped.
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnWorldPreActorTick, UWorld* /*World*/, ELevelTick, float);
    static UE_API FOnWorldPreActorTick OnWorldPreActorTick;
 
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnWorldPostActorTick, UWorld* /*World*/, ELevelTick, float);
    static UE_API FOnWorldPostActorTick OnWorldPostActorTick;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnWorldPreSendAllEndOfFrameUpdates, UWorld* /*World*/);
    static UE_API FOnWorldPreSendAllEndOfFrameUpdates OnWorldPreSendAllEndOfFrameUpdates;
 
    // Callback for world creation
    static UE_API FWorldEvent OnPostWorldCreation;
    
    // Callback for world initialization (pre)
    static UE_API FWorldInitializationEvent OnPreWorldInitialization;
    
    // Callback for world initialization (post)
    static UE_API FWorldInitializationEvent OnPostWorldInitialization;
 
#if WITH_EDITOR
    // Callback for world rename event (pre)
    static UE_API FWorldPreRenameEvent OnPreWorldRename;
 
    // Callback for world rename event (post)
    static UE_API FWorldPostRenameEvent OnPostWorldRename;
 
    static UE_API FWorldCurrentLevelChangedEvent OnCurrentLevelChanged;
 
    // PIE has started
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnWorldPIEStarted, UGameInstance*);
    static UE_API FOnWorldPIEStarted OnPIEStarted;
 
    // PIE is ready
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnWorldPIEReady, UGameInstance*);
    static UE_API FOnWorldPIEStarted OnPIEReady;
 
    // PIE map is created
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnWorldPIEMapCreated, UGameInstance*);
    static UE_API FOnWorldPIEMapCreated OnPIEMapCreated;
 
    // PIE map is created
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnWorldPIEMapReady, UGameInstance*);
    static UE_API FOnWorldPIEMapReady OnPIEMapReady;
 
    // PIE has ended
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnWorldPIEEnded, UGameInstance*);
    static UE_API FOnWorldPIEEnded OnPIEEnded;
 
    // Callback to add references when Serialize is called during SavePackage
    DECLARE_MULTICAST_DELEGATE_TwoParams(FWorldCollectSaveReferencesEvent, UWorld*, FArchive&);
    static UE_API FWorldCollectSaveReferencesEvent OnCollectSaveReferences;
#endif // WITH_EDITOR
 
    // Post duplication event.
    static UE_API FWorldPostDuplicateEvent OnPostDuplicate;
 
    // Callback for world cleanup start
    static UE_API FWorldCleanupEvent OnWorldCleanup;
 
    // Callback for world cleanup end
    static UE_API FWorldCleanupEvent OnPostWorldCleanup;
 
    // Callback for world destruction (only called for initialized worlds)
    static UE_API FWorldEvent OnPreWorldFinishDestroy;
 
    // Sent when a ULevel is added to the world via UWorld::AddToWorld
    static UE_API FOnLevelChanged           LevelAddedToWorld;
 
    // Sent before a ULevel is removed from the world via UWorld::RemoveFromWorld or 
    // LoadMap (a NULL object means the LoadMap case, because all levels will be 
    // removed from the world without a RemoveFromWorld call for each)
    static UE_API FOnLevelChanged           PreLevelRemovedFromWorld;
 
    // Sent when a ULevel is removed from the world via UWorld::RemoveFromWorld or 
    // LoadMap (a NULL object means the LoadMap case, because all levels will be 
    // removed from the world without a RemoveFromWorld call for each)
    static UE_API FOnLevelChanged           LevelRemovedFromWorld;
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FLevelComponentsEvent, UWorld*, ULevel*);
 
    static UE_API FLevelComponentsEvent LevelComponentsCleared;
 
    static UE_API FLevelComponentsEvent LevelComponentsUpdated;
 
    // Called after offset was applied to a level
    DECLARE_MULTICAST_DELEGATE_FourParams(FLevelOffsetEvent, ULevel*,  UWorld*, const FVector&, bool);
    static UE_API FLevelOffsetEvent     PostApplyLevelOffset;
 
    // Called after transform is applied to level
    DECLARE_MULTICAST_DELEGATE_TwoParams(FLevelTransformEvent, ULevel*, const FTransform&);
    static UE_API FLevelTransformEvent      PostApplyLevelTransform;
 
    // called by UWorld::GetAssetRegistryTags()
    static UE_API FWorldGetAssetTagsWithContext GetAssetTagsWithContext;
    UE_DEPRECATED(5.4, "Subscribe to GetAssetTagsWithContext instead")
    static UE_API FWorldGetAssetTags GetAssetTags;
 
#if WITH_EDITOR
    // Delegate called when levelscript actions need refreshing
    DECLARE_MULTICAST_DELEGATE_OneParam(FRefreshLevelScriptActionsEvent, UWorld*);
 
    // Called when changes in the levels require blueprint actions to be refreshed.
    static UE_API FRefreshLevelScriptActionsEvent RefreshLevelScriptActions;
#endif
    
    // Global Callback after actors have been initialized (on any world)
    static UE_API UWorld::FOnWorldInitializedActors OnWorldInitializedActors;
 
    // Global Callback when an initialized world begins to tear down before cleanup
    static UE_API FWorldEvent OnWorldBeginTearDown;
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnSeamlessTravelStart, UWorld*, const FString&);
    static UE_API FOnSeamlessTravelStart OnSeamlessTravelStart;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnSeamlessTravelTransition, UWorld*);
    static UE_API FOnSeamlessTravelTransition OnSeamlessTravelTransition;
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnNetDriverCreated, UWorld*, UNetDriver*);
    static UE_API FOnNetDriverCreated OnNetDriverCreated;
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnCopyWorldData, UWorld*, UWorld*);
    static UE_API FOnCopyWorldData OnCopyWorldData;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FGameInstanceEvent, UGameInstance* /*GameInstance*/);
    static UE_API FGameInstanceEvent OnStartGameInstance;
 
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FGameInstanceWorldChangedEvent, UGameInstance* /*GameInstance*/, UWorld* /*OldWorld*/, UWorld* /*NewWorld*/);
    static UE_API FGameInstanceWorldChangedEvent OnGameInstanceWorldChanged;
 
private:
    FWorldDelegates() {}
};
 
struct FWorldNotifyStreamingLevelLoading
{
private:
    static void Started(UWorld* World)
    {
        ++World->NumStreamingLevelsBeingLoaded;
    }
 
    static void Finished(UWorld* World)
    {
        if (ensure(World->NumStreamingLevelsBeingLoaded > 0))
        {
            --World->NumStreamingLevelsBeingLoaded;
        }
    }
 
    friend ULevelStreaming;
};
 
// UWorld inlines:
 
inline double UWorld::GetTimeSeconds() const
{
    return TimeSeconds;
}
 
inline double UWorld::GetUnpausedTimeSeconds() const
{
    return UnpausedTimeSeconds;
}
 
inline double UWorld::GetRealTimeSeconds() const
{
    checkSlow(!IsInActualRenderingThread());
    return RealTimeSeconds;
}
 
inline double UWorld::GetAudioTimeSeconds() const
{
    return AudioTimeSeconds;
}
 
inline float UWorld::GetDeltaSeconds() const
{
    return DeltaTimeSeconds;
}
 
inline FGameTime UWorld::GetTime() const
{
    return FGameTime::CreateDilated(
        RealTimeSeconds, DeltaRealTimeSeconds,
        TimeSeconds, DeltaTimeSeconds);
}
 
inline double UWorld::TimeSince(double Time) const
{
    return GetTimeSeconds() - Time;
}
 
inline FConstPhysicsVolumeIterator UWorld::GetNonDefaultPhysicsVolumeIterator() const
{
    auto Result = NonDefaultPhysicsVolumeList.CreateConstIterator();
    return (const FConstPhysicsVolumeIterator&)Result;
}
 
inline int32 UWorld::GetNonDefaultPhysicsVolumeCount() const
{
    return NonDefaultPhysicsVolumeList.Num();
}
 
inline bool UWorld::ComponentOverlapMulti(TArray<struct FOverlapResult>& OutOverlaps, const class UPrimitiveComponent* PrimComp, const FVector& Pos, const FRotator& Rot, const FComponentQueryParams& Params, const FCollisionObjectQueryParams& ObjectQueryParams) const
{
    // Pass through to FQuat version.
    return ComponentOverlapMulti(OutOverlaps, PrimComp, Pos, Rot.Quaternion(), Params, ObjectQueryParams);
}
 
inline bool UWorld::ComponentOverlapMultiByChannel(TArray<struct FOverlapResult>& OutOverlaps, const class UPrimitiveComponent* PrimComp, const FVector& Pos, const FRotator& Rot, ECollisionChannel TraceChannel, const FComponentQueryParams& Params /* = FComponentQueryParams::DefaultComponentQueryParams */, const FCollisionObjectQueryParams& ObjectQueryParams/* =FCollisionObjectQueryParams::DefaultObjectQueryParam */) const
{
    // Pass through to FQuat version.
    return ComponentOverlapMultiByChannel(OutOverlaps, PrimComp, Pos, Rot.Quaternion(), TraceChannel, Params, ObjectQueryParams);
}
 
inline bool UWorld::ComponentSweepMulti(TArray<struct FHitResult>& OutHits, class UPrimitiveComponent* PrimComp, const FVector& Start, const FVector& End, const FRotator& Rot, const FComponentQueryParams& Params) const
{
    // Pass through to FQuat version.
    return ComponentSweepMulti(OutHits, PrimComp, Start, End, Rot.Quaternion(), Params);
}
 
inline bool UWorld::ComponentSweepMultiByChannel(TArray<struct FHitResult>& OutHits, class UPrimitiveComponent* PrimComp, const FVector& Start, const FVector& End, const FRotator& Rot, ECollisionChannel TraceChannel, const FComponentQueryParams& Params) const
{
    // Pass through to FQuat version.
    return ComponentSweepMultiByChannel(OutHits, PrimComp, Start, End, Rot.Quaternion(), TraceChannel, Params);
}
 
inline ENetMode UWorld::GetNetMode() const
{
    // IsRunningDedicatedServer() is a compile-time check in optimized non-editor builds.
    if (IsRunningDedicatedServer())
    {
        return NM_DedicatedServer;
    }
 
    return InternalGetNetMode();
}
 
inline bool UWorld::IsNetMode(ENetMode Mode) const
{
#if UE_EDITOR
    // Editor builds are special because of PIE, which can run a dedicated server without the app running with -server.
    return GetNetMode() == Mode;
#else
    // IsRunningDedicatedServer() is a compile-time check in optimized non-editor builds.
    if (Mode == NM_DedicatedServer)
    {
        return IsRunningDedicatedServer();
    }
    else
    {
        return !IsRunningDedicatedServer() && (InternalGetNetMode() == Mode);
    }
#endif
}
 
UE_DEPRECATED(5.0, "Please use LexToString(EWorldType::Type Type) instead")
FString ENGINE_API ToString(EWorldType::Type Type);
FString ENGINE_API ToString(ENetMode NetMode);
 
#undef UE_API