SceneRendering.h

Go to the documentation of this file.

// 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"
#include "DepthRendering.h"
 
#if RHI_RAYTRACING
#include "RayTracing/RayTracingScene.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;
struct FMobileBasePassTextures;
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"));
 
class FMobileCSMVisibilityInfo
{
public:
    uint32 bMobileDynamicCSMInUse : 1;
 
    // true if all draws should be forced to use CSM shaders.
    uint32 bAlwaysUseCSM : 1;
 
    FSceneBitArray MobilePrimitiveCSMReceiverVisibilityMap;
    FSceneBitArray MobileCSMStaticMeshVisibilityMap;
 
    FSceneBitArray MobileNonCSMStaticMeshVisibilityMap;
 
    FMobileCSMVisibilityInfo() : bMobileDynamicCSMInUse(false), bAlwaysUseCSM(false)
    {}
};
 
class FMobileCSMSubjectPrimitives
{
public:
    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;
        }
    }
 
    const TArray<const FPrimitiveSceneInfo*, SceneRenderingAllocator>& GetShadowSubjectPrimitives() const
    {
        return ShadowSubjectPrimitives;
    }
 
    void InitShadowSubjectPrimitives(int32 PrimitiveCount)
    {
        ShadowSubjectPrimitivesEncountered.Init(false, PrimitiveCount);
    }
 
protected:
    FSceneBitArray ShadowSubjectPrimitivesEncountered;
    TArray<const FPrimitiveSceneInfo*, SceneRenderingAllocator> ShadowSubjectPrimitives;
};
 
class FVisibleLightViewInfo
{
public:
 
    FSceneBitArray ProjectedShadowVisibilityMap;
 
    TArray<FPrimitiveViewRelevance,SceneRenderingAllocator> ProjectedShadowViewRelevanceMap;
 
    uint32 bInViewFrustum : 1;
    uint32 bInDrawRange : 1;
 
    FMobileCSMSubjectPrimitives MobileCSMSubjectPrimitives;
 
    FVisibleLightViewInfo()
    :   bInViewFrustum(false)
    ,   bInDrawRange(false)
    {}
};
 
class FVisibleLightInfo
{
public:
 
    TArray<FProjectedShadowInfo*,SceneRenderingAllocator> AllProjectedShadows;
 
    TArray<FProjectedShadowInfo*,SceneRenderingAllocator> ShadowsToProject;
    TArray<FProjectedShadowInfo*,SceneRenderingAllocator> CapsuleShadowsToProject;
 
    TArray<TRefCountPtr<FProjectedShadowInfo>,SceneRenderingAllocator> ProjectedPreShadows;
 
    TArray<FProjectedShadowInfo*,SceneRenderingAllocator> OccludedPerObjectShadows;
 
    TArray<TSharedPtr<FVirtualShadowMapClipmap>, SceneRenderingAllocator> VirtualShadowMapClipmaps;
 
    bool ContainsOnlyVirtualShadowMaps() const;
 
    TSharedPtr<FVirtualShadowMapClipmap> FindVirtualShadowMapShadowClipmapForView(const FViewInfo* View) const;
 
    int32 GetVirtualShadowMapId( const FViewInfo* View ) const;
};
 
// 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];
    }
};
 
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;
};
 
class FOcclusionQueryBatcher
{
public:
 
    enum { OccludedPrimitiveQueryBatchSize = 16 };
 
    FOcclusionQueryBatcher(class FSceneViewState* ViewState, uint32 InMaxBatchedPrimitives, uint32 InNumInstances);
 
    ~FOcclusionQueryBatcher();
 
    bool HasBatches(void) const { return (NumBatchedPrimitives > 0); }
 
