r.FastVRam.Bloom

r.FastVRam.Bloom

#Overview

name: r.FastVRam.Bloom

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

It is referenced in 45 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of r.FastVRam.Bloom is to control whether bloom textures are allocated in fast VRAM on supported platforms.

Some key points about this setting variable:

  1. It is part of the FastVRAM system in Unreal Engine’s renderer, which allows specifying certain textures to be allocated in faster video memory on platforms that support it.

  2. It specifically controls the bloom effect textures used in the post-processing pipeline.

  3. When enabled (set to 1), it instructs the engine to try allocating bloom textures in fast VRAM.

  4. It is used in the post-processing passes, particularly in the bloom and lens flares rendering code.

  5. The value is read via the CVarFastVRam_Bloom console variable.

  6. It affects the texture creation flags used when allocating bloom-related render targets.

  7. Other post-processing effects like depth of field, eye adaptation, etc. have similar FastVRAM controls.

  8. The actual impact depends on the hardware capabilities - not all platforms have distinct “fast” and “slow” VRAM.

  9. Enabling this may improve performance of bloom effects on supported hardware by placing the textures in faster memory.

  10. However, overuse of fast VRAM allocation can potentially cause memory pressure, so it should be balanced with other rendering needs.

Developers should be aware that this is a relatively low-level optimization setting. In most cases, the default value should suffice. Tweaking it may be useful for performance optimization on specific hardware, but should be done carefully and with performance testing.

#References in C++ code

#Callsites

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

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

Scope: file

Source code excerpt:

FASTVRAM_CVAR(SceneDepth, 1);
FASTVRAM_CVAR(SceneColor, 1);
FASTVRAM_CVAR(Bloom, 1);
FASTVRAM_CVAR(BokehDOF, 1);
FASTVRAM_CVAR(CircleDOF, 1);
FASTVRAM_CVAR(CombineLUTs, 1);
FASTVRAM_CVAR(Downsample, 1);
FASTVRAM_CVAR(EyeAdaptation, 1);
FASTVRAM_CVAR(Histogram, 1);

#Associated Variable and Callsites

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

#Loc: <Workspace>/Engine/Plugins/Compositing/Composure/Source/Composure/Private/ComposureLensBloomPass.cpp:27

Scope (from outer to inner):

file
function     static void ComposureLensBloomPass_Impl::ApplyBloomSettings

Source code excerpt:

	{
		TonemapperMID->SetScalarParameterValue(IntensityParamName, SceneCapture->PostProcessSettings.BloomIntensity);
	}

	// Enables bloom.
	SceneCapture->ShowFlags.Bloom = true;
}

/* UComposureLensBloomPass
 *****************************************************************************/

UComposureLensBloomPass::UComposureLensBloomPass(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	// Replace the tonemapper with a post process material that outputs bloom only.
	COMPOSURE_CREATE_DYMAMIC_MATERIAL(Material, TonemapperReplacingMID, "ReplaceTonemapper/", "ComposureReplaceTonemapperComposeBloom");
	TonemapperReplacement = TonemapperReplacingMID;

#Loc: <Workspace>/Engine/Plugins/Compositing/Composure/Source/Composure/Private/ComposureUtils.cpp:16

Scope (from outer to inner):

file
function     void FComposureUtils::SetEngineShowFlagsForPostprocessingOnly

Source code excerpt:

	EngineShowFlags.DeferredLighting = false;
	EngineShowFlags.Decals = false;
	EngineShowFlags.Translucency = false;
	EngineShowFlags.AntiAliasing = false;
	EngineShowFlags.MotionBlur = false;
	EngineShowFlags.Bloom = false;
	EngineShowFlags.EyeAdaptation = false;
	EngineShowFlags.VolumetricFog = false;
	EngineShowFlags.Atmosphere = false;
	EngineShowFlags.Fog = false;

#if !UE_BUILD_OPTIMIZED_SHOWFLAGS
	// Development-only flags
	EngineShowFlags.ReflectionOverride = false;
	EngineShowFlags.DepthOfField = false;
#endif
}

#Loc: <Workspace>/Engine/Plugins/Experimental/Water/Source/Editor/Private/WaterBrushManager.cpp:52

Scope (from outer to inner):

file
function     AWaterBrushManager::AWaterBrushManager

Source code excerpt:

	SceneCaptureComponent2D->SetRelativeScale3D(FVector(0.01f, 0.01f, 0.01f));
	// HACK [jonathan.bard] : Nanite doesn't support USceneCaptureComponent's ShowOnlyComponents ATM so just disable Nanite during captures : 
	SceneCaptureComponent2D->ShowFlagSettings.Add(FEngineShowFlagsSetting { TEXT("NaniteMeshes"), false } );
	// These also need to be disabled to get a clean capture of just the water info material output
	SceneCaptureComponent2D->ShowFlagSettings.Add(FEngineShowFlagsSetting { TEXT("Atmosphere"), false } );
	SceneCaptureComponent2D->ShowFlagSettings.Add(FEngineShowFlagsSetting { TEXT("Bloom"), false } );
	SceneCaptureComponent2D->ShowFlagSettings.Add(FEngineShowFlagsSetting { TEXT("Lighting"), false } );

	PrimaryActorTick.TickGroup = ETickingGroup::TG_PrePhysics;
	bIsEditorOnlyActor = false;
}

