GenericPlatformApplicationMisc.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "GenericPlatform/GenericApplication.h"
#include "GenericPlatform/GenericApplicationMessageHandler.h"
#include "HAL/IConsoleManager.h"
#include "Math/Color.h"
#include "Math/Vector2D.h"
#include "Templates/IsFloatingPoint.h"
#include "Templates/UnrealTypeTraits.h"
#include "Templates/Function.h"
#include "Misc/EnumClassFlags.h"
 
class FAutoConsoleVariableRef;
class FFeedbackContext;
class FOutputDeviceConsole;
class FOutputDeviceError;
class IPlatformInputDeviceMapper;
 
enum class EScreenPhysicalAccuracy
{
    Unknown,
    Approximation,
    Truth
};
 
struct FShowInputDeviceSelectorParams
{
    FInputDeviceId InputDeviceId;
    FPlatformUserId PlatformUserId;
};
typedef TFunction<void(const FShowInputDeviceSelectorParams&)> FShowInputDeviceSelectorComplete;
 
struct FPlatformUserSelectionCompleteParams
{
    FPlatformUserId SelectedUserId;
    bool bSuccess;
};
typedef TFunction<void(const FPlatformUserSelectionCompleteParams& Params)> FPlatformUserSelectionComplete;
 
/*
 * Options for ShowPlatformUserSelector. Not all platforms will support all flags
 */
enum class EPlatformUserSelectorFlags : uint8
{
    None                         = 0,
    RequiresOnlineEnabledProfile = (1 << 1), // whether to only show profiles that have an online account
    ShowSkipButton               = (1 << 2), // display a 'skip' button UI to be closed & return the initiating user
    AllowGuests                  = (1 << 3), // temporary guest accounts, throwaways etc.
    ShowNewUsersOnly             = (1 << 4), // do not show profiles that are already in-use by the title
 
    Default                      = ShowSkipButton, // most commonly used options
};
ENUM_CLASS_FLAGS(EPlatformUserSelectorFlags);
 
 
struct FGenericPlatformApplicationMisc
{
    static APPLICATIONCORE_API void PreInit();
 
    static APPLICATIONCORE_API void Init();
 
    static APPLICATIONCORE_API void PostInit();
 
    static APPLICATIONCORE_API void TearDown();
 
    static void LoadPreInitModules()
    {
    }
 
    static void LoadStartupModules()
    {
    }
 
    static APPLICATIONCORE_API FOutputDeviceConsole* CreateConsoleOutputDevice();
 
    static APPLICATIONCORE_API FOutputDeviceError* GetErrorOutputDevice();
 
    static APPLICATIONCORE_API FFeedbackContext* GetFeedbackContext();
 
    static APPLICATIONCORE_API IPlatformInputDeviceMapper* CreatePlatformInputDeviceManager();
 
    static APPLICATIONCORE_API class GenericApplication* CreateApplication();
 
    static APPLICATIONCORE_API void RequestMinimize();
 
    static APPLICATIONCORE_API bool IsThisApplicationForeground();  
 
    static APPLICATIONCORE_API bool RequiresVirtualKeyboard();
 
    inline static void PumpMessages(bool bFromMainLoop)
    {
    }
 
    static void PreventScreenSaver()
    {
    }
 
    enum EScreenSaverAction
    {
        Disable,
        Enable
    };
 
    static bool IsScreensaverEnabled()
    {
        return false;
    }
 
    static bool ControlScreensaver(EScreenSaverAction Action)
    {
        return false;
    }
 
    static APPLICATIONCORE_API struct FLinearColor GetScreenPixelColor(const FVector2D& InScreenPos, float InGamma = 1.0f);
 
    static bool GetWindowTitleMatchingText(const TCHAR* TitleStartsWith, FString& OutTitle)
    {
        return false;
    }
 
    static void SetHighDPIMode()
    {
 
    }
 
    static float GetDPIScaleFactorAtPoint(float X, float Y)
    {
        return 1.0f;
    }
 
 
    static APPLICATIONCORE_API bool IsHighDPIAwarenessEnabled();
 
    /*
     * UE expects mouse coordinates in screen space. Some platforms provides in client space. 
     * Return true to anchor the window at the top/left corner to make sure client space coordinates and screen space coordinates match up. 
     */
    static bool AnchorWindowWindowPositionTopLeft()
    {
        return false;
    }
 
    /*
    * Set whether gamepads are allowed at the platform level.
    */
    static void SetGamepadsAllowed(bool bAllowed)
    {}
 
    /*
    * Set whether gamepads are allowed at the platform level.
    */
    static void SetGamepadsBlockDeviceFeedback(bool bAllowed)
    {}
 
    /*
     * Resets the gamepad to player controller id assignments
     */
    static void ResetGamepadAssignments()
    {}
 
