ScenePrivate.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    ScenePrivate.h: Private scene manager definitions.
=============================================================================*/
 
#pragma once
 
// Dependencies.
 
#include "Containers/SparseSet.h"
#include "Misc/Guid.h"
#include "Math/RandomStream.h"
#include "Templates/PimplPtr.h"
#include "Templates/RefCounting.h"
#include "RHI.h"
#include "RenderResource.h"
#include "UniformBuffer.h"
#include "SceneInterface.h"
#include "SceneView.h"
#include "RendererInterface.h"
#include "SceneUtils.h"
#include "Materials/MaterialInstanceDynamic.h"
#include "TextureLayout3d.h"
#include "ScenePrivateBase.h"
#include "RenderTargetPool.h"
#include "PrimitiveSceneInfo.h"
#include "LightSceneInfo.h"
#include "DepthRendering.h"
#include "SceneHitProxyRendering.h"
#include "TextureLayout.h"
#include "SceneRendering.h"
#include "LightMapRendering.h"
#include "VelocityRendering.h"
#include "VolumeRendering.h"
#include "CommonRenderResources.h"
#include "VisualizeTexture.h"
#include "UnifiedBuffer.h"
#include "DebugViewModeRendering.h"
#include "PrecomputedVolumetricLightmap.h"
#include "RayTracing/RaytracingOptions.h"
#if RHI_RAYTRACING
#include "RayTracing/RayTracingScene.h"
#include "RayTracing/RayTracingShaderBindingTable.h"
#endif
#include "Nanite/Nanite.h"
#include "Lumen/LumenViewState.h"
#include "MegaLights/MegaLightsViewState.h"
#include "StochasticLighting/StochasticLightingViewState.h"
#include "VolumetricRenderTargetViewStateData.h"
#include "TranslucentLightingViewState.h"
#include "GPUScene.h"
#include "DynamicBVH.h"
#include "OIT/OIT.h"
#include "ShadingEnergyConservation.h"
#include "Substrate/Substrate.h"
#include "Substrate/Glint/GlintShadingLUTs.h"
#include "Experimental/Containers/RobinHoodHashTable.h"
#include "SpanAllocator.h"
#include "GlobalDistanceField.h"
#include "Algo/RemoveIf.h"
#include "UObject/Package.h"
#include "LightFunctionAtlas.h"
#include "SceneExtensions.h"
#include "HeterogeneousVolumes/HeterogeneousVolumes.h"
#include "ScenePrimitiveUpdates.h"
#include "RenderTransform.h"
 
#define OCCLUSION_SLOP (1.0f)
 
DECLARE_GPU_STAT_NAMED_EXTERN(ShadowProjection, TEXT("Shadow Projection"));
 
class AWorldSettings;
class FMaterialParameterCollectionInstanceResource;
class FPrecomputedLightVolume;
class FScene;
class UDecalComponent;
class UExponentialHeightFogComponent;
class ULightComponent;
class UPlanarReflectionComponent;
class UPrimitiveComponent;
class UInstancedStaticMeshComponent;
class UReflectionCaptureComponent;
class USkyLightComponent;
class UStaticMesh;
class UStaticMeshComponent;
class UTextureCube;
class UWindDirectionalSourceComponent;
class FDeferredDecalProxy;
class FRHIGPUBufferReadback;
class FRHIGPUTextureReadback;
class FRuntimeVirtualTextureSceneProxy;
class FLumenSceneData;
class FVirtualShadowMapArrayCacheManager;
class FDistanceFieldObjectBuffers;
struct FHairStrandsInstance;
struct FPathTracingState;
class FSparseVolumeTextureViewerSceneProxy;
class FExponentialHeightFogSceneInfo;
class FStaticMeshBatch;
enum class EVTInvalidatePriority : uint8;
enum class ERayTracingProxyType : uint8;
namespace DiaphragmDOF
{
    class FDOFViewState;
}
 
class FPrimitiveOcclusionHistory
{
public:
    FPrimitiveComponentId PrimitiveId;
 
    FRHIRenderQuery* PendingOcclusionQuery[FOcclusionQueryHelpers::MaxBufferedOcclusionFrames];
    uint32 PendingOcclusionQueryFrames[FOcclusionQueryHelpers::MaxBufferedOcclusionFrames]; 
 
    uint32 LastTestFrameNumber;
    uint32 LastConsideredFrameNumber;
    uint32 HZBTestIndex;
 
    float LastProvenVisibleTime;
 
    float LastConsideredTime;
 
    float LastPixelsPercentage;
 
    int32 CustomIndex;
 
    uint8 BecameEligibleForQueryCooldown : 6;
 
    uint8 WasOccludedLastFrame : 1;
    uint8 OcclusionStateWasDefiniteLastFrame : 1;
 
    bool bGroupedQuery[FOcclusionQueryHelpers::MaxBufferedOcclusionFrames];
 
private:
    bool bNeedsScanOnRead;
 
    inline int32 ScanOldestNonStaleQueryIndex(uint32 FrameNumber, int32 NumBufferedFrames, int32 LagTolerance) const
    {
        uint32 OldestFrame = UINT32_MAX;
        int32 OldestQueryIndex = -1;
        for (int Index = 0; Index < NumBufferedFrames; ++Index)
        {
            const uint32 ThisFrameNumber = PendingOcclusionQueryFrames[Index];
            const int32 LaggedFrames = FrameNumber - ThisFrameNumber;
            // Queries older than LagTolerance are invalid. They may have already been reused and will give incorrect results if read
            if (PendingOcclusionQuery[Index] && LaggedFrames <= LagTolerance && ThisFrameNumber < OldestFrame)
            {
                OldestFrame = ThisFrameNumber;
                OldestQueryIndex = Index;
            }
        }
        return OldestQueryIndex;
    }
 
public:
    inline FPrimitiveOcclusionHistory(FPrimitiveComponentId InPrimitiveId, int32 SubQuery)
        : PrimitiveId(InPrimitiveId)
        , LastTestFrameNumber(~0u)
        , LastConsideredFrameNumber(~0u)
        , HZBTestIndex(0)
        , LastProvenVisibleTime(0.0f)
        , LastConsideredTime(0.0f)
        , LastPixelsPercentage(0.0f)
        , CustomIndex(SubQuery)
        , BecameEligibleForQueryCooldown(0)
        , WasOccludedLastFrame(false)
        , OcclusionStateWasDefiniteLastFrame(false)
        , bNeedsScanOnRead(false)
    {
        for (int32 Index = 0; Index < FOcclusionQueryHelpers::MaxBufferedOcclusionFrames; Index++)
        {
            PendingOcclusionQuery[Index] = nullptr;
            PendingOcclusionQueryFrames[Index] = 0;
            bGroupedQuery[Index] = false;
        }
    }
 
    inline FPrimitiveOcclusionHistory()
        : LastTestFrameNumber(~0u)
        , LastConsideredFrameNumber(~0u)
        , HZBTestIndex(0)
        , LastProvenVisibleTime(0.0f)
        , LastConsideredTime(0.0f)
        , LastPixelsPercentage(0.0f)
        , CustomIndex(0)
        , BecameEligibleForQueryCooldown(0)
        , WasOccludedLastFrame(false)
        , OcclusionStateWasDefiniteLastFrame(false)
        , bNeedsScanOnRead(false)
    {
        for (int32 Index = 0; Index < FOcclusionQueryHelpers::MaxBufferedOcclusionFrames; Index++)
        {
            PendingOcclusionQuery[Index] = nullptr;
            PendingOcclusionQueryFrames[Index] = 0;
            bGroupedQuery[Index] = false;
        }
    }
 
    inline FRHIRenderQuery* GetQueryForReading(uint32 FrameNumber, int32 NumBufferedFrames, int32 LagTolerance, bool& bOutGrouped) const
    {
        const int32 OldestQueryIndex = bNeedsScanOnRead ? ScanOldestNonStaleQueryIndex(FrameNumber, NumBufferedFrames, LagTolerance)
                                                        : FOcclusionQueryHelpers::GetQueryLookupIndex(FrameNumber, NumBufferedFrames);
        const int32 LaggedFrames = FrameNumber - PendingOcclusionQueryFrames[OldestQueryIndex];
        // Nenever read from queries are older than LagTolerance. They may have already been reused and will give incorrect results
        if (OldestQueryIndex == -1 || !PendingOcclusionQuery[OldestQueryIndex] || LaggedFrames > LagTolerance)
        {
            bOutGrouped = false;
            return nullptr;
        }
        bOutGrouped = bGroupedQuery[OldestQueryIndex];
        return PendingOcclusionQuery[OldestQueryIndex];
    }
 
    inline void SetCurrentQuery(uint32 FrameNumber, FRHIRenderQuery* NewQuery, int32 NumBufferedFrames, bool bGrouped, bool bNeedsScan)
    {
        // Get the current occlusion query
        const uint32 QueryIndex = FOcclusionQueryHelpers::GetQueryIssueIndex(FrameNumber, NumBufferedFrames);
        PendingOcclusionQuery[QueryIndex] = NewQuery;
        PendingOcclusionQueryFrames[QueryIndex] = FrameNumber;
        bGroupedQuery[QueryIndex] = bGrouped;
 
        bNeedsScanOnRead = bNeedsScan;
    }
 
    inline uint32 LastQuerySubmitFrame() const
    {
        uint32 Result = 0;
 
        for (int32 Index = 0; Index < FOcclusionQueryHelpers::MaxBufferedOcclusionFrames; Index++)
        {
            if (!bGroupedQuery[Index])
            {
                Result = FMath::Max(Result, PendingOcclusionQueryFrames[Index]);
            }
        }
 
        return Result;
    }
};
 
struct FPrimitiveOcclusionHistoryKey
{
    FPrimitiveComponentId PrimitiveId;
    int32 CustomIndex;
 
    explicit FPrimitiveOcclusionHistoryKey(const FPrimitiveOcclusionHistory& Element)
        : PrimitiveId(Element.PrimitiveId)
        , CustomIndex(Element.CustomIndex)
    {
    }
    FPrimitiveOcclusionHistoryKey(FPrimitiveComponentId InPrimitiveId, int32 InCustomIndex)
        : PrimitiveId(InPrimitiveId)
        , CustomIndex(InCustomIndex)
    {
    }
};
 
inline uint32 GetTypeHash(const FPrimitiveOcclusionHistoryKey& Key)
{
    return GetTypeHash(Key.PrimitiveId.PrimIDValue) ^ (GetTypeHash(Key.CustomIndex) >> 20);
}
 
inline bool operator==(const FPrimitiveOcclusionHistoryKey& A, const FPrimitiveOcclusionHistoryKey& B)
{
    return A.PrimitiveId == B.PrimitiveId && A.CustomIndex == B.CustomIndex;
}
 
struct FPrimitiveOcclusionHistoryKeyFuncs : BaseKeyFuncs<FPrimitiveOcclusionHistory,FPrimitiveOcclusionHistoryKey>
{
    typedef FPrimitiveOcclusionHistoryKey KeyInitType;
 
    static KeyInitType GetSetKey(const FPrimitiveOcclusionHistory& Element)
    {
        return FPrimitiveOcclusionHistoryKey(Element);
    }
 
    static bool Matches(KeyInitType A,KeyInitType B)
    {
        return A == B;
    }
 
    static uint32 GetKeyHash(KeyInitType Key)
    {
        return GetTypeHash(Key);
    }
};
 
class FIndividualOcclusionHistory
{
    FRHIPooledRenderQuery PendingOcclusionQuery[FOcclusionQueryHelpers::MaxBufferedOcclusionFrames];
    uint32 PendingOcclusionQueryFrames[FOcclusionQueryHelpers::MaxBufferedOcclusionFrames]; // not initialized...this is ok
 
public:
 
    inline void ReleaseStaleQueries(uint32 FrameNumber, int32 NumBufferedFrames)
    {
        for (uint32 DeltaFrame = NumBufferedFrames; DeltaFrame > 0; DeltaFrame--)
        {
            if (FrameNumber >= (DeltaFrame - 1))
            {
                uint32 TestFrame = FrameNumber - (DeltaFrame - 1);
                const uint32 QueryIndex = FOcclusionQueryHelpers::GetQueryLookupIndex(TestFrame, NumBufferedFrames);
                if (PendingOcclusionQueryFrames[QueryIndex] != TestFrame)
                {
                    PendingOcclusionQuery[QueryIndex].ReleaseQuery();
                }
            }
        }
    }
    inline void ReleaseQuery(uint32 FrameNumber, int32 NumBufferedFrames)
    {
        const uint32 QueryIndex = FOcclusionQueryHelpers::GetQueryLookupIndex(FrameNumber, NumBufferedFrames);
        PendingOcclusionQuery[QueryIndex].ReleaseQuery();
    }
 
    inline FRHIRenderQuery* GetPastQuery(uint32 FrameNumber, int32 NumBufferedFrames)
    {
        // Get the oldest occlusion query
        const uint32 QueryIndex = FOcclusionQueryHelpers::GetQueryLookupIndex(FrameNumber, NumBufferedFrames);
        if (PendingOcclusionQuery[QueryIndex].GetQuery() && PendingOcclusionQueryFrames[QueryIndex] == FrameNumber - uint32(NumBufferedFrames))
        {
            return PendingOcclusionQuery[QueryIndex].GetQuery();
        }
        return nullptr;
    }
 
    inline void SetCurrentQuery(uint32 FrameNumber, FRHIPooledRenderQuery&& NewQuery, int32 NumBufferedFrames)
    {
        // Get the current occlusion query
        const uint32 QueryIndex = FOcclusionQueryHelpers::GetQueryIssueIndex(FrameNumber, NumBufferedFrames);
        PendingOcclusionQuery[QueryIndex] = MoveTemp(NewQuery);
        PendingOcclusionQueryFrames[QueryIndex] = FrameNumber;
    }
};
 
class FGlobalDistanceCullFadeUniformBuffer : public TUniformBuffer< FDistanceCullFadeUniformShaderParameters >
{
public:
    void InitContents()
    {
        FDistanceCullFadeUniformShaderParameters Parameters;
        Parameters.FadeTimeScaleBias.X = 0.0f;
        Parameters.FadeTimeScaleBias.Y = 1.0f;
        SetContents(FRenderResource::GetImmediateCommandList(), Parameters);
    }
};
 
extern TGlobalResource< FGlobalDistanceCullFadeUniformBuffer > GDistanceCullFadedInUniformBuffer;
 
class FGlobalDitherUniformBuffer : public TUniformBuffer< FDitherUniformShaderParameters >
{
public:
    void InitContents()
    {
        FDitherUniformShaderParameters Parameters;
        Parameters.LODFactor = 0.0f;
        SetContents(FRenderResource::GetImmediateCommandList(), Parameters);
    }
};
 
extern TGlobalResource< FGlobalDitherUniformBuffer > GDitherFadedInUniformBuffer;
 
class FPrimitiveFadingState
{
public:
    FPrimitiveFadingState()
        : FadeTimeScaleBias(ForceInitToZero)
        , FrameNumber(0)
        , EndTime(0.0f)
        , bIsVisible(false)
        , bValid(false)
    {
    }
 
    FVector2D FadeTimeScaleBias;
 
    FDistanceCullFadeUniformBufferRef UniformBuffer;
 
    uint32 FrameNumber;
 
    float EndTime;
 
    bool bIsVisible;
 
    bool bValid;
};
 
class FGlobalDistanceFieldCacheTypeState
{
public:
    TArray<FBox> PrimitiveModifiedBounds;
};
 
class FGlobalDistanceFieldClipmapState
{
public:
 
    FGlobalDistanceFieldClipmapState()
    {
        FullUpdateOriginInPages = FInt64Vector::ZeroValue;
        LastPartialUpdateOriginInPages = FInt64Vector::ZeroValue;
        CachedClipmapCenter = FVector3f(0.0f, 0.0f, 0.0f);
        CachedClipmapExtent = 0.0f;
        CacheClipmapInfluenceRadius = 0.0f;
        CacheMostlyStaticSeparately = 1;
        LastUsedSceneDataForFullUpdate = nullptr;
    }
 
    FInt64Vector FullUpdateOriginInPages;
    FInt64Vector LastPartialUpdateOriginInPages;
    uint32 CacheMostlyStaticSeparately;
 
    FVector3f CachedClipmapCenter;
    float CachedClipmapExtent;
    float CacheClipmapInfluenceRadius;
 
    FGlobalDistanceFieldCacheTypeState Cache[GDF_Num];
 
    // Used to perform a full update of the clip map when the scene data changes
    const class FDistanceFieldSceneData* LastUsedSceneDataForFullUpdate;
};
 
typedef TMap<FPrimitiveComponentId, FPrimitiveFadingState> FPrimitiveFadingStateMap;
 
class FOcclusionRandomStream
{
    enum {NumSamples = 3571};
public:
 
    FOcclusionRandomStream()
        : CurrentSample(0)
    {
        FRandomStream RandomStream(0x83246);
        for (int32 Index = 0; Index < NumSamples; Index++)
        {
            Samples[Index] = RandomStream.GetFraction();
        }
        Samples[0] = 0.0f; // we want to make sure we have at least a few zeros
        Samples[NumSamples/3] = 0.0f; // we want to make sure we have at least a few zeros
        Samples[(NumSamples*2)/3] = 0.0f; // we want to make sure we have at least a few zeros
    }
 
    inline float GetFraction()
    {
        uint32 Current = CurrentSample.fetch_add(1);
 
        if (Current >= NumSamples)
        {
            Current++;
            CurrentSample.compare_exchange_strong(Current, 0);
            Current = 0;
            // It is intended here to not check if exchange worked or failed. 
            // It might be overkill to call recursively GetFraction if exchange failed. 
            // Another thread might already have reset CurrentSample and it is acceptable 
            // to have two threads returning the same Fraction at index 0
        }
        float Fraction = Samples[Current];
        return Fraction;
    }
private:
 
    std::atomic<uint32> CurrentSample;
    float Samples[NumSamples];
};
 
extern FOcclusionRandomStream GOcclusionRandomStream;
 
 
class FHLODVisibilityState
{
public:
    FHLODVisibilityState()
        : TemporalLODSyncTime(0.0f)
        , FOVDistanceScaleSq(1.0f)
        , UpdateCount(0)
    {}
 
    bool IsNodeFading(const int32 PrimIndex) const
    {
        checkSlow(IsValidPrimitiveIndex(PrimIndex));
        return PrimitiveFadingLODMap[PrimIndex];
    }
 
    bool IsNodeFadingOut(const int32 PrimIndex) const
    {
        checkSlow(IsValidPrimitiveIndex(PrimIndex));
        return PrimitiveFadingOutLODMap[PrimIndex];
    }
 
    bool IsNodeForcedVisible(const int32 PrimIndex) const
    {
        checkSlow(IsValidPrimitiveIndex(PrimIndex));
        return  ForcedVisiblePrimitiveMap[PrimIndex];
    }
 
    bool IsNodeForcedHidden(const int32 PrimIndex) const
    {
        checkSlow(IsValidPrimitiveIndex(PrimIndex));
        return ForcedHiddenPrimitiveMap[PrimIndex];
    }
 
    bool IsValidPrimitiveIndex(const int32 PrimIndex) const
    {
        return ForcedHiddenPrimitiveMap.IsValidIndex(PrimIndex);
    }
 
