GameUserSettings.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "UObject/ScriptMacros.h"
#include "GenericPlatform/GenericWindow.h"
#include "Scalability.h"
#include "GameUserSettings.generated.h"
 
#if !CPP      //noexport class
 
UENUM(BlueprintType)
namespace EWindowMode
{
    enum Type : int
    {
        Fullscreen,
        WindowedFullscreen,
        Windowed,
    };
}
 
#endif
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnGameUserSettingsUINeedsUpdate);
 
UCLASS(config=GameUserSettings, configdonotcheckdefaults, MinimalAPI)
class UGameUserSettings : public UObject
{
    GENERATED_UCLASS_BODY()
 
public:
 
    static ENGINE_API FString GetConfigDir();
 
    UFUNCTION(BlueprintCallable, Category=Settings, meta=(bCheckForCommandLineOverrides=true))
    ENGINE_API virtual void ApplySettings(bool bCheckForCommandLineOverrides);
    
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API virtual void ApplyNonResolutionSettings();
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API void ApplyResolutionSettings(bool bCheckForCommandLineOverrides);
 
    UFUNCTION(BlueprintPure, Category=Settings)
    ENGINE_API FIntPoint GetScreenResolution() const;
 
    UFUNCTION(BlueprintPure, Category=Settings)
    ENGINE_API FIntPoint GetLastConfirmedScreenResolution() const;
 
    UFUNCTION(BlueprintPure, Category = Settings)
    ENGINE_API FIntPoint GetDesktopResolution() const;
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API void SetScreenResolution(FIntPoint Resolution);
 
    UFUNCTION(BlueprintPure, Category=Settings)
    ENGINE_API EWindowMode::Type GetFullscreenMode() const;
 
    UFUNCTION(BlueprintPure, Category=Settings)
    ENGINE_API EWindowMode::Type GetLastConfirmedFullscreenMode() const;
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API void SetFullscreenMode(EWindowMode::Type InFullscreenMode);
 
    UFUNCTION(BlueprintPure, Category = Settings)
    ENGINE_API EWindowMode::Type GetPreferredFullscreenMode() const;
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API void SetVSyncEnabled(bool bEnable);
 
    UFUNCTION(BlueprintPure, Category=Settings)
    ENGINE_API bool IsVSyncEnabled() const;
 
    UFUNCTION(BlueprintCallable, Category = Settings)
    ENGINE_API void SetDynamicResolutionEnabled(bool bEnable);
 
    UFUNCTION(BlueprintPure, Category = Settings)
    ENGINE_API virtual bool IsDynamicResolutionEnabled() const;
 
    UFUNCTION(BlueprintPure, Category=Settings)
    ENGINE_API bool IsScreenResolutionDirty() const;
 
    UFUNCTION(BlueprintPure, Category=Settings)
    ENGINE_API bool IsFullscreenModeDirty() const;
 
    UFUNCTION(BlueprintPure, Category=Settings)
    ENGINE_API bool IsVSyncDirty() const;
 
    UFUNCTION(BlueprintPure, Category = Settings)
    ENGINE_API bool IsDynamicResolutionDirty() const;
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API virtual void ConfirmVideoMode();
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API void RevertVideoMode();
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API void SetBenchmarkFallbackValues();
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API void SetAudioQualityLevel(int32 QualityLevel);
 
    UFUNCTION(BlueprintPure, Category=Settings)
    int32 GetAudioQualityLevel() const { return AudioQualityLevel; }
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API void SetFrameRateLimit(float NewLimit);
 
    UFUNCTION(BlueprintPure, Category=Settings)
    ENGINE_API float GetFrameRateLimit() const;
 
    // Changes all scalability settings at once based on a single overall quality level
    // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API virtual void SetOverallScalabilityLevel(int32 Value);
 
    // Returns the overall scalability level (can return -1 if the settings are custom)
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API virtual int32 GetOverallScalabilityLevel() const;
 