    void Flush(FRHICommandList& RHICmdList);
 
    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;
    };
 
    TArray<FOcclusionBatch,SceneRenderingAllocator> BatchOcclusionQueries;
 
    FOcclusionBatch* CurrentBatchOcclusionQuery;
 
    const uint32 MaxBatchedPrimitives;
 
    uint32 NumBatchedPrimitives;
 
    FFrameBasedOcclusionQueryPool* OcclusionQueryPool;
 
    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
 
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)
    {}
 
    FBox Bounds;
 
    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:
    FBox Bounds;
 
    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;
 
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;
};
 
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;
 
    // 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;
};
 
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;
 
    FSceneViewState* ViewState;
 
    TUniquePtr<FViewUniformShaderParameters> CachedViewUniformShaderParameters;
 
    FSceneBitArray PrimitiveVisibilityMap;
 
    FSceneBitArray PrimitiveRayTracingVisibilityMap;
 
    FSceneBitArray PrimitiveDefinitelyUnoccludedMap;
 
    FSceneBitArray PotentiallyFadingPrimitiveMap;
 
    TArray<FRHIUniformBuffer*,SceneRenderingAllocator> PrimitiveFadeUniformBuffers;
 
    FSceneBitArray PrimitiveFadeUniformBufferMap;
 
    FUniformBufferRHIRef DitherFadeInUniformBuffer;
 
    FUniformBufferRHIRef DitherFadeOutUniformBuffer;
 
    TArray<FPrimitiveViewRelevance,SceneRenderingAllocator> PrimitiveViewRelevanceMap;
 
    FSceneBitArray StaticMeshVisibilityMap;
 
    FSceneBitArray StaticMeshFadeOutDitheredLODMap;
 
    FSceneBitArray StaticMeshFadeInDitheredLODMap;
 
    TArray<FLODMask, SceneRenderingAllocator> PrimitivesLODMask;
 
    TArray<FPrimitiveSceneInfo*, SceneRenderingAllocator> VisibleDynamicPrimitivesWithSimpleLights;
 
    int32 NumVisibleDynamicPrimitives;
 
    int32 NumVisibleDynamicEditorPrimitives;
 
    int32 NumVisibleDynamicMeshElements[EMeshPass::Num];
 
    TArray<FPrimitiveSceneInfo*,SceneRenderingAllocator> DirtyIndirectLightingCacheBufferPrimitives;
    UE::FMutex DirtyIndirectLightingCacheBufferPrimitivesMutex; 
 
    FTranslucentSelfShadowUniformBufferMap TranslucentSelfShadowUniformBufferMap;
 
    FGlobalDistanceFieldInfo& GlobalDistanceFieldInfo = *Allocator.Create<FGlobalDistanceFieldInfo>();
 
    FTranslucenyPrimCount TranslucentPrimCount;
    
    bool bHasDistortionPrimitives;
    bool bHasCustomDepthPrimitives;
 
    TSet<uint32, DefaultKeyFuncs<uint32>, SceneRenderingSetAllocator> CustomDepthStencilValues;
 
    TArray<FPrimitiveInstanceRange, SceneRenderingAllocator> NaniteCustomDepthInstances;
 
    TArray<FVolumetricMeshBatch, SceneRenderingAllocator> VolumetricMeshBatches;
 
    TArray<FVolumetricMeshBatch, SceneRenderingAllocator> HeterogeneousVolumesMeshBatches;
 
    TArray<FSkyMeshBatch, SceneRenderingAllocator> SkyMeshBatches;
 
    TArray<FSortedTrianglesMeshBatch, SceneRenderingAllocator> SortedTrianglesMeshBatches;
 
    TArray<FVisibleLightViewInfo, SceneRenderingAllocator> VisibleLightInfos;
 
    TArray<const FLightSceneProxy*, SceneRenderingAllocator> VisibleReflectionCaptureLights;
 
    FBatchedElements& BatchedViewElements = *Allocator.Create<FBatchedElements>();
 
    FBatchedElements& TopBatchedViewElements = *Allocator.Create<FBatchedElements>();
 
    TIndirectArray<FMeshBatch, SceneRenderingAllocator> ViewMeshElements;
 
    TIndirectArray<FMeshBatch, SceneRenderingAllocator> TopViewMeshElements;
 
    TArray<FDynamicPrimitiveResource*, SceneRenderingAllocator> DynamicResources;
 
    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;
 
    TArray<FMeshBatchAndRelevance, SceneRenderingAllocator> HairStrandsMeshElements;
    TArray<FMeshBatchAndRelevance, SceneRenderingAllocator> HairCardsMeshElements;
 
    /* Mesh pass relevance for gathered dynamic mesh elements. */
    TArray<FMeshPassMask, SceneRenderingAllocator> DynamicMeshElementsPassRelevance;
 
    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 VisibleRayTracingShaderBindings;
    FDynamicRayTracingMeshCommandStorage DynamicRayTracingMeshCommandStorage;
    TSet<FRDGBuffer*> DynamicRayTracingRDGBuffers;
 
    FRayTracingCullingParameters RayTracingCullingParameters;
 
    TArray<UE::Tasks::FTask> AddDynamicRayTracingMeshBatchTaskList;
    TArray<FRayTracingShaderBindingDataOneFrameArray*, SceneRenderingAllocator> DynamicRayTracingShaderBindingsPerTask;
    TArray<FDynamicRayTracingMeshCommandStorage*, SceneRenderingAllocator> DynamicRayTracingMeshCommandStoragePerTask;
