// Copyright Epic Games, Inc. All Rights Reserved.

/*=============================================================================
	SceneRendering.h: Scene rendering definitions.
=============================================================================*/

#pragma once

#include "SceneRendererInterface.h"
#include "CoreMinimal.h"
#include "Containers/IndirectArray.h"
#include "Containers/ArrayView.h"
#include "Stats/Stats.h"
#include "RHI.h"
#include "RenderResource.h"
#include "UniformBuffer.h"
#include "GlobalDistanceField.h"
#include "GlobalDistanceFieldParameters.h"
#include "SceneView.h"
#include "RendererInterface.h"
#include "BatchedElements.h"
#include "MeshBatch.h"
#include "ScenePrivateBase.h"
#include "SceneVisibility.h"
#include "PrimitiveSceneInfo.h"
#include "PrimitiveViewRelevance.h"
#include "LightShaftRendering.h"
#include "StaticBoundShaderState.h"
#include "Templates/UniquePtr.h"
#include "MeshDrawCommands.h"
#include "MeshPassProcessor.h"
#include "RayTracingMeshDrawCommands.h"
#include "ShaderPrintParameters.h"
#include "PostProcess/PostProcessAmbientOcclusionMobile.h"
#include "VirtualShadowMaps/VirtualShadowMapArray.h"
#include "VirtualShadowMaps/VirtualShadowMapProjection.h"
#include "Lumen/LumenTranslucencyVolumeLighting.h"
#include "MegaLights/MegaLights.h"
#include "HairStrands/HairStrandsData.h"
#include "Substrate/Substrate.h"
#include "TemporalUpscaler.h"
#include "GPUScene.h"
#include "RenderCore.h"
#include "SceneTextures.h"
#include "TranslucencyPass.h"
#include "SceneTexturesConfig.h"
#include "SceneUniformBuffer.h"
#include "TextureFallbacks.h"
#include "SceneInterface.h"
#include "Async/Mutex.h"
#include "LocalFogVolumeRendering.h"
#include "Nanite/NaniteShared.h"
#include "LightFunctionAtlas.h"
#include "SceneExtensions.h"
#include "PostProcess/LensDistortion.h"

#if RHI_RAYTRACING
#include "RayTracingInstanceBufferUtil.h"
#endif // RHI_RAYTRACING

// Forward declarations.
class FScene;
class FSceneViewState;
class FViewInfo;
struct FILCUpdatePrimTaskData;
class FPostprocessContext;
class FRayTracingLightGrid;
class FRayTracingDecals;
class FRayTracingLocalShaderBindingWriter;
class FVirtualShadowMapClipmap;
class FShadowProjectionPassParameters;
class FSceneTextureShaderParameters;
class FLumenSceneData;
class FShadowSceneRenderer;
class FGlobalShaderMap;
class FVirtualTextureUpdater;
class FExponentialHeightFogSceneInfo;
struct FCloudRenderContext;
struct FSceneWithoutWaterTextures;
struct FHairStrandsVisibilityViews;
struct FSortedLightSetSceneInfo;
enum class EVelocityPass : uint32;
enum class ERayTracingSceneLayer : uint8;
class FTransientLightFunctionTextureAtlas;
struct FSceneTexturesConfig;
struct FMinimalSceneTextures;
struct FSceneTextures;
struct FCustomDepthTextures;
struct FDynamicShadowsTaskData;
class FAtmosphereUniformShaderParameters;
struct FSkyAtmosphereRenderContext;
class FTexture2DResource;
class FSimpleLightArray;
struct FScreenMessageWriter;
struct FVolumetricFogIntegrationParameterData;
class FLumenHardwareRayTracingUniformBufferParameters;
struct FDBufferTextures;
class FDistanceFieldCulledObjectBufferParameters;
class FTileIntersectionParameters;
class FDistanceFieldAOParameters;
namespace Nanite
{
	struct FInstanceDraw;
}

struct FPersistentViewId
{
	bool IsValid() const { return Index != INDEX_NONE; }
	int32 Index = INDEX_NONE;
};

DECLARE_LOG_CATEGORY_EXTERN(LogSceneCapture, Log, All);

struct FSceneCaptureLogUtils
{
	static bool bEnableSceneCaptureLogging;
};

extern bool ShouldUseStereoLumenOptimizations();

DECLARE_GPU_STAT_NAMED_EXTERN(Postprocessing, TEXT("Postprocessing"));
DECLARE_GPU_STAT_NAMED_EXTERN(CustomRenderPasses, TEXT("CustomRenderPasses"));

/** Mobile only. Information used to determine whether static meshes will be rendered with CSM shaders or not. */
class FMobileCSMVisibilityInfo
{
public:
	/** true if there are any primitives affected by CSM subjects */
	uint32 bMobileDynamicCSMInUse : 1;

	// true if all draws should be forced to use CSM shaders.
	uint32 bAlwaysUseCSM : 1;

	/** Visibility lists for static meshes that will use expensive CSM shaders. */
	FSceneBitArray MobilePrimitiveCSMReceiverVisibilityMap;
	FSceneBitArray MobileCSMStaticMeshVisibilityMap;

	/** Visibility lists for static meshes that will use the non CSM shaders. */
	FSceneBitArray MobileNonCSMStaticMeshVisibilityMap;

	/** Initialization constructor. */
	FMobileCSMVisibilityInfo() : bMobileDynamicCSMInUse(false), bAlwaysUseCSM(false)
	{}
};

/** Stores a list of CSM shadow casters. Used by mobile renderer for culling primitives receiving static + CSM shadows. */
class FMobileCSMSubjectPrimitives
{
public:
	/** Adds a subject primitive */
	void AddSubjectPrimitive(const FPrimitiveSceneInfo* PrimitiveSceneInfo, int32 PrimitiveId)
	{
		checkSlow(PrimitiveSceneInfo->GetIndex() == PrimitiveId);
		const int32 PrimitiveIndex = PrimitiveSceneInfo->GetIndex();
		if (!ShadowSubjectPrimitivesEncountered[PrimitiveId])
		{
			ShadowSubjectPrimitives.Add(PrimitiveSceneInfo);
			ShadowSubjectPrimitivesEncountered[PrimitiveId] = true;
		}
	}

	/** Returns the list of subject primitives */
	const TArray<const FPrimitiveSceneInfo*, SceneRenderingAllocator>& GetShadowSubjectPrimitives() const
	{
		return ShadowSubjectPrimitives;
	}

	/** Used to initialize the ShadowSubjectPrimitivesEncountered bit array
	  * to prevent shadow primitives being added more than once. */
	void InitShadowSubjectPrimitives(int32 PrimitiveCount)
	{
		ShadowSubjectPrimitivesEncountered.Init(false, PrimitiveCount);
	}

protected:
	/** List of this light's shadow subject primitives. */
	FSceneBitArray ShadowSubjectPrimitivesEncountered;
	TArray<const FPrimitiveSceneInfo*, SceneRenderingAllocator> ShadowSubjectPrimitives;
};

/** Information about a visible light which is specific to the view it's visible in. */
class FVisibleLightViewInfo
{
public:

	/** Whether each shadow in the corresponding FVisibleLightInfo::AllProjectedShadows array is visible. */
	FSceneBitArray ProjectedShadowVisibilityMap;

	/** The view relevance of each shadow in the corresponding FVisibleLightInfo::AllProjectedShadows array. */
	TArray<FPrimitiveViewRelevance,SceneRenderingAllocator> ProjectedShadowViewRelevanceMap;

	/** true if this light in the view frustum (dir/sky lights always are). */
	uint32 bInViewFrustum : 1;
	/** true if the light didn't get distance culled. */
	uint32 bInDrawRange : 1;

	/** List of CSM shadow casters. Used by mobile renderer for culling primitives receiving static + CSM shadows */
	FMobileCSMSubjectPrimitives MobileCSMSubjectPrimitives;

	/** Initialization constructor. */
	FVisibleLightViewInfo()
	:	bInViewFrustum(false)
	,	bInDrawRange(false)
	{}
};

/** Information about a visible light which isn't view-specific. */
class FVisibleLightInfo
{
public:

	/** All visible projected shadows, output of shadow setup.  Not all of these will be rendered. */
	TArray<FProjectedShadowInfo*,SceneRenderingAllocator> AllProjectedShadows;

	/** Shadows to project for each feature that needs special handling. */
	TArray<FProjectedShadowInfo*,SceneRenderingAllocator> ShadowsToProject;
	TArray<FProjectedShadowInfo*,SceneRenderingAllocator> CapsuleShadowsToProject;

	/** All visible projected preshdows.  These are not allocated on the mem stack so they are refcounted. */
	TArray<TRefCountPtr<FProjectedShadowInfo>,SceneRenderingAllocator> ProjectedPreShadows;

	/** A list of per-object shadows that were occluded. We need to track these so we can issue occlusion queries for them. */
	TArray<FProjectedShadowInfo*,SceneRenderingAllocator> OccludedPerObjectShadows;

	TArray<TSharedPtr<FVirtualShadowMapClipmap>, SceneRenderingAllocator> VirtualShadowMapClipmaps;

	/** 
	* Returns true if the light has only virtual shadow maps (or no shadows at all), i.e. no conventional shadow maps that are allocated
	*/
	bool ContainsOnlyVirtualShadowMaps() const;

	/**
	 * Returns true if there are any virtual shadow maps for any views for this light.
	 */
	bool HasVirtualShadowMap() const { return VirtualShadowMapId != INDEX_NONE; }

	/**
	* Prefer this to direct access of the VirtualShadowMapId member when a view is known.
	* For directional lights this will attempt to find a clipmap associated with the given view,
	* while the VirtualShadowMapId variable will simply be an arbitrary one of them if multiple exist.
	*/
	int32 GetVirtualShadowMapId( const FViewInfo* View ) const;
	int32 VirtualShadowMapId = INDEX_NONE;	
};

// Stores the primitive count of each translucency pass (redundant, could be computed after sorting but this way we touch less memory)
struct FTranslucenyPrimCount
{
private:
	uint32 Count[ETranslucencyPass::TPT_MAX];
	bool UseSceneColorCopyPerPass[ETranslucencyPass::TPT_MAX];

public:
	// constructor
	FTranslucenyPrimCount()
	{
		for(uint32 i = 0; i < ETranslucencyPass::TPT_MAX; ++i)
		{
			Count[i] = 0;
			UseSceneColorCopyPerPass[i] = false;
		}
	}

	// interface similar to TArray but here we only store the count of Prims per pass
	void Append(const FTranslucenyPrimCount& InSrc)
	{
		for(uint32 i = 0; i < ETranslucencyPass::TPT_MAX; ++i)
		{
			Count[i] += InSrc.Count[i];
			UseSceneColorCopyPerPass[i] |= InSrc.UseSceneColorCopyPerPass[i];
		}
	}

	// interface similar to TArray but here we only store the count of Prims per pass
	void Add(ETranslucencyPass::Type InPass, bool bUseSceneColorCopy)
	{
		++Count[InPass];
		UseSceneColorCopyPerPass[InPass] |= bUseSceneColorCopy;
	}

	int32 Num(ETranslucencyPass::Type InPass) const
	{
		return Count[InPass];
	}

	int32 NumPrims() const
	{
		int32 NumTotal = 0;
		for (uint32 PassIndex = 0; PassIndex < ETranslucencyPass::TPT_MAX; ++PassIndex)
		{
			NumTotal += Count[PassIndex];
		}
		return NumTotal;
	}

	bool UseSceneColorCopy(ETranslucencyPass::Type InPass) const
	{
		return UseSceneColorCopyPerPass[InPass];
	}
};

/** A batched occlusion primitive. */
struct FOcclusionPrimitive
{
	FVector Center;
	FVector Extent;
};

// An occlusion query pool with frame based lifetime management
class FFrameBasedOcclusionQueryPool
{
public:
	FFrameBasedOcclusionQueryPool() = default;

	FRHIRenderQuery* AllocateQuery();

	// Recycle queries that are (OcclusionFrameCounter - NumBufferedFrames) old or older
	void AdvanceFrame(uint32 InOcclusionFrameCounter, uint32 InNumBufferedFrames, bool bStereoRoundRobin);

private:
	struct FFrameOcclusionQueries
	{
		TArray<FRenderQueryRHIRef> Queries;
		int32 FirstFreeIndex;
		uint32 OcclusionFrameCounter;

		FFrameOcclusionQueries()
			: FirstFreeIndex(0)
			, OcclusionFrameCounter(0)
		{}
	};

	FFrameOcclusionQueries FrameQueries[FOcclusionQueryHelpers::MaxBufferedOcclusionFrames * 2];
	uint32 CurrentFrameIndex = 0;
	uint32 OcclusionFrameCounter = -1;
	uint32 NumBufferedFrames = 0;
};

/**
 * Combines consecutive primitives which use the same occlusion query into a single DrawIndexedPrimitive call.
 */
class FOcclusionQueryBatcher
{
public:

	/** The maximum number of consecutive previously occluded primitives which will be combined into a single occlusion query. */
	enum { OccludedPrimitiveQueryBatchSize = 16 };

	/** Initialization constructor. */
	FOcclusionQueryBatcher(class FSceneViewState* ViewState, uint32 InMaxBatchedPrimitives, uint32 InNumInstances);

	/** Destructor. */
	~FOcclusionQueryBatcher();

	/** @returns True if the batcher has any outstanding batches, otherwise false. */
	bool HasBatches(void) const { return (NumBatchedPrimitives > 0); }

	/** Renders the current batch and resets the batch state. */
	void Flush(FRHICommandList& RHICmdList);

	/**
	 * Batches a primitive's occlusion query for rendering.
	 * @param Bounds - The primitive's bounds.
	 */
	FRHIRenderQuery* BatchPrimitive(const FVector& BoundsOrigin, const FVector& BoundsBoxExtent, FGlobalDynamicVertexBuffer& DynamicVertexBuffer);
	inline int32 GetNumBatchOcclusionQueries() const
	{
		return BatchOcclusionQueries.Num();
	}

private:

	struct FOcclusionBatch
	{
		FRHIRenderQuery* Query;
		FGlobalDynamicVertexBuffer::FAllocation VertexAllocation;
	};

	/** The pending batches. */
	TArray<FOcclusionBatch,SceneRenderingAllocator> BatchOcclusionQueries;

	/** The batch new primitives are being added to. */
	FOcclusionBatch* CurrentBatchOcclusionQuery;

	/** The maximum number of primitives in a batch. */
	const uint32 MaxBatchedPrimitives;

	/** The number of primitives in the current batch. */
	uint32 NumBatchedPrimitives;

	/** The pool to allocate occlusion queries from. */
	FFrameBasedOcclusionQueryPool* OcclusionQueryPool;

	/** The number of instances for instanced stereo rendering */
	uint32 NumInstances;
};

class FHZBOcclusionTester : public FRenderResource
{
public:
	FHZBOcclusionTester();
	~FHZBOcclusionTester() {}

	// FRenderResource interface
	virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
	virtual void ReleaseRHI() override;
	
	uint32 GetNum() const { return Primitives.Num(); }

	uint32 AddBounds( const FVector& BoundsOrigin, const FVector& BoundsExtent );
	void Submit(FRDGBuilder& GraphBuilder, const FViewInfo& View);

	void MapResults(FRHICommandListImmediate& RHICmdList);
	void UnmapResults(FRHICommandListImmediate& RHICmdList);
	bool IsVisible( uint32 Index ) const;

	bool IsValidFrame(uint32 FrameNumber) const;

	void SetValidFrameNumber(uint32 FrameNumber);

	uint64 GetGPUSizeBytes(bool bLogSizes) const;

private:
	enum { SizeX = 256 };
	enum { SizeY = 256 };
	enum { FrameNumberMask = 0x7fffffff };
	enum { InvalidFrameNumber = 0xffffffff };

	TArray< FOcclusionPrimitive, SceneRenderingAllocator >	Primitives;

	const uint8*						ResultsBuffer;
	int32								ResultsBufferRowPitch;
	TUniquePtr<FRHIGPUTextureReadback>	ResultsReadback;

	bool IsInvalidFrame() const;

	// set ValidFrameNumber to a number that cannot be set by SetValidFrameNumber so IsValidFrame will return false for any frame number
	void SetInvalidFrameNumber();

	uint32 ValidFrameNumber;
};

PRAGMA_DISABLE_DEPRECATION_WARNINGS

/** Helper class to marshal data from your RDG pass into the parallel command list set. */
class UE_DEPRECATED(5.5, "Use GraphBuilder.AddDispatchPass instead") FParallelCommandListBindings
{
public:
	template <typename ParameterStructType>
	FParallelCommandListBindings(ParameterStructType* ParameterStruct)
		: StaticUniformBuffers(GetStaticUniformBuffers(ParameterStruct))
		, bHasRenderPassInfo(HasRenderPassInfo(ParameterStruct))
	{
		if (bHasRenderPassInfo)
		{
			RenderPassInfo = GetRenderPassInfo(ParameterStruct);
		}
	}

	inline void SetOnCommandList(FRHICommandList& RHICmdList) const
	{
		if (bHasRenderPassInfo)
		{
			RHICmdList.BeginRenderPass(RenderPassInfo, TEXT("Parallel"));
		}

		RHICmdList.SetStaticUniformBuffers(StaticUniformBuffers);
	}

	FRHIRenderPassInfo RenderPassInfo;
	FUniformBufferStaticBindings StaticUniformBuffers;
	bool bHasRenderPassInfo;
};

