r.FastVRam.GBufferE

r.FastVRam.GBufferE

#Overview

name: r.FastVRam.GBufferE

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.GBufferE is to configure the memory allocation strategy for the GBufferE texture in Unreal Engine’s rendering system. This variable is part of the Fast VRAM configuration system, which allows developers to optimize texture memory usage for specific rendering targets.

The associated variable GBufferE is a texture reference used in various parts of the rendering pipeline:

When working with both r.FastVRam.GBufferE and GBufferE, developers should consider their impact on rendering performance, memory usage, and overall image quality, especially on different hardware configurations.

#References in C++ code

#Callsites

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

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

Scope: file

Source code excerpt:

FASTVRAM_CVAR(GBufferC, 0);
FASTVRAM_CVAR(GBufferD, 0);
FASTVRAM_CVAR(GBufferE, 0);
FASTVRAM_CVAR(GBufferF, 0);
FASTVRAM_CVAR(GBufferVelocity, 0);
FASTVRAM_CVAR(HZB, 1);
FASTVRAM_CVAR(SceneDepth, 1);
FASTVRAM_CVAR(SceneColor, 1);
FASTVRAM_CVAR(Bloom, 1);

#Associated Variable and Callsites

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

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/TextureShare/Source/TextureShare/Private/Game/ViewExtension/TextureShareSceneViewExtension.cpp:152

Scope (from outer to inner):

file
function     void FTextureShareSceneViewExtension::ShareSceneViewColors_RenderThread

Source code excerpt:

	AddShareTexturePass(UE::TextureShareStrings::SceneTextures::GBufferC, SceneTextures.GBufferC);
	AddShareTexturePass(UE::TextureShareStrings::SceneTextures::GBufferD, SceneTextures.GBufferD);
	AddShareTexturePass(UE::TextureShareStrings::SceneTextures::GBufferE, SceneTextures.GBufferE);
	AddShareTexturePass(UE::TextureShareStrings::SceneTextures::GBufferF, SceneTextures.GBufferF);
}

//////////////////////////////////////////////////////////////////////////////////////////////
FTextureShareSceneViewExtension::FTextureShareSceneViewExtension(const FAutoRegister& AutoRegister, const TSharedRef<ITextureShareObjectProxy, ESPMode::ThreadSafe>& InObjectProxy, FViewport* InLinkedViewport)
	: FSceneViewExtensionBase(AutoRegister)

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/TextureShare/Source/TextureShare/Private/Misc/TextureShareStrings.h:20

Scope (from outer to inner):

file
namespace    UE::TextureShareStrings::SceneTextures

Source code excerpt:

	static constexpr auto GBufferC = TEXT("GBufferC");
	static constexpr auto GBufferD = TEXT("GBufferD");
	static constexpr auto GBufferE = TEXT("GBufferE");
	static constexpr auto GBufferF = TEXT("GBufferF");

	// Read-write RTTs
	static constexpr auto FinalColor = TEXT("FinalColor");
	static constexpr auto Backbuffer = TEXT("Backbuffer");
};

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/SceneTexturesConfig.cpp:238

Scope (from outer to inner):

file
function     static void SetupMobileGBufferFlags

Source code excerpt:

		Bindings.GBufferC.Flags |= AddFlags;
		Bindings.GBufferD.Flags |= AddFlags;
		Bindings.GBufferE.Flags |= AddFlags;
		
		Bindings.GBufferA.Flags &= (~RemoveFlags);
		Bindings.GBufferB.Flags &= (~RemoveFlags);
		Bindings.GBufferC.Flags &= (~RemoveFlags);
		Bindings.GBufferD.Flags &= (~RemoveFlags);
		Bindings.GBufferE.Flags &= (~RemoveFlags);

		// Input attachments with PF_R8G8B8A8 has better support on mobile than PF_B8G8R8A8
		auto OverrideB8G8R8A8 = [](FGBufferBinding& Binding) { if (Binding.Format == PF_B8G8R8A8) Binding.Format = PF_R8G8B8A8; };
		OverrideB8G8R8A8(Bindings.GBufferA);
		OverrideB8G8R8A8(Bindings.GBufferB);
		OverrideB8G8R8A8(Bindings.GBufferC);
		OverrideB8G8R8A8(Bindings.GBufferD);
		OverrideB8G8R8A8(Bindings.GBufferE);
	}
}

