r.FastVRam.DistanceFieldNormal

r.FastVRam.DistanceFieldNormal

#Overview

name: r.FastVRam.DistanceFieldNormal

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

It is referenced in 30 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of r.FastVRam.DistanceFieldNormal is to control the texture creation flags for the distance field normal texture in Unreal Engine’s rendering system. This setting is part of the Fast VRAM configuration, which optimizes texture memory usage and performance for certain rendering features.

The Unreal Engine subsystems that rely on this setting are primarily the renderer and the distance field lighting system. It is used in various parts of the distance field ambient occlusion (DFAO) and lighting calculations.

The value of this variable is set through a console variable (CVar) named CVarFastVRam_DistanceFieldNormal. It is typically initialized with a value of 1, indicating that the feature is enabled by default.

This variable interacts with the DistanceFieldNormal texture, which is created and used in various distance field lighting calculations. It affects how this texture is allocated and accessed in memory.

Developers should be aware that changing this setting can impact performance and memory usage. Enabling it (setting to 1) allows the engine to optimize the distance field normal texture for faster access, potentially improving performance in scenes that heavily use distance field lighting techniques.

Best practices for using this variable include:

  1. Leaving it enabled (set to 1) for most scenarios, as it’s optimized by default.
  2. Only disabling it if there are specific memory constraints or if it’s causing issues on certain hardware.
  3. Profiling the performance impact when making changes to this setting, especially in scenes with complex lighting.

The associated variable DistanceFieldNormal is used throughout the rendering code to reference the actual texture that stores the distance field normal data. This texture is crucial for various distance field lighting calculations, including ambient occlusion, shadows, and global illumination.

When working with DistanceFieldNormal, developers should:

  1. Ensure that distance field features are properly set up in the project settings.
  2. Be aware of the performance implications of heavy distance field usage, especially on lower-end hardware.
  3. Consider the resolution and quality settings of distance fields, as they can significantly impact both visual quality and performance.
  4. Use profiling tools to monitor the memory usage and rendering time associated with distance field calculations when optimizing 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:482

Scope: file

Source code excerpt:

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); 
FASTVRAM_CVAR(DistanceFieldShadows, 1);
FASTVRAM_CVAR(Distortion, 1);

#Associated Variable and Callsites

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

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DeferredShadingRenderer.h:721

Scope (from outer to inner):

file
class        class FDeferredShadingSceneRenderer : public FSceneRenderer

Source code excerpt:

		const FTileIntersectionParameters& TileIntersectionParameters,
		const FDistanceFieldAOParameters& Parameters,
		FRDGTextureRef DistanceFieldNormal,
		FRDGTextureRef& OutDynamicBentNormalAO);

	void RenderManyLights(
		FRDGBuilder& GraphBuilder,
		const FSceneTextures& SceneTextures);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldAmbientOcclusion.cpp:390

Scope (from outer to inner):

file
function     void ComputeDistanceFieldNormal

