ShowFlag.VisualizeCalibrationGrayscale

ShowFlag.VisualizeCalibrationGrayscale

#Overview

name: ShowFlag.VisualizeCalibrationGrayscale

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.VisualizeCalibrationGrayscale is to enable the visualization of a full-screen calibration grayscale post-process material defined in the renderer configuration. This setting is part of the rendering system, specifically for calibration and visualization purposes.

This setting variable is primarily used in the Unreal Engine’s rendering module and editor subsystems. It’s referenced in the engine’s core files, including the SceneView, EditorViewportClient, and PostProcess components.

The value of this variable is typically set through the engine’s show flags system, which allows for runtime toggling of various rendering features. It’s often controlled via the editor interface or through code that manipulates the EngineShowFlags.

ShowFlag.VisualizeCalibrationGrayscale interacts with other calibration-related variables, particularly VisualizeCalibrationColor and VisualizeCalibrationCustom. These three variables are often used together to determine which type of calibration visualization is active.

Developers should be aware that this variable is part of a group of calibration visualization options. It’s specifically for grayscale calibration, which can be useful for checking display gamma and contrast settings.

Best practices when using this variable include:

  1. Use it in conjunction with the other calibration visualization options for comprehensive display testing.
  2. Ensure the appropriate calibration material is set up in the renderer configuration.
  3. Be mindful of performance implications when enabling this visualization in production builds.

Regarding the associated variable VisualizeCalibrationGrayscale:

This is not actually a separate variable, but rather the same ShowFlag.VisualizeCalibrationGrayscale referenced in different contexts. It’s used in various parts of the engine to check if the grayscale calibration visualization is enabled.

The purpose remains the same: to control the visibility of the grayscale calibration material. It’s used in functions like IsVisualizeCalibrationMaterialEnabled and IsPostProcessVisualizeCalibrationGrayscaleMaterialEnabled to determine if the grayscale calibration visualization should be applied.

This flag is typically set through the engine’s show flags system and can be toggled in the editor or through code. It interacts closely with the other calibration visualization flags (Color and Custom) and is often checked alongside them.

Developers should be aware that this flag affects the post-processing pipeline and may impact performance when enabled. It’s primarily a development and debugging tool, so it should be used judiciously in production environments.

Best practices include using this flag during display calibration processes, ensuring it’s disabled for final builds unless specifically needed, and considering its interaction with other post-processing effects when active.

#References in C++ code

#Callsites

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

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

Scope: file

Source code excerpt:

SHOWFLAG_ALWAYS_ACCESSIBLE(VisualizeCalibrationColor, SFG_Developer, NSLOCTEXT("UnrealEd", "VisualizeCalibrationColorSF", "Visualize Calibration Color"))
/** Shows a full-screen calibration grayscale post process material defined in renderer config  */
SHOWFLAG_ALWAYS_ACCESSIBLE(VisualizeCalibrationGrayscale, SFG_Developer, NSLOCTEXT("UnrealEd", "VisualizeCalibrationGrayscaleSF", "Visualize Calibration Grayscale"))
/** Shows a full-screen calibration custom post process material defined in renderer config  */
SHOWFLAG_ALWAYS_ACCESSIBLE(VisualizeCalibrationCustom, SFG_Developer, NSLOCTEXT("UnrealEd", "VisualizeCalibrationCustomSF", "Visualize Calibration Custom"))
/** Visualise information about the post processes stacked on screen */
SHOWFLAG_FIXED_IN_SHIPPING(0, VisualizePostProcessStack, SFG_Visualize, NSLOCTEXT("UnrealEd", "VisualizePostProcessStackSF", "Visualize Post Process Stack"))

/** Draw in the main pass the primitives that would normally only contribute to runtime virtual textures. */

#Associated Variable and Callsites

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

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/EditorViewportClient.cpp:2832

Scope (from outer to inner):

file
function     bool FEditorViewportClient::IsVisualizeCalibrationMaterialEnabled