void AWaterBrushManager::Serialize(FArchive& Ar)
{
	Super::Serialize(Ar);

	Ar.UsingCustomVersion(FWaterCustomVersion::GUID);

#Loc: <Workspace>/Engine/Plugins/Experimental/Water/Source/Runtime/Private/WaterInfoRendering.cpp:642

Scope (from outer to inner):

file
namespace    UE::WaterInfo
function     static FSceneRenderer* CreateWaterInfoSceneRenderer

Source code excerpt:


	FEngineShowFlags ShowFlags(ESFIM_Game);
	ShowFlags.NaniteMeshes = 0;
	ShowFlags.Atmosphere = 0;
	ShowFlags.Lighting = 0;
	ShowFlags.Bloom = 0;
	ShowFlags.ScreenPercentage = 0;
	ShowFlags.Translucency = 0;
	ShowFlags.SeparateTranslucency = 0;
	ShowFlags.AntiAliasing = 0;
	ShowFlags.Fog = 0;
	ShowFlags.VolumetricFog = 0;
	ShowFlags.DynamicShadows = 0;

	ShowFlags.SetDisableOcclusionQueries(true);
	ShowFlags.SetVirtualShadowMapPersistentData(false);

#Loc: <Workspace>/Engine/Plugins/Runtime/OpenXR/Source/OpenXRHMD/Private/OpenXRHMD.cpp:1233

Scope (from outer to inner):

file
function     void FOpenXRHMD::SetupViewFamily

Source code excerpt:


	const FPipelinedFrameState& FrameState = GetPipelinedFrameStateForThread();
	if (FrameState.Views.Num() > 2)
	{
		InViewFamily.EngineShowFlags.Vignette = 0;
		InViewFamily.EngineShowFlags.Bloom = 0;
	}
}

void FOpenXRHMD::SetupView(FSceneViewFamily& InViewFamily, FSceneView& InView)
{
}

void FOpenXRHMD::BeginRenderViewFamily(FSceneViewFamily& InViewFamily)
{
	uint32 ViewConfigCount = 0;
	XR_ENSURE(xrEnumerateViewConfigurationViews(Instance, System, SelectedViewConfigurationType, 0, &ViewConfigCount, nullptr));

#Loc: <Workspace>/Engine/Source/Developer/FunctionalTesting/Private/AutomationBlueprintFunctionLibrary.cpp:189

Scope (from outer to inner):

file
class        class FAutomationViewExtension : public FWorldSceneViewExtension
function     virtual void SetupViewFamily

Source code excerpt:

			ShowFlags.SetScreenSpaceReflections(ViewSettings->ScreenSpaceReflections);
			ShowFlags.SetScreenSpaceAO(ViewSettings->ScreenSpaceAO);
			ShowFlags.SetDistanceFieldAO(ViewSettings->DistanceFieldAO);
			ShowFlags.SetContactShadows(ViewSettings->ContactShadows);
			ShowFlags.SetEyeAdaptation(ViewSettings->EyeAdaptation);
			ShowFlags.SetBloom(ViewSettings->Bloom);
		}

		if (Options.bOverride_OverrideTimeTo)
		{
			// Turn off time the ultimate source of noise.
			InViewFamily.Time = FGameTime::CreateUndilated(Options.OverrideTimeTo, 0.0f);
		}

		if (Options.bDisableNoisyRenderingFeatures)
	{
			//// Turn off common show flags for noisy sources of rendering.

#Loc: <Workspace>/Engine/Source/Developer/FunctionalTesting/Public/AutomationViewSettings.h:20

Scope (from outer to inner):

file
class        class UAutomationViewSettings : public UDataAsset
function     UAutomationViewSettings

Source code excerpt:

		, ScreenSpaceReflections(true)
		, ScreenSpaceAO(true)
		, DistanceFieldAO(true)
		, ContactShadows(true)
		, EyeAdaptation(true)
		, Bloom(true)
	{
	}

	UPROPERTY(EditAnywhere, Category="Rendering")
	bool AntiAliasing;
	
	UPROPERTY(EditAnywhere, Category="Rendering")
	bool MotionBlur;
	
	UPROPERTY(EditAnywhere, Category="Rendering")
	bool TemporalAA;

#Loc: <Workspace>/Engine/Source/Developer/FunctionalTesting/Public/AutomationViewSettings.h:49

Scope (from outer to inner):

file
class        class UAutomationViewSettings : public UDataAsset

Source code excerpt:

	
	UPROPERTY(EditAnywhere, Category="Rendering")
	bool EyeAdaptation;

	UPROPERTY(EditAnywhere, Category = "Rendering")
	bool Bloom;
};

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/Engine/Scene.h:479

Scope: file

Source code excerpt:

{
	GENERATED_USTRUCT_BODY()


	UPROPERTY(Interp, BlueprintReadWrite, Category = "Lens")
	FLensBloomSettings Bloom;

	UPROPERTY(Interp, BlueprintReadWrite, Category = "Lens")
	FLensImperfectionSettings Imperfections;

	/** in percent, Scene chromatic aberration / color fringe (camera imperfection) to simulate an artifact that happens in real-world lens, mostly visible in the image corners. */
	UPROPERTY(Interp, BlueprintReadWrite, Category = "Lens", meta = (UIMin = "0.0", UIMax = "5.0"))
	float ChromaticAberration;


	FLensSettings()
	{

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Scene.cpp:183

Scope (from outer to inner):

file
function     void FLensSettings::ExportToPostProcessSettings

Source code excerpt:

	OutPostProcessSettings->BloomDirtMaskTint = DirtMaskTint;
}

void FLensSettings::ExportToPostProcessSettings(FPostProcessSettings* OutPostProcessSettings) const
{
	Bloom.ExportToPostProcessSettings(OutPostProcessSettings);
	Imperfections.ExportToPostProcessSettings(OutPostProcessSettings);

	OutPostProcessSettings->bOverride_SceneFringeIntensity = true;
	OutPostProcessSettings->SceneFringeIntensity = ChromaticAberration;
}

FCameraExposureSettings::FCameraExposureSettings()
{
	static const auto VarDefaultAutoExposureExtendDefaultLuminanceRange = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.DefaultFeature.AutoExposure.ExtendDefaultLuminanceRange"));
	const bool bExtendedLuminanceRange = VarDefaultAutoExposureExtendDefaultLuminanceRange->GetValueOnAnyThread() == 1;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Scene.cpp:341

Scope (from outer to inner):

file
function     static void DoPostProcessSettingsSanityCheck

Source code excerpt:

		RenameMap.Add(TEXT("BloomConvolutionPreFilterMin"), TEXT(""));
		RenameMap.Add(TEXT("BloomConvolutionPreFilterMax"), TEXT(""));
		RenameMap.Add(TEXT("BloomConvolutionPreFilterMult"), TEXT(""));
		RenameMap.Add(TEXT("BloomConvolutionBufferScale"), TEXT(""));

		VerifyPostProcessingProperties(TEXT("Bloom"),
			TArray<const UStruct*>({
				FGaussianSumBloomSettings::StaticStruct(),
				FLensBloomSettings::StaticStruct(),
				FLensImperfectionSettings::StaticStruct()}),
			RenameMap);
	}
	
	{
		TMap<FString, FString> RenameMap;
		VerifyPostProcessingProperties(TEXT("BloomConvolution"),
			TArray<const UStruct*>({FConvolutionBloomSettings::StaticStruct()}),
			RenameMap);
	}

	{
		TMap<FString, FString> RenameMap;

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

Scope (from outer to inner):

file
function     void FSceneView::EndFinalPostprocessSettings

Source code excerpt:

		{
			FinalPostProcessSettings.BloomIntensity = 0.0f;
		}
	}

	if(!Family->EngineShowFlags.Bloom)
	{
		FinalPostProcessSettings.BloomIntensity = 0.0f;
	}

	// scale down tone mapper shader permutation
	{
		int32 Quality = CVarTonemapperQuality.GetValueOnGameThread();

		if(Quality < 2)
		{
			FinalPostProcessSettings.VignetteIntensity = 0;

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

Scope (from outer to inner):

file
function     void EngineShowFlagOverride

Source code excerpt:

			 DISABLE_ENGINE_SHOWFLAG(DepthOfField)
			 DISABLE_ENGINE_SHOWFLAG(AmbientOcclusion)
			 DISABLE_ENGINE_SHOWFLAG(CameraImperfections)
			 DISABLE_ENGINE_SHOWFLAG(Decals)
			 DISABLE_ENGINE_SHOWFLAG(LensFlares)
			 DISABLE_ENGINE_SHOWFLAG(Bloom)
			 DISABLE_ENGINE_SHOWFLAG(ColorGrading)
			 DISABLE_ENGINE_SHOWFLAG(Tonemapper)
			 DISABLE_ENGINE_SHOWFLAG(Refraction)
			 DISABLE_ENGINE_SHOWFLAG(ReflectionEnvironment)
			 DISABLE_ENGINE_SHOWFLAG(AmbientCubemap)
			 DISABLE_ENGINE_SHOWFLAG(MotionBlur)
			 DISABLE_ENGINE_SHOWFLAG(DirectLighting)
			 DISABLE_ENGINE_SHOWFLAG(Lighting)
			 DISABLE_ENGINE_SHOWFLAG(Translucency)
			 DISABLE_ENGINE_SHOWFLAG(TextRender)
			 DISABLE_ENGINE_SHOWFLAG(Particles)

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

Scope: file

Source code excerpt:

#endif

/** Affects all postprocessing features, depending on viewmode this is on or off, for now SHOWFLAG_ALWAYS_ACCESSIBLE because it's used by ReflectionEnviromentCapture */
SHOWFLAG_ALWAYS_ACCESSIBLE(PostProcessing, SFG_Hidden, NSLOCTEXT("UnrealEd", "PostProcessingSF", "Post-processing"))
/** Bloom, for now SHOWFLAG_ALWAYS_ACCESSIBLE because it's exposed in SceneCapture */
SHOWFLAG_ALWAYS_ACCESSIBLE(Bloom, SFG_PostProcess, NSLOCTEXT("UnrealEd", "BloomSF", "Bloom"))
/** Local Exposure, for now SHOWFLAG_ALWAYS_ACCESSIBLE because it's exposed in SceneCapture */
SHOWFLAG_ALWAYS_ACCESSIBLE(LocalExposure, SFG_PostProcess, NSLOCTEXT("UnrealEd", "LocalExposureSF", "Local Exposure"))
/** HDR->LDR conversion is done through a tone mapper (otherwise linear mapping is used) */
SHOWFLAG_FIXED_IN_SHIPPING(1, Tonemapper, SFG_PostProcess, NSLOCTEXT("UnrealEd", "TonemapperSF", "Tonemapper"))
/** Any Anti-aliasing e.g. FXAA, Temporal AA, for now SHOWFLAG_ALWAYS_ACCESSIBLE because it's exposed in SceneCapture */
SHOWFLAG_ALWAYS_ACCESSIBLE(AntiAliasing, SFG_Normal, NSLOCTEXT("UnrealEd", "AntiAliasingSF", "Anti-aliasing"))
/** Only used in AntiAliasing is on, true:uses Temporal AA, otherwise FXAA, for now SHOWFLAG_ALWAYS_ACCESSIBLE because it's exposed in SceneCapture  */
SHOWFLAG_ALWAYS_ACCESSIBLE(TemporalAA, SFG_Advanced, NSLOCTEXT("UnrealEd", "TemporalAASF", "Temporal AA (instead FXAA)"))
/** e.g. Ambient cube map, for now SHOWFLAG_ALWAYS_ACCESSIBLE because it's exposed in SceneCapture */
SHOWFLAG_ALWAYS_ACCESSIBLE(AmbientCubemap, SFG_LightingFeatures, NSLOCTEXT("UnrealEd", "AmbientCubemapSF", "Ambient Cubemap"))
/** Human like eye simulation to adapt to the brightness of the view, for now SHOWFLAG_ALWAYS_ACCESSIBLE because it's exposed in SceneCapture */

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/LightShaftRendering.cpp:127

Scope: file

Source code excerpt:

}

enum class ELightShaftTechnique
{
	Occlusion,
	Bloom
};

BEGIN_SHADER_PARAMETER_STRUCT(FLightShaftPixelShaderParameters, )
	SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, View)
	SHADER_PARAMETER(FVector4f, UVMinMax)
	SHADER_PARAMETER(FVector4f, AspectRatioAndInvAspectRatio)
	SHADER_PARAMETER(FVector4f, LightShaftParameters)
	SHADER_PARAMETER(FVector4f, BloomTintAndThreshold)
	SHADER_PARAMETER(FVector2f, TextureSpaceBlurOrigin)
	SHADER_PARAMETER(float, BloomMaxBrightness)
END_SHADER_PARAMETER_STRUCT()

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/LightShaftRendering.cpp:629

Scope (from outer to inner):

file
function     void FDeferredShadingSceneRenderer::RenderLightShaftBloom

Source code excerpt:

								SceneTextures.UniformBuffer,
								SceneViewport,
								LightShaftViewport,
								TemporalHistory,
								LightComponentType,
								ELightShaftTechnique::Bloom);

							AddLightShaftBloomPass(GraphBuilder, View, LightShaftParameters, LightShafts, OutputViewport, OutputBinding);
							OutputLoadAction = ERenderTargetLoadAction::ELoad;

							FTranslucencyPassResources& TranslucencyPassResources = OutTranslucencyResourceMap.Get(ViewIndex, ETranslucencyPass::TPT_TranslucencyAfterDOF);
							if (bUpdateViewsSeparateTranslucency)
							{
								TranslucencyPassResources.ViewRect = OutputViewport.Rect;
								TranslucencyPassResources.ColorTexture = OutputTexture;
							}
							else if(TranslucencyPassResources.IsValid())

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessFFTBloom.cpp:880