#endif // RHI_RAYTRACING
 
    // 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;
 
    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;
 
    bool bUseDirectionalInscattering;
    float DirectionalInscatteringExponent;
    float DirectionalInscatteringStartDistance;
    FVector InscatteringLightDirection;
    FLinearColor DirectionalInscatteringColor;
 
    FVector TranslucencyLightingVolumeMin[TVC_MAX];
    float TranslucencyVolumeVoxelSize[TVC_MAX];
    FVector TranslucencyLightingVolumeSize[TVC_MAX];
 
    FViewInfo* TemporalSourceView;
 
    int32 TemporalJitterSequenceLength;
 
    int32 TemporalJitterIndex;
 
    FVector2D TemporalJitterPixels;
 
    uint32 bStatePrevViewInfoIsReadOnly : 1;
 
    uint32 bHasNoVisiblePrimitive : 1;
 
    uint32 bHasTranslucentViewMeshElements : 1;
    uint32 bPrevTransformsReset : 1;
    uint32 bIgnoreExistingQueries : 1;
    uint32 bDisableQuerySubmissions : 1;
    uint32 bUsesGlobalDistanceField : 1;
    uint32 bUsesLightingChannels : 1;
    uint32 bTranslucentSurfaceLighting : 1;
    uint32 bCustomDepthStencilValid : 1;
    uint32 bUsesCustomDepth : 1;
    uint32 bUsesCustomStencil : 1;
 
    uint32 bUsesMotionVectorWorldOffset : 1;
 
    uint32 bFogOnlyOnRenderedOpaque : 1;
 
    uint32 bSceneHasSkyMaterial : 1;
    uint32 bHasSingleLayerWaterMaterial : 1;
    uint32 bUsesSecondStageDepthPass : 1;
 
    uint32 bSceneCaptureMainViewJitter : 1;
 
    float AutoBeforeDOFTranslucencyBoundary;
 
    uint16 ShadingModelMaskInView;
 
    FPreviousViewInfo& PrevViewInfo = *Allocator.Create<FPreviousViewInfo>();
 
    int32 NumVisibleStaticMeshElements;
 
    float PreExposure;
 
    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;
 
    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;
 
    ICustomVisibilityQuery* CustomVisibilityQuery;
 
    const FTexture2DResource* FFTBloomKernelTexture = nullptr;
    const FTexture2DResource* FilmGrainTexture = nullptr;
 
    TArray<FPrimitiveSceneInfo*, SceneRenderingAllocator> IndirectShadowPrimitives;
 
    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
private:
    FRayTracingScene::FViewHandle RayTracingSceneViewHandle;
 
public:
 
    bool HasRayTracingScene() const;
    FRHIRayTracingScene* GetRayTracingSceneChecked(ERayTracingSceneLayer Layer) const;
    FRDGBufferSRVRef GetRayTracingSceneLayerViewChecked(ERayTracingSceneLayer Layer) const;
 
    FRDGBufferUAVRef GetRayTracingInstanceHitCountUAV(FRDGBuilder& GraphBuilder) const;
 
    inline const FRayTracingScene::FViewHandle& GetRayTracingSceneViewHandle() const
    {
        if (UNLIKELY(IStereoRendering::IsStereoEyePass(StereoPass) && IStereoRendering::IsASecondaryPass(StereoPass)))
        {
            return GetPrimaryView()->RayTracingSceneViewHandle;
        }
 
        return RayTracingSceneViewHandle;
    }
 
    inline void SetRayTracingSceneViewHandle(const FRayTracingScene::FViewHandle& InHandle)
    {
        checkf(!IStereoRendering::IsStereoEyePass(StereoPass) || !IStereoRendering::IsASecondaryPass(StereoPass), TEXT("Stereo views should share a single ray tracing scene view."));
        RayTracingSceneViewHandle = InHandle;
    }
 
    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;
    bool bOwnsShaderBindingTables = true;
    bool bTransientShaderBindingTables = false;
 
    // 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
 
    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
 
    RENDERER_API FViewInfo(const FSceneViewInitOptions& InitOptions);
 
    explicit FViewInfo(const FSceneView* InView);
 
    RENDERER_API virtual ~FViewInfo();
 
