LumenSceneData.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Containers/BinaryHeap.h"
#include "Containers/SparseArray.h"
#include "Experimental/Containers/RobinHoodHashTable.h"
#include "Lumen/Lumen.h"
#include "Lumen/LumenHeightfields.h"
#include "Lumen/LumenSparseSpanArray.h"
#include "Lumen/LumenSceneGPUDrivenUpdate.h"
#include "Lumen/LumenSurfaceCacheFeedback.h"
#include "Lumen/LumenUniqueList.h"
#include "LumenDefinitions.h"
#include "MeshCardRepresentation.h"
#include "RenderTransform.h"
#include "ShaderParameterMacros.h"
#include "UnifiedBuffer.h"
#include "Tasks/Task.h"
#include "Math/DoubleFloat.h"
 
enum class ELumenReflectionPass
{
    Opaque,
    SingleLayerWater,
    FrontLayerTranslucency,
 
    MAX
};
 
class FDistanceFieldSceneData;
class FLumenCardBuildData;
class FLumenCardPassUniformParameters;
class FLumenCardRenderer;
class FLumenMeshCards;
class FLumenViewState;
class FMeshCardsBuildData;
class FPrimitiveSceneInfo;
class FViewUniformShaderParameters;
class FRDGScatterUploadBuilder;
struct FLumenPageTableEntry;
 
BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT(FLumenCardScene, )
    SHADER_PARAMETER(uint32, NumCards)
    SHADER_PARAMETER(uint32, NumMeshCards)
    SHADER_PARAMETER(uint32, NumCardPages)
    SHADER_PARAMETER(uint32, NumHeightfields)
    SHADER_PARAMETER(uint32, NumPrimitiveGroups)
    SHADER_PARAMETER(FVector2f, PhysicalAtlasSize)
    SHADER_PARAMETER(FVector2f, InvPhysicalAtlasSize)
    SHADER_PARAMETER(float, IndirectLightingAtlasDownsampleFactor)
    SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer<float4>, CardData)
    SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer<float4>, CardPageData)
    SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer<float4>, MeshCardsData)
    SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer<float4>, HeightfieldData)
    SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer<float4>, PrimitiveGroupData)
    SHADER_PARAMETER_RDG_BUFFER_SRV(ByteAddressBuffer, PageTableBuffer)
    SHADER_PARAMETER_RDG_BUFFER_SRV(ByteAddressBuffer, SceneInstanceIndexToMeshCardsIndexBuffer)
    SHADER_PARAMETER_RDG_TEXTURE(Texture2D, AlbedoAtlas)
    SHADER_PARAMETER_RDG_TEXTURE(Texture2D, OpacityAtlas)
    SHADER_PARAMETER_RDG_TEXTURE(Texture2D, NormalAtlas)
    SHADER_PARAMETER_RDG_TEXTURE(Texture2D, EmissiveAtlas)
    SHADER_PARAMETER_RDG_TEXTURE(Texture2D, DepthAtlas)
END_GLOBAL_SHADER_PARAMETER_STRUCT()
 
BEGIN_SHADER_PARAMETER_STRUCT(FLumenLandscapeHeightSamplingParameters, )
    SHADER_PARAMETER_SRV(Texture2D, HeightVirtualTexture)
    SHADER_PARAMETER_TEXTURE(Texture2D<uint4>, HeightVirtualTexturePageTable)
    SHADER_PARAMETER_TEXTURE(Texture2D<uint>, HeightVirtualTexturePageTableIndirection)
    SHADER_PARAMETER(uint32, HeightVirtualTextureAdaptive)
    SHADER_PARAMETER_SAMPLER(SamplerState, HeightVirtualTextureSampler)
    SHADER_PARAMETER(FVector3f, HeightVirtualTextureLWCTile)
    SHADER_PARAMETER(FMatrix44f, HeightVirtualTextureWorldToUVTransform)
    SHADER_PARAMETER(uint32, HeightVirtualTextureEnabled)
    SHADER_PARAMETER(FUintVector4, HeightVirtualTexturePackedUniform0)
    SHADER_PARAMETER(FUintVector4, HeightVirtualTexturePackedUniform1)
    SHADER_PARAMETER(FUintVector4, HeightVirtualTextureUniforms)
END_SHADER_PARAMETER_STRUCT()
 
namespace Lumen
{
    constexpr uint32 FeedbackBufferElementStride = 2;
 
    uint32 GetFeedbackBufferSize(const FViewFamilyInfo& ViewFamily);
    uint32 GetCompactedFeedbackBufferSize();
 
    bool SetLandscapeHeightSamplingParameters(const FVector& LumenSceneViewOrigin, const FScene* Scene, FLumenLandscapeHeightSamplingParameters& OutParameters);
};
 
union FLumenCardId
{
    static constexpr uint64 InvalidPackedValue = -1;
 
    uint64 PackedValue;
    struct
    {
        uint32 ResLevelBiasX : 4;
        uint32 ResLevelBiasY : 4;
        uint32 AxisAlignedDirectionIndex : 3;
        uint32 Unused : 21;
        uint32 CustomId;
    };
 
    FLumenCardId() = default;
 
    FLumenCardId(uint32 InCustomId, uint8 InAxisAlignedDirectionIndex, uint8 InResLevelBiasX, uint8 InResLevelBiasY)
    {
        if (InCustomId != UINT32_MAX)
        {
            check(InAxisAlignedDirectionIndex <= 7u && InResLevelBiasX <= 15u && InResLevelBiasY <= 15u);
            CustomId = InCustomId;
            Unused = 0;
            AxisAlignedDirectionIndex = InAxisAlignedDirectionIndex;
            ResLevelBiasX = InResLevelBiasX;
            ResLevelBiasY = InResLevelBiasY;
        }
        else
        {
            Invalidate();
        }
    }
 
    bool operator<(const FLumenCardId& Other) const
    {
        return PackedValue < Other.PackedValue;
    }
 
    bool operator<=(const FLumenCardId& Other) const
    {
        return PackedValue <= Other.PackedValue;
    }
 
    bool operator==(const FLumenCardId& Other) const
    {
        return PackedValue == Other.PackedValue;
    }
 
    bool operator!=(const FLumenCardId& Other) const
    {
        return PackedValue != Other.PackedValue;
    }
 
    bool IsValid() const
    {
        return PackedValue != InvalidPackedValue;
    }
 
    void Invalidate()
    {
        PackedValue = InvalidPackedValue;
    }
 
    static constexpr FLumenCardId GetInvalidId()
    {
        FLumenCardId Id;
        Id.PackedValue = InvalidPackedValue;
        return Id;
    }
};
 
static_assert(sizeof(FLumenCardId) == sizeof(uint64), "Unexpected size of FLumenCardId");
 
inline uint32 GetTypeHash(const FLumenCardId& Key)
{
    return GetTypeHash(Key.PackedValue);
}
 
struct FLumenCardSharingInfo
{
    uint32 CardIndex : 27;
    uint32 MinAllocatedResLevel : 4;
    uint32 bAxisXFlipped : 1;
 
