FinalRDOLambda
FinalRDOLambda
#Overview
name: FinalRDOLambda
The value of this variable can be defined or overridden in .ini config files. 1 .ini config file referencing this setting variable.
It is referenced in 8 C++ source files.
#Summary
#Usage in the C++ source code
The purpose of FinalRDOLambda is to control the quality-performance trade-off in the Rate-Distortion Optimization (RDO) process for texture encoding in Unreal Engine 5. It is specifically used for the “final” or high-quality encoding settings.
This setting variable is primarily used in the texture encoding system of Unreal Engine 5. It is referenced in the TextureEditor module and the Engine module, particularly in texture encoding and rendering-related functions.
The value of this variable is set in the UTextureEncodingProjectSettings class, which is a subclass of UDeveloperSettings. It is initialized with a default value of 30 in the constructor of UTextureEncodingProjectSettings.
FinalRDOLambda interacts with several other variables, including:
- bFinalUsesRDO: Determines whether RDO is used for final encoding
- FinalEffortLevel: Specifies the effort level for final encoding
- FinalUniversalTiling: Specifies the tiling method for final encoding
- FastRDOLambda: The equivalent setting for fast encoding
Developers must be aware that:
- Lower values of FinalRDOLambda (minimum 1) result in higher quality but potentially slower encoding.
- This setting only applies when bFinalUsesRDO is true.
- Changes to this setting require a restart of the engine to take effect.
Best practices when using this variable include:
- Balance quality and performance based on project needs. Start with the default value and adjust as necessary.
- Consider the target platform and performance requirements when setting this value.
- Use in conjunction with other encoding settings (like FinalEffortLevel) for optimal results.
- Test thoroughly after changes, as it can significantly impact texture quality and performance.
#Setting Variables
#References In INI files
Location: <Workspace>/Engine/Config/BaseEngine.ini:3455, section: [/Script/Engine.TextureEncodingProjectSettings]
- INI Section:
/Script/Engine.TextureEncodingProjectSettings - Raw value:
30 - 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:389
Scope (from outer to inner):
file
function void FTextureEditorViewportClient::Draw
Source code excerpt:
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)
{
const FText LeadInText = NSLOCTEXT("TextureEditor", "ViewingCustom", "Viewing custom encoding");
Canvas->DrawShadowedText(ReportingLineX, ReportingLineY, LeadInText, ReportingFont, FLinearColor::Yellow);
#Loc: <Workspace>/Engine/Source/Editor/TextureEditor/Private/Models/TextureEditorViewportClient.cpp:431
Scope (from outer to inner):
file
function void FTextureEditorViewportClient::Draw
Source code excerpt:
{
// Some stuff only matters if RDO is on
if (EncodeSettings.Project.FastRDOLambda != EncodeSettings.Project.FinalRDOLambda)
{
if (bNeedComma)
{
DrawComma();
}
const FText RDOText = NSLOCTEXT("TextureEditor", "RDOLambdaDifference", "RDO Lambda");
#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureDerivedData.cpp:596
Scope (from outer to inner):
file
function static void GetEncodeSpeedOptions
Source code excerpt:
OutOptions->Effort = EncodeSettings.Project.FinalEffortLevel;
OutOptions->Tiling = EncodeSettings.Project.FinalUniversalTiling;
OutOptions->RDOLambda = EncodeSettings.Project.FinalRDOLambda;
}
else
{
OutOptions->bUsesRDO = EncodeSettings.Project.bFastUsesRDO;
OutOptions->Effort = EncodeSettings.Project.FastEffortLevel;
OutOptions->Tiling = EncodeSettings.Project.FastUniversalTiling;
#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureEncodingSettings.cpp:13
Scope (from outer to inner):
file
function UTextureEncodingProjectSettings::UTextureEncodingProjectSettings
Source code excerpt:
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),
FastUniversalTiling(ETextureUniversalTiling::Disabled),
#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureEncodingSettings.cpp:78
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;
OutResolvedSettings->Project.FastUniversalTiling = ProjectSettings->FastUniversalTiling;
OutResolvedSettings->Project.CookUsesSpeed = ProjectSettings->CookUsesSpeed;
#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:62
Scope (from outer to inner):
file
class class UTextureEncodingProjectSettings : public UDeveloperSettings
Source code excerpt:
// 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))
int8 FinalRDOLambda;
// Specifies how much time to take trying for better encoding results.
UPROPERTY(config, EditAnywhere, Category = EncodeSpeedSettings, meta = (ConfigRestartRequired = true))
ETextureEncodeEffort FinalEffortLevel;
// Specifies how to assume textures are laid out on disc. This only applies to Oodle with RDO
#Loc: <Workspace>/Engine/Source/Runtime/Engine/Public/TextureEncodingSettings.h:61
Scope: file
Source code excerpt:
uint32 bFinalUsesRDO : 1;
uint32 bFastUsesRDO : 1;
int8 FinalRDOLambda;
int8 FastRDOLambda;
ETextureEncodeEffort FinalEffortLevel;
ETextureUniversalTiling FinalUniversalTiling;
ETextureEncodeEffort FastEffortLevel;
ETextureUniversalTiling FastUniversalTiling;
ETextureEncodeSpeed CookUsesSpeed;