r.FastVRam.Tonemap

r.FastVRam.Tonemap

#Overview

name: r.FastVRam.Tonemap

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

It is referenced in 35 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of r.FastVRam.Tonemap is to control the memory allocation strategy for the tonemapping pass in Unreal Engine’s rendering pipeline. Specifically:

  1. This setting variable is used by the rendering system, particularly in the post-processing and tonemapping stages.

  2. The Renderer module in Unreal Engine relies on this setting variable. It’s referenced in various parts of the post-processing pipeline, including the tonemapping pass and device encoding.

  3. The value of this variable is set through a Console Variable (CVar) system, likely initialized at engine startup and potentially modifiable at runtime.

  4. It interacts closely with the Tonemap variable, which is used in various parts of the rendering code to determine whether tonemapping should be applied.

  5. Developers should be aware that this variable affects the memory allocation for tonemapping textures. Setting it to 1 (default) suggests using fast VRAM for these textures, which can improve performance but may increase memory usage in the GPU’s faster memory.

  6. Best practices include:

    • Only modify this if you understand the implications on memory usage and performance.
    • Monitor GPU memory usage when adjusting this setting.
    • Consider platform-specific behavior, as fast VRAM allocation strategies may differ between hardware.

Regarding the associated Tonemap variable:

The Tonemap variable is central to the engine’s HDR pipeline and affects the final look of the rendered image. Any modifications to its usage should be done carefully, considering the impact on visual quality and performance.

#References in C++ code

#Callsites

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

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

Scope: file

Source code excerpt:

FASTVRAM_CVAR(VelocityMax, 1);
FASTVRAM_CVAR(MotionBlur, 1);
FASTVRAM_CVAR(Tonemap, 1);
FASTVRAM_CVAR(Upscale, 1);
FASTVRAM_CVAR(DistanceFieldNormal, 1);
FASTVRAM_CVAR(DistanceFieldAOHistory, 1);
FASTVRAM_CVAR(DistanceFieldAODownsampledBentNormal, 1); 
FASTVRAM_CVAR(DistanceFieldAOBentNormal, 0); 
FASTVRAM_CVAR(DistanceFieldIrradiance, 0);

#Associated Variable and Callsites

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

#Loc: <Workspace>/Engine/Plugins/Compositing/OpenColorIO/Source/OpenColorIO/Private/OpenColorIODisplayExtension.cpp:68

Scope (from outer to inner):

file
function     void FOpenColorIODisplayExtension::SubscribeToPostProcessingPass

Source code excerpt:

void FOpenColorIODisplayExtension::SubscribeToPostProcessingPass(EPostProcessingPass PassId, FAfterPassCallbackDelegateArray& InOutPassCallbacks, bool bIsPassEnabled)
{
	if (PassId == EPostProcessingPass::Tonemap)
	{
		InOutPassCallbacks.Add(FAfterPassCallbackDelegate::CreateRaw(this, &FOpenColorIODisplayExtension::PostProcessPassAfterTonemap_RenderThread));
	}
}

FScreenPassTexture FOpenColorIODisplayExtension::PostProcessPassAfterTonemap_RenderThread(FRDGBuilder& GraphBuilder, const FSceneView& View, const FPostProcessMaterialInputs& InOutInputs)

#Loc: <Workspace>/Engine/Plugins/Experimental/CineCameraSceneCapture/Source/CineCameraSceneCapture/Private/CineCameraSceneCaptureComponent.cpp:100

Scope (from outer to inner):

file
class        class FCineCameraCaptureSceneViewExtension : public ISceneViewExtension, public TSharedFromThis<FCineCameraCaptureSceneViewExtension, ESPMode::ThreadSafe>
function     virtual void SubscribeToPostProcessingPass

Source code excerpt:

		}

		if (PassId == EPostProcessingPass::Tonemap)
		{
			InOutPassCallbacks.Add(FAfterPassCallbackDelegate::CreateRaw(this, &FCineCameraCaptureSceneViewExtension::PostProcessPassAfterTonemap_RenderThread));
		}
	}

	FScreenPassTexture PostProcessPassAfterTonemap_RenderThread(FRDGBuilder& GraphBuilder, const FSceneView& View, const FPostProcessMaterialInputs& InOutInputs)

#Loc: <Workspace>/Engine/Plugins/Media/BinkMedia/Source/BinkMediaPlayer/Private/Assets/BinkMediaTexture.cpp:11

Scope (from outer to inner):