    FLumenCardSharingInfo() = default;
 
    FLumenCardSharingInfo(uint32 InCardIndex, uint8 InMinAllocatedResLevel, bool bInAxisXFlipped)
        : CardIndex(InCardIndex)
        , MinAllocatedResLevel(InMinAllocatedResLevel)
        , bAxisXFlipped(bInAxisXFlipped)
    {}
};
 
struct FLumenCardSharingInfoPendingRemove
{
    FLumenCardId CardId;
    int32 CardSharingListIndex;
 
    FLumenCardSharingInfoPendingRemove() = default;
 
    FLumenCardSharingInfoPendingRemove(FLumenCardId InCardId, int32 InCardSharingListIndex)
        : CardId(InCardId)
        , CardSharingListIndex(InCardSharingListIndex)
    {}
 
    bool operator<(const FLumenCardSharingInfoPendingRemove& Other) const
    {
        if (CardId == Other.CardId)
        {
            return CardSharingListIndex < Other.CardSharingListIndex;
        }
        return CardId < Other.CardId;
    }
};
 
struct FLumenCardSharingInfoPendingAdd
{
    FLumenCardId CardId;
    int32 CardIndex;
    uint8 MinAllocatedResLevel;
    bool bAxisXFlipped;
 
    FLumenCardSharingInfoPendingAdd() = default;
 
    FLumenCardSharingInfoPendingAdd(FLumenCardId InCardId, int32 InCardIndex, uint8 InMinAllocatedResLevel, bool bInAxisXFlipped)
        : CardId(InCardId)
        , CardIndex(InCardIndex)
        , MinAllocatedResLevel(InMinAllocatedResLevel)
        , bAxisXFlipped(bInAxisXFlipped)
    {}
 
    bool operator<(const FLumenCardSharingInfoPendingAdd& Other) const
    {
        if (CardId == Other.CardId)
        {
            if (MinAllocatedResLevel == Other.MinAllocatedResLevel)
            {
                return CardIndex < Other.CardIndex;
            }
            return MinAllocatedResLevel > Other.MinAllocatedResLevel;
        }
        return CardId < Other.CardId;
    }
};
 
struct FLumenSurfaceMipMap
{
    uint8 SizeInPagesX = 0;
    uint8 SizeInPagesY = 0;
    uint8 ResLevelX = 0;
    uint8 ResLevelY = 0;
 
    int32 PageTableSpanOffset = -1;
    uint16 PageTableSpanSize = 0;
    bool bLocked = false;
 
    bool IsAllocated() const
    {
        return PageTableSpanSize > 0;
    }
 
    FIntPoint GetSizeInPages() const
    {
        return FIntPoint(SizeInPagesX, SizeInPagesY);
    }
 
    int32 GetPageTableIndex(int32 LocalPageIndex) const
    {
        return PageTableSpanOffset + LocalPageIndex;
    }
};
 
struct FLumenMipMapDesc
{
    FIntPoint Resolution;
    FIntPoint SizeInPages;
    FIntPoint PageResolution;
    uint16 ResLevelX;
    uint16 ResLevelY;
    bool bSubAllocation;
};
 
class FLumenCard
{
public:
    FLumenCard();
    ~FLumenCard();
 
    FLumenCardOBBf LocalOBB;
    FLumenCardOBBd WorldOBB;
    FLumenCardOBBf MeshCardsOBB;
 
    bool bVisible = false;
    bool bHeightfield = false;
    bool bAxisXFlipped = false;
 
    ELumenCardDilationMode DilationMode = ELumenCardDilationMode::Disabled;
 
    // First and last allocated mip map
    uint8 MinAllocatedResLevel = UINT8_MAX;
    uint8 MaxAllocatedResLevel = 0;
 
    // Requested res level based on distance. Actual allocated res level may be lower if atlas is out of space.
    uint8 DesiredLockedResLevel = 0;
 
    // Surface cache allocations per mip map, indexed by [ResLevel - Lumen::MinResLevel]
    FLumenSurfaceMipMap SurfaceMipMaps[Lumen::NumResLevels];
 
    int32 MeshCardsIndex = -1;
    int32 IndexInMeshCards = -1;
    uint8 IndexInBuildData = UINT8_MAX;
    uint8 AxisAlignedDirectionIndex = UINT8_MAX;
    float ResolutionScale = 1.0f;
 
    // Initial WorldOBB.Extent.X / WorldOBB.Extent.Y, which can't change during reallocation
    float CardAspect = 1.0f;
 
    FLumenCardId CardSharingId = FLumenCardId::GetInvalidId();
    int32 CardSharingListIndex = INDEX_NONE;
 
    void Initialize(
        float InResolutionScale,
        uint32 CustomId,
        const FMatrix& LocalToWorld,
        const FLumenMeshCards& InMeshCardsInstance,
        const FLumenCardBuildData& CardBuildData,
        int32 InIndexInMeshCards,
        int32 InMeshCardsIndex,
        uint8 InIndexInBuildData);
 
    void SetTransform(const FMatrix& LocalToWorld, const FLumenMeshCards& MeshCards);
 
    void UpdateMinMaxAllocatedLevel();
 
    bool IsAllocated() const
    {
        return MinAllocatedResLevel <= MaxAllocatedResLevel;
    }
 
    struct FSurfaceStats
    {
        uint32 NumVirtualTexels = 0;
        uint32 NumLockedVirtualTexels = 0;
        uint32 NumPhysicalTexels = 0;
        uint32 NumLockedPhysicalTexels = 0;
        uint32 DroppedResLevels = 0;
    };
 
    void GetSurfaceStats(const TSparseSpanArray<FLumenPageTableEntry>& PageTable, FSurfaceStats& Stats) const;
 
    FLumenSurfaceMipMap& GetMipMap(int32 ResLevel)
    {
        const int32 MipIndex = ResLevel - Lumen::MinResLevel;
        check(MipIndex >= 0 && MipIndex < UE_ARRAY_COUNT(SurfaceMipMaps));
        return SurfaceMipMaps[MipIndex]; 
    }
 
    FIntPoint ResLevelToResLevelXYBias() const;
    void GetMipMapDesc(int32 ResLevel, FLumenMipMapDesc& Desc) const;
 
    const FLumenSurfaceMipMap& GetMipMap(int32 ResLevel) const
    {
        const int32 MipIndex = ResLevel - Lumen::MinResLevel;
        check(MipIndex >= 0 && MipIndex < UE_ARRAY_COUNT(SurfaceMipMaps));
        return SurfaceMipMaps[MipIndex];
    }
};
 
class FLumenPrimitiveGroupRemoveInfo
{
public:
    FLumenPrimitiveGroupRemoveInfo(const FPrimitiveSceneInfo* InPrimitive, int32 InPrimitiveIndex);
 
    // Must not be dereferenced after creation, the primitive was removed from the scene and deleted
    // Value of the pointer is still useful for map lookups
    const FPrimitiveSceneInfo* Primitive;
 
