Engine.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Containers/IndirectArray.h"
#include "UObject/PrintStaleReferencesOptions.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "Misc/Guid.h"
#include "Templates/SubclassOf.h"
#include "Engine/EngineTypes.h"
#include "Engine/EngineBaseTypes.h"
#include "UObject/SoftObjectPath.h"
#include "Engine/World.h"
#include "Misc/FrameRate.h"
#include "Subsystems/SubsystemCollection.h"
#include "Subsystems/EngineSubsystem.h"
#include "RHIDefinitions.h"
#include "Templates/PimplPtr.h"
#include "Templates/UniqueObj.h"
#include "Containers/Ticker.h"
#include "DynamicRenderScaling.h"
#include "Misc/StatusLog.h"
#include "Engine.generated.h"
 
#define WITH_DYNAMIC_RESOLUTION (!UE_SERVER)
 
class APlayerController;
class Error;
class FAudioDeviceManager;
class FCanvas;
class FCommonViewportClient;
class FFineGrainedPerformanceTracker;
class FPerformanceTrackingChart;
class FScreenSaverInhibitor;
class FTypeContainer;
class FViewport;
class IEngineLoop;
class IHeadMountedDisplay;
class IMessageRpcClient;
class IPerformanceDataConsumer;
class IPortalRpcLocator;
class IPortalServiceLocator;
class FSceneViewExtensions;
class IStereoRendering;
class SViewport;
class UEditorEngine;
class UEngineCustomTimeStep;
class UGameUserSettings;
class UGameViewportClient;
class ULocalPlayer;
class UNetDriver;
class UTimecodeProvider;
class UActorFolder;
 
#if ALLOW_DEBUG_FILES
class FFineGrainedPerformanceTracker;
#endif
 
// The kind of failure handling that GetWorldFromContextObject uses 
enum class EGetWorldErrorMode
{
    // Silently returns nullptr, the calling code is expected to handle this gracefully
    ReturnNull,
 
    // Raises a runtime error but still returns nullptr, the calling code is expected to handle this gracefully
    LogAndReturnNull,
 
    // Asserts, the calling code is not expecting to handle a failure gracefully
    Assert
};
 
UENUM()
enum EFullyLoadPackageType : int
{
    FULLYLOAD_Map,
    FULLYLOAD_Game_PreLoadClass,
    FULLYLOAD_Game_PostLoadClass,
    FULLYLOAD_Always,
    FULLYLOAD_Mutator,
    FULLYLOAD_MAX,
};
 
 
UENUM()
enum class ETransitionType : uint8
{
    None,
    Paused,
    Loading,
    Saving,
    Connecting,
    Precaching,
    WaitingToConnect,
    MAX
};
 
enum class EDynamicResolutionStatus
{
    // Dynamic resolution is not supported by this platform.
    Unsupported,
 
    // Dynamic resolution is disabled by project setting cvar r.DynamicRes.OperationMode=0 or disabled by game user
    // settings with r.DynamicRes.OperationMode=1.
    Disabled,
 
    // Dynamic resolution has been paused by game thread.
    Paused,
 
    // Dynamic resolution is currently enabled.
    Enabled,
 
    // Forced enabled at static resolution fraction for profiling purpose with r.DynamicRes.TestScreenPercentage.
    DebugForceEnabled,
};
 
struct FDynamicResolutionStateInfos
{
    // Status of dynamic resolution.
    EDynamicResolutionStatus Status;
 
    // Approximation of the resolution fraction being applied. This is only an approximation because
    // of non (and unecessary) thread safety of this value between game thread, and render thread.
    DynamicRenderScaling::TMap<float> ResolutionFractionApproximations;
 
    // Maximum resolution fraction set, always MaxResolutionFraction >= ResolutionFractionApproximation.
    DynamicRenderScaling::TMap<float> ResolutionFractionUpperBounds;
};
 
 
USTRUCT()
struct FFullyLoadedPackagesInfo
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    TEnumAsByte<enum EFullyLoadPackageType> FullyLoadType;
 
    UPROPERTY()
    FString Tag;
 
    UPROPERTY()
    TArray<FName> PackagesToLoad;
 
    UPROPERTY()
    TArray<TObjectPtr<class UObject>> LoadedObjects;
 
 
    FFullyLoadedPackagesInfo()
        : FullyLoadType(0)
    {
    }
 
};
 
 
USTRUCT()
struct FLevelStreamingStatus
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    FName PackageName;
 
    UPROPERTY()
    uint32 bShouldBeLoaded:1;
 
    UPROPERTY()
    uint32 bShouldBeVisible:1;
 
    UPROPERTY()
    uint32 LODIndex;
 
 
    FLevelStreamingStatus(FName InPackageName, bool bInShouldBeLoaded, bool bInShouldBeVisible, int32 InLODIndex)
    : PackageName(InPackageName), bShouldBeLoaded(bInShouldBeLoaded), bShouldBeVisible(bInShouldBeVisible), LODIndex(InLODIndex)
    {}
    FLevelStreamingStatus()
    {
        FMemory::Memzero(this, sizeof(FLevelStreamingStatus));
        LODIndex = INDEX_NONE;
    }
    
};
 
 
USTRUCT()
struct FNetDriverDefinition
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    FName DefName;
 
    UPROPERTY()
    FName DriverClassName;
 
    UPROPERTY()
    FName DriverClassNameFallback;
 
    UPROPERTY()
    int32 MaxChannelsOverride;
 
    FNetDriverDefinition() :
        DefName(NAME_None),
        DriverClassName(NAME_None),
        DriverClassNameFallback(NAME_None),
        MaxChannelsOverride(INDEX_NONE)
    {
    }
};
 
USTRUCT()
struct FIrisNetDriverConfig 
{
    GENERATED_BODY()
 
    
    UPROPERTY()
    FName NetDriverDefinition;
 
    UPROPERTY()
    FName NetDriverName;
 
    UPROPERTY()
    FString NetDriverWildcardName;
 
    UPROPERTY()
    bool bCanUseIris = false;
};
 
 
USTRUCT()
struct FNamedNetDriver
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(transient)
    TObjectPtr<class UNetDriver> NetDriver;
 
    FNetDriverDefinition* NetDriverDef;
 
    FNamedNetDriver() :
        NetDriver(nullptr),
        NetDriverDef(nullptr)
    {}
 
    FNamedNetDriver(class UNetDriver* InNetDriver, FNetDriverDefinition* InNetDriverDef) :
        NetDriver(InNetDriver),
        NetDriverDef(InNetDriverDef)
    {}
 
    ~FNamedNetDriver() {}
};
 
 
USTRUCT()
struct FWorldContext
{
    GENERATED_USTRUCT_BODY()
 
    /**************************************************************/
    
    TEnumAsByte<EWorldType::Type>   WorldType;
 
    FSeamlessTravelHandler SeamlessTravelHandler;
 
    FName ContextHandle;
 
    FString TravelURL;
 
    uint8 TravelType;
 
    UPROPERTY()
    struct FURL LastURL;
 
    UPROPERTY()
    struct FURL LastRemoteURL;
 
    UPROPERTY()
    TObjectPtr<UPendingNetGame>  PendingNetGame;
 
    UPROPERTY()
    TArray<struct FFullyLoadedPackagesInfo> PackagesToFullyLoad;
 
    TArray<FName> LevelsToLoadForPendingMapChange;
 
    UPROPERTY()
    TArray<TObjectPtr<class ULevel>> LoadedLevelsForPendingMapChange;
 
    FString PendingMapChangeFailureDescription;
 
    uint32 bShouldCommitPendingMapChange:1;
 
    UPROPERTY()
    TArray<TObjectPtr<class UObjectReferencer>> ObjectReferencers;
 
    UPROPERTY()
    TArray<struct FLevelStreamingStatus> PendingLevelStreamingStatusUpdates;
 
    UPROPERTY()
    TObjectPtr<class UGameViewportClient> GameViewport;
 
    UPROPERTY()
    TObjectPtr<class UGameInstance> OwningGameInstance;
 
    UPROPERTY(transient)
    TArray<FNamedNetDriver> ActiveNetDrivers;
 
    int32   PIEInstance;
 
    FString PIEPrefix;
 
    ERHIFeatureLevel::Type PIEWorldFeatureLevel;
 
    bool    RunAsDedicated;
 
    bool    bWaitingOnOnlineSubsystem;
 
    bool    bIsPrimaryPIEInstance;
 
    uint32 AudioDeviceID;
 
    FString CustomDescription;
 
    // If > 0, tick this world at a fixed rate in PIE
    float PIEFixedTickSeconds  = 0.f;
    float PIEAccumulatedTickSeconds = 0.f;
 
    TSet<FObjectKey> GarbageObjectsToVerify;
 
    /**************************************************************/
 
    TArray<TObjectPtr<UWorld>*> ExternalReferences;
 
    void AddRef(UWorld*& WorldPtr)
    {
        AddRef(ObjectPtrWrap(WorldPtr));
    }
 
    void AddRef(TObjectPtr<UWorld>& WorldPtr)
    {
        WorldPtr = ThisCurrentWorld;
        ExternalReferences.AddUnique(&WorldPtr);
    }
 
    void RemoveRef(UWorld*& WorldPtr)
    {
        ExternalReferences.Remove(&ObjectPtrWrap(WorldPtr));
        WorldPtr = nullptr;
    }
 
    ENGINE_API void SetCurrentWorld(UWorld *World);
 
    void AddReferencedObjects(FReferenceCollector& Collector, const UObject* ReferencingObject);
 
    inline UWorld* World() const
    {
        return ThisCurrentWorld;
    }
 
    FWorldContext()
        : WorldType(EWorldType::None)
        , ContextHandle(NAME_None)
        , TravelURL()
        , TravelType(0)
        , PendingNetGame(nullptr)
        , bShouldCommitPendingMapChange(0)
        , GameViewport(nullptr)
        , OwningGameInstance(nullptr)
        , PIEInstance(INDEX_NONE)
        , PIEWorldFeatureLevel(ERHIFeatureLevel::Num)
        , RunAsDedicated(false)
        , bWaitingOnOnlineSubsystem(false)
        , bIsPrimaryPIEInstance(false)
        , AudioDeviceID(INDEX_NONE)
        , ThisCurrentWorld(nullptr)
    { }
 
private:
 
    TObjectPtr<UWorld>  ThisCurrentWorld;
};
 
 
USTRUCT()
struct FStatColorMapEntry
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(globalconfig)
    float In;
 
    UPROPERTY(globalconfig)
    FColor Out;
 
 
    FStatColorMapEntry()
        : In(0)
        , Out(ForceInit)
    {
    }
 
};
 
 
USTRUCT()
struct FStatColorMapping
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(globalconfig)
    FString StatName;
 
    UPROPERTY(globalconfig)
    TArray<struct FStatColorMapEntry> ColorMap;
 
    UPROPERTY(globalconfig)
    uint32 DisableBlend:1;
 
 
    FStatColorMapping()
        : DisableBlend(false)
    {
    }
 
};
 
 
USTRUCT()
struct FDropNoteInfo
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    FVector Location;
 
    UPROPERTY()
    FRotator Rotation;
 
    UPROPERTY()
    FString Comment;
 
 
    FDropNoteInfo()
        : Location(ForceInit)
        , Rotation(ForceInit)
    {
    }
 
};
 
 
USTRUCT()
struct FScreenMessageString
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(transient)
    uint64 Key;
 
    UPROPERTY(transient)
    FString ScreenMessage;
 
    UPROPERTY(transient)
    FColor DisplayColor;
 
    UPROPERTY(transient)
    float TimeToDisplay;
 
    UPROPERTY(transient)
    float CurrentTimeDisplayed;
 
    UPROPERTY(transient)
    FVector2D TextScale;
 
    FScreenMessageString()
        : Key(0)
        , DisplayColor(ForceInit)
        , TimeToDisplay(0)
        , CurrentTimeDisplayed(0)
        , TextScale(ForceInit)
    {
    }
};
 
 
USTRUCT()
struct FGameNameRedirect
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    FName OldGameName;
 
    UPROPERTY()
    FName NewGameName;
};
 
 
USTRUCT()
struct FClassRedirect
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    FName ObjectName;
 
    UPROPERTY()
    FName OldClassName;
 
    UPROPERTY()
    FName NewClassName;
 
    UPROPERTY()
    FName OldSubobjName;
 
    UPROPERTY()
    FName NewSubobjName;
 
    UPROPERTY()
    FName NewClassClass; 
 
    UPROPERTY()
    FName NewClassPackage; 
 
    UPROPERTY()
    bool InstanceOnly = false;
};
 
 
USTRUCT()
struct FStructRedirect
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    FName OldStructName;
 
    UPROPERTY()
    FName NewStructName;
};
 
 
USTRUCT()
struct FPluginRedirect
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    FString OldPluginName;
 
    UPROPERTY()
    FString NewPluginName;
};
 
enum class EDynamicResolutionStateEvent : uint8;
 
 
class IAnalyticsProvider;
 
DECLARE_DELEGATE_OneParam(FBeginStreamingPauseDelegate, FViewport*);
DECLARE_DELEGATE(FEndStreamingPauseDelegate);
 
enum class EFrameHitchType : uint8;
 
DECLARE_MULTICAST_DELEGATE_TwoParams(FEngineHitchDetectedDelegate, EFrameHitchType /*HitchType*/, float /*HitchDurationInSeconds*/);
 
DECLARE_MULTICAST_DELEGATE(FPreRenderDelegate);
DECLARE_MULTICAST_DELEGATE_OneParam(FPreRenderDelegateEx, class FRDGBuilder&);
DECLARE_MULTICAST_DELEGATE(FPostRenderDelegate);
DECLARE_MULTICAST_DELEGATE_OneParam(FPostRenderDelegateEx, class FRDGBuilder&);
 
DECLARE_DELEGATE_RetVal_ThreeParams(EBrowseReturnVal::Type, FBrowseURL, FWorldContext& WorldContext, FURL URL, FString& Error);
DECLARE_DELEGATE_TwoParams(FPendingLevelUpdate, FWorldContext& Context, float DeltaSeconds);
 
