WindowsPlatformMisc.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "HAL/PlatformMemory.h"
#include "GenericPlatform/GenericPlatformMisc.h"
 
#define UE_DEBUG_BREAK_IMPL() PLATFORM_BREAK()
 
class GenericApplication;
struct FGuid;
class IPlatformChunkInstall;
 
#if PLATFORM_CPU_X86_FAMILY
namespace ECPUFeatureBits_X86
{
    inline constexpr uint32 SSE2 = 1U << 2;
    inline constexpr uint32 SSSE3 = 1U << 3;
    inline constexpr uint32 SSE42 = 1U << 4;
    inline constexpr uint32 AVX = 1U << 5;
    inline constexpr uint32 BMI1 = 1U << 6; // Bit Manipulation Instructions - 1
    inline constexpr uint32 BMI2 = 1U << 7; // Bit Manipulation Instructions - 2
    inline constexpr uint32 AVX2 = 1U << 8;
    inline constexpr uint32 F16C = 1U << 9; // Float16 conversion instructions
    inline constexpr uint32 AVX512 = 1U << 10; // Skylake feature set : AVXF512{ F,VL,BW,DQ}.
    inline constexpr uint32 AVX512_NOCAVEATS = 1U << 11; // Set when we have AVX512 without caveats like throttling.
}
#endif
 
struct FWindowsOSVersionHelper
{
    enum ErrorCodes
    {
        SUCCEEDED = 0,
        ERROR_UNKNOWNVERSION = 1,
        ERROR_GETPRODUCTINFO_FAILED = 2,
        ERROR_GETVERSIONEX_FAILED = 4,
        ERROR_GETWINDOWSGT62VERSIONS_FAILED = 8,
    };
 
    static CORE_API int32 GetOSVersions( FString& OutOSVersion, FString& OutOSSubVersion );
};
 
enum class ECOMModel : uint8
{
    Singlethreaded = 0,     
    Multithreaded,          
};
 
enum class EStorageDeviceType : uint8
{
    Unknown = 0,
    HDD = 1,
    SSD = 2,
    NVMe = 3,
    Hybrid = 4,
 
    Other = 0xff
};
 
CORE_API const TCHAR* LexToString(EStorageDeviceType StorageType);
 
struct FPlatformDriveStats
{
    TCHAR DriveName;
    uint64 UsedBytes;
    uint64 FreeBytes;
    EStorageDeviceType DriveType;
};
 
