bFinalUsesRDO
bFinalUsesRDO
#Overview
name: bFinalUsesRDO
The value of this variable can be defined or overridden in .ini config files. 2 .ini config files referencing this setting variable.
It is referenced in 10 C++ source files.
#Summary
#Usage in the C++ source code
The purpose of bFinalUsesRDO is to control whether Rate-Distortion Optimization (RDO) is used during the final texture encoding process in Unreal Engine 5. RDO is a technique used to optimize the balance between compression rate and visual quality in texture encoding.
This setting variable is primarily used in the texture encoding and rendering systems of Unreal Engine 5. Based on the callsites, it’s utilized in the following subsystems and modules:
- TextureEditor module
- Engine module, specifically in texture-related functionality
The value of this variable is set in the UTextureEncodingProjectSettings class, which is derived from UDeveloperSettings. This suggests that it’s a project-wide setting that can be configured in the project settings.
Several other variables interact with bFinalUsesRDO:
- bFastUsesRDO: A similar setting for fast encoding
- FinalRDOLambda: Controls the RDO lambda value for final encoding
- FinalEffortLevel: Determines the encoding effort level for final encoding
- FinalUniversalTiling: Sets the universal tiling option for final encoding
Developers should be aware of the following when using this variable:
- It affects the final texture encoding process, which can impact both visual quality and performance.
- Changing this setting requires a project restart to take effect.
- It’s part of a larger set of texture encoding settings that should be considered holistically.
Best practices when using this variable include:
- Carefully balance quality and performance needs when enabling or disabling RDO.
- Consider the impact on build times and runtime performance when adjusting this setting.
- Test the visual quality of textures with and without RDO to ensure desired results.
- Use in conjunction with other texture encoding settings for optimal results.
- Document any changes to this setting and communicate them to the development team, as it can affect the entire project.
#Setting Variables
#References In INI files
Location: <Workspace>/Engine/Config/BaseEngine.ini:3454, section: [/Script/Engine.TextureEncodingProjectSettings]
- INI Section:
/Script/Engine.TextureEncodingProjectSettings - Raw value:
false - Is Array:
False
Location: <Workspace>/Projects/Lyra/Config/DefaultEngine.ini:273, section: [/Script/Engine.TextureEncodingProjectSettings]
- INI Section:
/Script/Engine.TextureEncodingProjectSettings - Raw value:
True - Is Array:
False
#References in C++ code
#Callsites
This variable is referenced in the following C++ source code:
#Loc: <Workspace>/Engine/Source/Editor/TextureEditor/Private/Models/TextureEditorViewportClient.cpp:387
Scope (from outer to inner):
file
function void FTextureEditorViewportClient::Draw
Source code excerpt:
{
FResolvedTextureEncodingSettings const& EncodeSettings = FResolvedTextureEncodingSettings::Get();
bool bEncodingDiffers = (EncodeSettings.Project.bFastUsesRDO != EncodeSettings.Project.bFinalUsesRDO ||
EncodeSettings.Project.FastEffortLevel != EncodeSettings.Project.FinalEffortLevel ||
EncodeSettings.Project.FastRDOLambda != EncodeSettings.Project.FinalRDOLambda ||
EncodeSettings.Project.FastUniversalTiling != EncodeSettings.Project.FinalUniversalTiling);
if (PlatformDataPtr[0]->ResultMetadata.bWasEditorCustomEncoding)
{
#Loc: <Workspace>/Engine/Source/Editor/TextureEditor/Private/Models/TextureEditorViewportClient.cpp:421
Scope (from outer to inner):
file
function void FTextureEditorViewportClient::Draw
Source code excerpt:
bool bNeedComma = false;
if (EncodeSettings.Project.bFastUsesRDO != EncodeSettings.Project.bFinalUsesRDO)
{
const FText RDOText = NSLOCTEXT("TextureEditor", "RDODifference", "RDO On/Off");
Canvas->DrawShadowedText(CurrentX, ReportingLineY, RDOText, ReportingFont, FLinearColor::Yellow);
CurrentX += ReportingFont->GetStringSize(*RDOText.ToString());
bNeedComma = true;
}
else if (EncodeSettings.Project.bFinalUsesRDO)
{
// Some stuff only matters if RDO is on
if (EncodeSettings.Project.FastRDOLambda != EncodeSettings.Project.FinalRDOLambda)
{
if (bNeedComma)
{
#Loc: <Workspace>/Engine/Source/Editor/TextureEditor/Private/TextureEditorToolkit.cpp:688
Scope (from outer to inner):
file
function void FTextureEditorToolkit::PopulateQuickInfo
Source code excerpt:
{
const FResolvedTextureEncodingSettings& Settings = FResolvedTextureEncodingSettings::Get();
const bool bDisabledGlobally = ResultMetadata.EncodeSpeed == (uint8)ETextureEncodeSpeed::Fast ? !Settings.Project.bFastUsesRDO : !Settings.Project.bFinalUsesRDO;
OodleRDOText->SetText(NSLOCTEXT("TextureEditor", "QuickInfo_Oodle_RDODisable", "Disabled"));
if (ResultMetadata.bWasEditorCustomEncoding)
{
OodleRDOSourceText->SetText(NSLOCTEXT("TextureEditor", "QuickInfo_Oodle_RDOSource_Custom", "Custom"));
}
#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureDerivedData.cpp:593
Scope (from outer to inner):
file
function static void GetEncodeSpeedOptions
Source code excerpt:
if (InEncodeSpeed == ETextureEncodeSpeed::Final)
{
OutOptions->bUsesRDO = EncodeSettings.Project.bFinalUsesRDO;
OutOptions->Effort = EncodeSettings.Project.FinalEffortLevel;
OutOptions->Tiling = EncodeSettings.Project.FinalUniversalTiling;
OutOptions->RDOLambda = EncodeSettings.Project.FinalRDOLambda;
}
else
{
#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureEncodingSettings.cpp:12
Scope (from outer to inner):
file
function UTextureEncodingProjectSettings::UTextureEncodingProjectSettings
Source code excerpt:
: Super(ObjectInitializer),
bSharedLinearTextureEncoding(false),
bFinalUsesRDO(false),
FinalRDOLambda(30), /* OodleTex_RDOLagrangeLambda_Default */
FinalEffortLevel(ETextureEncodeEffort::Normal),
FinalUniversalTiling(ETextureUniversalTiling::Disabled),
bFastUsesRDO(false),
FastRDOLambda(30), /* OodleTex_RDOLagrangeLambda_Default */
FastEffortLevel(ETextureEncodeEffort::Normal),
#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureEncodingSettings.cpp:76
Scope (from outer to inner):
file
function static void ConstructResolvedSettings
Source code excerpt:
}
}
OutResolvedSettings->Project.bFinalUsesRDO = ProjectSettings->bFinalUsesRDO;
OutResolvedSettings->Project.bFastUsesRDO = ProjectSettings->bFastUsesRDO;
OutResolvedSettings->Project.FinalRDOLambda = ProjectSettings->FinalRDOLambda;
OutResolvedSettings->Project.FastRDOLambda = ProjectSettings->FastRDOLambda;
OutResolvedSettings->Project.FinalEffortLevel = ProjectSettings->FinalEffortLevel;
OutResolvedSettings->Project.FinalUniversalTiling = ProjectSettings->FinalUniversalTiling;
OutResolvedSettings->Project.FastEffortLevel = ProjectSettings->FastEffortLevel;
#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureEncodingSettings.cpp:153
Scope (from outer to inner):
file
function static void ConstructResolvedSettings
Source code excerpt:
FString FinalRDOString;
if (OutResolvedSettings->Project.bFinalUsesRDO)
{
FinalRDOString = FString(TEXT("On"));
if (OutResolvedSettings->Project.FinalUniversalTiling != ETextureUniversalTiling::Disabled)
{
FinalRDOString += TEXT(" UT=");
FinalRDOString += UniversalTilingEnum->GetNameStringByValue((int64)OutResolvedSettings->Project.FinalUniversalTiling);
#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureEncodingSettings.cpp:169
Scope (from outer to inner):
file
function static void ConstructResolvedSettings
Source code excerpt:
UE_LOG(LogTextureEncodingSettings, Display, TEXT("Oodle Texture Encode Speed settings: Fast: RDO %s Lambda=%d, Effort=%s Final: RDO %s Lambda=%d, Effort=%s"), \
*FastRDOString, OutResolvedSettings->Project.bFastUsesRDO ? OutResolvedSettings->Project.FastRDOLambda : 0, *(EncodeEffortEnum->GetNameStringByValue((int64)OutResolvedSettings->Project.FastEffortLevel)), \
*FinalRDOString, OutResolvedSettings->Project.bFinalUsesRDO ? OutResolvedSettings->Project.FinalRDOLambda : 0, *(EncodeEffortEnum->GetNameStringByValue((int64)OutResolvedSettings->Project.FinalEffortLevel)));
}
UE_LOG(LogTextureEncodingSettings, Display, TEXT("Shared linear texture encoding: %s"), OutResolvedSettings->Project.bSharedLinearTextureEncoding ? TEXT("Enabled") : TEXT("Disabled"));
}
static void TryToResolveSettings(ReadyMask InReadyMask, UDeveloperSettings* InSettings, FResolvedTextureEncodingSettings** OutResolvedSettings)
#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureEncodingSettingsPrivate.h:55
Scope (from outer to inner):
file
class class UTextureEncodingProjectSettings : public UDeveloperSettings
Source code excerpt:
// Note that any distortion introduced is on top of, and likely less than, any introduced by the format itself.
UPROPERTY(config, EditAnywhere, Category = EncodeSpeedSettings, meta = (ConfigRestartRequired = true))
uint32 bFinalUsesRDO : 1;
// Ignored if UsesRDO is false. This value is used if a given texture is using "Default" LossyCompressionAmount.
// Otherwise, the value of LossyCompressionAmount is translated in to a fixed lambda (see UsesRDO tooltip).
//
// Low values (1) represent highest quality (least distortion) results.
UPROPERTY(config, EditAnywhere, Category = EncodeSpeedSettings, meta = (DisplayName = "Final RDO Lambda", UIMin = 1, UIMax = 100, ClampMin = 1, ClampMax = 100, EditCondition = bFinalUsesRDO, ConfigRestartRequired = true))
#Loc: <Workspace>/Engine/Source/Runtime/Engine/Public/TextureEncodingSettings.h:59
Scope: file
Source code excerpt:
{
uint32 bSharedLinearTextureEncoding : 1;
uint32 bFinalUsesRDO : 1;
uint32 bFastUsesRDO : 1;
int8 FinalRDOLambda;
int8 FastRDOLambda;
ETextureEncodeEffort FinalEffortLevel;
ETextureUniversalTiling FinalUniversalTiling;
ETextureEncodeEffort FastEffortLevel;