ShowFlag.VisualizeLumen

ShowFlag.VisualizeLumen

#Overview

name: ShowFlag.VisualizeLumen

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

It is referenced in 6 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of ShowFlag.VisualizeLumen is to enable the Lumen visualization mode in Unreal Engine 5. Lumen is a dynamic global illumination and reflections system, and this flag allows developers to visualize its effects and performance.

This setting variable is primarily used by the rendering system, specifically the Lumen subsystem. Based on the callsites, it’s clear that the Renderer module heavily relies on this variable.

The value of this variable is set through the engine’s show flags system, which allows toggling various visualization modes in the viewport. It can be accessed and modified through the engine’s UI or programmatically.

The ShowFlag.VisualizeLumen variable interacts with several other variables and systems:

  1. It’s associated with the VisualizeLumen variable, which shares the same value.
  2. It’s used in conjunction with GLumenVisualize to determine if the Lumen scene should be visualized.
  3. It’s used alongside other visualization flags like VisualizeNanite and VisualizeBuffer.

Developers should be aware of the following when using this variable:

  1. It’s part of the SFG_Hidden group, meaning it might not be directly accessible in all contexts.
  2. Enabling this flag may impact performance, as it adds additional visualization passes to the rendering pipeline.
  3. It’s used in various parts of the rendering code, including temporal super-resolution and radiance cache marking.

Best practices when using this variable include:

  1. Use it primarily for debugging and performance analysis of the Lumen system.
  2. Be aware of its performance impact and disable it in release builds.
  3. Use it in conjunction with other Lumen-related visualization tools and console variables for a comprehensive understanding of the system’s behavior.

Regarding the associated variable VisualizeLumen:

The purpose of VisualizeLumen is the same as ShowFlag.VisualizeLumen - to enable the Lumen visualization mode. It’s used interchangeably with ShowFlag.VisualizeLumen in the code.

This variable is used in the Engine module, specifically in the FindViewMode function to determine the current view mode.

The value of this variable is set through the same mechanism as ShowFlag.VisualizeLumen, typically through the engine’s show flags system.

Developers should be aware that this variable is used to set the view mode to VMI_VisualizeLumen when enabled.

Best practices for using this variable are similar to those for ShowFlag.VisualizeLumen, focusing on using it for debugging and performance analysis of the Lumen system.

#References in C++ code

#Callsites

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

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

Scope: file

Source code excerpt:

SHOWFLAG_ALWAYS_ACCESSIBLE(VisualizeNanite, SFG_Hidden, NSLOCTEXT("UnrealEd", "VisualizeNaniteSF", "Nanite Visualization"))
/** Needed for VMI_VisualizeLumen, Whether to enable the Lumen visualization mode. */
SHOWFLAG_ALWAYS_ACCESSIBLE(VisualizeLumen, SFG_Hidden, NSLOCTEXT("UnrealEd", "VisualizeLumenSF", "Lumen Visualization"))
/** Needed for VMI_VisualizeSubstrate, Whether to enable the Substrate visualization mode. */
SHOWFLAG_ALWAYS_ACCESSIBLE(VisualizeSubstrate, SFG_Hidden, NSLOCTEXT("UnrealEd", "VisualizeSubstrateSF", "Substrate Visualization"))
/** Needed for VMI_VisualizeGroom, Whether to enable the Groom visualization mode. */
SHOWFLAG_ALWAYS_ACCESSIBLE(VisualizeGroom, SFG_Hidden, NSLOCTEXT("UnrealEd", "VisualizeGroomSF", "Groom Visualization"))
/** Needed for VMI_VisualizeVirtualShadowMap, Whether to enable the virtual shadow map visualization mode. */
SHOWFLAG_ALWAYS_ACCESSIBLE(VisualizeVirtualShadowMap, SFG_Hidden, NSLOCTEXT("UnrealEd", "VisualizeVirtualShadowMapSF", "Virtual Shadow Map Visualization"))

#Associated Variable and Callsites

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

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

Scope (from outer to inner):

file
function     EViewModeIndex FindViewMode