class UE_DEPRECATED(5.5, "Use GraphBuilder.AddDispatchPass instead") FParallelCommandListSet
{
public:
	const FRDGPass* Pass;
	const FViewInfo& View;
	FRHICommandListImmediate& ParentCmdList;
	int32 Width;
	int32 NumAlloc;
	int32 MinDrawsPerCommandList;

private:
	TArray<FRHICommandListImmediate::FQueuedCommandList, SceneRenderingAllocator> QueuedCommandLists;

protected:
	//this must be called by deriving classes virtual destructor because it calls the virtual SetStateOnCommandList.
	//C++ will not do dynamic dispatch of virtual calls from destructors so we can't call it in the base class.
	void Dispatch(bool bHighPriority = false);
	FRHICommandList* AllocCommandList();
	bool bHasRenderPasses;

public:
	FParallelCommandListSet(const FRDGPass* InPass, const FViewInfo& InView, FRHICommandListImmediate& InParentCmdList, bool bHasRenderPasses = true);

	FParallelCommandListSet(const FRDGPass* InPass, TStatId InExecuteStat, const FViewInfo& InView, FRHICommandListImmediate& InParentCmdList, bool bHasRenderPasses = true)
		: FParallelCommandListSet(InPass, InView, InParentCmdList, bHasRenderPasses)
	{}

	virtual ~FParallelCommandListSet();

	int32 NumParallelCommandLists() const
	{
		return QueuedCommandLists.Num();
	}

	FRHICommandList* NewParallelCommandList();

	FORCEINLINE FGraphEventArray* GetPrereqs()
	{
		return nullptr;
	}

	void AddParallelCommandList(FRHICommandList* CmdList);

	virtual void SetStateOnCommandList(FRHICommandList& CmdList) {}
};

class UE_DEPRECATED(5.5, "Use GraphBuilder.AddDispatchPass instead") FRDGParallelCommandListSet final : public FParallelCommandListSet
{
public:
	FRDGParallelCommandListSet(
		const FRDGPass* InPass,
		FRHICommandListImmediate& InParentCmdList,
		const FViewInfo& InView,
		const FParallelCommandListBindings& InBindings,
		float InViewportScale = 1.0f)
		: FParallelCommandListSet(InPass, InView, InParentCmdList, InBindings.bHasRenderPassInfo)
		, Bindings(InBindings)
		, ViewportScale(InViewportScale)
	{}

	FRDGParallelCommandListSet(const FRDGPass* InPass, FRHICommandListImmediate& InParentCmdList, TStatId InStatId, const FViewInfo& InView, const FParallelCommandListBindings& InBindings, float InViewportScale = 1.0f)
		: FRDGParallelCommandListSet(InPass, InParentCmdList, InView, InBindings, InViewportScale)
	{}

	~FRDGParallelCommandListSet() override
	{
		Dispatch(bHighPriority);
	}

	void SetStateOnCommandList(FRHICommandList& RHICmdList) override;

	void SetHighPriority()
	{
		bHighPriority = true;
	}

private:
	FParallelCommandListBindings Bindings;
	float ViewportScale;
	bool bHighPriority = false;
};

PRAGMA_ENABLE_DEPRECATION_WARNINGS

enum EVolumeUpdateType
{
	VUT_MeshDistanceFields = 1,
	VUT_Heightfields = 2,
	VUT_All = VUT_MeshDistanceFields | VUT_Heightfields
};

class FVolumeUpdateRegion
{
public:

	FVolumeUpdateRegion() :
		UpdateType(VUT_All)
	{}

	/** World space bounds. */
	FBox Bounds;

	/** Number of texels in each dimension to update. */
	FIntVector CellsSize;

	EVolumeUpdateType UpdateType;
};

class FClipmapUpdateBounds
{
public:
	FClipmapUpdateBounds()
		: Center(0.0f, 0.0f, 0.0f)
		, bExpandByInfluenceRadius(false)
		, Extent(0.0f, 0.0f, 0.0f)
	{
	}

	FClipmapUpdateBounds(const FVector& InCenter, const FVector& InExtent, bool bInExpandByInfluenceRadius)
		: Center(InCenter)
		, bExpandByInfluenceRadius(bInExpandByInfluenceRadius)
		, Extent(InExtent)
	{
	}

	FVector Center;
	bool bExpandByInfluenceRadius;
	FVector Extent;
};

enum class EGlobalSDFFullRecaptureReason
{
	None,
	TooManyUpdateBounds,
	HeightfieldStreaming,
	MeshSDFStreaming,
	NoViewState
};

class FGlobalDistanceFieldClipmap
{
public:
	/** World space bounds. */
	FBox Bounds;

	/** Offset applied to UVs so that only new or dirty areas of the volume texture have to be updated. */
	FVector ScrollOffset;

	EGlobalSDFFullRecaptureReason FullRecaptureReason = EGlobalSDFFullRecaptureReason::None;

	// Bounds in the volume texture to update.
	TArray<FClipmapUpdateBounds, TInlineAllocator<64>> UpdateBounds;
};

class FGlobalDistanceFieldInfo
{
public:
	bool bInitialized = false;

	TArray<FGlobalDistanceFieldClipmap> MostlyStaticClipmaps;
	TArray<FGlobalDistanceFieldClipmap> Clipmaps;

	FGlobalDistanceFieldParameterData ParameterData;

	TRefCountPtr<FRDGPooledBuffer> PageFreeListAllocatorBuffer;
	TRefCountPtr<FRDGPooledBuffer> PageFreeListBuffer;
	TRefCountPtr<IPooledRenderTarget> PageAtlasTexture;
	TRefCountPtr<IPooledRenderTarget> CoverageAtlasTexture;
	TRefCountPtr<FRDGPooledBuffer> PageObjectGridBuffer;
	TRefCountPtr<IPooledRenderTarget> PageTableCombinedTexture;
	TRefCountPtr<IPooledRenderTarget> PageTableLayerTextures[GDF_Num];
	TRefCountPtr<IPooledRenderTarget> MipTexture;

	void UpdateParameterData(float MaxOcclusionDistance, bool bLumenEnabled, float LumenSceneViewDistance, FVector PreViewTranslation);
};

const int32 GMaxForwardShadowCascades = 4;

BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT_WITH_CONSTRUCTOR(FForwardLightUniformParameters, )
	SHADER_PARAMETER(uint32, NumLocalLights)
	SHADER_PARAMETER(uint32, NumDirectionalLights)
	SHADER_PARAMETER(uint32, NumReflectionCaptures)
	SHADER_PARAMETER(uint32, HasDirectionalLight)
	SHADER_PARAMETER(uint32, NumGridCells)
	SHADER_PARAMETER(FIntVector, CulledGridSize)
	SHADER_PARAMETER(uint32, MaxCulledLightsPerCell)
	SHADER_PARAMETER(uint32, LightGridPixelSizeShift)
	SHADER_PARAMETER(FVector3f, LightGridZParams)
	SHADER_PARAMETER(FVector3f, DirectionalLightDirection)
	SHADER_PARAMETER(float, DirectionalLightSourceRadius)
	SHADER_PARAMETER(float, DirectionalLightSoftSourceRadius)
	SHADER_PARAMETER(FVector3f, DirectionalLightColor)
	SHADER_PARAMETER(float, DirectionalLightVolumetricScatteringIntensity)
	SHADER_PARAMETER(float, DirectionalLightSpecularScale)
	SHADER_PARAMETER(float, DirectionalLightDiffuseScale)
	SHADER_PARAMETER(uint32, DirectionalLightSceneInfoExtraDataPacked)
	SHADER_PARAMETER(FVector2f, DirectionalLightDistanceFadeMAD)
	SHADER_PARAMETER(uint32, NumDirectionalLightCascades)
	SHADER_PARAMETER(int32, DirectionalLightVSM)
	SHADER_PARAMETER(FVector4f, CascadeEndDepths)
	SHADER_PARAMETER_ARRAY(FMatrix44f, DirectionalLightTranslatedWorldToShadowMatrix, [GMaxForwardShadowCascades])
	SHADER_PARAMETER_ARRAY(FVector4f, DirectionalLightShadowmapMinMax, [GMaxForwardShadowCascades])
	SHADER_PARAMETER(FVector4f, DirectionalLightShadowmapAtlasBufferSize)
	SHADER_PARAMETER(float, DirectionalLightDepthBias)
	SHADER_PARAMETER(uint32, DirectionalLightUseStaticShadowing)
	SHADER_PARAMETER(uint32, DirectionalLightHandledByMegaLights)
	SHADER_PARAMETER(uint32, DirectionalMegaLightsSupportedStartIndex)
	SHADER_PARAMETER(FVector4f, DirectionalLightStaticShadowBufferSize)
	SHADER_PARAMETER(FMatrix44f, DirectionalLightTranslatedWorldToStaticShadow)
	SHADER_PARAMETER(uint32, DirectLightingShowFlag)
	SHADER_PARAMETER(uint32, CulledBufferOffsetISR)
	SHADER_PARAMETER(uint32, LightFunctionAtlasLightIndex)
	SHADER_PARAMETER(uint32, bAffectsTranslucentLighting)
	SHADER_PARAMETER(FVector4f, PreViewTranslationOffsetISR)
	SHADER_PARAMETER_RDG_TEXTURE(Texture2D, DirectionalLightShadowmapAtlas)
	SHADER_PARAMETER_SAMPLER(SamplerState, ShadowmapSampler)
	SHADER_PARAMETER_TEXTURE(Texture2D, DirectionalLightStaticShadowmap)
	SHADER_PARAMETER_SAMPLER(SamplerState, StaticShadowmapSampler)
	SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer<float4>, ForwardLightBuffer)
	SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer<uint>, NumCulledLightsGrid)
	SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer<uint>, CulledLightDataGrid32Bit)
	SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer<uint>, CulledLightDataGrid16Bit)
	SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer<uint>, DirectionalLightIndices)
	SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer<FLightViewData>, LightViewData)
END_GLOBAL_SHADER_PARAMETER_STRUCT()

extern TRDGUniformBufferRef<FForwardLightUniformParameters> CreateDummyForwardLightUniformBuffer(FRDGBuilder& GraphBuilder, EShaderPlatform ShaderPlatform);
extern void SetDummyForwardLightUniformBufferOnViews(FRDGBuilder& GraphBuilder, EShaderPlatform ShaderPlatform, TArray<FViewInfo>& Views);

class FForwardLightingViewResources
{
public:
	void SetUniformBuffer(TRDGUniformBufferRef<FForwardLightUniformParameters> UniformBuffer)
	{
		check(UniformBuffer);
		ForwardLightUniformBuffer = UniformBuffer;
		ForwardLightUniformParameters = UniformBuffer->GetContents();
	}

	const FForwardLightUniformParameters* ForwardLightUniformParameters = nullptr;
	TRDGUniformBufferRef<FForwardLightUniformParameters> ForwardLightUniformBuffer = nullptr;

	const FLightSceneProxy* SelectedForwardDirectionalLightProxy = nullptr;

	// Buffers shared between primary and secondary view in single-pass stereo
	FRDGBufferSRVRef CulledLightDataGridSRV;
	FRDGBufferUAVRef CulledLightDataGridUAV;
	FRDGBufferSRVRef NumCulledLightsGridSRV;
	FRDGBufferUAVRef NumCulledLightsGridUAV;
};

BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT_WITH_CONSTRUCTOR(FVolumetricFogGlobalData,) 
	SHADER_PARAMETER(FIntVector,ViewGridSizeInt)
	SHADER_PARAMETER(FVector3f, ViewGridSize)
	SHADER_PARAMETER(FIntVector,ResourceGridSizeInt)
	SHADER_PARAMETER(FVector3f, ResourceGridSize)
	SHADER_PARAMETER(FVector3f, GridZParams)
	SHADER_PARAMETER(FVector2f, SVPosToVolumeUV)
	SHADER_PARAMETER(float, MaxDistance)
	SHADER_PARAMETER(float, LightSoftFading)
	SHADER_PARAMETER(FVector3f, HeightFogInscatteringColor)
	SHADER_PARAMETER(FVector3f, HeightFogDirectionalLightInscatteringColor)
	SHADER_PARAMETER(FIntPoint, FogGridToPixelXY)
END_GLOBAL_SHADER_PARAMETER_STRUCT()

extern void SetupVolumetricFogGlobalData(const FViewInfo& View, FVolumetricFogGlobalData& Parameters);

struct FTransientLightFunctionTextureAtlasTile
{
	bool bIsDefault;		// If true, then the atlas item generation can be skipped
	FRDGTextureRef Texture;
	FIntRect RectBound;
	FVector4f MinMaxUvBound;
};

struct FVolumetricFogLocalLightFunctionInfo
{
	FTransientLightFunctionTextureAtlasTile AtlasTile;
	FMatrix44f LightFunctionTranslatedWorldToLightMatrix;
};

class FVolumetricFogViewResources
{
public:
	TUniformBufferRef<FVolumetricFogGlobalData> VolumetricFogGlobalData;

	FRDGTextureRef IntegratedLightScatteringTexture = nullptr;

	FVolumetricFogViewResources()
	{}

	void Release()
	{
		IntegratedLightScatteringTexture = nullptr;
	}
};

struct FVolumetricMeshBatch
{
	const FMeshBatch* Mesh;
	const FPrimitiveSceneProxy* Proxy;

	FVolumetricMeshBatch(const FMeshBatch* M, const FPrimitiveSceneProxy* P)
		: Mesh(M)
		, Proxy(P)
	{}

	FORCEINLINE bool operator==(const FVolumetricMeshBatch& rhs) const
	{
		return (Mesh->MeshIdInPrimitive == rhs.Mesh->MeshIdInPrimitive) && (Proxy == rhs.Proxy);
	}
};

struct FSkyMeshBatch
{
	const FMeshBatch* Mesh;
	const FPrimitiveSceneProxy* Proxy;
	bool bVisibleInMainPass : 1;
	bool bVisibleInRealTimeSkyCapture : 1;
};

struct FSortedTrianglesMeshBatch
{
	const FMeshBatch* Mesh = nullptr;
	const FPrimitiveSceneProxy* Proxy = nullptr;
};

// DX11 maximum 2d texture array size is D3D11_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION = 2048, and 2048/6 = 341.33.
UE_DEPRECATED(5.4, "Using GMaxNumReflectionCaptures directly is deprecated. Please use GetMaxNumReflectionCaptures(EShaderPlatform) instead")
static const int32 GMaxNumReflectionCaptures = 341;

/** Per-reflection capture data needed by the shader. */
PRAGMA_DISABLE_DEPRECATION_WARNINGS
BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT(FReflectionCaptureShaderData,)
	SHADER_PARAMETER_ARRAY(FVector4f,PositionHighAndRadius,[GMaxNumReflectionCaptures])
	// W is unused
	SHADER_PARAMETER_ARRAY(FVector4f,PositionLow,[GMaxNumReflectionCaptures])
	// R is brightness, G is array index, B is shape
	SHADER_PARAMETER_ARRAY(FVector4f,CaptureProperties,[GMaxNumReflectionCaptures])
	SHADER_PARAMETER_ARRAY(FVector4f,CaptureOffsetAndAverageBrightness,[GMaxNumReflectionCaptures])
	// Stores the box transform for a box shape, other data is packed for other shapes
	SHADER_PARAMETER_ARRAY(FMatrix44f,BoxTransform,[GMaxNumReflectionCaptures])
	SHADER_PARAMETER_ARRAY(FVector4f,BoxScales,[GMaxNumReflectionCaptures])
END_GLOBAL_SHADER_PARAMETER_STRUCT()
PRAGMA_ENABLE_DEPRECATION_WARNINGS

UE_DEPRECATED(5.4, "Using GMobileMaxNumReflectionCaptures directly is deprecated. Please use GetMaxNumReflectionCaptures(EShaderPlatform) instead")
static const int32 GMobileMaxNumReflectionCaptures = 100;

PRAGMA_DISABLE_DEPRECATION_WARNINGS
BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT(FMobileReflectionCaptureShaderData, )
	SHADER_PARAMETER_ARRAY(FVector4f,PositionHighAndRadius,[GMobileMaxNumReflectionCaptures])
	// W is unused
	SHADER_PARAMETER_ARRAY(FVector4f,PositionLow,[GMobileMaxNumReflectionCaptures])
	// R is brightness, G is array index, B is shape
	SHADER_PARAMETER_ARRAY(FVector4f,CaptureProperties,[GMobileMaxNumReflectionCaptures])
	SHADER_PARAMETER_ARRAY(FVector4f,CaptureOffsetAndAverageBrightness,[GMobileMaxNumReflectionCaptures])
	// Stores the box transform for a box shape, other data is packed for other shapes
	SHADER_PARAMETER_ARRAY(FMatrix44f,BoxTransform,[GMobileMaxNumReflectionCaptures])
	SHADER_PARAMETER_ARRAY(FVector4f,BoxScales,[GMobileMaxNumReflectionCaptures])
END_GLOBAL_SHADER_PARAMETER_STRUCT()
PRAGMA_ENABLE_DEPRECATION_WARNINGS

extern int32 GetMaxNumReflectionCaptures(EShaderPlatform ShaderPlatform);

// Structure in charge of storing all information about TAA's history.
struct FTemporalAAHistory
{
	// Number of render target in the history.
	static constexpr int32 kRenderTargetCount = 2;

	// Render targets holding's pixel history.
	//  scene color's RGBA are in OutputRT[0].
	TStaticArray<TRefCountPtr<IPooledRenderTarget>, kRenderTargetCount> RT;

	// Reference size of RT. Might be different than RT's actual size to handle down res.
	FIntPoint ReferenceBufferSize;

	// Viewport coordinate of the history in RT according to ReferenceBufferSize.
	FIntRect ViewportRect;

	// Returns the slice index that contains the output in RT[0].
	int32 OutputSliceIndex = 0;


