GPUSortManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    GPUSortManager.h: Interface manage sorting between different FXSystemInterface
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "Templates/RefCounting.h"
#include "RHI.h"
#include "RenderResource.h"
 
ENGINE_API void CopyUIntBufferToTargets(FRHICommandList& RHICmdList, ERHIFeatureLevel::Type FeatureLevel, FRHIShaderResourceView* SourceSRV, FRHIUnorderedAccessView*const* TargetUAVs, int32* TargetSizes, int32 StartingOffset, int32 NumTargets);
 
struct FGPUSortBuffers;
 
class FParticleSortBuffers : public FRenderResource
{
public:
 
    void SetBufferSize(int32 InBufferSize)
    {
        BufferSize = InBufferSize;
    }
 
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
 
    virtual void ReleaseRHI() override;
 
    FRHIUnorderedAccessView* GetKeyBufferUAV(int32 BufferIndex)
    {
        check((BufferIndex & 0xFFFFFFFE) == 0);
        return KeyBufferUAVs[BufferIndex];
    }
 
    FGPUSortBuffers GetSortBuffers();
 
    FRHIBuffer* GetSortedVertexBufferRHI(int32 BufferIndex)
    {
        check((BufferIndex & 0xFFFFFFFE) == 0);
        return VertexBuffers[BufferIndex];
    }
 
    int32 GetSize() { return BufferSize; }
 
private:
 
    FBufferRHIRef KeyBuffers[2];
    FShaderResourceViewRHIRef KeyBufferSRVs[2];
    FUnorderedAccessViewRHIRef KeyBufferUAVs[2];
 
    FBufferRHIRef VertexBuffers[2];
    FShaderResourceViewRHIRef VertexBufferSortSRVs[2];
    FUnorderedAccessViewRHIRef VertexBufferSortUAVs[2];
 
    int32 BufferSize = 0;
};
 
enum class EGPUSortFlags : uint32
{
    None            = 0x00,
    LowPrecisionKeys    = 0x01,     // Low precision keys ((EleIdx << 16) | (16 bits key))
    HighPrecisionKeys   = 0x02,     // High precision keys ((EleIdx << (32 - IdxBitCount)) | (32 bits key >> IdxBitCount))
 
    AnyKeyPrecision     = 0x03,
 
    KeyGenAfterPreRender            = 0x04,     // Typically Cascade emitters simulated in PreRender() or any Niagara emitters.
    KeyGenAfterPostRenderOpaque     = 0x08,     // Typically any Cascade emitters, or Niagara emitters simulated in PreInitViews().
 
    AnyKeyGenLocation               = 0x0C,
 
    SortAfterPreRender          = 0x10,     // Any Emitter since good for both opaque or translucent
    SortAfterPostRenderOpaque   = 0x20,     // Emitter using translucent material.
 
    AnySortLocation             = 0x30,
 
    ValuesAsG16R16F = 0x40,
    ValuesAsInt32   = 0x80,
 
    AnyValueFormat  = 0xC0,
};
 
ENUM_CLASS_FLAGS(EGPUSortFlags)
 
 
DECLARE_DELEGATE_SixParams(FGPUSortKeyGenDelegate, FRHICommandListImmediate&, int32, int32, EGPUSortFlags, FRHIUnorderedAccessView*, FRHIUnorderedAccessView*);
 
class FGPUSortManager : public FRefCountedObject
{
public:
 
    struct FAllocationInfo
    {
        FShaderResourceViewRHIRef BufferSRV;
        uint32 BufferOffset = INDEX_NONE;
        int32 SortBatchId = INDEX_NONE;
        int32 ElementIndex = INDEX_NONE;
    };
 
    struct FKeyGenInfo
    {
        ENGINE_API FKeyGenInfo(uint32 NumElements, bool bHighPrecisionKeys);
 
        uint32 ElementKeyMask;
        uint32 ElementKeyShift;
        uint32 SortKeyMask;
        FUintVector4 SortKeyParams; 
    };
 
private:
 
    struct FCallbackInfo
    {
        FGPUSortKeyGenDelegate Delegate;
        EGPUSortFlags Flags = EGPUSortFlags::None;
        FName Name;
    };
 
    typedef TArray<FCallbackInfo> FCallbackArray;
 
    struct FSettings
    {
        EGPUSortFlags AllowedFlags = EGPUSortFlags::None;
        float BufferSlack = 2.f;
        int32 FrameCountBeforeShrinking = 100;
        int32 MinBufferSize = 8192;
    };
 
    class FValueBuffer : public FVertexBuffer
    {
    public:
 
        FValueBuffer(FRHICommandListBase& RHICmdList, int32 InAllocatedCount, int32 InUsedCount, const FSettings& InSettings);
 
        ~FValueBuffer() { ReleaseRHI(); }
 
        void ReleaseRHI() override final;
 
        FShaderResourceViewRHIRef UInt32SRV;
        FUnorderedAccessViewRHIRef UInt32UAV;
        FShaderResourceViewRHIRef Int32SRV;
        FUnorderedAccessViewRHIRef Int32UAV;
        FShaderResourceViewRHIRef G16R16SRV;
        FUnorderedAccessViewRHIRef G16R16UAV;
 
        int32 AllocatedCount = 0;
        int32 UsedCount = 0;
 
