GenericPlatformMisc.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/StringFwd.h"
#include "CoreFwd.h"
#include "CoreTypes.h"
#include "FramePro/FrameProConfig.h"
#include "HAL/PlatformCrt.h"
#include "Math/NumericLimits.h"
#include "Misc/CompressionFlags.h"
#include "Misc/EnumClassFlags.h"
#include "ProfilingDebugging/CsvProfilerConfig.h"
#include "ProfilingDebugging/ExternalProfilerConfig.h"
 
#if PLATFORM_CPU_X86_FAMILY
#include <xmmintrin.h> // _mm_prefetch
#elif PLATFORM_CPU_ARM_FAMILY && defined(_MSC_VER)
#include <intrin.h> // __prefetch
#endif
 
class Error;
class FDelegateHandle;
class FOutputDevice;
class FString;
class FText;
class GenericApplication;
class IInstallBundleManager;
class IPlatformChunkInstall;
class IPlatformCompression;
class IWrappedFileHandle;
class IPlatformHostCommunication;
struct FDefaultDelegateUserPolicy;
struct FGenericCrashContext;
struct FGenericMemoryWarningContext;
struct FGuid;
 
template <typename FuncType>
class TFunction;
 
template <typename FuncType, typename UserPolicy>
class TDelegate;
 
#if UE_BUILD_SHIPPING && !WITH_EDITOR
#define UE_DEBUG_BREAK() ((void)0)
#else
#define UE_DEBUG_BREAK() ((void)(FPlatformMisc::IsDebuggerPresent() && ([] () { UE_DEBUG_BREAK_IMPL(); } (), 1)))
#endif
 
// Enable this manually for debugging
#define LOG_NAMED_EVENTS 0
 
#define ENABLE_GENERIC_NAMED_EVENTS ((UE_EXTERNAL_PROFILING_ENABLED) || (STATS) || (ENABLE_STATNAMEDEVENTS) || ((CSV_PROFILER_STATS) && !UE_BUILD_SHIPPING) || (LOG_NAMED_EVENTS) || (FRAMEPRO_ENABLED))
 
enum class EBuildConfiguration : uint8
{
    Unknown,
 
    Debug,
 
    DebugGame,
 
    Development,
 
    Shipping,
 
    Test
};
 
enum class ECrashHandlingType : uint8
{
    Default,    /* UE default handling */
    Disabled,   /* UE doesn't handle crashes on main thread, general workers, rendering thread. */
};
 
CORE_API bool LexTryParseString(EBuildConfiguration& OutConfiguration, const TCHAR* Configuration);
 
CORE_API const TCHAR* LexToString(EBuildConfiguration Configuration);
 
namespace EBuildConfigurations
{
    UE_DEPRECATED(4.24, "EBuildConfigurations::Type is deprecated. Use EBuildConfiguration instead.")
    typedef EBuildConfiguration Type;
 
    UE_DEPRECATED(4.24, "EBuildConfigurations::Unknown is deprecated. Use EBuildConfiguration::Unknown instead.")
    static constexpr EBuildConfiguration Unknown = EBuildConfiguration::Unknown;
 
    UE_DEPRECATED(4.24, "EBuildConfigurations::Debug is deprecated. Use EBuildConfiguration::Debug instead.")
    static constexpr EBuildConfiguration Debug = EBuildConfiguration::Debug;
 
    UE_DEPRECATED(4.24, "EBuildConfigurations::DebugGame is deprecated. Use EBuildConfiguration::DebugGame instead.")
    static constexpr EBuildConfiguration DebugGame = EBuildConfiguration::DebugGame;
 
    UE_DEPRECATED(4.24, "EBuildConfigurations::Development is deprecated. Use EBuildConfiguration::Development instead.")
    static constexpr EBuildConfiguration Development = EBuildConfiguration::Development;
 
    UE_DEPRECATED(4.24, "EBuildConfigurations::Test is deprecated. Use EBuildConfiguration::Test instead.")
    static constexpr EBuildConfiguration Test = EBuildConfiguration::Test;
 
    UE_DEPRECATED(4.24, "EBuildConfigurations::Shipping is deprecated. Use EBuildConfiguration::Shipping instead.")
    static constexpr EBuildConfiguration Shipping = EBuildConfiguration::Shipping;
 
    UE_DEPRECATED(4.24, "EBuildConfigurations::FromString() is deprecated. Use LexFromString() instead.")
    CORE_API EBuildConfiguration FromString( const FString& Configuration );
 
    UE_DEPRECATED(4.24, "EBuildConfigurations::ToString() is deprecated. Use LexToString() instead.")
    CORE_API const TCHAR* ToString( EBuildConfiguration Configuration );
 
    CORE_API FText ToText( EBuildConfiguration Configuration );
}
 
enum class EBuildTargetType : uint8
{
    Unknown,
 
    Game,
 
    Server,
 
    Client,
 
    Editor,
 
