UnrealEngine/Plugin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

improve the sgusersettings implementation by introducing custom enum item and more accuracy

Browse Source
This commit is contained in:
Mamadou Babaei
2024-08-16 18:01:37 +02:00
parent 32073d34f4
commit 2b7f5bd5e2
6 changed files with 138 additions and 140 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/SenseGlove/Private/SenseGlove/GameFramework/SGGameUserSettings.cpp
+130 -90
View File
@@ -35,6 +35,8 @@
#include "SenseGlove/GameFramework/SGGameUserSettings.h"
#include "Scalability.h"
#include "SGSettings/SGSettings.h"
struct USGGameUserSettings::FImpl
@@ -43,6 +45,10 @@ struct USGGameUserSettings::FImpl
* Static methods
************************/
static float GetRenderScaleLevelFromQualityLevel(
int32 InQualityLevel,
Scalability::EQualityLevelBehavior Behavior = Scalability::EQualityLevelBehavior::EAbsolute);
/************************
* Owner object
************************/
@@ -67,9 +73,42 @@ struct USGGameUserSettings::FImpl
* Methods
************************/
bool DoesCurrentSettingsMatch(ESGEngineScalabilitySettings Scalability, float ResolutionScaleNormalized) const;
bool DoesCurrentSettingsMatch(ESGEngineScalabilitySettings Scalability) const;
};
float USGGameUserSettings::FImpl::GetRenderScaleLevelFromQualityLevel(
const int32 InQualityLevel, const Scalability::EQualityLevelBehavior Behavior)
{
if (!ensureAlwaysMsgf(GConfig, TEXT("Invalid GConfig!")))
{
return 0.0f;
}
TArray<FString> ResolutionValueStrings;
GConfig->GetSingleLineArray(TEXT("ScalabilitySettings"), TEXT("PerfIndexValues_ResolutionQuality"),
ResolutionValueStrings, GScalabilityIni);
if (ResolutionValueStrings.Num() == 0)
{
UE_LOG(LogConsoleResponse, Display,
TEXT("Failed to find resolution value strings in scalability ini. Falling back to the default."));
return 100.0f;
}
// No negative levels!
int32 QualityLevel = FMath::Max(0, InQualityLevel);
if (Behavior == Scalability::EQualityLevelBehavior::ERelativeToMax)
{
QualityLevel = FMath::Max(ResolutionValueStrings.Num() - 1 - QualityLevel, 0);
}
else
{
QualityLevel = FMath::Clamp(QualityLevel, 0, ResolutionValueStrings.Num() - 1);
}
return FCString::Atof(*ResolutionValueStrings[QualityLevel]);
}
USGGameUserSettings::USGGameUserSettings(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer),
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
@@ -85,57 +124,50 @@ USGGameUserSettings* USGGameUserSettings::GetInstance()
ESGEngineScalabilitySettings USGGameUserSettings::GetEngineScalabilitySettings() const
{
const FSGGameUserSettingSettings& Settings{USGSettings::GetInstance()->GetGameUserSettings()};
const bool bDoesCurrentSettingsMatchLow = Pimpl->DoesCurrentSettingsMatch(
ESGEngineScalabilitySettings::Low, Settings.ResolutionScaleNormalizedLow);
const bool bDoesCurrentSettingsMatchLow = Pimpl->DoesCurrentSettingsMatch(ESGEngineScalabilitySettings::Low);
if (bDoesCurrentSettingsMatchLow)
{
return ESGEngineScalabilitySettings::Low;
}
const bool bDoesCurrentSettingsMatchMedium = Pimpl->DoesCurrentSettingsMatch(
ESGEngineScalabilitySettings::Medium, Settings.ResolutionScaleNormalizedMedium);
const bool bDoesCurrentSettingsMatchMedium = Pimpl->DoesCurrentSettingsMatch(ESGEngineScalabilitySettings::Medium);
if (bDoesCurrentSettingsMatchMedium)
{
return ESGEngineScalabilitySettings::Medium;
}
const bool bDoesCurrentSettingsMatchHigh = Pimpl->DoesCurrentSettingsMatch(
ESGEngineScalabilitySettings::High, Settings.ResolutionScaleNormalizedHigh);
const bool bDoesCurrentSettingsMatchHigh = Pimpl->DoesCurrentSettingsMatch(ESGEngineScalabilitySettings::High);
if (bDoesCurrentSettingsMatchHigh)
{
return ESGEngineScalabilitySettings::High;
}
const bool bDoesCurrentSettingsMatchEpic = Pimpl->DoesCurrentSettingsMatch(
ESGEngineScalabilitySettings::Epic, Settings.ResolutionScaleNormalizedEpic);
const bool bDoesCurrentSettingsMatchEpic = Pimpl->DoesCurrentSettingsMatch(ESGEngineScalabilitySettings::Epic);
if (bDoesCurrentSettingsMatchEpic)
{
return ESGEngineScalabilitySettings::Epic;
}
const bool bDoesCurrentSettingsMatchCinematic = Pimpl->DoesCurrentSettingsMatch(
ESGEngineScalabilitySettings::Cinematic, Settings.ResolutionScaleNormalizedCinematic);
ESGEngineScalabilitySettings::Cinematic);
if (bDoesCurrentSettingsMatchCinematic)
{
return ESGEngineScalabilitySettings::Cinematic;
}
static constexpr int32 ScalabilityMinValue = 0;
static constexpr int32 ScalabilityMaxValue = static_cast<int32>(ESGEngineScalabilitySettings::Cinematic);
const int32 OverallScalabilityLevel = GetOverallScalabilityLevel();
if (OverallScalabilityLevel >= ScalabilityMinValue && OverallScalabilityLevel <= ScalabilityMaxValue)
{
return static_cast<ESGEngineScalabilitySettings>(OverallScalabilityLevel);
}
return ESGEngineScalabilitySettings::Epic;
return ESGEngineScalabilitySettings::Custom;
}
void USGGameUserSettings::SetEngineScalabilitySettings(ESGEngineScalabilitySettings Scalability)
{
if (!ensureAlwaysMsgf(Scalability != ESGEngineScalabilitySettings::Custom,
TEXT("Cannot set the engine scalability directly to custom!"
" It should be either: Low, Medium, High, Epic, Cinematic,"
" or Auto (determined by hardware benchmarking)!")))
{
return;
}
const FSGGameUserSettingSettings& Settings{USGSettings::GetInstance()->GetGameUserSettings()};
if (IsDirty())
@@ -146,44 +178,23 @@ void USGGameUserSettings::SetEngineScalabilitySettings(ESGEngineScalabilitySetti
if (Scalability != ESGEngineScalabilitySettings::Auto)
{
float ResolutionScaleNormalized = 0.0f;
switch (Scalability)
{
case ESGEngineScalabilitySettings::Low:
ResolutionScaleNormalized = Settings.ResolutionScaleNormalizedLow;
break;
case ESGEngineScalabilitySettings::Medium:
ResolutionScaleNormalized = Settings.ResolutionScaleNormalizedMedium;
break;
case ESGEngineScalabilitySettings::High:
ResolutionScaleNormalized = Settings.ResolutionScaleNormalizedHigh;
break;
case ESGEngineScalabilitySettings::Epic:
ResolutionScaleNormalized = Settings.ResolutionScaleNormalizedEpic;
break;
case ESGEngineScalabilitySettings::Cinematic:
ResolutionScaleNormalized = Settings.ResolutionScaleNormalizedCinematic;
break;
default:
break;
}
SetResolutionScaleNormalized(ResolutionScaleNormalized);
const int32 ScalabilityValue = static_cast<int32>(Scalability);
SetViewDistanceQuality(ScalabilityValue);
SetAntiAliasingQuality(ScalabilityValue);
SetShadowQuality(ScalabilityValue);
SetGlobalIlluminationQuality(ScalabilityValue);
SetReflectionQuality(ScalabilityValue);
SetPostProcessingQuality(ScalabilityValue);
SetTextureQuality(ScalabilityValue);
SetVisualEffectQuality(ScalabilityValue);
SetFoliageQuality(ScalabilityValue);
SetShadingQuality(ScalabilityValue);
const float ResolutionScaleNormalized = FImpl::GetRenderScaleLevelFromQualityLevel(
ScalabilityValue, Scalability::EQualityLevelBehavior::EAbsolute);
SetResolutionScaleNormalized(ResolutionScaleNormalized);
SetOverallScalabilityLevel(ScalabilityValue);
ScalabilityQuality.SetViewDistanceQuality(ScalabilityValue);
ScalabilityQuality.SetAntiAliasingQuality(ScalabilityValue);
ScalabilityQuality.SetShadowQuality(ScalabilityValue);
ScalabilityQuality.SetGlobalIlluminationQuality(ScalabilityValue);
ScalabilityQuality.SetReflectionQuality(ScalabilityValue);
ScalabilityQuality.SetPostProcessQuality(ScalabilityValue);
ScalabilityQuality.SetTextureQuality(ScalabilityValue);
ScalabilityQuality.SetEffectsQuality(ScalabilityValue);
ScalabilityQuality.SetFoliageQuality(ScalabilityValue);
ScalabilityQuality.SetShadingQuality(ScalabilityValue);
ScalabilityQuality.SetLandscapeQuality(ScalabilityValue);
}
else
{
@@ -205,42 +216,71 @@ USGGameUserSettings::FImpl::FImpl(USGGameUserSettings* InOwner)
USGGameUserSettings::FImpl::~FImpl() = default;
bool USGGameUserSettings::FImpl::DoesCurrentSettingsMatch(
const ESGEngineScalabilitySettings Scalability, const float ResolutionScaleNormalized) const
bool USGGameUserSettings::FImpl::DoesCurrentSettingsMatch(const ESGEngineScalabilitySettings Scalability) const
{
const ESGEngineScalabilitySettings CurrentViewDistanceQuality =
static_cast<ESGEngineScalabilitySettings>(Owner->GetViewDistanceQuality());
const ESGEngineScalabilitySettings CurrentAntiAliasingQuality =
static_cast<ESGEngineScalabilitySettings>(Owner->GetAntiAliasingQuality());
const ESGEngineScalabilitySettings CurrentShadowQuality =
static_cast<ESGEngineScalabilitySettings>(Owner->GetShadowQuality());
const ESGEngineScalabilitySettings CurrentGlobalIlluminationQuality =
static_cast<ESGEngineScalabilitySettings>(Owner->GetGlobalIlluminationQuality());
const ESGEngineScalabilitySettings CurrentReflectionQuality =
static_cast<ESGEngineScalabilitySettings>(Owner->GetReflectionQuality());
const ESGEngineScalabilitySettings CurrentPostProcessingQuality =
static_cast<ESGEngineScalabilitySettings>(Owner->GetPostProcessingQuality());
const ESGEngineScalabilitySettings CurrentTextureQuality =
static_cast<ESGEngineScalabilitySettings>(Owner->GetTextureQuality());
const ESGEngineScalabilitySettings CurrentVisualEffectQuality =
static_cast<ESGEngineScalabilitySettings>(Owner->GetVisualEffectQuality());
const ESGEngineScalabilitySettings CurrentFoliageQuality =
static_cast<ESGEngineScalabilitySettings>(Owner->GetFoliageQuality());
const ESGEngineScalabilitySettings CurrentShadingQuality =
static_cast<ESGEngineScalabilitySettings>(Owner->GetShadingQuality());
const float CurrentResolutionScaleNormalized = Owner->GetResolutionScaleNormalized();
static const float ResolutionScaleNormalizedLow = FImpl::GetRenderScaleLevelFromQualityLevel(
static_cast<int32>(ESGEngineScalabilitySettings::Low));
static const float ResolutionScaleNormalizedMedium = FImpl::GetRenderScaleLevelFromQualityLevel(
static_cast<int32>(ESGEngineScalabilitySettings::Medium));
static const float ResolutionScaleNormalizedHigh = FImpl::GetRenderScaleLevelFromQualityLevel(
static_cast<int32>(ESGEngineScalabilitySettings::High));
static const float ResolutionScaleNormalizedEpic = FImpl::GetRenderScaleLevelFromQualityLevel(
static_cast<int32>(ESGEngineScalabilitySettings::Epic));
static const float ResolutionScaleNormalizedCinematic = FImpl::GetRenderScaleLevelFromQualityLevel(
static_cast<int32>(ESGEngineScalabilitySettings::Cinematic));
float ResolutionScaleNormalized = 0.0f;
switch (Scalability)
{
case ESGEngineScalabilitySettings::Low:
ResolutionScaleNormalized = ResolutionScaleNormalizedLow;
break;
case ESGEngineScalabilitySettings::Medium:
ResolutionScaleNormalized = ResolutionScaleNormalizedMedium;
break;
case ESGEngineScalabilitySettings::High:
ResolutionScaleNormalized = ResolutionScaleNormalizedHigh;
break;
case ESGEngineScalabilitySettings::Epic:
ResolutionScaleNormalized = ResolutionScaleNormalizedEpic;
break;
case ESGEngineScalabilitySettings::Cinematic:
ResolutionScaleNormalized = ResolutionScaleNormalizedCinematic;
break;
default:
ensureAlwaysMsgf(false, TEXT("Login Error: the execution flow should never reach here!"));
break;
}
const int32 ScalabilityValue = static_cast<int32>(Scalability);
const float CurrentResolutionScaleNormalized = FImpl::GetRenderScaleLevelFromQualityLevel(
ScalabilityValue, Scalability::EQualityLevelBehavior::EAbsolute);
const int32 CurrentViewDistanceQuality = Owner->ScalabilityQuality.ViewDistanceQuality;
const int32 CurrentAntiAliasingQuality = Owner->ScalabilityQuality.AntiAliasingQuality;
const int32 CurrentShadowQuality = Owner->ScalabilityQuality.ShadowQuality;
const int32 CurrentGlobalIlluminationQuality = Owner->ScalabilityQuality.GlobalIlluminationQuality;
const int32 CurrentReflectionQuality = Owner->ScalabilityQuality.ReflectionQuality;
const int32 CurrentPostProcessingQuality = Owner->ScalabilityQuality.PostProcessQuality;
const int32 CurrentTextureQuality = Owner->ScalabilityQuality.TextureQuality;
const int32 CurrentEffectQuality = Owner->ScalabilityQuality.EffectsQuality;
const int32 CurrentFoliageQuality = Owner->ScalabilityQuality.FoliageQuality;
const int32 CurrentShadingQuality = Owner->ScalabilityQuality.ShadingQuality;
const int32 CurrentLandscapeQuality = Owner->ScalabilityQuality.LandscapeQuality;
if (FMath::IsNearlyEqual(CurrentResolutionScaleNormalized, ResolutionScaleNormalized)
&& CurrentViewDistanceQuality == Scalability
&& CurrentAntiAliasingQuality == Scalability
&& CurrentShadowQuality == Scalability
&& CurrentGlobalIlluminationQuality == Scalability
&& CurrentReflectionQuality == Scalability
&& CurrentPostProcessingQuality == Scalability
&& CurrentTextureQuality == Scalability
&& CurrentVisualEffectQuality == Scalability
&& CurrentFoliageQuality == Scalability
&& CurrentShadingQuality == Scalability)
&& CurrentViewDistanceQuality == ScalabilityValue
&& CurrentAntiAliasingQuality == ScalabilityValue
&& CurrentShadowQuality == ScalabilityValue
&& CurrentGlobalIlluminationQuality == ScalabilityValue
&& CurrentReflectionQuality == ScalabilityValue
&& CurrentPostProcessingQuality == ScalabilityValue
&& CurrentTextureQuality == ScalabilityValue
&& CurrentEffectQuality == ScalabilityValue
&& CurrentFoliageQuality == ScalabilityValue
&& CurrentShadingQuality == ScalabilityValue
&& CurrentLandscapeQuality == ScalabilityValue)
{
return true;
}
Source/SenseGloveKismet/Private/SGKismet/SGGameUserSettingsKismetLibrary.cpp
-5
View File
@@ -37,11 +37,6 @@
#include "SenseGlove/GameFramework/SGGameUserSettings.h"
USGGameUserSettings* UGameUserSettingsKismetLibrary::GetInstance()
{
return USGGameUserSettings::GetInstance();
}
ESGEngineScalabilitySettings UGameUserSettingsKismetLibrary::GetEngineScalabilitySettings(
const USGGameUserSettings* GameUserSettings)
{
Source/SenseGloveKismet/Public/SGKismet/SGGameUserSettingsKismetLibrary.h
-3
View File
@@ -48,9 +48,6 @@ class SENSEGLOVEKISMET_API UGameUserSettingsKismetLibrary final : public USGBlue
GENERATED_BODY()
public:
UFUNCTION(BlueprintCallable, Category="SenseGlove | Game Framework | Game User Settings")
static USGGameUserSettings* GetInstance();
UFUNCTION(BlueprintPure, Category="SenseGlove | Game Framework | Game User Settings")
static ESGEngineScalabilitySettings GetEngineScalabilitySettings(const USGGameUserSettings* GameUserSettings);
Source/SenseGloveSettings/Private/SGSettings/SGGameUserSettingSettings.cpp
+1 -16
View File
@@ -37,11 +37,6 @@
FSGGameUserSettingSettings::FSGGameUserSettingSettings()
: FSGGameUserSettingSettings(
0.5f,
0.71f,
0.87f,
1.0f,
1.0f,
10.0f,
1.0f,
1.0f)
@@ -49,20 +44,10 @@ FSGGameUserSettingSettings::FSGGameUserSettingSettings()
}
FSGGameUserSettingSettings::FSGGameUserSettingSettings(
const float InResolutionScaleNormalizedLow,
const float InResolutionScaleNormalizedMedium,
const float InResolutionScaleNormalizedHigh,
const float InResolutionScaleNormalizedEpic,
const float InResolutionScaleNormalizedCinematic,
const float InHardwareBenchmarkWorkScale,
const float InHardwareBenchmarkCPUMultiplier,
const float InHardwareBenchmarkGPUMultiplier)
: ResolutionScaleNormalizedLow(InResolutionScaleNormalizedLow),
ResolutionScaleNormalizedMedium(InResolutionScaleNormalizedMedium),
ResolutionScaleNormalizedHigh(InResolutionScaleNormalizedHigh),
ResolutionScaleNormalizedEpic(InResolutionScaleNormalizedEpic),
ResolutionScaleNormalizedCinematic(InResolutionScaleNormalizedCinematic),
HardwareBenchmarkWorkScale(InHardwareBenchmarkWorkScale),
: HardwareBenchmarkWorkScale(InHardwareBenchmarkWorkScale),
HardwareBenchmarkCPUMultiplier(InHardwareBenchmarkCPUMultiplier),
HardwareBenchmarkGPUMultiplier(InHardwareBenchmarkGPUMultiplier)
{
Source/SenseGloveSettings/Public/SGSettings/SGGameUserSettingSettings.h
-20
View File
@@ -45,21 +45,6 @@ struct SENSEGLOVESETTINGS_API FSGGameUserSettingSettings
GENERATED_USTRUCT_BODY()
public:
UPROPERTY(Config, VisibleDefaultsOnly, Category = "Game User Settings")
float ResolutionScaleNormalizedLow;
UPROPERTY(Config, VisibleDefaultsOnly, Category = "Game User Settings")
float ResolutionScaleNormalizedMedium;
UPROPERTY(Config, VisibleDefaultsOnly, Category = "Game User Settings")
float ResolutionScaleNormalizedHigh;
UPROPERTY(Config, VisibleDefaultsOnly, Category = "Game User Settings")
float ResolutionScaleNormalizedEpic;
UPROPERTY(Config, VisibleDefaultsOnly, Category = "Game User Settings")
float ResolutionScaleNormalizedCinematic;
UPROPERTY(Config, EditDefaultsOnly, Category = "Game User Settings")
float HardwareBenchmarkWorkScale;
@@ -73,11 +58,6 @@ public:
FSGGameUserSettingSettings();
FSGGameUserSettingSettings(
float InResolutionScaleNormalizedLow,
float InResolutionScaleNormalizedMedium,
float InResolutionScaleNormalizedHigh,
float InResolutionScaleNormalizedEpic,
float InResolutionScaleNormalizedCinematic,
float InHardwareBenchmarkWorkScale,
float InHardwareBenchmarkCPUMultiplier,
float InHardwareBenchmarkGPUMultiplier);
Source/SenseGloveTypes/Public/SGTypes/SGTypes.h
+7 -6
View File
@@ -44,15 +44,16 @@
UENUM(BlueprintType)
enum class ESGEngineScalabilitySettings : uint8
{
Low UMETA(DisplayName = "Low"),
Medium UMETA(DisplayName = "Medium"),
High UMETA(DisplayName = "High"),
Epic UMETA(DisplayName = "Epic"),
Cinematic UMETA(DisplayName = "Cinematic"),
Low = 0 UMETA(DisplayName = "Low"),
Medium = 1 UMETA(DisplayName = "Medium"),
High = 2 UMETA(DisplayName = "High"),
Epic = 3 UMETA(DisplayName = "Epic"),
Cinematic = 4 UMETA(DisplayName = "Cinematic"),
/**
* This will be used for benchmarking purpose. Then it should set the engine scalability settings to one of the
* other levels.
*/
Auto UMETA(DisplayName = "Auto"),
Auto = 254 UMETA(DisplayName = "Auto"),
Custom = 255 UMETA(DisplayName = "Custom"),
};