enum class EGarbageCollectionType
{
    None,
    Incremental,
    Full
};
 
UCLASS(abstract, config=Engine, defaultconfig, transient, MinimalAPI)
class UEngine
    : public UObject
    , public FExec
{
    GENERATED_UCLASS_BODY()
 
private:
    UPROPERTY()
    TObjectPtr<class UFont> TinyFont;
 
public:
    UPROPERTY(globalconfig, EditAnywhere, Category=Fonts, meta=(AllowedClasses="/Script/Engine.Font", DisplayName="Tiny Font", ConfigRestartRequired=true))
    FSoftObjectPath TinyFontName;
 
private:
    UPROPERTY()
    TObjectPtr<class UFont> SmallFont;
 
public:
    UPROPERTY(globalconfig, EditAnywhere, Category=Fonts, meta=(AllowedClasses="/Script/Engine.Font", DisplayName="Small Font", ConfigRestartRequired=true))
    FSoftObjectPath SmallFontName;
 
private:
    UPROPERTY()
    TObjectPtr<class UFont> MediumFont;
 
public:
    UPROPERTY(globalconfig, EditAnywhere, Category=Fonts, meta=(AllowedClasses="/Script/Engine.Font", DisplayName="Medium Font", ConfigRestartRequired=true))
    FSoftObjectPath MediumFontName;
 
private:
    UPROPERTY()
    TObjectPtr<class UFont> LargeFont;
 
public:
    UPROPERTY(globalconfig, EditAnywhere, Category=Fonts, meta=(AllowedClasses="/Script/Engine.Font", DisplayName="Large Font", ConfigRestartRequired=true))
    FSoftObjectPath LargeFontName;
 
private:
    UPROPERTY()
    TObjectPtr<class UFont> SubtitleFont;
 
public:
    UPROPERTY(globalconfig, EditAnywhere, Category=Fonts, meta=(AllowedClasses="/Script/Engine.Font", DisplayName="Subtitle Font", ConfigRestartRequired=true), AdvancedDisplay)
    FSoftObjectPath SubtitleFontName;
 
private:
    UPROPERTY()
    TObjectPtr<class UFont> MonospaceFont;
 
public:
    UPROPERTY(globalconfig, EditAnywhere, Category=Fonts, meta=(AllowedClasses="/Script/Engine.Font", DisplayName="Monospace Font", ConfigRestartRequired=true), AdvancedDisplay)
    FSoftObjectPath MonospaceFontName;
 
private:
    UPROPERTY()
    TArray<TObjectPtr<class UFont>> AdditionalFonts;
 
public:
    UPROPERTY(globalconfig, EditAnywhere, Category=Fonts, AdvancedDisplay)
    TArray<FString> AdditionalFontNames;
 
    UPROPERTY()
    TSubclassOf<class UConsole>  ConsoleClass;
 
    UPROPERTY(globalconfig, noclear, EditAnywhere, Category=DefaultClasses, meta=(MetaClass="/Script/Engine.Console", DisplayName="Console Class", ConfigRestartRequired=true))
    FSoftClassPath ConsoleClassName;
 
    UPROPERTY()
    TSubclassOf<class UGameViewportClient>  GameViewportClientClass;
 
    UPROPERTY(globalconfig, noclear, EditAnywhere, Category=DefaultClasses, meta=(MetaClass="/Script/Engine.GameViewportClient", DisplayName="Game Viewport Client Class", ConfigRestartRequired=true))
    FSoftClassPath GameViewportClientClassName;
 
    UPROPERTY()
    TSubclassOf<class ULocalPlayer>  LocalPlayerClass;
 
    UPROPERTY(globalconfig, noclear, EditAnywhere, Category=DefaultClasses, meta=(MetaClass="/Script/Engine.LocalPlayer", DisplayName="Local Player Class", ConfigRestartRequired=true))
    FSoftClassPath LocalPlayerClassName;
 
    UPROPERTY()
    TSubclassOf<class AWorldSettings>  WorldSettingsClass;
 
    UPROPERTY(globalconfig, noclear, EditAnywhere, Category=DefaultClasses, meta=(MetaClass="/Script/Engine.WorldSettings", DisplayName="World Settings Class", ConfigRestartRequired=true))
    FSoftClassPath WorldSettingsClassName;
 
    UPROPERTY(globalconfig, noclear, meta=(MetaClass="/Script/NavigationSystem.NavigationSystem", DisplayName="Navigation System Class"))
    FSoftClassPath NavigationSystemClassName;
 
    UPROPERTY()
    TSubclassOf<class UNavigationSystemBase>  NavigationSystemClass;
 
    UPROPERTY(globalconfig, noclear, meta = (MetaClass = "/Script/NavigationSystem.NavigationSystem", DisplayName = "Navigation System Config Class"))
    FSoftClassPath NavigationSystemConfigClassName;
 
    UPROPERTY()
    TSubclassOf<class UNavigationSystemConfig>  NavigationSystemConfigClass;
    
    UPROPERTY(globalconfig, noclear, meta=(MetaClass="/Script/Engine.AvoidanceManager", DisplayName="Avoidance Manager Class"))
    FSoftClassPath AvoidanceManagerClassName;
    
    UPROPERTY()
    TSubclassOf<class UAvoidanceManager>  AvoidanceManagerClass;
 
    UPROPERTY(globalconfig, noclear, meta = (MetaClass = "/Script/AIModule.AIController", DisplayName = "Default AIController class for all Pawns"))
    FSoftClassPath AIControllerClassName;
 
    UPROPERTY()
    TSubclassOf<class UPhysicsCollisionHandler> PhysicsCollisionHandlerClass;
 
    UPROPERTY(globalconfig, noclear, EditAnywhere, Category=DefaultClasses, meta=(MetaClass="/Script/Engine.PhysicsCollisionHandler", DisplayName="Physics Collision Handler Class", ConfigRestartRequired=true), AdvancedDisplay)
    FSoftClassPath PhysicsCollisionHandlerClassName;
 
    UPROPERTY(globalconfig, noclear, EditAnywhere, Category=DefaultClasses, meta=(MetaClass="/Script/Engine.GameUserSettings", DisplayName="Game User Settings Class", ConfigRestartRequired=true), AdvancedDisplay)
    FSoftClassPath GameUserSettingsClassName;
 
    UPROPERTY()
    TSubclassOf<class UGameUserSettings> GameUserSettingsClass;
 
    UPROPERTY()
    TObjectPtr<class UGameUserSettings> GameUserSettings;
 
    UPROPERTY()
    TSubclassOf<class ALevelScriptActor>  LevelScriptActorClass;
 
    UPROPERTY(globalconfig, noclear, EditAnywhere, Category=DefaultClasses, meta=(MetaClass="/Script/Engine.LevelScriptActor", DisplayName="Level Script Actor Class", ConfigRestartRequired=true))
    FSoftClassPath LevelScriptActorClassName;
    
    UPROPERTY(globalconfig, noclear, EditAnywhere, Category=DefaultClasses, meta=(MetaClass="/Script/CoreUObject.Object", DisplayName="Default Blueprint Base Class", AllowAbstract, BlueprintBaseOnly), AdvancedDisplay)
    FSoftClassPath DefaultBlueprintBaseClassName;
 
    UPROPERTY(globalconfig, noclear, EditAnywhere, Category=DefaultClasses, meta=(MetaClass="/Script/CoreUObject.Object", DisplayName="Game Singleton Class", ConfigRestartRequired=true), AdvancedDisplay)
    FSoftClassPath GameSingletonClassName;
 
    UPROPERTY()
    TObjectPtr<UObject> GameSingleton;
 
    UPROPERTY(globalconfig, noclear, EditAnywhere, Category=DefaultClasses, meta=(MetaClass="/Script/CoreUObject.Object", DisplayName="Asset Manager Class", ConfigRestartRequired=true), AdvancedDisplay)
    FSoftClassPath AssetManagerClassName;
 
    UPROPERTY()
    TObjectPtr<class UAssetManager> AssetManager;
 
    UPROPERTY()
    TObjectPtr<class UTexture2D> DefaultTexture;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath DefaultTextureName;
 
    UPROPERTY()
    TObjectPtr<class UTexture> DefaultDiffuseTexture;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath DefaultDiffuseTextureName;
 
    UPROPERTY()
    TObjectPtr<class UTexture2D> DefaultBSPVertexTexture;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath DefaultBSPVertexTextureName;
 
    UPROPERTY()
    TObjectPtr<class UTexture2D> HighFrequencyNoiseTexture;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath HighFrequencyNoiseTextureName;
 
    UPROPERTY()
    TObjectPtr<class UTexture2D> DefaultBokehTexture;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath DefaultBokehTextureName;
 
    UPROPERTY()
    TObjectPtr<class UTexture2D> DefaultBloomKernelTexture;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath DefaultBloomKernelTextureName;
    
    UPROPERTY()
    TObjectPtr<class UTexture2D> DefaultFilmGrainTexture;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath DefaultFilmGrainTextureName;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> WireframeMaterial;
    
    UPROPERTY(globalconfig)
    FString WireframeMaterialName;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TObjectPtr<class UMaterial> GeomMaterial;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath GeomMaterialName;
#endif
 
    UPROPERTY()
    TObjectPtr<class UMaterial> DebugMeshMaterial;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath DebugMeshMaterialName;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> NaniteHiddenSectionMaterial;
 
    UPROPERTY(globalconfig)
    FString NaniteHiddenSectionMaterialName;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> EmissiveMeshMaterial;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath EmissiveMeshMaterialName;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> LevelColorationLitMaterial;
 
    UPROPERTY(globalconfig)
    FString LevelColorationLitMaterialName;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> LevelColorationUnlitMaterial;
 
    UPROPERTY(globalconfig)
    FString LevelColorationUnlitMaterialName;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> LightingTexelDensityMaterial;
 
    UPROPERTY(globalconfig)
    FString LightingTexelDensityName;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> ShadedLevelColorationLitMaterial;
 
    UPROPERTY(globalconfig)
    FString ShadedLevelColorationLitMaterialName;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> ShadedLevelColorationUnlitMaterial;
 
    UPROPERTY(globalconfig)
    FString ShadedLevelColorationUnlitMaterialName;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> RemoveSurfaceMaterial;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath RemoveSurfaceMaterialName;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> VertexColorMaterial;
 
    UPROPERTY(globalconfig)
    FString VertexColorMaterialName;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> VertexColorViewModeMaterial_ColorOnly;
 
    UPROPERTY(globalconfig)
    FString VertexColorViewModeMaterialName_ColorOnly;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> VertexColorViewModeMaterial_AlphaAsColor;
 
    UPROPERTY(globalconfig)
    FString VertexColorViewModeMaterialName_AlphaAsColor;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> VertexColorViewModeMaterial_RedOnly;
 
    UPROPERTY(globalconfig)
    FString VertexColorViewModeMaterialName_RedOnly;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> VertexColorViewModeMaterial_GreenOnly;
 
    UPROPERTY(globalconfig)
    FString VertexColorViewModeMaterialName_GreenOnly;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> VertexColorViewModeMaterial_BlueOnly;
 
    UPROPERTY(globalconfig)
    FString VertexColorViewModeMaterialName_BlueOnly;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> TextureColorViewModeMaterial;
 
    UPROPERTY(globalconfig)
    FString TextureColorViewModeMaterialName;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath DefaultZenStreamingTextureName;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TObjectPtr<class UMaterial> BoneWeightMaterial;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath BoneWeightMaterialName;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> ClothPaintMaterial;
    UPROPERTY()
    TObjectPtr<class UMaterial> ClothPaintOpaqueMaterial;
    UPROPERTY()
    TObjectPtr<class UMaterial> ClothPaintMaterialWireframe;
    UPROPERTY()
    TObjectPtr<class UMaterial> ClothPaintOpaqueMaterialWireframe;
    UPROPERTY()
    TObjectPtr<class UMaterialInstanceDynamic> ClothPaintMaterialInstance;
    UPROPERTY()
    TObjectPtr<class UMaterialInstanceDynamic> ClothPaintOpaqueMaterialInstance;
    UPROPERTY()
    TObjectPtr<class UMaterialInstanceDynamic> ClothPaintMaterialWireframeInstance;
    UPROPERTY()
    TObjectPtr<class UMaterialInstanceDynamic> ClothPaintOpaqueMaterialWireframeInstance;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath ClothPaintMaterialName;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath ClothPaintOpaqueMaterialName;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath ClothPaintMaterialWireframeName;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath ClothPaintOpaqueMaterialWireframeName;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> PhysicalMaterialMaskMaterial;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath PhysicalMaterialMaskMaterialName;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> DebugEditorMaterial;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath DefaultFlattenMaterialName;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath DefaultHLODFlattenMaterialName;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath DefaultLandscapeFlattenMaterialName;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> DefaultFlattenMaterial;
    UPROPERTY()
    TObjectPtr<class UMaterial> DefaultHLODFlattenMaterial;
    UPROPERTY()
    TObjectPtr<class UMaterial> DefaultLandscapeFlattenMaterial;
    UPROPERTY()
    TObjectPtr<class UMaterial> TexturePaintingMaskMaterial;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath TexturePaintingMaskMaterialName;
 
    UPROPERTY()
    TObjectPtr<class UMaterialInterface> ClayMaterial;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath ClayMaterialName;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> ZebraMaterial;
 
    UPROPERTY()
    TObjectPtr<class UMaterialInstanceDynamic> ZebraMaterialInstance;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath ZebraMaterialName;
    
    UPROPERTY()
    TObjectPtr<class UMaterialInterface> FrontBackFaceMaterial;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath FrontBackFaceMaterialName;
 
    UPROPERTY()
    TObjectPtr<class UMaterialInterface> RandomColorMaterial;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath RandomColorMaterialName;
 
#endif
 
    UPROPERTY(globalconfig)
    FSoftObjectPath DebugEditorMaterialName;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> ConstraintLimitMaterial;
 
    UPROPERTY()
    TObjectPtr<class UMaterialInstanceDynamic> ConstraintLimitMaterialX;
 
    UPROPERTY()
    TObjectPtr<class UMaterialInstanceDynamic> ConstraintLimitMaterialXAxis;
 
    UPROPERTY()
    TObjectPtr<class UMaterialInstanceDynamic> ConstraintLimitMaterialY;
    UPROPERTY()
    TObjectPtr<class UMaterialInstanceDynamic> ConstraintLimitMaterialYAxis;
 
    UPROPERTY()
    TObjectPtr<class UMaterialInstanceDynamic> ConstraintLimitMaterialZ;
    UPROPERTY()
    TObjectPtr<class UMaterialInstanceDynamic> ConstraintLimitMaterialZAxis;
 
    UPROPERTY()
    TObjectPtr<class UMaterialInstanceDynamic> ConstraintLimitMaterialPrismatic;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> InvalidLightmapSettingsMaterial;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath InvalidLightmapSettingsMaterialName;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> PreviewShadowsIndicatorMaterial;
 
    UPROPERTY(globalconfig, EditAnywhere, Category=DefaultMaterials, meta=(AllowedClasses="/Script/Engine.Material", DisplayName="Preview Shadows Indicator Material"))
    FSoftObjectPath PreviewShadowsIndicatorMaterialName;
 
    UPROPERTY()
    TObjectPtr<class UMaterial> ArrowMaterial;
 
    UPROPERTY()
    TObjectPtr<class UMaterialInstanceDynamic> ArrowMaterialYellow;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath ArrowMaterialName;
 
    UPROPERTY(globalconfig)
    FLinearColor LightingOnlyBrightness;
 
    UPROPERTY(globalconfig)
    TArray<FLinearColor> ShaderComplexityColors;
 
    UPROPERTY(globalconfig)
    TArray<FLinearColor> QuadComplexityColors;
 
    UPROPERTY(globalconfig)
    TArray<FLinearColor> LightComplexityColors;
 
    UPROPERTY(globalconfig)
    TArray<FLinearColor> StationaryLightOverlapColors;
 
    UPROPERTY(globalconfig)
    TArray<FLinearColor> LODColorationColors;
 
    UPROPERTY(globalconfig)
    TArray<FLinearColor> HLODColorationColors;
 
    UPROPERTY(globalconfig)
    TArray<FLinearColor> StreamingAccuracyColors;
 
    UPROPERTY(globalconfig)
    FLinearColor GPUSkinCacheVisualizationExcludedColor;
 
    UPROPERTY(globalconfig)
    FLinearColor GPUSkinCacheVisualizationIncludedColor;
 
    UPROPERTY(globalconfig)
    FLinearColor GPUSkinCacheVisualizationRecomputeTangentsColor;
 
    UPROPERTY(globalconfig)
    float GPUSkinCacheVisualizationLowMemoryThresholdInMB;
    UPROPERTY(globalconfig)
    float GPUSkinCacheVisualizationHighMemoryThresholdInMB;
 
    UPROPERTY(globalconfig)
    FLinearColor GPUSkinCacheVisualizationLowMemoryColor;
    UPROPERTY(globalconfig)
    FLinearColor GPUSkinCacheVisualizationMidMemoryColor;
    UPROPERTY(globalconfig)
    FLinearColor GPUSkinCacheVisualizationHighMemoryColor;
 
    UPROPERTY(globalconfig)
    TArray<FLinearColor> GPUSkinCacheVisualizationRayTracingLODOffsetColors;
 
    UPROPERTY(globalconfig)
    float MaxPixelShaderAdditiveComplexityCount;
 
    UPROPERTY(globalconfig)
    float MaxES3PixelShaderAdditiveComplexityCount;
 
    UPROPERTY(globalconfig)
    float MinLightMapDensity;
 
    UPROPERTY(globalconfig)
    float IdealLightMapDensity;
 
    UPROPERTY(globalconfig)
    float MaxLightMapDensity;
 
    UPROPERTY(globalconfig)
    uint32 bRenderLightMapDensityGrayscale:1;
 
    UPROPERTY(globalconfig)
    float RenderLightMapDensityGrayscaleScale;
 
    UPROPERTY(globalconfig)
    float RenderLightMapDensityColorScale;
 
    UPROPERTY(globalconfig)
    FLinearColor LightMapDensityVertexMappedColor;
 
    UPROPERTY(globalconfig)
    FLinearColor LightMapDensitySelectedColor;
 
    UPROPERTY(globalconfig)
    TArray<struct FStatColorMapping> StatColorMappings;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TObjectPtr<class UMaterial> EditorBrushMaterial;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath EditorBrushMaterialName;
#endif
 
    UPROPERTY()
    TObjectPtr<class UPhysicalMaterial> DefaultPhysMaterial;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath DefaultPhysMaterialName;
 
    UPROPERTY()
    TObjectPtr<class UPhysicalMaterial> DefaultDestructiblePhysMaterial;
 
    UPROPERTY(globalconfig, EditAnywhere, Category = DefaultMaterials, meta = (AllowedClasses = "/Script/PhysicsCore.PhysicalMaterial", DisplayName = "Destructible Physics Material"))
    FSoftObjectPath DefaultDestructiblePhysMaterialName;
 
    UPROPERTY(config)
    TArray<FGameNameRedirect> ActiveGameNameRedirects;
 
    UPROPERTY(config)
    TArray<FClassRedirect> ActiveClassRedirects;
 
    UPROPERTY(config)
    TArray<FPluginRedirect> ActivePluginRedirects;
 
    UPROPERTY(config)
    TArray<FStructRedirect> ActiveStructRedirects;
 
    UPROPERTY()
    TObjectPtr<class UTexture2D> PreIntegratedSkinBRDFTexture;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath PreIntegratedSkinBRDFTextureName;
 
    UPROPERTY()
    TObjectPtr<class UTexture2D> BlueNoiseScalarTexture;
 
    UPROPERTY()
    TObjectPtr<class UTexture2D> BlueNoiseVec2Texture;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath BlueNoiseScalarTextureName;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath BlueNoiseScalarMobileTextureName;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath BlueNoiseVec2TextureName;
 
    UPROPERTY()
    TObjectPtr<class UTexture2D> GGXLTCAmpTexture;
    UPROPERTY(globalconfig)
    FSoftObjectPath GGXLTCAmpTextureName;
 
    UPROPERTY()
    TObjectPtr<class UTexture2D> GGXLTCMatTexture;
    UPROPERTY(globalconfig)
    FSoftObjectPath GGXLTCMatTextureName;
 
    UPROPERTY()
    TObjectPtr<class UTexture2D> SheenLTCTexture;   
    UPROPERTY(globalconfig)
    FSoftObjectPath SheenLTCTextureName;
 
    UPROPERTY()
    TObjectPtr<class UTexture2D> GGXReflectionEnergyTexture;
    UPROPERTY(globalconfig)
    FSoftObjectPath GGXReflectionEnergyTextureName;
 
    UPROPERTY()
    TObjectPtr<class UTexture2D> GGXTransmissionEnergyTexture;
    UPROPERTY(globalconfig)
    FSoftObjectPath GGXTransmissionEnergyTextureName;
        
    UPROPERTY()
    TObjectPtr<class UTexture2D> SheenEnergyTexture;
    UPROPERTY(globalconfig)
    FSoftObjectPath SheenLegacyEnergyTextureName;       
    UPROPERTY(globalconfig)
    FSoftObjectPath SheenEnergyTextureName;
        
    UPROPERTY()
    TObjectPtr<class UTexture2D> DiffuseEnergyTexture;
    UPROPERTY(globalconfig)
    FSoftObjectPath DiffuseEnergyTextureName;
 
    UPROPERTY()
    TObjectPtr<class UTexture2DArray> GlintTexture;
    UPROPERTY()
    TObjectPtr<class UTexture2DArray> GlintTexture2;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath GlintTextureName;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath GlintTexture2Name;
    
    UPROPERTY()
    TObjectPtr<class UVolumeTexture> SimpleVolumeTexture;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath SimpleVolumeTextureName;
    
    UPROPERTY()
    TObjectPtr<class UVolumeTexture> SimpleVolumeEnvTexture;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath SimpleVolumeEnvTextureName;
 
    UPROPERTY()
    TObjectPtr<class UTexture2D> MiniFontTexture;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath MiniFontTextureName;
 
    UPROPERTY()
    TObjectPtr<class UTexture> WeightMapPlaceholderTexture;
 
    UPROPERTY()
    TObjectPtr<class UTexture> WeightMapArrayPlaceholderTexture;
    
    UPROPERTY(globalconfig)
    FSoftObjectPath WeightMapPlaceholderTextureName;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath WeightMapArrayPlaceholderTextureName;
 
    UPROPERTY()
    TObjectPtr<class UTexture2D> LightMapDensityTexture;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath LightMapDensityTextureName;
 
    UPROPERTY()
    TObjectPtr<class UTexture2D> SMAAAreaTexture;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath SMAAAreaTextureName;
 
    UPROPERTY()
    TObjectPtr<class UTexture2D> SMAASearchTexture;
 
    UPROPERTY(globalconfig)
    FSoftObjectPath SMAASearchTextureName;
 
    // Variables.
 
    class IEngineLoop* EngineLoop;
 
    UPROPERTY()
    TObjectPtr<class UGameViewportClient> GameViewport;
 
    UPROPERTY()
    TArray<FString> DeferredCommands;
 
    UPROPERTY(EditAnywhere, config, Category=Settings)
    float NearClipPlane;
 
    UPROPERTY(EditAnywhere, config, Category=Subtitles)
    uint32 bSubtitlesEnabled:1;
 
    UPROPERTY(EditAnywhere, config, Category=Subtitles)
    uint32 bSubtitlesForcedOff:1;
 
    UPROPERTY(EditAnywhere, config, Category=Blueprints)
    int32 MaximumLoopIterationCount;
 
    // Controls whether Blueprint subclasses of actors or components can tick by default.
    //
    // Blueprints that derive from native C++ classes that have bCanEverTick=true will always be able to tick
    // Blueprints that derive from exactly AActor or UActorComponent will always be able to tick
    // Otherwise, they can tick as long as the parent doesn't have meta=(ChildCannotTick) and either bCanBlueprintsTickByDefault is true or the parent has meta=(ChildCanTick)
    UPROPERTY(EditAnywhere, config, Category=Blueprints)
    uint32 bCanBlueprintsTickByDefault:1;
 
    UPROPERTY(EditAnywhere, config, Category="Anim Blueprints")
    uint32 bOptimizeAnimBlueprintMemberVariableAccess:1;
 
    UPROPERTY(EditAnywhere, config, Category="Anim Blueprints")
    uint32 bAllowMultiThreadedAnimationUpdate:1;
 
    UPROPERTY(config)
    uint32 bEnableEditorPSysRealtimeLOD:1;
 
    uint32 bForceDisableFrameRateSmoothing : 1;
 
    UPROPERTY(config, EditAnywhere, Category=Framerate, meta=(EditCondition="!bUseFixedFrameRate"))
    uint32 bSmoothFrameRate:1;
 
    UPROPERTY(config, EditAnywhere, Category=Framerate)
    uint32 bUseFixedFrameRate : 1;
    
    UPROPERTY(config, EditAnywhere, Category=Framerate, meta=(EditCondition="bUseFixedFrameRate", ClampMin = "15.0"))
    float FixedFrameRate;
 
    UPROPERTY(config, EditAnywhere, Category=Framerate, meta=(UIMin=0, UIMax=200, EditCondition="!bUseFixedFrameRate"))
    FFloatRange SmoothedFrameRateRange;
 
private:
    UPROPERTY(transient)
    TObjectPtr<UEngineCustomTimeStep> CustomTimeStep;
 
    FSimpleMulticastDelegate CustomTimeStepChangedEvent;
 
    bool bIsCurrentCustomTimeStepInitialized;
 
public:
    UPROPERTY(AdvancedDisplay, config, EditAnywhere, Category=Framerate, meta=(MetaClass="/Script/Engine.EngineCustomTimeStep", DisplayName="Custom TimeStep"))
    FSoftClassPath CustomTimeStepClassName;
 
private:
    UPROPERTY(transient)
    TObjectPtr<UTimecodeProvider> TimecodeProvider;
 
    FSimpleMulticastDelegate TimecodeProviderChangedEvent;
 
    bool bIsCurrentTimecodeProviderInitialized;
 
public:
    UPROPERTY(config, EditAnywhere, Category=Timecode, meta=(MetaClass="/Script/Engine.TimecodeProvider", DisplayName="Timecode Provider"))
    FSoftClassPath TimecodeProviderClassName;
 
    UPROPERTY(config, EditAnywhere, Category=Timecode)
    bool bGenerateDefaultTimecode;
 
    UPROPERTY(config, EditAnywhere, Category=Timecode, meta=(EditCondition="bGenerateDefaultTimecode"))
    FFrameRate GenerateDefaultTimecodeFrameRate;
 
    UPROPERTY(AdvancedDisplay, config, EditAnywhere, Category=Timecode, meta=(EditCondition="bGenerateDefaultTimecode"))
    float GenerateDefaultTimecodeFrameDelay;
 
public:
    UPROPERTY(config)
    uint32 bCheckForMultiplePawnsSpawnedInAFrame:1;
 
    UPROPERTY(config)
    int32 NumPawnsAllowedToBeSpawnedInAFrame;
 
    UPROPERTY(globalconfig)
    uint32 bShouldGenerateLowQualityLightmaps_DEPRECATED :1;
 
    // Various Colors used for editor and debug rendering
 
    UPROPERTY()
    FColor C_WorldBox;
 
    UPROPERTY()
    FColor C_BrushWire;
 
    UPROPERTY()
    FColor C_AddWire;
 
    UPROPERTY()
    FColor C_SubtractWire;
 
    UPROPERTY()
    FColor C_SemiSolidWire;
 
    UPROPERTY()
    FColor C_NonSolidWire;
 
    UPROPERTY()
    FColor C_WireBackground;
 
    UPROPERTY()
    FColor C_ScaleBoxHi;
 
    UPROPERTY()
    FColor C_VolumeCollision;
 
    UPROPERTY()
    FColor C_BSPCollision;
 
    UPROPERTY()
    FColor C_OrthoBackground;
 
    UPROPERTY()
    FColor C_Volume;
 
    UPROPERTY()
    FColor C_BrushShape;
 
    UPROPERTY(config, EditAnywhere, Category = Screenshots)
    FDirectoryPath GameScreenshotSaveDirectory;
 
    UPROPERTY(config, EditAnywhere, Category = PerQualityLevelProperty, AdvancedDisplay)
    bool UseStaticMeshMinLODPerQualityLevels;
 
    UPROPERTY(config, EditAnywhere, Category = PerQualityLevelProperty, AdvancedDisplay)
    bool UseSkeletalMeshMinLODPerQualityLevels;
 
    UPROPERTY(config, EditAnywhere, Category = PerQualityLevelProperty, AdvancedDisplay)
    bool UseClothAssetMinLODPerQualityLevels;
 
    UPROPERTY(config, EditAnywhere, Category = PerQualityLevelProperty, AdvancedDisplay)
    bool UseGrassVarityPerQualityLevels;
 
    UPROPERTY()
    ETransitionType TransitionType;
 
    UPROPERTY()
    FString TransitionDescription;
 
    UPROPERTY()
    FString TransitionGameMode;
 
    UPROPERTY(config)
    uint32 bAllowMatureLanguage:1;
 
    UPROPERTY(config)
    float CameraRotationThreshold;
 
    UPROPERTY(config)
    float CameraTranslationThreshold;
 
    UPROPERTY(config)
    float PrimitiveProbablyVisibleTime;
 
    UPROPERTY(config)
    float MaxOcclusionPixelsFraction;
 
    UPROPERTY(config)
    uint32 bPauseOnLossOfFocus:1;
 
    UPROPERTY(config)
    int32 MaxParticleResize;
 
    UPROPERTY(config)
    int32 MaxParticleResizeWarn;
 
    UPROPERTY(transient)
    TArray<struct FDropNoteInfo> PendingDroppedNotes;
 
    UPROPERTY(globalconfig)
    float NetClientTicksPerSecond;
 
    UPROPERTY(config)
    float DisplayGamma;
 
    UPROPERTY(config, EditAnywhere, Category=Framerate, meta=(UIMin=0, ClampMin=0, EditCondition="!bUseFixedFrameRate"))
    float MinDesiredFrameRate;
 
private:
    UPROPERTY(globalconfig)
    FLinearColor DefaultSelectedMaterialColor;
 
    UPROPERTY(transient)
    FLinearColor SelectedMaterialColor;
 
    UPROPERTY(transient)
    FLinearColor SelectionOutlineColor;
 
    UPROPERTY(transient)
    FLinearColor SubduedSelectionOutlineColor;
 
    UPROPERTY(transient)
    FLinearColor SelectedMaterialColorOverride;
 
    UPROPERTY(transient)
    bool bIsOverridingSelectedColor;
public:
 
    UPROPERTY(globalconfig)
    uint32 bEnableOnScreenDebugMessages:1;
 
    UPROPERTY(transient)
    uint32 bEnableOnScreenDebugMessagesDisplay:1;
 
    UPROPERTY(globalconfig)
    uint32 bSuppressMapWarnings:1;
 
    UPROPERTY(globalconfig)
    uint32 bDisableAILogging:1;
 
    UPROPERTY(globalconfig)
    uint32 bEnableVisualLogRecordingOnStart;
 
private:
    
    UPROPERTY(transient)
    int32 ScreenSaverInhibitorSemaphore;
 
public:
 
    UPROPERTY(transient)
    uint32 bLockReadOnlyLevels:1;
 
    UPROPERTY(globalconfig)
    FString ParticleEventManagerClassPath;
 
    UPROPERTY(transient)
    float SelectionHighlightIntensity;
 
    UPROPERTY(transient)
    float BSPSelectionHighlightIntensity;
 
    UPROPERTY(transient)
    float SelectionHighlightIntensityBillboards;
 
    ENGINE_API void RegisterBeginStreamingPauseRenderingDelegate( FBeginStreamingPauseDelegate* InDelegate );
    FBeginStreamingPauseDelegate* BeginStreamingPauseDelegate;
 
    ENGINE_API void RegisterEndStreamingPauseRenderingDelegate( FEndStreamingPauseDelegate* InDelegate );
    FEndStreamingPauseDelegate* EndStreamingPauseDelegate;
 
private:
    FPreRenderDelegate PreRenderDelegate;
    FPreRenderDelegateEx PreRenderDelegateEx;
    FPostRenderDelegate PostRenderDelegate;
    FPostRenderDelegateEx PostRenderDelegateEx;
 
public:
    UE_DEPRECATED(5.0, "Please use GetPreRenderDelegateEx().")
    FPreRenderDelegate& GetPreRenderDelegate() { return PreRenderDelegate; }
    FPreRenderDelegateEx& GetPreRenderDelegateEx() { return PreRenderDelegateEx; }
    UE_DEPRECATED(5.0, "Please use GetPostRenderDelegateEx().")
    FPostRenderDelegate& GetPostRenderDelegate() { return PostRenderDelegate; }
    FPostRenderDelegateEx& GetPostRenderDelegateEx() { return PostRenderDelegateEx; }
 
    DECLARE_EVENT_ThreeParams(UEngine, FOnTravelFailure, UWorld*, ETravelFailure::Type, const FString&);
    FOnTravelFailure TravelFailureEvent;
 
    DECLARE_EVENT_FourParams(UEngine, FOnNetworkFailure, UWorld*, UNetDriver*, ENetworkFailure::Type, const FString&);
    FOnNetworkFailure NetworkFailureEvent;
 
    DECLARE_EVENT_ThreeParams(UEngine, FOnNetworkLagStateChanged, UWorld*, UNetDriver*, ENetworkLagState::Type);
    FOnNetworkLagStateChanged NetworkLagStateChangedEvent;
 
    DECLARE_EVENT_ThreeParams(UEngine, FOnNetworkDDoSEscalation, UWorld*, UNetDriver*, FString /*SeverityCategory*/);
    FOnNetworkDDoSEscalation NetworkDDoSEscalationEvent;
 
    // for IsInitialized()
    bool bIsInitialized;
 
private:
 
    uint64 LastGCFrame;
 
    float TimeSinceLastPendingKillPurge;
 
    bool bFullPurgeTriggered;
 
    bool bGCPerformingFullPurge = false;
 
    bool bShouldDelayGarbageCollect; 
 
public:
 
    const FLinearColor& GetSelectedMaterialColor() const { return bIsOverridingSelectedColor ? SelectedMaterialColorOverride : SelectedMaterialColor; }
 
    const FLinearColor& GetSelectionOutlineColor() const { return SelectionOutlineColor; }
 
    const FLinearColor& GetSubduedSelectionOutlineColor() const { return SubduedSelectionOutlineColor; }
 
    const FLinearColor& GetHoveredMaterialColor() const { return GetSelectedMaterialColor(); }
 
    void SetSelectedMaterialColor( const FLinearColor& InSelectedMaterialColor ) { SelectedMaterialColor = InSelectedMaterialColor; }
 
    void SetSelectionOutlineColor( const FLinearColor& InSelectionOutlineColor ) { SelectionOutlineColor = InSelectionOutlineColor; }
 
    void SetSubduedSelectionOutlineColor( const FLinearColor& InSubduedSelectionOutlineColor ) { SubduedSelectionOutlineColor = InSubduedSelectionOutlineColor; }
    ENGINE_API void OverrideSelectedMaterialColor( const FLinearColor& OverrideColor );
 
    ENGINE_API void RestoreSelectedMaterialColor();
 
    ENGINE_API void GetDynamicResolutionCurrentStateInfos(FDynamicResolutionStateInfos& OutInfos) const;
 
    ENGINE_API void PauseDynamicResolution();
 
    inline void ResumeDynamicResolution()
    {
        #if WITH_DYNAMIC_RESOLUTION
            bIsDynamicResolutionPaused = false;
            UpdateDynamicResolutionStatus();
        #endif // !UE_SERVER
    }
 
    ENGINE_API void EmitDynamicResolutionEvent(EDynamicResolutionStateEvent Event);
 
    inline class IDynamicResolutionState* GetDynamicResolutionState()
    {
        #if !WITH_DYNAMIC_RESOLUTION
            return nullptr;
        #else
            // Returns next's frame dynamic resolution state to keep game thread consistency after a ChangeDynamicResolutionStateAtNextFrame().
            check(NextDynamicResolutionState.IsValid() || IsRunningCommandlet() || IsRunningDedicatedServer());
            return NextDynamicResolutionState.Get();
        #endif
    }
 
    ENGINE_API void ChangeDynamicResolutionStateAtNextFrame(TSharedPtr< class IDynamicResolutionState > NewState);
 
    inline bool GetDynamicResolutionUserSetting() const
    {
        #if !WITH_DYNAMIC_RESOLUTION
            return false;
        #else
            return bDynamicResolutionEnableUserSetting;
        #endif
    }
 
    inline void SetDynamicResolutionUserSetting(bool Enable)
    {
        #if WITH_DYNAMIC_RESOLUTION
            bDynamicResolutionEnableUserSetting = Enable;
            UpdateDynamicResolutionStatus();
        #endif
    }
 
    ENGINE_API void LoadDefaultBloomTexture();
 
    ENGINE_API void LoadBlueNoiseTexture(bool LoadVector2BlueNoiseTexture);
 
    ENGINE_API void LoadDefaultFilmGrainTexture();
 
    ENGINE_API void ConditionallyLoadPreIntegratedSkinBRDFTexture();
 
    ENGINE_API void LoadLTCTextures();
 
    ENGINE_API void LoadEnergyTextures();
 
    ENGINE_API void LoadGlintTextures();
 
 
    ENGINE_API void LoadSimpleVolumeTextures();
 
    ENGINE_API void LoadSMAATextures();
 
private:
    #if WITH_DYNAMIC_RESOLUTION
        EDynamicResolutionStateEvent LastDynamicResolutionEvent;
 
        TSharedPtr< class IDynamicResolutionState > DynamicResolutionState;
 
        TSharedPtr< class IDynamicResolutionState > NextDynamicResolutionState;
 
        bool bIsDynamicResolutionPaused;
 
        bool bDynamicResolutionEnableUserSetting;
 
        ENGINE_API bool ShouldEnableDynamicResolutionState() const;
 
        ENGINE_API void UpdateDynamicResolutionStatus();
    #endif
 
protected:
 
    FAudioDeviceManager* AudioDeviceManager = nullptr;
 
    FAudioDeviceHandle MainAudioDeviceHandle;
 
private:
    TArray<struct FScreenMessageString> PriorityScreenMessages;
 
    TMap<int32, FScreenMessageString> ScreenMessages;
 
public:
    ENGINE_API float DrawOnscreenDebugMessages(UWorld* World, FViewport* Viewport, FCanvas* Canvas, UCanvas* CanvasObject, float MessageX, float MessageY);
 
    ENGINE_API void AddOnScreenDebugMessage(uint64 Key, float TimeToDisplay, FColor DisplayColor, const FString& DebugMessage, bool bNewerOnTop = true, const FVector2D& TextScale = FVector2D::UnitVector);
 
    ENGINE_API void AddOnScreenDebugMessage(int32 Key, float TimeToDisplay, FColor DisplayColor, const FString& DebugMessage, bool bNewerOnTop = true, const FVector2D& TextScale = FVector2D::UnitVector);
 
    ENGINE_API bool OnScreenDebugMessageExists(uint64 Key);
 
    ENGINE_API void ClearOnScreenDebugMessages();
 
    //Remove the message for the given key
    ENGINE_API void RemoveOnScreenDebugMessage(uint64 Key);
 
    TSharedPtr< class IStereoRendering, ESPMode::ThreadSafe > StereoRenderingDevice;
 
    TSharedPtr< class IXRTrackingSystem, ESPMode::ThreadSafe > XRSystem;
 
    TSharedPtr<FSceneViewExtensions> ViewExtensions;
 
    TSharedPtr< class IEyeTracker, ESPMode::ThreadSafe > EyeTrackingDevice;
    
    DECLARE_EVENT_OneParam( UEngine, FWorldAddedEvent , UWorld* );
    
    FWorldAddedEvent&       OnWorldAdded() { return WorldAddedEvent; }
    
    DECLARE_EVENT_OneParam( UEngine, FWorldDestroyedEvent , UWorld* );
    
    FWorldDestroyedEvent&   OnWorldDestroyed() { return WorldDestroyedEvent; }
    
    ENGINE_API virtual void         WorldAdded( UWorld* World );
    
    ENGINE_API virtual void         WorldDestroyed( UWorld* InWorld );
 
    virtual bool IsInitialized() const { return bIsInitialized; }
 
    ENGINE_API virtual ERHIFeatureLevel::Type GetDefaultWorldFeatureLevel() const;
 
#if WITH_EDITOR
    ENGINE_API virtual bool GetPreviewPlatformName(FName& PlatformName) const;
 
    DECLARE_EVENT( UEngine, FLevelActorListChangedEvent );
    FLevelActorListChangedEvent& OnLevelActorListChanged() { return LevelActorListChangedEvent; }
 
    void BroadcastLevelActorListChanged() { LevelActorListChangedEvent.Broadcast(); }
 
    DECLARE_EVENT_OneParam( UEngine, FLevelActorAddedEvent, AActor* );
    FLevelActorAddedEvent& OnLevelActorAdded() { return LevelActorAddedEvent; }
 
    void BroadcastLevelActorAdded(AActor* InActor) { LevelActorAddedEvent.Broadcast(InActor); }
 
    DECLARE_EVENT_OneParam( UEngine, FLevelActorDeletedEvent, AActor* );
    FLevelActorDeletedEvent& OnLevelActorDeleted() { return LevelActorDeletedEvent; }
 
    void BroadcastLevelActorDeleted(AActor* InActor) { LevelActorDeletedEvent.Broadcast(InActor); }
 
    DECLARE_EVENT_OneParam(UEngine, FActorFolderAddedEvent, UActorFolder*);
    FActorFolderAddedEvent& OnActorFolderAdded() { return ActorFolderAddedEvent; }
 
    void BroadcastActorFolderAdded(UActorFolder* InActorFolder) { ActorFolderAddedEvent.Broadcast(InActorFolder); }
 
    DECLARE_EVENT_OneParam(UEngine, FActorFolderRemovedEvent, UActorFolder*);
    FActorFolderRemovedEvent& OnActorFolderRemoved() { return ActorFolderRemovedEvent; }
 
    void BroadcastActorFolderRemoved(UActorFolder* InActorFolder) { ActorFolderRemovedEvent.Broadcast(InActorFolder); }
 
    DECLARE_EVENT_OneParam(UEngine, FActorFoldersUpdatedEvent, ULevel*);
    FActorFoldersUpdatedEvent& OnActorFoldersUpdatedEvent() { return ActorFoldersUpdatedEvent; }
 
    void BroadcastActorFoldersUpdated(ULevel* InLevel) { ActorFoldersUpdatedEvent.Broadcast(InLevel); }
 
    DECLARE_EVENT_TwoParams(UEngine, FLevelActorOuterChangedEvent, AActor*, UObject*);
    FLevelActorOuterChangedEvent& OnLevelActorOuterChanged() { return LevelActorOuterChangedEvent; }
 
    void BroadcastLevelActorOuterChanged(AActor* InActor, UObject* InOldOuter) { LevelActorOuterChangedEvent.Broadcast(InActor, InOldOuter); }
 
    DECLARE_EVENT_TwoParams( UEngine, FLevelActorAttachedEvent, AActor*, const AActor* );
    FLevelActorAttachedEvent& OnLevelActorAttached() { return LevelActorAttachedEvent; }
 
    void BroadcastLevelActorAttached(AActor* InActor, const AActor* InParent) { LevelActorAttachedEvent.Broadcast(InActor, InParent); }
 
    DECLARE_EVENT_TwoParams( UEngine, FLevelActorDetachedEvent, AActor*, const AActor* );
    FLevelActorDetachedEvent& OnLevelActorDetached() { return LevelActorDetachedEvent; }
 
    void BroadcastLevelActorDetached(AActor* InActor, const AActor* InParent) { LevelActorDetachedEvent.Broadcast(InActor, InParent); }
 
    DECLARE_EVENT_TwoParams( UEngine, FLevelActorFolderChangedEvent, const AActor*, FName );
    FLevelActorFolderChangedEvent& OnLevelActorFolderChanged() { return LevelActorFolderChangedEvent; }
 
    void BroadcastLevelActorFolderChanged(const AActor* InActor, FName OldPath) { LevelActorFolderChangedEvent.Broadcast(InActor, OldPath); }
 
    DECLARE_EVENT_OneParam(UEngine, FOnActorMovingEvent, AActor*);
    FOnActorMovingEvent& OnActorMoving() { return OnActorMovingEvent; }
 
    void BroadcastOnActorMoving(AActor* Actor) { OnActorMovingEvent.Broadcast(Actor); }
 
    DECLARE_EVENT_OneParam(UEditorEngine, FOnActorsMovedEvent, TArray<AActor*>&);
    FOnActorsMovedEvent& OnActorsMoved() { return OnActorsMovedEvent; }
 
    void BroadcastActorsMoved(TArray<AActor*>& Actors) const { OnActorsMovedEvent.Broadcast(Actors); }
 
    DECLARE_EVENT_OneParam( UEngine, FOnActorMovedEvent, AActor* );
    FOnActorMovedEvent& OnActorMoved() { return OnActorMovedEvent; }
 
    void BroadcastOnActorMoved( AActor* Actor ) { OnActorMovedEvent.Broadcast( Actor ); }
 
    DECLARE_EVENT_TwoParams(UEngine, FOnComponentTransformChangedEvent, USceneComponent*, ETeleportType);
    FOnComponentTransformChangedEvent& OnComponentTransformChanged() { return OnComponentTransformChangedEvent; }
 
    void BroadcastOnComponentTransformChanged(USceneComponent* InComponent, ETeleportType InTeleport) { OnComponentTransformChangedEvent.Broadcast(InComponent, InTeleport); }
 
    DECLARE_EVENT_OneParam( UEngine, FLevelActorRequestRenameEvent, const AActor* );
    FLevelActorRequestRenameEvent& OnLevelActorRequestRename() { return LevelActorRequestRenameEvent; }
 
    void BroadcastLevelActorRequestRename(const AActor* InActor) { LevelActorRequestRenameEvent.Broadcast(InActor); }
 
    DECLARE_EVENT_OneParam(UEngine, FLevelComponentRequestRenameEvent, const UActorComponent*);
    FLevelComponentRequestRenameEvent& OnLevelComponentRequestRename() { return LevelComponentRequestRenameEvent; }
 
    void BroadcastLevelComponentRequestRename(const UActorComponent* InComponent) { LevelComponentRequestRenameEvent.Broadcast(InComponent); }
 
    DECLARE_EVENT_OneParam(UEditorEngine, FPostEditorTick, float /* DeltaTime */);
    FPostEditorTick& OnPostEditorTick() { return PostEditorTickEvent; }
 
    void BroadcastPostEditorTick(float DeltaSeconds) { PostEditorTickEvent.Broadcast(DeltaSeconds); }
 
    DECLARE_EVENT(UEditorEngine, FEditorCloseEvent);
    FEditorCloseEvent& OnEditorClose() { return EditorCloseEvent; }
 
    void BroadcastEditorClose() { EditorCloseEvent.Broadcast(); }
 
#endif // #if WITH_EDITOR
 
    FOnTravelFailure& OnTravelFailure() { return TravelFailureEvent; }
    void BroadcastTravelFailure(UWorld* InWorld, ETravelFailure::Type FailureType, const FString& ErrorString = TEXT(""))
    {
        UE_LOGSTATUS(Warning, TEXT("Travel failed, type: %s, reason: \"%s\""), *UEnum::GetValueAsString(FailureType), *ErrorString);
        TravelFailureEvent.Broadcast(InWorld, FailureType, ErrorString);
    }
 
    FOnNetworkFailure& OnNetworkFailure() { return NetworkFailureEvent; }
    ENGINE_API void BroadcastNetworkFailure(UWorld * World, UNetDriver *NetDriver, ENetworkFailure::Type FailureType, const FString& ErrorString = TEXT(""));
 
    FOnNetworkLagStateChanged& OnNetworkLagStateChanged() { return NetworkLagStateChangedEvent; }
    void BroadcastNetworkLagStateChanged(UWorld * World, UNetDriver *NetDriver, ENetworkLagState::Type LagType)
    {
        NetworkLagStateChangedEvent.Broadcast(World, NetDriver, LagType);
    }
 
    FOnNetworkDDoSEscalation& OnNetworkDDoSEscalation() { return NetworkDDoSEscalationEvent; }
    void BroadcastNetworkDDosSEscalation(UWorld* World, UNetDriver* NetDriver, FString SeverityCategory)
    {
        NetworkDDoSEscalationEvent.Broadcast(World, NetDriver, SeverityCategory);
    }
 
    //~ Begin UObject Interface.
    ENGINE_API virtual void FinishDestroy() override;
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    static ENGINE_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
#if WITH_EDITOR
    ENGINE_API virtual void PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent) override;
