bFastUsesRDO
bFastUsesRDO
#Overview
name: bFastUsesRDO
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 10 C++ source files.
#Summary
#Usage in the C++ source code
The purpose of bFastUsesRDO is to control whether Rate-Distortion Optimization (RDO) is used during fast texture encoding in Unreal Engine 5. This setting is part of the texture compression and encoding system, which is crucial for optimizing texture quality and performance in game development.
This variable is primarily used in the Engine module, specifically in the texture encoding and editing subsystems. It’s referenced in the TextureEditor and Engine source files, indicating its importance in both runtime and editor functionalities.
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 by developers.
bFastUsesRDO interacts with several other variables, including:
- bFinalUsesRDO: A similar setting for final (non-fast) encoding
- FastRDOLambda: The lambda value used when RDO is enabled for fast encoding
- FastEffortLevel: The effort level for fast encoding
- FastUniversalTiling: The universal tiling setting for fast encoding
Developers should be aware of the following when using this variable:
- It affects the quality and performance of texture compression during fast encoding.
- Enabling RDO may increase encoding time but can result in better quality-to-size ratios.
- The setting is used in conjunction with other fast encoding settings to determine the overall encoding behavior.
Best practices when using this variable include:
- Consider the trade-off between encoding speed and texture quality when deciding to enable or disable RDO for fast encoding.
- Ensure that the FastRDOLambda value is appropriate when bFastUsesRDO is enabled.
- Test the impact of this setting on your project’s texture quality and build times to find the optimal configuration.
- Be consistent in your use of fast and final encoding settings across your project to maintain predictable texture quality.
#Setting Variables
#References In INI files
Location: <Workspace>/Engine/Config/BaseEngine.ini:3458, section: [/Script/Engine.TextureEncodingProjectSettings]
- INI Section:
/Script/Engine.TextureEncodingProjectSettings - Raw value:
false - 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;
}
#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:600
Scope (from outer to inner):
file
function static void GetEncodeSpeedOptions
Source code excerpt:
else
{
OutOptions->bUsesRDO = EncodeSettings.Project.bFastUsesRDO;
OutOptions->Effort = EncodeSettings.Project.FastEffortLevel;
OutOptions->Tiling = EncodeSettings.Project.FastUniversalTiling;
OutOptions->RDOLambda = EncodeSettings.Project.FastRDOLambda;
}
}
#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureEncodingSettings.cpp:16
Scope (from outer to inner):
file
function UTextureEncodingProjectSettings::UTextureEncodingProjectSettings
Source code excerpt:
FinalEffortLevel(ETextureEncodeEffort::Normal),
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:77
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;
#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureEncodingSettings.cpp:138
Scope (from outer to inner):
file
function static void ConstructResolvedSettings
Source code excerpt:
FString FastRDOString;
if (OutResolvedSettings->Project.bFastUsesRDO)
{
FastRDOString = FString(TEXT("On"));
if (OutResolvedSettings->Project.FastUniversalTiling != ETextureUniversalTiling::Disabled)
{
FastRDOString += TEXT(" UT=");
FastRDOString += UniversalTilingEnum->GetNameStringByValue((int64)OutResolvedSettings->Project.FastUniversalTiling);
#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:93
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 bFastUsesRDO : 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 = "Fast RDO Lambda", UIMin = 1, UIMax = 100, ClampMin = 1, ClampMax = 100, EditCondition = bFastUsesRDO, ConfigRestartRequired = true))
#Loc: <Workspace>/Engine/Source/Runtime/Engine/Public/TextureEncodingSettings.h:60
Scope: file
Source code excerpt:
uint32 bSharedLinearTextureEncoding : 1;
uint32 bFinalUsesRDO : 1;
uint32 bFastUsesRDO : 1;
int8 FinalRDOLambda;
int8 FastRDOLambda;
ETextureEncodeEffort FinalEffortLevel;
ETextureUniversalTiling FinalUniversalTiling;
ETextureEncodeEffort FastEffortLevel;
ETextureUniversalTiling FastUniversalTiling;