    Program,
};
 
CORE_API bool LexTryParseString(EBuildTargetType& OutType, const TCHAR* Text);
 
CORE_API const TCHAR* LexToString(EBuildTargetType Type);
 
namespace EBuildTargets
{
    UE_DEPRECATED(4.24, "EBuildTargets::Type is deprecated. Use EBuildTargetType instead.")
    typedef EBuildTargetType Type;
 
    UE_DEPRECATED(4.24, "EBuildTargets::Unknown is deprecated. Use EBuildTargetType::Unknown instead.")
    static constexpr EBuildTargetType Unknown = EBuildTargetType::Unknown;
 
    UE_DEPRECATED(4.24, "EBuildTargets::Editor is deprecated. Use EBuildTargetType::Unknown instead.")
    static constexpr EBuildTargetType Editor = EBuildTargetType::Editor;
 
    UE_DEPRECATED(4.24, "EBuildTargets::Game is deprecated. Use EBuildTargetType::Unknown instead.")
    static constexpr EBuildTargetType Game = EBuildTargetType::Game;
 
    UE_DEPRECATED(4.24, "EBuildTargets::Server is deprecated. Use EBuildTargetType::Unknown instead.")
    static constexpr EBuildTargetType Server = EBuildTargetType::Server;
 
    UE_DEPRECATED(4.24, "EBuildTargets::FromString is deprecated. Use LexFromString() instead.")
    CORE_API EBuildTargetType FromString( const FString& Target );
 
    UE_DEPRECATED(4.24, "EBuildTargets::FromString is deprecated. Use LexFromString() instead.")
    CORE_API const TCHAR* ToString(EBuildTargetType Target);
}
 
enum class EConvertibleLaptopMode
{
    NotSupported,
 
    Laptop,
 
    Tablet
};
 
enum class EDeviceScreenOrientation : uint8
{
    Unknown,
 
    Portrait,
 
    PortraitUpsideDown,
 
    LandscapeLeft,
 
    LandscapeRight,
 
    FaceUp,
 
    FaceDown,
 
    PortraitSensor,
 
    LandscapeSensor,
 
    FullSensor,
};
 
 
namespace EErrorReportMode
{
    enum Type
    {
        Interactive,
 
        Unattended,
 
        Balloon,
    };
}
 
 
enum class EAppMsgCategory : uint8
{
    Warning,
    Error,
    Success,
    Info,
};
 
 
namespace EAppMsgType
{
    enum Type
    {
        Ok,
        YesNo,
        OkCancel,
        YesNoCancel,
        CancelRetryContinue,
        YesNoYesAllNoAll,
        YesNoYesAllNoAllCancel,
        YesNoYesAll,
    };
}
 
 
namespace EAppReturnType
{
    enum Type
    {
        No,
        Yes,
        YesAll,
        NoAll,
        Cancel,
        Ok,
        Retry,
        Continue,
    };
}
 
CORE_API const TCHAR* LexToString(EAppReturnType::Type Value);
 
/*
 * Holds a computed SHA256 hash.
 */
struct FSHA256Signature
{
    uint8 Signature[32];
 
    CORE_API FString ToString() const;
};
 
enum class EMobileHapticsType : uint8
{
    // these are IOS UIFeedbackGenerator types
    FeedbackSuccess,
    FeedbackWarning,
    FeedbackError,
    SelectionChanged,
    ImpactLight,
    ImpactMedium,
    ImpactHeavy,
};
 
enum class ENetworkConnectionStatus : uint8
{
    Unknown = 0,
    Disabled,
    Local,
    Connected
};
CORE_API const TCHAR* LexToString(ENetworkConnectionStatus EnumVal);
 
enum class ENetworkConnectionType : uint8
{
    Unknown,
    None,
    AirplaneMode,
    Cell,
    WiFi,
    WiMAX,
    Bluetooth,
    Ethernet,
};
 
typedef TDelegate<void(ENetworkConnectionType ConnectionType), FDefaultDelegateUserPolicy> FOnNetworkConnectionChangedDelegate;
 
enum class EProcessDiagnosticFlags : uint32
{
    None            = 0,
    MemorySanitizer = 1 << 0,
    AnsiMalloc      = 1 << 1,
    StompMalloc     = 1 << 2,
};
 
ENUM_CLASS_FLAGS(EProcessDiagnosticFlags);
 
CORE_API const TCHAR* LexToString( ENetworkConnectionType Target );
 
struct FProcessorGroupDesc 
{
    static constexpr uint16 MaxNumProcessorGroups = 16;
    uint64 ThreadAffinities[MaxNumProcessorGroups] = {}; 
    uint16 NumProcessorGroups = 0;
};
 
struct FPageFaultStats
{
    uint64 SoftPageFaults   = 0;
 
    uint64 HardPageFaults   = 0;
 
    uint64 TotalPageFaults  = 0;
};
 