Source code excerpt:

	return ((EngineShowFlags.VisualizeCalibrationCustom && Settings->VisualizeCalibrationCustomMaterialPath.IsValid()) ||
		(EngineShowFlags.VisualizeCalibrationColor  && Settings->VisualizeCalibrationColorMaterialPath.IsValid()) ||
		(EngineShowFlags.VisualizeCalibrationGrayscale && Settings->VisualizeCalibrationGrayscaleMaterialPath.IsValid()));
}

void FEditorViewportClient::ChangeRayTracingDebugVisualizationMode(FName InName)
{
	SetViewMode(VMI_RayTracingDebug);
	CurrentRayTracingDebugVisualizationMode = InName;

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

Scope (from outer to inner):

file
function     void FSceneView::ConfigureVisualizeCalibrationSettings

Source code excerpt:

		ConfigureCalibrationSettings(Settings->VisualizeCalibrationColorMaterialPath, FinalPostProcessSettings.VisualizeCalibrationColorMaterial, CurrentVisualizeCalibrationColorMaterialName);
	}
	else if (Family->EngineShowFlags.VisualizeCalibrationGrayscale)
	{
		ConfigureCalibrationSettings(Settings->VisualizeCalibrationGrayscaleMaterialPath, FinalPostProcessSettings.VisualizeCalibrationGrayscaleMaterial, CurrentVisualizeCalibrationGrayscaleMaterialName);
	}
	else if (Family->EngineShowFlags.VisualizeCalibrationCustom)
	{
		ConfigureCalibrationSettings(Settings->VisualizeCalibrationCustomMaterialPath, FinalPostProcessSettings.VisualizeCalibrationCustomMaterial, CurrentVisualizeCalibrationCustomMaterialName);

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Public/ShowFlags.h:262

Scope (from outer to inner):

file
function     bool IsVisualizeCalibrationEnabled

Source code excerpt:

	bool IsVisualizeCalibrationEnabled() const
	{
		return (VisualizeCalibrationColor || VisualizeCalibrationGrayscale || VisualizeCalibrationCustom);
	}

	// ---------------------------------------------------------
	// The following methods are there for serialization, localization and in general to iterate and manipulate flags.
	// ---------------------------------------------------------

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

Scope: file

Source code excerpt:

SHOWFLAG_ALWAYS_ACCESSIBLE(VisualizeCalibrationColor, SFG_Developer, NSLOCTEXT("UnrealEd", "VisualizeCalibrationColorSF", "Visualize Calibration Color"))
/** Shows a full-screen calibration grayscale post process material defined in renderer config  */
SHOWFLAG_ALWAYS_ACCESSIBLE(VisualizeCalibrationGrayscale, SFG_Developer, NSLOCTEXT("UnrealEd", "VisualizeCalibrationGrayscaleSF", "Visualize Calibration Grayscale"))
/** Shows a full-screen calibration custom post process material defined in renderer config  */
SHOWFLAG_ALWAYS_ACCESSIBLE(VisualizeCalibrationCustom, SFG_Developer, NSLOCTEXT("UnrealEd", "VisualizeCalibrationCustomSF", "Visualize Calibration Custom"))
/** Visualise information about the post processes stacked on screen */
SHOWFLAG_FIXED_IN_SHIPPING(0, VisualizePostProcessStack, SFG_Visualize, NSLOCTEXT("UnrealEd", "VisualizePostProcessStackSF", "Visualize Post Process Stack"))

/** Draw in the main pass the primitives that would normally only contribute to runtime virtual textures. */

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessVisualizeCalibrationMaterial.cpp:10

Scope (from outer to inner):

file
function     static bool IsPostProcessVisualizeCalibrationGrayscaleMaterialEnabled

Source code excerpt:

static bool IsPostProcessVisualizeCalibrationGrayscaleMaterialEnabled(const FSceneView& View) 
{
	return View.Family->EngineShowFlags.VisualizeCalibrationGrayscale && View.CurrentVisualizeCalibrationGrayscaleMaterialName != NAME_None;
}

static bool IsPostProcessVisualizeCalibrationCustomMaterialEnabled(const FSceneView& View)
{
	return View.Family->EngineShowFlags.VisualizeCalibrationCustom && View.CurrentVisualizeCalibrationCustomMaterialName != NAME_None;
}