        inline void Allocate(FAllocationInfo& OutInfo, int32 ValueCount, EGPUSortFlags Flags);
    };
 
    typedef TIndirectArray<FValueBuffer, TInlineAllocator<4>> FValueBufferArray;
 
    struct FDynamicValueBuffer
    {
        ~FDynamicValueBuffer() { ReleaseRHI(); }
 
        FValueBufferArray ValueBuffers;
 
        int32 NumFramesRequiringShrinking = 0;
 
        EGPUSortFlags LastSortBatchFlags = EGPUSortFlags::None;
 
        int32 CurrentSortBatchId = INDEX_NONE;
 
        void Allocate(FRHICommandListBase& RHICmdList, FAllocationInfo& OutInfo, const FSettings& InSettings, int32 ValueCount, EGPUSortFlags Flags);
 
        void SkrinkAndReset(FRHICommandListBase& RHICmdList, const FSettings& InSettings);
        
        void ReleaseRHI();
        inline int32 GetUsedCount() const { return ValueBuffers.Num() ? ValueBuffers.Last().UsedCount : 0; }
        inline int32 GetAllocatedCount() const { return ValueBuffers.Num() ? ValueBuffers.Last().AllocatedCount : 0; }
    };
 
    typedef TIndirectArray<FDynamicValueBuffer, TInlineAllocator<4>> FDynamicValueBufferArray;
 
    enum class ESortBatchProcessingOrder : uint32
    {
        Undefined = 0,
        KeyGenAndSortAfterPreRender = 1,
        KeyGenAfterPreRenderAndSortAfterPostRenderOpaque = 2,
        KeyGenAndSortAfterPostRenderOpaque = 3,
    };
 
    struct FSortBatch
    {
        int32 Id = INDEX_NONE;
        int32 NumElements = 0;
 
        EGPUSortFlags Flags = EGPUSortFlags::None;
 
        FDynamicValueBuffer* DynamicValueBuffer = nullptr;
 
        FParticleSortBuffers* SortBuffers = nullptr;
 
        ESortBatchProcessingOrder ProcessingOrder = ESortBatchProcessingOrder::Undefined;
 
        void UpdateProcessingOrder();
 
        void GenerateKeys(FRHICommandListImmediate& RHICmdList, const FCallbackArray& InCallbacks, EGPUSortFlags KeyGenLocation);
 
        void SortAndResolve(FRHICommandListImmediate& RHICmdList, ERHIFeatureLevel::Type InFeatureLevel);
 
        inline int32 GetUsedValueCount() const { return DynamicValueBuffer ? DynamicValueBuffer->GetUsedCount() : 0; }
        inline int32 GetAllocatedValueCount() const { return DynamicValueBuffer ? DynamicValueBuffer->GetAllocatedCount() : 0; }
    };
 
    typedef TArray<FSortBatch, TInlineAllocator<4>> FSortBatchArray;
 
public:
 
    ENGINE_API FGPUSortManager(ERHIFeatureLevel::Type InFeatureLevel);
 
    ENGINE_API ~FGPUSortManager();
 
    ENGINE_API void Register(const FGPUSortKeyGenDelegate& CallbackDelegate, EGPUSortFlags UsedFlags, const FName& InName); 
 
    ENGINE_API bool AddTask(FRHICommandListBase& RHICmdList, FAllocationInfo& OutInfo, int32 ValueCount, EGPUSortFlags TaskFlags);
 
    ENGINE_API void OnPreRender(class FRDGBuilder& GraphBuilder);
 
    ENGINE_API void OnPostRenderOpaque(class FRDGBuilder& GraphBuilder);
 
    DECLARE_EVENT_OneParam(FGPUSortManager, FPostPreRenderEvent, FRHICommandListImmediate&);
    FPostPreRenderEvent PostPreRenderEvent;
 
    DECLARE_EVENT_OneParam(FGPUSortManager, FPostPostRenderEvent, FRHICommandListImmediate&);
    FPostPreRenderEvent PostPostRenderEvent;
 
private:
 
    static inline bool HasEither(EGPUSortFlags Flags, EGPUSortFlags A, EGPUSortFlags B);
    static inline EGPUSortFlags GetBatchFlags(EGPUSortFlags TaskFlags);
    static inline EGPUSortFlags CombineBatchFlags(EGPUSortFlags BatchFlags, EGPUSortFlags TaskFlags);
    static inline bool TestBatchFlags(EGPUSortFlags BatchFlags, EGPUSortFlags TaskFlags);
    static inline auto GetPrecisionString(EGPUSortFlags BatchFlags) -> TCHAR const(&)[1];
 
    FDynamicValueBuffer* GetDynamicValueBufferFromPool(EGPUSortFlags TaskFlags, int32 SortBatchId);
 
    void FinalizeSortBatches();
    void UpdateSortBuffersPool(FRHICommandListBase& RHICmdList);
    void ResetDynamicValuesBuffers(FRHICommandListBase& RHICmdList);
    void ReleaseSortBuffers();
 
    UE::FMutex AddTaskMutex;
 
    FSortBatchArray SortBatches;
 
    FSettings Settings;
 
    FDynamicValueBufferArray DynamicValueBufferPool;
 
    TArray<FParticleSortBuffers*, TInlineAllocator<2>> SortBuffersPool;
 
    FCallbackArray Callbacks;
 
    ERHIFeatureLevel::Type FeatureLevel;
};