DataDrivenPlatformInfoRegistry.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "HAL/PlatformCrt.h"
#include "Internationalization/Text.h"
#include "Misc/Guid.h"
#include "UObject/NameTypes.h"
#include "UObject/UnrealNames.h"
 
class FConfigFile;
 
#define DDPI_HAS_EXTENDED_PLATFORMINFO_DATA (WITH_EDITOR || IS_PROGRAM)
 
enum class EPlatformInfoType : uint8
{
    TruePlatformsOnly,
 
    AllPlatformInfos,
};
 
#if DDPI_HAS_EXTENDED_PLATFORMINFO_DATA
 
 
enum class EPlatformIconSize : uint8
{
    Normal,
 
    Large,
 
    XLarge,
};
 
 
 
// enum class EPlatformSDKStatus : uint8
// {
//  /** SDK status is unknown */
//  Unknown,
// 
//  /** SDK is installed */
//  Installed,
// 
//  /** SDK is not installed */
//  NotInstalled,
// };
 
struct FPlatformIconPaths
{
    FPlatformIconPaths()
    {
    }
 
    FPlatformIconPaths(const FString& InIconPath)
        : NormalPath(InIconPath)
        , LargePath(InIconPath)
        , XLargePath(InIconPath)
    {
    }
 
    FPlatformIconPaths(const FString& InNormalPath, const FString& InLargePath)
        : NormalPath(InNormalPath)
        , LargePath(InLargePath)
        , XLargePath(InLargePath)
    {
    }
 
    FPlatformIconPaths(const FString& InNormalPath, const FString& InLargePath, const FString& InXLargePath)
        : NormalPath(InNormalPath)
        , LargePath(InLargePath)
        , XLargePath(InXLargePath)
    {
    }
 
    FName NormalStyleName;
    FString NormalPath;
 
    FName LargeStyleName;
    FString LargePath;
 
    FName XLargeStyleName;
    FString XLargePath;
};
 
 
struct FPreviewPlatformMenuItem
{
    FName PlatformName;
    FName ShaderFormat;
    FName ShaderPlatformToPreview;
    FName PreviewShaderPlatformName;
    FName PreviewFeatureLevelName;
    FString ActiveIconPath;
    FName ActiveIconName;
    FString InactiveIconPath;
    FName InactiveIconName;
    FText OptionalFriendlyNameOverride;
    FText MenuTooltip;
    FText IconText;
    FName DeviceProfileName;
};
 
#endif
 
 
// Information about a platform loaded from disk
struct FDataDrivenPlatformInfo
{
    // copy of the platform name, same as the Key into GetAllPlatformInfos()
    FName IniPlatformName;
 
    // cached list of ini parents
    TArray<FString> IniParentChain;
 
    // is this platform confidential
    bool bIsConfidential = false;
 
    // some platforms are here just for IniParentChain needs and are not concrete platforms
    bool bIsFakePlatform = false;
 
    // the name of the ini section to use to load target platform settings (used at runtime and cooktime)
    FString TargetSettingsIniSectionName;
 
    // list of additional restricted folders
    TArray<FString> AdditionalRestrictedFolders;
 
    // GUID to represent this platform forever
    FGuid GlobalIdentifier;
 
    // MemoryFreezing information, matches FPlatformTypeLayoutParameters - defaults are clang, noneditor
    uint32 Freezing_MaxFieldAlignment = 0xffffffff;
    bool Freezing_b32Bit = false;
    bool Freezing_bForce64BitMemoryImagePointers = false;
    bool Freezing_bAlignBases = false;
 
    // True if this platform has a non-generic gamepad specifically associated with it
    bool bHasDedicatedGamepad = false;
 
    // True if this platform handles input via standard keyboard layout by default, translates to PC platform
    bool bDefaultInputStandardKeyboard = false;
 
    // Input-related settings
    bool bInputSupportConfigurable = false;
    FString DefaultInputType = "Gamepad";
    bool bSupportsMouseAndKeyboard = false;
    bool bSupportsGamepad = true;
    bool bCanChangeGamepadType = true;
    bool bSupportsTouch = false;
 
    // the compression format that this platform wants; overrides game unless bForceUseProjectCompressionFormat
    FString HardwareCompressionFormat;
 
    FName OverrideCookPlatformName;
 
    const FName& GetCookPlatformName() const
    {
        if (!OverrideCookPlatformName.IsNone() && OverrideCookPlatformName.IsValid())
        {
            return OverrideCookPlatformName;
        }
        return IniPlatformName;
    }
 
    // NOTE: add more settings here (and read them in in the LoadDDPIIniSettings() function in the .cpp)
 
 
#if DDPI_HAS_EXTENDED_PLATFORMINFO_DATA
 
public:
 
 
    // setting moved from PlatformInfo::FTargetPlatformInfo
 
 
    FPlatformIconPaths IconPaths;
 