enum class EPageFaultFlags : uint8
{
    SoftPageFaults      = 0x01,
    HardPageFaults      = 0x02,
    TotalPageFaults     = 0x04,
 
    All                 = 0xFF
};
 
ENUM_CLASS_FLAGS(EPageFaultFlags);
 
 
struct FProcessIOStats
{
    uint64 BlockingInput    = 0;
 
    uint64 BlockingOutput   = 0;
 
    uint64 BlockingOther    = 0;
 
    uint64 InputBytes       = 0;
 
    uint64 OutputBytes      = 0;
 
    uint64 OtherBytes       = 0;
};
 
enum class EInputOutputFlags : uint8
{
    BlockingInput       = 0x01,
    BlockingOutput      = 0x02,
    BlockingOther       = 0x04,
    InputBytes          = 0x08,
    OutputBytes         = 0x10,
    OtherBytes          = 0x20,
 
    All                 = 0xFF
};
 
ENUM_CLASS_FLAGS(EInputOutputFlags);
 
enum class EDisplayOutputFormat
{
    SDR_sRGB = 0,
    SDR_Rec709 = 1,
    SDR_ExplicitGammaMapping = 2,
    HDR_ACES_1000nit_ST2084 = 3,
    HDR_ACES_2000nit_ST2084 = 4,
    HDR_ACES_1000nit_ScRGB = 5,
    HDR_ACES_2000nit_ScRGB = 6,
    HDR_LinearEXR = 7,
    HDR_LinearNoToneCurve = 8,
    HDR_LinearWithToneCurve = 9,
 
    MAX
};
 
enum class EDisplayColorGamut
{
    sRGB_D65 = 0,
    DCIP3_D65 = 1,
    Rec2020_D65 = 2,
    ACES_D60 = 3,
    ACEScg_D60 = 4,
 
    MAX
};
 
struct FContextSwitchStats
{
    uint64 VoluntaryContextSwitches     = 0;
 
    uint64 InvoluntaryContextSwitches   = 0;
 
    uint64 TotalContextSwitches         = 0;
};
 
enum class EContextSwitchFlags : uint8
{
    VoluntaryContextSwitches        = 0x01,
    InvoluntaryContextSwitches      = 0x02,
    TotalContextSwitches            = 0x04,
 
    All                             = 0xFF
};
 
ENUM_CLASS_FLAGS(EContextSwitchFlags);
 
struct FGenericPlatformMisc
{
    static CORE_API void PlatformPreInit();
    static void PlatformInit() { }
 
 
    static CORE_API FDelegateHandle AddNetworkListener(FOnNetworkConnectionChangedDelegate&& InNewDelegate);
    static CORE_API bool RemoveNetworkListener(FDelegateHandle Handle);
    
    static void PlatformHandleSplashScreen(bool ShowSplashScreen = false) { }
 
    static void PlatformTearDown() { }
 
    static void SetGracefulTerminationHandler() { }
 
    static void SetCrashHandler(void (* CrashHandler)(const FGenericCrashContext& Context)) { }
 
    static ECrashHandlingType GetCrashHandlingType() { return ECrashHandlingType::Default; }
    
    static ECrashHandlingType SetCrashHandlingType(ECrashHandlingType Type) { return ECrashHandlingType::Default; }
    
    static CORE_API FString GetEnvironmentVariable(const TCHAR* VariableName);
 
    static CORE_API void SetEnvironmentVar(const TCHAR* VariableName, const TCHAR* Value);
 
    FORCEINLINE static int32 GetMaxPathLength()
    {
        return 128;
    }
 
    static CORE_API int32 GetExternalAppMaxPathLength();
 
    static CORE_API const TCHAR* GetPathVarDelimiter();
 
    UE_DEPRECATED(4.14, "GetMacAddress is deprecated. It is not reliable on all platforms")
    static CORE_API TArray<uint8> GetMacAddress();
 
    UE_DEPRECATED(4.14, "GetMacAddressString is deprecated. It is not reliable on all platforms")
    static CORE_API FString GetMacAddressString();
 
    UE_DEPRECATED(4.14, "GetHasedMacAddressString is deprecated. It is not reliable on all platforms")
    static CORE_API FString GetHashedMacAddressString();
 
    static CORE_API FString GetDeviceId();
 
    static CORE_API FString GetUniqueAdvertisingId();
 
    // #CrashReport: 2015-02-24 Remove
    static CORE_API void SubmitErrorReport( const TCHAR* InErrorHist, EErrorReportMode::Type InMode );
 
    static bool IsRemoteSession()
    {
        return false;
    }
 
    FORCEINLINE static bool IsDebuggerPresent()
    {
#if UE_BUILD_SHIPPING
        return false;
#else
        return true; // unknown platforms return true so that they can crash into a debugger
#endif
    }
 
    static CORE_API EProcessDiagnosticFlags GetProcessDiagnostics();
 