#endif
    //~ End UObject Interface.
 
    ENGINE_API virtual void Init(IEngineLoop* InEngineLoop);
 
    ENGINE_API virtual void Start();
 
    ENGINE_API virtual void PreExit();
    ENGINE_API virtual void ReleaseAudioDeviceManager();
    
    ENGINE_API void ShutdownHMD();
 
    ENGINE_API void ParseCommandline();
 
    //~ Begin FExec Interface
public:
#if UE_ALLOW_EXEC_COMMANDS
    ENGINE_API virtual bool Exec( UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Out=*GLog ) override;
#endif
 
protected:
    ENGINE_API virtual bool Exec_Dev( UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Out=*GLog ) override;
    ENGINE_API virtual bool Exec_Editor(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Out = *GLog) override;
    //~ End FExec Interface
 
public:
    ENGINE_API bool HandleFlushLogCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleGameVerCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleStatCommand( UWorld* World, FCommonViewportClient* ViewportClient, const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleStopMovieCaptureCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleCrackURLCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleDeferCommand( const TCHAR* Cmd, FOutputDevice& Ar );
 
    ENGINE_API bool HandleCeCommand( UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleDumpTicksCommand( UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleGammaCommand( const TCHAR* Cmd, FOutputDevice& Ar );
 
    ENGINE_API bool HandleShowLogCommand( const TCHAR* Cmd, FOutputDevice& Ar );
 
    // Only compile in when STATS is set
#if STATS
    ENGINE_API bool HandleDumpParticleMemCommand( const TCHAR* Cmd, FOutputDevice& Ar );
#endif
 
#if WITH_PROFILEGPU && (RHI_NEW_GPU_PROFILER == 0)
    ENGINE_API bool HandleProfileGPUCommand( const TCHAR* Cmd, FOutputDevice& Ar ); 
#endif
 
#if WITH_DUMPGPU
    ENGINE_API bool HandleDumpGPUCommand( const TCHAR* Cmd, FOutputDevice& Ar );
#endif
 
#if WITH_GPUDEBUGCRASH
    ENGINE_API bool HandleGPUDebugCrashCommand( const TCHAR* Cmd, FOutputDevice& Ar );
#endif
 
    // Compile in Debug or Development
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST) && WITH_HOT_RELOAD
    ENGINE_API bool HandleHotReloadCommand( const TCHAR* Cmd, FOutputDevice& Ar );
#endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST) && WITH_HOT_RELOAD
 
    // Compile in Debug, Development, and Test
#if !UE_BUILD_SHIPPING
    ENGINE_API bool HandleDumpConsoleCommandsCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
    ENGINE_API bool HandleDumpAvailableResolutionsCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleAnimSeqStatsCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleCountDisabledParticleItemsCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleViewnamesCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleFreezeStreamingCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );       // Smedis
    ENGINE_API bool HandleFreezeAllCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );         // Smedis
 
    ENGINE_API bool HandleToggleRenderingThreadCommand( const TCHAR* Cmd, FOutputDevice& Ar );  
    ENGINE_API bool HandleRecompileShadersCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleRecompileGlobalShadersCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleDumpShaderStatsCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleDumpMaterialStatsCommand( const TCHAR* Cmd, FOutputDevice& Ar );