#if DO_CHECK || USING_CODE_ANALYSIS
    bool VerifyMembersChecks() const;
#endif
 
    RENDERER_API FIntPoint GetSecondaryViewRectSize() const;
 
    RENDERER_API FIntRect GetSecondaryViewCropRect() const;
    
    bool RequiresSecondaryUpscale() const
    {
        return UnscaledViewRect.Size() != GetSecondaryViewRectSize() || GetSecondaryViewCropRect().Size() != GetSecondaryViewRectSize();
    }
 
    void UpdatePreExposure();
 
    RENDERER_API void SetupUniformBufferParameters(
        const FViewMatrices& InViewMatrices,
        const FViewMatrices& InPrevViewMatrices,
        FBox* OutTranslucentCascadeBoundsArray, 
        int32 NumTranslucentCascades,
        FViewUniformShaderParameters& ViewUniformShaderParameters) const;
 
    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;
 
    void InitRHIResources(uint32 OverrideNumMSAASamples = 0);
 
    void CreateViewUniformBuffers(const FViewUniformShaderParameters& Params);
 
    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;
 
    bool UpdatePrimitiveFadingState(const FPrimitiveSceneInfo* PrimitiveSceneInfo, bool bFadingIn);
 
    using FSceneView::GetEyeAdaptationBuffer;
    FRDGPooledBuffer* GetEyeAdaptationBuffer(FRDGBuilder& GraphBuilder) const;
 
    float GetLastEyeAdaptationExposure() const;
 
    float GetLastAverageLocalExposure() const;
 
    float GetLastAverageSceneLuminance() const;
 
    void SwapEyeAdaptationBuffers() const;
 
    void UpdateEyeAdaptationLastExposureFromBuffer() const;
 
    void EnqueueEyeAdaptationExposureBufferReadback(FRDGBuilder& GraphBuilder) const;
 
    bool ShouldUpdateEyeAdaptationBuffer() const;
    
    void SetValidTonemappingLUT() const;
 
    IPooledRenderTarget* GetTonemappingLUT() const;
 
    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;
    }
 
    bool ShouldRenderView() const 
    {
        if (bHasNoVisiblePrimitive)
        {
            return false;
        }
        else if (!bIsSinglePassStereo)
        {
            return true;
        }
        else if (bIsSinglePassStereo && !IStereoRendering::IsASecondaryPass(StereoPass))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
 
    FIntRect GetFamilyViewRect() const;
 
    FIntRect GetUnscaledFamilyViewRect() const;
 
    void BeginRenderView() const;
 
    FViewShaderParameters GetShaderParameters() const;
 
    RENDERER_API const FViewInfo* GetPrimaryView() const;
 
    inline const FViewInfo* GetInstancedView() const { return static_cast<const FViewInfo*>(GetInstancedSceneView()); }
 
    FViewInfo* CreateSnapshot() const;
 
    void Cleanup();
 
    // Get the range in DynamicMeshElements[] for a given PrimitiveIndex
    // @return range (start is inclusive, end is exclusive)
    FInt32Range GetDynamicMeshElementRange(uint32 PrimitiveIndex) const;
 
    const FSceneTexturesConfig& GetSceneTexturesConfig() const;
    const FSceneTextures& GetSceneTextures() const;
    const FSceneTextures* GetSceneTexturesChecked() const;
 
    FSceneUniformBuffer& GetSceneUniforms() const;
 
    RENDERER_API FRDGTextureRef GetVolumetricCloudTexture(FRDGBuilder& GraphBuilder) const;
 
    bool RequiresDebugMaterials() const;
 
    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;
 
    void Init();
 
    void CalcTranslucencyLightingVolumeBounds(FBox* InOutCascadeBoundsArray, int32 NumCascades) const;
};
 
 
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
{
    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;
};
 
class FViewFamilyInfo : public FSceneViewFamily
{
public:
    explicit FViewFamilyInfo(const FSceneViewFamily& InViewFamily);
    explicit FViewFamilyInfo(const FSceneViewFamily::ConstructionValues& CVS, const FViewFamilyInfo& MainViewFamily);
    virtual ~FViewFamilyInfo();
 
    FSceneTexturesConfig SceneTexturesConfig;
 
    bool bIsSceneTextureSizedCapture = false;
 
    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:
    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; }
 
    TArray<FViewInfo> Views;
 
    virtual FViewFamilyInfo* GetViewFamily() { return nullptr; }
 
    virtual FDeferredShadingSceneRenderer* GetDeferredShadingSceneRenderer() { return nullptr; }
 