Source code excerpt:

	const FViewInfo& View,
	TRDGUniformBufferRef<FSceneTextureUniformParameters> SceneTexturesUniformBuffer,
	FRDGTextureRef DistanceFieldNormal,
	const FDistanceFieldAOParameters& Parameters)
{
	const FIntPoint DFAOViewSize = View.ViewRect.Size() / GAODownsampleFactor;

	if (GAOComputeShaderNormalCalculation)
	{

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldAmbientOcclusion.cpp:405

Scope (from outer to inner):

file
function     void ComputeDistanceFieldNormal

Source code excerpt:

		PassParameters->Substrate = Substrate::BindSubstrateGlobalUniformParameters(View);
		PassParameters->AOParameters = DistanceField::SetupAOShaderParameters(Parameters);
		PassParameters->RWDistanceFieldNormal = GraphBuilder.CreateUAV(DistanceFieldNormal);

		TShaderMapRef<FComputeDistanceFieldNormalCS> ComputeShader(View.ShaderMap);

		FComputeShaderUtils::AddPass(GraphBuilder, RDG_EVENT_NAME("ComputeNormalCS"), ComputeShader, PassParameters, FIntVector(GroupSizeX, GroupSizeY, 1));
	}
	else

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldAmbientOcclusion.cpp:418

Scope (from outer to inner):

file
function     void ComputeDistanceFieldNormal

Source code excerpt:

		PassParameters->Substrate = Substrate::BindSubstrateGlobalUniformParameters(View);
		PassParameters->AOParameters = DistanceField::SetupAOShaderParameters(Parameters);
		PassParameters->RenderTargets[0] = FRenderTargetBinding(DistanceFieldNormal, ERenderTargetLoadAction::EClear);

		GraphBuilder.AddPass(
			RDG_EVENT_NAME("ComputeNormal"),
			PassParameters,
			ERDGPassFlags::Raster,
			[&View, PassParameters, DFAOViewSize](FRHICommandList& RHICmdList)

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldAmbientOcclusion.cpp:861

Scope (from outer to inner):

file
function     void FDeferredShadingSceneRenderer::RenderDistanceFieldLighting

Source code excerpt:

		RDG_EVENT_SCOPE_CONDITIONAL(GraphBuilder, Views.Num() > 1, "View%d", ViewIndex);

		FRDGTextureRef DistanceFieldNormal = nullptr;

		{
			const FIntPoint BufferSize = GetBufferSizeForAO(View);
			const FRDGTextureDesc Desc = FRDGTextureDesc::Create2D(BufferSize, PF_FloatRGBA, FClearValueBinding::Transparent, GFastVRamConfig.DistanceFieldNormal | TexCreate_RenderTargetable | TexCreate_UAV | TexCreate_ShaderResource);
			DistanceFieldNormal = GraphBuilder.CreateTexture(Desc, TEXT("DistanceFieldNormal"));
		}

		ComputeDistanceFieldNormal(GraphBuilder, View, SceneTextures.UniformBuffer, DistanceFieldNormal, Parameters);

		const FIntPoint TileListGroupSize = GetTileListGroupSizeForView(View);
		const int32 MaxSceneObjects = FMath::DivideAndRoundUp(Scene->DistanceFieldSceneData.NumObjectsInBuffer, 256) * 256;
		const bool bAllow16BitIndices = !IsMetalPlatform(GShaderPlatformForFeatureLevel[View.FeatureLevel]);

		FRDGBufferRef ObjectTilesIndirectArguments = nullptr;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldAmbientOcclusion.cpp:893

Scope (from outer to inner):

file
function     void FDeferredShadingSceneRenderer::RenderDistanceFieldLighting

Source code excerpt:

			CullObjectsToView(GraphBuilder, *Scene, View, Parameters, CulledObjectBufferParameters);

			BuildTileObjectLists(GraphBuilder, *Scene, View, SceneTextures.UniformBuffer, ObjectIndirectArguments, CulledObjectBufferParameters, TileIntersectionParameters, DistanceFieldNormal, Parameters);
		}

		// Render to a per-view BentNormal first because it also needs to be stored by the view history.
		// The per-view output can be copied back to the appropriate region in the output BentNormal texture.
		FRDGTextureRef PerViewBentNormal = nullptr;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldAmbientOcclusion.cpp:908

Scope (from outer to inner):

file
function     void FDeferredShadingSceneRenderer::RenderDistanceFieldLighting

Source code excerpt:

			TileIntersectionParameters,
			Parameters,
			DistanceFieldNormal,
			PerViewBentNormal);

		RenderCapsuleShadowsForMovableSkylight(GraphBuilder, View, SceneTextures.UniformBuffer, PerViewBentNormal);

		// Upsample to full resolution, write to output in case of debug AO visualization or scene color modulation (standard upsampling is done later together with sky lighting and reflection environment)
		if (bModulateToSceneColor || bVisualizeAmbientOcclusion)

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldAmbientOcclusion.h:114

Scope: file

