NaniteStreamingManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "IO/IoDispatcher.h"
#include "Memory/SharedBuffer.h"
#include "NaniteResources.h"
#include "UnifiedBuffer.h"
#include "SpanAllocator.h"
 
namespace UE
{
    namespace DerivedData
    {
        class FRequestOwner; // Can't include DDC headers from here, so we have to forward declare
        struct FCacheGetChunkRequest;
    }
}
 
class FRDGBuilder;
 
namespace Nanite
{
 
class FFixupChunk;
 
struct FPageKey
{
    uint32 RuntimeResourceID    = INDEX_NONE;
    uint32 PageIndex            = INDEX_NONE;
 
    friend inline uint32 GetTypeHash(const FPageKey& Key)
    {
        return Key.RuntimeResourceID * 0xFC6014F9u + Key.PageIndex * 0x58399E77u;
    }
 
    inline bool operator==(const FPageKey& Other) const 
    {
        return RuntimeResourceID == Other.RuntimeResourceID && PageIndex == Other.PageIndex;
    }
 
    inline bool operator!=(const FPageKey& Other) const
    {
        return !(*this == Other);
    }
 
    inline bool operator<(const FPageKey& Other) const
    {
        return RuntimeResourceID != Other.RuntimeResourceID ? RuntimeResourceID < Other.RuntimeResourceID : PageIndex < Other.PageIndex;
    }
};
 
struct FStreamingRequest
{
    FPageKey    Key;
    uint32      Priority;
    
    inline bool operator<(const FStreamingRequest& Other) const 
    {
        return Key != Other.Key ? Key < Other.Key : Priority > Other.Priority;
    }
};
 
/*
 * Streaming manager for Nanite.
 */
class FStreamingManager : public FRenderResource
{
public:
    FStreamingManager();
    
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
    virtual void ReleaseRHI() override;
 
    void    Add(FResources* Resources);
    void    Remove(FResources* Resources);
 
    ENGINE_API void BeginAsyncUpdate(FRDGBuilder& GraphBuilder);            // Should be called at least once per frame. Must be called before any Nanite rendering when new meshes are added.
    ENGINE_API void EndAsyncUpdate(FRDGBuilder& GraphBuilder);              // Must be called after BeginAsyncUpdate and before any Nanite rendering.
    ENGINE_API bool IsAsyncUpdateInProgress();
    ENGINE_API bool IsSafeForRendering() const;
 
    UE_DEPRECATED(5.7, "SubmitFrameStreamingRequests should no longer be called.")
    ENGINE_API void SubmitFrameStreamingRequests(FRDGBuilder& GraphBuilder);
 
    ENGINE_API FRDGBuffer* GetStreamingRequestsBuffer(FRDGBuilder& GraphBuilder) const;
    ENGINE_API FRDGBufferSRV* GetHierarchySRV(FRDGBuilder& GraphBuilder) const;
    ENGINE_API FRDGBufferSRV* GetClusterPageDataSRV(FRDGBuilder& GraphBuilder) const;
    ENGINE_API FRDGBufferSRV* GetImposterDataSRV(FRDGBuilder& GraphBuilder) const;
 
    ENGINE_API uint32 GetStreamingRequestsBufferVersion() const;
    
    float GetQualityScaleFactor() const
    {
        return QualityScaleFactor;
    }
    
    uint32 GetMaxStreamingPages() const 
    {
        return MaxStreamingPages;
    }
 
    uint32 GetMaxHierarchyLevels() const
    {
        return MaxHierarchyLevels;
    }
 
    inline bool HasResourceEntries() const
    {
        return NumResources > 0u;
    }
 
    TMap<uint32, uint32> GetAndClearModifiedResources()
    {
        return MoveTemp(ModifiedResources);
    }
 
    ENGINE_API void     PrefetchResource(const FResources* Resource, uint32 NumFramesUntilRender);
    ENGINE_API void     RequestNanitePages(TArrayView<uint32> RequestData);
#if WITH_EDITOR
    ENGINE_API uint64   GetRequestRecordBuffer(TArray<uint32>& OutRequestData);
    ENGINE_API void     SetRequestRecordBuffer(uint64 Handle);
#endif
 
private:
    friend class FStreamingUpdateTask;
    
    static constexpr uint16 INVALID_RESIDENT_PAGE_INDEX = 0xFFFFu;
 
    struct FResourcePrefetch
    {
        uint32  RuntimeResourceID;
        uint32  NumFramesUntilRender;
    };
 
    struct FAsyncState
    {
        struct FGPUStreamingRequest*    GPUStreamingRequestsPtr = nullptr;
        uint32                          NumGPUStreamingRequests = 0;
        uint32                          NumReadyOrSkippedPages = 0;
        bool                            bUpdateActive = false;
        bool                            bBuffersTransitionedToWrite = false;
    };
 
    struct FPendingPage
    {
#if WITH_EDITOR
        FSharedBuffer           SharedBuffer;
        enum class EState
        {
            None,
            DDC_Pending,
            DDC_Ready,
            DDC_Failed,
            Memory,
            Disk,
        } State = EState::None;
#endif
        FIoBuffer               RequestBuffer;
        FBulkDataBatchReadRequest Request;
 