private:
    FSceneUniformBuffer SceneUniforms;
    FSceneExtensionsRenderers SceneExtensionsRenderers;
};
 
class FSceneRenderer : public FSceneRendererBase
{
public:
    FDepthPassInfo DepthPass;
 
    FSceneRenderingBulkObjectAllocator Allocator;
 
    FViewFamilyInfo ViewFamily;
 
    struct FCustomRenderPassInfo
    {
        FCustomRenderPassInfo(const FSceneViewFamily::ConstructionValues& CVS);
        FCustomRenderPassInfo(const FSceneViewFamily::ConstructionValues& CVS, const FViewFamilyInfo& MainViewFamily);
 
        FCustomRenderPassBase* CustomRenderPass;
        FViewFamilyInfo ViewFamily;
        TArray<FViewInfo> Views;
        FNaniteShadingCommands NaniteBasePassShadingCommands;
    };
    TArray<FCustomRenderPassInfo> CustomRenderPassInfos;
 
    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;
                }
            }
        }
    }
 
 
    DynamicRenderScaling::TMap<float> DynamicResolutionFractions;
    DynamicRenderScaling::TMap<float> DynamicResolutionUpperBounds;
 
    TArray<FVisibleLightInfo, SceneRenderingAllocator> VisibleLightInfos;
 
    UE::FMutex DispatchedShadowDepthPassesMutex;
    TArray<FParallelMeshDrawCommandPass*, SceneRenderingAllocator> DispatchedShadowDepthPasses;
 
    FSortedShadowMaps SortedShadowsForShadowDepthPass;
 
    FVirtualShadowMapArray VirtualShadowMapArray;
 
    LightFunctionAtlas::FLightFunctionAtlas LightFunctionAtlas;
 
    bool bHasRequestedToggleFreeze;
 
    bool bUsedPrecomputedVisibility;
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    TArray<FString, SceneRenderingAllocator> UsedWholeScenePointLightNames;
#endif
    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;
 
    void PrepareViewRectsForRendering();
 
#if WITH_MGPU
    void ComputeGPUMasks(FRHICommandListImmediate* RHICmdList);
#endif
 
    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; }
 
    static FGlobalBoundShaderState OcclusionTestBoundShaderState;
    
    static bool ShouldCompositeEditorPrimitives(const FViewInfo& View);
 
    static FIntPoint ApplyResolutionFraction(
        const FSceneViewFamily& ViewFamily, const FIntPoint& UnscaledViewSize, float ResolutionFraction);
 
    static FIntPoint QuantizeViewRectMin(const FIntPoint& ViewRectMin);
 
    static FIntPoint GetDesiredInternalBufferSize(const FSceneViewFamily& ViewFamily);
 
    static ISceneViewFamilyScreenPercentage* ForkScreenPercentageInterface(
        const ISceneViewFamilyScreenPercentage* ScreenPercentageInterface, FSceneViewFamily& ForkedViewFamily)
    {
        return ScreenPercentageInterface->Fork_GameThread(ForkedViewFamily);
    }
 
    static int32 GetRefractionQuality(const FSceneViewFamily& ViewFamily);
 
    void RenderSkyAtmosphereInternal(
        FRDGBuilder& GraphBuilder,
        const FSceneTextureShaderParameters& SceneTextures,
        FSkyAtmosphereRenderContext& SkyRenderContext);
 
    void  RenderVolumetricCloudsInternal(FRDGBuilder& GraphBuilder, FCloudRenderContext& CloudRC, FInstanceCullingManager& InstanceCullingManager, const FIntPoint& CloudViewportSize);
 
    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);
 
    void RenderCapsuleShadowsForMovableSkylight(
        FRDGBuilder& GraphBuilder,
        const FViewInfo& View,
        FRDGTextureRef& BentNormalOutput) const;
 
    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);
 
    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; }
 
    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:
 
    FIntPoint FamilySize;
 
#if WITH_MGPU
    TArray<FCrossGPUTransferFence*> CrossGPUTransferFencesDefer;
    TArray<FCrossGPUTransferFence*> CrossGPUTransferFencesWait;
 
    TRefCountPtr<class FCrossGPUTransfersDeferred> CrossGPUTransferDeferred;
 
    FRHIGPUMask AllViewsGPUMask;
    bool IsShadowCached(FProjectedShadowInfo* ProjectedShadowInfo) const;
    FRHIGPUMask GetGPUMaskForShadow(FProjectedShadowInfo* ProjectedShadowInfo) const;