file
function     UBinkMediaTexture::UBinkMediaTexture

Source code excerpt:

	: Super(ObjectInitializer)
	, MediaPlayer(nullptr)
	, Tonemap(false)
	, OutputNits(10000)
	, Alpha(1)
	, CachedDimensions()
	, CurrentMediaPlayer()
	, ReleasePlayerFence()
{

#Loc: <Workspace>/Engine/Plugins/Media/BinkMedia/Source/BinkMediaPlayer/Private/Assets/BinkMediaTextureResource.cpp:100

Scope (from outer to inner):

file
function     void FBinkMediaTextureResource::UpdateDeferredResource

Source code excerpt:

	uint32 height = tex->GetSizeY();
	bool is_hdr = PixelFormat != PF_B8G8R8A8;
	Player->UpdateTexture(RHICmdList, tex, tex->GetNativeResource(), width, height, false, Owner->Tonemap, Owner->OutputNits, Owner->Alpha, Owner->DecodeSRGB, is_hdr);
}

void FBinkMediaTextureResource::Clear() 
{
	int w = Owner->GetSurfaceWidth() > 0 ? Owner->GetSurfaceWidth() : 1;
	int h = Owner->GetSurfaceHeight() > 0 ? Owner->GetSurfaceHeight() : 1;

#Loc: <Workspace>/Engine/Plugins/Media/BinkMedia/Source/BinkMediaPlayer/Public/BinkMediaTexture.h:81

Scope (from outer to inner):

file
class        class UBinkMediaTexture : public UTexture

Source code excerpt:

	/** Whether to enable tonemaping for the video. */
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=MediaPlayer)
	bool Tonemap;

	/** When tonemapping, set this for to desired output nits capability for the current display. Typically 80 for SDR, or 2000 for HDR. */
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = MediaPlayer)
	float OutputNits;

	/** alpha_value is just a constant blend value for entire video frame. 1 (default) opaque, 0 fully transparent. */

#Loc: <Workspace>/Engine/Plugins/Media/MediaIOFramework/Source/MediaIOCore/Private/MediaCaptureSceneViewExtension.h:76

Scope (from outer to inner):

file
class        class FMediaCaptureSceneViewExtension : public FSceneViewExtensionBase
function     virtual void SubscribeToPostProcessingPass

Source code excerpt:

	{
		if ((CapturePhase == EMediaCapturePhase::AfterMotionBlur && PassId == EPostProcessingPass::MotionBlur)
			|| (CapturePhase == EMediaCapturePhase::AfterToneMap && PassId == EPostProcessingPass::Tonemap)
			|| (CapturePhase == EMediaCapturePhase::AfterFXAA && PassId == EPostProcessingPass::FXAA)
			|| (CapturePhase == EMediaCapturePhase::BeforePostProcessing && PassId == EPostProcessingPass::SSRInput))
		{
			InOutPassCallbacks.Add(FAfterPassCallbackDelegate::CreateSP(this, &FMediaCaptureSceneViewExtension::PostProcessCallback_RenderThread));
		}
	}

#Loc: <Workspace>/Engine/Plugins/Runtime/nDisplay/Source/DisplayCluster/Private/Render/Viewport/DisplayClusterViewportFrameStatsViewExtension.cpp:83

Scope (from outer to inner):

file
function     void FDisplayClusterViewportFrameStatsViewExtension::SubscribeToPostProcessingPass

Source code excerpt:

void FDisplayClusterViewportFrameStatsViewExtension::SubscribeToPostProcessingPass(EPostProcessingPass PassId, FAfterPassCallbackDelegateArray& InOutPassCallbacks, bool bIsPassEnabled)
{
	if (IsActive() && PassId == EPostProcessingPass::Tonemap)
	{
		InOutPassCallbacks.Add(FAfterPassCallbackDelegate::CreateRaw(this, &FDisplayClusterViewportFrameStatsViewExtension::PostProcessPassAfterTonemap_RenderThread));
	}
}

void FDisplayClusterViewportFrameStatsViewExtension::BeginRenderViewFamily(FSceneViewFamily& InViewFamily)

#Loc: <Workspace>/Engine/Plugins/Runtime/nDisplay/Source/DisplayCluster/Private/Render/Viewport/DisplayClusterViewportManagerViewExtension.cpp:96

Scope (from outer to inner):

file
function     void FDisplayClusterViewportManagerViewExtension::SubscribeToPostProcessingPass