        uint32                  GPUPageIndex = INDEX_NONE;
        FPageKey                InstallKey;
        uint32                  RingBufferAllocationSize = 0;
        uint32                  BytesLeftToStream = 0;
        uint32                  RetryCount = 0;
    };
 
    struct FHeapBuffer
    {
        int32                           TotalUpload = 0;
        FSpanAllocator                  Allocator;
        FRDGScatterUploadBuffer         UploadBuffer;
        TRefCountPtr<FRDGPooledBuffer>  DataBuffer;
 
        void Release()
        {
            UploadBuffer = {};
            DataBuffer = {};
        }
    };
 
    struct FRegisteredVirtualPage
    {
        uint32 Priority             = 0u;                       // Priority != 0u means referenced this frame
        uint32 RegisteredPageIndex  = INDEX_NONE;
 
        bool operator==(const FRegisteredVirtualPage&) const = default;
    };
 
    struct FResidentVirtualPage
    {
        uint16 ResidentPageIndex = INVALID_RESIDENT_PAGE_INDEX;
 
        bool operator==(const FResidentVirtualPage&) const = default;
    };
 
    struct FNewPageRequest
    {
        FPageKey Key;
        uint32 VirtualPageIndex = INDEX_NONE;
    };
 
    struct FRegisteredPage
    {
        FPageKey    Key;
        uint32      VirtualPageIndex = INDEX_NONE;
        uint8       RefCount = 0;
    };
 
    struct FResidentPage
    {
        FPageKey    Key;
        uint8       MaxHierarchyDepth   = 0xFF;
    };
 
    struct FRootPageInfo
    {
        FFixupChunk*    FixupChunk              = nullptr;
        uint8           MaxHierarchyDepth       = 0xFF;
 
        // Per-resource properties.
        // This could be moved to a separate struct, but probably isn't worth the indirection as there is typically one root page per resource.
        FResources*     Resources               = nullptr;
        uint32          RuntimeResourceID       = INDEX_NONE;
        uint32          VirtualPageRangeStart   = INDEX_NONE;   // Points to virtual address of this root page, not the first one
        uint32          NumRootPages            = INDEX_NONE;
        uint32          NumTotalPages           = INDEX_NONE;
 
        uint32          bInvalidResource : 1    = 0;    // Crude defensive measure against invalid DDC data and IO errors.
                                                        // Instead of just crashing on invalid data, emit an error and stop streaming from the resource.
 
        bool operator==(const FRootPageInfo&) const = default;
    };
 
    TArray<FRootPageInfo>   RootPageInfos;
    TArray<uint8>           RootPageVersions;
    
    FHeapBuffer             ClusterPageData;    // FPackedCluster*, GeometryData { Index, Position, TexCoord, TangentX, TangentZ }*
    FHeapBuffer             Hierarchy;
    FHeapBuffer             ImposterData;
 
    TPimplPtr<class FOrderedScatterUpdater> ClusterScatterUpdates;
    TPimplPtr<class FOrderedScatterUpdater> HierarchyScatterUpdates;
    
    TPimplPtr<class FHierarchyDepthManager> HierarchyDepthManager;
    uint32                  MaxHierarchyLevels = 0;
 
    uint32                  MaxStreamingPages = 0;
    uint32                  MaxRootPages = 0;
    uint32                  NumInitialRootPages = 0;
    uint32                  PrevNumInitialRootPages = 0;
    uint32                  MaxPendingPages = 0;
    uint32                  MaxPageInstallsPerUpdate = 0;
 
    uint32                  NumResources = 0;
    uint32                  NumPendingPages = 0;
    uint32                  NextPendingPageIndex = 0;
    float                   QualityScaleFactor = 1.0f;
    bool                    bClusterPageDataAllocated = false;
 
    uint32                  StatNumRootPages = 0;
    uint32                  StatPeakRootPages = 0;
    uint32                  StatVisibleSetSize = 0;
    uint32                  StatPrevUpdateTime = 0;
    uint32                  StatNumAllocatedRootPages = 0;
    uint32                  StatNumHierarchyNodes = 0;
    uint32                  StatPeakHierarchyNodes = 0;
    float                   StatStreamingPoolPercentage = 0.0f;
    
    uint64                  PrevUpdateTick = 0;
    uint64                  PrevUpdateFrameNumber = ~0ull;
 
    TArray<FResources*>                 PendingAdds;
 
    TMultiMap<uint32, FResources*>      PersistentHashResourceMap;          // TODO: MultiMap to handle potential collisions and issues with there temporarily being two meshes with the same hash because of unordered add/remove.
    
    TMap<uint32, uint32>                ModifiedResources;                  // Key = RuntimeResourceID, Value = NumResidentClusters
 
    FSpanAllocator                      VirtualPageAllocator;
    TArray<FRegisteredVirtualPage>      RegisteredVirtualPages;
 
    typedef TArray<uint32, TInlineAllocator<16>> FRegisteredPageDependencies;
    TArray<FRegisteredPage>             RegisteredPages;
    TArray<FRegisteredPageDependencies> RegisteredPageDependencies;
 