#endif
 
    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;
 
    TRefCountPtr<FProjectedShadowInfo> GetCachedPreshadow(
        const FLightPrimitiveInteraction* InParentInteraction,
        const FProjectedShadowInitializer& Initializer,
        const FBoxSphereBounds& Bounds,
        uint32 InResolutionX);
 
    void CreatePerObjectProjectedShadow(
        FDynamicShadowsTaskData& TaskData,
        FLightPrimitiveInteraction* Interaction,
        bool bCreateTranslucentObjectShadow,
        bool bCreateInsetObjectShadow,
        const TArray<FProjectedShadowInfo*, SceneRenderingAllocator>& ViewDependentWholeSceneShadows,
        TArray<FProjectedShadowInfo*, SceneRenderingAllocator>& OutPreShadows);
 
    void SetupInteractionShadows(
        FDynamicShadowsTaskData& TaskData,
        FLightPrimitiveInteraction* Interaction,
        FVisibleLightInfo& VisibleLightInfo,
        bool bStaticSceneOnly,
        const TArray<FProjectedShadowInfo*, SceneRenderingAllocator>& ViewDependentWholeSceneShadows,
        TArray<FProjectedShadowInfo*, SceneRenderingAllocator>& PreShadows);
 
    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);
    bool CheckForProjectedShadows(const FLightSceneInfo* LightSceneInfo) const;
 
    void BeginGatherShadowPrimitives(FDynamicShadowsTaskData* TaskData, IVisibilityTaskData* VisibilityTaskData);
    void FinishGatherShadowPrimitives(FDynamicShadowsTaskData* TaskData);
 
    void RenderShadowDepthMaps(FRDGBuilder& GraphBuilder, FDynamicShadowsTaskData* DynamicShadowsTaskData, FInstanceCullingManager& InstanceCullingManager, FRDGExternalAccessQueue& ExternalAccessQueue);
 
    void RenderShadowDepthMapAtlases(FRDGBuilder& GraphBuilder);
 
    void CreateWholeSceneProjectedShadow(FDynamicShadowsTaskData& TaskData, FLightSceneInfo* LightSceneInfo, int64 CachedShadowMapsSize, uint32& NumPointShadowCachesUpdatedThisFrame, uint32& NumSpotShadowCachesUpdatedThisFrame);
 
    void UpdatePreshadowCache();
 
    static void GatherSimpleLights(const FSceneViewFamily& ViewFamily, const TArray<FViewInfo>& Views, FSimpleLightArray& SimpleLights);
 
    void InitProjectedShadowVisibility(FDynamicShadowsTaskData& TaskData);
 
    void DrawDebugShadowFrustum(FViewInfo& View, FProjectedShadowInfo& ProjectedShadowInfo);
 
    void GatherShadowDynamicMeshElements(FDynamicShadowsTaskData& TaskData);
 
    bool RenderCapsuleDirectShadows(
        FRDGBuilder& GraphBuilder,
        const FLightSceneInfo& LightSceneInfo,
        FRDGTextureRef ScreenShadowMaskTexture,
        TArrayView<const FProjectedShadowInfo* const> CapsuleShadows,
        bool bProjectingForForwardShading) const;
 
    void PreVisibilityFrameSetup(FRDGBuilder& GraphBuilder);
 
    void GatherReflectionCaptureLightMeshElements();
 
    void PostVisibilityFrameSetup(FILCUpdatePrimTaskData*& OutILCTaskData);
 
    void InitFogConstants();
 
    bool ShouldRenderTranslucency() const;
    static bool ShouldRenderTranslucency(ETranslucencyPass::Type TranslucencyPass, TArrayView<FViewInfo> InViews);
 
    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);
 
    void InitSkyAtmosphereForViews(FRHICommandListImmediate& RHICmdList, FRDGBuilder& GraphBuilder);
    
    void RenderSkyAtmosphereLookUpTables(FRDGBuilder& GraphBuilder, class FSkyAtmospherePendingRDGResources& PendingRDGResources);
 
    void RenderSkyAtmosphere(FRDGBuilder& GraphBuilder, const FMinimalSceneTextures& SceneTextures);
 
    void InitVolumetricCloudsForViews(FRDGBuilder& GraphBuilder, bool bShouldRenderVolumetricCloud, FInstanceCullingManager& InstanceCullingManager);
 
    bool RenderVolumetricCloud(
        FRDGBuilder& GraphBuilder,
        const FMinimalSceneTextures& SceneTextures,
        bool bSkipVolumetricRenderTarget,
        bool bSkipPerPixelTracing,
        FRDGTextureRef HalfResolutionDepthCheckerboardMinMaxTexture,
        FRDGTextureRef QuarterResolutionDepthMinMaxTexture,
        bool bAsyncCompute,
        FInstanceCullingManager& InstanceCullingManager);
 
    void RenderSkyAtmosphereEditorNotifications(FRDGBuilder& GraphBuilder, TArrayView<FViewInfo> InViews, FRDGTextureRef SceneColorTexture) const;
 
    static bool ShouldRenderSkyAtmosphereEditorNotifications(TArrayView<FViewInfo> Views);
 
    void GatherAndSortLights(FSortedLightSetSceneInfo& OutSortedLights, bool bShadowedLightsInClustered = false);
 
    void UpdateLightFunctionAtlasTaskFunction();
    
    FComputeLightGridOutput ComputeLightGrid(FRDGBuilder& GraphBuilder, bool bCullLightsToGrid, const FSortedLightSetSceneInfo& SortedLightSet, TArray<FForwardLightUniformParameters*, TInlineAllocator<2>>& PerViewForwardLightUniformParameters);
 
    FComputeLightGridOutput PrepareForwardLightData(FRDGBuilder& GraphBuilder, bool bCullLightsToGrid, const FSortedLightSetSceneInfo& SortedLightSet);
 
    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;
};
 