    TBitArray<> PrimitiveFadingLODMap;
    TBitArray<> PrimitiveFadingOutLODMap;
    TBitArray<> ForcedVisiblePrimitiveMap;
    TBitArray<> ForcedHiddenPrimitiveMap;
    float       TemporalLODSyncTime;
    float       FOVDistanceScaleSq;
    uint16      UpdateCount;
};
 
struct FHLODSceneNodeVisibilityState
{
    FHLODSceneNodeVisibilityState()
        : UpdateCount(0)
        , bWasVisible(0)
        , bIsVisible(0)
        , bIsFading(0)
    {}
 
    uint16 UpdateCount;
 
    uint16 bWasVisible  : 1;
    uint16 bIsVisible   : 1;
    uint16 bIsFading    : 1;
};
 
struct FShaderPrintStateData
{
    TRefCountPtr<FRDGPooledBuffer> StateBuffer;
    TRefCountPtr<FRDGPooledBuffer> EntryBuffer;
    FVector PreViewTranslation = FVector::ZeroVector;
    bool bIsLocked = false;
 
    void Release()
    {
        bIsLocked = false;
        PreViewTranslation = FVector::ZeroVector;
        StateBuffer = nullptr;
        EntryBuffer = nullptr;
    }
};
 
// Some resources used across frames can prevent execution of PS, CS and VS work across overlapping frames work.
// This struct is used to transparently double buffer the sky aerial perspective volume on some platforms,
// in order to make sure two consecutive frames have no resource dependencies, resulting in no cross frame barrier/sync point.
struct FPersistentSkyAtmosphereData
{
    FPersistentSkyAtmosphereData();
 
    void InitialiseOrNextFrame(ERHIFeatureLevel::Type FeatureLevel, FPooledRenderTargetDesc& AerialPerspectiveDesc, FRHICommandListImmediate& RHICmdList, bool bSeparatedAtmosphereMieRayLeigh);
 
    TRefCountPtr<IPooledRenderTarget> GetCurrentCameraAerialPerspectiveVolume();
    TRefCountPtr<IPooledRenderTarget> GetCurrentCameraAerialPerspectiveVolumeMieOnly();
    TRefCountPtr<IPooledRenderTarget> GetCurrentCameraAerialPerspectiveVolumeRayOnly();
 
    uint64 GetGPUSizeBytes(bool bLogSizes) const;
 
private:
    bool bInitialised;
    int32 CurrentScreenResolution;
    int32 CurrentDepthResolution;
    EPixelFormat CurrentTextureAerialLUTFormat;
    TRefCountPtr<IPooledRenderTarget> CameraAerialPerspectiveVolumes[2];
    TRefCountPtr<IPooledRenderTarget> CameraAerialPerspectiveVolumesMieOnly[2];
    TRefCountPtr<IPooledRenderTarget> CameraAerialPerspectiveVolumesRayOnly[2];
    uint8 CameraAerialPerspectiveVolumeCount;
    uint8 CameraAerialPerspectiveVolumeIndex;
    bool bSeparatedAtmosphereMieRayLeigh;
};
 
struct FGlobalDistanceFieldStreamingReadback
{
    FGlobalDistanceFieldStreamingReadback()
    {
        PendingStreamingReadbackBuffers.SetNum(MaxPendingStreamingReadbackBuffers);
    }
 
    TArray<TUniquePtr<FRHIGPUBufferReadback>> PendingStreamingReadbackBuffers;
    uint32 MaxPendingStreamingReadbackBuffers = 4;
    uint32 ReadbackBuffersWriteIndex = 0;
    uint32 ReadbackBuffersNumPending = 0;
};
 
struct FPersistentGlobalDistanceFieldData : public FThreadSafeRefCountedObject
{
    // Array of ClipmapIndex
    TArray<int32> DeferredUpdates[GDF_Num];
    TArray<int32> DeferredUpdatesForMeshSDFStreaming[GDF_Num];
 
    int32   UpdateFrame = 0;
    bool    bFirstFrame = true;
 
    bool    bInitializedOrigins = false;
    bool    bPendingReset = false;
    FGlobalDistanceFieldClipmapState ClipmapState[GlobalDistanceField::MaxClipmaps];
    int32   UpdateIndex = 0;
    FVector CameraVelocityOffset = FVector(0);
    bool    bUpdateViewOrigin = true;
    FVector LastViewOrigin = FVector(0);
#if WITH_MGPU
    FRHIGPUMask LastGPUMask;
#endif
 
    FGlobalDistanceFieldStreamingReadback StreamingReadback[GDF_Num];
 
    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;
 
    uint64 GetGPUSizeBytes(bool bLogSizes) const;
};
 
class FOcclusionFeedback : public FRenderResource
{
public:
    FOcclusionFeedback();
    ~FOcclusionFeedback();
 
    // FRenderResource interface
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
    virtual void ReleaseRHI() override;
 
    void AddPrimitive(const FPrimitiveOcclusionHistoryKey& PrimitiveKey, const FVector& BoundsOrigin, const FVector& BoundsBoxExtent, FGlobalDynamicVertexBuffer& DynamicVertexBuffer);
 
    void BeginOcclusionScope(FRDGBuilder& GraphBuilder);
    void EndOcclusionScope(FRDGBuilder& GraphBuilder);
 
    void SubmitOcclusionDraws(FRHICommandList& RHICmdList, FViewInfo& View);
 
    void ReadbackResults(FRHICommandListImmediate& RHICmdList);
    void AdvanceFrame(uint32 OcclusionFrameCounter);
 
    inline FRDGBuffer* GetGPUFeedbackBuffer() const
    {
        return GPUFeedbackBuffer;
    }
 
    inline bool IsOccluded(const FPrimitiveOcclusionHistoryKey& PrimitiveKey) const
    {
        return LatestOcclusionResults.Contains(PrimitiveKey);
    }
 
private:
    struct FOcclusionBatch
    {
        FGlobalDynamicVertexBuffer::FAllocation VertexAllocation;
        uint32 NumBatchedPrimitives;
    };
 
    TArray<FOcclusionBatch, TInlineAllocator<3>> BatchOcclusionQueries;
 
    FRDGBuffer* GPUFeedbackBuffer{};
 
    struct FOcclusionBuffer
    {
        TArray<FPrimitiveOcclusionHistoryKey> BatchedPrimitives;
        FRHIGPUBufferReadback* ReadbackBuffer = nullptr;
        uint32 OcclusionFrameCounter = 0u;
    };
 
    FOcclusionBuffer OcclusionBuffers[3];
    uint32 CurrentBufferIndex;
 
    TSet<FPrimitiveOcclusionHistoryKey> LatestOcclusionResults;
    uint32 ResultsOcclusionFrameCounter;
 
    //
    FVertexDeclarationRHIRef OcclusionVertexDeclarationRHI;
};
 
class FSceneViewState : public FSceneViewStateInterface, public FRenderResource
{
public:
 
    class FProjectedShadowKey
    {
    public:
 
        inline bool operator == (const FProjectedShadowKey &Other) const
        {
            return (PrimitiveId == Other.PrimitiveId && Light == Other.Light && ShadowSplitIndex == Other.ShadowSplitIndex && bTranslucentShadow == Other.bTranslucentShadow);
        }
 
        FProjectedShadowKey(const FProjectedShadowInfo& ProjectedShadowInfo);
 
        FProjectedShadowKey(FPrimitiveComponentId InPrimitiveId, const ULightComponent* InLight, int32 InSplitIndex, bool bInTranslucentShadow)
            : PrimitiveId(InPrimitiveId)
            , Light(InLight)
            , ShadowSplitIndex(InSplitIndex)
            , bTranslucentShadow(bInTranslucentShadow)
        {
        }
 
        friend inline uint32 GetTypeHash(const FSceneViewState::FProjectedShadowKey& Key)
        {
            return PointerHash(Key.Light,GetTypeHash(Key.PrimitiveId));
        }
 
    private:
        FPrimitiveComponentId PrimitiveId;
        const ULightComponent* Light;
        int32 ShadowSplitIndex;
        bool bTranslucentShadow;
    };
 
    uint32 UniqueID;
 
    uint32 ShareOriginUniqueID;
 
    FScene* Scene;
 
    typedef TMap<FSceneViewState::FProjectedShadowKey, FRHIPooledRenderQuery> ShadowKeyOcclusionQueryMap;
    TArray<ShadowKeyOcclusionQueryMap, TInlineAllocator<FOcclusionQueryHelpers::MaxBufferedOcclusionFrames> > ShadowOcclusionQueryMaps;
 
    FRenderQueryPoolRHIRef OcclusionQueryPool;
    FFrameBasedOcclusionQueryPool PrimitiveOcclusionQueryPool;
 
    FHZBOcclusionTester HZBOcclusionTests;
    FOcclusionFeedback OcclusionFeedback;
 
    FPersistentSkyAtmosphereData PersistentSkyAtmosphereData;
 
    TArray<uint8> DecompressedVisibilityChunk;
 
    const TArray<uint8>* CachedVisibilityChunk;
    int32 CachedVisibilityHandlerId;
    int32 CachedVisibilityBucketIndex;
    int32 CachedVisibilityChunkIndex;
 
    uint32      PendingPrevFrameNumber;
    uint32      PrevFrameNumber;
    double      LastRenderTime;
    float       MotionBlurTimeScale;
    float       MotionBlurTargetDeltaTime;
    FMatrix44f  PrevViewMatrixForOcclusionQuery;
    FVector     PrevViewOriginForOcclusionQuery;
 
    // A counter incremented once each time this view is rendered.
    uint32 OcclusionFrameCounter;
 
    FPrimitiveFadingStateMap PrimitiveFadingStates;
 
    TMap<int32, FIndividualOcclusionHistory> PlanarReflectionOcclusionHistories;
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    uint32 bIsFreezing : 1;
 
    uint32 bIsFrozen : 1;
 
    uint32 bIsFrozenViewMatricesCached : 1;
 
    TSet<FPrimitiveComponentId> FrozenPrimitives;
 
    FViewMatrices CachedViewMatrices;
#endif
 
    FHLODVisibilityState HLODVisibilityState;
    TMap<FPrimitiveComponentId, FHLODSceneNodeVisibilityState> HLODSceneNodeVisibilityStates;
 
    float PreExposure;
 
    bool bUpdateLastExposure;
 
private:
    
    // to implement eye adaptation / auto exposure changes over time
    class FEyeAdaptationManager
    {
    public:
        FEyeAdaptationManager();
 
        void SafeRelease();
 
        float GetLastExposure() const { return LastExposure; }
 
        float GetLastAverageLocalExposure() const { return LastAverageLocalExposure; }
 
        float GetLastAverageSceneLuminance() const { return LastAverageSceneLuminance; }
 
        const TRefCountPtr<FRDGPooledBuffer>& GetCurrentBuffer() const
        {
            return GetBuffer(CurrentBufferIndex);
        }
 
        const TRefCountPtr<FRDGPooledBuffer>& GetCurrentBuffer(FRDGBuilder& GraphBuilder)
        {
            return GetOrCreateBuffer(GraphBuilder, CurrentBufferIndex);
        }
 
        void SwapBuffers();
        void UpdateLastExposureFromBuffer();
        void EnqueueExposureBufferReadback(FRDGBuilder& GraphBuilder);
 
        uint64 GetGPUSizeBytes(bool bLogSizes) const;
 
    private:
        const TRefCountPtr<IPooledRenderTarget>& GetTexture(uint32 TextureIndex) const;
        const TRefCountPtr<IPooledRenderTarget>& GetOrCreateTexture(FRDGBuilder& GraphBuilder, uint32 TextureIndex);
 
        const TRefCountPtr<FRDGPooledBuffer>& GetBuffer(uint32 BufferIndex) const;
        const TRefCountPtr<FRDGPooledBuffer>& GetOrCreateBuffer(FRDGBuilder& GraphBuilder, uint32 BufferIndex);
 
        FRHIGPUBufferReadback* GetLatestReadbackBuffer();
 
        // TODO: Do we need to double buffer?
        // - for readback we copy data to readback buffers
        // - do we ever need to access prev frame exposure AFTER current frame exposure has been calculated?
        // - should at least make it more explicit/safe by having GetCurrentBuffer() and GetPreviousBuffer()
        //      and assert if current is accessed too early in frame.
        static const int32 NUM_BUFFERS = 2;
 
        static const int32 EXPOSURE_BUFFER_SIZE_IN_VECTOR4 = 2;
 
        int32 CurrentBufferIndex = 0;
 
        float LastExposure = 0;
        float LastAverageLocalExposure = 1.0f;
        float LastAverageSceneLuminance = 0; // 0 means invalid. Used for Exposure Compensation Curve.
 
        UE_DEPRECATED(5.2, "Use ExposureBufferData instead.")
        TRefCountPtr<IPooledRenderTarget> PooledRenderTarget[NUM_BUFFERS];
 
        TRefCountPtr<FRDGPooledBuffer> ExposureBufferData[NUM_BUFFERS];
        TArray<FRHIGPUBufferReadback*> ExposureReadbackBuffers;
 
        static const uint32 MAX_READBACK_BUFFERS = 4;
        uint32 ReadbackBuffersWriteIndex = 0;
        uint32 ReadbackBuffersNumPending = 0;
 
    } EyeAdaptationManager;
 
    struct {
        FTextureRHIRef Texture;
        UCurveFloat* Curve = nullptr;
#if WITH_EDITORONLY_DATA
        UCurveFloat* Curve_GameThread = nullptr;
        FDelegateHandle CurveUpdateDelegateHandle;
        uint32 Version = 0;
#endif
    } ExposureCompensationCurveLUT;
 
    FSubstrateViewDebugData SubstrateViewDebugData;
 
    // The LUT used by tonemapping.  In stereo this is only computed and stored by the Left Eye.
    TRefCountPtr<IPooledRenderTarget> CombinedLUTRenderTarget;
 
    // LUT is only valid after it has been computed, not on allocation of the RT
    bool bValidTonemappingLUT = false;
 
 
    // used by the Postprocess Material Blending system to avoid recreation and garbage collection of MIDs
    TArray<TObjectPtr<UMaterialInstanceDynamic>> MIDPool;
    uint32 MIDUsedCount;
 
    // counts up by one each frame, warped in 0..3 range, ResetViewState() puts it back to 0
    int32 DistanceFieldTemporalSampleIndex;
 
    // whether this view is a stereo counterpart to a primary view
    bool bIsStereoView;
 
    // The whether or not round-robin occlusion querying is enabled for this view
    bool bRoundRobinOcclusionEnabled;
 
public:
    
    // if TemporalAA is on this cycles through 0..TemporalAASampleCount-1, ResetViewState() puts it back to 0
    int32 TemporalAASampleIndex;
 
    // Counts up by one each frame, ResetViewState() puts it back to 0. Should be used as the seed for Halton
    // and other per-render changes. Use OutputFrameIndex as the seed if the effect should be per output frame.
    // Under normal rendering FrameIndex == OutputFrameIndex and there is no distinction between per-render and
    // per-frame, but when accumulating multiple samples then FrameIndex will be unique for each accumulation sample
    // rendered, but OutputFrameIndex will only increment per multi-sample accumulated output frame.
    // 
    // Can be overwritten by OverrideFrameIndexValue.
    uint32 FrameIndex;
 
    // Counts up by one each frame, ResetViewState() puts it back to zero. See FrameIndex for more details. This should
    // equal FrameIndex in normal scenarios, but can differ when accumulating multiple samples to produce one output frame.
    //
    // Can be overwritten by OverrideOutputFrameIndexValue
    uint32 OutputFrameIndex;
    
    FPreviousViewInfo PrevFrameViewInfo;
 
    // Temporal AA result for light shafts of last frame
    FTemporalAAHistory LightShaftOcclusionHistory;
    // Temporal AA result for light shafts of last frame
    TMap<const ULightComponent*, TUniquePtr<FTemporalAAHistory> > LightShaftBloomHistoryRTs;
 
    FIntRect DistanceFieldAOHistoryViewRect;
    TRefCountPtr<IPooledRenderTarget> DistanceFieldAOHistoryRT;
    TRefCountPtr<IPooledRenderTarget> DistanceFieldIrradianceHistoryRT;
 
    // Burley Subsurface scattering variance texture from the last frame.
    TRefCountPtr<IPooledRenderTarget> SubsurfaceScatteringQualityHistoryRT;
 
    FLumenViewState Lumen;
    FMegaLightsViewState MegaLights;
 
    // Shared by Lumen and Mega Lights
    FStochasticLightingViewState StochasticLighting;
 
    FTranslucencyLightingViewState TranslucencyLighting;
 
    // Heterogeneous Volumes cached data stores
    TRDGUniformBufferRef<FOrthoVoxelGridUniformBufferParameters> OrthoVoxelGridUniformBuffer = nullptr;
    TRDGUniformBufferRef<FFrustumVoxelGridUniformBufferParameters> FrustumVoxelGridUniformBuffer = nullptr;
 
    FAdaptiveVolumetricShadowMapUniformBufferParameters* AdaptiveVolumetricCameraMapUniformBufferParameters = nullptr;
    TRDGUniformBufferRef<FAdaptiveVolumetricShadowMapUniformBufferParameters> AdaptiveVolumetricCameraMapUniformBuffer = nullptr;
    TMap<int32, TRDGUniformBufferRef<FAdaptiveVolumetricShadowMapUniformBufferParameters>> AdaptiveVolumetricShadowMapUniformBufferMap;
 
    TMap<int32, TRDGUniformBufferRef<FBeerShadowMapUniformBufferParameters>> BeerShadowMapUniformBufferMap;
 
    // Map from Light ID in GPU Scene to index in the View's ForwardLightData array
    // This is stored in ViewState so we can access previous frame mapping
    TMap<int32, int32> LightSceneIdToForwardLightIndex;
 
    // Similar to LightSceneIdToForwardLightIndex but for simple lights
    TMap<FSimpleLightId, int32> SimpleLightIdToForwardLightIndex;
 
    // Pre-computed filter in spectral (i.e. FFT) domain along with data to determine if we need to up date it
    struct {
        void SafeRelease()
        {
            PhysicalRHI = nullptr;
            Spectral.SafeRelease();
            ConstantsBuffer.SafeRelease();
        }
 
        // The 2d fourier transform of the physical space texture.
        TRefCountPtr<IPooledRenderTarget> Spectral;
        TRefCountPtr<FRDGPooledBuffer> ConstantsBuffer;
 
        // The physical space source texture
        FRHITexture* PhysicalRHI = nullptr;
 
        // The Scale * 100 = percentage of the image space that the physical kernel represents.
        // e.g. Scale = 1 indicates that the physical kernel image occupies the same size 
        // as the image to be processed with the FFT convolution.
        float Scale = 0.f;
 
        // The size of the viewport for which the spectral kernel was calculated. 
        FIntPoint ImageSize;
 
        // Mip level of the physical space source texture used when caching the spectral space texture.
        uint32 PhysicalMipLevel;
    } BloomFFTKernel;
 
    // Film grain
    struct
    {
        void SafeRelease()
        {
            TextureRHI = nullptr;
            ConstantsBuffer.SafeRelease();
        }
        // Cache View.FilmGrainTexture in TextureRHI and compare it every frame in case a new one is set (and rebuild constant buffers if this is the case)
        FRHITexture* TextureRHI = nullptr;
        TRefCountPtr<FRDGPooledBuffer> ConstantsBuffer;
    } FilmGrainCache;
 