void FSceneTexturesConfig::Init(const FSceneTexturesConfigInitSettings& InitSettings)
{
	FeatureLevel			= InitSettings.FeatureLevel;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/SceneTexturesConfig.cpp:300

Scope (from outer to inner):

file
function     void FSceneTexturesConfig::Init

Source code excerpt:

				BindingCache.Bindings[Layout].GBufferC = FindGBufferBindingByName(GBufferInfo, TEXT("GBufferC"), ShaderPlatform);
				BindingCache.Bindings[Layout].GBufferD = FindGBufferBindingByName(GBufferInfo, TEXT("GBufferD"), ShaderPlatform);
				BindingCache.Bindings[Layout].GBufferE = FindGBufferBindingByName(GBufferInfo, TEXT("GBufferE"), ShaderPlatform);
				BindingCache.Bindings[Layout].GBufferVelocity = FindGBufferBindingByName(GBufferInfo, TEXT("Velocity"), ShaderPlatform);

				// Remove DisableDCC flag for velocity. Only Nanite fast tile clear sets this flag currently
				// but we want to exclude velocity because it usually doesn't have many written pixels
				EnumRemoveFlags(BindingCache.Bindings[Layout].GBufferVelocity.Flags, TexCreate_DisableDCC);
			}

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

Scope (from outer to inner):

file
function     uint32 FSceneTexturesConfig::GetGBufferRenderTargetsInfo

