ShowFlag.LODColoration

ShowFlag.LODColoration

#Overview

name: ShowFlag.LODColoration

This variable is created as a Console Variable (cvar).

It is referenced in 20 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of ShowFlag.LODColoration is to visualize Level of Detail (LOD) coloration in the Unreal Engine 5 rendering system. This setting is primarily used for debugging and visualizing how LODs are applied to different objects in the scene.

Unreal Engine’s rendering system relies on this setting to determine whether to apply LOD coloration to objects in the scene. It is used across various subsystems and modules, including:

  1. The Base Pass rendering system
  2. The Hair Strands rendering system
  3. The Groom Visualization system
  4. The Scene View system
  5. The Primitive Drawing system

The value of this variable is typically set through the engine’s show flags system, which allows developers to toggle various visualization modes in the editor and at runtime.

This variable interacts closely with other debug visualization modes, such as HLODColoration (Hierarchical LOD coloration) and other engine show flags. It’s often used in conjunction with these other flags to provide comprehensive debugging information.

Developers should be aware that:

  1. This is a debug visualization tool and should not be enabled in shipping builds.
  2. Enabling this flag may impact performance, as it requires additional rendering passes.
  3. The coloration is based on the LOD index of the object, using a predefined color palette (GEngine->LODColorationColors).

Best practices when using this variable include:

  1. Use it in conjunction with other debug visualization tools for a comprehensive understanding of the scene’s rendering.
  2. Remember to disable it when not needed, as it can impact performance.
  3. Be aware that it might not accurately represent the final rendered quality, as it’s meant for debugging LOD transitions and not final visual fidelity.

Regarding the associated variable LODColoration:

The purpose of LODColoration is to represent the actual LOD coloration mode in various parts of the engine, particularly in the Hair Strands and Groom systems. It’s used to determine when to apply LOD-based coloring to these specific systems.

This variable is typically used in the rendering code to decide whether to apply LOD-based coloring to specific elements like hair strands or groom components. It’s often set based on the value of ShowFlag.LODColoration, but can be controlled independently in some contexts.

Developers should be aware that this variable is specific to certain subsystems and may not affect the entire scene in the same way as ShowFlag.LODColoration. It’s primarily used for more granular control over LOD visualization in specific rendering contexts.

When using this variable, consider:

  1. Its scope is more limited than ShowFlag.LODColoration, often applying to specific systems or components.
  2. It may be used in conjunction with other visualization modes specific to hair or groom rendering.
  3. Like ShowFlag.LODColoration, it’s primarily a debugging tool and should be used accordingly.

#References in C++ code

#Callsites

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

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Public/ShowFlagsValues.inl:357

Scope: file

Source code excerpt:

SHOWFLAG_FIXED_IN_SHIPPING(0, VisualizeSenses, SFG_Advanced, NSLOCTEXT("UnrealEd", "VisualizeSenses", "Senses"))
/** Visualize LOD Coloration */
SHOWFLAG_FIXED_IN_SHIPPING(0, LODColoration, SFG_Hidden, NSLOCTEXT("UnrealEd", "VisualizeLODColoration", "Visualize LOD Coloration"))
/** Visualize HLOD Coloration */
SHOWFLAG_FIXED_IN_SHIPPING(0, HLODColoration, SFG_Hidden, NSLOCTEXT("UnrealEd", "VisualizeHLODColoration", "Visualize HLOD Coloration"))
/** Visualize screen quads */
SHOWFLAG_FIXED_IN_SHIPPING(0, QuadOverdraw, SFG_Hidden, NSLOCTEXT("UnrealEd", "QuadOverdrawSF", "Quad Overdraw"))
/** Visualize the overhead of material quads */
SHOWFLAG_FIXED_IN_SHIPPING(0, ShaderComplexityWithQuadOverdraw, SFG_Hidden, NSLOCTEXT("UnrealEd", "ShaderComplexityWithQuadOverdraw", "Shader Complexity With Quad Overdraw"))

#Associated Variable and Callsites

This variable is associated with another variable named LODColoration. They share the same value. See the following C++ source code.

#Loc: <Workspace>/Engine/Plugins/Runtime/HairStrands/Source/HairStrandsCore/Private/GroomComponent.cpp:774

Scope (from outer to inner):

file
class        class FHairStrandsSceneProxy final : public FPrimitiveSceneProxy
function     virtual void GetDynamicMeshElements