    TPimplPtr<DiaphragmDOF::FDOFViewState> DepthOfFieldState;
 
    // Cached material texture samplers
    float MaterialTextureCachedMipBias;
    float LandscapeCachedMipBias;
    FSamplerStateRHIRef MaterialTextureBilinearWrapedSamplerCache;
    FSamplerStateRHIRef MaterialTextureBilinearClampedSamplerCache;
    FSamplerStateRHIRef LandscapeWeightmapSamplerCache;
 
#if RHI_RAYTRACING
    // Invalidates cached results related to the path tracer so accumulated rendering can start over
    void PathTracingInvalidate(bool InvalidateAnimationStates = true);
    virtual uint32 GetPathTracingSampleIndex() const override;
    virtual uint32 GetPathTracingSampleCount() const override;
 
    // Keeps track of the internal path tracer state
    TPimplPtr<FPathTracingState> PathTracingState;
    uint32 PathTracingInvalidationCounter = 0;
 
    // Ray Traced Sky Light Sample Direction Data
    TRefCountPtr<FRDGPooledBuffer> SkyLightVisibilityRaysBuffer;
    FIntVector SkyLightVisibilityRaysDimensions;
 
    // List of landscape ray tracing state associated with this view, so it can be cleaned up if the view gets deleted.
    TPimplPtr<FLandscapeRayTracingStateList> LandscapeRayTracingStates;
 
    virtual void SetLandscapeRayTracingStates(TPimplPtr<FLandscapeRayTracingStateList>&& InLandscapeRayTracingStates) final { LandscapeRayTracingStates = MoveTemp(InLandscapeRayTracingStates); }
    virtual FLandscapeRayTracingStateList* GetLandscapeRayTracingStates() const final { return LandscapeRayTracingStates.Get(); }
#endif // RHI_RAYTRACING
 
    TUniquePtr<FForwardLightingViewResources> ForwardLightingResources;
 
    float LightScatteringHistoryPreExposure;
    FVector2f PrevLightScatteringViewGridUVToViewRectVolumeUV;
    FVector2f VolumetricFogPrevViewGridRectUVToResourceUV;
    FVector2f VolumetricFogPrevUVMax;
    FVector2f VolumetricFogPrevUVMaxForTemporalBlend;
    FIntVector VolumetricFogPrevResourceGridSize;
    TRefCountPtr<IPooledRenderTarget> LightScatteringHistory;
    TRefCountPtr<IPooledRenderTarget> PrevLightScatteringConservativeDepthTexture;
 
    TRefCountPtr<FPersistentGlobalDistanceFieldData> GlobalDistanceFieldData;
 
    // Sequencer state for view management
    ESequencerState SequencerState;
 
    FTemporalLODState TemporalLODState;
 
    FVolumetricRenderTargetViewStateData VolumetricCloudRenderTarget;
    FTemporalRenderTargetState VolumetricCloudShadowRenderTarget[NUM_ATMOSPHERE_LIGHTS];
    FMatrix VolumetricCloudShadowmapPreviousTranslatedWorldToLightClipMatrix[NUM_ATMOSPHERE_LIGHTS];
    FVector VolumetricCloudShadowmapPreviousAtmosphericLightPos[NUM_ATMOSPHERE_LIGHTS];
    FVector VolumetricCloudShadowmapPreviousAnchorPoint[NUM_ATMOSPHERE_LIGHTS];
    FVector VolumetricCloudShadowmapPreviousAtmosphericLightDir[NUM_ATMOSPHERE_LIGHTS];
 
    virtual FRDGTextureRef GetVolumetricCloudTexture(FRDGBuilder& GraphBuilder) override
    {
        return VolumetricCloudRenderTarget.GetDstVolumetricReconstructRT(GraphBuilder);
    }
 
    virtual FVector2f GetVolumetricCloudTextureUVScale() const override
    {
        return VolumetricCloudRenderTarget.GetDstVolumetricReconstructUVScale();
    }
 
    virtual FVector2f GetVolumetricCloudTextureUVMax() const override
    {
        return VolumetricCloudRenderTarget.GetDstVolumetricReconstructUVMax();
    }
 
    FHairStrandsViewStateData HairStrandsViewStateData;
 
    FShaderPrintStateData ShaderPrintStateData;
 
    FGlintShadingLUTsStateData GlintShadingLUTsData;
 
    bool bLumenSceneDataAdded;
    float LumenSurfaceCacheResolution;
 
    // call after OnFrameRenderingSetup()
    virtual uint32 GetCurrentTemporalAASampleIndex() const
    {
        return TemporalAASampleIndex;
    }
 
    // Returns the index of the frame with a desired power of two modulus.
    inline uint32 GetFrameIndex(uint32 Pow2Modulus) const
    {
        check(FMath::IsPowerOfTwo(Pow2Modulus));
        return FrameIndex & (Pow2Modulus - 1);
    }
 
    // Returns 32bits frame index.
    inline uint32 GetFrameIndex() const
    {
        return FrameIndex;
    }
 
    // Returns the index of the output frame with a desired power of two modulus.
    inline uint32 GetOutputFrameIndex(uint32 Pow2Modulus) const
    {
        check(FMath::IsPowerOfTwo(Pow2Modulus));
        return OutputFrameIndex & (Pow2Modulus - 1);
    }
 
    // Returns 32bits output frame index. Matches GetFrameIndex unless using multi-sample accumulation.
    inline uint32 GetOutputFrameIndex() const
    {
        return OutputFrameIndex;
    }
 
    // to make rendering more deterministic
    virtual void ResetViewState()
    {
        TemporalAASampleIndex = 0;
        FrameIndex = 0;
        OutputFrameIndex = 0;
        DistanceFieldTemporalSampleIndex = 0;
        PreExposure = 1.f;
 
        ReleaseRHI();
    }
 
    void SetupDistanceFieldTemporalOffset(const FSceneViewFamily& Family)
    {
        if (!Family.bWorldIsPaused)
        {
            DistanceFieldTemporalSampleIndex++;
        }
 
        if(DistanceFieldTemporalSampleIndex >= 4)
        {
            DistanceFieldTemporalSampleIndex = 0;
        }
    }
 
    uint32 GetDistanceFieldTemporalSampleIndex() const
    {
        return DistanceFieldTemporalSampleIndex;
    }
 
    FSceneViewState(ERHIFeatureLevel::Type FeatureLevel, FSceneViewState* ShareOriginTarget);
 
private:
    // May only be called via Destroy (ensuring it happens on the RT)
    virtual ~FSceneViewState();
 
public:
    // called every frame after the view state was updated
    void UpdateLastRenderTime(const FSceneViewFamily& Family)
    {
        LastRenderTime = Family.Time.GetRealTimeSeconds();
    }
 
    // InScene is passed in, as the Scene pointer in the class itself may be null, if it was allocated without a scene.
    void TrimHistoryRenderTargets(const FScene* InScene);
 
    void UpdateMotionBlurTimeScale(const FViewInfo& View);
 
    void UpdateTemporalLODTransition(const FViewInfo& View)
    {
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
        if (bIsFrozen)
        {
            return;
        }
#endif
 
        TemporalLODState.UpdateTemporalLODTransition(View, LastRenderTime);
    }
 
    const uint8* ResolvePrecomputedVisibilityData(FViewInfo& View, const FScene* InScene);
 
    void TrimOcclusionHistory(float CurrentTime, float MinHistoryTime, float MinQueryTime, int32 FrameNumber);
 
    inline void UpdateRoundRobin(const bool bUseRoundRobin)
    {
        bRoundRobinOcclusionEnabled = bUseRoundRobin;
    }
 
    inline bool IsRoundRobinEnabled() const
    {
        return bRoundRobinOcclusionEnabled;
    }
 
    bool IsShadowOccluded(FSceneViewState::FProjectedShadowKey ShadowKey, int32 NumBufferedFrames) const;
 
    FRDGPooledBuffer* GetCurrentEyeAdaptationBuffer() const override final
    {
        FRDGPooledBuffer* Buffer = EyeAdaptationManager.GetCurrentBuffer().GetReference();
        check(bValidEyeAdaptationBuffer && Buffer);
        return Buffer;
    }
 
    FRDGPooledBuffer* GetCurrentEyeAdaptationBuffer(FRDGBuilder& GraphBuilder)
    {
        bValidEyeAdaptationBuffer = true;
        return EyeAdaptationManager.GetCurrentBuffer(GraphBuilder).GetReference();
    }
 
    void SwapEyeAdaptationBuffers()
    {
        EyeAdaptationManager.SwapBuffers();
    }
 
    void UpdateEyeAdaptationLastExposureFromBuffer()
    {
        if (bUpdateLastExposure && bValidEyeAdaptationBuffer)
        {
            EyeAdaptationManager.UpdateLastExposureFromBuffer();
        }
    }
 
    void EnqueueEyeAdaptationExposureBufferReadback(FRDGBuilder& GraphBuilder)
    {
        if (bUpdateLastExposure && bValidEyeAdaptationBuffer)
        {
            EyeAdaptationManager.EnqueueExposureBufferReadback(GraphBuilder);
        }
    }
 
    float GetLastEyeAdaptationExposure() const
    {
        return EyeAdaptationManager.GetLastExposure();
    }
 
    float GetLastAverageLocalExposure() const
    {
        return EyeAdaptationManager.GetLastAverageLocalExposure();
    }
 
    float GetLastAverageSceneLuminance() const
    {
        return EyeAdaptationManager.GetLastAverageSceneLuminance();
    }
 
    FRHITexture* GetExposureCompensationCurveLUT() const
    {
        return ExposureCompensationCurveLUT.Texture;
    }
 
    virtual void SetExposureCompensationCurve(UCurveFloat* NewCurve) override;
 
    void UpdateExposureCompensationCurveLUT(FRHICommandList& RHICmdList, UCurveFloat* Curve);
 
    bool HasValidTonemappingLUT() const
    {
        return bValidTonemappingLUT;
    }
 
    void SetValidTonemappingLUT(bool bValid = true)
    {
        bValidTonemappingLUT = bValid;
    }
 
    static FPooledRenderTargetDesc CreateLUTRenderTarget(const int32 LUTSize, const bool bUseVolumeLUT, const bool bNeedUAV, const bool bNeedFloatOutput)
    {
        // Create the texture needed for the tonemapping LUT in one place
        EPixelFormat LUTPixelFormat = PF_A2B10G10R10;
        if (!GPixelFormats[LUTPixelFormat].Supported)
        {
            LUTPixelFormat = PF_R8G8B8A8;
        }
        if (bNeedFloatOutput)
        {
            LUTPixelFormat = PF_FloatRGBA;
        }
 
        FPooledRenderTargetDesc Desc = FPooledRenderTargetDesc::Create2DDesc(FIntPoint(LUTSize * LUTSize, LUTSize), LUTPixelFormat, FClearValueBinding::Transparent, TexCreate_None, TexCreate_ShaderResource, false);
        Desc.Flags |= bNeedUAV ? TexCreate_UAV : TexCreate_RenderTargetable;
 
        if (bUseVolumeLUT)
        {
            Desc.Extent = FIntPoint(LUTSize, LUTSize);
            Desc.Depth = LUTSize;
        }
 
        Desc.DebugName = TEXT("CombineLUTs");
        Desc.Flags |= GFastVRamConfig.CombineLUTs;
 
        return Desc;
    }
 
    // Returns a reference to the render target used for the LUT.  Allocated on the first request.
    IPooledRenderTarget* GetTonemappingLUT(FRHICommandList& RHICmdList, const int32 LUTSize, const bool bUseVolumeLUT, const bool bNeedUAV, const bool bNeedFloatOutput)
    {
        if (CombinedLUTRenderTarget.IsValid() == false || 
            CombinedLUTRenderTarget->GetDesc().Extent.Y != LUTSize ||
            ((CombinedLUTRenderTarget->GetDesc().Depth != 0) != bUseVolumeLUT) ||
            !!(CombinedLUTRenderTarget->GetDesc().Flags & TexCreate_UAV) != bNeedUAV ||
            (CombinedLUTRenderTarget->GetDesc().Format == PF_FloatRGBA) != bNeedFloatOutput)
        {
            // Create the texture needed for the tonemapping LUT
            FPooledRenderTargetDesc Desc = CreateLUTRenderTarget(LUTSize, bUseVolumeLUT, bNeedUAV, bNeedFloatOutput);
 
            GRenderTargetPool.FindFreeElement(RHICmdList, Desc, CombinedLUTRenderTarget, Desc.DebugName);
        }
 
        return CombinedLUTRenderTarget.GetReference();
    }
 
    IPooledRenderTarget* GetTonemappingLUT() const
    {
        return CombinedLUTRenderTarget.GetReference();
    }
 
    FSubstrateViewDebugData& GetSubstrateViewDebugData()
    {
        return SubstrateViewDebugData;
    }
 
    // FRenderResource interface.
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override
    {
        HZBOcclusionTests.InitRHI(RHICmdList);
    }
 
    virtual void ReleaseRHI() override;
 
    // FSceneViewStateInterface
    RENDERER_API virtual void Destroy() override;
 
    virtual FSceneViewState* GetConcreteViewState() override
    {
        return this;
    }
 
    virtual void AddReferencedObjects(FReferenceCollector& Collector) override
    {
        Collector.AddReferencedObjects(MIDPool);
    }
 
    // needed for GetReusableMID()
    virtual void OnStartPostProcessing(FSceneView& CurrentView) override
    {
        check(IsInGameThread());
 
        // Needs to be done once for all viewstates.  If multiple FSceneViews are sharing the same ViewState, this will cause problems.
        // Sharing should be illegal right now though.
        MIDUsedCount = 0;
    }
 
    virtual float GetPreExposure() const override
    {
        return PreExposure;
    }
 
    // Note: OnStartPostProcessing() needs to be called each frame for each view
    virtual UMaterialInstanceDynamic* GetReusableMID(class UMaterialInterface* InSource) override
    {       
        check(IsInGameThread());
        check(InSource);
 
        // 0 or MID (MaterialInstanceDynamic) pointer
        auto InputAsMID = Cast<UMaterialInstanceDynamic>(InSource);
 
        // fixup MID parents as this is not allowed, take the next MIC or Material.
        UMaterialInterface* ParentOfTheNewMID = InputAsMID ? ToRawPtr(InputAsMID->Parent) : InSource;
 
        // this is not allowed and would cause an error later in the code
        check(!ParentOfTheNewMID->IsA(UMaterialInstanceDynamic::StaticClass()));
 
        UMaterialInstanceDynamic* NewMID = 0;
 
        if(MIDUsedCount < (uint32)MIDPool.Num())
        {
            NewMID = MIDPool[MIDUsedCount];
 
            if(NewMID->Parent != ParentOfTheNewMID)
            {
                // create a new one
                // garbage collector will remove the old one
                // this should not happen too often
                NewMID = UMaterialInstanceDynamic::Create(ParentOfTheNewMID, 0);
                MIDPool[MIDUsedCount] = NewMID;
            }
 
            // reusing an existing object means we need to clear out the Vector and Scalar parameters
            NewMID->ClearParameterValues();
        }
        else
        {
            NewMID = UMaterialInstanceDynamic::Create(ParentOfTheNewMID, 0);
            check(NewMID);
 
            MIDPool.Add(NewMID);
        }
 
        if(InputAsMID)
        {
            // parent is an MID so we need to copy the MID Vector and Scalar parameters over
            NewMID->CopyInterpParameters(InputAsMID);
        }
 
        check(!FApp::CanEverRender() || NewMID->GetRenderProxy());
        MIDUsedCount++;
        return NewMID;
    }
 
    virtual void ClearMIDPool(FStringView MidParentRootPath = {}) override
    {
        check(IsInGameThread());
        if (MidParentRootPath.IsEmpty())
        {
            MIDPool.Empty();
            return;
        }
 
        FNameBuilder PackagePath;
        const int32 RemoveNum = Algo::RemoveIf(MIDPool, [&PackagePath, MidParentRootPath](UMaterialInstanceDynamic* MID) -> bool
        {
            if (MID->Parent)
            {
                MID->Parent->GetPackage()->GetFName().ToString(PackagePath);
                return FStringView(PackagePath).StartsWith(MidParentRootPath);
            }
            return false;
        });
 
        MIDPool.SetNum(RemoveNum);
    }
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    virtual const FViewMatrices* GetFrozenViewMatrices() const override
    {
        if (bIsFrozen && bIsFrozenViewMatricesCached)
        {
            return &CachedViewMatrices;
        }
        return nullptr;
    }
 
    virtual void ActivateFrozenViewMatrices(FSceneView& SceneView) override
    {
        auto* ViewState = static_cast<FSceneViewState*>(SceneView.State);
        if (ViewState->bIsFrozen)
        {
            check(ViewState->bIsFrozenViewMatricesCached);
 
            Swap(SceneView.ViewMatrices, ViewState->CachedViewMatrices);
            ViewState->bIsFrozenViewMatricesCached = false;
        }
    }
 
    virtual void RestoreUnfrozenViewMatrices(FSceneView& SceneView) override
    {
        auto* ViewState = static_cast<FSceneViewState*>(SceneView.State);
        if (ViewState->bIsFrozen)
        {
            check(!ViewState->bIsFrozenViewMatricesCached);
 
            Swap(SceneView.ViewMatrices, ViewState->CachedViewMatrices);
            ViewState->bIsFrozenViewMatricesCached = true;
        }
    }
#endif
 
    virtual FTemporalLODState& GetTemporalLODState() override
    {
        return TemporalLODState;
    }
 
    virtual const FTemporalLODState& GetTemporalLODState() const override
    {
        return TemporalLODState;
    }
 
    float GetTemporalLODTransition() const override
    {
        return TemporalLODState.GetTemporalLODTransition(LastRenderTime);
    }
 
    uint32 GetViewKey() const override
    {
        return UniqueID;
    }
 
    uint32 GetShareOriginViewKey() const
    {
        return ShareOriginUniqueID;
    }
 
    uint32 GetOcclusionFrameCounter() const
    {
        return OcclusionFrameCounter;
    }
 
    virtual SIZE_T GetSizeBytes() const override;
    uint64 GetGPUSizeBytes(bool bLogSizes = false) const;
 
    virtual void SetSequencerState(ESequencerState InSequencerState) override
    {
        SequencerState = InSequencerState;
    }
 
    virtual ESequencerState GetSequencerState() override
    {
        return SequencerState;
    }
 
    virtual void AddLumenSceneData(FSceneInterface* InScene, float SurfaceCacheResolution) override;
    virtual void RemoveLumenSceneData(FSceneInterface* InScene) override;
    virtual bool HasLumenSceneData() const override;
 
    struct FOcclusion
    {
        TSet<FPrimitiveOcclusionHistory, FPrimitiveOcclusionHistoryKeyFuncs> PrimitiveOcclusionHistorySet;
 
        TArray<FRHIRenderQuery*, TInlineAllocator<FOcclusionQueryHelpers::MaxBufferedOcclusionFrames> > LastOcclusionQueryArray;
 
        uint32 NumRequestedQueries = 0;
    
    } Occlusion;
 