    UE_DEPRECATED(4.19, "FPlatformMisc::DebugBreak is deprecated. Use the UE_DEBUG_BREAK() macro instead.")
    FORCEINLINE static void DebugBreak()
    {
        if (IsDebuggerPresent())
        {
            *((int32*)3) = 13; // unknown platforms crash into the debugger
        }
    }
 
    static CORE_API FString GetCPUVendor();
 
    static CORE_API uint32 GetCPUInfo();
 
    static CORE_API bool HasNonoptionalCPUFeatures();
    static CORE_API bool NeedsNonoptionalCPUFeaturesCheck();
 
    static CORE_API FString GetHostArchitecture();
 
    static CORE_API FString GetCPUBrand();
    static CORE_API uint32 GetCPUModelID();
    static CORE_API uint32 GetCPUMicrocodeRevision();
 
    static CORE_API FString GetCPUChipset();
 
    static CORE_API FString GetPrimaryGPUBrand();
 
    static CORE_API FString GetDeviceMakeAndModel();
 
    static CORE_API struct FGPUDriverInfo GetGPUDriverInfo(const FString& DeviceDescription);
 
    static CORE_API void GetOSVersions( FString& out_OSVersionLabel, FString& out_OSSubVersionLabel );
 
    static CORE_API FString GetOSVersion();
 
    static CORE_API bool GetDiskTotalAndFreeSpace( const FString& InPath, uint64& TotalNumberOfBytes, uint64& NumberOfFreeBytes );
 
    static bool GetPageFaultStats(FPageFaultStats& OutStats, EPageFaultFlags Flags=EPageFaultFlags::All)
    {
        return false;
    }
 
    static bool GetBlockingIOStats(FProcessIOStats& OutStats, EInputOutputFlags Flags=EInputOutputFlags::All)
    {
        return false;
    }
 
    static bool GetContextSwitchStats(FContextSwitchStats& OutStats, EContextSwitchFlags Flags=EContextSwitchFlags::All)
    {
        return false;
    }
 
    static bool SupportsMessaging()
    {
        return true;
    }
 
    static bool IsCacheStorageAvailable()
    {
        return true;
    }
 
    static bool SupportsLocalCaching()
    {
        return true;
    }
 
    static bool AllowLocalCaching()
    {
#if PLATFORM_DESKTOP
        return true;
#else
        return false;
#endif
    }
 
    static bool SupportsFullCrashDumps()
    {
        return true;
    }
 
    CORE_API FORCENOINLINE static void MemoryBarrier();
 
    static void SetMemoryWarningHandler(void (* Handler)(const FGenericMemoryWarningContext& Context))
    {
    }
 
    static bool HasMemoryWarningHandler()
    {
        return false;
    }
 
    FORCEINLINE static uint32 GetLastError()
    {
        return 0;
    }
 
    static void SetLastError(uint32 ErrorCode) {}
 
    static CORE_API void RaiseException( uint32 ExceptionCode );
 
public:
 
#if ENABLE_GENERIC_NAMED_EVENTS
    static CORE_API void BeginNamedEventFrame();
    static CORE_API void BeginNamedEvent(const struct FColor& Color, const TCHAR* Text);
    static CORE_API void BeginNamedEvent(const struct FColor& Color, const ANSICHAR* Text);
    static CORE_API void EndNamedEvent();
    static CORE_API void CustomNamedStat(const TCHAR* Text, float Value, const TCHAR* Graph, const TCHAR* Unit);
    static CORE_API void CustomNamedStat(const ANSICHAR* Text, float Value, const ANSICHAR* Graph, const ANSICHAR* Unit);
#else
    FORCEINLINE static void BeginNamedEventFrame()
    {
    }
    FORCEINLINE static void BeginNamedEvent(const struct FColor& Color, const TCHAR* Text)
    {
    }
    FORCEINLINE static void BeginNamedEvent(const struct FColor& Color, const ANSICHAR* Text)
    {
    }
    FORCEINLINE static void EndNamedEvent()
    {
    }
    FORCEINLINE static void CustomNamedStat(const TCHAR* Text, float Value, const TCHAR* Graph, const TCHAR* Unit)
    {
    }
    FORCEINLINE static void CustomNamedStat(const ANSICHAR* Text, float Value, const ANSICHAR* Graph, const ANSICHAR* Unit)
    {
    }
#endif
 
 
    template<typename CharType>
    static void StatNamedEvent(const CharType* Text);
    static CORE_API void TickStatNamedEvents();
    static CORE_API void LogNameEventStatsInit();
 
    static void BeginEnterBackgroundEvent(const TCHAR* Text) {}
    static void EndEnterBackgroundEvent() {}
 
 
    FORCEINLINE static void InitTaggedStorage(uint32 NumTags)
    {
    }
 
    FORCEINLINE static void ShutdownTaggedStorage()
    {
    }
 
