PrimitiveSceneInfo.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    PrimitiveSceneInfo.h: Primitive scene info definitions.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "Containers/IndirectArray.h"
#include "RenderDeferredCleanup.h"
#include "HitProxies.h"
#include "Math/GenericOctreePublic.h"
#include "PrimitiveComponentId.h"
#include "PrimitiveDirtyState.h"
#include "RendererInterface.h"
#include "ShaderParameterMacros.h"
#include "RayTracingMeshDrawCommands.h"
 
enum class ERayTracingPrimitiveFlags : uint8;
 
class FIndirectLightingCacheUniformParameters;
class FPlanarReflectionSceneProxy;
class FPrimitiveSceneInfo;
class FPrimitiveSceneProxy;
class FRayTracingGeometry;
class FReflectionCaptureProxy;
class FScene;
class FViewInfo;
class UPrimitiveComponent;
class IPrimitiveComponent;
struct FPrimitiveSceneInfoAdapter;
struct FPrimitiveSceneDesc;
struct FPrimitiveSceneInfoData;
struct FInstanceDataBufferHeader;
class FInstanceSceneDataBuffers;
class FInstanceDataUpdateTaskInfo;
 
struct FNaniteMaterialSlot;
struct FNaniteRasterBin;
struct FNaniteShadingBin;
struct FRayTracingInstance;
struct FRayTracingSBTAllocation;
struct FRayTracingMaskAndFlags;
 
template<typename ElementType,typename OctreeSemantics> class TOctree2;
 
namespace Nanite
{
    using CoarseMeshStreamingHandle = int16;
}
 
namespace RayTracing
{
    using FGeometryGroupHandle = int32;
    using GeometryGroupHandle UE_DEPRECATED(5.6, "Use FGeometryGroupHandle instead.") = FGeometryGroupHandle;
}
 
class FIndirectLightingCacheAllocation
{
public:
 
    FIndirectLightingCacheAllocation() :
        Add(FVector(0, 0, 0)),
        Scale(FVector(0, 0, 0)),
        MinUV(FVector(0, 0, 0)),
        MaxUV(FVector(0, 0, 0)),
        MinTexel(FIntVector(-1, -1, -1)),
        AllocationTexelSize(0),
        TargetPosition(FVector(0, 0, 0)),
        TargetDirectionalShadowing(1),
        TargetSkyBentNormal(FVector4f(0, 0, 1, 1)),
        SingleSamplePosition(FVector(0, 0, 0)),
        CurrentDirectionalShadowing(1),
        CurrentSkyBentNormal(FVector4f(0, 0, 1, 1)),
        bHasEverUpdatedSingleSample(false),
        bPointSample(true),
        bIsDirty(false),
        bUnbuiltPreview(false)
    {
        for (int32 VectorIndex = 0; VectorIndex < 3; VectorIndex++) // RGB
        {
            TargetSamplePacked0[VectorIndex] = FVector4f(0, 0, 0, 0);
            SingleSamplePacked0[VectorIndex] = FVector4f(0, 0, 0, 0);
            TargetSamplePacked1[VectorIndex] = FVector4f(0, 0, 0, 0);
            SingleSamplePacked1[VectorIndex] = FVector4f(0, 0, 0, 0);
        }
        TargetSamplePacked2 = FVector4f(0, 0, 0, 0);
        SingleSamplePacked2 = FVector4f(0, 0, 0, 0);
    }
 
    FVector Add;
 
    FVector Scale;
 
    FVector MinUV;
 
    FVector MaxUV;
 
    FIntVector MinTexel;
 
    int32 AllocationTexelSize;
 
    FVector TargetPosition;
 
    FVector4f TargetSamplePacked0[3];   // { { R.C0, R.C1, R.C2, R.C3 }, { G.C0, G.C1, G.C2, G.C3 }, { B.C0, B.C1, B.C2, B.C3 } }
    FVector4f TargetSamplePacked1[3];   // { { R.C4, R.C5, R.C6, R.C7 }, { G.C4, G.C5, G.C6, G.C7 }, { B.C4, B.C5, B.C6, B.C7 } }
    FVector4f TargetSamplePacked2;      // { R.C8, R.C8, R.C8, R.C8 }
 