Source code excerpt:

		IncludeBindingIfValid(Bindings.GBufferC);
		IncludeBindingIfValid(Bindings.GBufferD);
		IncludeBindingIfValid(Bindings.GBufferE);
		IncludeBindingIfValid(Bindings.GBufferVelocity);
	}
	// Forward shading path. Simple forward shading does not use velocity.
	else if (IsUsingBasePassVelocity(ShaderPlatform))
	{
		const FGBufferBinding& GBufferVelocity = GBufferBindings[GBL_Default].GBufferVelocity;

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/GBufferInfo.cpp:207

Scope: file

Source code excerpt:

 *    4: GBufferD
 *    if (GBUFFER_HAS_PRECSHADOWFACTOR)
 *        5: GBufferE
 * else if (SrcGlobal.GBUFFER_HAS_VELOCITY == 1 && SrcGlobal.GBUFFER_HAS_TANGENT == 0)
 *    0: Lighting
 *    1: GBufferA
 *    2: GBufferB
 *    3: GBufferC
 *    4: Velocity (NOTE!)
 *    5: GBufferD
 *    if (GBUFFER_HAS_PRECSHADOWFACTOR)
 *        6: GBufferE
 * else if (SrcGlobal.GBUFFER_HAS_VELOCITY == 0 && SrcGlobal.GBUFFER_HAS_TANGENT == 1)
 *    0: Lighting
 *    1: GBufferA
 *    2: GBufferB
 *    3: GBufferC
 *    4: GBufferF (NOTE!)
 *    5: GBufferD
 *    if (GBUFFER_HAS_PRECSHADOWFACTOR)
 *        6: GBufferE
 * else if (SrcGlobal.GBUFFER_HAS_VELOCITY == 1 && SrcGlobal.GBUFFER_HAS_TANGENT == 1)
 *    assert(0)
 *
*/

/*
 * LegacyFormatIndex: EGBufferFormat enum. Going forward, we will have better granularity on choosing precision, so thes
 *    are just being maintained for the transition.
 *
 * bUsesVelocityDepth: Normal velocity format is half16 for RG. But when enabled, it changes to half16 RGBA with
 *    alpha storing depth and blue unused.
 *
 */

FGBufferInfo RENDERCORE_API FetchLegacyGBufferInfo(const FGBufferParams& Params)
{
	FGBufferInfo Info = {};

	check(!Params.bHasVelocity || !Params.bHasTangent);

	bool bStaticLighting = Params.bHasPrecShadowFactor;

	int32 TargetLighting = 0;
	int32 TargetGBufferA = 1;
	int32 TargetGBufferB = 2;
	int32 TargetGBufferC = 3;
	int32 TargetGBufferD = -1;
	int32 TargetGBufferE = -1;
	int32 TargetGBufferF = -1;
	int32 TargetVelocity = -1;
	int32 TargetSeparatedMainDirLight = -1;

	// Substrate outputs material data through UAV. Only SceneColor, PrecalcShadow & Velocity data are still emitted through RenderTargets
	if (Substrate::IsSubstrateEnabled())
	{
		TargetGBufferA = -1;
		TargetGBufferB = -1;
		TargetGBufferC = -1;

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/GBufferInfo.cpp:303

Scope (from outer to inner):

file
function     FGBufferInfo FetchLegacyGBufferInfo

Source code excerpt:

		if (Params.bHasPrecShadowFactor)
		{
			Info.Targets[TargetGBufferE].Init(GBT_Unorm_8_8_8_8, TEXT("GBufferE"), false, true, true, false); // Precalc
			Info.Slots[GBS_PrecomputedShadowFactor] = FGBufferItem(GBS_PrecomputedShadowFactor, GBC_Raw_Unorm_8_8_8_8, GBCH_Both);
			Info.Slots[GBS_PrecomputedShadowFactor].Packing[0] = FGBufferPacking(TargetGBufferE, 0, 0);
			Info.Slots[GBS_PrecomputedShadowFactor].Packing[1] = FGBufferPacking(TargetGBufferE, 1, 1);
			Info.Slots[GBS_PrecomputedShadowFactor].Packing[2] = FGBufferPacking(TargetGBufferE, 2, 2);
			Info.Slots[GBS_PrecomputedShadowFactor].Packing[3] = FGBufferPacking(TargetGBufferE, 3, 3);
		}

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/GBufferInfo.cpp:372

Scope (from outer to inner):

file
function     FGBufferInfo FetchLegacyGBufferInfo

Source code excerpt:

		{
			TargetGBufferE = 5;
			Info.Targets[5].Init(GBT_Unorm_8_8_8_8, TEXT("GBufferE"), false, true, true, true);
			TargetSeparatedMainDirLight = 6;
		}
	}
	else if (Params.bHasVelocity)
	{
		TargetVelocity = 4;

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/GBufferInfo.cpp:389

Scope (from outer to inner):

file
function     FGBufferInfo FetchLegacyGBufferInfo

Source code excerpt:

		{
			TargetGBufferE = 6;
			Info.Targets[6].Init(GBT_Unorm_8_8_8_8, TEXT("GBufferE"), false, true, true, false);
			TargetSeparatedMainDirLight = 7;
		}
	}
	else if (Params.bHasTangent)
	{
		TargetGBufferF = 4;

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/GBufferInfo.cpp:403

Scope (from outer to inner):

file
function     FGBufferInfo FetchLegacyGBufferInfo

Source code excerpt:

		{
			TargetGBufferE = 6;
			Info.Targets[6].Init(GBT_Unorm_8_8_8_8, TEXT("GBufferE"), false, true, true, true);
			TargetSeparatedMainDirLight = 7;
		}
	}
	else
	{
		// should never hit this path

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Public/GBufferInfo.h:275

Scope: file

Source code excerpt:

	FGBufferBinding GBufferC;
	FGBufferBinding GBufferD;
	FGBufferBinding GBufferE;
	FGBufferBinding GBufferVelocity;
};

struct FGBufferInfo
{
	static const int MaxTargets = 8;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Internal/SceneTextures.h:74

Scope: file

Source code excerpt:

	FRDGTextureRef GBufferC{};
	FRDGTextureRef GBufferD{};
	FRDGTextureRef GBufferE{};
	FRDGTextureRef GBufferF{};

	// Additional Buffer texture used by mobile
	FRDGTextureMSAA DepthAux{};

	// Texture containing dynamic motion vectors. Can be bound by the base pass or its own velocity pass.

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

Scope (from outer to inner):

file
function     FDeferredDecalPassTextures GetDeferredDecalPassTextures

Source code excerpt:

		PassTextures.GBufferB = (*SceneTextures.UniformBuffer)->GBufferBTexture;
		PassTextures.GBufferC = (*SceneTextures.UniformBuffer)->GBufferCTexture;
		PassTextures.GBufferE = (*SceneTextures.UniformBuffer)->GBufferETexture;
	}

	PassTextures.DBufferTextures = DBufferTextures;

	return PassTextures;
}

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/CompositionLighting/PostProcessDeferredDecals.h:36

Scope: file

Source code excerpt:

	FRDGTextureRef GBufferB = nullptr;
	FRDGTextureRef GBufferC = nullptr;
	FRDGTextureRef GBufferE = nullptr;
	FDBufferTextures* DBufferTextures = nullptr;
};