Source code excerpt:

					case EGroomViewMode::AO				:
					case EGroomViewMode::Group			:
					case EGroomViewMode::LODColoration	:
						bNeedDebugMaterial = true; break;
					};

					if (bNeedDebugMaterial)
					{
						float DebugModeScalar = 0;

#Loc: <Workspace>/Engine/Plugins/Runtime/HairStrands/Source/HairStrandsCore/Private/GroomComponent.cpp:797

Scope (from outer to inner):

file
class        class FHairStrandsSceneProxy final : public FPrimitiveSceneProxy
function     virtual void GetDynamicMeshElements

Source code excerpt:

						case EGroomViewMode::ClusterAABB		: DebugModeScalar = 0.f; break;
						case EGroomViewMode::Group				: DebugModeScalar = 9.f; break;
						case EGroomViewMode::LODColoration		: DebugModeScalar = 10.f; break;
						case EGroomViewMode::ClumpID			: DebugModeScalar = 11.f; break;
						case EGroomViewMode::AO					: DebugModeScalar = 12.f; break;
						};

						// TODO: fix this as the radius is incorrect. This code run before the interpolation code, which is where HairRadius is updated.
						float HairMaxRadius = 0;

#Loc: <Workspace>/Engine/Plugins/Runtime/HairStrands/Source/HairStrandsCore/Private/GroomComponent.cpp:810

Scope (from outer to inner):

file
class        class FHairStrandsSceneProxy final : public FPrimitiveSceneProxy
function     virtual void GetDynamicMeshElements

Source code excerpt:

						
						// Reuse the HairMaxRadius field to send the LOD index instead of adding yet another variable
						if (ViewMode == EGroomViewMode::LODColoration)
						{
							HairMaxRadius = HairGroupInstances[GroupIt]->HairGroupPublicData ? HairGroupInstances[GroupIt]->HairGroupPublicData->LODIndex : 0;
						}

						// Reuse the HairMaxRadius field to send the clumpID index selection
						if (ViewMode == EGroomViewMode::ClumpID)

#Loc: <Workspace>/Engine/Plugins/Runtime/HairStrands/Source/HairStrandsCore/Private/GroomComponent.cpp:826

Scope (from outer to inner):

file
class        class FHairStrandsSceneProxy final : public FPrimitiveSceneProxy
function     virtual void GetDynamicMeshElements

Source code excerpt:

							HairColor = FVector(GetHairGroupDebugColor(GroupIt));
						}
						else if (ViewMode == EGroomViewMode::LODColoration)
						{
							int32 LODIndex = HairGroupInstances[GroupIt]->HairGroupPublicData ? HairGroupInstances[GroupIt]->HairGroupPublicData->LODIndex : 0;
							LODIndex = FMath::Clamp(LODIndex, 0, GEngine->LODColorationColors.Num() - 1);
							const FLinearColor LODColor = GEngine->LODColorationColors[LODIndex];
							HairColor = FVector(LODColor.R, LODColor.G, LODColor.B);
						}

#Loc: <Workspace>/Engine/Source/Editor/CommonMenuExtensions/Private/GroomVisualizationMenuCommands.cpp:68

Scope (from outer to inner):

file
function     void FGroomVisualizationMenuCommands::InternalBuildVisualisationSubMenu

Source code excerpt:

			}
			Commands.AddCommandTypeToMenu(Menu, EGroomViewMode::Group);
			Commands.AddCommandTypeToMenu(Menu, EGroomViewMode::LODColoration);
			Menu.EndSection();
		}

		// Attributes
		{
			Menu.BeginSection("LevelViewportGroomVisualizationAttributes", LOCTEXT("GroomVisualizationAttributes", "Groom Attributes"));

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/GroomVisualizationData.cpp:79

Scope (from outer to inner):

file
function     EGroomViewMode GetGroomViewMode

Source code excerpt:

			case 34: return EGroomViewMode::ControlPoints;
			case 35: return EGroomViewMode::Group;
			case 36: return EGroomViewMode::LODColoration;
			case 37: return EGroomViewMode::CardGuides;
			case 38: return EGroomViewMode::AO;
			case 39: return EGroomViewMode::ClumpID;
			case 40: return EGroomViewMode::Memory;
			default: break;
			}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/GroomVisualizationData.cpp:93

Scope (from outer to inner):

file
function     EGroomViewMode GetGroomViewMode