Source code excerpt:

	const FDistanceFieldCulledObjectBufferParameters& CulledObjectBufferParameters,
	FTileIntersectionParameters TileIntersectionParameters,
	FRDGTextureRef DistanceFieldNormal,
	const FDistanceFieldAOParameters& Parameters);
extern FIntPoint GetTileListGroupSizeForView(const FViewInfo& View);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldLightingPost.cpp:86

Scope (from outer to inner):

file
function     FGeometryAwareUpsampleParameters SetupGeometryAwareUpsampleParameters

Source code excerpt:

END_SHADER_PARAMETER_STRUCT()

FGeometryAwareUpsampleParameters SetupGeometryAwareUpsampleParameters(const FViewInfo& View, FRDGTextureRef DistanceFieldNormal, FRDGTextureRef DistanceFieldAOBentNormal)
{
	extern FVector2f GetJitterOffset(const FViewInfo& View);
	FVector2f const JitterOffsetValue = GetJitterOffset(View);

	const FIntPoint DownsampledBufferSize = GetBufferSizeForAO(View);
	const FVector2f BaseLevelTexelSizeValue(1.0f / DownsampledBufferSize.X, 1.0f / DownsampledBufferSize.Y);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldLightingPost.cpp:104

Scope (from outer to inner):

file
function     FGeometryAwareUpsampleParameters SetupGeometryAwareUpsampleParameters

Source code excerpt:


	FGeometryAwareUpsampleParameters ShaderParameters;
	ShaderParameters.DistanceFieldNormalTexture = DistanceFieldNormal;
	ShaderParameters.DistanceFieldNormalSampler = TStaticSamplerState<SF_Point, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI();
	ShaderParameters.BentNormalAOTexture = DistanceFieldAOBentNormal;
	ShaderParameters.BentNormalAOSampler = TStaticSamplerState<SF_Bilinear, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI();
	ShaderParameters.UVToScreenPos = FScreenTransform::ChangeTextureBasisFromTo(FScreenPassTextureViewport(DownsampledBufferSize, AOViewRect), FScreenTransform::ETextureBasis::TextureUV, FScreenTransform::ETextureBasis::ScreenPosition);
	ShaderParameters.BentNormalBufferAndTexelSize = BentNormalBufferAndTexelSizeValue;
	ShaderParameters.DistanceFieldGBufferTexelSize = BaseLevelTexelSizeValue;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldLightingPost.cpp:224

Scope (from outer to inner):

file
function     void GeometryAwareUpsample

Source code excerpt:

}