	void SafeRelease()
	{
		*this = FTemporalAAHistory();
	}

	bool IsValid() const
	{
		return RT[0].IsValid();
	}

	uint64 GetGPUSizeBytes(bool bLogSizes) const;
};

// Structure in charge of storing all information about TSR's history.
struct FTSRHistory
{
	// Output resolution.
	TRefCountPtr<IPooledRenderTarget> ColorArray;
	TRefCountPtr<IPooledRenderTarget> MetadataArray;

	// Input resolution representation of the output
	TRefCountPtr<IPooledRenderTarget> GuideArray;
	TRefCountPtr<IPooledRenderTarget> MoireArray;
	TRefCountPtr<IPooledRenderTarget> CoverageArray;

	// Frame's input and output resolution.
	FIntRect InputViewportRect;
	FIntRect OutputViewportRect;

	// Format of the history for auto camera cut when setting change.
	uint32 FormatBit = 0;

	// Number of frame in history.
	int32 FrameStorageCount = 1;
	int32 FrameStoragePeriod = 1;
	int32 AccumulatedFrameCount = 1;
	int32 LastFrameRollingIndex = 0;

	// All the information the previous frames for resurrection.
	TArray<FViewMatrices> ViewMatrices;
	TArray<float> SceneColorPreExposures;
	TArray<FIntRect> InputViewportRects;
	TArray<TRefCountPtr<IPooledRenderTarget>> DistortingDisplacementTextures;


	void SafeRelease()
	{
		*this = FTSRHistory();
	}

	bool IsValid() const
	{
		return MetadataArray.IsValid();
	}

	uint64 GetGPUSizeBytes(bool bLogSizes) const;
};

/** Temporal history for a denoiser. */
struct FScreenSpaceDenoiserHistory
{
	// Number of history render target to store.
	static constexpr int32 RTCount = 3;

	// Scissors of valid data in the render target (can be multiple if there are split screen views)
	TArray<FIntRect, TInlineAllocator<1>> Scissors;

	// Render target specific to the history.
	TStaticArray<TRefCountPtr<IPooledRenderTarget>, RTCount> RT;

	// The texture for tile classification.
	TRefCountPtr<IPooledRenderTarget> TileClassification;


	void SafeRelease()
	{
		for (int32 i = 0; i < RTCount; i++)
			RT[i].SafeRelease();
		TileClassification.SafeRelease();
	}

	bool IsValid() const
	{
		return RT[0].IsValid();
	}

	uint64 GetGPUSizeBytes(bool bLogSizes) const;
};



// Structure for storing a frame of GTAO history.
struct FGTAOTAAHistory
{
	// Render targets holding a frame's pixel history.
	//  scene color's RGBA are in RT[0].
	TRefCountPtr<IPooledRenderTarget> RT;

	// Reference size of RT. Might be different than RT's actual size to handle down res.
	FIntPoint ReferenceBufferSize;

	// Viewport coordinate of the history in RT according to ReferenceBufferSize.
	FIntRect ViewportRect;

	void SafeRelease()
	{
		RT.SafeRelease();
	}

	bool IsValid() const
	{
		return RT.IsValid();
	}
};

// Structure that hold all information related to previous frame.
struct FPreviousViewInfo
{
	// View rect
	FIntRect ViewRect;

	// View matrices.
	FViewMatrices	ViewMatrices;

	// Scene color's PreExposure.
	float SceneColorPreExposure = 1.0f;

	bool bUsesGlobalDistanceField = false;

	// Depth buffer and Normals of the previous frame generating this history entry for bilateral kernel rejection.
	TRefCountPtr<IPooledRenderTarget> DepthBuffer;
	TRefCountPtr<IPooledRenderTarget> GBufferA;
	TRefCountPtr<IPooledRenderTarget> GBufferB;
	TRefCountPtr<IPooledRenderTarget> GBufferC;

	TRefCountPtr<IPooledRenderTarget> HZB;
	TRefCountPtr<IPooledRenderTarget> NaniteHZB;

	// Distorting displacement texture applied.
	TRefCountPtr<IPooledRenderTarget> DistortingDisplacementTexture;

	// Bit mask used to interpret per-instance occlusion query results for this view.
	// Expected to contain a single active bit or zero if instance occlusion query data is not available.
	// See FInstanceCullingOcclusionQueryRenderer.
	uint32 InstanceOcclusionQueryMask = 0;

	// Compressed scene textures for bandwidth efficient bilateral kernel rejection.
	// DeviceZ as float16, and normal in view space.
	TRefCountPtr<IPooledRenderTarget> CompressedDepthViewNormal;

	// 16bit compressed depth buffer with opaque only.
	TRefCountPtr<IPooledRenderTarget> CompressedOpaqueDepth;

	// R8_UINT Shading model ID with opaque only.
	TRefCountPtr<IPooledRenderTarget> CompressedOpaqueShadingModel;

	// Bleed free scene color to use for screen space ray tracing.
	TRefCountPtr<IPooledRenderTarget> ScreenSpaceRayTracingInput;

	// Temporal AA result of last frame
	FTemporalAAHistory TemporalAAHistory;

	// Temporal Super Resolution result of last frame
	FTSRHistory TSRHistory;

	// Custom Temporal AA result of last frame, used by plugins
	TRefCountPtr<UE::Renderer::Private::ITemporalUpscaler::IHistory> ThirdPartyTemporalUpscalerHistory;

	// Half resolution version temporal AA result of last frame
	TRefCountPtr<IPooledRenderTarget> HalfResTemporalAAHistory;

	// Temporal AA history for diaphragm DOF.
	FTemporalAAHistory DOFSetupHistory;
	
	// Temporal AA history for SSR
	FTemporalAAHistory SSRHistory;
	FTemporalAAHistory WaterSSRHistory;

	// Temporal AA history for Rough refraction
	FTemporalAAHistory RoughRefractionHistory;

	// Temporal AA history for Hair
	FTemporalAAHistory HairHistory;

#if UE_ENABLE_DEBUG_DRAWING
	// Temporal AA history for the editor primitive depth upsampling
	FTemporalAAHistory CompositePrimitiveDepthHistory;
#endif

	// Scene color input for SSR, that can be different from TemporalAAHistory.RT[0] if there is a SSR
	// input post process material.
	FTemporalAAHistory CustomSSRInput;

	// History for the reflections
	FScreenSpaceDenoiserHistory ReflectionsHistory;
	FScreenSpaceDenoiserHistory WaterReflectionsHistory;
	
	// History for the ambient occlusion
	FScreenSpaceDenoiserHistory AmbientOcclusionHistory;

	// History for GTAO
	FGTAOTAAHistory				 GTAOHistory;

	// History for global illumination
	FScreenSpaceDenoiserHistory DiffuseIndirectHistory;

	// History for sky light
	FScreenSpaceDenoiserHistory SkyLightHistory;

	// History for reflected sky light
	FScreenSpaceDenoiserHistory ReflectedSkyLightHistory;

	// History for shadow denoising.
	TMap<const ULightComponent*, TSharedPtr<FScreenSpaceDenoiserHistory>> ShadowHistories;

	// History for denoising all lights penumbra at once.
	FScreenSpaceDenoiserHistory PolychromaticPenumbraHarmonicsHistory;

	// History for the final back buffer luminance
	TRefCountPtr<IPooledRenderTarget> LuminanceHistory;

	// History for the final back buffer luminance view rect
	FIntRect LuminanceViewRectHistory;

	// Mobile bloom setup eye adaptation surface.
	TRefCountPtr<IPooledRenderTarget> MobileBloomSetup_EyeAdaptation;

	// Mobile ambient occlusion texture used for next frame.
	TRefCountPtr<IPooledRenderTarget> MobileAmbientOcclusion = nullptr;

	// Scene color used for reprojecting next frame to verify the motion vector reprojects correctly.
	TRefCountPtr<IPooledRenderTarget> VisualizeMotionVectors;
	FIntRect VisualizeMotionVectorsRect;
	bool bIsVisualizeMotionVectorsDistorted = false;

	uint64 GetGPUSizeBytes(bool bLogSizes) const;
};

#if RHI_RAYTRACING

namespace RayTracing
{
	enum class ECullingMode : uint8;
};

struct FRayTracingCullingParameters
{
	RayTracing::ECullingMode CullingMode;
	float CullingRadius;
	float FarFieldCullingRadius;
	float CullAngleThreshold;
	float AngleThresholdRatio;
	float AngleThresholdRatioSq;
	FVector ViewOrigin;
	FVector ViewDirection;
	FVector3f TranslatedViewOrigin;
	bool bCullAllObjects;
	bool bCullByRadiusOrDistance;
	bool bIsRayTracingFarField;
	bool bCullUsingGroupIds;
	bool bCullMinDrawDistance;
	bool bUseInstanceCulling;

	void Init(FViewInfo& View);
};

#endif

struct FPrimitiveInstanceRange
{
	int32 PrimitiveIndex;
	int32 InstanceSceneDataOffset;
	int32 NumInstances;
};

/** A FSceneView with additional state used by the scene renderer. */
class FViewInfo : public FSceneView
{
public:
	FSceneRenderingBulkObjectAllocator Allocator;

	/* Final position of the view in the final render target (in pixels), potentially scaled by ScreenPercentage */
	FIntRect ViewRect;

	/** 
	 * The view's state, or NULL if no state exists.
	 * This should be used internally to the renderer module to avoid having to cast View.State to an FSceneViewState*
	 */
	FSceneViewState* ViewState;

	/** Cached view uniform shader parameters, to allow recreating the view uniform buffer without having to fill out the entire struct. */
	TUniquePtr<FViewUniformShaderParameters> CachedViewUniformShaderParameters;

	/** A map from primitive ID to a boolean visibility value. */
	FSceneBitArray PrimitiveVisibilityMap;

	/** A map from primitive ID to a boolean ray tracing visibility value. */
	FSceneBitArray PrimitiveRayTracingVisibilityMap;

	/** Bit set when a primitive is known to be un-occluded. */
	FSceneBitArray PrimitiveDefinitelyUnoccludedMap;

	/** A map from primitive ID to a boolean is fading value. */
	FSceneBitArray PotentiallyFadingPrimitiveMap;

	/** Primitive fade uniform buffers, indexed by packed primitive index. */
	TArray<FRHIUniformBuffer*,SceneRenderingAllocator> PrimitiveFadeUniformBuffers;

	/**  Bit set when a primitive has a valid fade uniform buffer. */
	FSceneBitArray PrimitiveFadeUniformBufferMap;

	/** One frame dither fade in uniform buffer. */
	FUniformBufferRHIRef DitherFadeInUniformBuffer;

	/** One frame dither fade out uniform buffer. */
	FUniformBufferRHIRef DitherFadeOutUniformBuffer;

	/** A map from primitive ID to the primitive's view relevance. */
	TArray<FPrimitiveViewRelevance,SceneRenderingAllocator> PrimitiveViewRelevanceMap;

	/** A map from static mesh ID to a boolean visibility value. */
	FSceneBitArray StaticMeshVisibilityMap;

	/** A map from static mesh ID to a boolean dithered LOD fade out value. */
	FSceneBitArray StaticMeshFadeOutDitheredLODMap;

	/** A map from static mesh ID to a boolean dithered LOD fade in value. */
	FSceneBitArray StaticMeshFadeInDitheredLODMap;

	/** Will only contain relevant primitives for view and/or shadow */
	TArray<FLODMask, SceneRenderingAllocator> PrimitivesLODMask;

	/** The dynamic primitives with simple lights visible in this view. */
	TArray<FPrimitiveSceneInfo*, SceneRenderingAllocator> VisibleDynamicPrimitivesWithSimpleLights;

	/** Number of dynamic primitives visible in this view. */
	int32 NumVisibleDynamicPrimitives;

	/** Number of dynamic editor primitives visible in this view. */
	int32 NumVisibleDynamicEditorPrimitives;

	/** Number of dynamic mesh elements per mesh pass (inside FViewInfo::DynamicMeshElements). */
	int32 NumVisibleDynamicMeshElements[EMeshPass::Num];

	/** List of visible primitives with dirty indirect lighting cache buffers */
	TArray<FPrimitiveSceneInfo*,SceneRenderingAllocator> DirtyIndirectLightingCacheBufferPrimitives;
	UE::FMutex DirtyIndirectLightingCacheBufferPrimitivesMutex; 

	/** Maps a single primitive to it's per view translucent self shadow uniform buffer. */
	FTranslucentSelfShadowUniformBufferMap TranslucentSelfShadowUniformBufferMap;

	/** View dependent global distance field clipmap info. */
	FGlobalDistanceFieldInfo& GlobalDistanceFieldInfo = *Allocator.Create<FGlobalDistanceFieldInfo>();

	/** Count of translucent prims for this view. */
	FTranslucenyPrimCount TranslucentPrimCount;
	
	bool bHasDistortionPrimitives;
	bool bHasCustomDepthPrimitives;

    /** Get all stencil values written into the custom depth pass */
	TSet<uint32, DefaultKeyFuncs<uint32>, SceneRenderingSetAllocator> CustomDepthStencilValues;

	/** Get the GPU Scene instance ranges of visible Nanite primitives writing custom depth. */
	TArray<FPrimitiveInstanceRange, SceneRenderingAllocator> NaniteCustomDepthInstances;

	/** Mesh batches with a volumetric material. */
	TArray<FVolumetricMeshBatch, SceneRenderingAllocator> VolumetricMeshBatches;

	/** Mesh batches for heterogeneous volumes rendering. */
	TArray<FVolumetricMeshBatch, SceneRenderingAllocator> HeterogeneousVolumesMeshBatches;

	/** Mesh batches with a sky material. */
	TArray<FSkyMeshBatch, SceneRenderingAllocator> SkyMeshBatches;

	/** Mesh batches with a triangle sorting. */
	TArray<FSortedTrianglesMeshBatch, SceneRenderingAllocator> SortedTrianglesMeshBatches;

	/** A map from light ID to a boolean visibility value. */
	TArray<FVisibleLightViewInfo, SceneRenderingAllocator> VisibleLightInfos;

	/** Tracks the list of visible reflection capture lights that need to add meshes to the view. */
	TArray<const FLightSceneProxy*, SceneRenderingAllocator> VisibleReflectionCaptureLights;

	/** The view's batched elements. */
	FBatchedElements& BatchedViewElements = *Allocator.Create<FBatchedElements>();

	/** The view's batched elements, above all other elements, for gizmos that should never be occluded. */
	FBatchedElements& TopBatchedViewElements = *Allocator.Create<FBatchedElements>();

	/** The view's mesh elements. */
	TIndirectArray<FMeshBatch, SceneRenderingAllocator> ViewMeshElements;

	/** The view's mesh elements for the foreground (editor gizmos and primitives )*/
	TIndirectArray<FMeshBatch, SceneRenderingAllocator> TopViewMeshElements;

	/** The dynamic resources used by the view elements. */
	TArray<FDynamicPrimitiveResource*, SceneRenderingAllocator> DynamicResources;

	/** Gathered in initviews from all the primitives with dynamic view relevance, used in each mesh pass. */
	TArray<FMeshBatchAndRelevance,SceneRenderingAllocator> DynamicMeshElements;

	/* [PrimitiveIndex] = end index index in DynamicMeshElements[], to support GetDynamicMeshElementRange(). Contains valid values only for visible primitives with bDynamicRelevance. */
	TArray<FInt32Vector2, SceneRenderingAllocator> DynamicMeshElementRanges;

	/** Hair strands & cards dynamic mesh element. */
	TArray<FMeshBatchAndRelevance, SceneRenderingAllocator> HairStrandsMeshElements;
	TArray<FMeshBatchAndRelevance, SceneRenderingAllocator> HairCardsMeshElements;

	/* Mesh pass relevance for gathered dynamic mesh elements. */
	TArray<FMeshPassMask, SceneRenderingAllocator> DynamicMeshElementsPassRelevance;

	/** Gathered in UpdateRayTracingWorld from all the primitives with dynamic view relevance, used in each mesh pass. */
	TArray<FMeshBatchAndRelevance, SceneRenderingAllocator> RayTracedDynamicMeshElements;

	TArray<FMeshBatchAndRelevance,SceneRenderingAllocator> DynamicEditorMeshElements;

	FSimpleElementCollector& SimpleElementCollector = *Allocator.Create<FSimpleElementCollector>();

	FSimpleElementCollector& EditorSimpleElementCollector = *Allocator.Create<FSimpleElementCollector>();;

#if UE_ENABLE_DEBUG_DRAWING
	//Separate DebugSimpleElementCollector to not conflate any other simple element collector draws which may have been added from non-debug draw passes (e.g. non-opaque draws)
	FSimpleElementCollector& DebugSimpleElementCollector = *Allocator.Create<FSimpleElementCollector>();;
#endif

	FParallelMeshDrawCommandPass* CreateMeshPass(EMeshPass::Type MeshPass);

	TStaticArray<FParallelMeshDrawCommandPass*, EMeshPass::Num> ParallelMeshDrawCommandPasses = TStaticArray<FParallelMeshDrawCommandPass*, EMeshPass::Num>(InPlace, nullptr);

#if RHI_RAYTRACING 
	FRayTracingShaderBindingDataOneFrameArray DirtyPersistentRayTracingShaderBindings;
	FRayTracingShaderBindingDataOneFrameArray VisibleRayTracingShaderBindings;
	FDynamicRayTracingMeshCommandStorage DynamicRayTracingMeshCommandStorage;
	TSet<FRDGBuffer*> DynamicRayTracingRDGBuffers;

	FRayTracingCullingParameters RayTracingCullingParameters;