Scope (from outer to inner):

file
function     FFFTBloomOutput AddFFTBloomPass

Source code excerpt:


	FRDGTextureDesc OutputSceneColorDesc = FRDGTextureDesc::Create2D(
		FFTInputSceneColor.TextureSRV->Desc.Texture->Desc.Extent,
		FFTInputSceneColor.TextureSRV->Desc.Texture->Desc.Format,
		FClearValueBinding::None,
		TexCreate_ShaderResource | TexCreate_UAV | GFastVRamConfig.Bloom);
		
	BloomOutput.BloomTexture.Texture = GraphBuilder.CreateTexture(OutputSceneColorDesc, TEXT("Bloom.FFT.ScatterDispersion"));
	BloomOutput.BloomTexture.ViewRect = FFTInputSceneColor.ViewRect;

	GPUFFT::ConvolutionWithTextureImage2D(
		GraphBuilder,
		Intermediates.ComputePassFlags,
		View.ShaderMap,
		Intermediates.FrequencySize,
		Intermediates.bDoHorizontalFirst,
		SpectralKernelTexture,
		FFTInputSceneColor.TextureSRV, FFTInputSceneColor.ViewRect,
		BloomOutput.BloomTexture.Texture, BloomOutput.BloomTexture.ViewRect,
		Intermediates.PreFilter,
		FFTMulitplyParameters,
		GFastVRamConfig.Bloom);

	return BloomOutput;
}

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessLensFlares.cpp:130

Scope (from outer to inner):

file
function     FScreenPassTexture AddLensFlaresPass

