SceneCullingRenderer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "SceneCulling.h"
#include "GPUWorkGroupLoadBalancer.h"
 
class FSceneCulling;
class FSceneInstanceCullResult;
class FSceneInstanceCullingQuery;
 
BEGIN_SHADER_PARAMETER_STRUCT( FInstanceHierarchyParameters, )
    SHADER_PARAMETER(uint32, NumCellsPerBlockLog2)
    SHADER_PARAMETER(uint32, CellBlockDimLog2)
    SHADER_PARAMETER(uint32, LocalCellCoordMask) // (1 << NumCellsPerBlockLog2) - 1
    SHADER_PARAMETER(int32, FirstLevel)
    SHADER_PARAMETER(uint32, bCullChunkViewDistance)
    SHADER_PARAMETER(uint32, NumAllocatedChunks)
 
    SHADER_PARAMETER_RDG_BUFFER_SRV( StructuredBuffer< FCellBlockData >, InstanceHierarchyCellBlockData)
    SHADER_PARAMETER_RDG_BUFFER_SRV( StructuredBuffer< FPackedCellHeader >, InstanceHierarchyCellHeaders)
    SHADER_PARAMETER_RDG_BUFFER_SRV( StructuredBuffer< uint >, InstanceHierarchyItemChunks)
    SHADER_PARAMETER_RDG_BUFFER_SRV( StructuredBuffer< uint >, InstanceIds)
    SHADER_PARAMETER_RDG_BUFFER_SRV( ByteAddressBuffer, ExplicitChunkBounds)
    SHADER_PARAMETER_RDG_BUFFER_SRV( StructuredBuffer< uint32 >, ExplicitChunkCellIds)
    SHADER_PARAMETER_RDG_BUFFER_SRV( StructuredBuffer< uint >, UsedChunkIdMask)
END_SHADER_PARAMETER_STRUCT()
 
class FSceneCullingRenderer : public ISceneExtensionRenderer
{
    DECLARE_SCENE_EXTENSION_RENDERER(FSceneCullingRenderer, FSceneCulling);
public:
    friend class FSceneInstanceCullingQuery;
 
    FSceneCullingRenderer(FSceneRendererBase& InSceneRenderer, FSceneCulling& InSceneCulling) : ISceneExtensionRenderer(InSceneRenderer), SceneCulling(InSceneCulling) {}
 
    inline bool IsEnabled() const { return SceneCulling.IsEnabled(); }
 
    FInstanceHierarchyParameters& GetShaderParameters(FRDGBuilder& GraphBuilder);
    
    FSceneInstanceCullingQuery* CullInstances(FRDGBuilder& GraphBuilder, const TConstArrayView<FConvexVolume>& ViewCullVolumes);
    FSceneInstanceCullingQuery* CullInstances(FRDGBuilder& GraphBuilder, const FConvexVolume& ViewCullVolume) { return CullInstances(GraphBuilder, TConstArrayView<FConvexVolume>(&ViewCullVolume, 1)); }
 
    FSceneInstanceCullingQuery* CreateInstanceQuery(FRDGBuilder& GraphBuilder);
 
    void DebugRender(FRDGBuilder& GraphBuilder, TArrayView<FViewInfo> Views);
 
private:
    FSceneCulling& SceneCulling;
    using FSpatialHash = FSceneCulling::FSpatialHash;
 
    FInstanceHierarchyParameters ShaderParameters;
    FRDGBuffer* CellHeadersRDG = nullptr;
    FRDGBuffer* ItemChunksRDG = nullptr;
    FRDGBuffer* InstanceIdsRDG = nullptr;
    FRDGBuffer* CellBlockDataRDG = nullptr;
    FRDGBuffer* ExplicitChunkBoundsRDG = nullptr;
    FRDGBuffer* ExplicitChunkCellIdsRDG = nullptr;
    FRDGBuffer* UsedChunkIdMaskRDG = nullptr;
};
 
class FSceneInstanceCullingQuery
{
public:
    FSceneInstanceCullingQuery(FSceneCullingRenderer& InSceneCullingRenderer);
 
    int32 AddViewDrawGroup(uint32 FirstPrimaryView, uint32 NumPrimaryViews);
 
    void Add(uint32 FirstPrimaryView, uint32 NumPrimaryViews, const FCullingVolume& CullingVolume);
 
    void Dispatch(FRDGBuilder& GraphBuilder, bool bAllowAsync = true);
 
    // Get GPU stuffs, TBD
    FSceneInstanceCullResult* GetResult();
 
    FSceneInstanceCullResult* GetResultAsync() const { return CullingResult; }
 
    bool IsAsync() const { return AsyncTaskHandle.IsValid() && !AsyncTaskHandle.IsCompleted(); }
 
    UE::Tasks::FTask GetAsyncTaskHandle() const { return AsyncTaskHandle; }
 
    FSceneCullingRenderer& GetSceneCullingRenderer() { return SceneCullingRenderer; }
    
    TConstArrayView<FViewDrawGroup> GetViewDrawGroups() const
    {
        return ViewDrawGroups;
    }
 
private:
    void ComputeResult();
 
    FSceneCullingRenderer& SceneCullingRenderer;
 
    using FViewDrawGroups = TArray<FViewDrawGroup, SceneRenderingAllocator>;
    FViewDrawGroups ViewDrawGroups;
 
    struct FCullingJob
    {
        FCullingVolume CullingVolume;
        int32 ViewGroupId = 0;
    };
 
    TArray<FCullingJob, SceneRenderingAllocator> CullingJobs;
 
    FSceneInstanceCullResult *CullingResult = nullptr;
 
    UE::Tasks::FTask AsyncTaskHandle;
};
 
 
class FSceneInstanceCullResult
{
public:
    using FCellChunkDraws = TGPUWorkGroupLoadBalancer<FCellChunkDraw>;
    // The list of cell/view-group pairs to feed to rendering
    FCellChunkDraws CellChunkDraws;
    // List of view group IDs (indexing into the query) that should be culled on a per chunk basis.
    using FChunkCullViewGroupIds = TArray<uint32, SceneRenderingAllocator>;
    FChunkCullViewGroupIds ChunkCullViewGroupIds;
    uint32 NumInstanceGroups = 0;
    // This is the number of occluded chunks that might be emitted (if everything is occluded in the Main pass).
    int32 MaxOccludedChunkDraws = 0;
    // This is the number of allocated chunks, we run a thread for each and skip those that are not currently in use.
    uint32 NumAllocatedChunks = 0u;
    FSceneCullingRenderer* SceneCullingRenderer = nullptr;
    uint32 UncullableItemChunksOffset = 0;
    uint32 UncullableNumItemChunks = 0;
};