    // Need to copy by value as this is a deferred remove and Primitive may be already destroyed
    int32 PrimitiveIndex;
    TArray<int32, TInlineAllocator<1>> LumenPrimitiveGroupIndices;
};
 
// Defines a group of scene primitives for a given LOD level 
class FLumenPrimitiveGroup
{
public:
    TArray<FPrimitiveSceneInfo*, TInlineAllocator<1>> Primitives;
    int32 PrimitiveInstanceIndex = -1;
    int32 MeshCardsIndex = -1;
    int32 HeightfieldIndex = -1;
    int32 PrimitiveCullingInfoIndex = INDEX_NONE;
    int32 InstanceCullingInfoIndex = INDEX_NONE;
    uint32 CustomId = UINT32_MAX;
    
    Experimental::FHashElementId RayTracingGroupMapElementId;
    float CardResolutionScale = 1.0f;
 
    uint8 bValidMeshCards : 1 = false;
    uint8 bFarField : 1 = false;
    uint8 bHeightfield : 1 = false;
    uint8 bEmissiveLightSource : 1 = false;
    uint8 bOpaqueOrMasked : 1 = true;
 
    uint8 bLandscape : 1 = false;
 
    uint8 LightingChannelMask = MAX_uint8;
 
    bool HasMergedInstances() const;
 
    bool HasMergedPrimitives() const
    {
        return RayTracingGroupMapElementId.IsValid();
    }
};
 
struct FLumenPrimitiveGroupCullingInfo
{
    uint32 bVisible : 1;
    uint32 bValidMeshCards : 1;
    uint32 bFarField : 1;
    uint32 bEmissiveLightSource : 1;
    uint32 bOpaqueOrMasked : 1;
    uint32 NumInstances : 27;
 
    union
    {
        int32 PrimitiveGroupIndex;
        int32 InstanceCullingInfoOffset;
    };
 
    FRenderBounds WorldSpaceBoundingBox; // LWC_TODO
 
    FLumenPrimitiveGroupCullingInfo() = default;
 
    FLumenPrimitiveGroupCullingInfo(const FRenderBounds& Bounds, const FLumenPrimitiveGroup& PrimitiveGroup, int32 InPrimitiveGroupIndex)
        : bVisible(false)
        , bValidMeshCards(PrimitiveGroup.bValidMeshCards)
        , bFarField(PrimitiveGroup.bFarField)
        , bEmissiveLightSource(PrimitiveGroup.bEmissiveLightSource)
        , bOpaqueOrMasked(PrimitiveGroup.bOpaqueOrMasked)
        , NumInstances(0)
        , PrimitiveGroupIndex(InPrimitiveGroupIndex)
        , WorldSpaceBoundingBox(Bounds)
    {}
 
    FLumenPrimitiveGroupCullingInfo(const FRenderBounds& Bounds, int32 InInstanceCullingInfoOffset, uint32 InNumInstances, bool bInFarField)
        : bVisible(false)
        , bValidMeshCards(false)
        , bFarField(bInFarField)
        , bEmissiveLightSource(false)
        , bOpaqueOrMasked(false)
        , NumInstances(InNumInstances)
        , InstanceCullingInfoOffset(InInstanceCullingInfoOffset)
        , WorldSpaceBoundingBox(Bounds)
    {}
};
 
struct FLumenPageTableEntry
{
    // Allocated physical page data
    FIntPoint PhysicalPageCoord = FIntPoint(-1, -1);
 
    // Allows to point to a sub-allocation inside a shared physical page
    FIntRect PhysicalAtlasRect;
 
    // Sampling data, can point to a coarser page
    uint32 SamplePageIndex = 0;
    uint16 SampleAtlasBiasX = 0;
    uint16 SampleAtlasBiasY = 0;
    uint16 SampleCardResLevelX = 0;
    uint16 SampleCardResLevelY = 0;
 
    // CardPage for atlas operations
    int32 CardIndex = -1;
    uint8 ResLevel = 0;
    FVector4f CardUVRect;
 
    FIntPoint SubAllocationSize = FIntPoint(-1, -1);
 
    bool IsSubAllocation() const
    {
        return SubAllocationSize.X >= 0 || SubAllocationSize.Y >= 0;
    }
 
    bool IsMapped() const 
    { 
        return PhysicalPageCoord.X >= 0 && PhysicalPageCoord.Y >= 0;
    }
 
    uint32 GetNumVirtualTexels() const
    {
        return IsSubAllocation() ? SubAllocationSize.X * SubAllocationSize.Y : Lumen::VirtualPageSize * Lumen::VirtualPageSize;
    }
 
    uint32 GetNumPhysicalTexels() const
    {
        return IsMapped() ? PhysicalAtlasRect.Area() : 0;
    }
};
 
class FSurfaceCacheRequest
{
public:
    int32 CardIndex = -1;
    uint16 ResLevel = 0;
    uint16 LocalPageIndex = UINT16_MAX;
    float Distance = 0.0f;
 
    bool IsLockedMip() const { return LocalPageIndex == UINT16_MAX; }
};
 
union FVirtualPageIndex
{
    FVirtualPageIndex() {}
    FVirtualPageIndex(int32 InCardIndex, uint16 InResLevel, uint16 InLocalPageIndex)
        : CardIndex(InCardIndex), ResLevel(InResLevel), LocalPageIndex(InLocalPageIndex)
    {}
 
    uint64 PackedValue;
    struct
    {
        int32 CardIndex;
        uint16 ResLevel;
        uint16 LocalPageIndex;
    };
};
 
// Physical page allocator, which routes sub page sized allocations to a bin allocator
class FLumenSurfaceCacheAllocator
{
public:
    struct FAllocation
    {
        // Allocated physical page data
        FIntPoint PhysicalPageCoord = FIntPoint(-1, -1);
 
        // Allows to point to a sub-allocation inside a shared physical page
        FIntRect PhysicalAtlasRect;
    };
 
    struct FBinStats
    {
        FIntPoint ElementSize = FIntPoint(0, 0);
        int32 NumAllocations = 0;
        int32 NumPages = 0;
    };
 
    struct FStats
    {
        uint32 NumFreePages = 0;
 
        uint32 BinNumPages = 0;
        uint32 BinNumWastedPages = 0;
        uint32 BinPageFreeTexels = 0;
 
        TArray<FBinStats> Bins;
    };
 
    void Init(const FIntPoint& InPageAtlasSizeInPages);
    void Allocate(const FLumenPageTableEntry& Page, FAllocation& Allocation);
    void Free(const FLumenPageTableEntry& Page);
    bool IsSpaceAvailable(const FLumenCard& Card, int32 ResLevel, bool bSinglePage) const;
    void GetStats(FStats& Stats) const;
 
private:
 