Source code excerpt:

	FRDGBuilder& GraphBuilder,
	const FViewInfo& View,
	const FLensFlareInputs& Inputs)
{
	check(Inputs.Flare.IsValid());
	check(Inputs.Bloom.IsValid());
	check(Inputs.BokehShapeTexture);
	check(Inputs.LensFlareCount <= FLensFlareInputs::LensFlareCountMax);
	check(Inputs.TintColorsPerFlare.Num() == Inputs.LensFlareCount);
	check(Inputs.BokehSizePercent > 0.0f);
	check(Inputs.Intensity > 0.0f);
	check(Inputs.LensFlareCount > 0);

	RDG_EVENT_SCOPE(GraphBuilder, "LensFlares");

	const float PercentToScale = 0.01f;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessLensFlares.cpp:148

Scope (from outer to inner):

file
function     FScreenPassTexture AddLensFlaresPass

Source code excerpt:

	// changing this constant will not preserve energy properly. The kernel size should also change based
	// on this constant. This is not implemented in order to provide preserve the look of content. The masking
	// behavior is also affected by this constant.
	const float GuardBandScale = 2.0f;

	const FScreenPassTextureViewport BloomViewport(Inputs.Bloom);
	const FIntPoint BloomViewportSize(BloomViewport.Rect.Size());
	const FScreenPassTextureViewport FlareViewport(Inputs.Flare);
	const FIntPoint FlareViewSize = FlareViewport.Rect.Size();

	FRHIBlendState* AdditiveBlendState = TStaticBlendState<CW_RGB, BO_Add, BF_One, BF_One>::GetRHI();
	FRHISamplerState* BilinearClampSampler = TStaticSamplerState<SF_Bilinear, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI();

	FRDGTextureRef BlurOutputTexture = nullptr;

	// Initialize the blur output texture.
	{

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessLensFlares.cpp:242

Scope (from outer to inner):

file
function     FScreenPassTexture AddLensFlaresPass

Source code excerpt:


	FRDGTextureRef LensFlareTexture = nullptr;

	// Initialize the lens flare output texture.
	{
		const FRDGTextureDesc& InputDesc = Inputs.Bloom.TextureSRV->Desc.Texture->Desc;
		FRDGTextureDesc LensFlareTextureDesc = FRDGTextureDesc::Create2D(
			InputDesc.Extent,
			InputDesc.Format,
			FClearValueBinding(FLinearColor::Transparent),
			/* InFlags = */ TexCreate_ShaderResource | TexCreate_RenderTargetable | TexCreate_DisableDCC);

		LensFlareTexture = GraphBuilder.CreateTexture(LensFlareTextureDesc, TEXT("LensFlareTexture"));
	}

	ERenderTargetLoadAction LensFlareLoadAction = ERenderTargetLoadAction::ELoad;

	if (Inputs.bCompositeWithBloom)
	{
		FLensFlareCopyBloomPS::FParameters* CopyPassParameters = GraphBuilder.AllocParameters<FLensFlareCopyBloomPS::FParameters>();
		CopyPassParameters->Pass.InputTexture = Inputs.Bloom.TextureSRV;
		CopyPassParameters->Pass.RenderTargets[0] = FRenderTargetBinding(LensFlareTexture, ERenderTargetLoadAction::ENoAction);

		FPixelShaderUtils::AddFullscreenPass(
			GraphBuilder,
			View.ShaderMap,
			RDG_EVENT_NAME("LensFlareCopyBloom %dx%d", Inputs.Bloom.ViewRect.Size().X, Inputs.Bloom.ViewRect.Size().Y),
			View.ShaderMap->GetShader<FLensFlareCopyBloomPS>(),
			CopyPassParameters,
			Inputs.Bloom.ViewRect);
	}
	else
	{
		// Clear to transparent black on the first render pass.
		LensFlareLoadAction = ERenderTargetLoadAction::EClear;
	}

	const FIntRect OutputViewRect = BloomViewport.Rect;

	const FVector2f OutputCenter = FVector2f(OutputViewRect.Min + OutputViewRect.Max) / 2;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessLensFlares.cpp:361

Scope (from outer to inner):

file
function     FScreenPassTexture AddLensFlaresPass

Source code excerpt:

}

FScreenPassTexture AddLensFlaresPass(
	FRDGBuilder& GraphBuilder,
	const FViewInfo& View,
	FScreenPassTexture Bloom,
	FScreenPassTextureSlice QualitySceneDownsample,
	FScreenPassTextureSlice DefaultSceneDownsample)
{
	ensure(IsLensFlaresEnabled(View));

	const FPostProcessSettings& Settings = View.FinalPostProcessSettings;

	RDG_GPU_STAT_SCOPE(GraphBuilder, LensFlare);

	FRHITexture* BokehTextureRHI = GWhiteTexture->TextureRHI;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessLensFlares.cpp:394

Scope (from outer to inner):

file
function     FScreenPassTexture AddLensFlaresPass

Source code excerpt:

			BokehTextureRHI = BokehTextureResource->TextureRHI;
		}
	}

	FLensFlareInputs LensFlareInputs;
	LensFlareInputs.Bloom = FScreenPassTextureSlice::CreateFromScreenPassTexture(GraphBuilder, Bloom);
	LensFlareInputs.Flare = QualitySceneDownsample;
	LensFlareInputs.BokehShapeTexture = BokehTextureRHI;
	LensFlareInputs.TintColorsPerFlare = Settings.LensFlareTints;
	LensFlareInputs.TintColor = Settings.LensFlareTint;
	LensFlareInputs.BokehSizePercent = Settings.LensFlareBokehSize;
	LensFlareInputs.Intensity = Settings.LensFlareIntensity * Settings.BloomIntensity;
	LensFlareInputs.Threshold = Settings.LensFlareThreshold;

	// If a bloom output texture isn't available, substitute the half resolution scene color instead, but disable bloom
	// composition. The pass needs a primary input in order to access the image descriptor and viewport for output.
	if (!Bloom.IsValid())
	{
		LensFlareInputs.Bloom = DefaultSceneDownsample;
		LensFlareInputs.bCompositeWithBloom = false;
	}

	return AddLensFlaresPass(GraphBuilder, View, LensFlareInputs);
}

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessLensFlares.h:21

Scope: file

Source code excerpt:

	static const uint32 LensFlareCountMax = 8;

	// [Required] The bloom convolution texture. If enabled, this will be composited with lens flares. Otherwise,
	// a transparent black texture is used instead. Either way, the final output texture will use the this texture
	// descriptor and viewport.
	FScreenPassTextureSlice Bloom;

	// [Required] The scene color input, before bloom, which is used as the source of lens flares.
	// This can be a downsampled input based on the desired quality level.
	FScreenPassTextureSlice Flare;

	// [Required] The bokeh shape texture to use to blur the lens flares.
	FRHITexture* BokehShapeTexture;

	// The number of lens flares to render.
	uint32 LensFlareCount = LensFlareCountMax;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessLensFlares.h:61

Scope: file

Source code excerpt:


// Helper function which pulls inputs from the post process settings of the view.
FScreenPassTexture AddLensFlaresPass(
	FRDGBuilder& GraphBuilder,
	const FViewInfo& View,
	FScreenPassTexture Bloom,
	FScreenPassTextureSlice QualitySceneDownsample,
	FScreenPassTextureSlice DefaultSceneDownsample);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessMobile.cpp:126

Scope: file

Source code excerpt:

	return IsValidBloomSetupVariation(Variation);
}

enum class EBloomSetupOutputType : uint32
{
	Bloom = 1 << 0,
	SunShaftAndDof = 1 << 1,
	EyeAdaptation = 1 << 2,
};

const TCHAR* GetBloomSetupOutputTypeName(EBloomSetupOutputType BloomSetupOutputType)
{
	switch (BloomSetupOutputType)
	{
	case EBloomSetupOutputType::Bloom : return TEXT("BloomSetup_Bloom");
	case EBloomSetupOutputType::SunShaftAndDof: return TEXT("BloomSetup_SunShaftAndDof");
	case EBloomSetupOutputType::EyeAdaptation: return TEXT("BloomSetup_EyeAdaptation");
	default: return TEXT("Unknown");
	}
}