    float TargetDirectionalShadowing;
 
    FVector4f TargetSkyBentNormal;
 
    FVector SingleSamplePosition;
 
    FVector4f SingleSamplePacked0[3];   // { { R.C0, R.C1, R.C2, R.C3 }, { G.C0, G.C1, G.C2, G.C3 }, { B.C0, B.C1, B.C2, B.C3 } }
    FVector4f SingleSamplePacked1[3];   // { { R.C4, R.C5, R.C6, R.C7 }, { G.C4, G.C5, G.C6, G.C7 }, { B.C4, B.C5, B.C6, B.C7 } }
    FVector4f SingleSamplePacked2;      // { R.C8, R.C8, R.C8, R.C8 }
 
    float CurrentDirectionalShadowing;
 
    FVector4f CurrentSkyBentNormal;
 
    bool bHasEverUpdatedSingleSample;
 
    bool bPointSample;
 
    bool bIsDirty;
 
    bool bUnbuiltPreview;
 
    void SetDirty() 
    { 
        bIsDirty = true; 
    }
 
    bool IsValid() const
    {
        return MinTexel.X >= 0 && MinTexel.Y >= 0 && MinTexel.Z >= 0 && AllocationTexelSize > 0;
    }
 
    void SetParameters(FIntVector InMinTexel, int32 InAllocationTexelSize, FVector InScale, FVector InAdd, FVector InMinUV, FVector InMaxUV, bool bInPointSample, bool bInUnbuiltPreview)
    {
        checkf(InAllocationTexelSize > 1 || bInPointSample, TEXT("%i, %i"), InAllocationTexelSize, bInPointSample ? 1 : 0);
        Add = InAdd;
        Scale = InScale;
        MinUV = InMinUV;
        MaxUV = InMaxUV;
        MinTexel = InMinTexel;
        AllocationTexelSize = InAllocationTexelSize;
        bIsDirty = false;
        bPointSample = bInPointSample;
        bUnbuiltPreview = bInUnbuiltPreview;
    }
};
 
struct FPrimitiveFlagsCompact
{
    uint8 bCastDynamicShadow : 1;
 
    uint8 bStaticLighting : 1;
 
    uint8 bCastStaticShadow : 1;
 
    uint8 bIsNaniteMesh : 1;
 
    uint8 bIsAlwaysVisible : 1;
 
    uint8 bSupportsGPUScene : 1;
 
    FPrimitiveFlagsCompact(const FPrimitiveSceneProxy* Proxy);
};
 
class FPrimitiveSceneInfoCompact
{
public:
    FPrimitiveSceneInfo* PrimitiveSceneInfo;
    FPrimitiveSceneProxy* Proxy;
    FCompactBoxSphereBounds Bounds;
    float MinDrawDistance;
    float MaxDrawDistance;
    int32 VisibilityId;
    FPrimitiveFlagsCompact PrimitiveFlagsCompact;
 
    FPrimitiveSceneInfoCompact(FPrimitiveSceneInfo* InPrimitiveSceneInfo);
};
 
struct FPrimitiveRuntimeVirtualTextureLodInfo
{
    enum { LodBiasOffset = 7 };
 
    uint16 MinLod : 4 = 0;
    uint16 MaxLod : 4 = 0;
    uint16 LodBias : 4 = 0;
    uint16 CullMethod : 1 = 0;
    uint16 CullValue : 3 = 0;
};
 
typedef TOctree2<FPrimitiveSceneInfoCompact,struct FPrimitiveOctreeSemantics> FScenePrimitiveOctree;
 
namespace ENaniteMeshPass
{
    enum Type
    {
        BasePass,
        LumenCardCapture,
        MaterialCache,
        Num,
    };
}
 