Source code excerpt:

		break;

	case EPostProcessingPass::Tonemap:
		for (const FViewportProxy& ViewportIt : ViewportProxies)
		{
			if (FDisplayClusterViewportProxy* ViewportProxy = ViewportIt.GetViewportProxy())
			{
				if (ViewportProxy->ShouldUsePostProcessPassTonemap())
				{

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Public/SceneViewExtension.h:104

Scope (from outer to inner):

file
class        class ISceneViewExtension

Source code excerpt:

		SSRInput,
		MotionBlur,
		Tonemap,
		FXAA,
		VisualizeDepthOfField,
		MAX
	};

public:

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

Scope (from outer to inner):

file
namespace    LumenVisualize
function     FTonemappingParameters GetTonemappingParameters

Source code excerpt:

	{
		FTonemappingParameters TonemappingParameters;
		TonemappingParameters.Tonemap = (EyeAdaptationBuffer != nullptr && ColorGradingTexture != nullptr) ? 1 : 0;
		TonemappingParameters.ColorGradingLUT = ColorGradingTexture;
		TonemappingParameters.ColorGradingLUTSampler = TStaticSamplerState<SF_Bilinear, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI();
		TonemappingParameters.EyeAdaptationBuffer = GraphBuilder.CreateSRV(EyeAdaptationBuffer);

		if (!TonemappingParameters.ColorGradingLUT)
		{

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/Lumen/LumenVisualize.h:30

Scope (from outer to inner):

file
namespace    LumenVisualize

Source code excerpt:

{
	BEGIN_SHADER_PARAMETER_STRUCT(FTonemappingParameters, )
		SHADER_PARAMETER(int32, Tonemap)
		SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer<float4>, EyeAdaptationBuffer)
		SHADER_PARAMETER_RDG_TEXTURE(Texture3D, ColorGradingLUT)
		SHADER_PARAMETER_SAMPLER(SamplerState, ColorGradingLUTSampler)
	END_SHADER_PARAMETER_STRUCT()

	BEGIN_SHADER_PARAMETER_STRUCT(FSceneParameters, )

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessDeviceEncodingOnly.cpp:180

Scope (from outer to inner):

file
function     FScreenPassTexture AddDeviceEncodingOnlyPass

Source code excerpt:

		OutputDesc.ClearValue = FClearValueBinding(FLinearColor(0, 0, 0, 0));
		OutputDesc.Flags |= View.bUseComputePasses ? TexCreate_UAV : TexCreate_RenderTargetable;
		OutputDesc.Flags |= GFastVRamConfig.Tonemap;

		const FDeviceEncodingOnlyOutputDeviceParameters OutputDeviceParameters = GetDeviceEncodingOnlyOutputDeviceParameters(*View.Family);
		const EDisplayOutputFormat OutputDevice = static_cast<EDisplayOutputFormat>(OutputDeviceParameters.OutputDevice);

		if (OutputDevice == EDisplayOutputFormat::HDR_LinearEXR)
		{

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessTonemap.cpp:610

Scope (from outer to inner):

file
function     FScreenPassTexture AddTonemapPass

Source code excerpt:

			Inputs.SceneColor.TextureSRV->Desc.Texture->Desc.Format,
			FClearValueBinding(FLinearColor(0, 0, 0, 0)),
			GFastVRamConfig.Tonemap | TexCreate_ShaderResource | TexCreate_RenderTargetable | (View.bUseComputePasses ? TexCreate_UAV : TexCreate_None));;
		
		const FTonemapperOutputDeviceParameters OutputDeviceParameters = GetTonemapperOutputDeviceParameters(*View.Family);
		const EDisplayOutputFormat OutputDevice = static_cast<EDisplayOutputFormat>(OutputDeviceParameters.OutputDevice);

		if (OutputDevice == EDisplayOutputFormat::HDR_LinearEXR)
		{

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessTonemap.cpp:644

Scope (from outer to inner):

file
function     FScreenPassTexture AddTonemapPass

Source code excerpt:


		Output = FScreenPassRenderTarget(
			GraphBuilder.CreateTexture(OutputDesc, TEXT("Tonemap")),
			Inputs.SceneColor.ViewRect,
			ERenderTargetLoadAction::ENoAction);
	}

	const bool bShouldWriteAlphaChannel = ShouldWriteAlphaChannel(View, Inputs, Output.Texture);
	if (ShouldOverrideOutputLoadActionToFastClear(Output, bShouldWriteAlphaChannel))
	{
		Output.LoadAction = ERenderTargetLoadAction::EClear;
	}

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessTonemap.cpp:977

Scope (from outer to inner):

file
function     FScreenPassTexture AddTonemapPass

Source code excerpt:

	{
		FTonemapCS::FParameters* PassParameters = GraphBuilder.AllocParameters<FTonemapCS::FParameters>();
		PassParameters->Tonemap = CommonParameters;
		PassParameters->RWOutputTexture = GraphBuilder.CreateUAV(Output.Texture);

		if (OutputLuminance)
		{
			PassParameters->RWOutputLuminance = GraphBuilder.CreateUAV(OutputLuminance);
		}

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessTonemap.cpp:1001

Scope (from outer to inner):

file
function     FScreenPassTexture AddTonemapPass

Source code excerpt:

	{
		FTonemapPS::FParameters* PassParameters = GraphBuilder.AllocParameters<FTonemapPS::FParameters>();
		PassParameters->Tonemap = CommonParameters;
		PassParameters->RenderTargets[0] = Output.GetRenderTargetBinding();
		PassParameters->RenderTargets.MultiViewCount = View.bIsMobileMultiViewEnabled ? 2 : 0;

		if (OutputLuminance)
		{
			PassParameters->RenderTargets[1] = FRenderTargetBinding(OutputLuminance, ERenderTargetLoadAction::ELoad);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessTonemap.cpp:1030

Scope (from outer to inner):

file
function     FScreenPassTexture AddTonemapPass
lambda-function

Source code excerpt:

			[VertexShader, PixelShader, PassParameters](FRHICommandList& RHICmdList)
		{
			SetShaderParameters(RHICmdList, VertexShader, VertexShader.GetVertexShader(), PassParameters->Tonemap);
			SetShaderParameters(RHICmdList, PixelShader, PixelShader.GetPixelShader(), *PassParameters);
		});
	}

	if (OutputLuminance && View.ViewState)
	{

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp:363

Scope (from outer to inner):

file
function     void AddPostProcessingPasses

Source code excerpt:

		MotionBlur,
		PostProcessMaterialBeforeBloom,
		Tonemap,
		FXAA,
		PostProcessMaterialAfterTonemapping,
		VisualizeLumenScene,
		VisualizeDepthOfField,
		VisualizeStationaryLightOverlap,
		VisualizeLightCulling,

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp:404

Scope (from outer to inner):

file
function     void AddPostProcessingPasses
lambda-function

Source code excerpt:

		{
			case ISceneViewExtension::EPostProcessingPass::MotionBlur            : return EPass::MotionBlur;
			case ISceneViewExtension::EPostProcessingPass::Tonemap               : return EPass::Tonemap;
			case ISceneViewExtension::EPostProcessingPass::FXAA                  : return EPass::FXAA;
			case ISceneViewExtension::EPostProcessingPass::VisualizeDepthOfField : return EPass::VisualizeDepthOfField;

			default:
				check(false);
				return EPass::MAX;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp:639

Scope (from outer to inner):

file
function     void AddPostProcessingPasses

Source code excerpt:

		PassSequence.SetEnabled(EPass::MotionBlur, bVisualizeMotionBlur || bMotionBlurEnabled);
		PassSequence.SetEnabled(EPass::PostProcessMaterialBeforeBloom, PostProcessMaterialBeforeBloomChain.Num() != 0);
		PassSequence.SetEnabled(EPass::Tonemap, bTonemapEnabled);
		PassSequence.SetEnabled(EPass::FXAA, AntiAliasingMethod == AAM_FXAA);
		PassSequence.SetEnabled(EPass::PostProcessMaterialAfterTonemapping, PostProcessMaterialAfterTonemappingChain.Num() != 0);
		PassSequence.SetEnabled(EPass::VisualizeDepthOfField, bVisualizeDepthOfField);
		PassSequence.SetEnabled(EPass::VisualizeLocalExposure, EngineShowFlags.VisualizeLocalExposure);

		FAfterPassCallbackDelegateArray SSRInputDelegates;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp:821

Scope (from outer to inner):

file
function     void AddPostProcessingPasses

Source code excerpt:

					DownsampleQuality == EDownsampleQuality::Low;
			}
			UpscalerPassInputs.bAllowFullResSlice = PassSequence.IsEnabled(EPass::MotionBlur) || PassSequence.IsEnabled(EPass::Tonemap);
			UpscalerPassInputs.DownsampleOverrideFormat = DownsampleOverrideFormat;
			UpscalerPassInputs.PostDOFTranslucencyResources = PostDOFTranslucencyResources;
			UpscalerPassInputs.FlickeringInputTexture = TSRFlickeringInput;
			check(UpscalerPassInputs.SceneColor.ViewRect == View.ViewRect);

			FDefaultTemporalUpscaler::FOutputs Outputs;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp:1217

Scope (from outer to inner):

file
function     void AddPostProcessingPasses

Source code excerpt:

		SceneColorBeforeTonemapSlice = SceneColorSlice;

		if (PassSequence.IsEnabled(EPass::Tonemap))
		{
			const FPostProcessMaterialChain MaterialChain = GetPostProcessMaterialChain(View, BL_ReplacingTonemapper);

			if (MaterialChain.Num())
			{
				const UMaterialInterface* HighestPriorityMaterial = MaterialChain[0];

				FPostProcessMaterialInputs PassInputs;
				PassSequence.AcceptOverrideIfLastPass(EPass::Tonemap, PassInputs.OverrideOutput);
				PassInputs.SetInput(GraphBuilder, EPostProcessMaterialInput::SceneColor, FScreenPassTexture::CopyFromSlice(GraphBuilder, SceneColorSlice));
				//PassInputs.SetInput(EPostProcessMaterialInput::SeparateTranslucency, SeparateTranslucency);
				PassInputs.SetInput(GraphBuilder, EPostProcessMaterialInput::CombinedBloom, Bloom);
				PassInputs.SceneTextures = GetSceneTextureShaderParameters(Inputs.SceneTextures);
				PassInputs.CustomDepthTexture = CustomDepth.Texture;
				PassInputs.bManualStencilTest = Inputs.bSeparateCustomStencil;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp:1256

Scope (from outer to inner):

file
function     void AddPostProcessingPasses

Source code excerpt:


				FTonemapInputs PassInputs;
				PassSequence.AcceptOverrideIfLastPass(EPass::Tonemap, PassInputs.OverrideOutput);
				PassInputs.SceneColor = SceneColorSlice;
				PassInputs.Bloom = Bloom;
				PassInputs.SceneColorApplyParamaters = SceneColorApplyParameters;
				PassInputs.LocalExposureTexture = LocalExposureTexture;
				PassInputs.BlurredLogLuminanceTexture = LocalExposureBlurredLogLumTexture;
				PassInputs.LocalExposureParameters = &LocalExposureParameters;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp:1277

Scope (from outer to inner):

file
function     void AddPostProcessingPasses

Source code excerpt:

		}
		
		SceneColor = AddAfterPass(EPass::Tonemap, SceneColor);

		SceneColorAfterTonemap = SceneColor;

		if (PassSequence.IsEnabled(EPass::FXAA))
		{
			FFXAAInputs PassInputs;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp:1335

Scope (from outer to inner):

file
function     void AddPostProcessingPasses

Source code excerpt:

		PassSequence.SetEnabled(EPass::MotionBlur, false);
		PassSequence.SetEnabled(EPass::PostProcessMaterialBeforeBloom, false);
		PassSequence.SetEnabled(EPass::Tonemap, true);
		PassSequence.SetEnabled(EPass::FXAA, false);
		PassSequence.SetEnabled(EPass::PostProcessMaterialAfterTonemapping, false);
		PassSequence.SetEnabled(EPass::VisualizeDepthOfField, false);
		PassSequence.SetEnabled(EPass::VisualizeLocalExposure, false);
		PassSequence.Finalize();

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp:1366

Scope (from outer to inner):

file
function     void AddPostProcessingPasses

Source code excerpt:

		SceneColorBeforeTonemapSlice = FScreenPassTextureSlice::CreateFromScreenPassTexture(GraphBuilder, SceneColor);

		if (PassSequence.IsEnabled(EPass::Tonemap))
		{
			FTonemapInputs PassInputs;
			PassSequence.AcceptOverrideIfLastPass(EPass::Tonemap, PassInputs.OverrideOutput);
			PassInputs.SceneColor = FScreenPassTextureSlice::CreateFromScreenPassTexture(GraphBuilder, SceneColor);
			PassInputs.EyeAdaptationParameters = &EyeAdaptationParameters;
			PassInputs.EyeAdaptationBuffer = EyeAdaptationBuffer;
			PassInputs.bOutputInHDR = bViewFamilyOutputInHDR;
			PassInputs.bGammaOnly = true;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp:1379

Scope (from outer to inner):

file
function     void AddPostProcessingPasses

Source code excerpt:

		}

		SceneColor = AddAfterPass(EPass::Tonemap, SceneColor);

		SceneColorAfterTonemap = SceneColor;
	}

	if (PassSequence.IsEnabled(EPass::VisualizeStationaryLightOverlap))
	{

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp:2134

Scope (from outer to inner):

file
function     void AddMobilePostProcessingPasses

Source code excerpt:

		SeparateTranslucency,
		TAA,
		Tonemap,
		PostProcessMaterialAfterTonemapping,
		FXAA,
		HighResolutionScreenshotMask,
		SelectionOutline,
		EditorPrimitive,
#if UE_ENABLE_DEBUG_DRAWING

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp:2214

Scope (from outer to inner):

file
function     void AddMobilePostProcessingPasses

Source code excerpt:

	bShouldPrimaryUpscale |= View.Family->GetPrimarySpatialUpscalerInterface() != nullptr;

	PassSequence.SetEnabled(EPass::Tonemap, bUseToneMapper);
	PassSequence.SetEnabled(EPass::HighResolutionScreenshotMask, bUseHighResolutionScreenshotMask);
#if WITH_EDITOR
	PassSequence.SetEnabled(EPass::SelectionOutline, GIsEditor && View.Family->EngineShowFlags.Selection && View.Family->EngineShowFlags.SelectionOutline && !View.Family->EngineShowFlags.Wireframe);
	PassSequence.SetEnabled(EPass::EditorPrimitive, FSceneRenderer::ShouldCompositeEditorPrimitives(View));
#else
	PassSequence.SetEnabled(EPass::SelectionOutline, false);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp:2674

Scope (from outer to inner):

file
function     void AddMobilePostProcessingPasses

Source code excerpt:

	}
	
	if (PassSequence.IsEnabled(EPass::Tonemap))
	{
		bool bHDRTonemapperOutput = false;

		if (!BloomOutput.IsValid())
		{
			BloomOutput = BlackAlphaOneDummy;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp:2703

Scope (from outer to inner):

file
function     void AddMobilePostProcessingPasses

Source code excerpt:


		FTonemapInputs TonemapperInputs;
		PassSequence.AcceptOverrideIfLastPass(EPass::Tonemap, TonemapperInputs.OverrideOutput);

		// This is the view family render target.
		if (TonemapperInputs.OverrideOutput.Texture)
		{
			FIntRect OutputViewRect;
			if (View.PrimaryScreenPercentageMethod == EPrimaryScreenPercentageMethod::RawOutput)

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

Scope: file

Source code excerpt:

FASTVRAM_CVAR(VelocityMax, 1);
FASTVRAM_CVAR(MotionBlur, 1);
FASTVRAM_CVAR(Tonemap, 1);
FASTVRAM_CVAR(Upscale, 1);
FASTVRAM_CVAR(DistanceFieldNormal, 1);
FASTVRAM_CVAR(DistanceFieldAOHistory, 1);
FASTVRAM_CVAR(DistanceFieldAODownsampledBentNormal, 1); 
FASTVRAM_CVAR(DistanceFieldAOBentNormal, 0); 
FASTVRAM_CVAR(DistanceFieldIrradiance, 0);

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

Scope (from outer to inner):

file
function     void FFastVramConfig::Update

Source code excerpt:

	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_VelocityMax, VelocityMax);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_MotionBlur, MotionBlur);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_Tonemap, Tonemap);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_Upscale, Upscale);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_DistanceFieldNormal, DistanceFieldNormal);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_DistanceFieldAOHistory, DistanceFieldAOHistory);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_DistanceFieldAODownsampledBentNormal, DistanceFieldAODownsampledBentNormal);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_DistanceFieldAOBentNormal, DistanceFieldAOBentNormal);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_DistanceFieldIrradiance, DistanceFieldIrradiance);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/SceneRendering.h:2829

Scope: file

Source code excerpt:

	ETextureCreateFlags VelocityMax;
	ETextureCreateFlags MotionBlur;
	ETextureCreateFlags Tonemap;
	ETextureCreateFlags Upscale;
	ETextureCreateFlags DistanceFieldNormal;
	ETextureCreateFlags DistanceFieldAOHistory;
	ETextureCreateFlags DistanceFieldAOBentNormal;
	ETextureCreateFlags DistanceFieldAODownsampledBentNormal;
	ETextureCreateFlags DistanceFieldShadows;