    // Data structure overview
    // -----------------------
    // * The atlas is divided in to pages
    // * Each page is 128x128
    // * Each page can be divided into sub-allocation to hold smaller element size (e..g 8x8, 8x16, 8x32, ...)
    // 
    // * Card elements are allocated into these pages.
    // * Card elements are allocated into page with the correct sub-allocation size
    //
    // Data structures:
    // * FPageBin -           Holds reference to all the page allocations for a given element size. Due to this, there is at max. 64 FPageBin E.g.:
    //                           * 1 FPageBin for 8x8 allocation, 
    //                           * 1 FPageBin for 8x16 allocation, 
    //                           * 1 FPageBin for 8x32 allocation,
    //                           * ...  
    //                        A PageBin holds reference to several PageBinAllocation, one per physical page. There can be a large quantity of FPageBinAllocation
    // * FPageBinAllocation - Tracks the sub-allocation within a single physical page. A physical page (128x128) will be broken into 32x32 sub-allocation for
    //                        an element size of 8x8. The sub-allocation is tracked with a bitfield to indicate which slot is available or not
    // * FPageBinLookup -     Lookup table to fast retrivable of FPageBin based on the desired element size. The lookup is a 8x8 table, so there is at max 64 FPageBin
    struct FPageBinAllocation
    {
    public:
        void Init(const FIntPoint& InPageCoord, const FIntPoint& InPageSizeInElements)
        {
            static_assert(Lumen::MinResLevel == 3);
            static_assert(Lumen::PhysicalPageSize == 128);
 
            PageCoord = InPageCoord;
            PageSizeInElements = InPageSizeInElements;
            SubPageFreeCount = InPageSizeInElements.X * InPageSizeInElements.Y;
            SubPageList.SetNum(SubPageFreeCount, false);
        }
 
        FIntPoint Add()
        {
            const int32 Index = SubPageList.FindAndSetFirstZeroBit();
            checkSlow(Index != INDEX_NONE);
            --SubPageFreeCount;
            return FIntPoint(Index % PageSizeInElements.X, Index / PageSizeInElements.X);
        }
 
        void Remove(const FIntPoint& In)
        {
            const int32 Index = In.X + PageSizeInElements.X * In.Y;
            checkSlow(SubPageList.IsValidIndex(Index));
            ++SubPageFreeCount;
            SubPageList[Index] = false;
        }
 
        uint32 GetSubPageFreeCount() const
        {
            return SubPageFreeCount;
        }
 
        bool HasFreeElements() const
        {
            return SubPageFreeCount > 0;
        }
 
        bool IsEmpty() const
        {
            return SubPageFreeCount == PageSizeInElements.X * PageSizeInElements.Y;
        }
 
        FIntPoint PageCoord;
        FIntPoint PageSizeInElements;
    private:
        // 256 bits for storing sub-page elements
        // * MinPage size is 2^Lumen::MinResLevel=8
        // * Physical page is Lumen::PhysicalPageSize=128
        // * Max sub-allocation within a physical page is (128/8)^2 = 16x16 = 256
        // Values -> 0:free 1:used
        TBitArray<TInlineAllocator<8>> SubPageList;
        int32 SubPageFreeCount = 0;
    };
    
    // There is only a single FPageBin per element size (8x8, 8x16, 8x32, 8x64, 128x64)
    // At max there should be 64 FPageBin elements
    struct FPageBin
    {
        FPageBin(const FIntPoint& InElementSize);
 
        int32 GetSubPageCount() const
        {
            return PageSizeInElements.X * PageSizeInElements.Y;
        }
 
        uint32 GetBinAllocationCount() const
        {
            return BinAllocations.Num();
        }
 
        uint32 GetSubPageFreeCount() const
        {
            uint32 Count = 0;
            for (auto& BinAllocation : BinAllocations)
            {
                Count += BinAllocation.GetSubPageFreeCount();
            }
            return Count;
        }
 
        bool HasFreeElements() const
        {
            // Ideally, make a 0(1) lookup for this
            for (auto& BinAllocation : BinAllocations)
            {
                if (BinAllocation.HasFreeElements())
                {
                    return true;
                }
            }
            return false;
        }
 
        FPageBinAllocation* GetBinAllocation()
        {
            // Ideally, make a 0(1) lookup for this
            for (auto& BinAllocation : BinAllocations)
            {
                if (BinAllocation.HasFreeElements())
                {
                    return &BinAllocation;
                }
            }
            return nullptr;
        }
 
        FPageBinAllocation* AddBinAllocation(const FIntPoint& InPageCoord)
        {
            FPageBinAllocation& NewBinAllocation = BinAllocations.AddDefaulted_GetRef();
            NewBinAllocation.Init(InPageCoord, PageSizeInElements);
            return &NewBinAllocation;
        }
 
        // Return true if the bin is now completely empty (and can be deleted), false otherwise.
        bool RemoveBinAllocation(const FLumenPageTableEntry& Page)
        {
            // Ideally, make a 0(1) lookup for this
            for (uint32 BinAllocIt = 0, BinAllocCount = BinAllocations.Num(); BinAllocIt < BinAllocCount; ++BinAllocIt)
            {
                FPageBinAllocation& BinAllocation = BinAllocations[BinAllocIt];
                if (BinAllocation.PageCoord == Page.PhysicalPageCoord)
                {
                    const FIntPoint ElementCoord = (Page.PhysicalAtlasRect.Min - BinAllocation.PageCoord * Lumen::PhysicalPageSize) / ElementSize;
                    BinAllocation.Remove(ElementCoord);
                    const bool bIsEmpty = BinAllocation.IsEmpty();
                    if (bIsEmpty)
                    {
                        BinAllocations.RemoveAtSwap(BinAllocIt);
                    }
                    return bIsEmpty;
                }
            }
            check(false); // Shouldn't reach this
            return false;
        }
 
        FIntPoint ElementSize = FIntPoint(0, 0);
        FIntPoint PageSizeInElements = FIntPoint(0, 0);
    private:
        TArray<FPageBinAllocation, TInlineAllocator<16>> BinAllocations;
    };
 
    // Physical pages
    FIntPoint AllocatePhysicalAtlasPage();
    void FreePhysicalAtlasPage(const FIntPoint& PageCoord);
    // Stored into a bitfield (0:free,1:used)
    // Mapping from page coord to bit is using simple linear remapping
    TBitArray<TInlineAllocator<32>> PhysicalPageList;
    int32 PhysicalPageFreeCount = 0;
    FIntPoint PageAtlasSizeInPages = FIntPoint::ZeroValue;
    
    TArray<FPageBin> PageBins;
 
    // Bin lookups are stored as 2D mapping (8x8 - [1-128]x[1-128])
    // This mapping indexes PageX dim. and PageY dim.
    // As an example, a 8x16 SubPage allocator will be stored at [3,4] (i.e., [log2(8),log2(16)] )
    //          0 1 2 3 4  5  6   7
    //          --------------------
    //          1 2 4 8 16 32 64 128
    // 0 |   1
    // 1 |   2    X
    // 2 |   4
    // 3 |   8        X
    // 4 |  16
    // 5 |  32      X
    // 6 |  64                X
    // 7 | 128
    static const uint8 InvalidPageBinIndex = 0xFF;
    typedef TStaticArray<uint8, 64u> FPageBinLookup;
    FPageBinLookup PageBinLookup;
    bool bInitPageBinLookup = true;
 