enum class EUpdateStaticMeshFlags : uint8
{
    RasterCommands      = (1U << 1U),
    RayTracingCommands  = (1U << 2U),
 
    AllCommands         = RasterCommands | RayTracingCommands,
};
ENUM_CLASS_FLAGS(EUpdateStaticMeshFlags);
 
class FPrimitiveSceneInfo : public FDeferredCleanupInterface
{
    friend class FSceneRenderer;
    friend struct FViewDebugInfo;
public:
    using FPersistentId = FPersistentPrimitiveIndex;
 
    FPrimitiveSceneProxy* Proxy;
 
    FPrimitiveComponentId PrimitiveComponentId;
 
    FPrimitiveComponentId LightingAttachmentRoot;
 
    FPrimitiveComponentId LODParentComponentId;
 
    TArray<class FCachedMeshDrawCommandInfo> StaticMeshCommandInfos;
 
    TArray<class FStaticMeshBatchRelevance> StaticMeshRelevances;
 
    TArray<class FStaticMeshBatch> StaticMeshes;
 
    TArray<FNaniteRasterBin> NaniteRasterBins[ENaniteMeshPass::Num];
    TArray<FNaniteShadingBin> NaniteShadingBins[ENaniteMeshPass::Num];
    TArray<FNaniteMaterialSlot> NaniteMaterialSlots[ENaniteMeshPass::Num];
 
    FOctreeElementId2 OctreeId;
 
    const FIndirectLightingCacheAllocation* IndirectLightingCacheAllocation;
 
    TUniformBufferRef<FIndirectLightingCacheUniformParameters> IndirectLightingCacheUniformBuffer;
 
    const FPlanarReflectionSceneProxy* CachedPlanarReflectionProxy;
 
    const FReflectionCaptureProxy* CachedReflectionCaptureProxy;
 
    TArray<int32, TInlineAllocator<1>> DistanceFieldInstanceIndices;
 
    TArray<int32, TInlineAllocator<1>> LumenPrimitiveGroupIndices;
 
    static const uint32 MaxCachedReflectionCaptureProxies = 3;
    const FReflectionCaptureProxy* CachedReflectionCaptureProxies[MaxCachedReflectionCaptureProxies];
    
    TArray<TRefCountPtr<HHitProxy> > HitProxies;
 
    HHitProxy* DefaultDynamicHitProxy;
 
    FHitProxyId DefaultDynamicHitProxyId;
 
    float LastRenderTime;
 
    class FLightPrimitiveInteraction* LightList;
 
    FScene* Scene;
 
    int32 NumMobileDynamicLocalLights;
 
    float GpuLodInstanceRadius;
 
    FPrimitiveSceneInfo(UPrimitiveComponent* InPrimitive,FScene* InScene);
    FPrimitiveSceneInfo(FPrimitiveSceneDesc* InPrimitiveSceneDesc, FScene* InScene);
 
    ~FPrimitiveSceneInfo();
 
    static void AddToScene(FScene* Scene, TArrayView<FPrimitiveSceneInfo*> SceneInfos);
 
    void RemoveFromScene(bool bUpdateStaticDrawLists);
 
    static void AllocateGPUSceneInstances(FScene* Scene, const TArrayView<FPrimitiveSceneInfo*>& SceneInfos);
    void FreeGPUSceneInstances();
 
    inline bool NeedsIndirectLightingCacheBufferUpdate()
    {
        return bIndirectLightingCacheBufferDirty;
    }
 
    static void UpdateStaticMeshes(FScene* Scene, TArrayView<FPrimitiveSceneInfo*> SceneInfos, EUpdateStaticMeshFlags UpdateFlags, bool bReAddToDrawLists = true);
 
    void RequestStaticMeshUpdate();
 
    RENDERER_API bool RequestUniformBufferUpdate();
 
    static void AddStaticMeshes(FRHICommandListBase& RHICmdList, FScene* Scene, TArrayView<FPrimitiveSceneInfo*> SceneInfos, bool bCacheMeshDrawCommands = true);
 