    FORCEINLINE static void TagBuffer(const char* Label, uint32 Category, const void* Buffer, size_t BufferSize)
    {
    }
 
    static CORE_API bool SetStoredValues(const FString& InStoreId, const FString& InSectionName, const TMap<FString, FString>& InKeyValues);
 
    static CORE_API bool SetStoredValue(const FString& InStoreId, const FString& InSectionName, const FString& InKeyName, const FString& InValue);
 
    static CORE_API bool GetStoredValue(const FString& InStoreId, const FString& InSectionName, const FString& InKeyName, FString& OutValue);
 
    static CORE_API bool DeleteStoredValue(const FString& InStoreId, const FString& InSectionName, const FString& InKeyName);
 
    static CORE_API bool DeleteStoredSection(const FString& InStoreId, const FString& InSectionName);
 
    static CORE_API void LowLevelOutputDebugString(const TCHAR *Message);
    static CORE_API void VARARGS LowLevelOutputDebugStringf(const TCHAR *Format, ... );
 
    static CORE_API bool IsLowLevelOutputDebugStringStructured();
 
    static CORE_API void SetUTF8Output();
 
    static CORE_API void LocalPrint( const TCHAR* Str );
 
    static bool IsLocalPrintThreadSafe() { return false;  }
 
    static CORE_API bool HasSeparateChannelForDebugOutput();
 
    static CORE_API void RequestExit( bool Force, const TCHAR* CallSite = nullptr);
 
    static CORE_API void RequestExitWithStatus( bool Force, uint8 ReturnCode, const TCHAR* CallSite = nullptr);
 
 
    static CORE_API bool RestartApplication();
 
    static CORE_API bool RestartApplicationWithCmdLine(const char* CmdLine);
 
    static CORE_API const TCHAR* GetSystemErrorMessage(TCHAR* OutBuffer, int32 BufferCount, int32 Error);
 
    static CORE_API void CreateGuid(struct FGuid& Result);
 
    static CORE_API EAppReturnType::Type MessageBoxExt( EAppMsgType::Type MsgType, const TCHAR* Text, const TCHAR* Caption );
 
    static bool CommandLineCommands()
    {
        return 1;
    }
 
    FORCEINLINE static bool Is64bitOperatingSystem()
    {
        return !!PLATFORM_64BITS;
    }
 
    static bool IsValidAbsolutePathFormat(const FString& Path)
    {
        return 1;
    }
 
    static void NormalizePath(FString& InPath)
    {
    }
 
    static void NormalizePath(FStringBuilderBase& InPath)
    {
    }
 
    static CORE_API const TCHAR* GetDefaultPathSeparator();
 
    static CORE_API bool UseRenderThread();
 
    static bool AllowAudioThread()
    {
        // allow if not overridden
        return true;
    }
 
    static CORE_API bool AllowThreadHeartBeat();
 
    static CORE_API int32 NumberOfCores();
 
    static CORE_API const FProcessorGroupDesc& GetProcessorGroupDesc();
 
    static CORE_API int32 NumberOfCoresIncludingHyperthreads();
 
    static CORE_API int32 NumberOfWorkerThreadsToSpawn();
 
    static CORE_API int32 NumberOfIOWorkerThreadsToSpawn();
 
    static struct FAsyncIOSystemBase* GetPlatformSpecificAsyncIOSystem()
    {
        return nullptr;
    }
 
    static const TCHAR* GetPlatformFeaturesModuleName()
    {
        // by default, no module
        return nullptr;
    }
 
    static CORE_API const TCHAR* RootDir();
 
    static CORE_API TArray<FString> GetAdditionalRootDirectories();
    static CORE_API void AddAdditionalRootDirectory(const FString& RootDir);
 
    static CORE_API const TCHAR* EngineDir();
 
    static CORE_API const TCHAR* LaunchDir();
 
    static CORE_API void CacheLaunchDir();
 
    static CORE_API const TCHAR* ProjectDir();
 
    static CORE_API bool GetEngineAndProjectAbsoluteDirsFromExecutable(FString& OutProjectDir, FString& OutEngineDir);
 
    static CORE_API FString CloudDir();
 
    static bool HasProjectPersistentDownloadDir()
    {
        return true;
    }
 
    static CORE_API bool CheckPersistentDownloadStorageSpaceAvailable( uint64 BytesRequired, bool bAttemptToUseUI );
 
 
    static CORE_API const TCHAR* GamePersistentDownloadDir();
 
    static CORE_API const TCHAR* GameTemporaryDownloadDir();
 
    static CORE_API const TCHAR* GeneratedConfigDir();
 
    static CORE_API const TCHAR* GetUBTPlatform();
 
    static CORE_API const TCHAR* GetUBTTarget();
 
    static CORE_API const TCHAR* GetUBTArchitecture();
 
    static CORE_API void SetUBTTargetName(const TCHAR* InTargetName);
    static CORE_API const TCHAR* GetUBTTargetName();
 