void GeometryAwareUpsample(FRDGBuilder& GraphBuilder, const FViewInfo& View, FRDGTextureRef DistanceFieldAOBentNormal, FRDGTextureRef DistanceFieldNormal, FRDGTextureRef BentNormalInterpolation, const FDistanceFieldAOParameters& Parameters)
{
	auto* PassParameters = GraphBuilder.AllocParameters<FGeometryAwareUpsamplePS::FParameters>();
	PassParameters->View = View.ViewUniformBuffer;
	PassParameters->AOParameters = DistanceField::SetupAOShaderParameters(Parameters);
	PassParameters->GeometryAwareUpsampleParameters = SetupGeometryAwareUpsampleParameters(View, DistanceFieldNormal, BentNormalInterpolation);
	PassParameters->RenderTargets[0] = FRenderTargetBinding(DistanceFieldAOBentNormal, ERenderTargetLoadAction::ELoad);

	auto VertexShader = View.ShaderMap->GetShader<FPostProcessVS>();
	auto PixelShader = View.ShaderMap->GetShader<FGeometryAwareUpsamplePS>();

	ClearUnusedGraphResources(PixelShader, PassParameters);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldLightingPost.cpp:310

Scope (from outer to inner):

file
function     void UpdateHistory

Source code excerpt:

	TRDGUniformBufferRef<FSceneTextureUniformParameters> SceneTexturesUniformBuffer,
	FRDGTextureRef VelocityTexture,
	FRDGTextureRef DistanceFieldNormal,
	FRDGTextureRef BentNormalInterpolation,
	/** Contains last frame's history, if non-NULL.  This will be updated with the new frame's history. */
	FIntRect* DistanceFieldAOHistoryViewRect,
	TRefCountPtr<IPooledRenderTarget>* BentNormalHistoryState,
	/** Output of Temporal Reprojection for the next step in the pipeline. */
	FRDGTextureRef& BentNormalHistoryOutput,

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldLightingPost.cpp:347

Scope (from outer to inner):

file
function     void UpdateHistory

Source code excerpt:

				PassParameters->SceneTextures = SceneTexturesUniformBuffer;
				PassParameters->AOParameters = DistanceField::SetupAOShaderParameters(Parameters);
				PassParameters->GeometryAwareUpsampleParameters = SetupGeometryAwareUpsampleParameters(View, DistanceFieldNormal, BentNormalInterpolation);
				PassParameters->BentNormalHistoryTexture = BentNormalHistoryTexture;
				PassParameters->BentNormalHistorySampler = TStaticSamplerState<SF_Bilinear, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI();
				PassParameters->VelocityTexture = GetIfProduced(VelocityTexture, SystemTextures.Black);
				PassParameters->VelocityTextureSampler = TStaticSamplerState<SF_Bilinear, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI();

				PassParameters->HistoryWeight = GAOHistoryWeight;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldLightingPost.cpp:506

Scope (from outer to inner):

file
function     void UpdateHistory

Source code excerpt:

			AllocateOrReuseAORenderTarget(GraphBuilder, View, DistanceFieldAOBentNormal, TEXT("PerViewDistanceFieldBentNormalAO"), PF_FloatRGBA, GFastVRamConfig.DistanceFieldAOHistory);

			GeometryAwareUpsample(GraphBuilder, View, DistanceFieldAOBentNormal, DistanceFieldNormal, BentNormalInterpolation, Parameters);

			GraphBuilder.QueueTextureExtraction(DistanceFieldAOBentNormal, BentNormalHistoryState);
			BentNormalHistoryOutput = DistanceFieldAOBentNormal;
		}

		DistanceFieldAOHistoryViewRect->Min = FIntPoint::ZeroValue;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldLightingPost.cpp:521

Scope (from outer to inner):

file
function     void UpdateHistory

Source code excerpt:

		AllocateOrReuseAORenderTarget(GraphBuilder, View, DistanceFieldAOBentNormal, TEXT("PerViewDistanceFieldBentNormalAO"), PF_FloatRGBA, GFastVRamConfig.DistanceFieldAOHistory);

		GeometryAwareUpsample(GraphBuilder, View, DistanceFieldAOBentNormal, DistanceFieldNormal, BentNormalInterpolation, Parameters);

		BentNormalHistoryOutput = DistanceFieldAOBentNormal;
	}
}

class FDistanceFieldAOUpsamplePS : public FGlobalShader

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldLightingPost.h:20

Scope: file

Source code excerpt:

	FRDGTextureRef VelocityTexture,
	FRDGTextureRef BentNormalInterpolation,
	FRDGTextureRef DistanceFieldNormal,
	/** Contains last frame's history, if non-NULL.  This will be updated with the new frame's history. */
	FIntRect* DistanceFieldAOHistoryViewRect,
	TRefCountPtr<IPooledRenderTarget>* BentNormalHistoryState,
	/** Output of Temporal Reprojection for the next step in the pipeline. */
	FRDGTextureRef& BentNormalHistoryOutput,
	const FDistanceFieldAOParameters& Parameters);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldObjectCulling.cpp:351

Scope (from outer to inner):

file
function     void BuildTileObjectLists