    void RemoveStaticMeshes();
 
    void LinkLODParentComponent();
 
    void UnlinkLODParentComponent();
 
    void LinkAttachmentGroup();
 
    void UnlinkAttachmentGroup();
 
    RENDERER_API bool RequestGPUSceneUpdate(EPrimitiveDirtyState PrimitiveDirtyState = EPrimitiveDirtyState::ChangedAll);
 
    void MarkGPUStateDirty(EPrimitiveDirtyState PrimitiveDirtyState = EPrimitiveDirtyState::ChangedAll)
    {
        RequestUniformBufferUpdate();
        RequestGPUSceneUpdate(PrimitiveDirtyState);
    }
 
    RENDERER_API void RefreshNaniteRasterBins();
 
    void UpdateOcclusionFlags();
 
    void GatherLightingAttachmentGroupPrimitives(TArray<FPrimitiveSceneInfo*, SceneRenderingAllocator>& OutChildSceneInfos);
    void GatherLightingAttachmentGroupPrimitives(TArray<const FPrimitiveSceneInfo*, SceneRenderingAllocator>& OutChildSceneInfos) const;
 
    FBoxSphereBounds GetAttachmentGroupBounds() const;
 
    uint32 GetMemoryFootprint();
 
    inline int32 GetIndex() const { return PackedIndex; }
    inline const int32* GetIndexAddress() const { return &PackedIndex; }
 
    inline bool IsIndexValid() const { return PackedIndex != INDEX_NONE && PackedIndex != MAX_int32; }
 
    inline FPersistentPrimitiveIndex GetPersistentIndex() const { return PersistentIndex; }
 
    void ApplyWorldOffset(FRHICommandListBase& RHICmdList, FVector InOffset);
 
    inline void MarkIndirectLightingCacheBufferDirty()
    {
        if (!bIndirectLightingCacheBufferDirty)
        {
            bIndirectLightingCacheBufferDirty = true;
        }
    }
 
    void UpdateIndirectLightingCacheBuffer(FRHICommandListBase& RHICmdList);
 
    RENDERER_API void GetStaticMeshesLODRange(int8& OutMinLOD, int8& OutMaxLOD) const;
 
    RENDERER_API const FMeshBatch* GetMeshBatch(int8 InLODIndex) const;
 
    int32 GetInstanceSceneDataOffset() const { return InstanceSceneDataOffset; }
    int32 GetNumInstanceSceneDataEntries() const { return NumInstanceSceneDataEntries; }
 
    int32 GetInstancePayloadDataOffset() const { return InstancePayloadDataOffset; }
    int32 GetInstancePayloadDataStride() const { return InstancePayloadDataStride; }
 
    int32 GetLightmapDataOffset() const { return LightmapDataOffset; }
    int32 GetNumLightmapDataEntries() const { return NumLightmapDataEntries; }
 
    bool NeedsReflectionCaptureUpdate() const;
 
    void CacheReflectionCaptures();
 
    void RemoveCachedReflectionCaptures();
 
    void UpdateComponentLastRenderTime(float CurrentWorldTime, bool bUpdateLastRenderTimeOnScreen);
 
    RENDERER_API int32 UpdateStaticLightingBuffer();
 
    FPrimitiveRuntimeVirtualTextureLodInfo const& GetRuntimeVirtualTextureLodInfo() const { return RuntimeVirtualTextureLodInfo; }
 
    void FlushRuntimeVirtualTexture();
 
#if RHI_RAYTRACING
    static void UpdateCachedRaytracingData(FScene* Scene, const TArrayView<FPrimitiveSceneInfo*>& SceneInfos);
 
    bool IsCachedRayTracingGeometryValid() const;
 
    RENDERER_API FRayTracingGeometry* GetStaticRayTracingGeometry(int8 LODIndex) const;
    RENDERER_API FRayTracingGeometry* GetValidStaticRayTracingGeometry(int8& InOutLODIndex) const;
 
