Scalability.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*===================================================================================
    Scalability.h: Manager class for handling scalability settings
=====================================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
 
enum EShaderPlatform : uint16;
 
namespace Scalability
{ 
    enum class EQualityLevelBehavior
    {
        EAbsolute,
        ERelativeToMax,
    };
 
    inline const int32 DefaultQualityLevel = 3;
 
    struct FQualityLevels
    {
        float ResolutionQuality;
        int32 ViewDistanceQuality;
        int32 AntiAliasingQuality;
        int32 ShadowQuality;
        int32 GlobalIlluminationQuality;
        int32 ReflectionQuality;
        int32 PostProcessQuality;
        int32 TextureQuality;
        int32 EffectsQuality;
        int32 FoliageQuality;
        int32 ShadingQuality;
        int32 LandscapeQuality;
 
        float CPUBenchmarkResults;
        float GPUBenchmarkResults;
        TArray<float> CPUBenchmarkSteps;
        TArray<float> GPUBenchmarkSteps;
 
        // Allows us to avoid SetDefaults for static init variables, as SetDefaults is not defined to call during static int
        FQualityLevels(bool bSetDefaults = true)
            : CPUBenchmarkResults(-1.0f)
            , GPUBenchmarkResults(-1.0f)
        {
            if (bSetDefaults)
            {
                SetDefaults();
            }
        }
        
        bool operator==(const FQualityLevels& Other ) const
        {
            return ResolutionQuality == Other.ResolutionQuality &&
                ViewDistanceQuality == Other.ViewDistanceQuality &&
                AntiAliasingQuality == Other.AntiAliasingQuality &&
                ShadowQuality == Other.ShadowQuality &&
                GlobalIlluminationQuality == Other.GlobalIlluminationQuality &&
                ReflectionQuality == Other.ReflectionQuality &&
                PostProcessQuality == Other.PostProcessQuality &&
                TextureQuality == Other.TextureQuality &&
                EffectsQuality == Other.EffectsQuality &&
                FoliageQuality == Other.FoliageQuality &&
                ShadingQuality == Other.ShadingQuality &&
                LandscapeQuality == Other.LandscapeQuality;
        }
 
        bool operator!=(const FQualityLevels& Other ) const
        {
            return !(*this == Other);
        }
 
        uint32 GetHash() const
        {
            return FCrc::TypeCrc32<float>(ResolutionQuality) ^
                FCrc::TypeCrc32<int32>(ViewDistanceQuality) ^
                FCrc::TypeCrc32<int32>(AntiAliasingQuality) ^
                FCrc::TypeCrc32<int32>(ShadowQuality) ^
                FCrc::TypeCrc32<int32>(GlobalIlluminationQuality) ^
                FCrc::TypeCrc32<int32>(ReflectionQuality) ^
                FCrc::TypeCrc32<int32>(PostProcessQuality) ^
                FCrc::TypeCrc32<int32>(TextureQuality) ^
                FCrc::TypeCrc32<int32>(EffectsQuality) ^
                FCrc::TypeCrc32<int32>(FoliageQuality) ^
                FCrc::TypeCrc32<int32>(ShadingQuality) ^
                FCrc::TypeCrc32<int32>(LandscapeQuality);
        }
 
        // Sets all other settings based on an overall value
        // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        ENGINE_API void SetFromSingleQualityLevel(int32 Value);
 
        // Sets all other settings based on an overall value, but relative to the maximum.
        // @param Value 0: maximum level, 1: maximumlevel -1, etc
        ENGINE_API void SetFromSingleQualityLevelRelativeToMax(int32 Value);
 
        // Returns the overall value if all settings are set to the same thing
        // @param Value -1:custom, 0:low, 1:medium, 2:high, 3:epic, 4:cinematic
        ENGINE_API int32 GetSingleQualityLevel() const;
 
        // Returns the minimum set quality level from all settings
        // @param Value -1:custom, 0:low, 1:medium, 2:high, 3:epic, 4:cinematic
        ENGINE_API int32 GetMinQualityLevel() const;
 
        // Sets view distance quality
        // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        ENGINE_API void SetViewDistanceQuality(int32 Value);
 
        // Sets anti-aliasing quality
        // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        ENGINE_API void SetAntiAliasingQuality(int32 Value);
 