    FString AutoSDKPath;
 
    FString SDKTutorial;
 
    FName PlatformGroupName;
 
    FName PlatformSubMenu;
 
    FName UBTPlatformName;
    FString UBTPlatformString;
 
    bool bCanUseCrashReporter;
 
    bool bEnabledForUse;
 
    bool bUsesHostCompiler;
 
    bool bUATClosesAfterLaunch;
 
    bool bHasCompiledTargetSupport;
 
 
 
    FName GetIconStyleName(const EPlatformIconSize InIconSize) const
    {
        switch (InIconSize)
        {
        case EPlatformIconSize::Normal:
            return IconPaths.NormalStyleName;
        case EPlatformIconSize::Large:
            return IconPaths.LargeStyleName;
        case EPlatformIconSize::XLarge:
            return IconPaths.XLargeStyleName;
        default:
            break;
        }
        return NAME_None;
    }
 
    const FString& GetIconPath(const EPlatformIconSize InIconSize) const
    {
        switch (InIconSize)
        {
        case EPlatformIconSize::Normal:
            return IconPaths.NormalPath;
        case EPlatformIconSize::Large:
            return IconPaths.LargePath;
        case EPlatformIconSize::XLarge:
            return IconPaths.XLargePath;
        default:
            break;
        }
        static const FString EmptyString = TEXT("");
        return EmptyString;
    }
 
private:
    friend struct FDataDrivenPlatformInfoRegistry;
 
#endif
};
 
 
struct FDataDrivenPlatformInfoRegistry
{
 
    static CORE_API const TMap<FName, FDataDrivenPlatformInfo>& GetAllPlatformInfos();
 
    static CORE_API const TArray<FString>& GetPlatformDirectoryNames(bool bCheckValid);
 
    static const TArray<FString>& GetValidPlatformDirectoryNames() { return GetPlatformDirectoryNames(true); }
 
    static CORE_API const FDataDrivenPlatformInfo& GetPlatformInfo(const FString& PlatformName);
    static CORE_API const FDataDrivenPlatformInfo& GetPlatformInfo(FName PlatformName);
    static CORE_API const FDataDrivenPlatformInfo& GetPlatformInfo(const char* PlatformName);
 
 
    static CORE_API const TArray<FName> GetSortedPlatformNames(EPlatformInfoType PlatformType);
    static CORE_API const TArray<const FDataDrivenPlatformInfo*>& GetSortedPlatformInfos(EPlatformInfoType PlatformType);
 
    UE_DEPRECATED(5.1, "Use GetSoprtedPlatformNames that takes a PlatformType parameter")
    static const TArray<FName> GetSortedPlatformNames()
    {
        return GetSortedPlatformNames(EPlatformInfoType::AllPlatformInfos);
    }
    UE_DEPRECATED(5.1, "Use GetSortedPlatformInfos that takes a PlatformType parameter")
    static const TArray<const FDataDrivenPlatformInfo*>& GetSortedPlatformInfos()
    {
        return GetSortedPlatformInfos(EPlatformInfoType::AllPlatformInfos);
    }
 
    static CORE_API const TArray<FName>& GetConfidentialPlatforms();
 
    static CORE_API int32 GetNumDataDrivenIniFiles();
 
    static CORE_API bool LoadDataDrivenIniFile(int32 Index, FConfigFile& IniFile, FString& PlatformName);
 
 
#if DDPI_HAS_EXTENDED_PLATFORMINFO_DATA
    enum class EPlatformNameType
    {
        // for instance Win64
        UBT,
        // for instance Windows
        Ini,
        // for instance WindowsClient
        TargetPlatform,
    };
    static CORE_API bool HasCompiledSupportForPlatform(FName PlatformName, EPlatformNameType PlatformNameType);
 
    static CORE_API void ClearDeviceStatus(FName PlatformName);
 
    static CORE_API FDataDrivenPlatformInfo& DeviceIdToInfo(FString DeviceId, FString* OutDeviceName = nullptr);
 
    static CORE_API const TArray<struct FPreviewPlatformMenuItem>& GetAllPreviewPlatformMenuItems();
    
    static CORE_API const TArray<struct FPreviewPlatformMenuItem>* GetMenuItemForShaderPlatformName(FName ShaderPlatformName);
 
    static CORE_API bool IsPlatformHiddenFromUI(FName PlatformName);
    static CORE_API void SetPlatformHiddenFromUI(FName PlatformName);
 
private:
    friend class FTurkeySupportModule;
    static CORE_API FDataDrivenPlatformInfo& GetMutablePlatformInfo(FName PlatformName);
    static CORE_API TMap<FName, FDataDrivenPlatformInfo>& GetMutablePlatformInfos();
 
#endif
 
};