    int GetStaticRayTracingGeometryNum() const { return StaticRayTracingGeometries.Num(); }
 
    const FRayTracingGeometry* GetCachedRayTracingGeometry() const { return CachedRayTracingGeometry; }
#endif
 
    FString GetFullnameForDebuggingOnly() const;
    FString GetOwnerActorNameOrLabelForDebuggingOnly() const;
    UE_DEPRECATED(5.7, "Unused")
    inline bool ShouldCacheShadowAsStatic() const
    {
        return false;
    }
 
    inline FMeshDrawCommandPrimitiveIdInfo GetMDCIdInfo() const { return FMeshDrawCommandPrimitiveIdInfo(PackedIndex, PersistentIndex, InstanceSceneDataOffset);}
 
    UPrimitiveComponent* GetComponentForDebugOnly() const;
    IPrimitiveComponent* GetComponentInterfaceForDebugOnly() const;
 
    bool HasInstanceDataBuffers() const { return InstanceSceneDataBuffersInternal != nullptr; }
    
    RENDERER_API const FInstanceSceneDataBuffers* GetInstanceSceneDataBuffers() const;
 
    FInstanceDataBufferHeader GetInstanceDataHeader() const;
 
    const FPrimitiveSceneInfoData* GetSceneData() const { return SceneData; }
 
private:
    
    FPrimitiveSceneInfo(const FPrimitiveSceneInfoAdapter& InAdapter, FScene* InScene);
 
    friend class FScene;
 
    int32 PackedIndex;
 
    FPersistentPrimitiveIndex PersistentIndex;
 
    IPrimitiveComponent* PrimitiveComponentInterfaceForDebuggingOnly;
 
    FPrimitiveSceneInfoData* SceneData;
 
    FPrimitiveRuntimeVirtualTextureLodInfo RuntimeVirtualTextureLodInfo;
 
    bool bNeedsUniformBufferUpdate : 1;
 
    bool bIndirectLightingCacheBufferDirty : 1;
 
    bool bRegisteredLightmapVirtualTextureProducerCallback : 1;
 
    bool bRegisteredWithVelocityData : 1;
 
    bool bNaniteRasterBinsRenderCustomDepth : 1;
 
    bool bPendingAddToScene : 1;
 
    bool bPendingAddStaticMeshes : 1;
 
    bool bPendingDelete : 1 = false;
 
    bool bPendingFlushRuntimeVirtualTexture : 1;
 
public:
    bool bNeedsCachedReflectionCaptureUpdate : 1;
 
    bool bShouldRenderInMainPass : 1;
 
    bool bVisibleInRealTimeSkyCapture : 1;
 
    bool bWritesRuntimeVirtualTexture : 1;
 
#if RHI_RAYTRACING
    bool bIsRelevantToPathTracing : 1;
    bool bIsCachedRayTracingInstanceValid : 1;
    UE_DEPRECATED(5.7, "Use DynamicRayTracingInstanceCachedData or GetRayTracingLODData(...) instead.")
    bool bCachedRayTracingInstanceMaskAndFlagsDirty : 1;
    UE_DEPRECATED(5.7, "Use DynamicRayTracingInstanceCachedData or GetRayTracingLODData(...) instead.")
    bool bCachedRayTracingInstanceAnySegmentsDecal : 1;
    UE_DEPRECATED(5.7, "Use DynamicRayTracingInstanceCachedData or GetRayTracingLODData(...) instead.")
    bool bCachedRayTracingInstanceAllSegmentsDecal : 1;
    UE_DEPRECATED(5.7, "Use DynamicRayTracingInstanceCachedData or GetRayTracingLODData(...) instead.")
    bool bCachedRayTracingInstanceAllSegmentsTranslucent : 1;
 
