FastRDOLambda
FastRDOLambda
#Overview
name: FastRDOLambda
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 FastRDOLambda is to control the Rate-Distortion Optimization (RDO) parameter for fast texture encoding in Unreal Engine 5. It is specifically used in the texture compression and encoding process, which is part of the rendering system.
This setting variable is primarily used in the Texture Editor and Engine modules of Unreal Engine 5. It’s referenced in the TextureEditor and Engine source files, indicating its importance in texture processing and rendering.
The value of FastRDOLambda is set in the UTextureEncodingProjectSettings class, which is derived from UDeveloperSettings. It’s initialized with a default value of 30 in the constructor.
FastRDOLambda interacts with several other variables, including:
- bFastUsesRDO: Determines if RDO is used in fast encoding.
- FastEffortLevel: Specifies the effort level for fast encoding.
- FastUniversalTiling: Controls the universal tiling setting for fast encoding.
- FinalRDOLambda: The RDO lambda value for final (high-quality) encoding.
Developers should be aware of the following when using this variable:
- It only applies when fast encoding is used and RDO is enabled (bFastUsesRDO is true).
- The value range is between 1 and 100, with lower values resulting in higher quality but potentially slower encoding.
- Changes to this setting require a project restart to take effect.
Best practices when using FastRDOLambda include:
- Balance between quality and performance: Lower values provide better quality but may increase encoding time.
- Consider the target platform and performance requirements when adjusting this value.
- Use in conjunction with other encoding settings (like FastEffortLevel) for optimal results.
- Test thoroughly after making changes, as it can impact both texture quality and build times.
- Document any custom settings used in the project for consistency across the development team.
#Setting Variables
#References In INI files
Location: <Workspace>/Engine/Config/BaseEngine.ini:3459, 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:603
Scope (from outer to inner):
file
function static void GetEncodeSpeedOptions
Source code excerpt:
OutOptions->Effort = EncodeSettings.Project.FastEffortLevel;
OutOptions->Tiling = EncodeSettings.Project.FastUniversalTiling;
OutOptions->RDOLambda = EncodeSettings.Project.FastRDOLambda;
}
}
// Convert the baseline build settings for all layers to one for the given layer.
// Note this gets called twice for layer 0, so needs to be idempotent.
#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureEncodingSettings.cpp:17
Scope (from outer to inner):
file
function UTextureEncodingProjectSettings::UTextureEncodingProjectSettings
Source code excerpt:
FinalUniversalTiling(ETextureUniversalTiling::Disabled),
bFastUsesRDO(false),
FastRDOLambda(30), /* OodleTex_RDOLagrangeLambda_Default */
FastEffortLevel(ETextureEncodeEffort::Normal),
FastUniversalTiling(ETextureUniversalTiling::Disabled),
CookUsesSpeed(ETextureEncodeSpeed::Final),
EditorUsesSpeed(ETextureEncodeSpeed::FinalIfAvailable)
{
}
#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureEncodingSettings.cpp:79
Scope (from outer to inner):
file
function static void ConstructResolvedSettings
Source code excerpt:
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;
OutResolvedSettings->Project.EditorUsesSpeed = ProjectSettings->EditorUsesSpeed;
#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureEncodingSettings.cpp:168
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"));
}
#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureEncodingSettingsPrivate.h:100
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 = "Fast RDO Lambda", UIMin = 1, UIMax = 100, ClampMin = 1, ClampMax = 100, EditCondition = bFastUsesRDO, ConfigRestartRequired = true))
int8 FastRDOLambda;
// Specifies how much time to take trying for better encode results.
UPROPERTY(config, EditAnywhere, Category = EncodeSpeedSettings, meta = (ConfigRestartRequired = true))
ETextureEncodeEffort FastEffortLevel;
// 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:62
Scope: file
Source code excerpt:
uint32 bFastUsesRDO : 1;
int8 FinalRDOLambda;
int8 FastRDOLambda;
ETextureEncodeEffort FinalEffortLevel;
ETextureUniversalTiling FinalUniversalTiling;
ETextureEncodeEffort FastEffortLevel;
ETextureUniversalTiling FastUniversalTiling;
ETextureEncodeSpeed CookUsesSpeed;
ETextureEncodeSpeed EditorUsesSpeed;