	UE::Tasks::FTask RayTracingSceneInitTask; // Task to asynchronously call RayTracingScene.BuildInitializationData()
	UE::Tasks::FTask VisibleRayTracingShaderBindingsFinalizeTask;

	TArray<UE::Tasks::FTask> AddDynamicRayTracingMeshBatchTaskList;
	TArray<FRayTracingShaderBindingDataOneFrameArray*, SceneRenderingAllocator> DynamicRayTracingShaderBindingsPerTask;
	TArray<FDynamicRayTracingMeshCommandStorage*, SceneRenderingAllocator> DynamicRayTracingMeshCommandStoragePerTask;
#endif

	// Used by mobile renderer to determine whether static meshes will be rendered with CSM shaders or not.
	FMobileCSMVisibilityInfo MobileCSMVisibilityInfo;

	FSubstrateViewData& SubstrateViewData = *Allocator.Create<FSubstrateViewData>();

	FLocalFogVolumeViewData& LocalFogVolumeViewData = *Allocator.Create<FLocalFogVolumeViewData>();

	FHairStrandsViewData& HairStrandsViewData = *Allocator.Create<FHairStrandsViewData>();

	LightFunctionAtlas::FLightFunctionAtlasViewData LightFunctionAtlasViewData;

	/** Parameters for exponential height fog. */
	FVector4f ExponentialFogParameters;
	FVector4f ExponentialFogParameters2;
	FVector3f ExponentialFogColor;
	float FogMaxOpacity;
	FVector4f ExponentialFogParameters3;
	FVector4f SkyAtmosphereAmbientContributionColorScale;
	float FogEndDistance;
	bool bEnableVolumetricFog;
	float VolumetricFogStartDistance;
	float VolumetricFogNearFadeInDistanceInv;
	FVector3f VolumetricFogAlbedo;
	float VolumetricFogPhaseG;
	FVector2f SinCosInscatteringColorCubemapRotation;

	UTexture* FogInscatteringColorCubemap;
	FVector FogInscatteringTextureParameters;

	/** Parameters for directional inscattering of exponential height fog. */
	bool bUseDirectionalInscattering;
	float DirectionalInscatteringExponent;
	float DirectionalInscatteringStartDistance;
	FVector InscatteringLightDirection;
	FLinearColor DirectionalInscatteringColor;

	/** Translucency lighting volume properties. */
	FVector TranslucencyLightingVolumeMin[TVC_MAX];
	float TranslucencyVolumeVoxelSize[TVC_MAX];
	FVector TranslucencyLightingVolumeSize[TVC_MAX];

	/** Optional source view for temporal AA, to handle custom render passes and scene captures sharing the main view's camera (jitter needs to match) */
	FViewInfo* TemporalSourceView;

	/** Number of samples in the temporal AA sequqnce */
	int32 TemporalJitterSequenceLength;

	/** Index of the temporal AA jitter in the sequence. */
	int32 TemporalJitterIndex;

	/** Temporal AA jitter at the pixel scale. */
	FVector2D TemporalJitterPixels;

	/** Whether FSceneViewState::PrevFrameViewInfo can be updated with this view. */
	uint32 bStatePrevViewInfoIsReadOnly : 1;

	/** true if all PrimitiveVisibilityMap's bits are set to false. */
	uint32 bHasNoVisiblePrimitive : 1;

	/** true if the view has at least one mesh with a translucent material. */
	uint32 bHasTranslucentViewMeshElements : 1;
	/** Indicates whether previous frame transforms were reset this frame for any reason. */
	uint32 bPrevTransformsReset : 1;
	/** Whether we should ignore queries from last frame (useful to ignoring occlusions on the first frame after a large camera movement). */
	uint32 bIgnoreExistingQueries : 1;
	/** Whether we should submit new queries this frame. (used to disable occlusion queries completely. */
	uint32 bDisableQuerySubmissions : 1;
	/** Whether the view has any materials that use the global distance field. */
	uint32 bUsesGlobalDistanceField : 1;
	uint32 bUsesLightingChannels : 1;
	uint32 bTranslucentSurfaceLighting : 1;
	uint32 bCustomDepthStencilValid : 1;
	uint32 bUsesCustomDepth : 1;
	uint32 bUsesCustomStencil : 1;

	/** Whether fog should only be computed on rendered opaque pixels or not. */
	uint32 bFogOnlyOnRenderedOpaque : 1;

	/**
	 * true if the scene has at least one mesh with a material tagged as sky. 
	 * This is used to skip the sky rendering part during the SkyAtmosphere pass on non mobile platforms.
	 */
	uint32 bSceneHasSkyMaterial : 1;
	/**
	 * true if the scene has at least one mesh with a material tagged as water visible in a view.
	 */
	uint32 bHasSingleLayerWaterMaterial : 1;
	/**
	 * True if the scene has at least one mesh that needs to sample form the first stage depth buffer.
	 * And as such will need to render in the second stage depth buffer after the first stage depth buffer is copied.
	 * The first stage depth buffer is usually used for depth buffer collision and projection of Niagara's particles.
	 */
	uint32 bUsesSecondStageDepthPass : 1;

	/**
	 * Set to true if this is a scene capture sharing temporal AA jitter with the main view camera.  Needed to force temporal jitter
	 * logic to run when post processing is disabled for the scene capture, which otherwise disables jitter.
	 */
	uint32 bSceneCaptureMainViewJitter : 1;

	/** Whether post DOF translucency should be rendered before DOF if primitive bounds behind DOF's focus distance. */
	float AutoBeforeDOFTranslucencyBoundary;

	/** Bitmask of all shading models used by primitives in this view */
	uint16 ShadingModelMaskInView;

	/** Informations from the previous frame to use for this view. */
	FPreviousViewInfo& PrevViewInfo = *Allocator.Create<FPreviousViewInfo>();

	/** An intermediate number of visible static meshes.  Doesn't account for occlusion until after FinishOcclusionQueries is called. */
	int32 NumVisibleStaticMeshElements;

	/** Frame's exposure. Always > 0. */
	float PreExposure;

	/** Precomputed visibility data, the bits are indexed by VisibilityId of a primitive component. */
	const uint8* PrecomputedVisibilityData;

	FOcclusionQueryBatcher IndividualOcclusionQueries;
	FOcclusionQueryBatcher GroupedOcclusionQueries;

	// Furthest and closest Hierarchical Z Buffer
	FRDGTextureRef HZB = nullptr;
	FRDGTextureRef ClosestHZB = nullptr;

	struct FTranslucencyVolumeMarkData
	{
		FRDGTextureRef MarkTexture = nullptr;
		FRDGBufferRef VoxelAllocator = nullptr;
		FRDGBufferRef VoxelData = nullptr;
		FRDGBufferRef VoxelIndirectArgs = nullptr;
	};

	TStaticArray<FTranslucencyVolumeMarkData, TVC_MAX> TranslucencyVolumeMarkData = {};

	int32 NumBoxReflectionCaptures;
	int32 NumSphereReflectionCaptures;
	float FurthestReflectionCaptureDistance;
	TUniformBufferRef<FReflectionCaptureShaderData> ReflectionCaptureUniformBuffer;
	TUniformBufferRef<FMobileReflectionCaptureShaderData> MobileReflectionCaptureUniformBuffer;

	// Sky / Atmosphere textures (transient owned by this view info) and pointer to constants owned by SkyAtmosphere proxy.
	TRefCountPtr<IPooledRenderTarget> SkyAtmosphereCameraAerialPerspectiveVolume;
	TRefCountPtr<IPooledRenderTarget> SkyAtmosphereCameraAerialPerspectiveVolumeMieOnly;
	TRefCountPtr<IPooledRenderTarget> SkyAtmosphereCameraAerialPerspectiveVolumeRayOnly;
	TRefCountPtr<IPooledRenderTarget> SkyAtmosphereViewLutTexture;
	const FAtmosphereUniformShaderParameters* SkyAtmosphereUniformShaderParameters;

	FRDGTextureRef VolumetricCloudSkyAO = nullptr;
	TUniformBufferRef<FViewUniformShaderParameters> VolumetricRenderTargetViewUniformBuffer;
	// The effective cloud shadow target this frame independently of the fact that a view can have a state (primary view) or not (sky light reflection capture)
	FRDGTextureRef VolumetricCloudShadowRenderTarget[NUM_ATMOSPHERE_LIGHTS] = {};
	// We need to extract that RDG resource because the RHI must be accessed to setup FTranslucentLightingInjectPS & TVolumetricFogLightScatteringCS
	TRefCountPtr<IPooledRenderTarget> VolumetricCloudShadowExtractedRenderTarget[NUM_ATMOSPHERE_LIGHTS] = {};

	FForwardLightingViewResources ForwardLightingResources;
	FVolumetricFogViewResources VolumetricFogResources;

	bool bLightGridHasRectLights = false;
	bool bLightGridHasTexturedLights = false;

	FRDGTextureRef HeterogeneousVolumeRadiance = nullptr;
	FRDGTextureRef HeterogeneousVolumeHoldout = nullptr;
	FRDGTextureRef HeterogeneousVolumeBeerShadowMap = nullptr;

	// Size of the HZB's mipmap 0
	// NOTE: the mipmap 0 is downsampled version of the depth buffer
	FIntPoint HZBMipmap0Size;

	/** Used by occlusion for percent unoccluded calculations. */
	float OneOverNumPossiblePixels;

	TOptional<FMobileLightShaftInfo> MobileLightShaft;

	FGlobalShaderMap* ShaderMap;

	// Whether this view should use compute passes where appropriate.
	bool bUseComputePasses = false;

	// Optional stencil dithering optimization during prepasses
	bool bAllowStencilDither;

	// Max emissive luminance ouput by any material for this view.
	float MaterialMaxEmissiveValue;

	/** Custom visibility query for view */
	ICustomVisibilityQuery* CustomVisibilityQuery;

	const FTexture2DResource* FFTBloomKernelTexture = nullptr;
	const FTexture2DResource* FilmGrainTexture = nullptr;

	TArray<FPrimitiveSceneInfo*, SceneRenderingAllocator> IndirectShadowPrimitives;

	/** Only one of the resources(TextureBuffer or Texture2D) will be used depending on the Mobile.UseGPUSceneTexture cvar */

	FTextureRHIRef PrimitiveSceneDataTextureOverrideRHI;

	FLensDistortionLUT LensDistortionLUT;

	FShaderPrintData ShaderPrintData;

private:
	FLumenTranslucencyGIVolume& LumenTranslucencyGIVolume = *Allocator.Create<FLumenTranslucencyGIVolume>();
	FMegaLightsVolume MegaLightsVolume;

public:
	FLumenFrontLayerTranslucency LumenFrontLayerTranslucency;

	inline const FLumenTranslucencyGIVolume& GetLumenTranslucencyGIVolume() const
	{
		if (UNLIKELY(bIsInstancedStereoEnabled && ShouldUseStereoLumenOptimizations() && IStereoRendering::IsASecondaryPass(StereoPass)))
		{
			return GetPrimaryView()->LumenTranslucencyGIVolume;
		}

		return LumenTranslucencyGIVolume;
	}

	inline FLumenTranslucencyGIVolume& GetOwnLumenTranslucencyGIVolume()
	{
		return LumenTranslucencyGIVolume;
	}

	inline const FMegaLightsVolume& GetMegaLightsVolume() const
	{
		return MegaLightsVolume;
	}

	inline FMegaLightsVolume& GetOwnMegaLightsVolume()
	{
		return MegaLightsVolume;
	}

	FLumenSceneData* ViewLumenSceneData;

#if RHI_RAYTRACING
	bool HasRayTracingScene() const;
	FRHIRayTracingScene* GetRayTracingSceneChecked(ERayTracingSceneLayer Layer) const; // Soft-deprecated method, use FScene.RayTracingScene instead.
	FRDGBufferSRVRef GetRayTracingSceneLayerViewChecked(ERayTracingSceneLayer Layer) const; // Soft-deprecated method, use FScene.RayTracingScene instead.

	FRDGBufferUAVRef GetRayTracingInstanceHitCountUAV(FRDGBuilder& GraphBuilder) const;

	struct FRayTracingData
	{
		FRayTracingPipelineState* PipelineState = nullptr;
		FShaderBindingTableRHIRef ShaderBindingTable;

		TArray<FRayTracingLocalShaderBindingWriter*, SceneRenderingAllocator> MaterialBindings; // One per binding task
		TArray<FRayTracingLocalShaderBindingWriter*, SceneRenderingAllocator> CallableBindings; // One per binding task

		FMemStackBase MaterialBindingsMemory; //< Optional stacked based alloc for binding data
	};

	FRayTracingData MaterialRayTracingData;
	FRayTracingData LumenRayTracingData;
	FRayTracingData InlineRayTracingData;	

	// Buffer to the shader binding data used for inline raytracing - only valid when inline raytracing is enabled
	FRDGBufferRef InlineRayTracingBindingDataBuffer = nullptr;

	// Buffer that stores the hit group data for Lumen passes that use MinimalPayload and inline ray tracing.
	FRDGBufferRef LumenHardwareRayTracingHitDataBuffer = nullptr;

	// Global Lumen parameters for CHS, AHS and inline
	TUniformBufferRef<FLumenHardwareRayTracingUniformBufferParameters> LumenHardwareRayTracingUniformBuffer;

	// Common resources used for lighting in ray tracing effects
	TRDGUniformBufferRef<FRayTracingLightGrid>			RayTracingLightGridUniformBuffer;
	TRDGUniformBufferRef<FRayTracingDecals>				RayTracingDecalUniformBuffer;
	bool												bHasRayTracingDecals = false;

	int32 PathTracingVolumetricCloudCallableShaderIndex = -1;

	bool bHasAnyRayTracingPass = false;
	bool bHasRayTracingShadows = false;
	bool bRayTracingFeedbackEnabled = false;
#endif // RHI_RAYTRACING

	/**
	 * Index of the view in the AllViews array on the FSceneRenderer. This view ID is transient and only valid during this frame.
	 * Identical to the ID of the view in the GPU instance culling manager. Among other things, used to fetch the culled draw commands.
	 */
	int32 SceneRendererPrimaryViewId;

	/**
	 */
	FPersistentViewId PersistentViewId;

	/* View rect for all instanced views laid out side-by-side. Only primary view will have it populated. 
	 *
	 * This may be different than FamilySize if we're using adaptive resolution stereo rendering. In that case, FamilySize represents the maximum size of
	 * the family to ensure the backing render targets don't change between frames as the view size varies.
	 */
	FIntRect ViewRectWithSecondaryViews;

#if WITH_EDITOR
	TArray<Nanite::FInstanceDraw, SceneRenderingAllocator> EditorVisualizeLevelInstancesNanite;
	TArray<Nanite::FInstanceDraw, SceneRenderingAllocator> EditorSelectedInstancesNanite;
	TArray<uint32, SceneRenderingAllocator> EditorSelectedNaniteHitProxyIds;
#endif

	/** 
	 * Initialization constructor. Passes all parameters to FSceneView constructor
	 */
	RENDERER_API FViewInfo(const FSceneViewInitOptions& InitOptions);

	/** 
	* Initialization constructor. 
	* @param InView - copy to init with
	*/
	explicit FViewInfo(const FSceneView* InView);

	/** 
	* Destructor. 
	*/
	RENDERER_API virtual ~FViewInfo();

#if DO_CHECK || USING_CODE_ANALYSIS
	/** Verifies all the assertions made on members. */
	bool VerifyMembersChecks() const;
#endif

	/** Returns the size of view rect after primary upscale ( == only with secondary screen percentage). */
	RENDERER_API FIntPoint GetSecondaryViewRectSize() const;

	/** Returns the rectangle to crop to during the secondary upscale */
	RENDERER_API FIntRect GetSecondaryViewCropRect() const;
	
	/** Returns whether the view requires a secondary upscale. */
	bool RequiresSecondaryUpscale() const
	{
		return UnscaledViewRect.Size() != GetSecondaryViewRectSize() || GetSecondaryViewCropRect().Size() != GetSecondaryViewRectSize();
	}

	/** Compute the pre-exposure of internal renderer resources. */
	void UpdatePreExposure();

	/** Creates ViewUniformShaderParameters given a set of view transforms. */
	RENDERER_API void SetupUniformBufferParameters(
		const FViewMatrices& InViewMatrices,
		const FViewMatrices& InPrevViewMatrices,
		FBox* OutTranslucentCascadeBoundsArray, 
		int32 NumTranslucentCascades,
		FViewUniformShaderParameters& ViewUniformShaderParameters) const;

	/** Recreates ViewUniformShaderParameters, taking the view transform from the View Matrices */
	inline void SetupUniformBufferParameters(
		FBox* OutTranslucentCascadeBoundsArray,
		int32 NumTranslucentCascades,
		FViewUniformShaderParameters& ViewUniformShaderParameters) const
	{
		SetupUniformBufferParameters(
			ViewMatrices,
			PrevViewInfo.ViewMatrices,
			OutTranslucentCascadeBoundsArray,
			NumTranslucentCascades,
			ViewUniformShaderParameters);
	}

	void SetupDefaultGlobalDistanceFieldUniformBufferParameters(FViewUniformShaderParameters& ViewUniformShaderParameters) const;
	void SetupGlobalDistanceFieldUniformBufferParameters(FViewUniformShaderParameters& ViewUniformShaderParameters) const;
	void SetupVolumetricFogUniformBufferParameters(FViewUniformShaderParameters& ViewUniformShaderParameters) const;

	/** Initializes the RHI resources used by this view. OverrideNumMSAASamples can optionally override NumSceneColorMSAASamples (needed for editor views) */
	void InitRHIResources(uint32 OverrideNumMSAASamples = 0);