TArray<EBloomSetupOutputType> GetBloomSetupOutputType(bool bUseBloom, bool bUseSun, bool bUseDof, bool bUseEyeAdaptation)
{
	bool bValidVariation = IsValidBloomSetupVariation(bUseBloom, bUseSun, bUseDof, bUseEyeAdaptation);

	TArray<EBloomSetupOutputType> BloomSetupOutputType;

	//if the variation is invalid, always use bloom permutation
	if (!bValidVariation || bUseBloom)
	{
		BloomSetupOutputType.Add(EBloomSetupOutputType::Bloom);
	}

	if (bUseSun || bUseDof)
	{
		BloomSetupOutputType.Add(EBloomSetupOutputType::SunShaftAndDof);
	}

	if (bUseEyeAdaptation)
	{
		BloomSetupOutputType.Add(EBloomSetupOutputType::EyeAdaptation);
	}

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessMobile.cpp:288

Scope (from outer to inner):

file
function     FMobileBloomSetupOutputs AddMobileBloomSetupPass
lambda-function

Source code excerpt:


		ETextureCreateFlags TargetableFlags = TexCreate_RenderTargetable | TexCreate_ShaderResource;

		EPixelFormat Format = PF_R16F;

		if (BloomSetupOutputType[OutputIndex] == EBloomSetupOutputType::Bloom)
		{
			checkSlow(OutputIndex == 0);

			if (!bIsValidVariation)
			{
				TargetableFlags |= TexCreate_Memoryless;
			}

			Format = PF_FloatR11G11B10;
		}

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessMobile.cpp:384

Scope (from outer to inner):

file
function     FMobileBloomSetupOutputs AddMobileBloomSetupPass

Source code excerpt:


	FMobileBloomSetupOutputs Outputs;

	for (int32 i = 0; i < BloomSetupOutputType.Num(); ++i)
	{
		if (BloomSetupOutputType[i] == EBloomSetupOutputType::Bloom)
		{
			Outputs.Bloom = DestRenderTargets[i];
		}
		else if(BloomSetupOutputType[i] == EBloomSetupOutputType::SunShaftAndDof)
		{
			Outputs.SunShaftAndDof = DestRenderTargets[i];
		}
		else if (BloomSetupOutputType[i] == EBloomSetupOutputType::EyeAdaptation)
		{
			Outputs.EyeAdaptation = DestRenderTargets[i];
		}
	}

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessMobile.h:27

Scope: file

Source code excerpt:

	bool bUseMetalMSAAHDRDecode = false;
};

struct FMobileBloomSetupOutputs
{
	FScreenPassTexture Bloom;
	FScreenPassTexture SunShaftAndDof;
	FScreenPassTexture EyeAdaptation;
};

FMobileBloomSetupOutputs AddMobileBloomSetupPass(FRDGBuilder& GraphBuilder, const FViewInfo& View, const FEyeAdaptationParameters& EyeAdaptationParameters, const FMobileBloomSetupInputs& Inputs);

struct FMobileDofNearInputs
{
	FScreenPassTexture BloomSetup_SunShaftAndDof;

	bool bUseSun = false;

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

Scope (from outer to inner):

file
function     FScreenPassTexture AddTonemapPass

Source code excerpt:

	CommonParameters.LUTOffset = 0.5f / LUTSize;
	CommonParameters.LensPrincipalPointOffsetScale = View.LensPrincipalPointOffsetScale;

	// Bloom parameters
	{
		const bool bUseBloom = Inputs.Bloom.Texture != nullptr;

		if (bUseBloom)
		{
			const FScreenPassTextureViewport BloomViewport(Inputs.Bloom);
			CommonParameters.ColorToBloom = FScreenTransform::ChangeTextureUVCoordinateFromTo(SceneColorViewport, BloomViewport);
			CommonParameters.BloomUVViewportBilinearMin = GetScreenPassTextureViewportParameters(BloomViewport).UVViewportBilinearMin;
			CommonParameters.BloomUVViewportBilinearMax = GetScreenPassTextureViewportParameters(BloomViewport).UVViewportBilinearMax;
			CommonParameters.BloomTexture = Inputs.Bloom.Texture;
			CommonParameters.BloomSampler = BilinearClampSampler;
		}
		else
		{
			CommonParameters.ColorToBloom = FScreenTransform::Identity;
			CommonParameters.BloomUVViewportBilinearMin = FVector2f::ZeroVector;
			CommonParameters.BloomUVViewportBilinearMax = FVector2f::UnitVector;
			CommonParameters.BloomTexture = GSystemTextures.GetBlackDummy(GraphBuilder);
			CommonParameters.BloomSampler = BilinearClampSampler;
		}

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessTonemap.h:33

Scope: file

Source code excerpt:


	// [Required] HDR scene color to tonemap.
	FScreenPassTextureSlice SceneColor;

	// [Required] Filtered bloom texture to composite with tonemapped scene color. This should be transparent black for no bloom.
	FScreenPassTexture Bloom;

	// [Optional] structured buffer of multiply parameters to apply to the scene color.
	FRDGBufferRef SceneColorApplyParamaters = nullptr;

	// [Optional] Luminance bilateral grid. If this is null, local exposure is disabled.
	FRDGTextureRef LocalExposureTexture = nullptr;

	// [Optional] Blurred luminance texture used to calculate local exposure.
	FRDGTextureRef BlurredLogLuminanceTexture = nullptr;

	// [Optional] Local exposure parameters.

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

Scope (from outer to inner):

file
function     void AddPostProcessingPasses

Source code excerpt:

				LocalExposureParameters,
				HistogramTexture,
				bLocalExposureEnabled);
		}

		FScreenPassTexture Bloom;
		FRDGBufferRef SceneColorApplyParameters = nullptr;
		if (bBloomEnabled)
		{
			const FSceneDownsampleChain* LensFlareSceneDownsampleChain;

			FSceneDownsampleChain BloomDownsampleChain;

			if (bFFTBloomEnabled)
			{
				LensFlareSceneDownsampleChain = &SceneDownsampleChain;

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

Scope (from outer to inner):

file
function     void AddPostProcessingPasses

Source code excerpt:

					EyeAdaptationBuffer,
					LocalExposureParameters,
					CVarBloomApplyLocalExposure.GetValueOnRenderThread() ? LocalExposureTexture : nullptr,
					LocalExposureBlurredLogLumTexture);

				Bloom = Outputs.BloomTexture;
				SceneColorApplyParameters = Outputs.SceneColorApplyParameters;
			}
			else
			{
				const bool bBloomSetupRequiredEnabled = View.FinalPostProcessSettings.BloomThreshold > -1.0f || LocalExposureTexture != nullptr;

				// Reuse the main scene downsample chain if setup isn't required for gaussian bloom.
				if (SceneDownsampleChain.IsInitialized() && !bBloomSetupRequiredEnabled)
				{
					LensFlareSceneDownsampleChain = &SceneDownsampleChain;
				}

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

Scope (from outer to inner):

file
function     void AddPostProcessingPasses

Source code excerpt:

					BloomDownsampleChain.Init(GraphBuilder, View, EyeAdaptationParameters, DownsampleInput, DownsampleChainQuality, bLogLumaInAlpha);

					LensFlareSceneDownsampleChain = &BloomDownsampleChain;
				}

				Bloom = AddGaussianBloomPasses(GraphBuilder, View, LensFlareSceneDownsampleChain);
			}

			if (bLensFlareEnabled)
			{
				const ELensFlareQuality LensFlareQuality = GetLensFlareQuality();
				const uint32 LensFlareDownsampleStageIndex = static_cast<uint32>(ELensFlareQuality::MAX) - static_cast<uint32>(LensFlareQuality) - 1;
				Bloom = AddLensFlaresPass(GraphBuilder, View, Bloom,
					LensFlareSceneDownsampleChain->GetTexture(LensFlareDownsampleStageIndex),
					LensFlareSceneDownsampleChain->GetFirstTexture());
			}
		}

		SceneColorBeforeTonemapSlice = SceneColorSlice;

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

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