    // Returns the current resolution scale and the range
    UFUNCTION(BlueprintCallable, Category=Settings, meta=(DisplayName="GetResolutionScaleInformation"))
    ENGINE_API void GetResolutionScaleInformationEx(float& CurrentScaleNormalized, float& CurrentScaleValue, float& MinScaleValue, float& MaxScaleValue) const;
 
    // Gets the current resolution scale as a normalized 0..1 value between MinScaleValue and MaxScaleValue
    UFUNCTION(BlueprintCallable, Category = Settings)
    ENGINE_API float GetResolutionScaleNormalized() const;
 
    // Sets the current resolution scale
    UFUNCTION(BlueprintCallable, Category=Settings, meta=(DisplayName="SetResolutionScaleValue"))
    ENGINE_API void SetResolutionScaleValueEx(float NewScaleValue);
 
    // Sets the current resolution scale as a normalized 0..1 value between MinScaleValue and MaxScaleValue
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API void SetResolutionScaleNormalized(float NewScaleNormalized);
 
    // Sets the view distance quality (0..4, higher is better)
    // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API void SetViewDistanceQuality(int32 Value);
 
    // Returns the view distance quality (0..4, higher is better)
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API int32 GetViewDistanceQuality() const;
 
    // Sets the shadow quality (0..4, higher is better)
    // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API void SetShadowQuality(int32 Value);
 
    // Returns the shadow quality (0..4, higher is better)
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API int32 GetShadowQuality() const;
 
    // Sets the global illumination quality (0..4, higher is better)
    // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API void SetGlobalIlluminationQuality(int32 Value);
 
    // Returns the global illumination quality (0..4, higher is better)
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API int32 GetGlobalIlluminationQuality() const;
 
    // Sets the reflection quality (0..4, higher is better)
    // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API void SetReflectionQuality(int32 Value);
 
    // Returns the reflection quality (0..4, higher is better)
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API int32 GetReflectionQuality() const;
 
    // Sets the anti-aliasing quality (0..4, higher is better)
    // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API void SetAntiAliasingQuality(int32 Value);
 
    // Returns the anti-aliasing quality (0..4, higher is better)
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API int32 GetAntiAliasingQuality() const;
 
    // Sets the texture quality (0..4, higher is better)
    // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic  (gets clamped if needed)
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API void SetTextureQuality(int32 Value);
 
    // Returns the texture quality (0..4, higher is better)
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API int32 GetTextureQuality() const;
 
    // Sets the visual effects quality (0..4, higher is better)
    // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API void SetVisualEffectQuality(int32 Value);
 
    // Returns the visual effects quality (0..4, higher is better)
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API int32 GetVisualEffectQuality() const;
 
    // Sets the post-processing quality (0..4, higher is better)
    // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API void SetPostProcessingQuality(int32 Value);
 
    // Returns the post-processing quality (0..4, higher is better)
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API int32 GetPostProcessingQuality() const;
    
    // Sets the foliage quality (0..4, higher is better)
    // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API void SetFoliageQuality(int32 Value);
 
    // Returns the foliage quality (0..4, higher is better)
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API int32 GetFoliageQuality() const;
 
    // Sets the shading quality (0..4, higher is better)
    // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
    UFUNCTION(BlueprintCallable, Category = Settings)
    ENGINE_API void SetShadingQuality(int32 Value);
 
    // Returns the shading quality (0..4, higher is better)
    UFUNCTION(BlueprintCallable, Category = Settings)
    ENGINE_API int32 GetShadingQuality() const;
 
    UFUNCTION(BlueprintPure, Category=Settings)
    ENGINE_API virtual bool IsDirty() const;
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API virtual void ValidateSettings();
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API virtual void LoadSettings(bool bForceReload = false);
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API virtual void SaveSettings();
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API virtual void ResetToCurrentSettings();
 
    ENGINE_API virtual void SetWindowPosition(int32 WindowPosX, int32 WindowPosY);
 