Source code excerpt:

	const FDistanceFieldCulledObjectBufferParameters& CulledObjectBufferParameters,
	FTileIntersectionParameters TileIntersectionParameters,
	FRDGTextureRef DistanceFieldNormal,
	const FDistanceFieldAOParameters& Parameters)
{
	ensure(GAOScatterTileCulling);

	RDG_EVENT_SCOPE(GraphBuilder, "BuildTileList");
	RDG_GPU_MASK_SCOPE(GraphBuilder, View.GPUMask);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldObjectCulling.cpp:367

Scope (from outer to inner):

file
function     void BuildTileObjectLists

Source code excerpt:

		PassParameters->RWTileConeDepthRanges = TileIntersectionParameters.RWTileConeDepthRanges;
		PassParameters->SceneTextures = SceneTexturesUniformBuffer;
		PassParameters->DistanceFieldNormalTexture = DistanceFieldNormal;
		PassParameters->DistanceFieldNormalSampler = TStaticSamplerState<SF_Point, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI();
		PassParameters->AOParameters = DistanceField::SetupAOShaderParameters(Parameters);
		PassParameters->NumGroups = FVector2f(TileListGroupSize.X, TileListGroupSize.Y);

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

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldScreenGridLighting.cpp:122

Scope: file

Source code excerpt:

END_SHADER_PARAMETER_STRUCT()

static FScreenGridParameters SetupScreenGridParameters(const FViewInfo& View, FRDGTextureRef DistanceFieldNormal)
{
	const FIntPoint DownsampledBufferSize = GetBufferSizeForAO(View);

	FScreenGridParameters ShaderParameters;
	ShaderParameters.DistanceFieldNormalTexture = DistanceFieldNormal;
	ShaderParameters.DistanceFieldNormalSampler = TStaticSamplerState<SF_Point, AM_Wrap, AM_Wrap, AM_Wrap>::GetRHI();
	ShaderParameters.BaseLevelTexelSize = FVector2f(1.0f / DownsampledBufferSize.X, 1.0f / DownsampledBufferSize.Y);
	ShaderParameters.JitterOffset = GetJitterOffset(View);

	return ShaderParameters;
}

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldScreenGridLighting.cpp:267

Scope (from outer to inner):

file
function     void PostProcessBentNormalAOScreenGrid

Source code excerpt:

	FRDGTextureRef VelocityTexture,
	FRDGTextureRef BentNormalInterpolation,
	FRDGTextureRef DistanceFieldNormal,
	FRDGTextureRef& BentNormalOutput)
{
	FSceneViewState* ViewState = (FSceneViewState*)View.State;
	FIntRect* DistanceFieldAOHistoryViewRect = ViewState ? &ViewState->DistanceFieldAOHistoryViewRect : nullptr;
	TRefCountPtr<IPooledRenderTarget>* BentNormalHistoryState = ViewState ? &ViewState->DistanceFieldAOHistoryRT : NULL;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldScreenGridLighting.cpp:280

Scope (from outer to inner):

file
function     void PostProcessBentNormalAOScreenGrid

Source code excerpt:

		SceneTexturesUniformBuffer,
		VelocityTexture,
		DistanceFieldNormal,
		BentNormalInterpolation,
		DistanceFieldAOHistoryViewRect,
		BentNormalHistoryState,
		BentNormalOutput,
		Parameters);
}

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

Scope (from outer to inner):

file
function     void FDeferredShadingSceneRenderer::RenderDistanceFieldAOScreenGrid