Source code excerpt:

			Out = VisualizationData.GetViewMode(View.CurrentGroomVisualizationMode);
		}
		else if (View.Family && View.Family->EngineShowFlags.LODColoration)
		{
			Out = EGroomViewMode::LODColoration;
		}
	}
	return Out;
}

const TCHAR* GetGroomViewModeName(EGroomViewMode In)

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/GroomVisualizationData.cpp:139

Scope (from outer to inner):

file
function     const TCHAR* GetGroomViewModeName

Source code excerpt:

	case EGroomViewMode::ControlPoints:				return TEXT("ControlPoints");
	case EGroomViewMode::Group:						return TEXT("Group");
	case EGroomViewMode::LODColoration:				return TEXT("LODColoration");
	case EGroomViewMode::CardGuides:				return TEXT("CardGuides");
	case EGroomViewMode::Memory:					return TEXT("Memory");
	}
	return TEXT("None");
}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/GroomVisualizationData.cpp:228

Scope (from outer to inner):

file
function     void FGroomVisualizationData::Initialize

Source code excerpt:

		AddVisualizationMode(ModeMap, true, EGroomViewMode::ClusterAABB,				LOCTEXT("ClusterAABB", "Clusters Bounds"),					LOCTEXT("ClusterAABBDesc", "Hair clusters AABBs"));
		AddVisualizationMode(ModeMap, true, EGroomViewMode::Group,						LOCTEXT("Group", "Groups"),									LOCTEXT("GroupDesc", "Hair groups"));
		AddVisualizationMode(ModeMap, true, EGroomViewMode::LODColoration,				LOCTEXT("LODColoration", "LOD Color"),						LOCTEXT("LODColorationDesc", "Hair LOD coloring"));
		AddVisualizationMode(ModeMap, true, EGroomViewMode::AO,							LOCTEXT("AO", "Per-CV AO"),									LOCTEXT("AODesc", "Control point AO  (optional)"));
		AddVisualizationMode(ModeMap, true, EGroomViewMode::ClumpID,					LOCTEXT("ClumpID", "Clump ID"),								LOCTEXT("ClumpIDDesc", "Curve clumpID  (optional)"));
		AddVisualizationMode(ModeMap, true, EGroomViewMode::Memory,						LOCTEXT("Memory", "Memory"),								LOCTEXT("MemoryDesc", "Memory"));

		ConsoleDocumentationVisualizationMode = ConfigureConsoleCommand(ModeMap);
	}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/PrimitiveDrawingUtils.cpp:1542

Scope (from outer to inner):

file
function     bool IsRichView

Source code excerpt:

		ViewFamily.EngineShowFlags.Wireframe ||
		ViewFamily.EngineShowFlags.ActorColoration ||
		ViewFamily.EngineShowFlags.LODColoration ||
		ViewFamily.EngineShowFlags.HLODColoration ||
		ViewFamily.EngineShowFlags.MassProperties )
	{
		return true;
	}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/SceneView.cpp:3095

Scope (from outer to inner):

file
function     EDebugViewShaderMode FSceneViewFamily::ChooseDebugViewShaderMode