    ENGINE_API virtual void SetWindowPosition(int32 WindowPosX, int32 WindowPosY, int32 SaveSlotIndex);
 
    ENGINE_API virtual FIntPoint GetWindowPosition();
 
    ENGINE_API virtual FIntPoint GetWindowPosition(int32 SaveSlotIndex);
    
    ENGINE_API void ReloadWindowPositions();
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API virtual void SetToDefaults();
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API virtual float GetDefaultResolutionScale();
 
    UFUNCTION(BlueprintCallable, Category = Settings)
    ENGINE_API virtual float GetRecommendedResolutionScale();
 
    static ENGINE_API void PreloadResolutionSettings(bool bAllowCmdLineOverrides = true);
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    static ENGINE_API FIntPoint GetDefaultResolution();
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    static ENGINE_API FIntPoint GetDefaultWindowPosition();
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    static ENGINE_API EWindowMode::Type GetDefaultWindowMode();
 
    UE_DEPRECATED(4.25, "Please use GetFramePace to get the paced frame rate")
    UFUNCTION(BlueprintPure, Category = Settings)
    static ENGINE_API int32 GetSyncInterval();
 
    UFUNCTION(BlueprintPure, Category = Settings)
    static ENGINE_API int32 GetFramePace();
 
    static ENGINE_API void LoadConfigIni(bool bForceReload = false);
 
    static ENGINE_API void RequestResolutionChange(int32 InResolutionX, int32 InResolutionY, EWindowMode::Type InWindowMode, bool bInDoOverrides = true);
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    static ENGINE_API UGameUserSettings* GetGameUserSettings();
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API virtual void RunHardwareBenchmark(int32 WorkScale = 10, float CPUMultiplier = 1.0f, float GPUMultiplier = 1.0f);
 
    UFUNCTION(BlueprintCallable, Category=Settings)
    ENGINE_API virtual void ApplyHardwareBenchmarkResults();
 
    UFUNCTION(BlueprintCallable, Category=Settings, meta = (DisplayName = "Supports HDR Display Output"))
    ENGINE_API virtual bool SupportsHDRDisplayOutput() const;
 
    UFUNCTION(BlueprintCallable, Category=Settings, meta=(DisplayName = "Enable HDR Display Output"))
    ENGINE_API void EnableHDRDisplayOutput(bool bEnable, int32 DisplayNits = 1000);
 
    UFUNCTION(BlueprintCallable, Category = Settings, meta = (DisplayName = "Get Current HDR Display Nits"))
    ENGINE_API int32 GetCurrentHDRDisplayNits() const;
 
    UFUNCTION(BlueprintCallable, Category = Settings, meta = (DisplayName = "Is HDR Enabled"))
    ENGINE_API bool IsHDREnabled() const;
 
    UPROPERTY(config)
    bool bUseVSync;
 
    UPROPERTY(config)
    bool bUseDynamicResolution;
 
    // cached for the UI, current state if stored in console variables
    Scalability::FQualityLevels ScalabilityQuality;
 
protected:
    UPROPERTY(config)
    uint32 ResolutionSizeX;
 
    UPROPERTY(config)
    uint32 ResolutionSizeY;
 
    UPROPERTY(config)
    uint32 LastUserConfirmedResolutionSizeX;
 
    UPROPERTY(config)
    uint32 LastUserConfirmedResolutionSizeY;
 
    UE_DEPRECATED(5.6, "Use the WindowPositions array instead.")
    UPROPERTY(config)
    int32 WindowPosX_DEPRECATED;
 
    UE_DEPRECATED(5.6, "Use the WindowPositions array instead.")
    UPROPERTY(config)
    int32 WindowPosY_DEPRECATED;
 
    UPROPERTY(config)
    TArray<FIntPoint> WindowPositions;
 
    UPROPERTY(config)
    int32 FullscreenMode;
 
    UPROPERTY(config)
    int32 LastConfirmedFullscreenMode;
 
    UPROPERTY(config)
    int32 PreferredFullscreenMode;
 