#if WITH_EDITOR
    ENGINE_API bool HandleDumpShaderCompileStatsCommand( const TCHAR* Cmd, FOutputDevice& Ar );
#endif
    ENGINE_API bool HandleProfileCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleProfileGPUHitchesCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleShaderComplexityCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleFreezeRenderingCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
    ENGINE_API bool HandleStartFPSChartCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleStopFPSChartCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
    ENGINE_API bool HandleDumpLevelScriptActorsCommand( UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleKismetEventCommand( UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleListTexturesCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleListStaticMeshesCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    ENGINE_API bool HandleListSkeletalMeshesCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    ENGINE_API bool HandleListAnimsCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    ENGINE_API bool HandleRemoteTextureStatsCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleListParticleSystemsCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleListSpawnedActorsCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
    ENGINE_API bool HandleLogoutStatLevelsCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
    ENGINE_API virtual void WriteMemReportMetadata( FOutputDevice& Ar, UWorld* InWorld );
    ENGINE_API bool HandleMemReportCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
    ENGINE_API bool HandleMemReportDeferredCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
    ENGINE_API bool HandleSkeletalMeshReportCommand(const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld);
    ENGINE_API bool HandleParticleMeshUsageCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleDumpParticleCountsCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleListLoadedPackagesCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleMemCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleDebugCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleMergeMeshCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
    ENGINE_API bool HandleContentComparisonCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleTogglegtPsysLODCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleObjCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleTestslateGameUICommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleDirCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleTrackParticleRenderingStatsCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleDumpAllocatorStats( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleHeapCheckCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleToggleOnscreenDebugMessageDisplayCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    ENGINE_API bool HandleToggleOnscreenDebugMessageSystemCommand( const TCHAR* Cmd, FOutputDevice& Ar );   
    ENGINE_API bool HandleDisableAllScreenMessagesCommand( const TCHAR* Cmd, FOutputDevice& Ar );           
    ENGINE_API bool HandleEnableAllScreenMessagesCommand( const TCHAR* Cmd, FOutputDevice& Ar );            
    ENGINE_API bool HandleToggleAllScreenMessagesCommand( const TCHAR* Cmd, FOutputDevice& Ar );            
    ENGINE_API bool HandleConfigHashCommand( const TCHAR* Cmd, FOutputDevice& Ar );                     
    ENGINE_API bool HandleConfigMemCommand( const TCHAR* Cmd, FOutputDevice& Ar );  
    ENGINE_API bool HandleGetIniCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    ENGINE_API bool HandleRedirectOutputCommand(const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld);
#endif // !UE_BUILD_SHIPPING
 
    virtual void Tick( float DeltaSeconds, bool bIdleMode ) PURE_VIRTUAL(UEngine::Tick,);
 
    ENGINE_API virtual void UpdateTimeAndHandleMaxTickRate();
 
    static ENGINE_API void SetInputSampleLatencyMarker(uint64 FrameNumber);
 
    static ENGINE_API void SetSimulationLatencyMarkerStart(uint64 FrameNumber);
    static ENGINE_API void SetSimulationLatencyMarkerEnd(uint64 FrameNumber);
 
    static ENGINE_API void SetPresentLatencyMarkerStart(uint64 FrameNumber);
    static ENGINE_API void SetPresentLatencyMarkerEnd(uint64 FrameNumber);
 
    static ENGINE_API void SetRenderSubmitLatencyMarkerStart(uint64 FrameNumber);
    static ENGINE_API void SetRenderSubmitLatencyMarkerEnd(uint64 FrameNumber);
 
    static ENGINE_API void SetFlashIndicatorLatencyMarker(uint64 FrameNumber);
 
    ENGINE_API virtual double CorrectNegativeTimeDelta(double DeltaRealTime);
 
    ENGINE_API void ReinitializeCustomTimeStep();
 
    ENGINE_API bool SetCustomTimeStep(UEngineCustomTimeStep* InCustomTimeStep);
 
    UEngineCustomTimeStep* GetCustomTimeStep() const { return CustomTimeStep; };
 
    FSimpleMulticastDelegate& OnCustomTimeStepChanged() { return CustomTimeStepChangedEvent; }
 
    ENGINE_API void TickDeferredCommands();
 
    ENGINE_API virtual float GetMaxTickRate(float DeltaTime, bool bAllowFrameRateSmoothing = true) const;
 
    ENGINE_API virtual float GetMaxFPS() const;
 
    ENGINE_API virtual void SetMaxFPS(const float MaxFPS);
 
    ENGINE_API virtual void UpdateRunningAverageDeltaTime(float DeltaTime, bool bAllowFrameRateSmoothing = true);
 
    ENGINE_API virtual bool IsAllowedFramerateSmoothing() const;
 
    virtual bool IsRenderingSuspended() const { return false; }
 
    ENGINE_API void UpdateTimecode();
 
    ENGINE_API void ReinitializeTimecodeProvider();
 
    ENGINE_API bool SetTimecodeProvider(UTimecodeProvider* InTimecodeProvider);
 
    UTimecodeProvider* GetTimecodeProvider() const { return TimecodeProvider; };
 
    FSimpleMulticastDelegate& OnTimecodeProviderChanged() { return TimecodeProviderChangedEvent; }
 
public:
 
    ENGINE_API virtual void OnLostFocusPause( bool EnablePause );
 
    ENGINE_API void GetAverageUnitTimes( TArray<float>& AverageTimes );
 
    ENGINE_API void SetAverageUnitTimes(float FrameTime, float RenderThreadTime, float GameThreadTime, float GPUFrameTime, float RHITFrameTime);
 
    ENGINE_API FColor GetFrameTimeDisplayColor(float FrameTimeMS) const;
 
    ENGINE_API virtual bool ShouldThrottleCPUUsage() const;
 
    ENGINE_API bool AreAllWindowsHidden() const;
 
public:
    ENGINE_API TArray<class ULocalPlayer*>::TConstIterator  GetLocalPlayerIterator(UWorld *World);
    ENGINE_API TArray<class ULocalPlayer*>::TConstIterator GetLocalPlayerIterator(const UGameViewportClient *Viewport);
 
    ENGINE_API const TArray<class ULocalPlayer*>& GetGamePlayers(UWorld *World) const;
    ENGINE_API const TArray<class ULocalPlayer*>& GetGamePlayers(const UGameViewportClient *Viewport) const;
 
    ENGINE_API ULocalPlayer* FindFirstLocalPlayerFromControllerId(int32 ControllerId) const;
 
    virtual bool IsControllerIdUsingPlatformUserId() const { return true; }
 
    ENGINE_API ULocalPlayer* FindFirstLocalPlayerFromPlatformUserId(FPlatformUserId PlatformUserId) const;
 
    ENGINE_API ULocalPlayer* GetLocalPlayerFromPlatformUserId(UWorld* InWorld, const FPlatformUserId PlatformUserId) const;
 
    ENGINE_API int32 GetNumGamePlayers(UWorld *InWorld);
    ENGINE_API int32 GetNumGamePlayers(const UGameViewportClient *InViewport);
 
    ENGINE_API ULocalPlayer* GetGamePlayer( UWorld * InWorld, int32 InPlayer );
    ENGINE_API ULocalPlayer* GetGamePlayer( const UGameViewportClient* InViewport, int32 InPlayer );
    
    ENGINE_API ULocalPlayer* GetFirstGamePlayer( UWorld *InWorld );
    ENGINE_API ULocalPlayer* GetFirstGamePlayer(const UGameViewportClient *InViewport );
    ENGINE_API ULocalPlayer* GetFirstGamePlayer( UPendingNetGame *PendingNetGame );
 
    ENGINE_API ULocalPlayer* GetDebugLocalPlayer();
 
    ENGINE_API void CleanupGameViewport();
 
    virtual bool ShouldDrawBrushWireframe( class AActor* InActor ) { return true; }
 
    virtual bool GetMapBuildCancelled() const
    {
        return false;
    }
 
    virtual void SetMapBuildCancelled( bool InCancelled )
    {
        // Intentionally empty.
    }
 
    ENGINE_API bool GetStatValueColoration(const FString& StatName, float Value, FColor& OutColor);
 
    virtual bool AllowSelectTranslucent() const
    {
        // The editor may override this to disallow translucent selection based on user preferences
        return true;
    }
 
    virtual bool OnlyLoadEditorVisibleLevelsInPIE() const
    {
        // The editor may override this to apply the user's preference state
        return true;
    }
 
    ENGINE_API virtual double GetUnifiedTimeBudgetForStreaming(float DeltaSeconds, bool bHighPriority);
 
    ENGINE_API virtual void HandleUnifiedStreaming(float DeltaSeconds);
 
    virtual bool PreferToStreamLevelsInPIE() const
    {
        return false;
    }
 
    ENGINE_API void EnableScreenSaver( bool bEnable );
    
    virtual int32 GetSpriteCategoryIndex( const FName& InSpriteCategory )
    {
        // The editor may override this to handle sprite categories as necessary
        return INDEX_NONE;
    }
 
    static ENGINE_API void PreGarbageCollect();
 
    ENGINE_API void ConditionalCollectGarbage();
 
    ENGINE_API void PerformGarbageCollectionAndCleanupActors();
 
    ENGINE_API void ForceGarbageCollection(bool bFullPurge = false);
 
    ENGINE_API void DelayGarbageCollection();
 
    ENGINE_API void SetTimeUntilNextGarbageCollection(float MinTimeUntilNextPass);
 
    ENGINE_API float GetTimeBetweenGarbageCollectionPasses() const;
 
#if !UE_BUILD_SHIPPING
    ENGINE_API void PerformanceCapture(UWorld* World, const FString& MapName, const FString& SequenceName, float EventTime);
 
    ENGINE_API void LogPerformanceCapture(UWorld* World, const FString& MapName, const FString& SequenceName, float EventTime);
#endif  // UE_BUILD_SHIPPING
 
    ENGINE_API virtual void StartFPSChart(const FString& Label, bool bRecordPerFrameTimes);
 
    ENGINE_API virtual void StopFPSChart(const FString& MapName);
 
    static ENGINE_API void TrimMemory();
 
    ENGINE_API void TickPerformanceMonitoring(float DeltaSeconds);
 
    ENGINE_API void AddPerformanceDataConsumer(TSharedPtr<IPerformanceDataConsumer> Consumer);
 
    ENGINE_API void RemovePerformanceDataConsumer(TSharedPtr<IPerformanceDataConsumer> Consumer);
 
public:
    FEngineHitchDetectedDelegate OnHitchDetectedDelegate;
 
private:
 
    ENGINE_API void OnExternalUIChange(bool bInIsOpening);
 
protected:
 
    ENGINE_API virtual float GetTimeBetweenGarbageCollectionPasses(bool bHasPlayersConnected) const;
 
    virtual void ProcessToggleFreezeCommand( UWorld* InWorld )
    {
        // Intentionally empty.
    }
 
     virtual void ProcessToggleFreezeStreamingCommand(UWorld* InWorld)
     {
        // Intentionally empty.
     }
 
     ENGINE_API bool PerformError(const TCHAR* Cmd, FOutputDevice& Out = *GLog);
 
     static ENGINE_API void SendWorldEndOfFrameUpdates();
 
    ENGINE_API virtual EGarbageCollectionType ShouldForceGarbageCollection();
 
    ENGINE_API virtual float GetIncrementalGCTimePerFrame();
 
public:
    ENGINE_API bool IsEditor();
 
    ENGINE_API FAudioDeviceManager* GetAudioDeviceManager();
 
    ENGINE_API uint32 GetMainAudioDeviceID() const;
 
    ENGINE_API FAudioDeviceHandle GetMainAudioDevice();
    ENGINE_API class FAudioDevice* GetMainAudioDeviceRaw();
 
    ENGINE_API FAudioDeviceHandle GetActiveAudioDevice();
 
    ENGINE_API virtual bool HasMultipleLocalPlayers(UWorld* InWorld);
 
    ENGINE_API bool IsStereoscopic3D(const FViewport* InViewport = nullptr) const;
 
    ENGINE_API void AddTextureStreamingLoc(FVector InLoc, float BoostFactor, bool bOverrideLocation, float OverrideDuration);
 
    ENGINE_API UWorld* GetWorldFromContextObject(const UObject* Object, EGetWorldErrorMode ErrorMode) const;
 
    UWorld* GetWorldFromContextObjectChecked(const UObject* Object) const
    {
        return GetWorldFromContextObject(Object, EGetWorldErrorMode::Assert);
    }
 
    virtual bool IsSettingUpPlayWorld() const { return false; }
 
    ENGINE_API ULocalPlayer* GetLocalPlayerFromControllerId( const UGameViewportClient* InViewport, const int32 ControllerId ) const;
    ENGINE_API ULocalPlayer* GetLocalPlayerFromControllerId( UWorld * InWorld, const int32 ControllerId ) const;
 
    ENGINE_API ULocalPlayer* GetLocalPlayerFromInputDevice(const UGameViewportClient* InViewport, const FInputDeviceId InputDevice) const;
    ENGINE_API ULocalPlayer* GetLocalPlayerFromInputDevice(UWorld * InWorld, const FInputDeviceId InputDevice) const;
 
    ENGINE_API void SwapControllerId(ULocalPlayer *NewPlayer, const int32 CurrentControllerId, const int32 NewControllerID) const;
    
    ENGINE_API void SwapPlatformUserId(ULocalPlayer *NewPlayer, const FPlatformUserId CurrentUserId, const FPlatformUserId NewUserID) const;
 
    ENGINE_API class APlayerController* GetFirstLocalPlayerController(const UWorld* InWorld);
 
    ENGINE_API void GetAllLocalPlayerControllers(TArray<APlayerController*>& PlayerList);
 
    virtual TSharedPtr<class SViewport> GetGameViewportWidget() const
    {
        return nullptr;
    }
 
    float GetDisplayGamma() const { return DisplayGamma; }
 
    virtual void FocusNextPIEWorld(UWorld *CurrentPieWorld, bool previous=false) { }
 
    virtual void ResetPIEAudioSetting(UWorld *CurrentPieWorld) {}
 
    virtual class UGameViewportClient* GetNextPIEViewport(UGameViewportClient * CurrentViewport) { return nullptr; }
 
    virtual void RemapGamepadControllerIdForPIE(class UGameViewportClient* InGameViewport, int32 &ControllerId) { }
 
    TSharedRef<IPortalServiceLocator> GetServiceLocator()
    {
        return ServiceLocator.ToSharedRef();
    }
 
protected:
 
    TSharedPtr<IMessageRpcClient> PortalRpcClient;
 
    TSharedPtr<IPortalRpcLocator> PortalRpcLocator;
 
    TSharedPtr<FTypeContainer> ServiceDependencies;
 
    TSharedPtr<IPortalServiceLocator> ServiceLocator;
 
    TSharedPtr<FPerformanceTrackingChart> ActivePerformanceChart;
 
#if ALLOW_DEBUG_FILES
    TSharedPtr<FFineGrainedPerformanceTracker> ActiveFrameTimesChart;
#endif
 
    TArray<TSharedPtr<IPerformanceDataConsumer>> ActivePerformanceDataConsumers;
 
public:
 
    static ENGINE_API class UFont* GetTinyFont();
 
    static ENGINE_API class UFont* GetSmallFont();
 
    static ENGINE_API class UFont* GetMediumFont();
 
    static ENGINE_API class UFont* GetLargeFont();
 
    static ENGINE_API class UFont* GetSubtitleFont();
 
    static ENGINE_API class UFont* GetMonospaceFont();
 
    static ENGINE_API class UFont* GetAdditionalFont(int32 AdditionalFontIndex);
 
    struct FCopyPropertiesForUnrelatedObjectsParams
    {
        UE_DEPRECATED(5.1, "Aggressive Default Subobject Replacement is no longer being done. An ensure has been left in place to catch any cases that was making use of this feature.")
        bool bAggressiveDefaultSubobjectReplacement;
        bool bDoDelta;
        bool bReplaceObjectClassReferences;
        bool bCopyDeprecatedProperties;
        bool bPreserveRootComponent;
        bool bPerformDuplication;
        bool bOnlyHandleDirectSubObjects;
 
        bool bSkipCompilerGeneratedDefaults;
        bool bNotifyObjectReplacement;
        bool bClearReferences;
        UE_DEPRECATED(5.4, "This isn't used anymore by the code.")
        bool bDontClearReferenceIfNewerClassExists;
        bool bReplaceInternalReferenceUponRead; // While reading back object ptr, immediately replace them if they are in the replacement map.
 
        // In cases where the SourceObject will no longer be able to look up its correct Archetype, it can be supplied
        UObject* SourceObjectArchetype;
        TMap<UObject*, UObject*>* OptionalReplacementMappings;
        const TMap<UClass*, UClass*>* OptionalOldToNewClassMappings; // Will be used along with the bReplaceInternalReferenceUponRead;
 
        ENGINE_API FCopyPropertiesForUnrelatedObjectsParams();
        ENGINE_API FCopyPropertiesForUnrelatedObjectsParams(const FCopyPropertiesForUnrelatedObjectsParams&);
    };
    static ENGINE_API void CopyPropertiesForUnrelatedObjects(UObject* OldObject, UObject* NewObject, FCopyPropertiesForUnrelatedObjectsParams Params = FCopyPropertiesForUnrelatedObjectsParams());
    virtual void NotifyToolsOfObjectReplacement(const TMap<UObject*, UObject*>& OldToNewInstanceMap) { }
 
    ENGINE_API virtual bool UseSound() const;
 
    // This should only ever be called for a EditorEngine
    virtual UWorld* CreatePIEWorldByDuplication(FWorldContext &Context, UWorld* InWorld, FString &PlayWorldMapName) { check(false); return nullptr; }
    virtual void PostCreatePIEWorld(UWorld* InWorld) { check(false); }
 
    virtual bool Experimental_ShouldPreDuplicateMap(const FName MapName) const { return false; }
 
protected:
 
    ENGINE_API virtual void InitializeAudioDeviceManager();
 
    ENGINE_API virtual bool InitializeHMDDevice();
 
    ENGINE_API virtual bool InitializeEyeTrackingDevice();
 
    ENGINE_API virtual void RecordHMDAnalytics();
 
    ENGINE_API virtual void InitializeObjectReferences();
 
    ENGINE_API virtual void InitializePortalServices();
 
    ENGINE_API virtual void InitializeRunningAverageDeltaTime();
 
    float RunningAverageDeltaTime;
 
    FWorldAddedEvent            WorldAddedEvent;
 
    FWorldDestroyedEvent        WorldDestroyedEvent;
private:
 
#if WITH_EDITOR
 
    FLevelActorListChangedEvent LevelActorListChangedEvent;
 
    FLevelActorAddedEvent LevelActorAddedEvent;
 
    FLevelActorDeletedEvent LevelActorDeletedEvent;
 
    FActorFolderAddedEvent ActorFolderAddedEvent;
 
    FActorFolderRemovedEvent ActorFolderRemovedEvent;
 
    FActorFoldersUpdatedEvent ActorFoldersUpdatedEvent;
 
    FLevelActorOuterChangedEvent LevelActorOuterChangedEvent;
 
    FLevelActorAttachedEvent LevelActorAttachedEvent;
 
    FLevelActorDetachedEvent LevelActorDetachedEvent;
 
    FLevelActorFolderChangedEvent LevelActorFolderChangedEvent;
 
    FLevelActorRequestRenameEvent LevelActorRequestRenameEvent;
 
    FLevelComponentRequestRenameEvent LevelComponentRequestRenameEvent;
 
    FOnActorMovingEvent OnActorMovingEvent;
 
    FOnActorMovedEvent  OnActorMovedEvent;
 
    FOnActorsMovedEvent OnActorsMovedEvent;
 
    FOnComponentTransformChangedEvent OnComponentTransformChangedEvent;
    
    FPostEditorTick PostEditorTickEvent;
 
    FEditorCloseEvent EditorCloseEvent;
 
#endif // #if WITH_EDITOR
 
    FRunnableThread*        ScreenSaverInhibitor;
    FScreenSaverInhibitor*  ScreenSaverInhibitorRunnable;
 
 
    UPROPERTY(Config)
    uint32 GlobalNetTravelCount = 0;
 
public:
    void IncrementGlobalNetTravelCount()
    {
        GlobalNetTravelCount++;
    }
 
    uint32 GetGlobalNetTravelCount() const
    {
        return GlobalNetTravelCount;
    }
public:
 
    UPROPERTY(Config, transient)
    TArray<FNetDriverDefinition> NetDriverDefinitions;
 
    UPROPERTY(Config, transient)
    TArray<FIrisNetDriverConfig> IrisNetDriverConfigs;
 
    ENGINE_API const FIrisNetDriverConfig* GetIrisNetDriverConfig(FName InNetDriverDefinition, FName InNetDriverName) const;
 
    ENGINE_API bool WillNetDriverUseIris(const FWorldContext& Context, FName InNetDriverDefinition, FName InNetDriverName) const;
    
    UPROPERTY(config)
    TArray<FString> ServerActors;
 
    UPROPERTY()
    TArray<FString> RuntimeServerActors;
 
    UPROPERTY(globalconfig)
    float NetErrorLogInterval;
 
    ENGINE_API virtual void SpawnServerActors(UWorld *World);
 
    ENGINE_API virtual void HandleNetworkFailure(UWorld *World, UNetDriver *NetDriver, ENetworkFailure::Type FailureType, const FString& ErrorString);
 
    ENGINE_API virtual void HandleTravelFailure(UWorld* InWorld, ETravelFailure::Type FailureType, const FString& ErrorString);
 
    
    ENGINE_API virtual void HandleNetworkLagStateChanged(UWorld* World, UNetDriver* NetDriver, ENetworkLagState::Type LagType);
 
    ENGINE_API void ShutdownWorldNetDriver(UWorld*);
 
    ENGINE_API void ShutdownAllNetDrivers();
 
    ENGINE_API UNetDriver* FindNamedNetDriver(const UWorld* InWorld, FName NetDriverName);
    ENGINE_API UNetDriver* FindNamedNetDriver(const UPendingNetGame* InPendingNetGame, FName NetDriverName);
 
    //virtual ENetMode GetNetMode(FName NetDriverName = NAME_GameNetDriver) const;
    ENGINE_API ENetMode GetNetMode(const UWorld *World) const;
 
    ENGINE_API UNetDriver* CreateNetDriver(UWorld *InWorld, FName NetDriverDefinition);
 
    ENGINE_API bool CreateNamedNetDriver(UWorld *InWorld, FName NetDriverName, FName NetDriverDefinition);
 
    ENGINE_API bool CreateNamedNetDriver(UPendingNetGame *PendingNetGame, FName NetDriverName, FName NetDriverDefinition);
    
    ENGINE_API void DestroyNamedNetDriver(UWorld *InWorld, FName NetDriverName);
    ENGINE_API void DestroyNamedNetDriver(UPendingNetGame *PendingNetGame, FName NetDriverName);
 
    virtual bool NetworkRemapPath(UNetConnection* Connection, FString& Str, bool bReading=true) { return false; }
    virtual bool NetworkRemapPath(UPendingNetGame *PendingNetGame, FString &Str, bool bReading=true) { return false; }
 
    ENGINE_API virtual bool HandleOpenCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld * InWorld );
 
    ENGINE_API virtual bool HandleTravelCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
    
    ENGINE_API virtual bool HandleStreamMapCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld *InWorld );
 
#if WITH_SERVER_CODE
    ENGINE_API virtual bool HandleServerTravelCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
#endif
 
    ENGINE_API virtual bool HandleDisconnectCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld *InWorld );
 
    ENGINE_API virtual bool HandleReconnectCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld *InWorld );
 
    
    ENGINE_API void HandleDisconnect( UWorld *InWorld, UNetDriver *NetDriver );
 
    ENGINE_API bool MakeSureMapNameIsValid(FString& InOutMapName);
 
    ENGINE_API void SetClientTravel( UWorld *InWorld, const TCHAR* NextURL, ETravelType InTravelType );
 
    ENGINE_API void SetClientTravel( UPendingNetGame *PendingNetGame, const TCHAR* NextURL, ETravelType InTravelType );
 
    ENGINE_API void SetClientTravelFromPendingGameNetDriver( UNetDriver *PendingGameNetDriverGame, const TCHAR* NextURL, ETravelType InTravelType );
 
    ENGINE_API virtual EBrowseReturnVal::Type Browse( FWorldContext& WorldContext, FURL URL, FString& Error );
 
    ENGINE_API virtual void TickWorldTravel(FWorldContext& WorldContext, float DeltaSeconds);
 
    ENGINE_API void BrowseToDefaultMap( FWorldContext& WorldContext );
 
    ENGINE_API virtual bool LoadMap( FWorldContext& WorldContext, FURL URL, class UPendingNetGame* Pending, FString& Error );
 
    virtual void RedrawViewports( bool bShouldPresent = true ) { }
 
    virtual void TriggerStreamingDataRebuild() { }
 
    ENGINE_API void BlockTillLevelStreamingCompleted(UWorld* InWorld);
 
    UPROPERTY(transient)
    uint32 bStartedLoadMapMovie:1;
 
    ENGINE_API void CleanupPackagesToFullyLoad(FWorldContext &Context, EFullyLoadPackageType FullyLoadType, const FString& Tag);
 
    virtual void LoadMapRedrawViewports(void)
    {
        RedrawViewports(false);
    }
 
    ENGINE_API void ClearDebugDisplayProperties();
 
    ENGINE_API void LoadPackagesFully(UWorld * InWorld, EFullyLoadPackageType FullyLoadType, const FString& Tag);
 
    ENGINE_API void UpdateTransitionType(UWorld *CurrentWorld);
 
    ENGINE_API UPendingNetGame* PendingNetGameFromWorld( UWorld* InWorld );
 
    ENGINE_API virtual void CancelAllPending();
 
    ENGINE_API virtual void CancelPending(UWorld *InWorld, UPendingNetGame *NewPendingNetGame=nullptr );
 
    ENGINE_API virtual bool WorldIsPIEInNewViewport(UWorld *InWorld);
 
    ENGINE_API FWorldContext* GetWorldContextFromWorld(const UWorld* InWorld);
    ENGINE_API FWorldContext* GetWorldContextFromGameViewport(const UGameViewportClient *InViewport);
    ENGINE_API FWorldContext* GetWorldContextFromPendingNetGame(const UPendingNetGame *InPendingNetGame);   
    ENGINE_API FWorldContext* GetWorldContextFromPendingNetGameNetDriver(const UNetDriver *InPendingNetGame);   
    ENGINE_API FWorldContext* GetWorldContextFromHandle(const FName WorldContextHandle);
    ENGINE_API FWorldContext* GetWorldContextFromPIEInstance(const int32 PIEInstance);
 
    ENGINE_API const FWorldContext* GetWorldContextFromWorld(const UWorld* InWorld) const;
    ENGINE_API const FWorldContext* GetWorldContextFromGameViewport(const UGameViewportClient *InViewport) const;
    ENGINE_API const FWorldContext* GetWorldContextFromPendingNetGame(const UPendingNetGame *InPendingNetGame) const;   
    ENGINE_API const FWorldContext* GetWorldContextFromPendingNetGameNetDriver(const UNetDriver *InPendingNetGame) const;   
    ENGINE_API const FWorldContext* GetWorldContextFromHandle(const FName WorldContextHandle) const;
    ENGINE_API const FWorldContext* GetWorldContextFromPIEInstance(const int32 PIEInstance) const;
 
    ENGINE_API FWorldContext& GetWorldContextFromWorldChecked(const UWorld * InWorld);
    ENGINE_API FWorldContext& GetWorldContextFromGameViewportChecked(const UGameViewportClient *InViewport);
    ENGINE_API FWorldContext& GetWorldContextFromPendingNetGameChecked(const UPendingNetGame *InPendingNetGame);    
    ENGINE_API FWorldContext& GetWorldContextFromPendingNetGameNetDriverChecked(const UNetDriver *InPendingNetGame);    
    ENGINE_API FWorldContext& GetWorldContextFromHandleChecked(const FName WorldContextHandle);
    ENGINE_API FWorldContext& GetWorldContextFromPIEInstanceChecked(const int32 PIEInstance);
 
    ENGINE_API const FWorldContext& GetWorldContextFromWorldChecked(const UWorld * InWorld) const;
    ENGINE_API const FWorldContext& GetWorldContextFromGameViewportChecked(const UGameViewportClient *InViewport) const;
    ENGINE_API const FWorldContext& GetWorldContextFromPendingNetGameChecked(const UPendingNetGame *InPendingNetGame) const;    
    ENGINE_API const FWorldContext& GetWorldContextFromPendingNetGameNetDriverChecked(const UNetDriver *InPendingNetGame) const;    
    ENGINE_API const FWorldContext& GetWorldContextFromHandleChecked(const FName WorldContextHandle) const;
    ENGINE_API const FWorldContext& GetWorldContextFromPIEInstanceChecked(const int32 PIEInstance) const;
 
    const TIndirectArray<FWorldContext>& GetWorldContexts() const { return WorldList;   }
 
    ENGINE_API UWorld* GetCurrentPlayWorld(UWorld* PossiblePlayWorld = nullptr) const;
 
    ENGINE_API virtual void CheckAndHandleStaleWorldObjectReferences(FWorldContext* InWorldContext = nullptr);
 
    UE_DEPRECATED(5.1, "Please use FReferenceChainSearch::FindAndPrintStaleReferencesToObject")
    static ENGINE_API void FindAndPrintStaleReferencesToObject(UObject* ObjectToFindReferencesTo, ELogVerbosity::Type Verbosity);
 
    UE_DEPRECATED(5.3, "Please use FReferenceChainSearch::FindAndPrintStaleReferencesToObject")
    static ENGINE_API FString FindAndPrintStaleReferencesToObject(UObject* ObjectToFindReferencesTo, EPrintStaleReferencesOptions Options);
    UE_DEPRECATED(5.3, "Please use FReferenceChainSearch::FindAndPrintStaleReferencesToObjects")
    static ENGINE_API TArray<FString> FindAndPrintStaleReferencesToObjects(TConstArrayView<UObject*> ObjectsToFindReferencesTo, EPrintStaleReferencesOptions Options);
 
    ENGINE_API FWorldContext& CreateNewWorldContext(EWorldType::Type WorldType);
 
    ENGINE_API virtual void DestroyWorldContext(UWorld * InWorld);
 
    DECLARE_EVENT_OneParam(UEngine, FWorldContextDestroyedEvent, FWorldContext&);
 
    FWorldContextDestroyedEvent&    OnWorldContextDestroyed() { return WorldContextDestroyedEvent; }
 
