TextureLODSettings

TextureLODSettings

#Overview

name: TextureLODSettings

The value of this variable can be defined or overridden in .ini config files. 5 .ini config files referencing this setting variable.

It is referenced in 40 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of TextureLODSettings is to manage texture Level of Detail (LOD) settings in Unreal Engine 5. It is primarily used for controlling texture quality and performance across different platforms and device profiles. Here’s a detailed breakdown:

  1. TextureLODSettings is used by various Unreal Engine subsystems, including rendering, texture streaming, and device profile management.

  2. The value of this variable is typically set by the device profile system. It’s often initialized as nullptr and then populated by the UDeviceProfileManager.

  3. TextureLODSettings interacts with other variables like StaticMeshLODSettings, and is often used in conjunction with platform-specific settings.

  4. Developers should be aware that TextureLODSettings can significantly impact rendering performance and memory usage. It’s crucial for optimizing games across different platforms and hardware configurations.

  5. Best practices when using this variable include:

    • Ensuring it’s properly initialized for each target platform
    • Using it consistently across different parts of the engine that deal with textures
    • Carefully tuning the settings for each texture group to balance quality and performance
    • Considering the impact on different types of textures (e.g., world textures, UI textures, terrain textures)

  6. TextureLODSettings is used to determine various texture-related parameters, such as:

    • Sampler filter modes
    • LOD bias calculations
    • Maximum anisotropy settings
    • Mip-map generation settings
    • Texture downscaling options

  7. It’s particularly important for platform-specific optimizations, as seen in the Android, iOS, and Windows target platform implementations.

  8. The settings can be accessed and modified through the Device Profile editor in the Unreal Engine editor, allowing for fine-tuning of texture settings per device profile.

In summary, TextureLODSettings is a critical component for managing texture quality and performance in Unreal Engine 5, providing a flexible way to optimize texture rendering across different platforms and device capabilities.

#Setting Variables

#References In INI files

Location: <Workspace>/Engine/Config/BaseDeviceProfiles.ini:1179, section: [Linux DeviceProfile]

Location: <Workspace>/Engine/Config/BaseDeviceProfiles.ini:1185, section: [LinuxEditor DeviceProfile]

Location: <Workspace>/Engine/Config/BaseDeviceProfiles.ini:1191, section: [LinuxAArch6 DeviceProfile]

Location: <Workspace>/Engine/Config/BaseDeviceProfiles.ini:1205, section: [LinuxServer DeviceProfile]

Location: <Workspace>/Engine/Config/BaseDeviceProfiles.ini:1211, section: [LinuxArm64Server DeviceProfile]

#References in C++ code

#Callsites

This variable is referenced in the following C++ source code:

#Loc: <Workspace>/Engine/Plugins/Enterprise/GLTFExporter/Source/GLTFExporter/Private/Converters/GLTFTextureUtilities.cpp:72

Scope (from outer to inner):

file
function     TextureFilter FGLTFTextureUtilities::GetDefaultFilter

Source code excerpt:

TextureFilter FGLTFTextureUtilities::GetDefaultFilter(TextureGroup LODGroup)
{
	const UTextureLODSettings* TextureLODSettings = UDeviceProfileManager::Get().GetActiveProfile()->GetTextureLODSettings();
	const ETextureSamplerFilter Filter = TextureLODSettings->GetTextureLODGroup(LODGroup).Filter;

	switch (Filter)
	{
		case ETextureSamplerFilter::Point:             return TF_Nearest;
		case ETextureSamplerFilter::Bilinear:          return TF_Bilinear;
		case ETextureSamplerFilter::Trilinear:         return TF_Trilinear;

#Loc: <Workspace>/Engine/Plugins/Experimental/Mutable/Source/CustomizableObjectEditor/Private/MuCOE/GenerateMutableSource/GenerateMutableSourceImage.cpp:610

Scope: file

Source code excerpt:

			GenerationContext.AddParticipatingObject(*TypedNodeProject->ReferenceTexture);

			const UTextureLODSettings& TextureLODSettings = GenerationContext.Options.TargetPlatform->GetTextureLODSettings();
			const int32 FirstLODAvailable = GenerationContext.Options.bUseLODAsBias ? GenerationContext.FirstLODAvailable : 0;
			MaxReferenceTextureSizeInGame = GetTextureSizeInGame(*TypedNodeProject->ReferenceTexture, TextureLODSettings, FirstLODAvailable);
		}

		FUintVector2 TextureSize(TypedNodeProject->TextureSizeX, TypedNodeProject->TextureSizeY);

		// Max TextureSize allowed
		const int32 MaxProjectedTextureSizeInGame = ReferenceTextureSize > 0 && ReferenceTextureSize < MaxReferenceTextureSizeInGame ? ReferenceTextureSize : MaxReferenceTextureSizeInGame;

#Loc: <Workspace>/Engine/Plugins/Experimental/Mutable/Source/CustomizableObjectEditor/Private/MuCOE/GenerateMutableSource/GenerateMutableSourceImage.cpp:839

Scope: file

Source code excerpt:

			GenerationContext.AddParticipatingObject(*TypedNodeTransform->ReferenceTexture);

			const UTextureLODSettings& TextureLODSettings = GenerationContext.Options.TargetPlatform->GetTextureLODSettings();
			const uint8 SurfaceLODBias = GenerationContext.Options.bUseLODAsBias ? GenerationContext.FirstLODAvailable : 0;
			MaxReferenceTextureSizeInGame = GetTextureSizeInGame(*TypedNodeTransform->ReferenceTexture, TextureLODSettings, SurfaceLODBias);
		}

		// Max TextureSize allowed
		const int32 MaxTransformTextureSizeInGame = ReferenceTextureSize > 0 && ReferenceTextureSize < MaxReferenceTextureSizeInGame ? ReferenceTextureSize : MaxReferenceTextureSizeInGame;

		const int32 TransformNodeTextureSize = FMath::Max(TextureSize.X, TextureSize.Y);