    UPROPERTY(config)
    uint32 Version;
 
    UPROPERTY(config)
    int32 AudioQualityLevel;
 
    UPROPERTY(config)
    int32 LastConfirmedAudioQualityLevel;
 
    UPROPERTY(config)
    float FrameRateLimit;
 
    UE_DEPRECATED(5.3, "MinResolutionScale is now always Scalability::MinResolutionScale=0 that fallbacks to default project wide behavior defined by r.ScreenPercentage.Default")
    float MinResolutionScale;
 
    UPROPERTY(config)
    int32 DesiredScreenWidth;
 
    UPROPERTY(globalconfig)
    bool bUseDesiredScreenHeight;
 
    UPROPERTY(config)
    int32 DesiredScreenHeight;
 
    UPROPERTY(config)
    int32 LastUserConfirmedDesiredScreenWidth;
 
    UPROPERTY(config)
    int32 LastUserConfirmedDesiredScreenHeight;
 
    UPROPERTY(config)
    float LastRecommendedScreenWidth;
 
    UPROPERTY(config)
    float LastRecommendedScreenHeight;
 
    UPROPERTY(config)
    float LastCPUBenchmarkResult;
 
    UPROPERTY(config)
    float LastGPUBenchmarkResult;
 
    UPROPERTY(config)
    TArray<float> LastCPUBenchmarkSteps;
 
    UPROPERTY(config)
    TArray<float> LastGPUBenchmarkSteps;
 
    UPROPERTY(config)
    float LastGPUBenchmarkMultiplier;
 
    UPROPERTY(config)
    bool bUseHDRDisplayOutput;
 
    UPROPERTY(config)
    int32 HDRDisplayOutputNits;
 
    bool bEnableScalabilitySettings = true;
 
public:
    float GetLastCPUBenchmarkResult() const
    {
        return LastCPUBenchmarkResult;
    }
 
    float GetLastGPUBenchmarkResult() const
    {
        return LastGPUBenchmarkResult;
    }
 
    TArray<float> GetLastCPUBenchmarkSteps() const
    {
        return LastCPUBenchmarkSteps;
    }
 
    TArray<float> GetLastGPUBenchmarkSteps() const
    {
        return LastGPUBenchmarkSteps;
    }
 
    void RequestUIUpdate()
    {
        OnGameUserSettingsUINeedsUpdate.Broadcast();
    }
 
    int32 GetMaxNumWindowPositionSaveSlots() const;
 
    DECLARE_DELEGATE_RetVal_OneParam(bool, FUpdateGameUserSettingsFileFromCloud, const FString&);
    FUpdateGameUserSettingsFileFromCloud OnUpdateGameUserSettingsFileFromCloud;
 
    DECLARE_DELEGATE_RetVal_OneParam(bool, FUpdateCloudDataFromGameUserSettings, const FString&);
    FUpdateCloudDataFromGameUserSettings OnUpdateCloudDataFromGameUserSettings;
 
protected:
    ENGINE_API virtual bool IsVersionValid();
 
    ENGINE_API virtual void UpdateVersion();
 
    ENGINE_API float FindResolutionQualityForScreenSize(float Width, float Height);
 
    static ENGINE_API void SetFrameRateLimitCVar(float InLimit);
 
    static ENGINE_API void SetSyncTypeCVar(int32 InInterval);
 
    ENGINE_API virtual float GetEffectiveFrameRateLimit();
 
    ENGINE_API void UpdateResolutionQuality();
 
    ENGINE_API void EnableHDRDisplayOutputInternal(bool bEnable, int32 DisplayNits, bool bFromUserSettings);
 
private:
 
    UPROPERTY(BlueprintAssignable, meta = (AllowPrivateAccess = "true"))
    FOnGameUserSettingsUINeedsUpdate OnGameUserSettingsUINeedsUpdate;
 
    ENGINE_API void SetPreferredFullscreenMode(int32 Mode);
};