struct FWindowsPlatformMisc
    : public FGenericPlatformMisc
{
    static CORE_API void PlatformPreInit();
    static CORE_API void PlatformInit();
    static CORE_API void PlatformTearDown();
    static CORE_API void SetGracefulTerminationHandler();
    static CORE_API void CallGracefulTerminationHandler();
    static CORE_API ECrashHandlingType GetCrashHandlingType();
    static CORE_API ECrashHandlingType SetCrashHandlingType(ECrashHandlingType);
    static CORE_API int32 GetMaxPathLength();
    static CORE_API int32 GetExternalAppMaxPathLength();
 
    UE_DEPRECATED(4.21, "void FPlatformMisc::GetEnvironmentVariable(Name, Result, Length) is deprecated. Use FString FPlatformMisc::GetEnvironmentVariable(Name) instead.")
    static CORE_API void GetEnvironmentVariable(const TCHAR* VariableName, TCHAR* Result, int32 ResultLength);
 
    static CORE_API FString GetEnvironmentVariable(const TCHAR* VariableName);
    static CORE_API void SetEnvironmentVar(const TCHAR* VariableName, const TCHAR* Value);
 
    static CORE_API TArray<uint8> GetMacAddress();
    static CORE_API void SubmitErrorReport( const TCHAR* InErrorHist, EErrorReportMode::Type InMode );
 
#if !UE_BUILD_SHIPPING
    static CORE_API bool IsDebuggerPresent();
    static CORE_API EProcessDiagnosticFlags GetProcessDiagnostics();
#endif
 
    inline static void MemoryBarrier() 
    {
#if PLATFORM_CPU_X86_FAMILY
        _mm_sfence();
#elif PLATFORM_CPU_ARM_FAMILY
        __dmb(_ARM64_BARRIER_SY);
#endif
    }
 
    static CORE_API void AsymmetricThreadFenceHeavy();
 
    UE_FORCEINLINE_HINT static void AsymmetricThreadFenceLight()
    {
        _ReadWriteBarrier();
    }
 
    static CORE_API bool IsRemoteSession();
 
    static CORE_API void SetUTF8Output();
    static CORE_API void LocalPrint(const TCHAR *Message);
 
    static bool IsLocalPrintThreadSafe()
    { 
        //returning true when the debugger is attached is to allow
        //printing of log lines immediately to the output window.
        //return false in not attached because OutputDebuString is slow.
        return IsDebuggerPresent();
    }
    
    static CORE_API void RequestExitWithStatus(bool Force, uint8 ReturnCode, const TCHAR* CallSite = nullptr);
    static CORE_API void RequestExit(bool Force, const TCHAR* CallSite = nullptr);
    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 CORE_API bool CommandLineCommands();
    static CORE_API bool Is64bitOperatingSystem();
    static CORE_API bool IsValidAbsolutePathFormat(const FString& Path);
    static CORE_API int32 NumberOfCores();
    static CORE_API const FProcessorGroupDesc& GetProcessorGroupDesc();
    static CORE_API int32 NumberOfCoresIncludingHyperthreads();
    static CORE_API int32 NumberOfWorkerThreadsToSpawn();
 
    static CORE_API const TCHAR* GetPlatformFeaturesModuleName();
 
    static CORE_API FString GetDefaultLanguage();
    static CORE_API FString GetDefaultLocale();
 
    static CORE_API uint32 GetLastError();
    static CORE_API void SetLastError(uint32 ErrorCode);
    static CORE_API void RaiseException( uint32 ExceptionCode );
    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 bool CoInitialize(ECOMModel Model = ECOMModel::Singlethreaded);
    static CORE_API void CoUninitialize();
 
    static CORE_API bool OsExecute(const TCHAR* CommandType, const TCHAR* Command, const TCHAR* CommandLine = NULL);
 
    static CORE_API Windows::HWND GetTopLevelWindowHandle(uint32 ProcessId);
 
    static CORE_API bool VerifyWindowsVersion(uint32 MajorVersion, uint32 MinorVersion, uint32 BuildNumber = 0);
 
    static CORE_API bool IsWine();
 
#if !UE_BUILD_SHIPPING
    static CORE_API void PromptForRemoteDebugging(bool bIsEnsure);
#endif  //#if !UE_BUILD_SHIPPING
 
 
    static CORE_API bool HasCPUIDInstruction();
 
#if PLATFORM_CPU_X86_FAMILY
    // Query the CPUID and parse out various feature bits. This is safe to call multiple times and caches the result internally for rapid access.
    // Bits are all from the ECPUFeatureBits_X86 namespace.
    static CORE_API uint32 GetFeatureBits_X86();
    static bool CheckFeatureBit_X86(uint32 FeatureBit_X86) { return (GetFeatureBits_X86() & FeatureBit_X86) != 0; }
    static bool CheckAllFeatureBits_X86(uint32 FeatureBits_X86) { return (GetFeatureBits_X86() & FeatureBits_X86) == FeatureBits_X86; }
#endif
 
    static CORE_API bool HasAVX2InstructionSupport();
    
    static CORE_API bool HasTPM2Support();
    static CORE_API bool HasSecureBootSupport();
    static CORE_API bool SupportsWindows11();
 
    static CORE_API FString GetCPUVendor();
    static CORE_API FString GetCPUBrand();
    static CORE_API uint32 GetCPUModelID();
    static CORE_API uint32 GetCPUMicrocodeRevision();
 
    static CORE_API FString GetPrimaryGPUBrand();
    static CORE_API struct FGPUDriverInfo GetGPUDriverInfo(const FString& DeviceDescription, bool bVerbose = true);
    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 CORE_API bool GetPageFaultStats(FPageFaultStats& OutStats, EPageFaultFlags Flags=EPageFaultFlags::All);
    static CORE_API bool GetBlockingIOStats(FProcessIOStats& OutStats, EInputOutputFlags Flags=EInputOutputFlags::All);
 
    static CORE_API uint32 GetCPUInfo();
 
    static CORE_API bool HasNonoptionalCPUFeatures();
    static CORE_API bool NeedsNonoptionalCPUFeaturesCheck();
    static CORE_API bool HasTimedPauseCPUFeature();
 
    static CORE_API FString GetHostArchitecture();
 
    static CORE_API bool QueryRegKey( const Windows::HKEY InKey, const TCHAR* InSubKey, const TCHAR* InValueName, FString& OutData );
 
    static CORE_API bool GetVSComnTools(int32 Version, FString& OutData);
 
    UE_DEPRECATED(5.2, "Please use PLATFORM_CACHE_LINE_SIZE instead, runtime query of cache line size not supported")
    static CORE_API int32 GetCacheLineSize();
    static CORE_API const TCHAR* GetDefaultPathSeparator();
 
    static CORE_API FText GetFileManagerName();
 
    static bool HasActiveWiFiConnection()
    {
        // for now return true
        return true;
    }
 
    static CORE_API bool IsDeviceHandheld();
    
    static CORE_API bool IsRunningOnBattery();
 
    static CORE_API int GetBatteryLevel();
 
    static CORE_API bool IsUsingBatterySaver();
 
    inline static void ChooseHDRDeviceAndColorGamut(uint32 DeviceId, uint32 DisplayNitLevel, EDisplayOutputFormat& OutputDevice, EDisplayColorGamut& ColorGamut)
    {
        // needs to match GRHIHDRDisplayOutputFormat chosen in FD3D12DynamicRHI::Init
#if WITH_EDITOR
        // ScRGB, 1000 or 2000 nits
        OutputDevice = (DisplayNitLevel == 1000) ? EDisplayOutputFormat::HDR_ACES_1000nit_ScRGB : EDisplayOutputFormat::HDR_ACES_2000nit_ScRGB;
        // Rec709
        ColorGamut = EDisplayColorGamut::sRGB_D65;
#else
        // ST-2084, 1000 or 2000 nits
        OutputDevice = (DisplayNitLevel == 1000) ? EDisplayOutputFormat::HDR_ACES_1000nit_ST2084 : EDisplayOutputFormat::HDR_ACES_2000nit_ST2084;
        // Rec2020
        ColorGamut = EDisplayColorGamut::Rec2020_D65;
#endif
    }
 
    static CORE_API FString GetOperatingSystemId();
 
    static CORE_API EConvertibleLaptopMode GetConvertibleLaptopMode();
 
    static CORE_API IPlatformChunkInstall* GetPlatformChunkInstall();
 
    static CORE_API void PumpMessagesOutsideMainLoop();
 
    static CORE_API uint64 GetFileVersion(const FString &FileName);
 
    static CORE_API int32 GetMaxRefreshRate();
 
    static CORE_API void UpdateDriveFreeSpace();
 
    static CORE_API const FPlatformDriveStats* GetDriveStats(WIDECHAR DriveLetter);
};
 
 
#if defined(WINDOWS_USE_FEATURE_PLATFORMMISC_CLASS) && WINDOWS_USE_FEATURE_PLATFORMMISC_CLASS
typedef FWindowsPlatformMisc FPlatformMisc;
#endif