Scope (from outer to inner):

file
function     void AddPostProcessingPasses

Source code excerpt:


				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;

				SceneColor = AddPostProcessMaterialPass(GraphBuilder, View, PassInputs, HighestPriorityMaterial);
			}
			else
			{
				FRDGTextureRef ColorGradingTexture = nullptr;

				if (bPrimaryView)

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

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;
				PassInputs.EyeAdaptationParameters = &EyeAdaptationParameters;
				PassInputs.EyeAdaptationBuffer = EyeAdaptationBuffer;
				PassInputs.ColorGradingTexture = ColorGradingTexture;
				PassInputs.bWriteAlphaChannel = AntiAliasingMethod == AAM_FXAA || bProcessSceneColorAlpha;
				PassInputs.bOutputInHDR = bTonemapOutputInHDR;

				SceneColor = AddTonemapPass(GraphBuilder, View, PassInputs);

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

Scope (from outer to inner):

file
function     void AddMobilePostProcessingPasses

Source code excerpt:

	{
		Distortion,
		SunMask,
		BloomSetup,
		DepthOfField,
		Bloom,
		EyeAdaptation,
		SunMerge,
		SeparateTranslucency,
		TAA,
		Tonemap,
		PostProcessMaterialAfterTonemapping,
		FXAA,
		HighResolutionScreenshotMask,
		SelectionOutline,
		EditorPrimitive,
#if UE_ENABLE_DEBUG_DRAWING

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

Scope (from outer to inner):

file
function     void AddMobilePostProcessingPasses

Source code excerpt:


		PassSequence.SetEnabled(EPass::Distortion, bUseDistortion);
		PassSequence.SetEnabled(EPass::SunMask, bUseSun || bUseDof);
		PassSequence.SetEnabled(EPass::BloomSetup, bUseSun || bUseMobileDof || bUseBloom || bUseBasicEyeAdaptation || bUseHistogramEyeAdaptation);
		PassSequence.SetEnabled(EPass::DepthOfField, bUseDof);
		PassSequence.SetEnabled(EPass::Bloom, bUseBloom);
		PassSequence.SetEnabled(EPass::EyeAdaptation, bUseEyeAdaptation);
		PassSequence.SetEnabled(EPass::SunMerge, bUseBloom || bUseSun);
		PassSequence.SetEnabled(EPass::SeparateTranslucency, bUseSeparateTranslucency);
		PassSequence.SetEnabled(EPass::TAA, bUseTAA);
		PassSequence.SetEnabled(EPass::PostProcessMaterialAfterTonemapping, PostProcessMaterialAfterTonemappingChain.Num() != 0);
		PassSequence.SetEnabled(EPass::FXAA, View.AntiAliasingMethod == AAM_FXAA);
		PassSequence.Finalize();
			
		if (PassSequence.IsEnabled(EPass::Distortion))
		{
			PassSequence.AcceptPass(EPass::Distortion);

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

Scope (from outer to inner):

file
function     void AddMobilePostProcessingPasses

Source code excerpt:

		}

		// Bloom.
		FScreenPassTexture BloomUpOutputs;

		if (PassSequence.IsEnabled(EPass::Bloom))
		{
			PassSequence.AcceptPass(EPass::Bloom);
			auto AddBloomDownPass = [&GraphBuilder, &View](FScreenPassTexture& BloomDownSource, float BloomDownScale)
			{
				FMobileBloomDownInputs BloomDownInputs;
				BloomDownInputs.BloomDownScale = BloomDownScale;
				BloomDownInputs.BloomDownSource = BloomDownSource;

				return AddMobileBloomDownPass(GraphBuilder, View, BloomDownInputs);
			};

			float BloomDownScale = 0.66f * 4.0f;

			FScreenPassTexture PostProcessDownsample_Bloom[4];

			for (int32 i = 0; i < 4; ++i)
			{
				PostProcessDownsample_Bloom[i] = AddBloomDownPass(i == 0 ? BloomSetupOutputs.Bloom : PostProcessDownsample_Bloom[i - 1], BloomDownScale);
			}

			const FFinalPostProcessSettings& Settings = View.FinalPostProcessSettings;

			auto AddBloomUpPass = [&GraphBuilder, &View](FScreenPassTexture& BloomUpSourceA, FScreenPassTexture& BloomUpSourceB, float BloomSourceScale, const FVector4f& TintA, const FVector4f& TintB)
			{
				FMobileBloomUpInputs BloomUpInputs;
				BloomUpInputs.BloomUpSourceA = BloomUpSourceA;
				BloomUpInputs.BloomUpSourceB = BloomUpSourceB;
				BloomUpInputs.ScaleAB = FVector2D(BloomSourceScale, BloomSourceScale);
				BloomUpInputs.TintA = TintA;

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

Scope (from outer to inner):

file
function     void AddMobilePostProcessingPasses

Source code excerpt:


				SunBlurOutputs = AddMobileSunBlurPass(GraphBuilder, View, SunBlurInputs);
			}

			FMobileSunMergeInputs SunMergeInputs;
			SunMergeInputs.BloomSetup_Bloom = BloomSetupOutputs.Bloom;
			SunMergeInputs.BloomUp = BloomUpOutputs;
			SunMergeInputs.SunBlur = SunBlurOutputs;
			SunMergeInputs.bUseBloom = bUseBloom;
			SunMergeInputs.bUseSun = bUseSun;

			BloomOutput = AddMobileSunMergePass(GraphBuilder, View, SunMergeInputs);

		}

		// mobile separate translucency 
		if (PassSequence.IsEnabled(EPass::SeparateTranslucency))

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

Scope (from outer to inner):

file
function     void AddMobilePostProcessingPasses

Source code excerpt:

	{
		PassSequence.SetEnabled(EPass::Distortion, false);
		PassSequence.SetEnabled(EPass::SunMask, false);
		PassSequence.SetEnabled(EPass::BloomSetup, false);
		PassSequence.SetEnabled(EPass::DepthOfField, false);
		PassSequence.SetEnabled(EPass::Bloom, false);
		PassSequence.SetEnabled(EPass::EyeAdaptation, false);
		PassSequence.SetEnabled(EPass::SunMerge, false);
		PassSequence.SetEnabled(EPass::SeparateTranslucency, false);
		PassSequence.SetEnabled(EPass::TAA, false);
		PassSequence.SetEnabled(EPass::PostProcessMaterialAfterTonemapping, false);
		PassSequence.SetEnabled(EPass::FXAA, false);
		PassSequence.Finalize();
	}
	
	if (PassSequence.IsEnabled(EPass::Tonemap))
	{

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

Scope (from outer to inner):

file
function     void AddMobilePostProcessingPasses

Source code excerpt:

			TonemapperInputs.OverrideOutput.ViewRect = OutputViewRect;
			TonemapperInputs.OverrideOutput.LoadAction = OutputLoadAction;
		}
			
		TonemapperInputs.SceneColor = FScreenPassTextureSlice::CreateFromScreenPassTexture(GraphBuilder, SceneColor);
		TonemapperInputs.Bloom = BloomOutput;
		TonemapperInputs.EyeAdaptationParameters = &EyeAdaptationParameters;
		TonemapperInputs.ColorGradingTexture = ColorGradingTexture;
		TonemapperInputs.bWriteAlphaChannel = View.AntiAliasingMethod == AAM_FXAA || IsPostProcessingWithAlphaChannelSupported() || bUseMobileDof || IsMobilePropagateAlphaEnabled(View.GetShaderPlatform());
		TonemapperInputs.bOutputInHDR = bHDRTonemapperOutput;
		TonemapperInputs.bGammaOnly = bDoGammaOnly;
		TonemapperInputs.bMetalMSAAHDRDecode = bMetalMSAAHDRDecode;
		TonemapperInputs.EyeAdaptationBuffer = bUseEyeAdaptation ? LastEyeAdaptationBuffer : nullptr;

		SceneColor = AddTonemapPass(GraphBuilder, View, TonemapperInputs);

		//The output color should been decoded to linear space after tone mapper apparently

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

Scope: file

Source code excerpt:

FASTVRAM_CVAR(GBufferF, 0);
FASTVRAM_CVAR(GBufferVelocity, 0);
FASTVRAM_CVAR(HZB, 1);
FASTVRAM_CVAR(SceneDepth, 1);
FASTVRAM_CVAR(SceneColor, 1);
FASTVRAM_CVAR(Bloom, 1);
FASTVRAM_CVAR(BokehDOF, 1);
FASTVRAM_CVAR(CircleDOF, 1);
FASTVRAM_CVAR(CombineLUTs, 1);
FASTVRAM_CVAR(Downsample, 1);
FASTVRAM_CVAR(EyeAdaptation, 1);
FASTVRAM_CVAR(Histogram, 1);
FASTVRAM_CVAR(HistogramReduce, 1);
FASTVRAM_CVAR(VelocityFlat, 1);
FASTVRAM_CVAR(VelocityMax, 1);
FASTVRAM_CVAR(MotionBlur, 1);
FASTVRAM_CVAR(Tonemap, 1);

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

Scope (from outer to inner):

file
function     void FFastVramConfig::Update

Source code excerpt:

	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_GBufferF, GBufferF);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_GBufferVelocity, GBufferVelocity);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_HZB, HZB);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_SceneDepth, SceneDepth);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_SceneColor, SceneColor);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_Bloom, Bloom);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_BokehDOF, BokehDOF);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_CircleDOF, CircleDOF);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_CombineLUTs, CombineLUTs);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_Downsample, Downsample);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_EyeAdaptation, EyeAdaptation);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_Histogram, Histogram);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_HistogramReduce, HistogramReduce);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_VelocityFlat, VelocityFlat);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_VelocityMax, VelocityMax);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_MotionBlur, MotionBlur);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_Tonemap, Tonemap);

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

Scope: file

Source code excerpt:

	ETextureCreateFlags GBufferF;
	ETextureCreateFlags GBufferVelocity;
	ETextureCreateFlags HZB;
	ETextureCreateFlags SceneDepth;
	ETextureCreateFlags SceneColor;
	ETextureCreateFlags Bloom;
	ETextureCreateFlags BokehDOF;
	ETextureCreateFlags CircleDOF;
	ETextureCreateFlags CombineLUTs;
	ETextureCreateFlags Downsample;
	ETextureCreateFlags EyeAdaptation;
	ETextureCreateFlags Histogram;
	ETextureCreateFlags HistogramReduce;
	ETextureCreateFlags VelocityFlat;
	ETextureCreateFlags VelocityMax;
	ETextureCreateFlags MotionBlur;
	ETextureCreateFlags Tonemap;