    struct FDynamicRayTracingInstanceCachedData
    {
        uint8 Mask = 0;
        uint8 bForceOpaque : 1 = false;
        uint8 bDoubleSided : 1 = false;
        uint8 bReverseCulling : 1 = false;
        uint8 bAnySegmentsDecal : 1 = false;
        uint8 bAllSegmentsDecal : 1 = false;
        uint8 bAllSegmentsTranslucent : 1 = false;
    };
    bool bDynamicRayTracingInstanceCachedDataDirty : 1 = true;
    FDynamicRayTracingInstanceCachedData DynamicRayTracingInstanceCachedData;
 
    struct FRayTracingLODData
    {
        FRayTracingSBTAllocation* SBTAllocation = nullptr;
        FRayTracingCachedMeshCommandFlags CachedMeshCommandFlags;
        TArray<FRayTracingShaderBindingData> CachedShaderBindingDataBase;
        TArray<FRayTracingShaderBindingData> CachedShaderBindingDataDecal;
        int32 BaseCachedMeshCommandIndex = INDEX_NONE;
        int32 NumCachedMeshCommands = 0;
        int32 SBTAllocationUniqueId = -1;
        int32 InstanceContributionToHitGroupIndexBase = INDEX_NONE;
        int32 InstanceContributionToHitGroupIndexDecal = INDEX_NONE;
    };
 
    uint32 GetRayTracingLODDataNum() const
    {
        return RayTracingLODData.Num();
    }
 
    const FRayTracingLODData& GetRayTracingLODData(uint32 Index) const
    {
        return RayTracingLODData[Index];
    }
 
    UE_DEPRECATED(5.7, "Cached Ray Tracing Instances are stored directly in FRayTracingScene. Use GetBaseRayTracingInstanceIndex()/GetDecalRayTracingInstanceIndex() instead.")
    const FRayTracingGeometryInstance GetCachedRayTracingInstance() const
    {
        return {};
    }
 
    const uint32 GetMainRayTracingInstanceIndex() const
    {
        return RayTracingInstanceIndexMain;
    }
 
    const uint32 GetDecalRayTracingInstanceIndex() const
    {
        return RayTracingInstanceIndexDecal;
    }
 
    void SetRayTracingLODData(TArray<FRayTracingLODData> LODData)
    {
        RayTracingLODData = MoveTemp(LODData);
    }
 
    void SetCachedRayTracingInstanceGeometryRHI(FRHIRayTracingGeometry* GeometryRHI, uint32 SegmentCount);
 
    UE_DEPRECATED(5.7, "Please provide SegmentCount.")
    void SetCachedRayTracingInstanceGeometryRHI(FRHIRayTracingGeometry* GeometryRHI)
    {
        SetCachedRayTracingInstanceGeometryRHI(GeometryRHI, GeometryRHI->GetInitializer().Segments.Num());
    }
 
    UE_DEPRECATED(5.7, "No longer necessary.")
    void UpdateCachedRayTracingInstanceMaskAndFlags(FRayTracingMaskAndFlags& InstanceMaskAndFlags) {}
 
private:
 
    // Allocate the RayTracing SBT ranges for all the setup LODs
    void AllocateRayTracingSBT(const FRHIRayTracingGeometry* CachedRayTracingInstanceGeometryRHI, uint32 CachedRayTracingInstanceSegmentCount);
 
    void CacheRayTracingShaderBindingData(const FRHIRayTracingGeometry* CachedRayTracingInstanceGeometryRHI);
    void CacheRayTracingInstance(FRayTracingGeometryInstance Instance);
 
    // for cached static instances (hot path), we only cache data for one LOD, so inline allocator avoids cache misses.
    TArray<FRayTracingLODData, TInlineAllocator<1>> RayTracingLODData;
 
    uint32 RayTracingInstanceIndexMain = UINT32_MAX;
    uint32 RayTracingInstanceIndexDecal = UINT32_MAX;
#endif // RHI_RAYTRACING
 
private:
    // Don't access this directly, even internally unless you are sure what you're up to. Use GetInstanceSceneDataBuffers() which handles thread safety.
    const FInstanceSceneDataBuffers *InstanceSceneDataBuffersInternal = nullptr;
    FInstanceDataUpdateTaskInfo *InstanceDataUpdateTaskInfo = nullptr;
 