    virtual void SystemMemoryMirrorBackup(FSceneViewStateSystemMemoryMirror* SystemMemoryMirror) override final;
    virtual void SystemMemoryMirrorRestore(FSceneViewStateSystemMemoryMirror* SystemMemoryMirror) override final;
};
 
class FReflectionEnvironmentCubemapArray : public FRenderResource
{
public:
 
    FReflectionEnvironmentCubemapArray(ERHIFeatureLevel::Type InFeatureLevel)
        : FRenderResource(InFeatureLevel)
        , MaxCubemaps(0)
        , CubemapSize(0)
    {}
 
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
    virtual void ReleaseRHI() override;
 
    void UpdateMaxCubemaps(uint32 InMaxCubemaps, int32 CubemapSize);
 
    void ResizeCubemapArrayGPU(uint32 InMaxCubemaps, int32 CubemapSize, const TArray<int32>& IndexRemapping);
 
    int32 GetMaxCubemaps() const { return MaxCubemaps; }
    int32 GetCubemapSize() const { return CubemapSize; }
    bool IsValid() const { return IsValidRef(ReflectionEnvs); }
    const TRefCountPtr<IPooledRenderTarget>& GetRenderTarget() const { return ReflectionEnvs; }
    void Reset();
 
protected:
    uint32 MaxCubemaps;
    int32 CubemapSize;
    TRefCountPtr<IPooledRenderTarget> ReflectionEnvs;
 
    void ReleaseCubeArray();
};
 
class FCaptureComponentSceneState
{
public:
    int32 CubemapIndex;
 
    float AverageBrightness;
 
    FCaptureComponentSceneState(int32 InCubemapIndex) :
        CubemapIndex(InCubemapIndex),
        AverageBrightness(0.0f)
    {}
 
    bool operator==(const FCaptureComponentSceneState& Other) const 
    {
        return CubemapIndex == Other.CubemapIndex;
    }
};
 
struct FReflectionCaptureSortData
{
    FDFVector3 Position;
    FMatrix44f BoxTransform;
    uint32 Guid;
    int32 CubemapIndex;
    float Radius;
    FVector4f CaptureProperties;
    FVector4f BoxScales;
    FVector4f CaptureOffsetAndAverageBrightness;
    FReflectionCaptureProxy* CaptureProxy;
 
    bool operator < (const FReflectionCaptureSortData& Other) const
    {
        if (Radius != Other.Radius)
        {
            return Radius < Other.Radius;
        }
        else
        {
            return Guid < Other.Guid;
        }
    }
};
 
 
struct FReflectionCaptureCacheEntry
{
    int32 RefCount;
    FCaptureComponentSceneState SceneState;
};
 
 
struct FReflectionCaptureCache
{
public:
 
    const FCaptureComponentSceneState* Find(const FGuid& MapBuildDataId) const;
    FCaptureComponentSceneState* Find(const FGuid& MapBuildDataId);
 
    const FCaptureComponentSceneState* Find(const UReflectionCaptureComponent* Component) const;
    FCaptureComponentSceneState* Find(const UReflectionCaptureComponent* Component);
    const FCaptureComponentSceneState& FindChecked(const UReflectionCaptureComponent* Component) const;
    FCaptureComponentSceneState& FindChecked(const UReflectionCaptureComponent* Component);
 
    FCaptureComponentSceneState& Add(const UReflectionCaptureComponent* Component, const FCaptureComponentSceneState& Value);
    FCaptureComponentSceneState* AddReference(const UReflectionCaptureComponent* Component);
    bool Remove(const UReflectionCaptureComponent* Component);
    int32 Prune(const TSet<FGuid> KeysToKeep, TArray<int32>& ReleasedIndices);
 
    int32 GetKeys(TArray<FGuid>& OutKeys) const;
    int32 GetKeys(TSet<FGuid>& OutKeys) const;
 
    void Empty();
 
protected:
 
    bool RemapRegisteredComponentMapBuildDataId(const UReflectionCaptureComponent* Component);
    void RegisterComponentMapBuildDataId(const UReflectionCaptureComponent* Component);
    void UnregisterComponentMapBuildDataId(const UReflectionCaptureComponent* Component);
 
    // Different map build data id of a capture might share the same capture component while editing (e.g., when they move).
    // need to replace it with the new one.
    TMap<const UReflectionCaptureComponent*, FGuid> RegisteredComponentMapBuildDataIds;
 
    TMap<FGuid, FReflectionCaptureCacheEntry> CaptureData;
};
 
class FReflectionEnvironmentSceneData
{
public:
 
    bool bRegisteredReflectionCapturesHasChanged;
 
    bool AllocatedReflectionCaptureStateHasChanged;
 
    TArray<FReflectionCaptureProxy*> RegisteredReflectionCaptures;
    TArray<FSphere> RegisteredReflectionCapturePositionAndRadius;
 
    FReflectionEnvironmentCubemapArray CubemapArray;
 
    FReflectionCaptureCache AllocatedReflectionCaptureState;
 
    TBitArray<> CubemapArraySlotsUsed;
 
    TArray<FReflectionCaptureSortData> SortedCaptures;
    int32 NumBoxCaptures;
    int32 NumSphereCaptures;
 
    // Uniforms buffers with a sorted captures
    TUniformBufferRef<FReflectionCaptureShaderData> ReflectionCaptureUniformBuffer;
    TUniformBufferRef<FMobileReflectionCaptureShaderData> MobileReflectionCaptureUniformBuffer;
 
    TSparseArray<UReflectionCaptureComponent*> AllocatedReflectionCapturesGameThread;
 
    int32 MaxAllocatedReflectionCubemapsGameThread;
 
    int32 ReflectionCaptureSizeGameThread;
    int32 DesiredReflectionCaptureSizeGameThread;
 
    FReflectionEnvironmentSceneData(ERHIFeatureLevel::Type InFeatureLevel) :
        bRegisteredReflectionCapturesHasChanged(true),
        AllocatedReflectionCaptureStateHasChanged(false),
        CubemapArray(InFeatureLevel),
        MaxAllocatedReflectionCubemapsGameThread(0),
        ReflectionCaptureSizeGameThread(0),
        DesiredReflectionCaptureSizeGameThread(0)
    {}
 
    void SetGameThreadTrackingData(int32 MaxAllocatedCubemaps, int32 CaptureSize, int32 DesiredCaptureSize);
 
    bool DoesAllocatedDataNeedUpdate(int32 DesiredMaxCubemaps, int32 DesiredCaptureSize) const;
 
    void ResizeCubemapArrayGPU(uint32 InMaxCubemaps, int32 InCubemapSize);
 
    void Reset(FScene* Scene);
};
 
class FHairStrandsSceneData
{
public:
    TArray<FHairStrandsInstance*> RegisteredProxies;
    FHairTransientResources* TransientResources = nullptr;
};
 
class FVolumetricLightmapInterpolation
{
public:
    FVector4f IndirectLightingSHCoefficients0[3];
    FVector4f IndirectLightingSHCoefficients1[3];
    FVector4f IndirectLightingSHCoefficients2;
    FVector4f IndirectLightingSHSingleCoefficient;
    FVector4f PointSkyBentNormal;
    float DirectionalLightShadowing;
    uint32 LastUsedSceneFrameNumber;
};
 
class FVolumetricLightmapSceneData
{
public:
 
    FVolumetricLightmapSceneData(FScene* InScene)
        : Scene(InScene)
    {
        GlobalVolumetricLightmap.Data = &GlobalVolumetricLightmapData;
    }
 
    bool HasData() const;
    void AddLevelVolume(const class FPrecomputedVolumetricLightmap* InVolume, EShadingPath ShadingPath, bool bIsPersistentLevel);
    void RemoveLevelVolume(const class FPrecomputedVolumetricLightmap* InVolume);
    const FPrecomputedVolumetricLightmap* GetLevelVolumetricLightmap() const;
 
    TMap<FVector, FVolumetricLightmapInterpolation> CPUInterpolationCache;
 
    FPrecomputedVolumetricLightmapData GlobalVolumetricLightmapData;
private:
    FScene* Scene;
    FPrecomputedVolumetricLightmap GlobalVolumetricLightmap;
    const FPrecomputedVolumetricLightmap* PersistentLevelVolumetricLightmap = nullptr;
    TArray<const FPrecomputedVolumetricLightmap*> LevelVolumetricLightmaps;
};
 
class FPrimitiveAndInstance
{
public:
    FPrimitiveAndInstance(const FMatrix& InLocalToWorld, const FBox& InWorldBounds, FPrimitiveSceneInfo* InPrimitive, int32 InInstanceIndex)
    : Primitive(InPrimitive)
    , InstanceIndex(InInstanceIndex)
    {
        SetTransformAndBounds(InLocalToWorld, InWorldBounds);
    }
 
    FPrimitiveSceneInfo* Primitive;
 
    FVector Origin;
    FVector3f TransformRows[3];
 
    FRenderBounds WorldBoundsRelativeToOrigin;
 
    int32 InstanceIndex;
 
    FORCEINLINE void SetTransformAndBounds(const FMatrix& InLocalToWorld, const FBox& InWorldBounds)
    {
        TransformRows[0] = FVector3f((float)InLocalToWorld.M[0][0], (float)InLocalToWorld.M[0][1], (float)InLocalToWorld.M[0][2]);
        TransformRows[1] = FVector3f((float)InLocalToWorld.M[1][0], (float)InLocalToWorld.M[1][1], (float)InLocalToWorld.M[1][2]);
        TransformRows[2] = FVector3f((float)InLocalToWorld.M[2][0], (float)InLocalToWorld.M[2][1], (float)InLocalToWorld.M[2][2]);
        Origin = FVector(InLocalToWorld.M[3][0], InLocalToWorld.M[3][1], InLocalToWorld.M[3][2]);
 
        WorldBoundsRelativeToOrigin = InWorldBounds.ShiftBy(-Origin);
    }
 
    FORCEINLINE FMatrix GetLocalToWorld() const
    {
        FMatrix Matrix;
        Matrix.M[0][0] = TransformRows[0].X;
        Matrix.M[0][1] = TransformRows[0].Y;
        Matrix.M[0][2] = TransformRows[0].Z;
        Matrix.M[0][3] = 0.0f;
        Matrix.M[1][0] = TransformRows[1].X;
        Matrix.M[1][1] = TransformRows[1].Y;
        Matrix.M[1][2] = TransformRows[1].Z;
        Matrix.M[1][3] = 0.0f;
        Matrix.M[2][0] = TransformRows[2].X;
        Matrix.M[2][1] = TransformRows[2].Y;
        Matrix.M[2][2] = TransformRows[2].Z;
        Matrix.M[2][3] = 0.0f;
        Matrix.M[3][0] = Origin.X;
        Matrix.M[3][1] = Origin.Y;
        Matrix.M[3][2] = Origin.Z;
        Matrix.M[3][3] = 1.0f;
        return Matrix;
    }
 
    FORCEINLINE FBox GetWorldBounds() const
    {
        FBox WorldBoundsRelativeToOriginDoublePrecision = WorldBoundsRelativeToOrigin.ToBox();
        return WorldBoundsRelativeToOriginDoublePrecision.ShiftBy(Origin);
    }
};
 
class FPrimitiveRemoveInfo
{
public:
    FPrimitiveRemoveInfo(const FPrimitiveSceneInfo* InPrimitive)
    : Primitive(InPrimitive)
    , bOftenMoving(InPrimitive->Proxy->IsOftenMoving())
    , DistanceFieldInstanceIndices(Primitive->DistanceFieldInstanceIndices)
    {
        float SelfShadowBias;
        InPrimitive->Proxy->GetDistanceFieldAtlasData(DistanceFieldData, SelfShadowBias);
    }
 
    const FPrimitiveSceneInfo* Primitive;
 
    bool bOftenMoving;
 
    TArray<int32, TInlineAllocator<1>> DistanceFieldInstanceIndices;
 
    const FDistanceFieldVolumeData* DistanceFieldData;
};
 
class FHeightFieldPrimitiveRemoveInfo : public FPrimitiveRemoveInfo
{
public:
    FHeightFieldPrimitiveRemoveInfo(const FPrimitiveSceneInfo* InPrimitive)
        : FPrimitiveRemoveInfo(InPrimitive)
    {
        const FBoxSphereBounds Bounds = InPrimitive->Proxy->GetBounds();
        WorldBounds = Bounds.GetBox();
    }
 
    FBox WorldBounds;
};
 
class FDistanceFieldAssetMipId
{
public:
 
    FDistanceFieldAssetMipId(FSetElementId InAssetId, int32 InReversedMipIndex = 0) :
        AssetId(InAssetId),
        ReversedMipIndex(InReversedMipIndex)
    {}
 
    FSetElementId AssetId;
    int32 ReversedMipIndex;
};
 
class FDistanceFieldAssetMipRelocation
{
public:
    FDistanceFieldAssetMipRelocation(FIntVector InIndirectionDimensions, FIntVector InSrcPosition, FIntVector InDstPosition) :
        IndirectionDimensions(InIndirectionDimensions),
        SrcPosition(InSrcPosition),
        DstPosition(InDstPosition)
    {}
 
    FIntVector IndirectionDimensions;
    FIntVector SrcPosition;
    FIntVector DstPosition;
};
 
class FDistanceFieldAssetMipState
{
public:
 
    FDistanceFieldAssetMipState() :
        IndirectionDimensions(FIntVector(0, 0, 0)),
        IndirectionTableOffset(-1),
        NumBricks(0)
    {}
 
    FIntVector IndirectionDimensions;
    int32 IndirectionTableOffset;
    FIntVector IndirectionAtlasOffset;
    int32 NumBricks;
    TArray<int32, TInlineAllocator<4>> AllocatedBlocks;
};
 
class FDistanceFieldAssetState
{
public:
 
    FDistanceFieldAssetState() :
        BuiltData(nullptr),
        RefCount(0),
        WantedNumMips(0)
    {}
 
    const FDistanceFieldVolumeData* BuiltData;
    int32 RefCount;
    int32 WantedNumMips;
    TArray<FDistanceFieldAssetMipState, TInlineAllocator<3>> ReversedMips;
};
 
struct TFDistanceFieldAssetStateFuncs : BaseKeyFuncs<FDistanceFieldAssetState, const FDistanceFieldVolumeData*, /* bInAllowDuplicateKeys = */ false>
{
    static FORCEINLINE KeyInitType GetSetKey(ElementInitType Element)
    {
        return Element.BuiltData;
    }
    static bool Matches(KeyInitType A,KeyInitType B)
    {
        return A == B;
    }
    static FORCEINLINE uint32 GetKeyHash(KeyInitType Key)
    {
        return PointerHash(Key);
    }
};
 
class FDistanceFieldBlockAllocator
{
public:
    void Allocate(int32 NumBlocks, TArray<int32, TInlineAllocator<4>>& OutBlocks);
 
    void Free(const TArray<int32, TInlineAllocator<4>>& ElementRange);
 
    int32 GetMaxSize() const 
    { 
        return MaxNumBlocks; 
    }
 
    int32 GetAllocatedSize() const
    {
        return MaxNumBlocks - FreeBlocks.Num();
    }
 
private:
    int32 MaxNumBlocks = 0;
    TArray<int32, TInlineAllocator<4>> FreeBlocks;
};
 
struct FDistanceFieldReadRequest;
struct FDistanceFieldAsyncUpdateParameters;
 
class FDistanceFieldSceneData
{
public:
    FDistanceFieldSceneData(FDistanceFieldSceneData&&);
    FDistanceFieldSceneData(EShaderPlatform ShaderPlatform);
    ~FDistanceFieldSceneData();
 
    void AddPrimitive(FPrimitiveSceneInfo* InPrimitive);
    void UpdatePrimitive(FPrimitiveSceneInfo* InPrimitive);
    void RemovePrimitive(FPrimitiveSceneInfo* InPrimitive);
    void Release();
    void VerifyIntegrity();
    void ListMeshDistanceFields(bool bDumpAssetStats) const;
 
    void UpdateDistanceFieldObjectBuffers(
        FRDGBuilder& GraphBuilder,
        FRDGExternalAccessQueue& ExternalAccessQueue,
        FScene* Scene,
        TArray<FDistanceFieldAssetMipId>& DistanceFieldAssetAdds,
        TArray<FSetElementId>& DistanceFieldAssetRemoves);
 
    void UpdateDistanceFieldAtlas(
        FRDGBuilder& GraphBuilder,
        FRDGExternalAccessQueue& ExternalAccessQueue,
        const FSceneRenderUpdateInputs& SceneUpdateInputs,
        TArray<FDistanceFieldAssetMipId>& DistanceFieldAssetAdds,
        TArray<FSetElementId>& DistanceFieldAssetRemoves);
 
    bool HasPendingUploads() const
    {
        return IndicesToUpdateInObjectBuffers.Num() > 0;
    }
 
    bool HasPendingOperations() const
    {
        return PendingAddOperations.Num() > 0 || PendingUpdateOperations.Num() > 0 || PendingRemoveOperations.Num() > 0;
    }
 
    bool HasPendingHeightFieldOperations() const
    {
        return PendingHeightFieldAddOps.Num() > 0 || PendingHeightFieldRemoveOps.Num() > 0;
    }
 
    bool HasPendingRemovePrimitive(const FPrimitiveSceneInfo* Primitive) const
    {
        for (int32 RemoveIndex = 0; RemoveIndex < PendingRemoveOperations.Num(); ++RemoveIndex)
        {
            if (PendingRemoveOperations[RemoveIndex].Primitive == Primitive)
            {
                return true;
            }
        }
 
        return false;
    }
 
    bool HasPendingStreaming() const
    {
        return ReadRequests.Num() > 0;
    }
 
    inline bool CanUse16BitObjectIndices() const
    {
        return bCanUse16BitObjectIndices && (NumObjectsInBuffer < (1 << 16));
    }
 
    const FDistanceFieldObjectBuffers* GetCurrentObjectBuffers() const
    {
        return ObjectBuffers;
    }
 
    const FDistanceFieldObjectBuffers* GetHeightFieldObjectBuffers() const
    {
        return HeightFieldObjectBuffers;
    }
 
    int32 NumObjectsInBuffer;
    FDistanceFieldObjectBuffers* ObjectBuffers;
    FDistanceFieldObjectBuffers* HeightFieldObjectBuffers;
 
    FRDGScatterUploadBuffer UploadHeightFieldDataBuffer;
    FRDGScatterUploadBuffer UploadHeightFieldBoundsBuffer;
    FRDGScatterUploadBuffer UploadDistanceFieldDataBuffer;
    FRDGScatterUploadBuffer UploadDistanceFieldBoundsBuffer;
 
    // track indices that need to be updated using both an array and a set
    // array is used for fast iteration and support ParallelFor
    // set is used to prevent duplicate indices
    TArray<int32> IndicesToUpdateInObjectBuffers;
    TSet<int32> IndicesToUpdateInObjectBuffersSet;
 
    TSparseSet<FDistanceFieldAssetState, TFDistanceFieldAssetStateFuncs> AssetStateArray;
    TRefCountPtr<FRDGPooledBuffer> AssetDataBuffer;
    FRDGScatterUploadBuffer AssetDataUploadBuffer;
 
    TArray<FRHIGPUBufferReadback*> StreamingRequestReadbackBuffers;
    uint32 MaxStreamingReadbackBuffers = 4;
    uint32 ReadbackBuffersWriteIndex = 0;
    uint32 ReadbackBuffersNumPending = 0;
 