	/** Creates both ViewUniformBuffer and InstancedViewUniformBuffer (if needed). */
	void CreateViewUniformBuffers(const FViewUniformShaderParameters& Params);

	/** Determines distance culling and fades if the state changes */
	bool IsDistanceCulled(float DistanceSquared, float MinDrawDistance, float InMaxDrawDistance, const FPrimitiveSceneInfo* PrimitiveSceneInfo);

	bool IsDistanceCulled_AnyThread(float DistanceSquared, float MinDrawDistance, float InMaxDrawDistance, const FPrimitiveSceneInfo* PrimitiveSceneInfo, bool& bOutMayBeFading, bool& bOutFadingIn) const;

	/** @return - whether this primitive has completely faded out */
	bool UpdatePrimitiveFadingState(const FPrimitiveSceneInfo* PrimitiveSceneInfo, bool bFadingIn);

	/** Allocates and returns the current eye adaptation texture. */
	using FSceneView::GetEyeAdaptationTexture;
	IPooledRenderTarget* GetEyeAdaptationTexture(FRDGBuilder& GraphBuilder) const;

	/** Allocates and returns the current eye adaptation buffer. */
	using FSceneView::GetEyeAdaptationBuffer;
	FRDGPooledBuffer* GetEyeAdaptationBuffer(FRDGBuilder& GraphBuilder) const;

	/** Get the last valid exposure value for eye adaptation. */
	float GetLastEyeAdaptationExposure() const;

	/** Get the last valid average local exposure value. */
	float GetLastAverageLocalExposure() const;

	/** Get the last valid average scene luminance for eye adaptation (exposure compensation curve). */
	float GetLastAverageSceneLuminance() const;

	/**Swap the order of the two eye adaptation targets in the double buffer system */
	void SwapEyeAdaptationBuffers() const;

	/** Update Last Exposure with the most recent available value */
	void UpdateEyeAdaptationLastExposureFromBuffer() const;

	/** Enqueue a pass to readback current exposure */
	void EnqueueEyeAdaptationExposureBufferReadback(FRDGBuilder& GraphBuilder) const;

	/** Returns whether the current view should update the eye adaptation state */
	bool ShouldUpdateEyeAdaptationBuffer() const;
	
	/** Informs sceneinfo that tonemapping LUT has queued commands to compute it at least once */
	void SetValidTonemappingLUT() const;

	/** Gets the tonemapping LUT texture, previously computed by the CombineLUTS post process,
	* for stereo rendering, this will force the post-processing to use the same texture for both eyes*/
	IPooledRenderTarget* GetTonemappingLUT() const;

	/** Gets the rendertarget that will be populated by CombineLUTS post process 
	* for stereo rendering, this will force the post-processing to use the same render target for both eyes*/
	IPooledRenderTarget* GetTonemappingLUT(FRHICommandList& RHICmdList, const int32 LUTSize, const bool bUseVolumeLUT, const bool bNeedUAV, const bool bNeedFloatOutput) const;

	bool IsFirstInFamily() const
	{
		return Family->Views[0] == this;
	}

	bool IsLastInFamily() const
	{
		return Family->Views.Last() == this;
	}

	ERenderTargetLoadAction DecayLoadAction(ERenderTargetLoadAction RequestedLoadAction) const
	{
		return IsFirstInFamily() || Family->bMultiGPUForkAndJoin ? RequestedLoadAction : ERenderTargetLoadAction::ELoad;
	}

	/** Instanced stereo and multi-view only need to render the left eye. */
	bool ShouldRenderView() const 
	{
		if (bHasNoVisiblePrimitive)
		{
			return false;
		}
		else if (!bIsSinglePassStereo)
		{
			return true;
		}
		else if (bIsSinglePassStereo && !IStereoRendering::IsASecondaryPass(StereoPass))
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	/** Returns view rect for all views in the family (usable for atlased views only). Normally a union of their view rects */
	FIntRect GetFamilyViewRect() const;

	/** Similar to above, but returns the unscaled rect, ignoring dynamic resolution scaling */
	FIntRect GetUnscaledFamilyViewRect() const;

	/** Prepares the view shader parameters for rendering and calls the persistent uniform buffer hooks. */
	void BeginRenderView() const;

	/** Returns the set of view uniform buffers representing this view. */
	FViewShaderParameters GetShaderParameters() const;

	/** Returns the primary view associated with the input view, or null if none exists. */
	const FViewInfo* GetPrimaryView() const;

	/** Returns the instanced view associated with the input view, or null if none exists. */
	inline const FViewInfo* GetInstancedView() const { return static_cast<const FViewInfo*>(GetInstancedSceneView()); }

	/** Create a snapshot of this view info on the scene allocator. */
	FViewInfo* CreateSnapshot() const;

	void WaitForTasks();

	// Get the range in DynamicMeshElements[] for a given PrimitiveIndex
	// @return range (start is inclusive, end is exclusive)
	FInt32Range GetDynamicMeshElementRange(uint32 PrimitiveIndex) const;

	/** Get scene textures or config from the view family associated with this view */
	const FSceneTexturesConfig& GetSceneTexturesConfig() const;
	const FSceneTextures& GetSceneTextures() const;
	const FSceneTextures* GetSceneTexturesChecked() const;

	FSceneUniformBuffer& GetSceneUniforms() const;

	RENDERER_API FRDGTextureRef GetVolumetricCloudTexture(FRDGBuilder& GraphBuilder) const;

	/** Return true if this view requires the use of debug material permutations. */
	bool RequiresDebugMaterials() const;

	/**
	 * Collector for view-dependent data.
	 */
	FGPUScenePrimitiveCollector DynamicPrimitiveCollector;
	FGPUScenePrimitiveCollector RayTracingDynamicPrimitiveCollector;

private:
	// Cache of TEXTUREGROUP_World to create view's samplers on render thread.
	// may not have a valid value if FViewInfo is created on the render thread.
	ESamplerFilter WorldTextureGroupSamplerFilter;
	ESamplerFilter TerrainWeightmapTextureGroupSamplerFilter;
	int32 WorldTextureGroupMaxAnisotropy;
	bool bIsValidTextureGroupSamplerFilters;

	FSceneViewState* GetEyeAdaptationViewState() const;

	/** Initialization that is common to the constructors. */
	void Init();

	/** Calculates bounding boxes for the translucency lighting volume cascades. */
	void CalcTranslucencyLightingVolumeBounds(FBox* InOutCascadeBoundsArray, int32 NumCascades) const;
};


/**
 * Masks indicating for which views a primitive needs to have a certain operation on.
 * One entry per primitive in the scene.
 */
typedef TArray<uint8, SceneRenderingAllocator> FPrimitiveViewMasks;

class FShadowMapRenderTargetsRefCounted
{
public:
	// This structure gets included in FCachedShadowMapData, so avoid SceneRenderingAllocator use!
	TArray<TRefCountPtr<IPooledRenderTarget>, TInlineAllocator<4>> ColorTargets;
	TRefCountPtr<IPooledRenderTarget> DepthTarget;

	bool IsValid() const
	{
		if (DepthTarget)
		{
			return true;
		}
		else 
		{
			return ColorTargets.Num() > 0;
		}
	}

	FIntPoint GetSize() const
	{
		const FPooledRenderTargetDesc* Desc = NULL;

		if (DepthTarget)
		{
			Desc = &DepthTarget->GetDesc();
		}
		else 
		{
			check(ColorTargets.Num() > 0);
			Desc = &ColorTargets[0]->GetDesc();
		}

		return Desc->Extent;
	}

	int64 ComputeMemorySize() const
	{
		int64 MemorySize = 0;

		for (int32 i = 0; i < ColorTargets.Num(); i++)
		{
			MemorySize += ColorTargets[i]->ComputeMemorySize();
		}

		if (DepthTarget)
		{
			MemorySize += DepthTarget->ComputeMemorySize();
		}

		return MemorySize;
	}

	void Release()
	{
		for (int32 i = 0; i < ColorTargets.Num(); i++)
		{
			ColorTargets[i] = NULL;
		}

		ColorTargets.Empty();

		DepthTarget = NULL;
	}
};

struct FSortedShadowMapAtlas
{
	FShadowMapRenderTargetsRefCounted RenderTargets;
	TArray<FProjectedShadowInfo*, SceneRenderingAllocator> Shadows;
};

struct FSortedShadowMaps
{
	/** Visible shadows sorted by their shadow depth map render target. */
	TArray<FSortedShadowMapAtlas,SceneRenderingAllocator> ShadowMapAtlases;

	TArray<FSortedShadowMapAtlas,SceneRenderingAllocator> ShadowMapCubemaps;

	FSortedShadowMapAtlas PreshadowCache;

	TArray<FSortedShadowMapAtlas,SceneRenderingAllocator> TranslucencyShadowMapAtlases;

	TArray<FProjectedShadowInfo*, SceneRenderingAllocator> VirtualShadowMapShadows;

	TArray<FSortedShadowMapAtlas,SceneRenderingAllocator> CompleteShadowMapAtlases;

	void Release();

	int64 ComputeMemorySize() const
	{
		int64 MemorySize = 0;

		for (int i = 0; i < ShadowMapAtlases.Num(); i++)
		{
			MemorySize += ShadowMapAtlases[i].RenderTargets.ComputeMemorySize();
		}

		for (int i = 0; i < ShadowMapCubemaps.Num(); i++)
		{
			MemorySize += ShadowMapCubemaps[i].RenderTargets.ComputeMemorySize();
		}

		MemorySize += PreshadowCache.RenderTargets.ComputeMemorySize();

		for (int i = 0; i < TranslucencyShadowMapAtlases.Num(); i++)
		{
			MemorySize += TranslucencyShadowMapAtlases[i].RenderTargets.ComputeMemorySize();
		}

		return MemorySize;
	}

	bool IsEmpty() const
	{
		return ShadowMapAtlases.IsEmpty() && ShadowMapCubemaps.IsEmpty() && PreshadowCache.Shadows.IsEmpty() && TranslucencyShadowMapAtlases.IsEmpty() &&
			VirtualShadowMapShadows.IsEmpty() && CompleteShadowMapAtlases.IsEmpty();
	}
};

struct FOcclusionSubmittedFenceState
{
	FGraphEventRef	Fence;
	uint32			ViewStateUniqueID;
};

/**
 * View family plus associated transient scene textures.
 */
class FViewFamilyInfo : public FSceneViewFamily
{
public:
	explicit FViewFamilyInfo(const FSceneViewFamily& InViewFamily);
	explicit FViewFamilyInfo(const FSceneViewFamily::ConstructionValues& CVS, const FViewFamilyInfo& MainViewFamily);
	virtual ~FViewFamilyInfo();

	FSceneTexturesConfig SceneTexturesConfig;

	/** Set to true if this is a scene capture sized to scene texture size */
	bool bIsSceneTextureSizedCapture = false;

	/** Get scene textures associated with this view family -- asserts or checks that they have been initialized */
	inline FSceneTextures& GetSceneTextures()
	{
		checkf(bIsViewFamilyInfo && SceneTextures->bIsSceneTexturesInitialized, TEXT("FSceneTextures was not initialized. Call FSceneTextures::InitializeViewFamily() first."));
		return *SceneTextures;
	}

	inline const FSceneTextures& GetSceneTextures() const
	{
		checkf(bIsViewFamilyInfo && SceneTextures->bIsSceneTexturesInitialized, TEXT("FSceneTextures was not initialized. Call FSceneTextures::InitializeViewFamily() first."));
		return *SceneTextures;
	}

	inline FSceneTextures* GetSceneTexturesChecked()
	{
		return bIsViewFamilyInfo && SceneTextures->bIsSceneTexturesInitialized ? SceneTextures : nullptr;
	}

	inline const FSceneTextures* GetSceneTexturesChecked() const
	{
		return bIsViewFamilyInfo && SceneTextures->bIsSceneTexturesInitialized ? SceneTextures : nullptr;
	}

private:
	friend struct FMinimalSceneTextures;
	friend struct FSceneTextures;

	// Structure may be pointed to by multiple FViewFamilyInfo during scene rendering, through CustomRenderPasses.  The Owner
	// (pointed to by FSceneTextures) handles deleting the structure when the scene renderer is destroyed.  TRefCountPtr doesn't
	// work, because the structure is also copied by value, and the copy constructor is disabled for reference counted structures.
	FSceneTextures* SceneTextures;
};

struct FComputeLightGridOutput
{
	FRDGPassRef CompactLinksPass = {};
};

struct FSceneRenderUpdateInputs;
class FDeferredShadingSceneRenderer;

class FSceneRendererBase : public ISceneRenderer
{
public:
	/** The scene being rendered. */
	FScene* Scene = nullptr;

	FSceneRendererBase() {}
	FSceneRendererBase(FScene& InScene) : Scene(&InScene) {}

	// Helper functions to retrieve the currently active scene renderer from the GraphBuilder instance.
	static void SetActiveInstance(FRDGBuilder& GraphBuilder, FSceneRendererBase* SceneRenderer);
	static FSceneRendererBase* GetActiveInstance(FRDGBuilder& GraphBuilder);

	// ISceneRenderer interface
	FScene* GetScene() final override { return Scene; }
	const FSceneUniformBuffer& GetSceneUniforms() const final override { return SceneUniforms; }
	FSceneUniformBuffer& GetSceneUniforms() final override { return SceneUniforms; }

	TRDGUniformBufferRef<FSceneUniformParameters> GetSceneUniformBufferRef(FRDGBuilder& GraphBuilder) override final
	{
		return GetSceneUniforms().GetBuffer(GraphBuilder);
	}

	void InitSceneExtensionsRenderers(const FEngineShowFlags& EngineShowFlags, bool bValidateCallbacks = false)
	{
		SceneExtensionsRenderers.Begin(*this, EngineShowFlags, bValidateCallbacks);
	}
	FSceneExtensionsRenderers& GetSceneExtensionsRenderers() { return SceneExtensionsRenderers; }
	const FSceneExtensionsRenderers& GetSceneExtensionsRenderers() const { return SceneExtensionsRenderers; }

	/** The views being rendered. */
	TArray<FViewInfo> Views;

	/** 
	 * The view family being rendered. This references the Views array, if it exsists. 
	 * A view family is not always set up by all rendering paths, notably not the VT rendering path.
	 */
	virtual FViewFamilyInfo* GetViewFamily() { return nullptr; }

	/**
	 * This is a workaround to allow initialization of scene extension (renderers) that depend on data not yet migrated to other extensions.
	 * Be very careful to not build in new dependencies on this unless 
	 * 1. required to make something new better, 
	 * 2. you intend to fix this later, pinky promise!
	 */
	virtual FDeferredShadingSceneRenderer* GetDeferredShadingSceneRenderer() { return nullptr; }

private:
	FSceneUniformBuffer SceneUniforms;
	FSceneExtensionsRenderers SceneExtensionsRenderers;
};

/**
 * Used as the scope for scene rendering functions.
 * It is initialized in the game thread by FSceneViewFamily::BeginRender, and then passed to the rendering thread.
 * The rendering thread calls Render(), and deletes the scene renderer when it returns.
 */
class FSceneRenderer : public FSceneRendererBase
{
public:
	/** Linear bulk allocator with a lifetime tied to the scene renderer. */
	FSceneRenderingBulkObjectAllocator Allocator;

	/** The view family being rendered.  This references the Views array. */
	FViewFamilyInfo ViewFamily;

	/** Information of a custom render pass that renders as part of the main renderer. */
	struct FCustomRenderPassInfo
	{
		FCustomRenderPassInfo(const FSceneViewFamily::ConstructionValues& CVS);
		FCustomRenderPassInfo(const FSceneViewFamily::ConstructionValues& CVS, const FViewFamilyInfo& MainViewFamily);

		/** Custom render pass that render as part of the main renderer. */
		FCustomRenderPassBase* CustomRenderPass;
		/** View family used by custom render pass. NOT treated as a linked view. Required to allow different EngineShowFlags from main renderer ViewFamily. */
		FViewFamilyInfo ViewFamily;
		/** Views used to render the custom render pass. */
		TArray<FViewInfo> Views;
		FNaniteShadingCommands NaniteBasePassShadingCommands;
	};
	TArray<FCustomRenderPassInfo> CustomRenderPassInfos;

	/** All views include main camera views and custom render pass views. */
	TArray<FViewInfo*> AllViews;

	//////////////////////////////////////////////////////////////////////////
	// Provides access to properties of linked scene renderers.

	struct
	{
		FSceneRenderer* Head = nullptr;
		FSceneRenderer* Next = nullptr;
	
	} Link;

	bool IsHeadLink() const { return Link.Head == this; }

	template <typename LambdaType>
	void EnumerateLinkedViews(LambdaType&& Lambda, const FSceneView* ViewToSkip = nullptr)
	{
		for (FSceneRenderer* Renderer = Link.Head; Renderer; Renderer = Renderer->Link.Next)
		{
			for (FViewInfo& View : Renderer->Views)
			{
				if (ViewToSkip != &View)
				{
					if (!Lambda(View))
					{
						return;
					}
				}
			}
		}
	}

	template <typename LambdaType>
	void EnumerateLinkedViewFamilies(LambdaType&& Lambda, const FSceneViewFamily* ViewFamilyToSkip = nullptr)
	{
		for (FSceneRenderer* Renderer = Link.Head; Renderer; Renderer = Renderer->Link.Next)
		{
			if (ViewFamilyToSkip != &Renderer->ViewFamily)
			{
				if (!Lambda(Renderer->ViewFamily))
				{
					return;
				}
			}
		}
	}

	//////////////////////////////////////////////////////////////////////////

	/** All the dynamic scaling informations */
	DynamicRenderScaling::TMap<float> DynamicResolutionFractions;
	DynamicRenderScaling::TMap<float> DynamicResolutionUpperBounds;