    uint8 GetLookupIndex(const FIntPoint& InRes) const
    {
        checkSlow(FMath::IsPowerOfTwo(InRes.X) && FMath::IsPowerOfTwo(InRes.Y));
        checkSlow(InRes.X <= Lumen::PhysicalPageSize && InRes.Y <= Lumen::PhysicalPageSize);
        const uint32 OutIndex = FMath::FloorLog2(InRes.X) + FMath::FloorLog2(InRes.Y) * 8u;
        //check(OutIndex < 64u);
        return (uint8)OutIndex;
    }
 
    const FPageBin* GetBin(const FIntPoint& InRes) const
    {
        const uint8 LookupIndex = GetLookupIndex(InRes);
        const uint8 BinIndex = PageBinLookup[LookupIndex];
        if (BinIndex != InvalidPageBinIndex)
        {
            return &PageBins[BinIndex];
        }
        return nullptr;
    }
 
    FPageBin* GetBin(const FIntPoint& InRes)
    {
        const uint8 LookupIndex = GetLookupIndex(InRes);
        const uint8 BinIndex = PageBinLookup[LookupIndex];
        if (BinIndex != InvalidPageBinIndex)
        {
            return &PageBins[BinIndex];
        }
        return nullptr;
    }
 
    FPageBin* GetOrAddBin(const FIntPoint& InRes)
    {
        const uint8 LookupIndex = GetLookupIndex(InRes);
        const uint8 BinIndex = PageBinLookup[LookupIndex];
        if (BinIndex == InvalidPageBinIndex)
        {
            PageBinLookup[LookupIndex] = PageBins.Num();
            PageBins.Add(FPageBin(InRes));
 
            // There can't be more than 64 PageBins, as the sub-allocation resolution within 
            // a 128x128 physical page is bound to 64 (8x8, 8x16, 8x32, ..., 128x64, 128x128).
            check(PageBins.Num() <= 64);
            return &PageBins.Last();
        }
        else
        {
            return &PageBins[BinIndex];
        }
    }
};
 
enum class ESurfaceCacheCompression : uint8
{
    Disabled,
    UAVAliasing,
    CopyTextureRegion,
    FramebufferCompression
};
 
ESurfaceCacheCompression GetSurfaceCacheCompression();
 
class FLumenSharedRT
{
public:
    FRDGTextureRef CreateSharedRT(FRDGBuilder& Builder, const FRDGTextureDesc& Desc, FIntPoint VisibleExtent, const TCHAR* Name, ERDGTextureFlags Flags = ERDGTextureFlags::None);
    
    FRDGTextureRef GetRenderTarget() const
    {
        return RenderTarget;
    }
 
private:
    FRDGTextureRef RenderTarget = nullptr;
};
 
// Unique view origin.  Typically one per view, but for the case of cube captures, a single view origin is shared.
// The advantage of sharing an origin is that Lumen scene data can be shared and updated once.  In the future, we could
// allow origins to be shared for other use cases, such as nDisplay inner frustums, or imagine a sim with a wide angle
// view across three monitors, where the three views share an origin.
struct FLumenViewOrigin
{
    void Init(const FViewInfo& View);
 
    bool IsPerspectiveProjection() const
    {
        return OrthoMaxDimension == 0.0f;
    }
 
    const FSceneViewFamily* Family;
 
    FVector LumenSceneViewOrigin;
    FVector4f WorldCameraOrigin;
    FDFVector3 PreViewTranslationDF;
    
    // Matrix used for frustum clipping tests in Lumen.  For typical views, this is set to WorldToClip, while cube captures
    // have an omnidirectional projection, and use a trivial matrix that will pass any point as in-frustum.
    FMatrix44f FrustumTranslatedWorldToClip;
    FMatrix44f ViewToClip;
 
    float OrthoMaxDimension;                // If orthographic projection, max dimension, otherwise zero
    float LastEyeAdaptationExposure;        // Shared origin views share exposure
    float MaxTraceDistance;                 // Shared origin views share post process settings, which control these values
    float CardMaxDistance;
    float LumenSceneDetail;
 
    // Ideally this structure would contain a mirror of all view origin specific data, so Lumen scene updates don't end up with
    // dependencies on FViewInfo, but there are still some code paths that pull data from the FViewInfo structure, which are messy
    // to refactor.  So this reference view is included to allow fetching an FViewInfo to send to those code paths.
    // 
    // The first is the "GetDeferredLightParameters" utility function, which uses a bunch of data from the FViewInfo structure, which
    // will be invariant across shared origin views in practice.  This includes fields originally copied from CVars, post process
    // settings, and projection type.  In the future, we could add an API variation that takes those all values as loose parameters.
    //
    // The View uniform buffer is used to access some data assumed to be invariant for views that share an origin:
    //      View.StateFrameIndex            shared origin views are created on same frame and always render together
    //      View.StateFrameIndexMod8        ""
    //      View.PreExposure                shared origin views share exposure
    //      View.OneOverPreExposure         ""
    //
    // The Substrate global uniform buffer is accessed from FViewInfo, but doesn't include any view dependent data.  Looking at
    // InitialiseSubstrateViewData, it uses SceneTexturesConfig.Extent (as opposed to a view rect), and View.GetShaderPlatform().
    // The Substrate uniforms aren't initialized until mid render, while the view origin is created early in render.  We could
    // copy those into the Lumen view origin later, but it works well enough to grab it from the view when it's needed.
    //
    // Messier are the uses of FViewInfo in FDeferredShadingSceneRenderer::RenderDirectLightingForLumenScene, where view specific
    // forward lighting data, volumetric cloud shadows, ray tracing TLAS, miscellaneous post process settings, shader map, view
    // family, feature level, and FScene are referenced.  Basically a ton of stuff.  To share all that, we probably need to refactor
    // things so there is a formal concept of shared origin views (FViewSharedOrigin?) at a higher level in the scene renderer
    // itself.  Then we could pull all of the above into that structure.  But that goes well beyond the scope of adding Lumen support
    // for cube maps, which is the immediate goal.
    //
    // There may be rendering artifacts with forward lighting, volumetric cloud shadows, and ray tracing, given that the code that
    // generates those may not be completely shared origin view friendly.  Forward lighting pulls in lights from the frustum, so that
    // definitely seems like it should be modified to take into account the frustums of all shared origin views.  It's less clear if
    // volumetric cloud shadows and ray tracing are view direction or just view origin aware (offhand, they look origin aware, but I
    // haven't done a deep dive).
    //
    const FViewInfo* ReferenceView;
};
 
// Temporaries valid only in a single frame
struct FLumenSceneFrameTemporaries
{
    FLumenSceneFrameTemporaries(const TArray<FViewInfo>& Views);
 