    FGrowOnlySpanAllocator IndirectionTableAllocator;
    TRefCountPtr<FRDGPooledBuffer> IndirectionTable;
    FRDGAsyncScatterUploadBuffer IndirectionTableUploadBuffer;
 
    TRefCountPtr<IPooledRenderTarget> IndirectionAtlas;
    FTextureLayout3d IndirectionAtlasLayout;
    FReadBuffer IndirectionUploadIndicesBuffer;
    FReadBuffer IndirectionUploadDataBuffer;
 
    FDistanceFieldBlockAllocator DistanceFieldAtlasBlockAllocator;
    TRefCountPtr<IPooledRenderTarget> DistanceFieldBrickVolumeTexture;
    FIntVector BrickTextureDimensionsInBricks;
    FReadBuffer BrickUploadCoordinatesBuffer;
    FReadBuffer BrickUploadDataBuffer;
 
    TArray<FDistanceFieldReadRequest> ReadRequests;
 
    TArray<FPrimitiveAndInstance> PrimitiveInstanceMapping;
    TArray<FPrimitiveSceneInfo*> HeightfieldPrimitives;
    TSet<FPrimitiveSceneInfo*> PendingAddOperations;
    TSet<FPrimitiveSceneInfo*> PendingUpdateOperations;
    TArray<FPrimitiveRemoveInfo> PendingRemoveOperations;
    TArray<FBox> PrimitiveModifiedBounds[GDF_Num];
 
    TSet<FPrimitiveSceneInfo*> PendingHeightFieldAddOps;
    TArray<FHeightFieldPrimitiveRemoveInfo> PendingHeightFieldRemoveOps;
 
    int32 HeightFieldAtlasGeneration;
    int32 HFVisibilityAtlasGenerattion;
 
    bool bTrackAllPrimitives;
    bool bCanUse16BitObjectIndices;
 
private:
 
    void ProcessStreamingRequestsFromGPU(
        TArray<FDistanceFieldReadRequest>& NewReadRequests,
        TArray<FDistanceFieldAssetMipId>& AssetDataUploads);
 
    void ProcessReadRequests(
        TArray<FDistanceFieldAssetMipId>& AssetDataUploads,
        TArray<FDistanceFieldAssetMipId>& DistanceFieldAssetMipAdds,
        TArray<FDistanceFieldReadRequest>& ReadRequestsToUpload,
        TArray<FDistanceFieldReadRequest>& ReadRequestsToCleanUp);
 
    FRDGTexture* ResizeBrickAtlasIfNeeded(FRDGBuilder& GraphBuilder, FGlobalShaderMap* GlobalShaderMap);
 
    bool ResizeIndirectionAtlasIfNeeded(FRDGBuilder& GraphBuilder, FGlobalShaderMap* GlobalShaderMap, FRDGTexture*& OutTexture);
 
    void DefragmentIndirectionAtlas(FIntVector MinSize, TArray<FDistanceFieldAssetMipRelocation>& Relocations);
 
    void UploadAssetData(FRDGBuilder& GraphBuilder, const TArray<FDistanceFieldAssetMipId>& AssetDataUploads, FRDGBuffer* AssetDataBufferRDG);
    
    void UploadAllAssetData(FRDGBuilder& GraphBuilder, FRDGBuffer* AssetDataBufferRDG);
 
    void AsyncUpdate(FRHICommandListBase& RHICmdList, FDistanceFieldAsyncUpdateParameters& UpdateParameters);
 
    void GenerateStreamingRequests(FRDGBuilder& GraphBuilder, const FSceneRenderUpdateInputs& SceneUpdateInputs);
 
    friend class FDistanceFieldStreamingUpdateTask;
};
 
extern void PrepareDistanceFieldScene(FRDGBuilder& GraphBuilder, FRDGExternalAccessQueue& ExternalAccessQueue, const FSceneRenderUpdateInputs& SceneUpdateInputs);
 
class FIndirectLightingCacheBlock
{
public:
 
    FIndirectLightingCacheBlock() :
        MinTexel(FIntVector(0, 0, 0)),
        TexelSize(0),
        Min(FVector(0, 0, 0)),
        Size(FVector(0, 0, 0)),
        bHasEverBeenUpdated(false)
    {}
 
    FIntVector MinTexel;
    int32 TexelSize;
    FVector Min;
    FVector Size;
    bool bHasEverBeenUpdated;
};
 
class FBlockUpdateInfo
{
public:
 
    FBlockUpdateInfo(const FIndirectLightingCacheBlock& InBlock, FIndirectLightingCacheAllocation* InAllocation) :
        Block(InBlock),
        Allocation(InAllocation)
    {}
 
    FIndirectLightingCacheBlock Block;
    FIndirectLightingCacheAllocation* Allocation;
};
 
class FAttachmentGroupSceneInfo
{
public:
 
    FPrimitiveSceneInfo* ParentSceneInfo;
 
    TArray<FPrimitiveSceneInfo*> Primitives;
 
    FAttachmentGroupSceneInfo() :
        ParentSceneInfo(nullptr)
    {}
};
 
struct FILCUpdatePrimTaskData
{
    FGraphEventRef TaskRef;
    TMap<FIntVector, FBlockUpdateInfo> OutBlocksToUpdate;
    TArray<FIndirectLightingCacheAllocation*> OutTransitionsOverTimeToUpdate;
    TArray<FPrimitiveSceneInfo*> OutPrimitivesToUpdateStaticMeshes;
};
 
class FIndirectLightingCache : public FRenderResource
{
public: 
 
    FIndirectLightingCache(ERHIFeatureLevel::Type InFeatureLevel);
 
    // FRenderResource interface
    virtual void InitRHI(FRHICommandListBase& RHICmdList);
    virtual void ReleaseRHI();
 
    FIndirectLightingCacheAllocation* AllocatePrimitive(const FPrimitiveSceneInfo* PrimitiveSceneInfo, bool bUnbuiltPreview);
 
    void ReleasePrimitive(FPrimitiveComponentId PrimitiveId);
 
    FIndirectLightingCacheAllocation* FindPrimitiveAllocation(FPrimitiveComponentId PrimitiveId) const; 
 
    void UpdateCache(FScene* Scene, FSceneRenderer& Renderer, bool bAllowUnbuiltPreview);
 
    void StartUpdateCachePrimitivesTask(FScene* Scene, FSceneRenderer& Renderer, bool bAllowUnbuiltPreview, FILCUpdatePrimTaskData& OutTaskData);
 
    void FinalizeCacheUpdates(FScene* Scene, FSceneRenderer& Renderer, FILCUpdatePrimTaskData& TaskData);
 
    void SetLightingCacheDirty(FScene* Scene, const FPrecomputedLightVolume* Volume);
 
    // Accessors
    FRHITexture* GetTexture0() { return Texture0->GetRHI(); }
    FRHITexture* GetTexture1() { return Texture1->GetRHI(); }
    FRHITexture* GetTexture2() { return Texture2->GetRHI(); }
 
private:
    bool IndirectLightingAllowed(FScene* Scene, FSceneRenderer& Renderer) const;
 
    void ProcessPrimitiveUpdate(FScene* Scene, FViewInfo& View, int32 PrimitiveIndex, bool bAllowUnbuiltPreview, bool bAllowVolumeSample, TMap<FIntVector, FBlockUpdateInfo>& OutBlocksToUpdate, TArray<FIndirectLightingCacheAllocation*>& OutTransitionsOverTimeToUpdate, TArray<FPrimitiveSceneInfo*>& OutPrimitivesToUpdateStaticMeshes);
 
    void UpdateCachePrimitivesInternal(FScene* Scene, FSceneRenderer& Renderer, bool bAllowUnbuiltPreview, TMap<FIntVector, FBlockUpdateInfo>& OutBlocksToUpdate, TArray<FIndirectLightingCacheAllocation*>& OutTransitionsOverTimeToUpdate, TArray<FPrimitiveSceneInfo*>& OutPrimitivesToUpdateStaticMeshes);
 
    void FinalizeUpdateInternal_RenderThread(FScene* Scene, FSceneRenderer& Renderer, TMap<FIntVector, FBlockUpdateInfo>& BlocksToUpdate, const TArray<FIndirectLightingCacheAllocation*>& TransitionsOverTimeToUpdate, TArray<FPrimitiveSceneInfo*>& PrimitivesToUpdateStaticMeshes);
 
    bool UpdateCacheAllocation(
        const FBoxSphereBounds& Bounds, 
        int32 BlockSize,
        bool bPointSample,
        bool bUnbuiltPreview,
        FIndirectLightingCacheAllocation*& Allocation, 
        TMap<FIntVector, FBlockUpdateInfo>& BlocksToUpdate,
        TArray<FIndirectLightingCacheAllocation*>& TransitionsOverTimeToUpdate);    
 
    void UpdateCachePrimitive(
        const TMap<FPrimitiveComponentId, FAttachmentGroupSceneInfo>& AttachmentGroups,
        FPrimitiveSceneInfo* PrimitiveSceneInfo,
        bool bAllowUnbuiltPreview, 
        bool bAllowVolumeSample, 
        TMap<FIntVector, FBlockUpdateInfo>& BlocksToUpdate, 
        TArray<FIndirectLightingCacheAllocation*>& TransitionsOverTimeToUpdate,
        TArray<FPrimitiveSceneInfo*>& PrimitivesToUpdateStaticMeshes);
 
    void UpdateBlocks(FScene* Scene, FViewInfo* DebugDrawingView, TMap<FIntVector, FBlockUpdateInfo>& BlocksToUpdate);
 
    void UpdateTransitionsOverTime(const TArray<FIndirectLightingCacheAllocation*>& TransitionsOverTimeToUpdate, float DeltaWorldTime) const;
 
    FIndirectLightingCacheAllocation* CreateAllocation(int32 BlockSize, const FBoxSphereBounds& Bounds, bool bPointSample, bool bUnbuiltPreview);   
 
    FIndirectLightingCacheBlock& FindBlock(FIntVector TexelMin);
    const FIndirectLightingCacheBlock& FindBlock(FIntVector TexelMin) const;
 
    void DeallocateBlock(FIntVector Min, int32 Size);
    bool AllocateBlock(int32 Size, FIntVector& OutMin);
 
    void UpdateBlock(FScene* Scene, FViewInfo* DebugDrawingView, FBlockUpdateInfo& Block);
 
    void InterpolatePoint(
        FScene* Scene, 
        const FIndirectLightingCacheBlock& Block,
        float& OutDirectionalShadowing, 
        FSHVectorRGB3& OutIncidentRadiance,
        FVector& OutSkyBentNormal);
 
    void InterpolateBlock(
        FScene* Scene, 
        const FIndirectLightingCacheBlock& Block, 
        TArray<float>& AccumulatedWeight, 
        TArray<FSHVectorRGB2>& AccumulatedIncidentRadiance);
 
    void EncodeBlock(
        FViewInfo* DebugDrawingView,
        const FIndirectLightingCacheBlock& Block, 
        const TArray<float>& AccumulatedWeight, 
        const TArray<FSHVectorRGB2>& AccumulatedIncidentRadiance,
        TArray<FFloat16Color>& Texture0Data,
        TArray<FFloat16Color>& Texture1Data,
        TArray<FFloat16Color>& Texture2Data     
    );
 
    void CalculateBlockPositionAndSize(const FBoxSphereBounds& Bounds, int32 TexelSize, FVector& OutMin, FVector& OutSize) const;
 
    void CalculateBlockScaleAndAdd(FIntVector InTexelMin, int32 AllocationTexelSize, FVector InMin, FVector InSize, FVector& OutScale, FVector& OutAdd, FVector& OutMinUV, FVector& OutMaxUV) const;
 
    bool bUpdateAllCacheEntries;
 
    int32 CacheSize;
 
    TRefCountPtr<IPooledRenderTarget> Texture0;
    TRefCountPtr<IPooledRenderTarget> Texture1;
    TRefCountPtr<IPooledRenderTarget> Texture2;
 
    TMap<FIntVector, FIndirectLightingCacheBlock> VolumeBlocks;
 
    FTextureLayout3d BlockAllocator;
 
    int32 NextPointId;
 
    TMap<FPrimitiveComponentId, FIndirectLightingCacheAllocation*> PrimitiveAllocations;
 
    friend class FUpdateCachePrimitivesTask;
};
 
struct FPrimitiveBounds
{
    FBoxSphereBounds BoxSphereBounds;
    float MinDrawDistance;
    float MaxDrawDistance;
    float MaxCullDistance;
};
 
struct FPrimitiveVisibilityId
{
    int32 ByteIndex;
    uint8 BitMask;
};
 
namespace EOcclusionFlags
{
    enum Type
    {
        None = 0x0,
        CanBeOccluded = 0x1,
        AllowApproximateOcclusion = 0x4,
        HasPrecomputedVisibility = 0x8,
        HasSubprimitiveQueries = 0x10,
        IsForceHidden = 0x20,
    };
};
 
class FComponentVelocityData
{
public:
 
    FPrimitiveSceneInfo* PrimitiveSceneInfo;
    FMatrix LocalToWorld;
    FMatrix PreviousLocalToWorld;
    mutable uint64 LastFrameUsed;
    uint64 LastFrameUpdated;
    bool bPreviousLocalToWorldValid = false;
};
 
class FSceneVelocityData
{
public:
 
    void StartFrame(FScene* Scene);
 
    inline bool GetComponentPreviousLocalToWorld(FPrimitiveComponentId PrimitiveComponentId, FMatrix& OutPreviousLocalToWorld) const
    {
        const FComponentVelocityData* VelocityData = ComponentData.Find(PrimitiveComponentId);
 
        if (VelocityData && VelocityData->PrimitiveSceneInfo)
        {
            check(VelocityData->bPreviousLocalToWorldValid);
            VelocityData->LastFrameUsed = InternalFrameIndex;
            OutPreviousLocalToWorld = VelocityData->PreviousLocalToWorld;
            return true;
        }
 
        return false;
    }
 
    void UpdateTransform(FPrimitiveSceneInfo* PrimitiveSceneInfo, const FMatrix& LocalToWorld, const FMatrix& PreviousLocalToWorld)
    {
        check(PrimitiveSceneInfo->Proxy->HasDynamicTransform());
 
        FComponentVelocityData& VelocityData = ComponentData.FindOrAdd(PrimitiveSceneInfo->PrimitiveComponentId);
        VelocityData.LocalToWorld = LocalToWorld;
        VelocityData.LastFrameUsed = InternalFrameIndex;
        VelocityData.LastFrameUpdated = InternalFrameIndex;
        VelocityData.PrimitiveSceneInfo = PrimitiveSceneInfo;
 
        // If this transform state is newly added, use the passed in PreviousLocalToWorld for this frame
        if (!VelocityData.bPreviousLocalToWorldValid)
        {
            VelocityData.PreviousLocalToWorld = PreviousLocalToWorld;
            VelocityData.bPreviousLocalToWorldValid = true;
        }
    }
 
    void RemoveFromScene(FPrimitiveComponentId PrimitiveComponentId, bool bImmediate)
    {
        if (bImmediate)
        {
            ComponentData.Remove(PrimitiveComponentId);
        }
        else
        {
            FComponentVelocityData* VelocityData = ComponentData.Find(PrimitiveComponentId);
 
            if (VelocityData)
            {
                VelocityData->PrimitiveSceneInfo = nullptr;
            }
        }
    }
 
    void OverridePreviousTransform(FPrimitiveComponentId PrimitiveComponentId, const FMatrix& PreviousLocalToWorld)
    {
        FComponentVelocityData* VelocityData = ComponentData.Find(PrimitiveComponentId);
        if (VelocityData)
        {
            VelocityData->PreviousLocalToWorld = PreviousLocalToWorld;
            VelocityData->bPreviousLocalToWorldValid = true;
        }
    }
 
    void ApplyOffset(FVector Offset)
    {
        for (TMap<FPrimitiveComponentId, FComponentVelocityData>::TIterator It(ComponentData); It; ++It)
        {
            FComponentVelocityData& VelocityData = It.Value();
            VelocityData.LocalToWorld.SetOrigin(VelocityData.LocalToWorld.GetOrigin() + Offset);
            VelocityData.PreviousLocalToWorld.SetOrigin(VelocityData.PreviousLocalToWorld.GetOrigin() + Offset);
        }
    }
 
private:
 
    uint64 InternalFrameIndex = 0;
    TMap<FPrimitiveComponentId, FComponentVelocityData> ComponentData;
};
 
class FLODSceneTree
{
public:
    FLODSceneTree(FScene* InScene)
        : Scene(InScene)
    {
    }
 
    struct FLODSceneNode
    {
        TArray<FPrimitiveSceneInfo*> ChildrenSceneInfos;
 
        FPrimitiveSceneInfo* SceneInfo;
 
        FLODSceneNode()
            : SceneInfo(nullptr)
        {
        }
 
        void AddChild(FPrimitiveSceneInfo* NewChild)
        {
            if (NewChild)
            {
                ChildrenSceneInfos.AddUnique(NewChild);
            }
        }
 
        void RemoveChild(FPrimitiveSceneInfo* ChildToDelete)
        {
            if (ChildToDelete)
            {
                ChildrenSceneInfos.Remove(ChildToDelete);
            }
        }
    };
 
    void AddChildNode(FPrimitiveComponentId ParentId, FPrimitiveSceneInfo* ChildSceneInfo);
    void RemoveChildNode(FPrimitiveComponentId ParentId, FPrimitiveSceneInfo* ChildSceneInfo);
 
    void UpdateNodeSceneInfo(FPrimitiveComponentId NodeId, FPrimitiveSceneInfo* SceneInfo);
    void UpdateVisibilityStates(FViewInfo& View, UE::Tasks::FTaskEvent& FlushCachedShadowsTaskEvent);
 
    void ClearVisibilityState(FViewInfo& View);
 
    bool IsActive() const { return (SceneNodes.Num() > 0); }
 
private:
 
    FScene* Scene;
 
    TMap<FPrimitiveComponentId, FLODSceneNode> SceneNodes;
 
    void ApplyNodeFadingToChildren(FSceneViewState* ViewState, FLODSceneNode& Node, FHLODSceneNodeVisibilityState& NodeVisibility, const bool bIsFading, const bool bIsFadingOut);
    void HideNodeChildren(FSceneViewState* ViewState, FLODSceneNode& Node);
};
 
// Enable the DEBUG_CSM_CACHING to make the debugging CSM caching with RenderDoc more easier
#define DEBUG_CSM_CACHING 0
 
class FCachedShadowMapData
{
public:
    FWholeSceneProjectedShadowInitializer Initializer;
    FShadowMapRenderTargetsRefCounted ShadowMap;
    float LastUsedTime;
    bool bCachedShadowMapHasPrimitives;
    bool bCachedShadowMapHasNaniteGeometry;
 
    TBitArray<> StaticShadowSubjectPersistentPrimitiveIdMap;
 
    FIntPoint ShadowBufferResolution;
    FVector PreShadowTranslation;
    float MaxSubjectZ;
    float MinSubjectZ;
 
    int32 LastFrameExtraStaticShadowSubjects;
 
    void InvalidateCachedShadow()
    {
        ShadowMap.Release();
 
        StaticShadowSubjectPersistentPrimitiveIdMap.SetRange(0, StaticShadowSubjectPersistentPrimitiveIdMap.Num(), false);
    }
 