    static CORE_API const TCHAR* GetNullRHIShaderFormat();
 
    static CORE_API IPlatformChunkInstall* GetPlatformChunkInstall();
 
    static CORE_API IPlatformCompression* GetPlatformCompression();
 
    static CORE_API IPlatformHostCommunication& GetPlatformHostCommunication();
 
    static bool OsExecute(const TCHAR* CommandType, const TCHAR* Command, const TCHAR* CommandLine = NULL)
    {
        return false;
    }
 
    static bool IsPackagedForDistribution()
    {
#if UE_BUILD_SHIPPING
        return true;
#else
        return false;
#endif
    }
 
    static CORE_API bool GetSHA256Signature(const void* Data, uint32 ByteSize, FSHA256Signature& OutSignature);
 
    static CORE_API FString GetDefaultLanguage();
 
    static CORE_API FString GetDefaultLocale();
 
    static CORE_API FString GetTimeZoneId();
 
    static bool Exec(class UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Out)
    {
        return false;
    }
 
    static CORE_API FText GetFileManagerName();
 
    static bool SupportsMultithreadedFileHandles()
    {
        return true;
    }
 
#if !UE_BUILD_SHIPPING
    static void SetShouldPromptForRemoteDebugging(bool bInShouldPrompt)
    {
        bShouldPromptForRemoteDebugging = bInShouldPrompt;
    }
 
    static void SetShouldPromptForRemoteDebugOnEnsure(bool bInShouldPrompt)
    {
        bPromptForRemoteDebugOnEnsure = bInShouldPrompt;
    }
#endif  //#if !UE_BUILD_SHIPPING
 
#if DO_ENSURE
    static CORE_API bool IsEnsureAllowed();
#else
    static bool IsEnsureAllowed() { return true; }
#endif // DO_ENSURE
 
#if DO_ENSURE
    static CORE_API void UpdateHotfixableEnsureSettings();
#else
    static void UpdateHotfixableEnsureSettings() {}
#endif // DO_ENSURE
 
    static CORE_API void TickHotfixables();
 
    static void PromptForRemoteDebugging(bool bIsEnsure)
    {
    }
 
    FORCEINLINE static void Prefetch(const void* Ptr)
    {
#if PLATFORM_CPU_X86_FAMILY
        _mm_prefetch(static_cast<const char*>(Ptr), _MM_HINT_T0);
#elif PLATFORM_CPU_ARM_FAMILY
#   if PLATFORM_COMPILER_MSVC
        __prefetch(Ptr);
#   else
        __asm__ __volatile__("prfm pldl1keep, [%[ptr]]\n" ::[ptr] "r"(Ptr) : );
#   endif
#else
        // any other architecture must implement this function so this is not called, but we can't use any convenience functions 
        // like unimplemented() or checkf(), so just crash with a comment that if you get here, implement Prefetch and ALL Prefecth calls below
        // this is because the Prefetch calls below will end up calling _this one_ not the platform specific functions
        UE_FORCE_CRASH();
#endif
    }
 
    FORCEINLINE static void Prefetch(const void* Ptr, int32 Offset)
    {
        Prefetch(reinterpret_cast<const void*>(reinterpret_cast<UPTRINT>(Ptr) + Offset));
    }
 
    UE_DEPRECATED(5.2, "Must supply size when prefetching a block of data")
    FORCEINLINE static void PrefetchBlock(const void* Ptr)
    {
        Prefetch(Ptr);
    }
 
    FORCEINLINE static void PrefetchBlock(const void* Ptr, int32 NumBytes)
    {
        // Use compile-time PLATFORM_CACHE_LINE_SIZE to avoid having to load a value before issuing prefetch instructions
        for (int32 Line = 0, NumLines = (NumBytes + PLATFORM_CACHE_LINE_SIZE - 1) / PLATFORM_CACHE_LINE_SIZE; Line < NumLines; ++Line)
        {
            Prefetch(Ptr, Line * PLATFORM_CACHE_LINE_SIZE);
        }
    }
 
    static CORE_API const TCHAR* GetDefaultDeviceProfileName();
 
    FORCEINLINE static int GetBatteryLevel()
    {
        return -1;
    }
 
    FORCEINLINE static void SetBrightness(float bBright) { }
    FORCEINLINE static float GetBrightness() { return 1.0f; }
    FORCEINLINE static bool SupportsBrightness() { return false; }
 
    FORCEINLINE static bool IsInLowPowerMode() { return false;}
 
    static CORE_API float GetDeviceTemperatureLevel();
 
    static CORE_API void SetOverrideProjectDir(const FString& InOverrideDir);
 
    UE_DEPRECATED(4.18, "FPaths::SetOverrideGameDir() has been superseded by FPaths::SetOverrideProjectDir().")
    static FORCEINLINE void SetOverrideGameDir(const FString& InOverrideDir) { return SetOverrideProjectDir(InOverrideDir); }
 