    TArray<uint32>                      RegisteredPageIndexToLRU;
    TArray<uint32>                      LRUToRegisteredPageIndex;
 
    TArray<FResidentPage>               ResidentPages;
    TArray<FFixupChunk*>                ResidentPageFixupChunks;            // Fixup information for resident streaming pages. We need to keep this around to be able to uninstall pages.
    TArray<FResidentVirtualPage>        ResidentVirtualPages;
 
    TArray<FNewPageRequest>             RequestedNewPages;
    TArray<uint32>                      RequestedRegisteredPages;
 
    TArray<FPendingPage>                PendingPages;
    TArray<uint8>                       PendingPageStagingMemory;
    TPimplPtr<class FRingBufferAllocator>   PendingPageStagingAllocator;
    
    TPimplPtr<class FStreamingPageUploader> PageUploader;
    TPimplPtr<class FReadbackManager>   ReadbackManager;
 
    TPimplPtr<class FQualityScalingManager>     QualityScalingManager;
 
    FGraphEventArray                    AsyncTaskEvents;
    FAsyncState                         AsyncState;
 
#if WITH_EDITOR
    UE::DerivedData::FRequestOwner*     RequestOwner;
 
    uint64                              PageRequestRecordHandle = (uint64)-1;
    TMap<FPageKey, uint32>              PageRequestRecordMap;
#endif
    TArray<uint32>                      PendingExplicitRequests;
    TArray<FResourcePrefetch>           PendingResourcePrefetches;
 
    // Transient lifetime, but persisted to reduce allocations
    TArray<FStreamingRequest>           PrioritizedRequestsHeap;
    TArray<uint32>                      GPUPageDependencies;
    TArray<FPageKey>                    SelectedPages;
 
    bool AddRequest(uint32 RuntimeResourceID, uint32 PageIndex, uint32 VirtualPageIndex, uint32 Priority);
    bool AddRequest(uint32 RuntimeResourceID, uint32 PageIndex, uint32 Priority);
    void AddPendingGPURequests();
    void AddPendingExplicitRequests();
    void AddPendingResourcePrefetchRequests();
    void AddParentRequests();
    void AddParentRegisteredRequestsRecursive(uint32 RegisteredPageIndex, uint32 Priority);
    void AddParentNewRequestsRecursive(const FResources& Resources, uint32 RuntimeResourceID, uint32 PageIndex, uint32 VirtualPageRangeStart, uint32 Priority);
 
    FRootPageInfo*  GetRootPage(uint32 RuntimeResourceID);
    FResources*     GetResources(uint32 RuntimeResourceID);
 
    void SelectHighestPriorityPagesAndUpdateLRU(uint32 MaxSelectedPages);
 
    void RegisterStreamingPage(uint32 RegisteredPageIndex, const FPageKey& Key);
    void UnregisterStreamingPage(const FPageKey& Key);
 
    void MoveToEndOfLRUList(uint32 RegisteredPageIndex);
    void CompactLRU();
    void VerifyLRU();
 
    void ApplyFixups(const FFixupChunk& FixupChunk, const FResources& Resources, const TSet<uint32>* NoWriteGPUPages, uint32 NumStreamingPages, uint32 PageToExclude, uint32 VirtualPageRangeStart, bool bUninstall, bool bAllowReconsider, bool bAllowReinstall);
    void VerifyFixupState();
 
    bool ArePageDependenciesCommitted(const FResources& Resources, FPageRangeKey PageRangeKey, uint32 PageToExclude, uint32 VirtualPageRangeStart);
 
    void ProcessNewResources(FRDGBuilder& GraphBuilder, FRDGBuffer* ClusterPageDataBuffer);
    FRDGBuffer* ResizePoolAllocationIfNeeded(FRDGBuilder& GraphBuilder);
    
    uint32 DetermineReadyOrSkippedPages(uint32& TotalPageSize);
    void InstallReadyPages(uint32 NumReadyOrSkippedPages);
    
    void UninstallResidentPage(uint32 GPUPageIndex, uint32 NumStreamingPages, const TSet<uint32>* NoWriteGPUPages, bool bApplyFixup);
    void UninstallAllResidentPages(uint32 NumStreamingPages);
    
    void ResetStreamingStateCPU();
    void UpdatePageConfiguration();
    
 
    void AsyncUpdate();
 
#if NANITE_SANITY_CHECK_STREAMING_REQUESTS
    void SanityCheckStreamingRequests(const struct FGPUStreamingRequest* StreamingRequestsPtr, const uint32 NumStreamingRequests);
#endif
 
#if WITH_EDITOR
    void RecordGPURequests();
    UE::DerivedData::FCacheGetChunkRequest BuildDDCRequest(const FResources& Resources, const FPageStreamingState& PageStreamingState, const uint32 PendingPageIndex);
    void RequestDDCData(TConstArrayView<UE::DerivedData::FCacheGetChunkRequest> DDCRequests);
#endif
};
 
extern ENGINE_API TGlobalResource< FStreamingManager > GStreamingManager;
 
} // namespace Nanite