#Loc: <Workspace>/Engine/Plugins/Experimental/Mutable/Source/CustomizableObjectEditor/Private/MuCOE/GenerateMutableSource/GenerateMutableSourceSurface.cpp:555

Scope (from outer to inner):

file
function     mu::NodeSurfacePtr GenerateMutableSourceSurface

Source code excerpt:


								// MaxTextureSize setting. Based on the ReferenceTexture and Platform settings.
								const UTextureLODSettings& TextureLODSettings = GenerationContext.Options.TargetPlatform->GetTextureLODSettings();
								Props.MaxTextureSize = GetMaxTextureSize(*ReferenceTexture, TextureLODSettings);

								// ReferenceTexture source size. Textures contributing to this Image should be equal to or smaller than TextureSize. 
								// The LOD Bias applied to the root node will be applied on top of it.
								Props.TextureSize = (int32)FMath::Max3(ReferenceTexture->Source.GetSizeX(), ReferenceTexture->Source.GetSizeY(), 1LL);

								// TODO: MTBL-1081

#Loc: <Workspace>/Engine/Source/Developer/Android/AndroidTargetPlatformSettings/Private/AndroidTargetPlatformSettings.cpp:15

Scope (from outer to inner):

file
function     FAndroidTargetPlatformSettings::FAndroidTargetPlatformSettings

Source code excerpt:

{
#if WITH_ENGINE
	TextureLODSettings = nullptr; // These are registered by the device profile system.
	StaticMeshLODSettings.Initialize(this);
	GetConfigSystem()->GetBool(TEXT("/Script/Engine.RendererSettings"), TEXT("r.DistanceFields"), bDistanceField, GEngineIni);
	GetConfigSystem()->GetInt(TEXT("/Script/Engine.RendererSettings"), TEXT("r.Mobile.ShadingPath"), MobileShadingPath, GEngineIni);
	GetConfigSystem()->GetBool(TEXT("/Script/Engine.RendererSettings"), TEXT("r.Mobile.Forward.EnableClusteredReflections"), bMobileForwardEnableClusteredReflections, GEngineIni);
	GetConfigSystem()->GetBool(TEXT("/Script/Engine.RendererSettings"), TEXT("r.Mobile.VirtualTextures"), bMobileVirtualTextures, GEngineIni);
#endif

#Loc: <Workspace>/Engine/Source/Developer/Android/AndroidTargetPlatformSettings/Private/AndroidTargetPlatformSettings.cpp:108

Scope (from outer to inner):

file
function     const UTextureLODSettings& FAndroidTargetPlatformSettings::GetTextureLODSettings

Source code excerpt:

const UTextureLODSettings& FAndroidTargetPlatformSettings::GetTextureLODSettings() const
{
	return *TextureLODSettings;
}
#endif

void FAndroidTargetPlatformSettings::GetAllPossibleShaderFormats(TArray<FName>& OutFormats) const
{
	static FName NAME_SF_VULKAN_ES31_ANDROID(TEXT("SF_VULKAN_ES31_ANDROID"));

#Loc: <Workspace>/Engine/Source/Developer/Android/AndroidTargetPlatformSettings/Public/AndroidTargetPlatformSettings.h:124

Scope (from outer to inner):

file
class        class FAndroidTargetPlatformSettings : public TTargetPlatformSettingsBase<FAndroidPlatformProperties>
function     virtual void RegisterTextureLODSettings

Source code excerpt:

	virtual void RegisterTextureLODSettings(const UTextureLODSettings* InTextureLODSettings) override
	{
		TextureLODSettings = InTextureLODSettings;
	}
	virtual const class FStaticMeshLODSettings& GetStaticMeshLODSettings() const override;
#endif
	// query for rendering mode support
	bool SupportsES31() const;
	bool SupportsVulkan() const;

#Loc: <Workspace>/Engine/Source/Developer/Android/AndroidTargetPlatformSettings/Public/AndroidTargetPlatformSettings.h:149

Scope (from outer to inner):

file
class        class FAndroidTargetPlatformSettings : public TTargetPlatformSettingsBase<FAndroidPlatformProperties>

Source code excerpt:

#if WITH_ENGINE
	// Holds a cache of the target LOD settings.
	const UTextureLODSettings* TextureLODSettings;

	// Holds the static mesh LOD settings.
	FStaticMeshLODSettings StaticMeshLODSettings;
#endif
};

#Loc: <Workspace>/Engine/Source/Developer/IOS/IOSTargetPlatform/Private/IOSTargetPlatform.cpp:39

Scope (from outer to inner):

file
function     FIOSTargetPlatform::FIOSTargetPlatform

Source code excerpt:

{
#if WITH_ENGINE
	TextureLODSettings = nullptr; // TextureLODSettings are registered by the device profile.
	StaticMeshLODSettings.Initialize(this);
	GetConfigSystem()->GetBool(TEXT("/Script/Engine.RendererSettings"), TEXT("r.DistanceFields"), bDistanceField, GEngineIni);
	GetConfigSystem()->GetInt(TEXT("/Script/Engine.RendererSettings"), TEXT("r.Mobile.ShadingPath"), MobileShadingPath, GEngineIni);
	GetConfigSystem()->GetBool(TEXT("/Script/Engine.RendererSettings"), TEXT("r.Mobile.Forward.EnableClusteredReflections"), bMobileForwardEnableClusteredReflections, GEngineIni);
	GetConfigSystem()->GetBool(TEXT("/Script/Engine.RendererSettings"), TEXT("r.Mobile.VirtualTextures"), bMobileVirtualTextures, GEngineIni);
#endif // #if WITH_ENGINE

#Loc: <Workspace>/Engine/Source/Developer/IOS/IOSTargetPlatform/Private/IOSTargetPlatform.cpp:760

Scope (from outer to inner):

file
function     const UTextureLODSettings& FIOSTargetPlatform::GetTextureLODSettings

Source code excerpt:

const UTextureLODSettings& FIOSTargetPlatform::GetTextureLODSettings() const
{
	return *TextureLODSettings;
}

#endif // WITH_ENGINE

#Loc: <Workspace>/Engine/Source/Developer/IOS/IOSTargetPlatform/Private/IOSTargetPlatform.h:85

Scope (from outer to inner):

file
class        class FIOSTargetPlatform : public TNonDesktopTargetPlatformBase<FIOSPlatformProperties>
function     virtual void RegisterTextureLODSettings

Source code excerpt:

	virtual void RegisterTextureLODSettings(const UTextureLODSettings* InTextureLODSettings) override
	{
		TextureLODSettings = InTextureLODSettings;
	}

#endif // WITH_ENGINE

	virtual void GetBuildProjectSettingKeys(FString& OutSection, TArray<FString>& InBoolKeys, TArray<FString>& InIntKeys, TArray<FString>& InStringKeys) const override
	{

#Loc: <Workspace>/Engine/Source/Developer/IOS/IOSTargetPlatform/Private/IOSTargetPlatform.h:147

Scope (from outer to inner):

file
class        class FIOSTargetPlatform : public TNonDesktopTargetPlatformBase<FIOSPlatformProperties>

Source code excerpt:

#if WITH_ENGINE
	// Holds the cache of the target LOD settings.
	const UTextureLODSettings* TextureLODSettings;

	// Holds the static mesh LOD settings.
	FStaticMeshLODSettings StaticMeshLODSettings;
#endif // WITH_ENGINE

    // holds usb device helper

#Loc: <Workspace>/Engine/Source/Developer/Linux/LinuxTargetPlatform/Public/LinuxTargetPlatform.h:58

Scope (from outer to inner):

file
class        class TLinuxTargetPlatform : public TTargetPlatformBase<TProperties>
function     bChangingDeviceConfig

Source code excerpt:


#if WITH_ENGINE
		TextureLODSettings = nullptr;
		StaticMeshLODSettings.Initialize(this);

		InitDevicesFromConfig();

		if (!TProperties::IsArm64())
		{

#Loc: <Workspace>/Engine/Source/Developer/Linux/LinuxTargetPlatform/Public/LinuxTargetPlatform.h:345

Scope (from outer to inner):

file
class        class TLinuxTargetPlatform : public TTargetPlatformBase<TProperties>
function     virtual const UTextureLODSettings& GetTextureLODSettings

Source code excerpt:

	virtual const UTextureLODSettings& GetTextureLODSettings() const override
	{
		return *TextureLODSettings;
	}

	virtual void RegisterTextureLODSettings(const UTextureLODSettings* InTextureLODSettings) override
	{
		TextureLODSettings = InTextureLODSettings;
	}

#endif //WITH_ENGINE

	virtual bool SupportsVariants() const override
	{

#Loc: <Workspace>/Engine/Source/Developer/Linux/LinuxTargetPlatform/Public/LinuxTargetPlatform.h:475

Scope (from outer to inner):

file
class        class TLinuxTargetPlatform : public TTargetPlatformBase<TProperties>

Source code excerpt:

#if WITH_ENGINE
	// Holds the texture LOD settings.
	const UTextureLODSettings* TextureLODSettings;

	// Holds static mesh LOD settings.
	FStaticMeshLODSettings StaticMeshLODSettings;

	// True if the project requires encoded HDR reflection captures
	bool bRequiresEncodedHDRReflectionCaptures;

#Loc: <Workspace>/Engine/Source/Developer/Mac/MacTargetPlatform/Public/GenericMacTargetPlatform.h:46

Scope (from outer to inner):

file
class        class TGenericMacTargetPlatform : public TTargetPlatformBase<FMacPlatformProperties<HAS_EDITOR_DATA, IS_DEDICATED_SERVER, IS_CLIENT_ONLY> >
function     TGenericMacTargetPlatform

Source code excerpt:


		#if WITH_ENGINE
			TextureLODSettings = nullptr;
			StaticMeshLODSettings.Initialize(this);
		#endif
	}

public:

#Loc: <Workspace>/Engine/Source/Developer/Mac/MacTargetPlatform/Public/GenericMacTargetPlatform.h:189

Scope (from outer to inner):

file
class        class TGenericMacTargetPlatform : public TTargetPlatformBase<FMacPlatformProperties<HAS_EDITOR_DATA, IS_DEDICATED_SERVER, IS_CLIENT_ONLY> >
function     virtual const UTextureLODSettings& GetTextureLODSettings

Source code excerpt:

	virtual const UTextureLODSettings& GetTextureLODSettings() const override
	{
		return *TextureLODSettings;
	}

	virtual void RegisterTextureLODSettings(const UTextureLODSettings* InTextureLODSettings) override
	{
		TextureLODSettings = InTextureLODSettings;
	}

	virtual bool CanSupportRemoteShaderCompile() const override
	{
		return true;
	}

#Loc: <Workspace>/Engine/Source/Developer/Mac/MacTargetPlatform/Public/GenericMacTargetPlatform.h:243

Scope (from outer to inner):

file
class        class TGenericMacTargetPlatform : public TTargetPlatformBase<FMacPlatformProperties<HAS_EDITOR_DATA, IS_DEDICATED_SERVER, IS_CLIENT_ONLY> >

Source code excerpt:

#if WITH_ENGINE
	// Holds the texture LOD settings.
	const UTextureLODSettings* TextureLODSettings;

	// Holds the static mesh LOD settings.
	FStaticMeshLODSettings StaticMeshLODSettings;

#endif // WITH_ENGINE

#Loc: <Workspace>/Engine/Source/Developer/Windows/WindowsTargetPlatform/Public/GenericWindowsTargetPlatform.h:58

Scope (from outer to inner):

file
class        class TGenericWindowsTargetPlatform : public TTargetPlatformBase<TProperties>
function     TGenericWindowsTargetPlatform

Source code excerpt:


	#if WITH_ENGINE
		TextureLODSettings = nullptr; // These are registered by the device profile system.
		StaticMeshLODSettings.Initialize(this);


		// Get the Target RHIs for this platform, we do not always want all those that are supported.
		TArray<FName> TargetedShaderFormats;
		TGenericWindowsTargetPlatform::GetAllTargetedShaderFormats(TargetedShaderFormats);

#Loc: <Workspace>/Engine/Source/Developer/Windows/WindowsTargetPlatform/Public/GenericWindowsTargetPlatform.h:356

Scope (from outer to inner):

file
class        class TGenericWindowsTargetPlatform : public TTargetPlatformBase<TProperties>
function     virtual const UTextureLODSettings& GetTextureLODSettings

Source code excerpt:

	virtual const UTextureLODSettings& GetTextureLODSettings() const override
	{
		return *TextureLODSettings;
	}

	virtual void RegisterTextureLODSettings(const UTextureLODSettings* InTextureLODSettings) override
	{
		TextureLODSettings = InTextureLODSettings;
	}

#endif //WITH_ENGINE

	virtual bool SupportsVariants() const override
	{

#Loc: <Workspace>/Engine/Source/Developer/Windows/WindowsTargetPlatform/Public/GenericWindowsTargetPlatform.h:403

Scope (from outer to inner):

file
class        class TGenericWindowsTargetPlatform : public TTargetPlatformBase<TProperties>

Source code excerpt:

#if WITH_ENGINE
	// Holds the texture LOD settings.
	const UTextureLODSettings* TextureLODSettings;

	// Holds static mesh LOD settings.
	FStaticMeshLODSettings StaticMeshLODSettings;

	// True if the project requires encoded HDR reflection captures
	bool bRequiresEncodedHDRReflectionCaptures;

#Loc: <Workspace>/Engine/Source/Editor/DeviceProfileEditor/Private/DeviceProfileTextureLODSettingsColumn.cpp:59

Scope (from outer to inner):

file
class        class FTextureLODSettingsCellPresenter : public TSharedFromThis< FTextureLODSettingsCellPresenter > , public IPropertyTableCellPresenter

Source code excerpt:


	/**
	 * Event handler triggered when the user presses the edit TextureLODSettings button
	 *
	 * @return Whether the event was handled.
	 */
	FReply HandleEditTextureLODSettingsButtonPressed()
	{
		OnEditTextureLODSettingsRequest.ExecuteIfBound(OwnerProfile);
		return FReply::Handled();
	}

public:

#Loc: <Workspace>/Engine/Source/Editor/DeviceProfileEditor/Private/DeviceProfileTextureLODSettingsColumn.cpp:116

Scope (from outer to inner):

file
class        class FTextureLODSettingsCellPresenter : public TSharedFromThis< FTextureLODSettingsCellPresenter > , public IPropertyTableCellPresenter

Source code excerpt:

	TWeakObjectPtr<UDeviceProfile> OwnerProfile;

	/** Delegate triggered when the user opts to edit the TextureLODSettings from the button in this cell */
	FOnEditDeviceProfileTextureLODSettingsRequestDelegate OnEditTextureLODSettingsRequest;
};


TSharedRef<class SWidget> FTextureLODSettingsCellPresenter::ConstructDisplayWidget()
{

#Loc: <Workspace>/Engine/Source/Editor/DeviceProfileEditor/Private/DeviceProfileTextureLODSettingsColumn.h:15

Scope: file

Source code excerpt:

class UDeviceProfile;

/** Delegate triggered when user opts to edit TextureLODSettings **/
DECLARE_DELEGATE_OneParam(FOnEditDeviceProfileTextureLODSettingsRequestDelegate, const TWeakObjectPtr<UDeviceProfile>&);


/**
 * A property table custom column used to bring the user to an editor which 
 * will manage the Texture LOD Settings associated with the device profile

#Loc: <Workspace>/Engine/Source/Editor/DeviceProfileEditor/Private/DeviceProfileTextureLODSettingsColumn.h:50

Scope (from outer to inner):

file
class        class FDeviceProfileTextureLODSettingsColumn : public IPropertyTableCustomColumn

Source code excerpt:

private:

	/** Delegate triggered when user opts to edit TextureLODSettings. **/
	FOnEditDeviceProfileTextureLODSettingsRequestDelegate OnEditTextureLODSettingsRequestDelegate;
};

#Loc: <Workspace>/Engine/Source/Editor/DeviceProfileEditor/Private/SDeviceProfileEditor.cpp:593

Scope (from outer to inner):

file
function     TSharedRef< SWidget > SDeviceProfileEditor::SetupPropertyEditor

Source code excerpt:

	CVarsColumn->OnEditCVarsRequest().BindRaw(this, &SDeviceProfileEditor::HandleDeviceProfileViewAlone);

	// Adapt the TextureLODSettings column as a button to open a single editor which will allow better control of the Texture Groups
	TSharedRef<FDeviceProfileTextureLODSettingsColumn> TextureLODSettingsColumn = MakeShareable(new FDeviceProfileTextureLODSettingsColumn());
	TextureLODSettingsColumn->OnEditTextureLODSettingsRequest().BindRaw(this, &SDeviceProfileEditor::HandleDeviceProfileViewAlone);

	// Add our Custom Rows to the table
	TArray<TSharedRef<IPropertyTableCustomColumn>> CustomColumns;
	CustomColumns.Add(CVarsColumn);

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/DeviceProfiles/DeviceProfileManager.cpp:968

Scope (from outer to inner):

file
function     void UDeviceProfileManager::LoadProfiles

Source code excerpt:

				ITargetPlatform* Platform = TargetPlatforms[PlatformIndex];

				// Set TextureLODSettings
				const UTextureLODSettings* TextureLODSettingsObj = FindProfile(Platform->CookingDeviceProfileName(), false);
				checkf(TextureLODSettingsObj, TEXT("No TextureLODSettings found for %s"), *Platform->CookingDeviceProfileName());

				Platform->RegisterTextureLODSettings(TextureLODSettingsObj);
			}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Rendering/StreamableTextureResource.cpp:96

Scope (from outer to inner):

file
function     FStreamableTextureResource::FStreamableTextureResource

Source code excerpt:

	bGreyScaleFormat = UE::TextureDefines::ShouldUseGreyScaleEditorVisualization( InOwner->CompressionSettings );

	const UTextureLODSettings* TextureLODSettings = UDeviceProfileManager::Get().GetActiveProfile()->GetTextureLODSettings();

	Filter = (ESamplerFilter)TextureLODSettings->GetSamplerFilter(InOwner);
	AddressU = InOwner->GetTextureAddressX() == TA_Wrap ? AM_Wrap : (InOwner->GetTextureAddressX() == TA_Clamp ? AM_Clamp : AM_Mirror);
	AddressV = InOwner->GetTextureAddressY() == TA_Wrap ? AM_Wrap : (InOwner->GetTextureAddressY() == TA_Clamp ? AM_Clamp : AM_Mirror);
	AddressW = InOwner->GetTextureAddressZ() == TA_Wrap ? AM_Wrap : (InOwner->GetTextureAddressZ() == TA_Clamp ? AM_Clamp : AM_Mirror);
	MaxAniso = TextureLODSettings->GetTextureLODGroup(InOwner->LODGroup).MaxAniso;

	// Get the biggest mips size, might be different from the actual resolution (depending on NumOfResidentLODs).
	const FTexture2DMipMap& Mip0 = PlatformData->Mips[State.AssetLODBias];
	SizeX = Mip0.SizeX;	
	SizeY = Mip0.SizeY;
	SizeZ = Mip0.SizeZ;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/SceneManagement.cpp:1251

Scope (from outer to inner):

file
function     void FSharedSamplerState::InitRHI

Source code excerpt:

	const float MipMapBias = UTexture2D::GetGlobalMipMapLODBias();

	const UTextureLODSettings* TextureLODSettings = UDeviceProfileManager::Get().GetActiveProfile()->GetTextureLODSettings();
	FSamplerStateInitializerRHI SamplerStateInitializer
	(
	(ESamplerFilter)TextureLODSettings->GetSamplerFilter(TEXTUREGROUP_World),
		bWrap ? AM_Wrap : AM_Clamp,
		bWrap ? AM_Wrap : AM_Clamp,
		bWrap ? AM_Wrap : AM_Clamp,
		MipMapBias,
		TextureLODSettings->GetTextureLODGroup(TEXTUREGROUP_World).MaxAniso
	);
	SamplerStateRHI = RHICreateSamplerState(SamplerStateInitializer);
}

FSharedSamplerState* Wrap_WorldGroupSettings = NULL;
FSharedSamplerState* Clamp_WorldGroupSettings = NULL;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Texture.cpp:1508

Scope (from outer to inner):

file
function     bool UTexture::IsCookPlatformTilingDisabled

Source code excerpt:

	if (CookPlatformTilingSettings.GetValue() == TextureCookPlatformTilingSettings::TCPTS_FromTextureGroup)
	{
		const UTextureLODSettings* TextureLODSettings = nullptr;

		if (TargetPlatform)
		{
			TextureLODSettings = &TargetPlatform->GetTextureLODSettings();
		}
		else
		{
			TextureLODSettings = UDeviceProfileManager::Get().GetActiveProfile()->GetTextureLODSettings();

			if (!TextureLODSettings)
			{
				return false;
			}
		}

		check(TextureLODSettings);

		checkf(LODGroup < TextureLODSettings->TextureLODGroups.Num(), 
			TEXT("A texture had passed a bad LODGroup to UTexture::IsCookPlatformTilingDisabled (%d, out of %d groups). The texture name is '%s'."), 
			LODGroup, TextureLODSettings->TextureLODGroups.Num(), *GetPathName());

		return TextureLODSettings->TextureLODGroups[LODGroup].CookPlatformTilingDisabled;
	}

	return CookPlatformTilingSettings.GetValue() == TextureCookPlatformTilingSettings::TCPTS_DoNotTile;
}

void UTexture::SetDeterministicLightingGuid()

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureDerivedData.cpp:830

Scope (from outer to inner):

file
function     static void GetTextureBuildSettings

Source code excerpt:

static void GetTextureBuildSettings(
	const UTexture& Texture,
	const UTextureLODSettings& TextureLODSettings,
	const ITargetPlatform& TargetPlatform,
	ETextureEncodeSpeed InEncodeSpeed, // must be Final or Fast.
	FTextureBuildSettings& OutBuildSettings,
	FTexturePlatformData::FTextureEncodeResultMetadata* OutBuildResultMetadata // can be nullptr if not needed
	)
{

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureDerivedData.cpp:939

Scope (from outer to inner):

file
function     static void GetTextureBuildSettings

Source code excerpt:

	bool bBorderColorBlack;
	TextureMipGenSettings MipGenSettings;
	TextureLODSettings.GetMipGenSettings( 
		Texture,
		MipGenSettings,
		OutBuildSettings.MipSharpening,
		OutBuildSettings.SharpenMipKernelSize,
		bDownsampleWithAverage,
		bSharpenWithoutColorShift,

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureDerivedData.cpp:1009

Scope (from outer to inner):

file
function     static void GetTextureBuildSettings

Source code excerpt:

	}

	OutBuildSettings.LODBias = TextureLODSettings.CalculateLODBias(SourceSize.X, SourceSize.Y, Texture.MaxTextureSize, Texture.LODGroup, Texture.LODBias, Texture.NumCinematicMipLevels, Texture.MipGenSettings, bVirtualTextureStreaming);
	OutBuildSettings.LODBiasWithCinematicMips = TextureLODSettings.CalculateLODBias(SourceSize.X, SourceSize.Y, Texture.MaxTextureSize, Texture.LODGroup, Texture.LODBias, 0, Texture.MipGenSettings, bVirtualTextureStreaming);
	OutBuildSettings.bVirtualStreamable = bVirtualTextureStreaming;
	OutBuildSettings.PowerOfTwoMode = Texture.PowerOfTwoMode;
	OutBuildSettings.PaddingColor = Texture.PaddingColor;
	OutBuildSettings.bPadWithBorderColor = Texture.bPadWithBorderColor;
	OutBuildSettings.ResizeDuringBuildX = Texture.ResizeDuringBuildX;
	OutBuildSettings.ResizeDuringBuildY = Texture.ResizeDuringBuildY;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureDerivedData.cpp:1029

Scope (from outer to inner):

file
function     static void GetTextureBuildSettings

Source code excerpt:

	if ( Texture.LossyCompressionAmount == TLCA_Default )
	{
		const FTextureLODGroup& LODGroup = TextureLODSettings.GetTextureLODGroup(Texture.LODGroup);
		OutBuildSettings.LossyCompressionAmount = LODGroup.LossyCompressionAmount;
		if (OutBuildResultMetadata)
		{
			OutBuildResultMetadata->RDOSource = FTexturePlatformData::FTextureEncodeResultMetadata::OodleRDOSource::LODGroup;
		}
	}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureDerivedData.cpp:1049

Scope (from outer to inner):

file
function     static void GetTextureBuildSettings

Source code excerpt:

	float Downscale;
	ETextureDownscaleOptions DownscaleOptions;
	TextureLODSettings.GetDownscaleOptions(Texture, TargetPlatform, Downscale, DownscaleOptions);

	// Downscale only allowed if NoMipMaps, 2d, and not VT
	//	silently does nothing otherwise
	if (! bVirtualTextureStreaming &&
		MipGenSettings == TMGS_NoMipmaps && 
		Texture.IsA(UTexture2D::StaticClass()))	// TODO: support more texture types

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureDerivedData.cpp:1094

Scope (from outer to inner):

file
function     static void GetTextureBuildSettings

Source code excerpt:


		// Apply any LOD group tile size bias here
		const int32 TileSizeBias = TextureLODSettings.GetTextureLODGroup(Texture.LODGroup).VirtualTextureTileSizeBias;
		OutBuildSettings.VirtualTextureTileSize >>= (TileSizeBias < 0) ? -TileSizeBias : 0;
		OutBuildSettings.VirtualTextureTileSize <<= (TileSizeBias > 0) ? TileSizeBias : 0;

		// Don't allow max resolution to be less than VT tile size
		OutBuildSettings.MaxTextureResolution = FMath::Max<uint32>(OutBuildSettings.MaxTextureResolution, OutBuildSettings.VirtualTextureTileSize);

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureLODSettings.cpp:5

Scope: file

Source code excerpt:

#include "Interfaces/ITargetPlatform.h"

#include UE_INLINE_GENERATED_CPP_BY_NAME(TextureLODSettings)

int32 GUITextureLODBias = 0;
FAutoConsoleVariableRef CVarUITextureLODBias(
	TEXT("r.UITextureLODBias"),
	GUITextureLODBias,
	TEXT("Extra LOD bias to apply to UI textures. (default=0)"),

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureRenderTarget2D.cpp:580

Scope (from outer to inner):

file
function     void FTextureRenderTarget2DResource::InitRHI

Source code excerpt:


	// Create the sampler state RHI resource.
	const UTextureLODSettings* TextureLODSettings = UDeviceProfileManager::Get().GetActiveProfile()->GetTextureLODSettings();
	FSamplerStateInitializerRHI SamplerStateInitializer
	(
		(ESamplerFilter)TextureLODSettings->GetSamplerFilter( Owner ),
		Owner->AddressX == TA_Wrap ? AM_Wrap : (Owner->AddressX == TA_Clamp ? AM_Clamp : AM_Mirror),
		Owner->AddressY == TA_Wrap ? AM_Wrap : (Owner->AddressY == TA_Clamp ? AM_Clamp : AM_Mirror),
		AM_Wrap,
		0,
		TextureLODSettings->GetTextureLODGroup(Owner->LODGroup).MaxAniso
	);
	SamplerStateRHI = GetOrCreateSamplerState( SamplerStateInitializer );
}

/**
 * Release the RHI render target resources used by this resource.

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/TextureRenderTarget2DArray.cpp:259

Scope (from outer to inner):

file
function     void FTextureRenderTarget2DArrayResource::InitRHI

Source code excerpt:


	// Create the sampler state RHI resource.
	const UTextureLODSettings* TextureLODSettings = UDeviceProfileManager::Get().GetActiveProfile()->GetTextureLODSettings();
	FSamplerStateInitializerRHI SamplerStateInitializer
	(
		(ESamplerFilter)TextureLODSettings->GetSamplerFilter(Owner),
		AM_Wrap,
		AM_Wrap,
		AM_Wrap,
		0,
		TextureLODSettings->GetTextureLODGroup(Owner->LODGroup).MaxAniso
	);
	SamplerStateRHI = GetOrCreateSamplerState(SamplerStateInitializer);
}

/**
 * Release the RHI render target resources used by this resource.

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/SceneRendering.cpp:996

Scope (from outer to inner):

file
function     void FViewInfo::Init

Source code excerpt:

	if (IsInGameThread())
	{
		const UTextureLODSettings* TextureLODSettings = UDeviceProfileManager::Get().GetActiveProfile()->GetTextureLODSettings();
		WorldTextureGroupSamplerFilter = (ESamplerFilter)TextureLODSettings->GetSamplerFilter(TEXTUREGROUP_World);
		TerrainWeightmapTextureGroupSamplerFilter = (ESamplerFilter)TextureLODSettings->GetSamplerFilter(TEXTUREGROUP_Terrain_Weightmap);
		WorldTextureGroupMaxAnisotropy = TextureLODSettings->GetTextureLODGroup(TEXTUREGROUP_World).MaxAniso;
		bIsValidTextureGroupSamplerFilters = true;
	}
	else
	{
		bIsValidTextureGroupSamplerFilters = false;
	}