enum class ESceneRenderCommonShowFlags
{
    None             = 0,
    HitProxies       = 1 << 0,
    PathTracing      = 1 << 1
};
ENUM_CLASS_FLAGS(ESceneRenderCommonShowFlags);
 
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;
}
 
typedef TArray<FRDGTextureRef, TInlineAllocator<6>> FColorTargets;
 
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;
 
    static bool RequiresMultiPass(int32 NumMSAASamples, EShaderPlatform ShaderPlatform);
 
    static bool ShouldRenderCustomDepth(const FViewInfo& View);
 
protected:
    FDynamicShadowsTaskData* InitDynamicShadows(FRDGBuilder& GraphBuilder, FInstanceCullingManager& FInstanceCullingManager);
 
    void PrepareViewVisibilityLists();
 
    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);
 
    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
    void RenderMobileDebugPrimitives(FRHICommandList& RHICmdList, const FViewInfo& View);
#endif
 
    void RenderMobileDebugView(FRHICommandList& RHICmdList, const FViewInfo& View, const FInstanceCullingDrawParams* DebugViewModeInstanceCullingDrawParams);
 
    void RenderModulatedShadowProjections(FRHICommandList& RHICmdList, int32 ViewIndex, const FViewInfo& View);
 
    void RenderOcclusion(FRHICommandList& RHICmdList, FViewInfo& View, const struct FViewOcclusionQueries& ViewOcclusionQueries);
 
    bool ShouldRenderHZB(TArrayView<FViewInfo> InViews);
 
 
    void RenderHZB(FRHICommandListImmediate& RHICmdList, const TRefCountPtr<IPooledRenderTarget>& SceneDepthZ);
    void RenderHZB(FRDGBuilder& GraphBuilder, FRDGTextureRef SceneDepthTexture);
 
    int32 ComputeNumOcclusionQueriesToBatch() const;
 
 
    void RenderDecals(FRHICommandList& RHICmdList, FViewInfo& View, const FInstanceCullingDrawParams* InstanceCullingDrawParams);
    void RenderDBuffer(FRDGBuilder& GraphBuilder, FSceneTextures& SceneTextures, FDBufferTextures& DBufferTextures, FInstanceCullingManager& InstanceCullingManager);
 
    void RenderFog(FRHICommandList& RHICmdList, const FViewInfo& View);
 
    static void RenderTranslucency(FRHICommandList& RHICmdList, const FViewInfo& View, TArrayView<FViewInfo> FamilyViewInfos, ETranslucencyPass::Type InStandardTranslucencyPass, EMeshPass::Type InStandardTranslucencyMeshPass, const FInstanceCullingDrawParams* InTranslucencyInstanceCullingDrawParams);
 
    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, FMobileBasePassTextures& BasePassTextures, FInstanceCullingManager& InstanceCullingManager);
    void RenderForwardSinglePass(FRDGBuilder& GraphBuilder, class FMobileRenderPassParameters* PassParameters, struct FRenderViewContext& ViewContext, FSceneTextures& SceneTextures, FInstanceCullingManager& InstanceCullingManager, struct FViewOcclusionQueries* ViewOcclusionQueries);
    void RenderForwardMultiPass(FRDGBuilder& GraphBuilder, class FMobileRenderPassParameters* PassParameters, struct FRenderViewContext& ViewContext, FSceneTextures& SceneTextures, FInstanceCullingManager& InstanceCullingManager, struct FViewOcclusionQueries* ViewOcclusionQueries);
    
    void RenderDeferredSinglePass(FRDGBuilder& GraphBuilder, FSceneTextures& SceneTextures, const FSortedLightSetSceneInfo& SortedLightSet, FMobileBasePassTextures& BasePassTextures, FInstanceCullingManager& InstanceCullingManager);
    void RenderDeferredMultiPass(FRDGBuilder& GraphBuilder, FSceneTextures& SceneTextures, const FSortedLightSetSceneInfo& SortedLightSet, FMobileBasePassTextures& BasePassTextures, FInstanceCullingManager& InstanceCullingManager);
 
    void RenderStereoMotionVectors(FRDGBuilder& GraphBuilder, FViewInfo& View, const FSceneTextures& SceneTextures, FInstanceCullingManager& InstanceCullingManager);
    bool HasStereoMotionVectorRenderTargets(const FSceneTextures& SceneTextures);
 
    FRDGTextureRef RenderAmbientOcclusion(FRDGBuilder& GraphBuilder, const FSceneTextures& SceneTextures);
 
    void RenderMobileScreenSpaceShadows(FRDGBuilder& GraphBuilder, FIntPoint Extent, FRDGTextureRef ScreenShadowMaskTexture);
    FRDGTextureRef RenderMobileShadowProjections(FRDGBuilder& GraphBuilder, FIntPoint Extent, bool bIsMobileMultiView);
 
    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 bShouldRenderVelocities;
    bool bShouldRenderHZB;
    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;
 