FDeferredDecalPassTextures GetDeferredDecalPassTextures(
	FRDGBuilder& GraphBuilder, 
	const FSceneView& ViewInfo,

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/HairStrands/HairStrandsComposition.cpp:642

Scope (from outer to inner):

file
function     static void InternalRenderHairComposition

Source code excerpt:

			const FRDGTextureRef GBufferCTexture = SceneTextures.GBufferC;
			const FRDGTextureRef GBufferDTexture = SceneTextures.GBufferD;
			const FRDGTextureRef GBufferETexture = SceneTextures.GBufferE;
			if (bWritePartialGBuffer && GBufferATexture && GBufferBTexture)
			{
				AddHairVisibilityGBufferWritePass(
					GraphBuilder,
					View,
					bWriteDummyData,

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/HairStrands/HairStrandsRendering.cpp:190

Scope (from outer to inner):

file
function     void RenderHairBasePass

Source code excerpt:

				SceneTextures.GBufferC,
				SceneTextures.GBufferD,
				SceneTextures.GBufferE,
				SceneTextures.Color.Resolve,
				SceneTextures.Depth.Resolve,
				SceneTextures.Velocity,
				InstanceCullingManager);

			const bool bDebugSamplingEnable = GetHairStrandsSkyLightingDebugEnable();

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessBufferInspector.cpp:13

Scope: file

Source code excerpt:

	RDG_TEXTURE_ACCESS(GBufferC, ERHIAccess::CopySrc)
	RDG_TEXTURE_ACCESS(GBufferD, ERHIAccess::CopySrc)
	RDG_TEXTURE_ACCESS(GBufferE, ERHIAccess::CopySrc)
	RDG_TEXTURE_ACCESS(GBufferF, ERHIAccess::CopySrc)
	RDG_TEXTURE_ACCESS(SceneColor, ERHIAccess::CopySrc)
	RDG_TEXTURE_ACCESS(SceneColorBeforeTonemap, ERHIAccess::CopySrc)
	RDG_TEXTURE_ACCESS(SceneDepth, ERHIAccess::CopySrc)
	RDG_TEXTURE_ACCESS(OriginalSceneColor, ERHIAccess::CopySrc)
END_SHADER_PARAMETER_STRUCT()

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessBufferInspector.cpp:230

Scope: file

Source code excerpt:

				}

				if (Parameters.GBufferE)
				{
					FRHITexture* SourceBufferE = Parameters.GBufferE->GetRHI();
					if (DestinationBufferBCDEF->GetFormat() == SourceBufferE->GetFormat())
					{
						FRHICopyTextureInfo CopyInfo;
						CopyInfo.SourcePosition = SourcePoint;
						CopyInfo.DestPosition = FIntVector(3, 0, 0);
						CopyInfo.Size = FIntVector(1, 1, 1);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessBufferInspector.cpp:293

Scope: file

Source code excerpt:

		PassParameters->GBufferC = SceneTextures.GBufferCTexture;
		PassParameters->GBufferD = SceneTextures.GBufferDTexture;
		PassParameters->GBufferE = SceneTextures.GBufferETexture;
		PassParameters->GBufferF = SceneTextures.GBufferFTexture;
		PassParameters->SceneColor = Inputs.SceneColor.Texture;
		PassParameters->SceneColorBeforeTonemap = Inputs.SceneColorBeforeTonemap.Texture;
		PassParameters->SceneDepth = SceneTextures.SceneDepthTexture;
		PassParameters->OriginalSceneColor = Inputs.OriginalSceneColor.Texture;

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

Scope: file

Source code excerpt:

FASTVRAM_CVAR(GBufferC, 0);
FASTVRAM_CVAR(GBufferD, 0);
FASTVRAM_CVAR(GBufferE, 0);
FASTVRAM_CVAR(GBufferF, 0);
FASTVRAM_CVAR(GBufferVelocity, 0);
FASTVRAM_CVAR(HZB, 1);
FASTVRAM_CVAR(SceneDepth, 1);
FASTVRAM_CVAR(SceneColor, 1);
FASTVRAM_CVAR(Bloom, 1);

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

Scope (from outer to inner):

file
function     void FFastVramConfig::Update

Source code excerpt:

	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_GBufferC, GBufferC);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_GBufferD, GBufferD);
	bDirty |= UpdateTextureFlagFromCVar(CVarFastVRam_GBufferE, GBufferE);
	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);

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

Scope: file

Source code excerpt:

	ETextureCreateFlags GBufferC;
	ETextureCreateFlags GBufferD;
	ETextureCreateFlags GBufferE;
	ETextureCreateFlags GBufferF;
	ETextureCreateFlags GBufferVelocity;
	ETextureCreateFlags HZB;
	ETextureCreateFlags SceneDepth;
	ETextureCreateFlags SceneColor;
	ETextureCreateFlags Bloom;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/SceneTextureParameters.cpp:28

Scope (from outer to inner):

file
function     FSceneTextureParameters GetSceneTextureParameters