	/** Information about the visible lights. */
	TArray<FVisibleLightInfo, SceneRenderingAllocator> VisibleLightInfos;

	/** Array of dispatched parallel shadow depth passes. */
	UE::FMutex DispatchedShadowDepthPassesMutex;
	TArray<FParallelMeshDrawCommandPass*, SceneRenderingAllocator> DispatchedShadowDepthPasses;

	FSortedShadowMaps SortedShadowsForShadowDepthPass;

	FVirtualShadowMapArray VirtualShadowMapArray;

	LightFunctionAtlas::FLightFunctionAtlas LightFunctionAtlas;

	/** If a freeze request has been made */
	bool bHasRequestedToggleFreeze;

	/** True if precomputed visibility was used when rendering the scene. */
	bool bUsedPrecomputedVisibility;

#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
	/** Lights added if wholescenepointlight shadow would have been rendered (ignoring r.SupportPointLightWholeSceneShadows). Used for warning about unsupported features. */
	TArray<FString, SceneRenderingAllocator> UsedWholeScenePointLightNames;
#endif
	/** Feature level being rendered */
	ERHIFeatureLevel::Type FeatureLevel;
	EShaderPlatform ShaderPlatform;

	bool bGPUMasksComputed;
	FRHIGPUMask RenderTargetGPUMask;

public:

	FSceneRenderer(const FSceneViewFamily* InViewFamily, FHitProxyConsumer* HitProxyConsumer);
	virtual ~FSceneRenderer();

	// ISceneRenderer interface
	virtual UE::Renderer::Private::IShadowInvalidatingInstances *GetShadowInvalidatingInstancesInterface(const FSceneView *SceneView) override;

	// FSceneRendererBase interface
	virtual FViewFamilyInfo* GetViewFamily() override { return &ViewFamily; }

	// FSceneRenderer interface
	virtual void Render(FRDGBuilder& GraphBuilder, const FSceneRenderUpdateInputs* SceneUpdateInputs) = 0;
	virtual void RenderHitProxies(FRDGBuilder& GraphBuilder, const FSceneRenderUpdateInputs* SceneUpdateInputs) {}
	virtual bool ShouldRenderVelocities() const { return false; }
	virtual bool ShouldRenderPrePass() const { return false; }
	virtual bool ShouldRenderNanite() const { return false; }
	virtual bool AllowSimpleLights() const;

	/** Setups FViewInfo::ViewRect according to ViewFamilly's ScreenPercentageInterface. */
	void PrepareViewRectsForRendering();

#if WITH_MGPU
	/**
	  * Assigns the view GPU masks and initializes RenderTargetGPUMask.  RHICmdList is only required if alternate frame rendering
	  * is active, and must be called in the render thread in that case, otherwise it can be called earlier.  Computing the masks
	  * early is used to optimize handling of cross GPU fences (see PreallocateCrossGPUFences).
	  */
	void ComputeGPUMasks(FRHICommandListImmediate* RHICmdList);
#endif

	/** Logic to update render targets across all GPUs */
	static void PreallocateCrossGPUFences(TConstArrayView<FSceneRenderer*> SceneRenderers);
	void DoCrossGPUTransfers(FRDGBuilder& GraphBuilder, FRDGTextureRef ViewFamilyTexture, TArrayView<FViewInfo> InViews, bool bCrossGPUTransferFencesDefer, FRHIGPUMask RenderTargetGPUMask, class FCrossGPUTransfersDeferred* TransfersDeferred);
	void FlushCrossGPUTransfers(FRDGBuilder& GraphBuilder);
	void FlushCrossGPUFences(FRDGBuilder& GraphBuilder);

	bool DoOcclusionQueries() const;

	void FenceOcclusionTests(FRDGBuilder& GraphBuilder);
	void WaitOcclusionTests(FRHICommandListImmediate& RHICmdList);

	// fences to make sure the rhi thread has digested the occlusion query renders before we attempt to read them back async
	static FOcclusionSubmittedFenceState OcclusionSubmittedFence[FOcclusionQueryHelpers::MaxBufferedOcclusionFrames];

	bool ShouldDumpMeshDrawCommandInstancingStats() const { return bDumpMeshDrawCommandInstancingStats; }

	/** bound shader state for occlusion test prims */
	static FGlobalBoundShaderState OcclusionTestBoundShaderState;
	
	/**
	* Whether or not to composite editor objects onto the scene as a post processing step
	*
	* @param View The view to test against
	*
	* @return true if compositing is needed
	*/
	static bool ShouldCompositeEditorPrimitives(const FViewInfo& View);
#if UE_ENABLE_DEBUG_DRAWING
	static bool ShouldCompositeDebugPrimitivesInPostProcess(const FViewInfo& View);
#endif

	/** Apply the ResolutionFraction on ViewSize, taking into account renderer's requirements. */
	static FIntPoint ApplyResolutionFraction(
		const FSceneViewFamily& ViewFamily, const FIntPoint& UnscaledViewSize, float ResolutionFraction);

	/** Quantize the ViewRect.Min according to various renderer's downscale requirements. */
	static FIntPoint QuantizeViewRectMin(const FIntPoint& ViewRectMin);

	/** Get the desired buffer size from the view family's ResolutionFraction upperbound.
	 * Can be called on game thread or render thread. 
	 */
	static FIntPoint GetDesiredInternalBufferSize(const FSceneViewFamily& ViewFamily);

	/** Exposes renderer's privilege to fork view family's screen percentage interface. */
	static ISceneViewFamilyScreenPercentage* ForkScreenPercentageInterface(
		const ISceneViewFamilyScreenPercentage* ScreenPercentageInterface, FSceneViewFamily& ForkedViewFamily)
	{
		return ScreenPercentageInterface->Fork_GameThread(ForkedViewFamily);
	}

	static int32 GetRefractionQuality(const FSceneViewFamily& ViewFamily);

	/** Common function to render a sky using shared LUT resources from any view point (if not using the SkyView and AerialPerspective textures). */
	void RenderSkyAtmosphereInternal(
		FRDGBuilder& GraphBuilder,
		const FSceneTextureShaderParameters& SceneTextures,
		FSkyAtmosphereRenderContext& SkyRenderContext);

	/** Common function to render a cloud layer using shared LUT resources. */
	void  RenderVolumetricCloudsInternal(FRDGBuilder& GraphBuilder, FCloudRenderContext& CloudRC, FInstanceCullingManager& InstanceCullingManager, const FIntPoint& CloudViewportSize);

	/** Sets the stereo-compatible RHI viewport. If the view doesn't requires stereo rendering, the standard viewport is set. */
	static void SetStereoViewport(FRHICommandList& RHICmdList, const FViewInfo& View, float ViewportScale = 1.0f);

	FGPUSceneDynamicContext& GetGPUSceneDynamicContext() { return GPUSceneDynamicContext; }

	void VoxelizeFogVolumePrimitives(
		FRDGBuilder& GraphBuilder,
		const FViewInfo& View,
		const FVolumetricFogIntegrationParameterData& IntegrationData,
		FIntVector VolumetricFogGridSize,
		FVector GridZParams,
		float VolumetricFogDistance,
		bool bVoxelizeEmissive);

	void RenderLightFunctionForVolumetricFog(
		FRDGBuilder& GraphBuilder,
		FViewInfo& View,
		const FSceneTextures& SceneTextures,
		FIntVector VolumetricFogGridSize,
		float VolumetricFogMaxDistance,
		FLightSceneInfo* DirectionalLightSceneInfo,
		FMatrix44f& OutLightFunctionTranslatedWorldToShadow,
		FRDGTexture*& OutLightFunctionTexture);

	void RenderLocalLightsForVolumetricFog(
		FRDGBuilder& GraphBuilder,
		FViewInfo& View, int32 ViewIndex,
		bool bUseTemporalReprojection,
		const struct FVolumetricFogIntegrationParameterData& IntegrationData,
		const FExponentialHeightFogSceneInfo& FogInfo,
		FIntVector VolumetricFogGridSize,
		FVector GridZParams,
		const FRDGTextureDesc& VolumeDesc,
		FRDGTextureRef ConservativeDepthTexture,
		TConstArrayView<const FLightSceneInfo*> LightsToInject,
		TConstArrayView<const FLightSceneInfo*> RayTracedLightsToInject,
		FRDGTexture*& OutLocalShadowedLightScattering);

	/** Renders capsule shadows for movable skylights, using the cone of visibility (bent normal) from DFAO. */
	void RenderCapsuleShadowsForMovableSkylight(
		FRDGBuilder& GraphBuilder,
		const FViewInfo& View,
		FRDGTextureRef& BentNormalOutput) const;

	/** Render Ambient Occlusion using mesh distance fields on a screen based grid. */
	void RenderDistanceFieldAOScreenGrid(
		FRDGBuilder& GraphBuilder,
		const FSceneTextures& SceneTextures,
		const FViewInfo& View,
		const FDistanceFieldCulledObjectBufferParameters& CulledObjectBufferParameters,
		FRDGBufferRef ObjectTilesIndirectArguments,
		const FTileIntersectionParameters& TileIntersectionParameters,
		const FDistanceFieldAOParameters& Parameters,
		FRDGTextureRef DistanceFieldNormal,
		FRDGTextureRef& OutDynamicBentNormalAO);

	/** Render Ambient Occlusion using mesh distance fields and the surface cache, which supports dynamic rigid meshes. */
	void RenderDistanceFieldLighting(
		FRDGBuilder& GraphBuilder,
		const FSceneTextures& SceneTextures,
		const class FDistanceFieldAOParameters& Parameters,
		TArray<FRDGTextureRef>& OutDynamicBentNormalAOTextures,
		bool bModulateToSceneColor,
		bool bVisualizeAmbientOcclusion,
		bool bModulateToScreenSpaceAO = false);

	void SetupVolumetricFog();

	bool ShouldRenderVolumetricFog() const;
	void ComputeVolumetricFog(FRDGBuilder& GraphBuilder, const FSceneTextures& SceneTextures);

	virtual bool IsLumenEnabled(const FViewInfo& View) const { return false; }
	virtual bool IsLumenGIEnabled(const FViewInfo& View) const { return false; }
	virtual bool AnyViewHasGIMethodSupportingDFAO() const { return true; }

	/** Gets a readable light name for use with a draw event. */
	static void GetLightNameForDrawEvent(const FLightSceneProxy* LightProxy, FString& LightNameWithLevel);

	FORCEINLINE FSceneTextures& GetActiveSceneTextures() { return ViewFamily.GetSceneTextures(); }
	FORCEINLINE FSceneTexturesConfig& GetActiveSceneTexturesConfig() { return ViewFamily.SceneTexturesConfig; }

	FORCEINLINE const FSceneTextures& GetActiveSceneTextures() const { return ViewFamily.GetSceneTextures(); }
	FORCEINLINE const FSceneTexturesConfig& GetActiveSceneTexturesConfig() const { return ViewFamily.SceneTexturesConfig; }

	DECLARE_MULTICAST_DELEGATE_OneParam(FSceneOnScreenMessagesDelegate, FScreenMessageWriter&);
	FSceneOnScreenMessagesDelegate OnGetOnScreenMessages;

	inline TConstStridedView<FSceneView> GetSceneViews() const { return MakeStridedViewOfBase<const FSceneView>(MakeArrayView(Views)); }

	static TGlobalResource<FGlobalDynamicReadBuffer> DynamicReadBufferForInitViews;
	static TGlobalResource<FGlobalDynamicReadBuffer> DynamicReadBufferForRayTracing;
	static TGlobalResource<FGlobalDynamicReadBuffer> DynamicReadBufferForShadows;

	bool IsRenderingStereo() const
	{
		return Views.Num() == 2 && IStereoRendering::IsASecondaryView(Views[1]);
	}

protected:

	/** Size of the family. */
	FIntPoint FamilySize;

#if WITH_MGPU
	/**
	 * Fences for cross GPU render target transfers.  We defer the wait on cross GPU fences until the last scene renderer,
	 * to avoid needless stalls in the middle of the frame, improving performance.  The "Defer" array holds fences issued
	 * by each prior scene renderer, while the "Wait" array holds fences to be waited on in the last scene renderer
	 * (a collection of all the fences from prior scene renderers).  The function "PreallocateCrossGPUFences" initializes
	 * these arrays.
	 */
	TArray<FCrossGPUTransferFence*> CrossGPUTransferFencesDefer;
	TArray<FCrossGPUTransferFence*> CrossGPUTransferFencesWait;

	/** Deferred transfers to be executed in the last scene renderer */
	TRefCountPtr<class FCrossGPUTransfersDeferred> CrossGPUTransferDeferred;

	FRHIGPUMask AllViewsGPUMask;
	bool IsShadowCached(FProjectedShadowInfo* ProjectedShadowInfo) const;
	FRHIGPUMask GetGPUMaskForShadow(FProjectedShadowInfo* ProjectedShadowInfo) const;
#endif

	/** The cached FXSystem which could be released while we are rendering. */
	class FFXSystemInterface* FXSystem = nullptr;

	bool bDumpMeshDrawCommandInstancingStats;

	// Shared functionality between all scene renderers

	enum class ERendererOutput
	{
		DepthPrepassOnly,	// Only render depth prepass and its related code paths
		FinalSceneColor		// Render the whole pipeline
	};

	ERendererOutput GetRendererOutput() const;

	FDynamicShadowsTaskData* BeginInitDynamicShadows(FRDGBuilder& GraphBuilder, bool bRunningEarly, IVisibilityTaskData* VisibilityTaskData, FInstanceCullingManager& InstanceCullingManager);
	void FinishInitDynamicShadows(FRDGBuilder& GraphBuilder, FDynamicShadowsTaskData* TaskData);
	void FinishDynamicShadowMeshPassSetup(FRDGBuilder& GraphBuilder, FDynamicShadowsTaskData* TaskData);
	FDynamicShadowsTaskData* InitDynamicShadows(FRDGBuilder& GraphBuilder, FInstanceCullingManager& InstanceCullingManager);

	void CreateDynamicShadows(FDynamicShadowsTaskData& TaskData);
	void FilterDynamicShadows(FDynamicShadowsTaskData& TaskData);
	friend struct FGatherShadowPrimitivesPrepareTask;

	void SetupMeshPass(FViewInfo& View, FExclusiveDepthStencil::Type BasePassDepthStencilAccess, FViewCommands& ViewCommands, FInstanceCullingManager& InstanceCullingManager);

	void RenderShadowProjections(
		FRDGBuilder& GraphBuilder,
		FRDGTextureRef OutputTexture,
		const FMinimalSceneTextures& SceneTextures,
		const FLightSceneProxy* LightSceneProxy,
		TArrayView<const FProjectedShadowInfo* const> Shadows,
		bool bSubPixelShadow,
		bool bProjectingForForwardShading);


	void RenderShadowProjections(
		FRDGBuilder& GraphBuilder,
		const FMinimalSceneTextures& SceneTextures,
		FRDGTextureRef ScreenShadowMaskTexture,
		FRDGTextureRef ScreenShadowMaskSubPixelTexture,
		const FLightSceneInfo* LightSceneInfo,
		bool bProjectingForForwardShading);

	void BeginAsyncDistanceFieldShadowProjections(
		FRDGBuilder& GraphBuilder,
		const FMinimalSceneTextures& SceneTextures,
		const FDynamicShadowsTaskData* TaskData) const;

	/** Finds a matching cached preshadow, if one exists. */
	TRefCountPtr<FProjectedShadowInfo> GetCachedPreshadow(
		const FLightPrimitiveInteraction* InParentInteraction,
		const FProjectedShadowInitializer& Initializer,
		const FBoxSphereBounds& Bounds,
		uint32 InResolutionX);

	/** Creates a per object projected shadow for the given interaction. */
	void CreatePerObjectProjectedShadow(
		FDynamicShadowsTaskData& TaskData,
		FLightPrimitiveInteraction* Interaction,
		bool bCreateTranslucentObjectShadow,
		bool bCreateInsetObjectShadow,
		const TArray<FProjectedShadowInfo*, SceneRenderingAllocator>& ViewDependentWholeSceneShadows,
		TArray<FProjectedShadowInfo*, SceneRenderingAllocator>& OutPreShadows);

	/** Creates shadows for the given interaction. */
	void SetupInteractionShadows(
		FDynamicShadowsTaskData& TaskData,
		FLightPrimitiveInteraction* Interaction,
		FVisibleLightInfo& VisibleLightInfo,
		bool bStaticSceneOnly,
		const TArray<FProjectedShadowInfo*, SceneRenderingAllocator>& ViewDependentWholeSceneShadows,
		TArray<FProjectedShadowInfo*, SceneRenderingAllocator>& PreShadows);

	/** Generates FProjectedShadowInfos for all wholesceneshadows on the given light.*/
	void AddViewDependentWholeSceneShadowsForView(
		TArray<FProjectedShadowInfo*, SceneRenderingAllocator>& ShadowInfos, 
		TArray<FProjectedShadowInfo*, SceneRenderingAllocator>& ShadowInfosThatNeedCulling, 
		FVisibleLightInfo& VisibleLightInfo, 
		FLightSceneInfo& LightSceneInfo,
		int64 CachedShadowMapsSize,
		uint32& NumCSMCachesUpdatedThisFrame);

	void AllocateShadowDepthTargets(FDynamicShadowsTaskData& TaskData);
	
	void AllocateAtlasedShadowDepthTargets(FRHICommandListBase& RHICmdList, TConstArrayView<FProjectedShadowInfo*> Shadows, TArray<FSortedShadowMapAtlas,SceneRenderingAllocator>& OutAtlases);