Source code excerpt:

		return VMI_VisualizeNanite;
	}
	else if (EngineShowFlags.VisualizeLumen)
	{
		return VMI_VisualizeLumen;
	}
	else if (EngineShowFlags.VisualizeSubstrate)
	{
		return VMI_VisualizeSubstrate;

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

Scope: file

Source code excerpt:

SHOWFLAG_ALWAYS_ACCESSIBLE(VisualizeNanite, SFG_Hidden, NSLOCTEXT("UnrealEd", "VisualizeNaniteSF", "Nanite Visualization"))
/** Needed for VMI_VisualizeLumen, Whether to enable the Lumen visualization mode. */
SHOWFLAG_ALWAYS_ACCESSIBLE(VisualizeLumen, SFG_Hidden, NSLOCTEXT("UnrealEd", "VisualizeLumenSF", "Lumen Visualization"))
/** Needed for VMI_VisualizeSubstrate, Whether to enable the Substrate visualization mode. */
SHOWFLAG_ALWAYS_ACCESSIBLE(VisualizeSubstrate, SFG_Hidden, NSLOCTEXT("UnrealEd", "VisualizeSubstrateSF", "Substrate Visualization"))
/** Needed for VMI_VisualizeGroom, Whether to enable the Groom visualization mode. */
SHOWFLAG_ALWAYS_ACCESSIBLE(VisualizeGroom, SFG_Hidden, NSLOCTEXT("UnrealEd", "VisualizeGroomSF", "Groom Visualization"))
/** Needed for VMI_VisualizeVirtualShadowMap, Whether to enable the virtual shadow map visualization mode. */
SHOWFLAG_ALWAYS_ACCESSIBLE(VisualizeVirtualShadowMap, SFG_Hidden, NSLOCTEXT("UnrealEd", "VisualizeVirtualShadowMapSF", "Virtual Shadow Map Visualization"))

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/Lumen/LumenRadianceCache.cpp:239

Scope (from outer to inner):

file
function     void MarkUsedProbesForVisualize

Source code excerpt:

	extern int32 GVisualizeLumenSceneTraceRadianceCache;

	if (View.Family->EngineShowFlags.VisualizeLumen && GVisualizeLumenSceneTraceRadianceCache != 0)
	{
		FMarkRadianceProbesUsedByVisualizeCS::FParameters* PassParameters = GraphBuilder.AllocParameters<FMarkRadianceProbesUsedByVisualizeCS::FParameters>();
		PassParameters->View = View.ViewUniformBuffer;
		PassParameters->RadianceCacheMarkParameters = RadianceCacheMarkParameters;

		auto ComputeShader = View.ShaderMap->GetShader<FMarkRadianceProbesUsedByVisualizeCS>(0);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/Lumen/LumenVisualize.cpp:265

Scope (from outer to inner):

file
function     bool Lumen::ShouldVisualizeScene

Source code excerpt:

bool Lumen::ShouldVisualizeScene(const FEngineShowFlags& ShowFlags)
{
	return ShowFlags.VisualizeLumen || GLumenVisualize > 0;
}

bool LumenVisualize::UseSurfaceCacheFeedback(const FEngineShowFlags& ShowFlags)
{
	return CVarVisualizeLumenSceneSurfaceCacheFeedback.GetValueOnRenderThread() != 0
		&& Lumen::ShouldVisualizeScene(ShowFlags);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/TemporalSuperResolution.cpp:1471

Scope (from outer to inner):

file
function     FDefaultTemporalUpscaler::FOutputs AddTemporalSuperResolutionPasses

Source code excerpt:

		   (!View.Family->EngineShowFlags.VisualizeBuffer    || (View.Family->EngineShowFlags.VisualizeBuffer    && View.CurrentBufferVisualizationMode == OverviewName))
		&& (!View.Family->EngineShowFlags.VisualizeNanite    || (View.Family->EngineShowFlags.VisualizeNanite    && View.CurrentNaniteVisualizationMode == OverviewName))
		&& (!View.Family->EngineShowFlags.VisualizeLumen     || (View.Family->EngineShowFlags.VisualizeLumen     && (View.CurrentLumenVisualizationMode  == OverviewName || View.CurrentLumenVisualizationMode == PerformanceOverviewName)))
		&& (!View.Family->EngineShowFlags.VisualizeGroom     || (View.Family->EngineShowFlags.VisualizeGroom     && View.CurrentGroomVisualizationMode  == OverviewName));
#endif
	if (bHasSeparateTranslucency)
	{
		SeparateTranslucencyTexture = PassInputs.PostDOFTranslucencyResources.ColorTexture.Resolve;
		SeparateTranslucencyRect = PassInputs.PostDOFTranslucencyResources.ViewRect;