private:
    FWorldContextDestroyedEvent WorldContextDestroyedEvent;
 
public:
    ENGINE_API int32 GetGlobalFunctionCallspace(UFunction* Function, UObject* FunctionTarget, FFrame* Stack);
 
    ENGINE_API bool ShouldAbsorbAuthorityOnlyEvent();
 
    ENGINE_API bool ShouldAbsorbCosmeticOnlyEvent();
 
    ENGINE_API UGameViewportClient* GameViewportForWorld(const UWorld *InWorld) const;
 
    virtual bool AreEditorAnalyticsEnabled() const { return false; }
    virtual void CreateStartupAnalyticsAttributes( TArray<struct FAnalyticsEventAttribute>& StartSessionAttributes ) const {}
    
    virtual bool IsAutosaving(const EPackageAutoSaveType AutoSaveType = EPackageAutoSaveType::Transient) const { return false; }
 
    virtual bool ShouldDoAsyncEndOfFrameTasks() const { return false; }
 
    bool IsVanillaProduct() const { return bIsVanillaProduct; }
 
protected:
    ENGINE_API void SetIsVanillaProduct(bool bInIsVanillaProduct);
 
private:
    bool bIsVanillaProduct;
 
protected:
    FBrowseURL OnOverrideBrowseURL;
 
    FPendingLevelUpdate OnOverridePendingNetGameUpdate;
 
    TIndirectArray<FWorldContext>   WorldList;
 
    UPROPERTY()
    int32   NextWorldContextHandle;
 
 
    ENGINE_API virtual void CancelPending(FWorldContext& WorldContext);
 
    ENGINE_API virtual void CancelPending(UNetDriver* PendingNetGameDriver);
 
    ENGINE_API virtual void MovePendingLevel(FWorldContext &Context);
 
    virtual bool ShouldShutdownWorldNetDriver()
    {
        return true;
    }
 
    ENGINE_API bool WorldHasValidContext(UWorld *InWorld);
 
    ENGINE_API virtual void HandleBrowseToDefaultMapFailure(FWorldContext& Context, const FString& TextURL, const FString& Error);
 
    ENGINE_API bool IsWorldDuplicate(const UWorld* const InWorld);
 