	void AllocateCachedShadowDepthTargets(FRHICommandListBase& RHICmdList, TConstArrayView<FProjectedShadowInfo*> CachedShadows);

	void AllocateCSMDepthTargets(FRHICommandListBase& RHICmdList, TConstArrayView<FProjectedShadowInfo*> WholeSceneDirectionalShadows, TArray<FSortedShadowMapAtlas, SceneRenderingAllocator>& OutAtlases);

	void AllocateOnePassPointLightDepthTargets(FRHICommandListBase& RHICmdList, TConstArrayView<FProjectedShadowInfo*> WholeScenePointShadows);

	void AllocateTranslucentShadowDepthTargets(FRHICommandListBase& RHICmdList, TConstArrayView<FProjectedShadowInfo*> TranslucentShadows);

	void AllocateMobileCSMAndSpotLightShadowDepthTargets(FRHICommandListBase& RHICmdList, TConstArrayView<FProjectedShadowInfo*> MobileCSMAndSpotLightShadows);
	/**
	* Used by RenderLights to figure out if projected shadows need to be rendered to the attenuation buffer.
	* Or to render a given shadowdepth map for forward rendering.
	*
	* @param LightSceneInfo Represents the current light
	* @return true if anything needs to be rendered
	*/
	bool CheckForProjectedShadows(const FLightSceneInfo* LightSceneInfo) const;

	/** Gathers the list of primitives used to draw various shadow types */
	void BeginGatherShadowPrimitives(FDynamicShadowsTaskData* TaskData, IVisibilityTaskData* VisibilityTaskData);
	void FinishGatherShadowPrimitives(FDynamicShadowsTaskData* TaskData);

	void RenderShadowDepthMaps(FRDGBuilder& GraphBuilder, FDynamicShadowsTaskData* DynamicShadowsTaskData, FInstanceCullingManager& InstanceCullingManager, FRDGExternalAccessQueue& ExternalAccessQueue);
	void RenderShadowDepthMaps(FRDGBuilder& GraphBuilder, FDynamicShadowsTaskData* DynamicShadowsTaskData, FInstanceCullingManager& InstanceCullingManager, FRDGExternalAccessQueue& ExternalAccessQueue, TFunctionRef<void(bool bNaniteEnabled)> RenderAdditionalShadowDepths);

	void RenderShadowDepthMapAtlases(FRDGBuilder& GraphBuilder);

	/**
	* Creates a projected shadow for all primitives affected by a light.
	* @param LightSceneInfo - The light to create a shadow for.
	*/
	void CreateWholeSceneProjectedShadow(FDynamicShadowsTaskData& TaskData, FLightSceneInfo* LightSceneInfo, int64 CachedShadowMapsSize, uint32& NumPointShadowCachesUpdatedThisFrame, uint32& NumSpotShadowCachesUpdatedThisFrame);

	/** Updates the preshadow cache, allocating new preshadows that can fit and evicting old ones. */
	void UpdatePreshadowCache();

	/** Gathers simple lights from visible primtives in the passed in views. */
	static void GatherSimpleLights(const FSceneViewFamily& ViewFamily, const TArray<FViewInfo>& Views, FSimpleLightArray& SimpleLights);

	/** Calculates projected shadow visibility. */
	void InitProjectedShadowVisibility(FDynamicShadowsTaskData& TaskData);

	/** Adds a debug shadow frustum to the views primitive draw interface. */
	void DrawDebugShadowFrustum(FViewInfo& View, FProjectedShadowInfo& ProjectedShadowInfo);

	/** Gathers dynamic mesh elements for all shadows. */
	void GatherShadowDynamicMeshElements(FDynamicShadowsTaskData& TaskData);

	/** Renders capsule shadows for all per-object shadows using it for the given light. */
	bool RenderCapsuleDirectShadows(
		FRDGBuilder& GraphBuilder,
		const FLightSceneInfo& LightSceneInfo,
		FRDGTextureRef ScreenShadowMaskTexture,
		TArrayView<const FProjectedShadowInfo* const> CapsuleShadows,
		bool bProjectingForForwardShading) const;

	/** Performs once per frame setup prior to visibility determination. */
	void PreVisibilityFrameSetup(FRDGBuilder& GraphBuilder);

	void GatherReflectionCaptureLightMeshElements();

	/** Performs once per frame setup after to visibility determination. */
	void PostVisibilityFrameSetup(FILCUpdatePrimTaskData*& OutILCTaskData);

	/** Initialized the fog constants for each view. */
	void InitFogConstants();

	/** Returns whether there are translucent primitives to be rendered. */
	bool ShouldRenderTranslucency() const;
	static bool ShouldRenderTranslucency(ETranslucencyPass::Type TranslucencyPass, TArrayView<FViewInfo> InViews);

	/** Called at the begin / finish of the scene render. */
	IVisibilityTaskData* OnRenderBegin(FRDGBuilder& GraphBuilder, const FSceneRenderUpdateInputs* SceneUpdateInputs);
	void OnRenderFinish(FRDGBuilder& GraphBuilder, FRDGTextureRef ViewFamilyTexture);

	bool RenderCustomDepthPass(
		FRDGBuilder& GraphBuilder,
		FCustomDepthTextures& CustomDepthTextures,
		const FSceneTextureShaderParameters& SceneTextures,
		TConstArrayView<Nanite::FRasterResults> PrimaryNaniteRasterResults,
		TConstArrayView<Nanite::FPackedView> PrimaryNaniteViews);

	void UpdatePrimitiveIndirectLightingCacheBuffers(FRHICommandListBase& RHICmdList);

	void RenderPlanarReflection(class FPlanarReflectionSceneProxy* ReflectionSceneProxy);

	/** Initialise sky atmosphere resources.*/
	void InitSkyAtmosphereForViews(FRHICommandListImmediate& RHICmdList, FRDGBuilder& GraphBuilder);
	
	/** Render the sky atmosphere look up table needed for this frame.*/
	void RenderSkyAtmosphereLookUpTables(FRDGBuilder& GraphBuilder, class FSkyAtmospherePendingRDGResources& PendingRDGResources);

	/** Render the sky atmosphere over the scene.*/
	void RenderSkyAtmosphere(FRDGBuilder& GraphBuilder, const FMinimalSceneTextures& SceneTextures);

	/** Initialise volumetric cloud resources.*/
	void InitVolumetricCloudsForViews(FRDGBuilder& GraphBuilder, bool bShouldRenderVolumetricCloud, FInstanceCullingManager& InstanceCullingManager);

	/** Render volumetric cloud. */
	bool RenderVolumetricCloud(
		FRDGBuilder& GraphBuilder,
		const FMinimalSceneTextures& SceneTextures,
		bool bSkipVolumetricRenderTarget,
		bool bSkipPerPixelTracing,
		FRDGTextureRef HalfResolutionDepthCheckerboardMinMaxTexture,
		FRDGTextureRef QuarterResolutionDepthMinMaxTexture,
		bool bAsyncCompute,
		FInstanceCullingManager& InstanceCullingManager);

	/** Render notification to artist when a sky material is used but it might comtains the camera (and then the sky/background would look black).*/
	void RenderSkyAtmosphereEditorNotifications(FRDGBuilder& GraphBuilder, TArrayView<FViewInfo> InViews, FRDGTextureRef SceneColorTexture) const;

	/** We should render on screen notification only if any of the scene contains a mesh using a sky material.*/
	static bool ShouldRenderSkyAtmosphereEditorNotifications(TArrayView<FViewInfo> Views);

	/**
	 * Rounds up lights and sorts them according to what type of renderer supports them. The result is stored in OutSortedLights 
	 * NOTE: Also extracts the SimpleLights AND adds them to the sorted range (first sub-range). 
	 */
	void GatherAndSortLights(FSortedLightSetSceneInfo& OutSortedLights, bool bShadowedLightsInClustered = false);

	/**
	 * Register all lights with the light function atlas and updates it.
	 */
	void UpdateLightFunctionAtlasTaskFunction();
	
	/** 
	 * Culls local lights and reflection probes to a grid in frustum space, builds one light list and grid per view in the current Views.  
	 * Needed for forward shading or translucency using the Surface lighting mode, and clustered deferred shading. 
	 */
	FComputeLightGridOutput ComputeLightGrid(FRDGBuilder& GraphBuilder, bool bCullLightsToGrid, const FSortedLightSetSceneInfo& SortedLightSet, TArray<FForwardLightUniformParameters*, TInlineAllocator<2>>& PerViewForwardLightUniformParameters);

	/**
	 * Prepare ForwardLightingResources for the Views (including building light grids)
	 */
	FComputeLightGridOutput PrepareForwardLightData(FRDGBuilder& GraphBuilder, bool bCullLightsToGrid, const FSortedLightSetSceneInfo& SortedLightSet);

	/**
	* Used by RenderLights to figure out if light functions need to be rendered to the attenuation buffer.
	*
	* @param LightSceneInfo Represents the current light
	* @return true if anything got rendered
	*/
	bool CheckForLightFunction(const FLightSceneInfo* LightSceneInfo) const;

	void SetupSceneReflectionCaptureBuffer(FRHICommandListImmediate& RHICmdList);

	void RenderVelocities(
		FRDGBuilder& GraphBuilder,
		TArrayView<FViewInfo> InViews,
		const FSceneTextures& SceneTextures,
		EVelocityPass VelocityPass,
		bool bForceVelocity,
		bool bBindRenderTarget = true);

	void RenderMeshDistanceFieldVisualization(FRDGBuilder& GraphBuilder, const FMinimalSceneTextures& SceneTextures);

#if !UE_BUILD_SHIPPING
	static void CreateSplitScreenDebugViewFamilies(const FSceneViewFamily& InFamily, TArray<const FSceneViewFamily*>& OutViewFamilies, TArray<const FSceneViewFamily*, TFixedAllocator<2>>& OutFamiliesStorage);
	static void DestroySplitScreenDebugViewFamilies(TConstArrayView<const FSceneViewFamily*> ViewFamilies);
#endif

protected:
	FGPUSceneDynamicContext GPUSceneDynamicContext;

	void CheckShadowDepthRenderCompleted() const
	{
		checkf(bShadowDepthRenderCompleted, TEXT("Shadow depth rendering was not done before shadow projections, this will cause severe shadow artifacts and indicates an engine bug (pass ordering)"));
	}

	virtual void ComputeLightVisibility();

private:
	void ComputeFamilySize();

	friend class FVisibilityTaskData;

	void SetupMeshPasses(IVisibilityTaskData& TaskData, FExclusiveDepthStencil::Type BasePassDepthStencilAccess, FInstanceCullingManager& InstanceCullingManager);

	void PrepareViewStateForVisibility(const FSceneTexturesConfig& SceneTexturesConfig);

	bool bShadowDepthRenderCompleted;

#if RHI_RAYTRACING
	virtual void InitializeRayTracingFlags_RenderThread() {}
#endif

	friend class FRendererModule;
	friend class FSceneRenderProcessor;
};

/** A set of show flags thare are guaranteed to be common among all renderers in the set. */
enum class ESceneRenderCommonShowFlags
{
	None             = 0,
	HitProxies       = 1 << 0,
	PathTracing      = 1 << 1
};
ENUM_CLASS_FLAGS(ESceneRenderCommonShowFlags);

/** An optional set of all renderers, view families, and views for operations that are performed once for a
 *  batch of scene renderers. Only the first scene renderer will have this applied.
 */
struct FSceneRenderUpdateInputs
{
	TConstArrayView<const FSceneView*> GetAsSceneViews() const
	{
		return MakeArrayView(reinterpret_cast<const FSceneView* const*>(Views.GetData()), Views.Num());
	}

	TConstArrayView<const FSceneViewFamily*> GetAsSceneViewFamilies() const
	{
		return MakeArrayView(reinterpret_cast<const FSceneViewFamily* const*>(ViewFamilies.GetData()), ViewFamilies.Num());
	}

	template <typename LambdaType>
	bool HasAnyShowFlags(LambdaType&& Lambda) const
	{
		for (FViewFamilyInfo* Family : ViewFamilies)
		{
			if (Lambda(Family->EngineShowFlags))
			{
				return true;
			}
		}
		return false;
	}

	template <typename LambdaType>
	void ForEachView(LambdaType&& Lambda) const
	{
		for (FSceneRenderer* Renderer : Renderers)
		{
			for (FViewInfo& View : Renderer->Views)
			{
				if (!Lambda(Renderer, View))
				{
					return;
				}
			}
		}
	}

	EShaderPlatform ShaderPlatform;
	ERHIFeatureLevel::Type FeatureLevel;
	FScene* Scene;
	FFXSystemInterface* FXSystem;
	FGlobalShaderMap* GlobalShaderMap;
	TConstArrayView<FSceneRenderer*> Renderers;
	TConstArrayView<FViewFamilyInfo*> ViewFamilies;
	TConstArrayView<FViewInfo*> Views;
	ESceneRenderCommonShowFlags CommonShowFlags;
};

template <typename LambdaType, typename PrerequisiteTaskCollectionType>
UE::Tasks::FTask LaunchSceneRenderTask(const TCHAR* DebugName, LambdaType&& Lambda, PrerequisiteTaskCollectionType&& Prerequisites, bool bExecuteInParallelCondition = true, UE::Tasks::ETaskPriority TaskPriority = UE::Tasks::ETaskPriority::High)
{
	const bool bExecuteInParallel = bExecuteInParallelCondition && FApp::ShouldUseThreadingForPerformance() && GIsThreadedRendering;

	return UE::Tasks::Launch(DebugName, [Lambda = Forward<LambdaType&&>(Lambda)] () mutable
		{
			FTaskTagScope Scope(ETaskTag::EParallelRenderingThread);
			Lambda();
		}, 
		Forward<PrerequisiteTaskCollectionType&&>(Prerequisites),
		TaskPriority,
		bExecuteInParallel ? UE::Tasks::EExtendedTaskPriority::None : UE::Tasks::EExtendedTaskPriority::Inline
	);
}

template <typename LambdaType>
UE::Tasks::FTask LaunchSceneRenderTask(const TCHAR* DebugName, LambdaType&& Lambda, bool bExecuteInParallelCondition = true, UE::Tasks::ETaskPriority TaskPriority = UE::Tasks::ETaskPriority::High)
{
	const bool bExecuteInParallel = bExecuteInParallelCondition && FApp::ShouldUseThreadingForPerformance() && GIsThreadedRendering;

	return UE::Tasks::Launch(DebugName, [Lambda = Forward<LambdaType&&>(Lambda)] () mutable
		{
			FTaskTagScope Scope(ETaskTag::EParallelRenderingThread);
			Lambda();
		},
		TaskPriority,
		bExecuteInParallel ? UE::Tasks::EExtendedTaskPriority::None : UE::Tasks::EExtendedTaskPriority::Inline
	);
}

template <typename ReturnType, typename LambdaType, typename PrerequisiteTaskCollectionType>
UE::Tasks::TTask<ReturnType> LaunchSceneRenderTask(const TCHAR* DebugName, LambdaType&& Lambda, PrerequisiteTaskCollectionType&& Prerequisites, bool bExecuteInParallelCondition = true, UE::Tasks::ETaskPriority TaskPriority = UE::Tasks::ETaskPriority::High)
{
	const bool bExecuteInParallel = bExecuteInParallelCondition && FApp::ShouldUseThreadingForPerformance() && GIsThreadedRendering;

	return UE::Tasks::Launch(DebugName, [Lambda = Forward<LambdaType&&>(Lambda)] () mutable
		{
			FTaskTagScope Scope(ETaskTag::EParallelRenderingThread);
			return Lambda();
		},
		Forward<PrerequisiteTaskCollectionType&&>(Prerequisites),
		TaskPriority,
		bExecuteInParallel ? UE::Tasks::EExtendedTaskPriority::None : UE::Tasks::EExtendedTaskPriority::Inline
	);
}

// Creates a FGraphEventRef from UE::Task::FTask prerequisites.
template <typename PrerequisiteTaskCollectionType>
FGraphEventRef CreateCompatibilityGraphEvent(PrerequisiteTaskCollectionType&& Prerequisites)
{
	FGraphEventRef GraphEvent = FGraphEvent::CreateGraphEvent();
	UE::Tasks::Launch(UE_SOURCE_LOCATION, [GraphEvent]
	{
		GraphEvent->DispatchSubsequents();

	}, Prerequisites, UE::Tasks::ETaskPriority::High, UE::Tasks::EExtendedTaskPriority::Inline);
	return GraphEvent;
}

struct FForwardScreenSpaceShadowMaskTextureMobileOutputs
{
	TRefCountPtr<IPooledRenderTarget> ScreenSpaceShadowMaskTextureMobile;

	bool IsValid()
	{
		return ScreenSpaceShadowMaskTextureMobile.IsValid();
	}

	void Release()
	{
		ScreenSpaceShadowMaskTextureMobile.SafeRelease();
	}
};

extern FForwardScreenSpaceShadowMaskTextureMobileOutputs GScreenSpaceShadowMaskTextureMobileOutputs;

typedef TArray<FRDGTextureRef, TInlineAllocator<6>> FColorTargets;

/**
 * Renderer that implements simple forward shading and associated features.
 */
class FMobileSceneRenderer : public FSceneRenderer
{
public:

	FMobileSceneRenderer(const FSceneViewFamily* InViewFamily, FHitProxyConsumer* HitProxyConsumer);

	// FSceneRenderer interface

	virtual void Render(FRDGBuilder& GraphBuilder, const FSceneRenderUpdateInputs* SceneUpdateInputs) override;

	virtual void RenderHitProxies(FRDGBuilder& GraphBuilder, const FSceneRenderUpdateInputs* SceneUpdateInputs) override;