    int32 LevelUpdateNotificationIndex;
 
    int32 InstanceSceneDataOffset;
 
    int32 NumInstanceSceneDataEntries;
 
    int32 InstancePayloadDataOffset;
 
    int32 InstancePayloadDataStride;
 
    int32 LightmapDataOffset;
 
    int32 NumLightmapDataEntries;
 
    void UpdateIndirectLightingCacheBuffer(
        FRHICommandListBase& RHICmdList,
        const class FIndirectLightingCache* LightingCache,
        const class FIndirectLightingCacheAllocation* LightingAllocation,
        FVector VolumetricLightmapLookupPosition,
        uint32 SceneFrameNumber,
        class FVolumetricLightmapSceneData* VolumetricLightmapSceneData);
 
    static void CacheMeshDrawCommands(FScene* Scene, TArrayView<FPrimitiveSceneInfo*> SceneInfos);
 
    void RemoveCachedMeshDrawCommands();
 
    static void CacheNaniteMaterialBins(FScene* Scene, const TArrayView<FPrimitiveSceneInfo*>& SceneInfos);
 
    void RemoveCachedNaniteMaterialBins();
 
#if RHI_RAYTRACING
    TArray<FRayTracingGeometry*> StaticRayTracingGeometries;
 
    // Cache pointer to FRayTracingGeometry used by cached ray tracing instance
    // since primitives using ERayTracingPrimitiveFlags::CacheInstances don't fill the StaticRayTracingGeometries array above
    const FRayTracingGeometry* CachedRayTracingGeometry;
 
    static void CacheRayTracingPrimitives(FScene* Scene, const TArrayView<FPrimitiveSceneInfo*>& SceneInfos);
 
    void RemoveCachedRayTracingPrimitives();
 
    static void SetupCachedRayTracingInstance(FPrimitiveSceneInfo* SceneInfo, const FRayTracingInstance& RayTracingInstance, FRayTracingGeometryInstance& OutCachedRayTracingInstance, uint32& OutSegmentCount);
#endif
 
public:
    DECLARE_MULTICAST_DELEGATE(FPrimitiveSceneInfoEvent);
    RENDERER_API static FPrimitiveSceneInfoEvent OnGPUSceneInstancesAllocated;
    RENDERER_API static FPrimitiveSceneInfoEvent OnGPUSceneInstancesFreed;
};
 
struct FPrimitiveOctreeSemantics
{
    enum { MaxElementsPerLeaf = 256 };
    enum { MinInclusiveElementsPerNode = 7 };
    enum { MaxNodeDepth = 12 };
 
    typedef FDefaultAllocator ElementAllocator;
 
    inline static const FCompactBoxSphereBounds& GetBoundingBox(const FPrimitiveSceneInfoCompact& PrimitiveSceneInfoCompact)
    {
        return PrimitiveSceneInfoCompact.Bounds;
    }
 
    inline static bool AreElementsEqual(const FPrimitiveSceneInfoCompact& A,const FPrimitiveSceneInfoCompact& B)
    {
        return A.PrimitiveSceneInfo == B.PrimitiveSceneInfo;
    }
 
    inline static void SetElementId(const FPrimitiveSceneInfoCompact& Element,FOctreeElementId2 Id)
    {
        Element.PrimitiveSceneInfo->OctreeId = Id;
        SetOctreeNodeIndex(Element, Id);
    }
 
    inline static void ApplyOffset(FPrimitiveSceneInfoCompact& Element, FVector Offset)
    {
        Element.Bounds.Origin+= Offset;
    }
 
    static void SetOctreeNodeIndex(const FPrimitiveSceneInfoCompact& Element, FOctreeElementId2 Id);
};
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "MeshPassProcessor.h"
#endif