    // Current frame's buffers for writing feedback
    FLumenSurfaceCacheFeedback::FFeedbackResources SurfaceCacheFeedbackResources;
 
    FRDGTextureRef AlbedoAtlas = nullptr;
    FRDGTextureRef OpacityAtlas = nullptr;
    FRDGTextureRef NormalAtlas = nullptr;
    FRDGTextureRef EmissiveAtlas = nullptr;
    FRDGTextureRef DepthAtlas = nullptr;
 
    FRDGTextureRef DirectLightingAtlas = nullptr;
    FRDGTextureRef IndirectLightingAtlas = nullptr;
    FRDGTextureRef RadiosityNumFramesAccumulatedAtlas = nullptr;
    FRDGTextureRef FinalLightingAtlas = nullptr;
    FRDGBufferRef TileShadowDownsampleFactorAtlas = nullptr;
    FRDGTextureRef DiffuseLightingAndSecondMomentHistoryAtlas = nullptr;
    FRDGTextureRef NumFramesAccumulatedHistoryAtlas = nullptr;
 
    FRDGBufferSRV* CardBufferSRV = nullptr;
    FRDGBufferSRV* MeshCardsBufferSRV = nullptr;
    FRDGBufferSRV* HeightfieldBufferSRV = nullptr;
    FRDGBufferSRV* PrimitiveGroupBufferSRV = nullptr;
    FRDGBufferSRV* SceneInstanceIndexToMeshCardsIndexBufferSRV = nullptr;
    FRDGBufferSRV* PageTableBufferSRV = nullptr;
    FRDGBufferSRV* CardPageBufferSRV = nullptr;
    FRDGBufferUAV* CardPageBufferUAV = nullptr;
 
    FRDGBufferUAV* CardPageLastUsedBufferUAV = nullptr;
    FRDGBufferSRV* CardPageLastUsedBufferSRV = nullptr;
 
    FRDGBufferUAV* CardPageHighResLastUsedBufferUAV = nullptr;
    FRDGBufferSRV* CardPageHighResLastUsedBufferSRV = nullptr;
 
    TRDGUniformBufferRef<FLumenCardScene> LumenCardSceneUniformBuffer = nullptr;
 
    FRHIGPUBufferReadback* SceneAddOpsReadbackBuffer = nullptr;
    FRHIGPUBufferReadback* SceneRemoveOpsReadbackBuffer = nullptr;
    FRHIGPUBufferReadback* SurfaceCacheFeedbackBuffer = nullptr;
 
    UE::Tasks::FTask UpdateSceneTask;
    bool bReallocateAtlas = false;
 
    TArray<FLumenViewOrigin, TFixedAllocator<LUMEN_MAX_VIEWS>> ViewOrigins;
 
    FIntPoint ViewExtent;
    
    // Targets shared per view, but can't be shared per pass
    FLumenSharedRT ReflectSpecularIndirect[(uint32)ELumenReflectionPass::MAX];
    FLumenSharedRT ReflectNumHistoryFrames[(uint32)ELumenReflectionPass::MAX];
    FLumenSharedRT ReflectResolveVariance[(uint32)ELumenReflectionPass::MAX];
 
    FLumenSharedRT DiffuseIndirect;
    FLumenSharedRT LightIsMoving;
    FLumenSharedRT BackfaceDiffuseIndirect;
    FLumenSharedRT RoughSpecularIndirect;
    FLumenSharedRT ResolveVariance;
    FLumenSharedRT NewDiffuseIndirect;
    FLumenSharedRT NewBackfaceDiffuseIndirect;
    FLumenSharedRT NewRoughSpecularIndirect;
    FLumenSharedRT NewHistoryFastUpdateMode_NumFramesAccumulated;
    FLumenSharedRT NewResolveVariance;
    FLumenSharedRT DepthHistory;
    FLumenSharedRT NormalHistory;
 
    FLumenSharedRT ReservoirRayDirection;
    FLumenSharedRT ReservoirTraceRadiance;
    FLumenSharedRT ReservoirTraceHitDistance;
    FLumenSharedRT ReservoirTraceHitNormal;
    FLumenSharedRT ReservoirWeights;
    FLumenSharedRT DownsampledSceneDepth2x1;
    FLumenSharedRT DownsampledWorldNormal2x1;
    FLumenSharedRT DownsampledSceneDepth2x2;
    FLumenSharedRT DownsampledWorldNormal2x2;
 
    FLumenSharedRT LumenTileBitmask;
    FLumenSharedRT MegaLightsTileBitmask;
 
    FLumenSharedRT EncodedReprojectionVector;
    FLumenSharedRT LumenPackedPixelData;
    FLumenSharedRT MegaLightsPackedPixelData;
 
    // Optional debug data enabled with stats visualization
    // Contains cursor point cards information
    FRDGBufferSRVRef DebugData = nullptr;
};
 
// Tracks scene-wide lighting state whose changes we should propagate quickly by flushing various lighting caches
class FLumenGlobalLightingState
{
public:
    FLinearColor DirectionalLightColor;
    FLinearColor SkyLightColor;
    bool bDirectionalLightValid;
    bool bSkyLightValid;
 
    FLumenGlobalLightingState()
    {
        DirectionalLightColor = FLinearColor::Black;
        SkyLightColor = FLinearColor::Black;
        bDirectionalLightValid = false;
        bSkyLightValid = false;
    }
};
 
class FLumenSceneData
{
public:
    // Clear all cached state like surface cache atlas. Including extra state like final lighting. Used only for debugging.
    bool bDebugClearAllCachedState = false;
 
    // Whether we allow sharing cards between primitive groups
    bool bAllowCardSharing = false;
    // Whether we allow cards to downsample from self when lowering resolutions
    bool bAllowCardDownsampleFromSelf = false;
 
    // Whether we should re-upload entire Lumen Scene on next update
    bool bReuploadSceneRequest = false;
 
    TSparseSpanArray<FLumenCard> Cards;
    FUniqueIndexList CardIndicesToUpdateInBuffer;
    TRefCountPtr<FRDGPooledBuffer> CardBuffer;
    FRDGAsyncScatterUploadBuffer CardUploadBuffer;
 
    // Primitive groups
    FUniqueIndexList PrimitiveGroupIndicesToUpdateInBuffer;
    TChunkedSparseArray<FLumenPrimitiveGroup> PrimitiveGroups;
    TRefCountPtr<FRDGPooledBuffer> PrimitiveGroupBuffer;
    FRDGAsyncScatterUploadBuffer PrimitiveGroupUploadBuffer;
 
    // Maps RayTracingGroupId to a specific Primitive Group Index
    Experimental::TRobinHoodHashMap<int32, int32> RayTracingGroups;
 
    // List of landscape primitives added to the Lumen scene
    TArray<const FPrimitiveSceneInfo*> LandscapePrimitives;
 