        // Sets shadow quality
        // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        ENGINE_API void SetShadowQuality(int32 Value);
 
        // Sets shadow quality
        // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        ENGINE_API void SetGlobalIlluminationQuality(int32 Value);
 
        // Sets shadow quality
        // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        ENGINE_API void SetReflectionQuality(int32 Value);
 
        // Sets the post-processing quality
        // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        ENGINE_API void SetPostProcessQuality(int32 Value);
 
        // Sets the texture quality
        // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        ENGINE_API void SetTextureQuality(int32 Value);
 
        // Sets the visual effects quality
        // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        ENGINE_API void SetEffectsQuality(int32 Value);
 
        // Sets the foliage quality
        // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        ENGINE_API void SetFoliageQuality(int32 Value);
 
        // Sets the shading quality
        // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        ENGINE_API void SetShadingQuality(int32 Value);
 
        // Sets the landscape quality
        // @param Value 0:low, 1:medium, 2:high, 3:epic, 4:cinematic (gets clamped if needed)
        ENGINE_API void SetLandscapeQuality(int32 Value);
 
        ENGINE_API void SetBenchmarkFallback();
 
        ENGINE_API void SetDefaults();
    };
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnScalabilitySettingsChanged, const Scalability::FQualityLevels&);
    ENGINE_API extern FOnScalabilitySettingsChanged OnScalabilitySettingsChanged;
 
    struct FResolutionPreset
    {
        FString Name;
        int32 Id = 0;
        float ResolutionQuality = 100.0f;
    };
 
    ENGINE_API TArray<FResolutionPreset> GetResolutionPresets();
 
    ENGINE_API void SetQualityLevels(const FQualityLevels& QualityLevels, bool bForce = false);
 
#if WITH_EDITOR
    ENGINE_API void ApplyCachedQualityLevels();
    ENGINE_API FQualityLevels GetDefaultQualityLevels();
    ENGINE_API void ResetQualityLevelsToDefault();
#endif
 
    ENGINE_API FQualityLevels GetQualityLevels();
 
    ENGINE_API void ToggleTemporaryQualityLevels(bool bEnable, const FQualityLevels& QualityLevelsOverride = FQualityLevels());
 
    ENGINE_API bool IsTemporaryQualityLevelActive();
 
    ENGINE_API int32 GetEffectsQualityDirect(bool bGameThread);
 
    ENGINE_API void InitScalabilitySystem();
 
    ENGINE_API void LoadState(const FString& IniName);
 
    ENGINE_API void LoadState(const FString& IniName, const TCHAR* Section);
    
    ENGINE_API void SaveState(const FString& IniName);
    
    ENGINE_API void SaveState(const FString& IniName, const TCHAR* Section);
 
    ENGINE_API void RecordQualityLevelsAnalytics(bool bAutoApplied);
 
    ENGINE_API FQualityLevels ComputeQualityLevelsFromPerfIndex(float CPUPerfIndex, float GPUPerfIndex);
    
    ENGINE_API FQualityLevels BenchmarkQualityLevels(uint32 WorkScale=10, float CPUMultiplier = 1.0f, float GPUMultiplier = 1.0f);
 
    ENGINE_API void ProcessCommand(const TCHAR* Cmd, FOutputDevice& Ar);
 
    ENGINE_API FQualityLevels GetQualityLevelCounts();
 
    inline constexpr float MinResolutionScale = 0.0f;
 
    inline constexpr float MaxResolutionScale = 100.0f;
 
    UE_DEPRECATED(5.3, "Uses FLegacyScreenPercentageDriver::GetCVarResolutionFraction() instead")
    ENGINE_API float GetResolutionScreenPercentage();
 
    ENGINE_API FText GetScalabilityNameFromQualityLevel(int32 QualityLevel);
 
#if WITH_EDITOR
    void ENGINE_API ChangeScalabilityPreviewPlatform(FName NewPlatformScalabilityName, const EShaderPlatform& ShaderPlatform);
#endif
 
    ENGINE_API FText GetQualityLevelText(int32 Value, int32 NumLevels);
 
    ENGINE_API FString GetScalabilitySectionString(const TCHAR* InGroupName, int32 InQualityLevel, int32 InNumLevels);
}