protected:
 
    // Async map change/ persistent level transition code.
 
    ENGINE_API bool CommitMapChange( FWorldContext &Context);
 
    ENGINE_API bool IsReadyForMapChange(FWorldContext &Context);
 
    ENGINE_API bool IsPreparingMapChange(FWorldContext &Context);
 
    ENGINE_API bool PrepareMapChange(FWorldContext &WorldContext, const TArray<FName>& LevelNames);
 
    ENGINE_API FString GetMapChangeFailureDescription(FWorldContext &Context);
 
    ENGINE_API void ConditionalCommitMapChange(FWorldContext &WorldContext);
 
    ENGINE_API void CancelPendingMapChange(FWorldContext &Context);
 
public:
 
    //~ Begin Public Interface for async map change functions
 
    bool CommitMapChange(UWorld* InWorld) { return CommitMapChange(GetWorldContextFromWorldChecked(InWorld)); }
    bool IsReadyForMapChange(UWorld* InWorld) { return IsReadyForMapChange(GetWorldContextFromWorldChecked(InWorld)); }
    bool IsPreparingMapChange(UWorld* InWorld) { return IsPreparingMapChange(GetWorldContextFromWorldChecked(InWorld)); }
    bool PrepareMapChange(UWorld* InWorld, const TArray<FName>& LevelNames) { return PrepareMapChange(GetWorldContextFromWorldChecked(InWorld), LevelNames); }
    void ConditionalCommitMapChange(UWorld* InWorld) { return ConditionalCommitMapChange(GetWorldContextFromWorldChecked(InWorld)); }
 
    FString GetMapChangeFailureDescription(UWorld *InWorld) { return GetMapChangeFailureDescription(GetWorldContextFromWorldChecked(InWorld)); }
 
    void CancelPendingMapChange(UWorld *InWorld) { return CancelPendingMapChange(GetWorldContextFromWorldChecked(InWorld)); }
 
    ENGINE_API void AddNewPendingStreamingLevel(UWorld *InWorld, FName PackageName, bool bNewShouldBeLoaded, bool bNewShouldBeVisible, int32 LODIndex);
 
    ENGINE_API bool ShouldCommitPendingMapChange(const UWorld *InWorld) const;
    ENGINE_API void SetShouldCommitPendingMapChange(UWorld *InWorld, bool NewShouldCommitPendingMapChange);
 
    ENGINE_API FSeamlessTravelHandler&  SeamlessTravelHandlerForWorld(UWorld *World);
 
    ENGINE_API FURL & LastURLFromWorld(UWorld *World);
 
    ENGINE_API const UGameUserSettings* GetGameUserSettings() const;
    ENGINE_API UGameUserSettings* GetGameUserSettings();
 