    FCachedShadowMapData(const FWholeSceneProjectedShadowInitializer& InInitializer, float InLastUsedTime) :
        Initializer(InInitializer),
        LastUsedTime(InLastUsedTime),
        bCachedShadowMapHasPrimitives(true),
        bCachedShadowMapHasNaniteGeometry(false)
    {}
};
 
#if WITH_EDITOR
class FPixelInspectorData
{
public:
    FPixelInspectorData();
 
    void InitializeBuffers(FRenderTarget* BufferFinalColor, FRenderTarget* BufferSceneColor, FRenderTarget* BufferDepth, FRenderTarget* BufferHDR, FRenderTarget* BufferA, FRenderTarget* BufferBCDEF, int32 bufferIndex);
 
    bool AddPixelInspectorRequest(FPixelInspectorRequest *PixelInspectorRequest);
 
    //Hold the buffer array
    TMap<FVector2f, FPixelInspectorRequest *> Requests;
 
    FRenderTarget* RenderTargetBufferDepth[2];
    FRenderTarget* RenderTargetBufferFinalColor[2];
    FRenderTarget* RenderTargetBufferHDR[2];
    FRenderTarget* RenderTargetBufferSceneColor[2];
    FRenderTarget* RenderTargetBufferA[2];
    FRenderTarget* RenderTargetBufferBCDEF[2];
};
 
// Reserved values for the stencil buffer that carry specific meaning
namespace EEditorSelectionStencilValues
{
    enum Type : int32
    {
        NotSelected = 0,
        BSP = 1, // The outlines of all BSPs should be merged
        VisualizeLevelInstances = 2,
        Nanite = 3, // Nanite can use only a single value
 
        COUNT,
    };
}
 
#endif //WITH_EDITOR
 
class FPersistentUniformBuffers
{
public:
    FPersistentUniformBuffers() = default;
 
    void Initialize();
    void Clear();
 
 
    TUniformBufferRef<FMobileDirectionalLightShaderParameters> MobileDirectionalLightUniformBuffers[NUM_LIGHTING_CHANNELS+1];
    TUniformBufferRef<FMobileReflectionCaptureShaderParameters> MobileSkyReflectionUniformBuffer;
};
 
#if RHI_RAYTRACING
 
enum class ERayTracingType : uint8;
 
#endif
 
struct FLumenSceneDataKey
{
    uint32 ViewUniqueId;        // Zero if not view specific
    uint32 GPUIndex;            // INDEX_NONE if not GPU specific
 
    friend FORCEINLINE bool operator == (const FLumenSceneDataKey& A, const FLumenSceneDataKey& B)
    {
        return A.ViewUniqueId == B.ViewUniqueId && A.GPUIndex == B.GPUIndex;
    }
 
    friend FORCEINLINE uint32 GetTypeHash(const FLumenSceneDataKey& Key)
    {
        return HashCombine(GetTypeHash(Key.ViewUniqueId), GetTypeHash(Key.GPUIndex));
    }
};
 
typedef TMap<FLumenSceneDataKey, FLumenSceneData*> FLumenSceneDataMap;
 
class FLumenSceneDataIterator
{
public:
    FLumenSceneDataIterator(const FScene* InScene);
    FLumenSceneDataIterator& operator++();
 
    FORCEINLINE explicit operator bool() const { return LumenSceneData != nullptr; }
    FORCEINLINE bool operator !() const { return LumenSceneData == nullptr; }
    FORCEINLINE FLumenSceneData* operator->() const { return LumenSceneData; }
    FORCEINLINE FLumenSceneData& operator*() const { return *LumenSceneData; }
 
private:
    const FScene* Scene;
    FLumenSceneData* LumenSceneData;
    FLumenSceneDataMap::TConstIterator NextSceneData;
};
 
enum class ELightDirtyFlags : uint32 
{
    None            =   0u
};
ENUM_CLASS_FLAGS(ELightDirtyFlags);
 
enum class ELightUpdateId : uint32 
{
    Invalidate,
    Transform,
    Color,
    MAX
};
 
using FSceneLightInfoUpdates = TSceneUpdateCommandQueue<FLightSceneInfo, ELightDirtyFlags, ELightUpdateId>;
using FUpdateLightCommand = FSceneLightInfoUpdates::FUpdateCommand;
 
using FUpdateLightInvalidateGPUState = FSceneLightInfoUpdates::TPayloadBase<ELightUpdateId::Invalidate, ELightDirtyFlags::None>;
 
struct FUpdateLightTransformParameters : public FSceneLightInfoUpdates::TPayloadBase<ELightUpdateId::Transform, ELightDirtyFlags::None>
{
    FMatrix LightToWorld;
    FVector4 Position;
};
 
struct FUpdateLightColorParameters: public FSceneLightInfoUpdates::TPayloadBase<ELightUpdateId::Color, ELightDirtyFlags::None>
{
    FLinearColor NewColor;
    float NewIndirectLightingScale;
    float NewVolumetricScatteringIntensity;
};
 
struct FLightSceneChangeSet
{
    // IDs of all lights before they were removed, IDs in this array may not be valid at all times when the change-set is used (depends on whether the callback site is before or after the given lights are removed from the scene).
    TConstArrayView<int32> RemovedLightIds;
    // IDs of all lights added to the scene, only available after all lights are added to the scene, may contain the same ID's as removed, as they may be reused.
    TConstArrayView<int32> AddedLightIds;
    FSceneLightInfoUpdates& SceneLightInfoUpdates;
    // Bit-array of at least size PreUpdateMaxIndex, with a bit set for each removed light
    const TBitArray<SceneRenderingAllocator>& RemovedLightsMask;
    int32 PreUpdateMaxIndex = 0;
    int32 PostUpdateMaxIndex = 0;
};
 
struct FViewSceneChangeSet
{
    TArray<FPersistentViewId, SceneRenderingAllocator> AddedViewIds;
    TArray<FPersistentViewId> RemovedViewIds;
    bool bIsRequiresDebugMaterialChanged = false;
};
 
class FScene : public FSceneInterface
{
public:
 
    UWorld* World;
 
    class FFXSystemInterface* FXSystem;
 
    TArray<FSceneViewState*> ViewStates;
 
    TSparseArray<int32> PersistentViewStateUniqueIDs;
 
    int32 GetMaxPersistentViewId() const { return PersistentViewStateUniqueIDs.GetMaxIndex(); }
 
    FPersistentUniformBuffers UniformBuffers;
 
    FStateBucketMap CachedMeshDrawCommandStateBuckets[EMeshPass::Num];
    FCachedPassMeshDrawList CachedDrawLists[EMeshPass::Num];
 
#if RHI_RAYTRACING
    void RefreshCachedRayTracingData();
 
    void ReleaseUnusedPersistentSBTs();
#endif
 
    FNaniteShadingCommands NaniteShadingCommands[ENaniteMeshPass::Num];
 
    FNaniteRasterPipelines  NaniteRasterPipelines[ENaniteMeshPass::Num];
    FNaniteShadingPipelines NaniteShadingPipelines[ENaniteMeshPass::Num];
 
    FNaniteVisibility NaniteVisibility[ENaniteMeshPass::Num];
 
    struct FPrimitiveUpdateParams
    {
        FScene* Scene;
        FPrimitiveSceneProxy* PrimitiveSceneProxy;
        FBoxSphereBounds WorldBounds;
        FBoxSphereBounds LocalBounds;
        FMatrix LocalToWorld;
        TOptional<FTransform> PreviousTransform;
        FVector AttachmentRootPosition;
    };
 
    struct FPrimitiveTransformUpdater : public IPrimitiveTransformUpdater
    {
        std::atomic_int32_t Index = 0;
        TArray<FPrimitiveUpdateParams> Params;
    };
 
    uint32 PrimitivesAlwaysVisibleOffset = ~0u;
 
    TArray<FPrimitiveSceneInfo*> Primitives;
    TScenePrimitiveArray<FMatrix> PrimitiveTransforms;
    TArray<FPrimitiveSceneProxy*> PrimitiveSceneProxies;
    TScenePrimitiveArray<FPrimitiveBounds> PrimitiveBounds;
    TArray<FPrimitiveFlagsCompact> PrimitiveFlagsCompact;
    TArray<FPrimitiveVisibilityId> PrimitiveVisibilityIds;
    TArray<uint32> PrimitiveOctreeIndex;
    TArray<uint8> PrimitiveOcclusionFlags;
    TScenePrimitiveArray<FBoxSphereBounds> PrimitiveOcclusionBounds;
    TArray<FPrimitiveComponentId> PrimitiveComponentIds;
#if RHI_RAYTRACING
    TArray<ERayTracingPrimitiveFlags> PrimitiveRayTracingFlags;
    struct FPrimitiveRayTracingData
    {
        bool bDrawInGame : 1;
        bool bRayTracingFarField : 1;
        bool bCastHiddenShadow : 1;
        bool bAffectIndirectLightingWhileHidden : 1;
        bool bIsVisibleInSceneCaptures : 1;
        bool bIsVisibleInSceneCapturesOnly : 1;
        bool bUsesLightingChannels : 1;
        bool bCachedRaytracingDataDirty : 1 = true;
        ERayTracingProxyType ProxyGeometryType;
        Nanite::CoarseMeshStreamingHandle CoarseMeshStreamingHandle;
        RayTracing::FGeometryGroupHandle RayTracingGeometryGroupHandle;
    };
    TArray<FPrimitiveRayTracingData> PrimitiveRayTracingDatas;
    TArray<Experimental::FHashElementId> PrimitiveRayTracingGroupIds;
    struct FRayTracingCullingGroup
    {
        FBoxSphereBounds Bounds;
        float MinDrawDistance = 0.0f;
        TArray<FPrimitiveSceneInfo*> Primitives;
    };
    Experimental::TRobinHoodHashMap<int32, FRayTracingCullingGroup> PrimitiveRayTracingGroups;
#endif
 
    TMap<FName, TArray<FPrimitiveSceneInfo*>> PrimitivesNeedingLevelUpdateNotification;
 
#if WITH_EDITOR
    TBitArray<> PrimitivesSelected;
#endif
 
    TBitArray<> PrimitivesNeedingStaticMeshUpdate;
    TBitArray<> PrimitivesNeedingUniformBufferUpdate;
 
    TArray<int32> PersistentPrimitiveIdToIndexMap;
 
    struct FPrimitiveSceneProxyType
    {
        FPrimitiveSceneProxyType(const FPrimitiveSceneProxy *PrimitiveSceneProxy);
        bool operator ==(const FPrimitiveSceneProxyType&) const = default;
 
        SIZE_T ProxyTypeHash; 
        bool bIsAlwaysVisible;
    };
 
    struct FTypeOffsetTableEntry
    {
        FTypeOffsetTableEntry(const FPrimitiveSceneProxyType &InPrimitiveSceneProxyType, uint32 InOffset) : PrimitiveSceneProxyType(InPrimitiveSceneProxyType), Offset(InOffset) {}
        FPrimitiveSceneProxyType PrimitiveSceneProxyType;
        uint32 Offset; //(e.g. prefix sum where the next type starts)
    };
    /* During insertion and deletion, used to skip large chunks of items of the same type */
    TArray<FTypeOffsetTableEntry> TypeOffsetTable;
 
    using FLightSceneInfoCompactSparseArray = TSparseArray<FLightSceneInfoCompact, TAlignedSparseArrayAllocator<alignof(FLightSceneInfoCompact)>>;
    FLightSceneInfoCompactSparseArray Lights;
 
    FLightSceneInfoCompactSparseArray InvisibleLights;
 
    TArray<FString> OverflowingDynamicShadowedLights;
 
    EDepthDrawingMode EarlyZPassMode;
 
    bool bEarlyZPassMovable;
 
    FExclusiveDepthStencil::Type DefaultBasePassDepthStencilAccess;
 
    FExclusiveDepthStencil::Type CachedDefaultBasePassDepthStencilAccess;
 
    bool bCachedShouldRenderSkylightInBasePass;
 
    bool bCachedSkyLightRealTimeCapture;
 
    bool bScenesPrimitivesNeedStaticMeshElementUpdate;
 
    TAtomic<uint32> PathTracingInvalidationCounter;
 
#if RHI_RAYTRACING
    ERayTracingType CachedRayTracingMeshCommandsType;
#endif
 
    FSkyLightSceneProxy* SkyLight;
 
    TRefCountPtr<FRDGPooledBuffer> SkyIrradianceEnvironmentMap;
 
    TRefCountPtr<IPooledRenderTarget> RealTimeReflectionCaptureSkyAtmosphereViewLutTexture;
 
    TRefCountPtr<IPooledRenderTarget> RealTimeReflectionCaptureCamera360APLutTexture;
 
    TRefCountPtr<IPooledRenderTarget> CapturedSkyRenderTarget;  // Needs to be a IPooledRenderTarget because it must be created before the View uniform buffer is created.
 
    TRefCountPtr<IPooledRenderTarget> ConvolvedSkyRenderTarget[2];
 
    int32 ConvolvedSkyRenderTargetReadyIndex;
 
    bool CanSampleSkyLightRealTimeCaptureData() const;
 
    struct FRealTimeSlicedReflectionCapture
    {
        enum class EFirstFrameState
        {
            INIT = 0,
            FIRST_FRAME = 1,
            BEYOND_FIRST_FRAME = 2,
        } FirstFrameState = EFirstFrameState::INIT;
 
        int32 State = -1;
 
        int32 StateSubStep = 0;
 
        uint32 GpusWithFullCube = 0;
 
        uint32 GpusHandledThisFrame = 0;
 
        uint64 FrameNumber = uint64(-1);
    } RealTimeSlicedReflectionCapture;
 
    TRefCountPtr<IPooledRenderTarget> PathTracingSkylightTexture;
    TRefCountPtr<IPooledRenderTarget> PathTracingSkylightPdf;
    FLinearColor PathTracingSkylightColor;
 
    TArray<FSkyLightSceneProxy*> SkyLightStack;
 
    TQueue<TSharedPtr<FRHIGPUBufferReadback>> MobileSkyLightRealTimeCaptureIrradianceReadBackQueries;
    FVector4f MobileSkyLightRealTimeCaptureIrradianceEnvironmentMap[SKY_IRRADIANCE_ENVIRONMENT_MAP_VEC4_COUNT];
 
    FLightSceneInfo* SimpleDirectionalLight;
 
    FLightSceneInfo* MobileDirectionalLights[NUM_LIGHTING_CHANNELS];
 
    FLightSceneInfo* AtmosphereLights[NUM_ATMOSPHERE_LIGHTS];
 
    TArray<FLightSceneInfo*, TInlineAllocator<4>> DirectionalLights;
 
    TArray<FDeferredDecalProxy*> Decals;
 
    TArray<FPrimitiveSceneInfo*> DynamicIndirectCasterPrimitives; 
 
    TArray<class FPlanarReflectionSceneProxy*> PlanarReflections;
    TArray<class UPlanarReflectionComponent*> PlanarReflections_GameThread;
 
    FReflectionEnvironmentSceneData ReflectionSceneData;
 
    FHairStrandsSceneData HairStrandsSceneData;
 
    FOITSceneData OITSceneData;
 
    TArray<const FPrecomputedLightVolume*> PrecomputedLightVolumes;
 
    FIndirectLightingCache IndirectLightingCache;
 
    FVolumetricLightmapSceneData VolumetricLightmapSceneData;
    
    FGPUScene GPUScene;
 
#if RHI_RAYTRACING
    FRayTracingScene RayTracingScene;
    FRayTracingScene HeterogeneousVolumesRayTracingScene;
 
    FRayTracingMeshCommandStorage CachedRayTracingMeshCommands;
    
    // Last valid RTPSO is saved, so it could be used as fallback in future frames if background PSO compilation is enabled.
    // This RTPSO can be used only if the only difference from previous PSO is the material hit shaders.
    FRayTracingPipelineStateSignature LastRayTracingMaterialPipelineSignature;
    
    FRayTracingShaderBindingTable RayTracingSBT;
 
    struct FRayTracingPersistentSBTState
    {
        struct FTrackedSBT
        {
            FRayTracingPersistentShaderBindingTableID ID = INDEX_NONE;
            bool bUsedThisFrame = false;
            FRayTracingPipelineState* LastValidPipelineState = nullptr;  // Cached fallback pipeline state from last ViewFamily that created it
 
            void Reset()
            {
                ID = INDEX_NONE;
                bUsedThisFrame = false;
                LastValidPipelineState = nullptr;
            }
        };
 
        FTrackedSBT MaterialSBT;
        FTrackedSBT PathTracingSBT;
        FTrackedSBT LumenSBT;
        FTrackedSBT InlineSBT;
    };
 
    FRayTracingPersistentSBTState RayTracingPersistentSBTState;
#endif // RHI_RAYTRACING
 
    FDistanceFieldSceneData DistanceFieldSceneData;
 
    FLumenSceneData* DefaultLumenSceneData;
    FLumenSceneDataMap PerViewOrGPULumenSceneData;
 
    TMap<FPrimitiveComponentId, FPrimitiveSceneInfo*> LandscapeToNaniteProxyMap;
 
    TMap<int32, TArray<FCachedShadowMapData>> CachedShadowMaps;
    
    TArray<TRefCountPtr<IPooledRenderTarget>>   PrevAtlasHZBs;
    TArray<TRefCountPtr<IPooledRenderTarget>>   PrevAtlasCompleteHZBs;
 
    TRefCountPtr<IPooledRenderTarget> PreShadowCacheDepthZ;
 
    TArray<TRefCountPtr<FProjectedShadowInfo> > CachedPreshadows;
 
    FTextureLayout PreshadowCacheLayout;
 
    TSparseArray<FStaticMeshBatch*> StaticMeshes;
 
    TArray<FExponentialHeightFogSceneInfo> ExponentialFogs;
 
    FSkyAtmosphereRenderSceneInfo* SkyAtmosphere;
 
    uint32 CachedTransmittanceAndMultiScatteringLUTsVersion;
 
    TArray<FSkyAtmosphereSceneProxy*> SkyAtmosphereStack;
 
    FVolumetricCloudRenderSceneInfo* VolumetricCloud;
 
    TArray<FVolumetricCloudSceneProxy*> VolumetricCloudStack;
 
    TArray<FLocalFogVolumeSceneProxy*> LocalFogVolumes;
 
    TArray<FSparseVolumeTextureViewerSceneProxy*> SparseVolumeTextureViewers;
 
    class FPhysicsFieldSceneProxy* PhysicsField = nullptr;
 
    TArray<class FWindSourceSceneProxy*> WindSources;
 
    TArray<UWindDirectionalSourceComponent*> WindComponents_GameThread;
 
    TMap<const UStaticMesh*, struct FSpeedTreeWindComputation*> SpeedTreeWindComputationMap;
    TMap<FVertexFactory*, const UStaticMesh*> SpeedTreeVertexFactoryMap;
 
    TMap<FPrimitiveComponentId,FAttachmentGroupSceneInfo> AttachmentGroups;
 
    const FPrecomputedVisibilityHandler* PrecomputedVisibilityHandler;
 
    FSceneLightOctree LocalShadowCastingLightOctree;
    TArray<int32> DirectionalShadowCastingLightIDs;
 
    FScenePrimitiveOctree PrimitiveOctree;
 