extern TConstArrayView<FProjectedShadowInfo*> GetProjectedDistanceFieldShadows(const FDynamicShadowsTaskData* TaskData);
 
extern void BeginShadowGatherDynamicMeshElements(FDynamicShadowsTaskData* TaskData);
 
extern bool UseCachedMeshDrawCommands();
extern bool UseCachedMeshDrawCommands_AnyThread();
extern bool IsDynamicInstancingEnabled(ERHIFeatureLevel::Type FeatureLevel);
enum class EGPUSkinCacheTransition
{
    FrameSetup,
    Renderer,
};
 
void AddResolveSceneColorPass(FRDGBuilder& GraphBuilder, const FViewInfo& View, FRDGTextureMSAA SceneColor);
void AddResolveSceneDepthPass(FRDGBuilder& GraphBuilder, const FViewInfo& View, FRDGTextureMSAA SceneDepth);
 
void AddResolveSceneColorPass(FRDGBuilder& GraphBuilder, TArrayView<const FViewInfo> Views, FRDGTextureMSAA SceneColor);
void AddResolveSceneDepthPass(FRDGBuilder& GraphBuilder, TArrayView<const FViewInfo> Views, FRDGTextureMSAA SceneDepth);
 
void VirtualTextureFeedbackBegin(FRDGBuilder& GraphBuilder, TArrayView<const FViewInfo> Views, FIntPoint SceneTextureExtent);
 
FRDGTextureRef CreateHalfResolutionDepthCheckerboardMinMax(FRDGBuilder& GraphBuilder, TArrayView<const FViewInfo> Views, FRDGTextureRef SceneDepth);
 
FRDGTextureRef CreateQuarterResolutionDepthMinAndMax(FRDGBuilder& GraphBuilder, TArrayView<const FViewInfo> Views, FRDGTextureRef DepthTexture);
 
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();
}
 
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;
}
 
bool IsPrimitiveAlphaHoldoutEnabled(const FViewInfo& View);
 
bool IsPrimitiveAlphaHoldoutEnabledForAnyView(TArrayView<const FViewInfo> Views);
 
bool SceneCaptureRequiresAlphaChannel(const FSceneView& View);
 
bool DoMaterialAndPrimitiveModifyMeshPosition(const FMaterial& Material, const FPrimitiveSceneProxy* PrimitiveSceneProxy);