    static CORE_API void GetValidTargetPlatforms(TArray<FString>& TargetPlatformNames);
 
    /*
     * Converts from a local user index to a FPlatformUserId
     *
     * @param LocalUserIndex    A logical index where 0 should always be a valid user
     * @returns                 A platform-allocated opaque user id, or PLATFORMUSERID_NONE
     */
    static CORE_API FPlatformUserId GetPlatformUserForUserIndex(int32 LocalUserIndex);
 
    /*
     * Converts from a FPlatformUserId to local user index
     *
     * @param LocalUserIndex    A platform-allocated opaque user id
     * @returns                 A valid logical index, or INDEX_NONE
     */
    static CORE_API int32 GetUserIndexForPlatformUser(FPlatformUserId PlatformUser);
 
    static bool GetUseVirtualJoysticks()
    {
        return PLATFORM_HAS_TOUCH_MAIN_SCREEN;
    }
 
    static bool SupportsTouchInput()
    {
        return PLATFORM_HAS_TOUCH_MAIN_SCREEN;
    }
 
    static bool SupportsForceTouchInput()
    {
        return false;
    }
 
    static bool ShouldDisplayTouchInterfaceOnFakingTouchEvents()
    {   // FSlateApplication::Get().IsFakingTouchEvents() will trigger to display the Touch Interface
        // on some platforms, we want to ignore that condition
        return true;
    }
 
    static bool DesktopTouchScreen()
    {
#if PLATFORM_DESKTOP
        return true;
#else
        return false;
#endif
    }
 
    static bool FullscreenSameAsWindowedFullscreen()
    {
        // On some platforms, Fullscreen and WindowedFullscreen behave the same.
        //   e.g. On Linux, see FLinuxWindow::ReshapeWindow()/SetWindowMode()
        //        Allowing Fullscreen window mode confuses higher level code (see UE-19996).
        return false;
    }
 
    /*
     * Returns whether the volume buttons are handled by the system
     */
    static bool GetVolumeButtonsHandledBySystem()
    {
        return true;
    }
 
    /*
     * Set whether the volume buttons are handled by the system
     */
    static void SetVolumeButtonsHandledBySystem(bool enabled)
    {}
 
    static CORE_API TArray<uint8> GetSystemFontBytes();
 
    static bool HasActiveWiFiConnection()
    {
        return false;
    }
 
    static CORE_API ENetworkConnectionStatus GetNetworkConnectionStatus();
 
    static CORE_API void SetNetworkConnectionStatus(ENetworkConnectionStatus NewNetworkConnectionStatus);
 
    static ENetworkConnectionType GetNetworkConnectionType()
    {
        return ENetworkConnectionType::Unknown;
    }
 
    static void EnsureNetworkIfNecessary()  {}
 
    static bool HasVariableHardware()
    {
        // By default assume that platform hardware is variable.
        return true;
    }
 
    static bool HasPlatformFeature(const TCHAR* FeatureName)
    {
        return false;
    }
 
    static CORE_API bool IsRunningOnBattery();
 
    static CORE_API EDeviceScreenOrientation GetDeviceOrientation();
 
    UE_DEPRECATED(5.1, "SetDeviceOrientation is deprecated. Use SetAllowedDeviceOrientation instead.")
    static CORE_API void SetDeviceOrientation(EDeviceScreenOrientation NewDeviceOrientation);
 
    static CORE_API EDeviceScreenOrientation GetAllowedDeviceOrientation();
 
    static CORE_API void SetAllowedDeviceOrientation(EDeviceScreenOrientation NewAllowedDeviceOrientation);
    
    static CORE_API int32 GetDeviceVolume();
 
    UE_DEPRECATED(4.14, "GetMachineId is deprecated. Use GetLoginId instead.")
    static CORE_API FGuid GetMachineId();
 
    static CORE_API FString GetLoginId();
 
    static CORE_API FString GetEpicAccountId();
 
    static CORE_API FString GetDeviceTag();
 
    static CORE_API FString GetOperatingSystemId();
 
    static CORE_API EConvertibleLaptopMode GetConvertibleLaptopMode();
 
    static CORE_API const TCHAR* GetEngineMode();
 
    static CORE_API TArray<FString> GetPreferredLanguages();
 
    static CORE_API FString GetLocalCurrencyCode();
 
    static CORE_API FString GetLocalCurrencySymbol();
 
    static CORE_API void RegisterForRemoteNotifications();
 
    static CORE_API bool IsRegisteredForRemoteNotifications();
 
    static CORE_API void UnregisterForRemoteNotifications();
 
    static CORE_API FString GetPendingActivationProtocol();
 
    static bool ShouldDisablePluginAtRuntime(const FString& PluginName)
    {
        return false;
    }
 
    static void PrepareMobileHaptics(EMobileHapticsType Type)
    {
    }
 
    static void TriggerMobileHaptics()
    {
    }
 