private:
    ENGINE_API void CreateGameUserSettings();
 
    ENGINE_API virtual void HandleNetworkFailure_NotifyGameInstance(UWorld* World, UNetDriver* NetDriver, ENetworkFailure::Type FailureType);
 
    ENGINE_API virtual void HandleTravelFailure_NotifyGameInstance(UWorld* World, ETravelFailure::Type FailureType);
 
public:
#if WITH_EDITOR
    //~ Begin Transaction Interfaces.
    virtual int32 BeginTransaction(const TCHAR* TransactionContext, const FText& Description, UObject* PrimaryObject) { return INDEX_NONE; }
    virtual int32 EndTransaction() { return INDEX_NONE; }
    virtual bool CanTransact() { return false; }
    virtual void CancelTransaction(int32 Index) { }
#endif
 
public:
    UEngineSubsystem* GetEngineSubsystemBase(TSubclassOf<UEngineSubsystem> SubsystemClass) const
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        checkSlow(IsThisNotNull(this, "UEngine::GetEditorSubsystemBase"));
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
        return EngineSubsystemCollection.GetSubsystem<UEngineSubsystem>(SubsystemClass);
    }
 
    template <typename TSubsystemClass>
    TSubsystemClass* GetEngineSubsystem() const
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        checkSlow(IsThisNotNull(this, "UEngine::GetEditorSubsystem"));
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
        return EngineSubsystemCollection.GetSubsystem<TSubsystemClass>(TSubsystemClass::StaticClass());
    }
 
    template <typename TSubsystemClass>
    TArray<TSubsystemClass*> GetEngineSubsystemArrayCopy() const
    {
        return EngineSubsystemCollection.GetSubsystemArrayCopy<TSubsystemClass>(TSubsystemClass::StaticClass());
    }
 
    template <typename TSubsystemClass>
    void ForEachEngineSubsystem(TFunctionRef<void(TSubsystemClass*)> Operation) const
    {
        static_assert(TIsDerivedFrom<TSubsystemClass, UEngineSubsystem>::IsDerived, "TSubsystemClass must be derived from UEngineSubsystem");
        return EngineSubsystemCollection.ForEachSubsystem([Operation=MoveTemp(Operation)](UEngineSubsystem* Subsystem){
            Operation(CastChecked<TSubsystemClass>(Subsystem));
        }, TSubsystemClass::StaticClass());
    }
 