    bool bRequiresHitProxies;
 
    bool bIsEditorScene;
 
    bool bRuntimeVirtualTexturePrimitiveHideEditor;
    bool bRuntimeVirtualTexturePrimitiveHideGame;
 
    volatile mutable int32 NumUncachedStaticLightingInteractions;
 
    volatile mutable int32 NumUnbuiltReflectionCaptures;
 
    int32 NumMobileStaticAndCSMLights_RenderThread;
    int32 NumMobileMovableDirectionalLights_RenderThread;
 
    FSceneVelocityData VelocityData;
 
    class FGPUSkinCache* GPUSkinCache;
    class FSkeletalMeshUpdater* SkeletalMeshUpdater;
 
    /* Array of registered compute work schedulers*/
    TArray<class IComputeTaskWorker*> ComputeTaskWorkers;
 
    TMap<FGuid, FUniformBufferRHIRef> ParameterCollections;
 
    FLODSceneTree SceneLODHierarchy;
 
    TSparseArray<FRuntimeVirtualTextureSceneProxy*> RuntimeVirtualTextures;
 
    FSubstrateSceneData SubstrateSceneData;
 
    LightFunctionAtlas::FLightFunctionAtlasSceneData LightFunctionAtlasSceneData;
 
    float DefaultMaxDistanceFieldOcclusionDistance;
 
    float GlobalDistanceFieldViewDistance;
 
    float DynamicIndirectShadowsSelfShadowingIntensity;
 
    FSpanAllocator PersistentPrimitiveIdAllocator;
 
#if WITH_EDITOR
    FPixelInspectorData PixelInspectorData;
#endif //WITH_EDITOR
 
#if RHI_RAYTRACING
    class FRayTracingDynamicGeometryUpdateManager* RayTracingDynamicGeometryUpdateManager;
#endif
 
    FSceneExtensions SceneExtensions;
 
    TArray<FCustomRenderPassRendererInput> CustomRenderPassRendererInputs;
 
    FScene(UWorld* InWorld, bool bInRequiresHitProxies,bool bInIsEditorScene, bool bCreateFXSystem, ERHIFeatureLevel::Type InFeatureLevel);
 
    virtual ~FScene();
 
    FString GetFullWorldName() const { return FullWorldName; }
 
    using FSceneInterface::UpdateAllPrimitiveSceneInfos;
 
    struct FUpdateParameters
    {
        FViewSceneChangeSet* ViewUpdateChangeSet = nullptr;
        EUpdateAllPrimitiveSceneInfosAsyncOps AsyncOps = EUpdateAllPrimitiveSceneInfosAsyncOps::None;
        UE::Tasks::FTask GPUSceneUpdateTaskPrerequisites;
        bool bDestruction = false;
 
        struct
        {
            TFunction<void(const UE::Tasks::FTask&)> PostStaticMeshUpdate;
 
        } Callbacks;
    };
 
 
    FViewSceneChangeSet* ProcessViewChanges(FRDGBuilder& GraphBuilder, TConstArrayView<FViewInfo*> AllViews);
 
    void Update(FRDGBuilder& GraphBuilder, const FUpdateParameters& Parameters);
 
    // FSceneInterface interface.
    virtual void AddPrimitive(UPrimitiveComponent* Primitive) override;
    virtual void RemovePrimitive(UPrimitiveComponent* Primitive) override;
    virtual void ReleasePrimitive(UPrimitiveComponent* Primitive) override;
    virtual void BatchAddPrimitives(TArrayView<UPrimitiveComponent*> InPrimitives) override;
    virtual void BatchRemovePrimitives(TArrayView<UPrimitiveComponent*> InPrimitives) override;
    virtual void BatchReleasePrimitives(TArrayView<UPrimitiveComponent*> InPrimitives) override;
    virtual void UpdateAllPrimitiveSceneInfos(FRDGBuilder& GraphBuilder, EUpdateAllPrimitiveSceneInfosAsyncOps AsyncOps = EUpdateAllPrimitiveSceneInfosAsyncOps::None) override;
    virtual void UpdatePrimitiveTransform(UPrimitiveComponent* Primitive) override;
    virtual void UpdatePrimitiveInstances(UPrimitiveComponent* Primitive) override;
    virtual void UpdatePrimitiveInstancesFromCompute(FPrimitiveSceneDesc* Primitive, FGPUSceneWriteDelegate&& DataWriterGPU) override;
    virtual void UpdatePrimitiveOcclusionBoundsSlack(UPrimitiveComponent* Primitive, float NewSlack) override;
    virtual void UpdatePrimitiveDrawDistance(UPrimitiveComponent* Primitive, float MinDrawDistance, float MaxDrawDistance, float VirtualTextureMaxDrawDistance) override;
    virtual void UpdateInstanceCullDistance(UPrimitiveComponent* Primitive, float StartCullDistance, float EndCullDistance) override;
    virtual void UpdatePrimitiveAttachment(UPrimitiveComponent* Primitive) override;
    virtual void UpdateCustomPrimitiveData(UPrimitiveComponent* Primitive) override;
    virtual void UpdatePrimitiveDistanceFieldSceneData_GameThread(UPrimitiveComponent* Primitive) override;
    virtual FPrimitiveSceneInfo* GetPrimitiveSceneInfo(int32 PrimitiveIndex) const final;
    virtual FPrimitiveSceneInfo* GetPrimitiveSceneInfo(FPrimitiveComponentId PrimitiveId) const final;
    virtual FPrimitiveSceneInfo* GetPrimitiveSceneInfo(const FPersistentPrimitiveIndex& PersistentPrimitiveIndex) const final;
    virtual bool GetPreviousLocalToWorld(const FPrimitiveSceneInfo* PrimitiveSceneInfo, FMatrix& OutPreviousLocalToWorld) const override;
    virtual void AddLight(ULightComponent* Light) override;
    virtual void RemoveLight(ULightComponent* Light) override;
    virtual void AddInvisibleLight(ULightComponent* Light) override;
    virtual void SetSkyLight(FSkyLightSceneProxy* Light) override;
    virtual void DisableSkyLight(FSkyLightSceneProxy* Light) override;
    virtual bool HasSkyLightRequiringLightingBuild() const override;
    virtual bool HasAtmosphereLightRequiringLightingBuild() const override;
    virtual void AddDecal(UDecalComponent* Component) override;
    virtual void RemoveDecal(UDecalComponent* Component) override;
    virtual void UpdateDecalTransform(UDecalComponent* Decal) override;
    virtual void UpdateDecalFadeOutTime(UDecalComponent* Decal) override;
    virtual void UpdateDecalFadeInTime(UDecalComponent* Decal) override;
    virtual void BatchUpdateDecals(TArray<FDeferredDecalUpdateParams>&& UpdateParams) override;
    virtual void AddReflectionCapture(UReflectionCaptureComponent* Component) override;
    virtual void RemoveReflectionCapture(UReflectionCaptureComponent* Component) override;
    virtual void GetReflectionCaptureData(UReflectionCaptureComponent* Component, class FReflectionCaptureData& OutCaptureData) override;
    virtual void UpdateReflectionCaptureTransform(UReflectionCaptureComponent* Component) override;
    virtual void ReleaseReflectionCubemap(UReflectionCaptureComponent* CaptureComponent) override;
    virtual void AddPlanarReflection(class UPlanarReflectionComponent* Component) override;
    virtual void RemovePlanarReflection(UPlanarReflectionComponent* Component) override;
    virtual void UpdatePlanarReflectionTransform(UPlanarReflectionComponent* Component) override;
    virtual void UpdateSceneCaptureContents(class USceneCaptureComponent2D* CaptureComponent, ISceneRenderBuilder& SceneRenderBuilder) override;
    virtual void UpdateSceneCaptureContents(class USceneCaptureComponentCube* CaptureComponent, ISceneRenderBuilder& SceneRenderBuilder) override;
    virtual void UpdatePlanarReflectionContents(UPlanarReflectionComponent* CaptureComponent, FSceneRenderer& MainSceneRenderer, ISceneRenderBuilder& SceneRenderBuilder) override;
    virtual void AllocateReflectionCaptures(const TArray<UReflectionCaptureComponent*>& NewCaptures, const TCHAR* CaptureReason, bool bVerifyOnlyCapturing, bool bCapturingForMobile, bool bInsideTick) override;
    virtual void ResetReflectionCaptures(bool bOnlyIfOOM) override;
    virtual void UpdateSkyCaptureContents(const USkyLightComponent* CaptureComponent, bool bCaptureEmissiveOnly, UTextureCube* SourceCubemap, FTexture* OutProcessedTexture, float& OutAverageBrightness, FSHVectorRGB3& OutIrradianceEnvironmentMap, TArray<FFloat16Color>* OutRadianceMap, FLinearColor* SpecifiedCubemapColorScale) override;
    virtual void AllocateAndCaptureFrameSkyEnvMap(FRDGBuilder& GraphBuilder, FSceneRenderer& SceneRenderer, FViewInfo& MainView, bool bShouldRenderSkyAtmosphere, bool bShouldRenderVolumetricCloud, FInstanceCullingManager& InstanceCullingManager, FRDGExternalAccessQueue& ExternalAccessQueue) override;
    virtual void ValidateSkyLightRealTimeCapture(FRDGBuilder& GraphBuilder, const FViewInfo& View, FRDGTextureRef SceneColorTexture) override;
    virtual void ProcessAndRenderIlluminanceMeter(FRDGBuilder& GraphBuilder, TArrayView<FViewInfo> Views, FRDGTextureRef SceneColorTexture);
    virtual void AddPrecomputedLightVolume(const class FPrecomputedLightVolume* Volume) override;
    virtual void RemovePrecomputedLightVolume(const class FPrecomputedLightVolume* Volume) override;
    virtual bool HasPrecomputedVolumetricLightmap_RenderThread() const override;
    virtual void AddPrecomputedVolumetricLightmap(const class FPrecomputedVolumetricLightmap* Volume, bool bIsPersistentLevel) override;
    virtual void RemovePrecomputedVolumetricLightmap(const class FPrecomputedVolumetricLightmap* Volume) override;
    virtual void AddRuntimeVirtualTexture(class URuntimeVirtualTextureComponent* Component) override;
    virtual void RemoveRuntimeVirtualTexture(class URuntimeVirtualTextureComponent* Component) override;
    virtual void GetRuntimeVirtualTextureHidePrimitiveMask(uint8& bHideMaskEditor, uint8& bHideMaskGame) const override;
    virtual void InvalidateRuntimeVirtualTexture(class URuntimeVirtualTextureComponent* Component, FBoxSphereBounds const& WorldBounds, EVTInvalidatePriority InvalidatePriority) override;
    virtual void RequestPreloadRuntimeVirtualTexture(class URuntimeVirtualTextureComponent* Component, FBoxSphereBounds const& WorldBounds, int32 Level) override;
    virtual void InvalidatePathTracedOutput(PathTracing::EInvalidateReason InvalidateReason = PathTracing::EInvalidateReason::Uncategorized) override;
    virtual void InvalidateLumenSurfaceCache_GameThread(UPrimitiveComponent* Component) override;
    virtual void GetPrimitiveUniformShaderParameters_RenderThread(const FPrimitiveSceneInfo* PrimitiveSceneInfo, bool& bHasPrecomputedVolumetricLightmap, FMatrix& PreviousLocalToWorld, int32& SingleCaptureIndex, bool& bOutputVelocity) const override;
    virtual void UpdateLightTransform(ULightComponent* Light) override;
    virtual void UpdateLightColorAndBrightness(ULightComponent* Light) override;
    virtual void UpdateLightProxy(ULightComponent* Light, TFunction<void(FLightSceneProxy*)>&& Func) override;
    virtual void AddExponentialHeightFog(uint64 Id, const FExponentialHeightFogDynamicState& State) override;
    virtual void RemoveExponentialHeightFog(uint64 Id) override;
    virtual bool HasAnyExponentialHeightFog() const override;
 
    virtual void AddHairStrands(FHairStrandsInstance* Proxy) override;
    virtual void RemoveHairStrands(FHairStrandsInstance* Proxy) override;
 
    virtual void GetLightIESAtlasSlot(const FLightSceneProxy* Proxy, FLightRenderParameters* Out) override;
    virtual void GetRectLightAtlasSlot(const FRectLightSceneProxy* Proxy, FLightRenderParameters* Out) override;
 
    virtual void AddLocalFogVolume(class FLocalFogVolumeSceneProxy* FogProxy) override;
    virtual void RemoveLocalFogVolume(class FLocalFogVolumeSceneProxy* FogProxy) override;
    virtual bool HasAnyLocalFogVolume() const override;
 
    virtual void AddSkyAtmosphere(FSkyAtmosphereSceneProxy* SkyAtmosphereSceneProxy, bool bStaticLightingBuilt) override;
    virtual void RemoveSkyAtmosphere(FSkyAtmosphereSceneProxy* SkyAtmosphereSceneProxy) override;
    virtual FSkyAtmosphereRenderSceneInfo* GetSkyAtmosphereSceneInfo() override { return SkyAtmosphere; }
    virtual const FSkyAtmosphereRenderSceneInfo* GetSkyAtmosphereSceneInfo() const override { return SkyAtmosphere; }
 
    inline uint32 GetCachedTransmittanceAndMultiScatteringLUTsVersion() const
    {
        return CachedTransmittanceAndMultiScatteringLUTsVersion;
    }
    inline void SetCachedTransmittanceAndMultiScatteringLUTsVersion(uint32 NewTransmittanceAndMultiScatteringLUTsVersion)
    {
        CachedTransmittanceAndMultiScatteringLUTsVersion = NewTransmittanceAndMultiScatteringLUTsVersion;
    }
 
    virtual void AddSparseVolumeTextureViewer(FSparseVolumeTextureViewerSceneProxy* SVTV) override;
    virtual void RemoveSparseVolumeTextureViewer(FSparseVolumeTextureViewerSceneProxy* SVTV) override;
 
    virtual TArray<FAnimBankRecordHandle> RegisterAnimBank(const TConstArrayView<struct FAnimBankDesc> Descs) override;
    virtual void UnregisterAnimBank(const TConstArrayView<FAnimBankRecordHandle> Handles) override;
 
    virtual void SetPhysicsField(class FPhysicsFieldSceneProxy* PhysicsFieldSceneProxy) override;
    virtual void ResetPhysicsField() override;
    virtual void ShowPhysicsField() override;
    virtual void UpdatePhysicsField(FRDGBuilder& GraphBuilder, FViewInfo& View) override;
 
    virtual void AddVolumetricCloud(FVolumetricCloudSceneProxy* VolumetricCloudSceneProxy) override;
    virtual void RemoveVolumetricCloud(FVolumetricCloudSceneProxy* VolumetricCloudSceneProxy) override;
    virtual FVolumetricCloudRenderSceneInfo* GetVolumetricCloudSceneInfo() override { return VolumetricCloud; }
    virtual const FVolumetricCloudRenderSceneInfo* GetVolumetricCloudSceneInfo() const override { return VolumetricCloud; }
 
    virtual void AddWindSource(UWindDirectionalSourceComponent* WindComponent) override;
    virtual void RemoveWindSource(UWindDirectionalSourceComponent* WindComponent) override;
    virtual void UpdateWindSource(UWindDirectionalSourceComponent* WindComponent) override;
    virtual const TArray<FWindSourceSceneProxy*>& GetWindSources_RenderThread() const override;
    virtual void GetWindParameters(const FVector& Position, FVector& OutDirection, float& OutSpeed, float& OutMinGustAmt, float& OutMaxGustAmt) const override;
    virtual void GetWindParameters_GameThread(const FVector& Position, FVector& OutDirection, float& OutSpeed, float& OutMinGustAmt, float& OutMaxGustAmt) const override;
    virtual void GetDirectionalWindParameters(FVector& OutDirection, float& OutSpeed, float& OutMinGustAmt, float& OutMaxGustAmt) const override;
    virtual void AddSpeedTreeWind(FVertexFactory* VertexFactory, const UStaticMesh* StaticMesh) override;
    virtual void RemoveSpeedTreeWind_RenderThread(FVertexFactory* VertexFactory, const UStaticMesh* StaticMesh) override;
    virtual void UpdateSpeedTreeWind(double CurrentTime) override;
    virtual FRHIUniformBuffer* GetSpeedTreeUniformBuffer(const FVertexFactory* VertexFactory) const override;
    virtual void DumpUnbuiltLightInteractions( FOutputDevice& Ar ) const override;
    virtual void UpdateParameterCollections(const TArray<FMaterialParameterCollectionInstanceResource*>& InParameterCollections) override;
 
    virtual bool RequestGPUSceneUpdate(FPrimitiveSceneInfo& PrimitiveSceneInfo, EPrimitiveDirtyState PrimitiveDirtyState) override;
    virtual bool RequestUniformBufferUpdate(FPrimitiveSceneInfo& PrimitiveSceneInfo) override;
 
    virtual void RefreshNaniteRasterBins(FPrimitiveSceneInfo& PrimitiveSceneInfo) override;
    virtual void ReloadNaniteFixedFunctionBins() override;
 
    FVirtualShadowMapArrayCacheManager* GetVirtualShadowMapCache();
 
    FLumenSceneData* FindLumenSceneData(uint32 ViewKey, uint32 GPUIndex) const;
    inline FLumenSceneData* GetLumenSceneData(const FViewInfo& View) const
    {
        if (View.ViewLumenSceneData)
        {
            return View.ViewLumenSceneData;
        }
        else
        {
            return FindLumenSceneData(View.ViewState ? View.ViewState->GetShareOriginViewKey() : 0, View.GPUMask.GetFirstIndex());
        }
    }
    inline FLumenSceneData* GetLumenSceneData(const FSceneView& View) const
    {
        // Should we assert that this is only called for FViewInfo (meaning inside scene renderer)?
        if (View.bIsViewInfo)
        {
            return GetLumenSceneData((const FViewInfo&)View);
        }
        else
        {
            return FindLumenSceneData(View.State ? ((const FSceneViewState*)View.State)->GetShareOriginViewKey() : 0, View.GPUMask.GetFirstIndex());
        }
    }
 
    virtual void AddPrimitive(FPrimitiveSceneDesc* Primitive) override;
    virtual void RemovePrimitive(FPrimitiveSceneDesc* Primitive) override;
    virtual void ReleasePrimitive(FPrimitiveSceneDesc* Primitive) override;
    virtual void UpdatePrimitiveTransform(FPrimitiveSceneDesc* Primitive) override;
 
    virtual void BatchAddPrimitives(TArrayView<FPrimitiveSceneDesc*> InPrimitives) override;
    virtual void BatchRemovePrimitives(TArrayView<FPrimitiveSceneDesc*> InPrimitives) override;
    virtual void BatchReleasePrimitives(TArrayView<FPrimitiveSceneDesc*> InPrimitives) override;
 
    virtual void BatchRemovePrimitives(TArray<FPrimitiveSceneProxy*>&& InPrimitives) override;
        
    virtual void UpdateCustomPrimitiveData(FPrimitiveSceneDesc* Primitive, const FCustomPrimitiveData& CustomPrimitiveData) override;
 
    virtual void UpdatePrimitiveInstances(FInstancedStaticMeshSceneDesc* Primitive) override;
    virtual void UpdatePrimitiveInstances(FPrimitiveSceneDesc* Primitive) override;
 