    static void ReleaseMobileHaptics()
    {
    }
 
    static void ShareURL(const FString& URL, const FText& Description, int32 LocationHintX, int32 LocationHintY)
    {
    }
 
    static bool SupportsDeviceCheckToken()
    {
        return false;
    }
 
    static CORE_API bool RequestDeviceCheckToken(TFunction<void(const TArray<uint8>&)> QuerySucceededFunc, TFunction<void(const FString&, const FString&)> QueryFailedFunc);
 
    static CORE_API FString LoadTextFileFromPlatformPackage(const FString& RelativePath);
 
    static CORE_API bool FileExistsInPlatformPackage(const FString& RelativePath);
 
    static CORE_API void TearDown();
 
    static CORE_API void ParseChunkIdPakchunkIndexMapping(TArray<FString> ChunkIndexRedirects, TMap<int32, int32>& OutMapping);
 
    static void PumpMessagesOutsideMainLoop()
    {
    }
 
    static void PumpMessagesForSlowTask()
    {
    }
    static void PumpEssentialAppMessages()
    {
    }
 
    static void HidePlatformStartupScreen()
    {
 
    }
 
    FORCEINLINE static bool UseHDRByDefault()
    {
        return false;
    }
 
    FORCEINLINE static void ChooseHDRDeviceAndColorGamut(uint32 DeviceId, uint32 DisplayNitLevel, EDisplayOutputFormat& OutputDevice, EDisplayColorGamut& ColorGamut)
    {
    }
 
    FORCEINLINE static int32 GetChunkIDFromPakchunkIndex(int32 PakchunkIndex)
    {
        return PakchunkIndex;
    }
 
    static CORE_API FStringView GetPakFilenamePrefix();
 
    static CORE_API int32 GetPakchunkIndexFromPakFile(FStringView InFilename);
 
    FORCEINLINE static bool Expand16BitIndicesTo32BitOnLoad()
    {
        return false;
    }
 
    FORCEINLINE static void GetNetworkFileCustomData(TMap<FString,FString>& OutCustomPlatformData)
    {
    }
 
    FORCEINLINE static bool SupportsBackbufferSampling()
    {
        return true;
    }
 
    static inline int32 GetMaxRefreshRate()
    {
        return 60;
    }
 
    static inline int32 GetMaxSupportedRefreshRate()
    {
        return GetMaxRefreshRate();
    }
 
    static inline int32 GetMaxSyncInterval()
    {
        // Generic platform has no limit.
        return MAX_int32;
    }
    
    /*
    * Returns the value of config rule variable or null if not found.
    */
    static CORE_API const FString* GetConfigRulesVariable(const FString& Key);
 
    /*
    * Returns the map containing all config rule variables.
    */
    static CORE_API const class TMap<FString, FString>& GetConfigRuleVars();
 
    static CORE_API bool IsPGOEnabled();
 
    static CORE_API bool IsPGICapableBinary();
 
    static bool StartNewPGOCollection(const FString& AbsoluteFileName) { return false; }
 
    static CORE_API bool IsPGIActive();
 
    static CORE_API const FString VersionCheckPlatformName();
 
    static bool StopPGOCollectionAndCloseFile() { return false; }
 
    static CORE_API void ShowConsoleWindow();
 
    /*
     * For mobile devices, this function will return true if we wish to propagate the alpha to the backbuffer
     */
    static CORE_API int GetMobilePropagateAlphaSetting();
 
    static bool IsRunningInCloud()
    {
        return false;
    }
 
    static bool WasLaunchedStreaming()
    {
        return false;
    }
 
    static void DisableScreenTimeout()
    {
    }
 
    static void EnableScreenTimeout()
    {
    }
 
    /*
     * Unix only function, but put a stub so we can call this for higher level code when we want to setup the Syscall Filters
     */
    static bool SetupSyscallFilters()
    {
        return false;
    }
 
    static const float GetVirtualKeyboardInputHeight()
    {
        return 0.0f;
    }
    
#if !UE_BUILD_SHIPPING
    static bool GetPlatformScreenWarnings(TArray<FText>& PlatformScreenWarnings)
    {
        return false;
    }
 
protected:
    static CORE_API bool bShouldPromptForRemoteDebugging;
    static CORE_API bool bPromptForRemoteDebugOnEnsure;
#endif  //#if !UE_BUILD_SHIPPING
 
    static CORE_API EDeviceScreenOrientation AllowedDeviceOrientation;
 
    static CORE_API ENetworkConnectionStatus CurrentNetworkConnectionStatus;
 
protected:
    static CORE_API void GetConfiguredCoreLimits(int32 PlatformNumPhysicalCores, int32 PlatformNumLogicalCores,
        bool& bOutFullyInitialized, int32& OutPhysicalCoreLimit, int32& OutLogicalCoreLimit,
        bool& bOutSetPhysicalCountToLogicalCount);
 
private:
    struct FStaticData;
};