    /*
    * Resets the gamepad assignment to player controller id
    */
    static void ResetGamepadAssignmentToController(int32 ControllerId)
    {}
 
    /*
     * Returns true if controller id assigned to a gamepad
     */
    static bool IsControllerAssignedToGamepad(int32 ControllerId)
    {
        return (ControllerId == 0);
    }
 
    /*
    * Returns name of gamepad if controller id assigned to a gamepad
    */
    static FString GetGamepadControllerName(int32 ControllerId)
    {
        if (IsControllerAssignedToGamepad(ControllerId))
        {
            return FString(TEXT("Generic"));
        }
        return FString(TEXT("None"));
    }
 
    /*
    * Returns a texture of the glyph representing the specified button on the specified controller, or nullptr if not supported.
    */
    static class UTexture2D* GetGamepadButtonGlyph(const FGamepadKeyNames::Type& ButtonKey, uint32 ControllerIndex)
    {
        return nullptr;
    }
    
    /*
    * Whether to enable controller motion data polling (by default motion data is enabled)
    * Some platforms may want to disable it to reduce battery drain
    */
    static void EnableMotionData(bool bEnable)
    {}
 
    /*
    * Whether controller motion data polling is enabled (by default motion data is enabled)
    */
    static bool IsMotionDataEnabled()
    {
        return true;
    }
                
    static APPLICATIONCORE_API void ClipboardCopy(const TCHAR* Str);
 
    static APPLICATIONCORE_API void ClipboardPaste(class FString& Dest);
 
    static APPLICATIONCORE_API EScreenPhysicalAccuracy GetPhysicalScreenDensity(int32& OutScreenDensity);
 
    static APPLICATIONCORE_API EScreenPhysicalAccuracy GetPhysicalScreenDimensions(FVector2f& OutScreenDimensions);
 
    static APPLICATIONCORE_API EScreenPhysicalAccuracy GetPhysicalScreenSize(float& OutScreenSize);
 
    static APPLICATIONCORE_API EScreenPhysicalAccuracy ComputePhysicalScreenDensity(int32& OutScreenDensity);
 
    static APPLICATIONCORE_API EScreenPhysicalAccuracy ComputePhysicalScreenDimensions(FVector2f& OutScreenDimensions, float& OutScreenSize);
 
    static void ComputePhysicalScreenData();
 
    template<typename T, typename T2 UE_REQUIRES(std::is_floating_point_v<T> && std::is_floating_point_v<T2>)>
    static EScreenPhysicalAccuracy ConvertInchesToPixels(T Inches, T2& OutPixels)
    {
        int32 ScreenDensity = 0;
        const EScreenPhysicalAccuracy Accuracy = GetPhysicalScreenDensity(ScreenDensity);
 
        if (ScreenDensity != 0)
        {
            OutPixels = static_cast<T2>(Inches * ScreenDensity);
        }
        else
        {
            OutPixels = 0;
        }
 
        return Accuracy;
    }
 
    template<typename T, typename T2 UE_REQUIRES(std::is_floating_point_v<T> && std::is_floating_point_v<T2>)>
    static EScreenPhysicalAccuracy ConvertPixelsToInches(T Pixels, T2& OutInches)
    {
        int32 ScreenDensity = 0;
        const EScreenPhysicalAccuracy Accuracy = GetPhysicalScreenDensity(ScreenDensity);
 
        if (ScreenDensity != 0)
        {
            OutInches = static_cast<T2>(Pixels / ScreenDensity);
        }
        else
        {
            OutInches = 0;
        }
 
        return Accuracy;        
    }
    
    static bool ShowInputDeviceSelector( FPlatformUserId InitiatingUserId, FShowInputDeviceSelectorComplete OnShowInputDeviceSelectorComplete )
    {
        // no default implementation
        return false;
    }
 
    static bool ShowPlatformUserSelector(FInputDeviceId InitiatingInputDeviceId, EPlatformUserSelectorFlags Flags, FPlatformUserSelectionComplete OnUserSelectionComplete)
    {
        // no default implementation
        return false;
    }
 
 
protected:
    static APPLICATIONCORE_API bool CachedPhysicalScreenData;
    static APPLICATIONCORE_API EScreenPhysicalAccuracy CachedPhysicalScreenAccuracy;
    static APPLICATIONCORE_API int32 CachedPhysicalScreenDensity;
    static APPLICATIONCORE_API FAutoConsoleVariableRef CVarEnableHighDPIAwareness;
    static APPLICATIONCORE_API FAutoConsoleVariableRef CVarAllowVirtualKeyboard;
 
    static APPLICATIONCORE_API EScreenPhysicalAccuracy CachedPhysicalScreenDimensionsAccuracy;
    static APPLICATIONCORE_API FVector2f CachedPhysicalScreenDimensions;
    static APPLICATIONCORE_API float CachedPhysicalScreenSize;
 
};