    // Mesh Cards
    FUniqueIndexList MeshCardsIndicesToUpdateInBuffer;
    TSparseSpanArray<FLumenMeshCards> MeshCards;
    TSparseSpanArray<FLumenPrimitiveGroupCullingInfo> InstanceCullingInfos;
    TSparseArray<FLumenPrimitiveGroupCullingInfo> PrimitiveCullingInfos;
    TRefCountPtr<FRDGPooledBuffer> MeshCardsBuffer;
    FRDGAsyncScatterUploadBuffer MeshCardsUploadBuffer;
 
    // Heightfields
    FUniqueIndexList HeightfieldIndicesToUpdateInBuffer;
    TSparseSpanArray<FLumenHeightfield> Heightfields;
    TRefCountPtr<FRDGPooledBuffer> HeightfieldBuffer;
    FRDGAsyncScatterUploadBuffer HeightfieldUploadBuffer;
 
    // Page Table
    TSparseSpanArray<FLumenPageTableEntry> PageTable;
    TArray<int32> PageTableIndicesToUpdateInBuffer;
    TRefCountPtr<FRDGPooledBuffer> PageTableBuffer;
    FRDGAsyncScatterUploadBuffer PageTableUploadBuffer;
 
    // GPUScene instance index to MeshCards mapping
    FUniqueIndexList PrimitivesToUpdateMeshCards;
    TRefCountPtr<FRDGPooledBuffer> SceneInstanceIndexToMeshCardsIndexBuffer;
    FRDGAsyncScatterUploadBuffer SceneInstanceIndexToMeshCardsIndexUploadBuffer;
 
    // Single card tile per FLumenPageTableEntry. Used for various atlas update operations
    TRefCountPtr<FRDGPooledBuffer> CardPageBuffer;
    FRDGAsyncScatterUploadBuffer CardPageUploadBuffer;
 
    // Last frame index when this page was sampled from. Used to controlling page update rate
    TRefCountPtr<FRDGPooledBuffer> CardPageLastUsedBuffer;
    TRefCountPtr<FRDGPooledBuffer> CardPageHighResLastUsedBuffer;
 
    // Captured from the triangle scene
    TRefCountPtr<IPooledRenderTarget> AlbedoAtlas;
    TRefCountPtr<IPooledRenderTarget> OpacityAtlas;
    TRefCountPtr<IPooledRenderTarget> NormalAtlas;
    TRefCountPtr<IPooledRenderTarget> EmissiveAtlas;
    TRefCountPtr<IPooledRenderTarget> DepthAtlas;
 
    // Generated
    TRefCountPtr<IPooledRenderTarget> DirectLightingAtlas;
    TRefCountPtr<IPooledRenderTarget> IndirectLightingAtlas;
    TRefCountPtr<IPooledRenderTarget> RadiosityNumFramesAccumulatedAtlas;
    TRefCountPtr<IPooledRenderTarget> FinalLightingAtlas;
    TRefCountPtr<FRDGPooledBuffer> TileShadowDownsampleFactorAtlas;
 
    // Radiosity probes
    TRefCountPtr<IPooledRenderTarget> RadiosityTraceRadianceAtlas;
    TRefCountPtr<IPooledRenderTarget> RadiosityTraceHitDistanceAtlas;
    TRefCountPtr<IPooledRenderTarget> RadiosityProbeSHRedAtlas;
    TRefCountPtr<IPooledRenderTarget> RadiosityProbeSHGreenAtlas;
    TRefCountPtr<IPooledRenderTarget> RadiosityProbeSHBlueAtlas;
 
    // Direct lighting denoising
    TRefCountPtr<IPooledRenderTarget> DiffuseLightingAndSecondMomentHistoryAtlas;
    TRefCountPtr<IPooledRenderTarget> NumFramesAccumulatedHistoryAtlas;
 
    // Lumen Scene readback for handling GPU driven updates
    FLumenSceneReadback SceneReadback;
 
    // Virtual surface cache feedback
    FLumenSurfaceCacheFeedback SurfaceCacheFeedback;
 
    FLumenGlobalLightingState GlobalLightingState;
 
    bool bFinalLightingAtlasContentsValid;
    int32 NumMeshCardsToAdd = 0;
    int32 NumLockedCardsToUpdate = 0;
    int32 NumHiResPagesToAdd = 0;
 
    bool bTrackAllPrimitives;
    TSet<FPrimitiveSceneInfo*> PendingAddOperations;
    TSet<FPrimitiveSceneInfo*> PendingUpdateOperations;
    TSet<FPrimitiveSceneInfo*> PendingSurfaceCacheInvalidationOperations;
    TArray<FLumenPrimitiveGroupRemoveInfo> PendingRemoveOperations;
 
    // Scale factor to adjust atlas size for tuning memory usage
    float SurfaceCacheResolution = 1.0f;
 
    // Multi-view multi-GPU information
    bool bViewSpecific = false;
#if WITH_MGPU
    bool bViewSpecificMaskInitialized = false;
    FRHIGPUMask ViewSpecificMask;
#endif
 
    FLumenSceneData(EShaderPlatform ShaderPlatform, EWorldType::Type WorldType);
    FLumenSceneData(bool bInTrackAllPrimitives);
    ~FLumenSceneData();
 
    void UpdatePrimitiveInstanceOffset(int32 PrimitiveIndex);
    void ResetAndConsolidate();
 
    void AddMeshCards(int32 PrimitiveGroupIndex);
    void UpdateMeshCards(const FMatrix& LocalToWorld, int32 MeshCardsIndex, const FMeshCardsBuildData& MeshCardsBuildData);
    void InvalidateSurfaceCache(FRHIGPUMask GPUMask, int32 MeshCardsIndex);
    void RemoveMeshCards(int32 PrimitiveGroupIndex, bool bUpdateCullingInfo = true);
 
    void RemoveCardFromAtlas(int32 CardIndex);
 
    bool HasPendingOperations() const
    {
        return PendingAddOperations.Num() > 0 || PendingUpdateOperations.Num() > 0 || PendingRemoveOperations.Num() > 0;
    }
 
    void DumpStats(const FDistanceFieldSceneData& DistanceFieldSceneData, bool bDumpMeshDistanceFields, bool bDumpPrimitiveCullingInfos, bool bDumpPrimitiveGroups);
    bool UpdateAtlasSize();
    void ReleaseAtlas();
    void RemoveAllMeshCards();
    void UploadPageTable(FRDGBuilder& GraphBuilder, FRDGScatterUploadBuilder& UploadBuilder, FLumenSceneFrameTemporaries& FrameTemporaries);
 
    void FillFrameTemporaries(FRDGBuilder& GraphBuilder, FLumenSceneFrameTemporaries& FrameTemporaries);
 
    void AllocateCardAtlases(FRDGBuilder& GraphBuilder, FLumenSceneFrameTemporaries& FrameTemporaries, const FSceneViewFamily* ViewFamily);
    void ReallocVirtualSurface(FLumenCard& Card, int32 CardIndex, int32 ResLevel, bool bLockPages);
    void FreeVirtualSurface(FLumenCard& Card, uint8 FromResLevel, uint8 ToResLevel);
 