    bool HasSkyAtmosphere() const
    {
        return (SkyAtmosphere != nullptr);
    }
    bool HasVolumetricCloud() const
    {
        return (VolumetricCloud != nullptr);
    }
 
    bool IsSecondAtmosphereLightEnabled()
    {
        // If the second light is not null then we enable the second light.
        // We do not do any light1 to light0 remapping if light0 is null.
        return AtmosphereLights[1] != nullptr;
    }
 
    // Reset all the light to default state "not being affected by atmosphere". Should only be called from render side.
    void ResetAtmosphereLightsProperties();
 
    virtual void GetRelevantLights( UPrimitiveComponent* Primitive, TArray<const ULightComponent*>* RelevantLights ) const override;
 
    virtual void SetPrecomputedVisibility(const FPrecomputedVisibilityHandler* InPrecomputedVisibilityHandler) override;
 
    virtual void UpdateStaticDrawLists() override;
 
    virtual void UpdateCachedRenderStates(FPrimitiveSceneProxy* SceneProxy) override;
 
    virtual void UpdatePrimitiveSelectedState_RenderThread(const FPrimitiveSceneInfo* PrimitiveSceneInfo, bool bIsSelected) override;
    virtual void UpdatePrimitiveVelocityState_RenderThread(FPrimitiveSceneInfo* PrimitiveSceneInfo, bool bIsBeingMoved) override;
 
    virtual void UpdateEarlyZPassMode() override;
 
    virtual void Release() override;
    virtual UWorld* GetWorld() const override { return World; }
 
    const FReflectionCaptureProxy* FindClosestReflectionCapture(FVector Position) const;
 
    const class FPlanarReflectionSceneProxy* FindClosestPlanarReflection(const FBoxSphereBounds& Bounds) const;
 
    const class FPlanarReflectionSceneProxy* GetForwardPassGlobalPlanarReflection() const;
 
    void FindClosestReflectionCaptures(FVector Position, const FReflectionCaptureProxy* (&SortedByDistanceOUT)[FPrimitiveSceneInfo::MaxCachedReflectionCaptureProxies]) const;
 
    int64 GetCachedWholeSceneShadowMapsSize() const;
 
    static FExclusiveDepthStencil::Type GetDefaultBasePassDepthStencilAccess(ERHIFeatureLevel::Type InFeatureLevel);
 
    static void GetEarlyZPassMode(ERHIFeatureLevel::Type InFeatureLevel, EDepthDrawingMode& OutZPassMode, bool& bOutEarlyZPassMovable);
 
    virtual bool RequiresHitProxies() const override;
 
    SIZE_T GetSizeBytes() const;
 
    virtual FScene* GetRenderScene() final { return this; }
    virtual const FScene* GetRenderScene() const final { return this; }
 
    virtual void OnWorldCleanup() override;
 
 
    virtual void UpdateSceneSettings(AWorldSettings* WorldSettings) override;
 
    virtual class FGPUSkinCache* GetGPUSkinCache() override
    {
        return GPUSkinCache;
    }
 
    virtual class FSkeletalMeshUpdater* GetSkeletalMeshUpdater() override
    {
        return SkeletalMeshUpdater;
    }
 
    virtual void GetComputeTaskWorkers(TArray<class IComputeTaskWorker*>& OutWorkers) const override
    {
        OutWorkers = ComputeTaskWorkers;
    }
 
#if RHI_RAYTRACING
    virtual void UpdateCachedRayTracingState(class FPrimitiveSceneProxy* SceneProxy) override;
    FRayTracingDynamicGeometryUpdateManager* GetRayTracingDynamicGeometryUpdateManager()
    {
        return RayTracingDynamicGeometryUpdateManager;
    }
#endif
 
    virtual void SetFXSystem( class FFXSystemInterface* InFXSystem ) override;
 
    virtual class FFXSystemInterface* GetFXSystem() override;
 
    virtual void Export( FArchive& Ar ) const override;
 
    FRHIUniformBuffer* GetParameterCollectionBuffer(const FGuid& InId) const
    {
        const FUniformBufferRHIRef* ExistingUniformBuffer = ParameterCollections.Find(InId);
 
        if (ExistingUniformBuffer)
        {
            return *ExistingUniformBuffer;
        }
 
        return nullptr;
    }
 
    virtual void ApplyWorldOffset(const FVector& InOffset) override;
 
    virtual void OnLevelAddedToWorld(const FName& InLevelName, UWorld* InWorld, bool bIsLightingScenario) override;
    virtual void OnLevelRemovedFromWorld(const FName& LevelRemovedName, UWorld* InWorld, bool bIsLightingScenario) override;
 
    virtual bool HasAnyLights() const override 
    { 
        check(IsInGameThread());
        return NumVisibleLights_GameThread > 0 || NumEnabledSkylights_GameThread > 0; 
    }
 
    virtual bool IsEditorScene() const override { return bIsEditorScene; }
 
    bool ShouldRenderSkylightInBasePass(bool bIsTranslucent) const;
 
    virtual TConstArrayView<FPrimitiveSceneProxy*> GetPrimitiveSceneProxies() const final
    {
        return PrimitiveSceneProxies;
    }
 
    virtual TConstArrayView<FPrimitiveComponentId> GetScenePrimitiveComponentIds() const final
    {
        return PrimitiveComponentIds;
    }
 
    void FlushDirtyRuntimeVirtualTextures();
 
#if WITH_EDITOR
    virtual bool InitializePixelInspector(FRenderTarget* BufferFinalColor, FRenderTarget* BufferSceneColor, FRenderTarget* BufferDepth, FRenderTarget* BufferHDR, FRenderTarget* BufferA, FRenderTarget* BufferBCDEF, int32 BufferIndex) override;
 
    virtual bool AddPixelInspectorRequest(FPixelInspectorRequest *PixelInspectorRequest) override;
#endif //WITH_EDITOR
 
    virtual void StartFrame() override
    {
        VelocityData.StartFrame(this);
    }
 
    virtual void EndFrame(FRHICommandListImmediate& RHICmdList) override;
 
    virtual uint32 GetFrameNumber() const override;
    inline uint32 GetFrameNumberRenderThread() const { return SceneFrameNumberRenderThread; }
 
    virtual void IncrementFrameNumber() override;
 
    void DumpMeshDrawCommandMemoryStats();
 
    FORCEINLINE TArray<FCachedShadowMapData>* GetCachedShadowMapDatas(int32 LightID)
    {
        return CachedShadowMaps.Find(LightID);
    }
 
    FORCEINLINE FCachedShadowMapData& GetCachedShadowMapDataRef(int32 LightID, int32 ShadowMapIndex = 0)
    {
        TArray<FCachedShadowMapData>& CachedShadowMapDatas = CachedShadowMaps.FindChecked(LightID);
 
        checkSlow(ShadowMapIndex >= 0 && ShadowMapIndex < CachedShadowMapDatas.Num());
 
        return CachedShadowMapDatas[ShadowMapIndex];
    }
 
    FORCEINLINE const FCachedShadowMapData& GetCachedShadowMapDataRef(int32 LightID, int32 ShadowMapIndex = 0) const
    {
        const TArray<FCachedShadowMapData>& CachedShadowMapDatas = CachedShadowMaps.FindChecked(LightID);
 
        checkSlow(ShadowMapIndex >= 0 && ShadowMapIndex < CachedShadowMapDatas.Num());
 
        return CachedShadowMapDatas[ShadowMapIndex];
    }
 
    FORCEINLINE const FCachedShadowMapData* GetCachedShadowMapData(int32 LightID, int32 ShadowMapIndex = 0) const
    {
        const TArray<FCachedShadowMapData>& CachedShadowMapDatas = CachedShadowMaps.FindChecked(LightID);
 
        checkSlow(ShadowMapIndex >= 0 && ShadowMapIndex < CachedShadowMapDatas.Num());
 
        return &CachedShadowMapDatas[ShadowMapIndex];
    }
 
    inline int32 GetMaxPersistentPrimitiveIndex() const { return PersistentPrimitiveIdAllocator.GetMaxSize(); }
 
    FORCEINLINE int32 GetPrimitiveIndex(const FPersistentPrimitiveIndex& PersistentPrimitiveIndex) const
    { 
        if (PersistentPrimitiveIndex.IsValid() && PersistentPrimitiveIndex.Index < PersistentPrimitiveIdToIndexMap.Num())
        {
            return PersistentPrimitiveIdToIndexMap[PersistentPrimitiveIndex.Index];
        }
        return INDEX_NONE;
    }
 
    bool GetForceNoPrecomputedLighting() const
    {
        return bForceNoPrecomputedLighting;
    }
 
    FLumenSceneDataIterator GetLumenSceneDataIterator() const
    {
        return FLumenSceneDataIterator(this);
    }
 
    void WaitForCreateLightPrimitiveInteractionsTask()
    {
        CSV_SCOPED_SET_WAIT_STAT(LightPrimitiveInteractions);
        CreateLightPrimitiveInteractionsTask.Wait();
    }
 
    const UE::Tasks::FTask& GetCreateLightPrimitiveInteractionsTask() const
    {
        return CreateLightPrimitiveInteractionsTask;
    }
 
    const UE::Tasks::FTask& GetGPUSkinUpdateTask() const
    {
        return GPUSkinUpdateTask;
    }
 
    const UE::Tasks::FTask& GetGPUSkinCacheTask() const
    {
        return GPUSkinCacheTask;
    }
 
    void AddGPUSkinCacheAsyncComputeWait(FRDGBuilder& GraphBuilder) const;
 
    void WaitForCacheMeshDrawCommandsTask()
    {
        CSV_SCOPED_SET_WAIT_STAT(CacheMeshDrawCommands);
        CacheMeshDrawCommandsTask.Wait();
    }
 
    const UE::Tasks::FTask& GetCacheMeshDrawCommandsTask() const
    {
        return CacheMeshDrawCommandsTask;
    }
 
    void WaitForCacheNaniteMaterialBinsTask()
    {
        CSV_SCOPED_SET_WAIT_STAT(CacheNaniteMaterialBins);
        CacheNaniteMaterialBinsTask.Wait();
    }
 
    const UE::Tasks::FTask& GetCacheNaniteMaterialBinsTask() const
    {
        return CacheNaniteMaterialBinsTask;
    }
 
#if RHI_RAYTRACING
    void WaitForCacheRayTracingPrimitivesTask()
    {
        CSV_SCOPED_SET_WAIT_STAT(CacheRayTracingPrimitives);
        CacheRayTracingPrimitivesTask.Wait();
    }
 
    const UE::Tasks::FTask& GetCacheRayTracingPrimitivesTask()
    {
        return CacheRayTracingPrimitivesTask;
    }
#endif
 
    void LumenAddPrimitive(FPrimitiveSceneInfo* InPrimitive);
    void LumenUpdatePrimitive(FPrimitiveSceneInfo* InPrimitive);
    void LumenInvalidateSurfaceCacheForPrimitive(FPrimitiveSceneInfo* InPrimitive);
    void LumenRemovePrimitive(FPrimitiveSceneInfo* InPrimitive, int32 PrimitiveIndex);
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    void DebugRender(TArrayView<FViewInfo> Views);
#endif
 
    template<typename TExtension>
    TExtension* GetExtensionPtr() { return SceneExtensions.GetExtensionPtr<TExtension>(); }
    template<typename TExtension>
    const TExtension* GetExtensionPtr() const { return SceneExtensions.GetExtensionPtr<TExtension>(); }
    template<typename TExtension>
    TExtension& GetExtension() { return SceneExtensions.GetExtension<TExtension>(); }
    template<typename TExtension>
    const TExtension& GetExtension() const { return SceneExtensions.GetExtension<TExtension>(); }
 
    virtual bool AddCustomRenderPass(const FSceneViewFamily* ViewFamily, const FCustomRenderPassRendererInput& CustomRenderPassInput);
 
    class FInstanceCullingOcclusionQueryRenderer* InstanceCullingOcclusionQueryRenderer = nullptr;
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FSceneLightSceneInfoUpdateDelegate, FRDGBuilder& , const FLightSceneChangeSet&);
    FSceneLightSceneInfoUpdateDelegate OnPreLightSceneInfoUpdate;
    FSceneLightSceneInfoUpdateDelegate OnPostLightSceneInfoUpdate;
 
    void GetRelevantLights_RenderThread( const FPrimitiveSceneProxy* PrimitiveSceneProxy, TArray<const FLightSceneProxy*> &OutRelevantLights ) const;
 
    void UpdatePrimitiveTransform_RenderThread(FPrimitiveSceneProxy* PrimitiveSceneProxy, const FBoxSphereBounds& WorldBounds, const FBoxSphereBounds& LocalBounds, const FMatrix& LocalToWorld, const FVector& OwnerPosition, const TOptional<FTransform>& PreviousTransform);
 
    bool RequiresDebugMaterials() const { return PersistentViewStateDebugFlags != 0; }
 
    virtual void UpdatePrimitivesDrawnInGame_RenderThread(TArrayView<FPrimitiveSceneProxy*> PrimitiveSceneProxies, bool bDrawnInGame) override;
 
protected:
 
private:
    template<class T>   
    void BatchAddPrimitivesInternal(TArrayView<T*> InPrimitives);
 
    template<class T>   
    void BatchRemovePrimitivesInternal(TArrayView<T*> InPrimitives);
 
    template<class T>   
    void BatchReleasePrimitivesInternal(TArrayView<T*> InPrimitives);   
 
    template<class T>   
    void UpdatePrimitiveTransformInternal(T* Primitive);
 
    [[nodiscard]] virtual IPrimitiveTransformUpdater* CreatePrimitiveTransformUpdater(int32 MaxPrimitives) override;
    virtual void UpdatePrimitiveTransforms(IPrimitiveTransformUpdater* PrimitiveTransformUpdater) override;
    
    void RemoveViewLumenSceneData_RenderThread(FSceneViewStateInterface* ViewState);
    void RemoveViewState_RenderThread(FSceneViewStateInterface*);
 
    void CheckPrimitiveArrays(int MaxTypeOffsetIndex = -1);
 
    void AddPrimitiveSceneInfo_RenderThread(FPrimitiveSceneInfo* PrimitiveSceneInfo, const TOptional<FTransform>& PreviousTransform);
 
    void RemovePrimitiveSceneInfo_RenderThread(FPrimitiveSceneInfo* PrimitiveSceneInfo);
 
 
    void UpdatePrimitiveOcclusionBoundsSlack_RenderThread(const FPrimitiveSceneProxy* PrimitiveSceneProxy, float NewSlack);
 
    void UpdateCustomPrimitiveData(FPrimitiveSceneProxy* SceneProxy, const FCustomPrimitiveData& CustomPrimitiveData);
 
    void UpdatePrimitiveLightingAttachmentRoot(UPrimitiveComponent* Primitive);
 
    void AssignAvailableShadowMapChannelForLight(FLightSceneInfo* LightSceneInfo);
 
    void AddLightSceneInfo_RenderThread(FLightSceneInfo* LightSceneInfo);
 
    void AddOrRemoveDecal_RenderThread(FDeferredDecalProxy* Component, bool bAdd);
 
    void RemoveLightSceneInfo_RenderThread(FLightSceneInfo* LightSceneInfo);
 
    void UpdateLightTransform_RenderThread(int32 LightId, FLightSceneInfo* LightSceneInfo, const struct FUpdateLightTransformParameters& Parameters);
 
    void CaptureOrUploadReflectionCapture(UReflectionCaptureComponent* CaptureComponent, int32 ReflectionCaptureSize, bool bVerifyOnlyCapturing, bool bCapturingForMobile, bool bInsideTick);
 
    void UpdateAllReflectionCaptures(const TCHAR* CaptureReason, int32 ReflectionCaptureSize, bool bVerifyOnlyCapturing, bool bCapturingForMobile, bool bInsideTick);
 
    void UpdateStaticDrawLists_RenderThread(FRHICommandListImmediate& RHICmdList);
 
    void ApplyWorldOffset_RenderThread(FRHICommandListBase& RHICmdList, const FVector& InOffset);
 
    void ProcessAtmosphereLightRemoval_RenderThread(FLightSceneInfo* LightSceneInfo);
    void ProcessAtmosphereLightAddition_RenderThread(FLightSceneInfo* LightSceneInfo);
 
    void UpdateLights(FRDGBuilder& GraphBuilder, FSceneExtensionsUpdaters& SceneExtensionsUpdaters);
 
private:
    template <typename UpdatePayloadType>
    void UpdatePrimitiveInternal(FPrimitiveSceneProxy* SceneProxy, UpdatePayloadType &&InUpdatePayload);
 
    template <typename UpdatePayloadType>
    void UpdateLightInternal(FLightSceneProxy* LightSceneProxy, UpdatePayloadType &&InUpdatePayload);
 
    template <typename UpdatePayloadType>
    void UpdateLightInternal_RenderThread(FLightSceneProxy* LightSceneProxy, UpdatePayloadType&& InUpdatePayload);
 
    void UpdateCachedShadowState(const FScenePreUpdateChangeSet &ScenePreUpdateChangeSet, const FScenePostUpdateChangeSet &ScenePostUpdateChangeSet);
 
    FString FullWorldName;
#if RHI_RAYTRACING
    void UpdateRayTracingGroupBounds_AddPrimitives(const TArray<FPrimitiveSceneInfo*, SceneRenderingAllocator>& PrimitiveSceneInfos);
    void UpdateRayTracingGroupBounds_RemovePrimitives(const TArray<FPrimitiveSceneInfo*, SceneRenderingAllocator>& PrimitiveSceneInfos);
    template<typename RangeType>
    inline void UpdateRayTracingGroupBounds_UpdatePrimitives(const RangeType& UpdatedTransforms);
#endif
 
    void UpdatePrimitiveInstances(FUpdateInstanceCommand& UpdateParams);
 
    struct FLevelCommand
    {
        enum class EOp
        {
            Add,
            Remove
        };
 
        FName Name;
        EOp Op;
    };
 
    FScenePrimitiveUpdates PrimitiveUpdates;
    TArray<FLevelCommand> LevelCommands;
 
    UE::Tasks::FTask CreateLightPrimitiveInteractionsTask;
    UE::Tasks::FTask GPUSkinUpdateTask;
    UE::Tasks::FTask GPUSkinCacheTask;
    UE::Tasks::FTask CacheMeshDrawCommandsTask;
    UE::Tasks::FTask CacheNaniteMaterialBinsTask;
#if RHI_RAYTRACING
    UE::Tasks::FTask CacheRayTracingPrimitivesTask;
#endif
 
    FSceneLightInfoUpdates *SceneLightInfoUpdates;
 
    uint64 PersistentViewStateDebugFlags;
 
    int32 NumVisibleLights_GameThread;
 
    int32 NumEnabledSkylights_GameThread;
 
    uint32 SceneFrameNumber;
    uint32 SceneFrameNumberRenderThread;
 
    uint32 LastUpdateFrameCounter = UINT32_MAX;
 
    bool bForceNoPrecomputedLighting;
 
    friend class FSceneViewState;
};
 
inline bool ShouldIncludeDomainInMeshPass(EMaterialDomain Domain)
{
    // Non-Surface domains can be applied to static meshes for thumbnails or material editor preview
    // Volume domain materials however must only be rendered in the voxelization pass
    return Domain != MD_Volume;
}