Source code excerpt:

		return DVSM_VirtualTexturePendingMips;
	}
	else if (EngineShowFlags.LODColoration || EngineShowFlags.HLODColoration)
	{
		return DVSM_LODColoration;
	}
	else if (EngineShowFlags.VisualizeGPUSkinCache)
	{
		return DVSM_VisualizeGPUSkinCache;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/ShowFlags.cpp:810

Scope: file

Source code excerpt:

		return VMI_CollisionVisibility;
	}
	else if (EngineShowFlags.LODColoration)
	{
		return VMI_LODColoration;
	}
	else if (EngineShowFlags.HLODColoration)
	{
		return VMI_HLODColoration;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Public/GroomVisualizationData.h:26

Scope: file

Source code excerpt:

	ClusterAABB,
	Group,
	LODColoration,
	ControlPoints,
	MacroGroups,
	LightBounds,
	DeepOpacityMaps,
	MacroGroupScreenRect,
	SamplePerPixel,

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Public/ParticleHelper.h:2467

Scope (from outer to inner):

file
class        class FParticleSystemSceneProxy final : public FPrimitiveSceneProxy

Source code excerpt:

	int32 LODMethod;
	float PendingLODDistance;
	int32 VisualizeLODIndex; // Only used in the LODColoration view mode.

	// from ViewFamily.FrameNumber
	int32 LastFramePreRendered;

	/** The primitive's uniform buffer.  Mutable because it is cached state during GetDynamicMeshElements. */
	mutable TUniformBuffer<FPrimitiveUniformShaderParameters> WorldSpacePrimitiveUniformBuffer;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Public/ShowFlagsValues.inl:357

Scope: file

Source code excerpt:

SHOWFLAG_FIXED_IN_SHIPPING(0, VisualizeSenses, SFG_Advanced, NSLOCTEXT("UnrealEd", "VisualizeSenses", "Senses"))
/** Visualize LOD Coloration */
SHOWFLAG_FIXED_IN_SHIPPING(0, LODColoration, SFG_Hidden, NSLOCTEXT("UnrealEd", "VisualizeLODColoration", "Visualize LOD Coloration"))
/** Visualize HLOD Coloration */
SHOWFLAG_FIXED_IN_SHIPPING(0, HLODColoration, SFG_Hidden, NSLOCTEXT("UnrealEd", "VisualizeHLODColoration", "Visualize HLOD Coloration"))
/** Visualize screen quads */
SHOWFLAG_FIXED_IN_SHIPPING(0, QuadOverdraw, SFG_Hidden, NSLOCTEXT("UnrealEd", "QuadOverdrawSF", "Quad Overdraw"))
/** Visualize the overhead of material quads */
SHOWFLAG_FIXED_IN_SHIPPING(0, ShaderComplexityWithQuadOverdraw, SFG_Hidden, NSLOCTEXT("UnrealEd", "ShaderComplexityWithQuadOverdraw", "Shader Complexity With Quad Overdraw"))

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/BasePassRendering.cpp:1046

Scope (from outer to inner):

file
function     void FDeferredShadingSceneRenderer::RenderBasePass

Source code excerpt:

			ViewFamily.EngineShowFlags.PrimitiveDistanceAccuracy ||
			ViewFamily.EngineShowFlags.ShaderComplexity ||
			ViewFamily.EngineShowFlags.LODColoration ||
			ViewFamily.EngineShowFlags.HLODColoration);

	const bool bForwardShadingEnabled = IsForwardShadingEnabled(SceneTextures.Config.ShaderPlatform);

	const FExclusiveDepthStencil ExclusiveDepthStencil(BasePassDepthStencilAccess);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DebugViewModeRendering.cpp:123

Scope (from outer to inner):

file
function     void SetupDebugViewModePassUniformBufferConstants

Source code excerpt:

	{
		const TArray<FLinearColor>* Colors = nullptr;
		if (ViewInfo.Family->EngineShowFlags.LODColoration)
		{
			Colors = &(GEngine->LODColorationColors);
		}
		else if (ViewInfo.Family->EngineShowFlags.HLODColoration)
		{
			Colors = &GEngine->HLODColorationColors;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/HairStrands/HairStrandsComposition.cpp:296

Scope (from outer to inner):

file
function     static void AddHairVisibilityComposeSamplePass

Source code excerpt:

	Parameters->RenderTargets.DepthStencil = FDepthStencilBinding(OutDepthTexture, ERenderTargetLoadAction::ELoad, ERenderTargetLoadAction::ELoad, FExclusiveDepthStencil::DepthWrite_StencilRead);

	const bool bDebugComposition = View.Family->EngineShowFlags.LODColoration;
	FHairVisibilityComposeSamplePS::FPermutationDomain PermutationVector;
	PermutationVector.Set<FHairVisibilityComposeSamplePS::FDebug>(bDebugComposition);
	TShaderMapRef<FHairVisibilityComposeSamplePS> PixelShader(View.ShaderMap, PermutationVector);
	InternalCommonDrawPass(
		GraphBuilder,
		RDG_EVENT_NAME("HairStrands::ComposeSample"),

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessEyeAdaptation.cpp:1201

Scope (from outer to inner):

file
function     void FViewInfo::UpdatePreExposure

Source code excerpt:

		&& !ViewFamily.EngineShowFlags.StationaryLightOverlap
		&& !ViewFamily.EngineShowFlags.LightComplexity
		&& !ViewFamily.EngineShowFlags.LODColoration
		&& !ViewFamily.EngineShowFlags.HLODColoration
		&& !ViewFamily.EngineShowFlags.ActorColoration
		&& ((!ViewFamily.EngineShowFlags.VisualizeBuffer) || CurrentBufferVisualizationMode != NAME_None) // disable pre-exposure for the buffer visualization modes
		&& !ViewFamily.EngineShowFlags.RayTracingDebug;

	// Compute the PreExposure to use.