    void UpdateCardMipMapHierarchy(FLumenCard& Card);
 
    bool IsPhysicalSpaceAvailable(const FLumenCard& Card, int32 ResLevel, bool bSinglePage) const
    {
        return SurfaceCacheAllocator.IsSpaceAvailable(Card, ResLevel, bSinglePage);
    }
 
    void ForceEvictEntireCache();
    bool EvictOldestAllocation(uint32 MaxFramesSinceLastUsed, TSparseUniqueList<int32, SceneRenderingAllocator>& DirtyCards);
 
    uint32 GetSurfaceCacheUpdateFrameIndex() const;
    void IncrementSurfaceCacheUpdateFrameIndex();
 
    const FLumenPageTableEntry& GetPageTableEntry(int32 PageTableIndex) const { return PageTable[PageTableIndex]; }
    FLumenPageTableEntry& GetPageTableEntry(int32 PageTableIndex) { return PageTable[PageTableIndex]; }
    void MapSurfaceCachePage(const FLumenSurfaceMipMap& MipMap, int32 PageTableIndex, FRHIGPUMask GPUMask);
    int32 GetNumCardPages() const { return PageTable.Num(); }
    FIntPoint GetPhysicalAtlasSize() const { return PhysicalAtlasSize; }
    FIntPoint GetRadiosityAtlasSize() const;
    FIntPoint GetCardCaptureAtlasSizeInPages() const;
    FIntPoint GetCardCaptureAtlasSize() const;
    uint32 GetCardCaptureRefreshNumTexels() const;
    uint32 GetCardCaptureRefreshNumPages() const;
    ESurfaceCacheCompression GetPhysicalAtlasCompression() const { return PhysicalAtlasCompression; }
 
    struct FFeedbackData
    {
        const uint32* Data = nullptr;
        uint32 NumElements = 0;
    };
 
    void UpdateSurfaceCacheFeedback(FFeedbackData Data, const TArray<FVector, TInlineAllocator<2>>& LumenSceneCameraOrigins, TArray<FSurfaceCacheRequest>& MeshCardsUpdate, const FViewFamilyInfo& ViewFamily, int32 RequestHistogram[Lumen::NumDistanceBuckets]);
 
    void ProcessLumenSurfaceCacheRequests(
        const FViewInfo& MainView,
        float MaxCardUpdateDistanceFromCamera,
        int32 MaxTileCapturesPerFrame,
        FLumenCardRenderer& LumenCardRenderer,
        FRHIGPUMask GPUMask,
        const TArray<FSurfaceCacheRequest, SceneRenderingAllocator>& SurfaceCacheRequests);
 
    int32 GetMeshCardsIndex(const FPrimitiveSceneInfo* PrimitiveSceneInfo, int32 InstanceIndex) const;
 
    FLumenPrimitiveGroupCullingInfo& GetPrimitiveGroupCullingInfo(const FLumenPrimitiveGroup& PrimitiveGroup, bool bForcePrimitiveLevel = false);
    const FLumenPrimitiveGroupCullingInfo& GetPrimitiveGroupCullingInfo(const FLumenPrimitiveGroup& PrimitiveGroup, bool bForcePrimitiveLevel = false) const;
    void RemovePrimitiveGroupCullingInfo(FLumenPrimitiveGroup& PrimitiveGroup);
    void UpdatePrimitiveGroupCullingInfo(const FLumenPrimitiveGroup& PrimitiveGroup, const FRenderBounds& NewWorldBounds, bool bForcePrimitiveLevel = false);
 
    // Copy initial data from default Lumen scene data to a view specific Lumen scene data
    void CopyInitialData(const FLumenSceneData& SourceSceneData);
#if WITH_MGPU
    void UpdateGPUMask(FRDGBuilder& GraphBuilder, const FLumenSceneFrameTemporaries& FrameTemporaries, FLumenViewState& LumenViewState, FRHIGPUMask ViewGPUMask);
#endif
 
    uint64 GetGPUSizeBytes(bool bLogSizes) const;
 
private:
 
    void AddMeshCardsFromBuildData(int32 PrimitiveGroupIndex, const FMatrix& LocalToWorld, const FMeshCardsBuildData& MeshCardsBuildData, FLumenPrimitiveGroup& PrimitiveGroup);
 
    void UnmapSurfaceCachePage(bool bLocked, FLumenPageTableEntry& Page, int32 PageIndex);
    bool RecaptureCardPage(const FViewInfo& MainView, FLumenCardRenderer& LumenCardRenderer, FLumenSurfaceCacheAllocator& CaptureAtlasAllocator, FRHIGPUMask GPUMask, int32 PageTableIndex);
 
    // Try to find a card with the same ID and has a MinAllocatedResLevel >= ResLevel
    const FLumenCardSharingInfo* FindMatchingCardForCopy(const FLumenCardId& CardId, uint32 ResLevel) const;
 
    // Called per frame right after we are done querying CardSharingInfoMap
    void FlushPendingCardSharingInfos();
 
    // Frame index used to time-splice various surface cache update operations
    // 0 is a special value, and means that surface contains default data
    uint32 SurfaceCacheUpdateFrameIndex = 1;
 
    // Used to detect change in data format
    EPixelFormat CurrentLightingDataFormat = PF_Unknown;
    float CurrentCachedLightingPreExposure = 0.0f;
 
    // Virtual surface cache page table
    FIntPoint PhysicalAtlasSize = FIntPoint(0, 0);
    ESurfaceCacheCompression PhysicalAtlasCompression;
    FLumenSurfaceCacheAllocator SurfaceCacheAllocator;
 
    // List of high res allocated physical pages which can be deallocated on demand, ordered by last used frame
    // FeedbackFrameIndex, PageTableIndex
    FBinaryHeap<uint32, uint32> UnlockedAllocationHeap;
 
    // List of pages for forced recapture, ordered by request frame index
    // RequestSurfaceCacheFrameIndex, PageTableIndex
    FBinaryHeap<uint32, uint32> PagesToRecaptureHeap[MAX_NUM_GPUS];
 
    // List of pages ordered by last captured frame used to periodically recapture pages, or for multi-GPU scenarios,
    // to track that a page is uninitialized on a particular GPU, and needs to be captured for the first time (indicated
    // by a CapturedSurfaceCacheFrameIndex value of zero).
    // CapturedSurfaceCacheFrameIndex, PageTableIndex
    FBinaryHeap<uint32, uint32> LastCapturedPageHeap[MAX_NUM_GPUS];
 
    // Data structures needed to support sharing cards between primitive groups
    TMap<FLumenCardId, TSparseArray<FLumenCardSharingInfo>> CardSharingInfoMap;
    TArray<FLumenCardSharingInfoPendingRemove> PendingRemoveCardSharingInfos;
    TArray<FLumenCardSharingInfoPendingAdd> PendingAddCardSharingInfos;
};