Source code excerpt:

	const FTileIntersectionParameters& TileIntersectionParameters,
	const FDistanceFieldAOParameters& Parameters,
	FRDGTextureRef DistanceFieldNormal,
	FRDGTextureRef& OutDynamicBentNormalAO)
{
	const bool bUseGlobalDistanceField = UseGlobalDistanceField(Parameters) && Scene->DistanceFieldSceneData.NumObjectsInBuffer > 0;
	const bool bUseObjectDistanceField = UseAOObjectDistanceField();

	const FIntPoint ConeTraceBufferSize = GetBufferSizeForConeTracing(View);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldScreenGridLighting.cpp:334

Scope (from outer to inner):

file
function     void FDeferredShadingSceneRenderer::RenderDistanceFieldAOScreenGrid

Source code excerpt:

		PassParameters->AOScreenGridParameters = AOScreenGridParameters;
		PassParameters->AOParameters = DistanceField::SetupAOShaderParameters(Parameters);
		PassParameters->ScreenGridParameters = SetupScreenGridParameters(View, DistanceFieldNormal);
		PassParameters->GlobalDistanceFieldParameters = SetupGlobalDistanceFieldParameters(View.GlobalDistanceFieldInfo.ParameterData);
		PassParameters->AOSampleParameters = SetupAOSampleParameters(View.Family->FrameNumber);
		PassParameters->TileConeDepthRanges = TileIntersectionParameters.TileConeDepthRanges;
		PassParameters->SceneTextures = SceneTextures.UniformBuffer;
		PassParameters->TileListGroupSize = TileListGroupSize;
		PassParameters->TanConeHalfAngle = FMath::Tan(GAOConeHalfAngle);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldScreenGridLighting.cpp:365

Scope (from outer to inner):

file
function     void FDeferredShadingSceneRenderer::RenderDistanceFieldAOScreenGrid

Source code excerpt:

		PassParameters->AOScreenGridParameters = AOScreenGridParameters;
		PassParameters->AOParameters = DistanceField::SetupAOShaderParameters(Parameters);
		PassParameters->ScreenGridParameters = SetupScreenGridParameters(View, DistanceFieldNormal);
		if (bUseGlobalDistanceField)
		{
			PassParameters->GlobalDistanceFieldParameters = SetupGlobalDistanceFieldParameters(View.GlobalDistanceFieldInfo.ParameterData);
		}
		PassParameters->AOSampleParameters = SetupAOSampleParameters(View.Family->FrameNumber);
		PassParameters->SceneTextures = SceneTextures.UniformBuffer;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldScreenGridLighting.cpp:403

Scope (from outer to inner):

file
function     void FDeferredShadingSceneRenderer::RenderDistanceFieldAOScreenGrid

Source code excerpt:

		PassParameters->View = View.ViewUniformBuffer;
		PassParameters->AOScreenGridParameters = AOScreenGridParameters;
		PassParameters->ScreenGridParameters = SetupScreenGridParameters(View, DistanceFieldNormal);
		PassParameters->AOSampleParameters = SetupAOSampleParameters(View.Family->FrameNumber);
		PassParameters->RWDistanceFieldBentNormal = GraphBuilder.CreateUAV(DownsampledBentNormal);
		PassParameters->ConeBufferMax = FIntPoint(ConeTraceBufferSize.X - 1, ConeTraceBufferSize.Y - 1);
		PassParameters->DFNormalBufferUVMax = DFNormalBufferUVMaxValue;

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

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/DistanceFieldScreenGridLighting.cpp:421

Scope (from outer to inner):

file
function     void FDeferredShadingSceneRenderer::RenderDistanceFieldAOScreenGrid

Source code excerpt:

		SceneTextures.Velocity,
		DownsampledBentNormal,
		DistanceFieldNormal,
		OutDynamicBentNormalAO);
}

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

Scope: file

Source code excerpt:

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); 
FASTVRAM_CVAR(DistanceFieldShadows, 1);
FASTVRAM_CVAR(Distortion, 1);

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

Scope (from outer to inner):

file
function     void FFastVramConfig::Update

Source code excerpt:

	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);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_DistanceFieldShadows, DistanceFieldShadows);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_Distortion, Distortion);

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

Scope: file

Source code excerpt:

	ETextureCreateFlags Tonemap;
	ETextureCreateFlags Upscale;
	ETextureCreateFlags DistanceFieldNormal;
	ETextureCreateFlags DistanceFieldAOHistory;
	ETextureCreateFlags DistanceFieldAOBentNormal;
	ETextureCreateFlags DistanceFieldAODownsampledBentNormal;
	ETextureCreateFlags DistanceFieldShadows;
	ETextureCreateFlags DistanceFieldIrradiance;
	ETextureCreateFlags DistanceFieldAOConfidence;