	virtual bool ShouldRenderVelocities() const override;

	virtual bool ShouldRenderPrePass() const override;

	virtual bool AllowSimpleLights() const override;

	/** Whether platform requires multiple render-passes for SceneColor rendering */
	static bool RequiresMultiPass(int32 NumMSAASamples, EShaderPlatform ShaderPlatform);

protected:
	/** Finds the visible dynamic shadows for each view. */
	FDynamicShadowsTaskData* InitDynamicShadows(FRDGBuilder& GraphBuilder, FInstanceCullingManager& FInstanceCullingManager);

	void PrepareViewVisibilityLists();

	/** Build visibility lists on CSM receivers and non-csm receivers. */
	void BuildCSMVisibilityState(FLightSceneInfo* LightSceneInfo);

	struct FInitViewTaskDatas
	{
		FInitViewTaskDatas(IVisibilityTaskData* InVisibilityTaskData)
			: VisibilityTaskData(InVisibilityTaskData)
		{}

		IVisibilityTaskData* VisibilityTaskData;
		FDynamicShadowsTaskData* DynamicShadows = nullptr;
	};

	void InitViews(
		FRDGBuilder& GraphBuilder,
		FSceneTexturesConfig& SceneTexturesConfig,
		FInstanceCullingManager& InstanceCullingManager,
		FVirtualTextureUpdater* VirtualTextureUpdater,
		FInitViewTaskDatas& TaskDatas);

	void RenderPrePass(FRHICommandList& RHICmdList, const FViewInfo& View, const FInstanceCullingDrawParams* InstanceCullingDrawParams);
	void RenderMaskedPrePass(FRHICommandList& RHICmdList, const FViewInfo& View, const FInstanceCullingDrawParams* DepthPassInstanceCullingDrawParams);
	void RenderFullDepthPrepass(FRDGBuilder& GraphBuilder, TArrayView<FViewInfo> InViews, FSceneTextures& SceneTextures, FInstanceCullingManager& InstanceCullingManager, bool bIsSceneCaptureRenderPass=false);

	void RenderVelocityPass(FRHICommandList& RHICmdList, const FViewInfo& View, const FInstanceCullingDrawParams* InstanceCullingDrawParams);

	void RenderMobileLocalLightsBuffer(FRDGBuilder& GraphBuilder, FSceneTextures& SceneTextures, const FSortedLightSetSceneInfo& SortedLights);

	void RenderCustomRenderPassBasePass(FRDGBuilder& GraphBuilder, TArrayView<FViewInfo> InViews, FRDGTextureRef ViewFamilyTexture, FSceneTextures& SceneTextures, FInstanceCullingManager& InstanceCullingManager, bool bIncludeTranslucent);

	/** Renders the opaque base pass for mobile. */
	void RenderMobileBasePass(FRHICommandList& RHICmdList, const FViewInfo& View, const FInstanceCullingDrawParams* InstanceCullingDrawParams, const FInstanceCullingDrawParams* SkyPassInstanceCullingDrawParams);

	void PostRenderBasePass(FRHICommandList& RHICmdList, FViewInfo& View);

	void RenderMobileEditorPrimitives(FRHICommandList& RHICmdList, const FViewInfo& View, const FMeshPassProcessorRenderState& DrawRenderState, const FInstanceCullingDrawParams* InstanceCullingDrawParams);

#if UE_ENABLE_DEBUG_DRAWING
	/** Render debug primitives in the base pass, for MobileHDR=false */
	void RenderMobileDebugPrimitives(FRHICommandList& RHICmdList, const FViewInfo& View);
#endif

	/** Renders the debug view pass for mobile. */
	void RenderMobileDebugView(FRHICommandList& RHICmdList, const FViewInfo& View, const FInstanceCullingDrawParams* DebugViewModeInstanceCullingDrawParams);

	/** Render modulated shadow projections in to the scene, loops over any unrendered shadows until all are processed.*/
	void RenderModulatedShadowProjections(FRHICommandList& RHICmdList, int32 ViewIndex, const FViewInfo& View);

	/** Issues occlusion queries */
	void RenderOcclusion(FRHICommandList& RHICmdList);
	
	bool ShouldRenderHZB(TArrayView<FViewInfo> InViews);


	/** Generate HZB */
	void RenderHZB(FRHICommandListImmediate& RHICmdList, const TRefCountPtr<IPooledRenderTarget>& SceneDepthZ);
	void RenderHZB(FRDGBuilder& GraphBuilder, FRDGTextureRef SceneDepthTexture);

	/** Computes how many queries will be issued this frame */
	int32 ComputeNumOcclusionQueriesToBatch() const;


	/** Renders decals. */
	void RenderDecals(FRHICommandList& RHICmdList, FViewInfo& View, const FInstanceCullingDrawParams* InstanceCullingDrawParams);
	void RenderDBuffer(FRDGBuilder& GraphBuilder, FSceneTextures& SceneTextures, FDBufferTextures& DBufferTextures, FInstanceCullingManager& InstanceCullingManager);

	/** Renders the atmospheric and height fog */
	void RenderFog(FRHICommandList& RHICmdList, const FViewInfo& View);

	/** Renders the base pass for translucency. */
	static void RenderTranslucency(FRHICommandList& RHICmdList, const FViewInfo& View, TArrayView<FViewInfo> FamilyViewInfos, ETranslucencyPass::Type InStandardTranslucencyPass, EMeshPass::Type InStandardTranslucencyMeshPass, const FInstanceCullingDrawParams* InTranslucencyInstanceCullingDrawParams);

	/** On chip pre-tonemap before scene color MSAA resolve (iOS only) */
	void PreTonemapMSAA(FRHICommandList& RHICmdList, const FMinimalSceneTextures& SceneTextures);

	void SetupMobileBasePassAfterShadowInit(FExclusiveDepthStencil::Type BasePassDepthStencilAccess, TArrayView<FViewCommands> ViewCommandsPerView, FInstanceCullingManager& InstanceCullingManager);

	void UpdateDirectionalLightUniformBuffers(FRDGBuilder& GraphBuilder, const FViewInfo& View);
	void UpdateSkyReflectionUniformBuffer(FRHICommandListBase& RHICmdList);
	
	void RenderForward(FRDGBuilder& GraphBuilder, FRDGTextureRef ViewFamilyTexture, FSceneTextures& SceneTextures, FDBufferTextures& DBufferTextures, FInstanceCullingManager& InstanceCullingManager);
	void RenderForwardSinglePass(FRDGBuilder& GraphBuilder, class FMobileRenderPassParameters* PassParameters, struct FRenderViewContext& ViewContext, FSceneTextures& SceneTextures, FInstanceCullingManager& InstanceCullingManager);
	void RenderForwardMultiPass(FRDGBuilder& GraphBuilder, class FMobileRenderPassParameters* PassParameters, struct FRenderViewContext& ViewContext, FSceneTextures& SceneTextures, FInstanceCullingManager& InstanceCullingManager);
	
	void RenderDeferredSinglePass(FRDGBuilder& GraphBuilder, FSceneTextures& SceneTextures, const FSortedLightSetSceneInfo& SortedLightSet, FDBufferTextures& DBufferTextures, FInstanceCullingManager& InstanceCullingManager);
	void RenderDeferredMultiPass(FRDGBuilder& GraphBuilder, FSceneTextures& SceneTextures, const FSortedLightSetSceneInfo& SortedLightSet, FDBufferTextures& DBufferTextures, FInstanceCullingManager& InstanceCullingManager);

	void RenderAmbientOcclusion(FRDGBuilder& GraphBuilder, FRDGTextureRef SceneDepthTexture, FRDGTextureRef AmbientOcclusionTexture);

	void RenderMobileShadowProjections(FRDGBuilder& GraphBuilder);

	FRenderTargetBindingSlots InitRenderTargetBindings_Deferred(FSceneTextures& SceneTextures, FColorTargets& ColorTargets);
	FRenderTargetBindingSlots InitRenderTargetBindings_Forward(FRDGTextureRef ViewFamilyTexture, FSceneTextures& SceneTextures);
	FColorTargets GetColorTargets_Deferred(FSceneTextures& SceneTextures);

private:
	const bool bGammaSpace;
	const bool bDeferredShading;
	const bool bRequiresDBufferDecals;
	const bool bUseVirtualTexturing;
	const bool bSupportsSimpleLights;
	bool bTonemapSubpass;
	bool bTonemapSubpassInline;
	int32 NumMSAASamples;
	bool bRenderToSceneColor;
	bool bRequiresMultiPass;
	bool bKeepDepthContent;
	bool bModulatedShadowsInUse;
	bool bShouldRenderCustomDepth;
	bool bRequiresAmbientOcclusionPass;
	bool bShouldRenderVelocities;
	bool bShouldRenderHZB;
	bool bRequiresScreenSpaceReflections;
	bool bIsFullDepthPrepassEnabled;
	bool bIsMaskedOnlyDepthPrepassEnabled;
	bool bRequiresSceneDepthAux;
	bool bEnableClusteredLocalLights;
	bool bEnableClusteredReflections;
	bool bRequiresShadowProjections;
	bool bAdrenoOcclusionMode;
	bool bEnableDistanceFieldAO;
	ETranslucencyPass::Type StandardTranslucencyPass;
	EMeshPass::Type StandardTranslucencyMeshPass;

	const FViewInfo* CachedView = nullptr;
};

// The noise textures need to be set in Slate too.
RENDERER_API void UpdateNoiseTextureParameters(FViewUniformShaderParameters& ViewUniformShaderParameters);

struct FFastVramConfig
{
	FFastVramConfig();
	void Update();
	void OnCVarUpdated();
	void OnSceneRenderTargetsAllocated();

	ETextureCreateFlags GBufferA;
	ETextureCreateFlags GBufferB;
	ETextureCreateFlags GBufferC;
	ETextureCreateFlags GBufferD;
	ETextureCreateFlags GBufferE;
	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;
	ETextureCreateFlags Upscale;
	ETextureCreateFlags DistanceFieldNormal;
	ETextureCreateFlags DistanceFieldAOHistory;
	ETextureCreateFlags DistanceFieldAOBentNormal;
	ETextureCreateFlags DistanceFieldAODownsampledBentNormal;
	ETextureCreateFlags DistanceFieldShadows;
	ETextureCreateFlags DistanceFieldIrradiance;
	ETextureCreateFlags DistanceFieldAOConfidence;
	ETextureCreateFlags Distortion;
	ETextureCreateFlags ScreenSpaceShadowMask;
	ETextureCreateFlags VolumetricFog;
	ETextureCreateFlags SeparateTranslucency;
	ETextureCreateFlags SeparateTranslucencyModulate;
	ETextureCreateFlags ScreenSpaceAO;
	ETextureCreateFlags SSR;
	ETextureCreateFlags DBufferA;
	ETextureCreateFlags DBufferB;
	ETextureCreateFlags DBufferC;
	ETextureCreateFlags DBufferMask;
	ETextureCreateFlags DOFSetup;
	ETextureCreateFlags DOFReduce;
	ETextureCreateFlags DOFPostfilter;
	ETextureCreateFlags PostProcessMaterial;

	ETextureCreateFlags CustomDepth;
	ETextureCreateFlags ShadowPointLight;
	ETextureCreateFlags ShadowPerObject;
	ETextureCreateFlags ShadowCSM;

	// Buffers
	EBufferUsageFlags DistanceFieldCulledObjectBuffers;
	EBufferUsageFlags DistanceFieldTileIntersectionResources;
	EBufferUsageFlags DistanceFieldAOScreenGridResources;
	EBufferUsageFlags ForwardLightingCullingResources;
	EBufferUsageFlags GlobalDistanceFieldCullGridBuffers;
	bool bDirty;

private:
	bool UpdateTextureFlagFromCVar(TAutoConsoleVariable<int32>& CVar, ETextureCreateFlags& InOutValue);
	bool UpdateBufferFlagFromCVar(TAutoConsoleVariable<int32>& CVar, EBufferUsageFlags& InOutValue);
};

extern FFastVramConfig GFastVRamConfig;

/** Returns the array of shadows with distance fields. Call only after finishing shadow initialization. */
extern TConstArrayView<FProjectedShadowInfo*> GetProjectedDistanceFieldShadows(const FDynamicShadowsTaskData* TaskData);

/** Triggers shadow gather dynamic mesh elements task graph to start processing. */
extern void BeginShadowGatherDynamicMeshElements(FDynamicShadowsTaskData* TaskData);

extern bool UseCachedMeshDrawCommands();
extern bool UseCachedMeshDrawCommands_AnyThread();
extern bool IsDynamicInstancingEnabled(ERHIFeatureLevel::Type FeatureLevel);
enum class EGPUSkinCacheTransition
{
	FrameSetup,
	Renderer,
};

/** Resolves the view rect of scene color or depth using either a custom resolve or hardware resolve. */
void AddResolveSceneColorPass(FRDGBuilder& GraphBuilder, const FViewInfo& View, FRDGTextureMSAA SceneColor);
void AddResolveSceneDepthPass(FRDGBuilder& GraphBuilder, const FViewInfo& View, FRDGTextureMSAA SceneDepth);

/** Resolves all views for scene color / depth. */
void AddResolveSceneColorPass(FRDGBuilder& GraphBuilder, TArrayView<const FViewInfo> Views, FRDGTextureMSAA SceneColor);
void AddResolveSceneDepthPass(FRDGBuilder& GraphBuilder, TArrayView<const FViewInfo> Views, FRDGTextureMSAA SceneDepth);

/** Prepares virtual textures for feedback updates. */
void VirtualTextureFeedbackBegin(FRDGBuilder& GraphBuilder, TArrayView<const FViewInfo> Views, FIntPoint SceneTextureExtent);

/** Creates a half resolution checkerboard min / max depth buffer from the input full resolution depth buffer. */
FRDGTextureRef CreateHalfResolutionDepthCheckerboardMinMax(FRDGBuilder& GraphBuilder, TArrayView<const FViewInfo> Views, FRDGTextureRef SceneDepth);

/** Creates a half resolution depth buffer storing the min and max depth for each 2x2 pixel quad of a half resolution buffer. */
FRDGTextureRef CreateQuarterResolutionDepthMinAndMax(FRDGBuilder& GraphBuilder, TArrayView<const FViewInfo> Views, FRDGTextureRef DepthTexture);

/** Creates a quarter resolution depth buffer storing the min and max depth for each 4x4 pixel quad of the depth buffer. */
void CreateQuarterResolutionDepthMinAndMaxFromDepthTexture(FRDGBuilder& GraphBuilder, TArrayView<const FViewInfo> Views, FRDGTextureRef DepthTexture, FRDGTextureRef& OutHalfResMinMax, FRDGTextureRef& OutQuarterResMinMax);

inline const FSceneTexturesConfig& FViewInfo::GetSceneTexturesConfig() const
{
	// TODO:  We are refactoring away use of the FSceneTexturesConfig::Get() global singleton, but need this workaround for now to avoid crashes
	return Family->bIsViewFamilyInfo ? ((const FViewFamilyInfo*)Family)->SceneTexturesConfig : FSceneTexturesConfig::Get();
}

inline const FSceneTextures& FViewInfo::GetSceneTextures() const
{
	return ((FViewFamilyInfo*)Family)->GetSceneTextures();
}

inline const FSceneTextures* FViewInfo::GetSceneTexturesChecked() const
{
	return ((FViewFamilyInfo*)Family)->GetSceneTexturesChecked();
}

inline FSceneUniformBuffer& FViewInfo::GetSceneUniforms() const
{
	return Family->GetSceneRenderer()->GetSceneUniforms();
}

/**
  * Returns a family from an array of views, with the assumption that all point to the same view family, which will be
  * true for the "Views" array in the scene renderer.  There are some utility functions that receive the Views array,
  * rather than the renderer itself, and this avoids confusing code that accesses Views[0], in addition to validating
  * the assumption that all Views have the same Family.  FViewFamilyInfo is used to access FSceneTextures|Config.
  */
inline FViewFamilyInfo& GetViewFamilyInfo(const TArray<FViewInfo>& Views)
{
	check(Views.Num() == 1 || Views[0].Family == Views.Last().Family);
	return *(FViewFamilyInfo*)Views[0].Family;
}

inline const FViewFamilyInfo& GetViewFamilyInfo(const TArray<const FViewInfo>& Views)
{
	check(Views.Num() == 1 || Views[0].Family == Views.Last().Family);
	return *(const FViewFamilyInfo*)Views[0].Family;
}

inline FViewFamilyInfo& GetViewFamilyInfo(const TArrayView<FViewInfo>& Views)
{
	check(Views.Num() == 1 || Views[0].Family == Views.Last().Family);
	return *(FViewFamilyInfo*)Views[0].Family;
}

inline const FViewFamilyInfo& GetViewFamilyInfo(const TArrayView<const FViewInfo>& Views)
{
	check(Views.Num() == 1 || Views[0].Family == Views.Last().Family);
	return *(const FViewFamilyInfo*)Views[0].Family;
}

/** Checks whether primitive alpha holdout is active.*/
bool IsPrimitiveAlphaHoldoutEnabled(const FViewInfo& View);

/** Checks whether primitive alpha holdout is active for any view.*/
bool IsPrimitiveAlphaHoldoutEnabledForAnyView(TArrayView<const FViewInfo> Views);

bool SceneCaptureRequiresAlphaChannel(const FSceneView& View);

/** Checks whether the material and scene proxy combination will modify the mesh position. Useful for determining whether the material can be substituted with a default material for depth rendering etc. */
bool DoMaterialAndPrimitiveModifyMeshPosition(const FMaterial& Material, const FPrimitiveSceneProxy* PrimitiveSceneProxy);