Source code excerpt:

	Parameters.GBufferCTexture = GetIfProduced(SceneTextures.GBufferC);
	Parameters.GBufferDTexture = GetIfProduced(SceneTextures.GBufferD);
	Parameters.GBufferETexture = GetIfProduced(SceneTextures.GBufferE);
	Parameters.GBufferFTexture = GetIfProduced(SceneTextures.GBufferF, SystemTextures.MidGrey);

	return Parameters;
}

FSceneTextureParameters GetSceneTextureParameters(FRDGBuilder& GraphBuilder, TRDGUniformBufferRef<FSceneTextureUniformParameters> SceneTextureUniformBuffer)

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/SceneTextures.cpp:571

Scope (from outer to inner):

file
function     void FSceneTextures::InitializeViewFamily

Source code excerpt:

		}

		if (Bindings.GBufferE.Index >= 0)
		{
			const FRDGTextureDesc Desc(FRDGTextureDesc::Create2D(Config.Extent, Bindings.GBufferE.Format, FClearValueBinding::Transparent, Bindings.GBufferE.Flags | FlagsToAdd | GFastVRamConfig.GBufferE));
			SceneTextures.GBufferE = GraphBuilder.CreateTexture(Desc, TEXT("GBufferE"));
		}

		// GBufferF is not yet part of the data driven GBuffer info.
		if (Config.ShadingPath == EShadingPath::Deferred)
		{
			ETextureCreateFlags GBufferFCreateFlags;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/SceneTextures.cpp:671

Scope (from outer to inner):

file
function     uint32 FSceneTextures::GetGBufferRenderTargets

Source code excerpt:

			{ TEXT("GBufferC"), GBufferC, Bindings.GBufferC.Index },
			{ TEXT("GBufferD"), GBufferD, Bindings.GBufferD.Index },
			{ TEXT("GBufferE"), GBufferE, Bindings.GBufferE.Index },
			{ TEXT("Velocity"), Velocity, Bindings.GBufferVelocity.Index }
		};

		for (const FGBufferEntry& Entry : GBufferEntries)
		{
			checkf(Entry.Index <= 0 || Entry.Texture != nullptr, TEXT("Texture '%s' was requested by FGBufferInfo, but it is null."), Entry.Name);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/SceneTextures.cpp:791

Scope (from outer to inner):

file
function     FRDGTextureRef GetSceneTexture

Source code excerpt:

	case ESceneTexture::GBufferC:       return SceneTextures.GBufferC;
	case ESceneTexture::GBufferD:       return SceneTextures.GBufferD;
	case ESceneTexture::GBufferE:       return SceneTextures.GBufferE;
	case ESceneTexture::GBufferF:       return SceneTextures.GBufferF;
	case ESceneTexture::SSAO:           return SceneTextures.ScreenSpaceAO;
	case ESceneTexture::CustomDepth:	return SceneTextures.CustomDepth.Depth;
	default:
		checkNoEntry();
		return nullptr;

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/SceneTextures.cpp:862

Scope (from outer to inner):

file
function     void SetupSceneTextureUniformParameters

Source code excerpt:

			}

			if (EnumHasAnyFlags(SetupMode, ESceneTextureSetupMode::GBufferE) && HasBeenProduced(SceneTextures->GBufferE))
			{
				SceneTextureParameters.GBufferETexture = SceneTextures->GBufferE;
			}

			if (EnumHasAnyFlags(SetupMode, ESceneTextureSetupMode::GBufferF) && HasBeenProduced(SceneTextures->GBufferF))
			{
				SceneTextureParameters.GBufferFTexture = SceneTextures->GBufferF;
			}

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Public/SceneRenderTargetParameters.h:18

Scope: file

Source code excerpt:

	GBufferC,
	GBufferD,
	GBufferE,
	GBufferF,
	SSAO,
	CustomDepth,
};

RENDERER_API FRDGTextureRef GetSceneTexture(const FSceneTextures& SceneTextures, ESceneTexture InSceneTexture);

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Public/SceneRenderTargetParameters.h:36

Scope: file

Source code excerpt:

	GBufferC		= 1 << 5,
	GBufferD		= 1 << 6,
	GBufferE		= 1 << 7,
	GBufferF		= 1 << 8,
	SSAO			= 1 << 9,
	CustomDepth		= 1 << 10,
	GBuffers		= GBufferA | GBufferB | GBufferC | GBufferD | GBufferE | GBufferF,
	All				= SceneColor | SceneDepth | SceneVelocity | GBuffers | SSAO | CustomDepth
};
ENUM_CLASS_FLAGS(ESceneTextureSetupMode);

/** Fills the shader parameter struct. */
extern RENDERER_API void SetupSceneTextureUniformParameters(