protected:
    FObjectSubsystemCollection<UEngineSubsystem> EngineSubsystemCollection;
 
public:
    DECLARE_EVENT_ThreeParams(UEngine, FOnNewStatRegistered, const FName&, const FName&, const FText&);
    static ENGINE_API FOnNewStatRegistered NewStatDelegate;
    
    ENGINE_API void ExecEngineStat(UWorld* World, FCommonViewportClient* ViewportClient, const TCHAR* InName);
 
    ENGINE_API bool IsEngineStat(const FString& InName);
 
    ENGINE_API void SetEngineStat(UWorld* World, FCommonViewportClient* ViewportClient, const FString& InName, const bool bShow);
 
    ENGINE_API void SetEngineStats(UWorld* World, FCommonViewportClient* ViewportClient, const TArray<FString>& InNames, const bool bShow);
 
    ENGINE_API void RenderEngineStats(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 LHSX, int32& InOutLHSY, int32 RHSX, int32& InOutRHSY, const FVector* ViewLocation, const FRotator* ViewRotation);
 
    ENGINE_API int32 RenderNamedEventsEnabled(FCanvas* Canvas, int32 X, int32 Y);
 
     //typedef bool (UEngine::* EngineStatToggle)(UWorld* World, FCommonViewportClient* ViewportClient, const TCHAR* Stream);
    DECLARE_DELEGATE_RetVal_ThreeParams(bool, FEngineStatToggle, UWorld* /*World*/, FCommonViewportClient* /*ViewportClient*/, const TCHAR* /*Stream*/)
 
    
    //typedef int32(UEngine::* EngineStatRender)(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation, const FRotator* ViewRotation);
    DECLARE_DELEGATE_RetVal_SevenParams(int32, FEngineStatRender, UWorld* /*World*/, FViewport* /*Viewport*/, FCanvas* /*Canvas*/, int32 /*X*/, int32 /*Y*/, const FVector* /*ViewLocation*/, const FRotator* /*ViewRotation*/)
 
    ENGINE_API void AddEngineStat(const FName& InCommandName, const FName& InCategoryName, const FText& InDescriptionString, FEngineStatRender InRenderFunc = nullptr, FEngineStatToggle InToggleFunc = nullptr, const bool bInIsRHS = false);
 
    ENGINE_API void RemoveEngineStat(const FName& InCommandName);
private:
 
    struct FEngineStatFuncs
    {
        FName CommandName;
 
        FString CommandNameString;
 
        FName CategoryName;
 
        FText DescriptionString;
 
        FEngineStatRender RenderFunc;
 
        FEngineStatToggle ToggleFunc;
 
        bool bIsRHS;
 
        FEngineStatFuncs(const FName& InCommandName, const FName& InCategoryName, const FText& InDescriptionString, FEngineStatRender InRenderFunc, FEngineStatToggle InToggleFunc, const bool bInIsRHS = false)
            : CommandName(InCommandName)
            , CommandNameString(InCommandName.ToString())
            , CategoryName(InCategoryName)
            , DescriptionString(InDescriptionString)
            , RenderFunc(InRenderFunc)
            , ToggleFunc(InToggleFunc)
            , bIsRHS(bInIsRHS)
        {
            CommandNameString.RemoveFromStart(TEXT("STAT_"));
        }
    };
 
    TArray<FEngineStatFuncs> EngineStats;
 
    // Helper struct that registers itself with the output redirector and copies off warnings
    // and errors that we'll overlay on the client viewport
    struct FErrorsAndWarningsCollector;
    TPimplPtr<FErrorsAndWarningsCollector> ErrorsAndWarningsCollector;
 
private:
 
    ENGINE_API bool ToggleStatFPS(UWorld* World, FCommonViewportClient* ViewportClient, const TCHAR* Stream = nullptr);
    ENGINE_API bool ToggleStatDetailed(UWorld* World, FCommonViewportClient* ViewportClient, const TCHAR* Stream = nullptr);
    ENGINE_API bool ToggleStatHitches(UWorld* World, FCommonViewportClient* ViewportClient, const TCHAR* Stream = nullptr);
    ENGINE_API bool ToggleStatNamedEvents(UWorld* World, FCommonViewportClient* ViewportClient, const TCHAR* Stream = nullptr);
    ENGINE_API bool ToggleStatVerboseNamedEvents(UWorld* World, FCommonViewportClient* ViewportClient, const TCHAR* Stream = nullptr);
    ENGINE_API bool ToggleStatUnit(UWorld* World, FCommonViewportClient* ViewportClient, const TCHAR* Stream = nullptr);
#if !UE_BUILD_SHIPPING
    ENGINE_API bool PostStatSoundModulatorHelp(UWorld* World, FCommonViewportClient* ViewportClient, const TCHAR* Stream = nullptr);
    ENGINE_API bool ToggleStatUnitCriticalPath(UWorld* World, FCommonViewportClient* ViewportClient, const TCHAR* Stream = nullptr);
    ENGINE_API bool ToggleStatUnitMax(UWorld* World, FCommonViewportClient* ViewportClient, const TCHAR* Stream = nullptr);
    ENGINE_API bool ToggleStatUnitGraph(UWorld* World, FCommonViewportClient* ViewportClient, const TCHAR* Stream = nullptr);
    ENGINE_API bool ToggleStatUnitTime(UWorld* World, FCommonViewportClient* ViewportClient, const TCHAR* Stream = nullptr);
    ENGINE_API bool ToggleStatRaw(UWorld* World, FCommonViewportClient* ViewportClient, const TCHAR* Stream = nullptr);
    ENGINE_API bool ToggleStatParticlePerf(UWorld* World, FCommonViewportClient* ViewportClient, const TCHAR* Stream = nullptr);
    ENGINE_API bool ToggleStatTSR(UWorld* World, FCommonViewportClient* ViewportClient, const TCHAR* Stream = nullptr);
#endif
 
#if !UE_BUILD_SHIPPING
    ENGINE_API int32 RenderStatVersion(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
#endif // !UE_BUILD_SHIPPING
    ENGINE_API int32 RenderStatFPS(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
    ENGINE_API int32 RenderStatHitches(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
    ENGINE_API int32 RenderStatSummary(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
    ENGINE_API int32 RenderStatColorList(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
    ENGINE_API int32 RenderStatLevels(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
    ENGINE_API int32 RenderStatLevelMap(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
    ENGINE_API int32 RenderStatUnit(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
    ENGINE_API int32 RenderStatDrawCount(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
#if !UE_BUILD_SHIPPING
    ENGINE_API int32 RenderStatSoundReverb(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
    ENGINE_API int32 RenderStatSoundMixes(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
    ENGINE_API int32 RenderStatSoundModulators(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
    ENGINE_API int32 RenderStatSoundWaves(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
    ENGINE_API int32 RenderStatAudioStreaming(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
    ENGINE_API int32 RenderStatSoundCues(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
    ENGINE_API int32 RenderStatSounds(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
    ENGINE_API int32 RenderStatParticlePerf(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
#endif // !UE_BUILD_SHIPPING
    ENGINE_API int32 RenderStatAI(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
    ENGINE_API int32 RenderStatTimecode(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
    ENGINE_API int32 RenderStatFrameCounter(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
#if STATS
    ENGINE_API int32 RenderStatSlateBatches(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation = nullptr, const FRotator* ViewRotation = nullptr);
#endif
 
    FDelegateHandle HandleScreenshotCapturedDelegateHandle;
 
public:
    ENGINE_API void SetPriorityAndAffinityOnGameThread();
};
 
extern ENGINE_API class UEngine*            GEngine;