RenderAssetUpdate.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
RenderAssetUpdate.h: Base class of helpers to stream in and out texture/mesh LODs
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "HAL/ThreadSafeCounter.h"
#include "Async/AsyncWork.h"
#include "RenderingThread.h"
#include "Streaming/StreamableRenderResourceState.h"
 
#define UE_API ENGINE_API
 
class UStreamableRenderAsset;
 
#define SRA_UPDATE_CALLBACK(FunctionName) [this](const FContext& C){ FunctionName(C); }
 
ENGINE_API bool IsAssetStreamingSuspended();
 
extern ENGINE_API bool GEnableAssetUpdateAbandons;
 
class FRenderAssetUpdate;
namespace FRenderAssetUpdateHelper
{
    bool TickRenderAssetUpdateForGarbageCollection(TRefCountPtr<FRenderAssetUpdate> RenderAssetUpdate);
}
 
class FRenderAssetUpdate : public IRefCountedObject
{
public:
 
    enum EThreadType
    {
        TT_None,    // No thread.
        TT_Render,  // The render thread.
        TT_Async,   // An async work thread.
        TT_GameThread, // The game thread
        TT_GameRunningAsync // The game thread running async work.
    };
 
    enum ETaskState
    {
        TS_Done,        // Nothing to do.
        TS_Suspended,   // Waiting for external events, like IO requests, or when the renderthread is suspended.
        TS_InProgress,  // Callbacks are about to be executed.
        TS_Locked,      // The object is locked, and no one is allowed to process or look at the next task.
        TS_Init         // The object is in initialization
    };
 
    UE_API FRenderAssetUpdate(const UStreamableRenderAsset* InAsset);
 
    UE_API void Tick(EThreadType InCurrentThread);
 
    bool IsCompleted() const
    {
        return TaskState == TS_Done;
    }
 
    virtual void Abort()
    {
        MarkAsCancelled();
    }
 
    virtual bool CanAbandon() const
    {
        return false;
    }
 
    virtual void OnAbandoned()
    {
        check(CanAbandon());
        StreamableAsset = nullptr;
    }
 
    bool IsCancelled() const
    {
        return bIsCancelled;
    }
 
    bool IsSuccessfullyFinished() const
    {
        return bSuccess;
    }
 
    UE_API ETaskState DoLock();
 
    UE_API void DoUnlock(ETaskState PreviousTaskState);
 
    bool IsLocked() const
    {
        return TaskState == TS_Locked;
    }
 
    virtual EThreadType GetRelevantThread() const = 0;
 
    //****************** IRefCountedObject ****************/
 
    FReturnedRefCountValue AddRef() const final override 
    { 
        return FReturnedRefCountValue{(uint32)NumRefs.Increment()};
    }
 
    UE_API uint32 Release() const final override;
 
    uint32 GetRefCount() const final override
    {
        return (uint32)NumRefs.GetValue();
    }
 
protected:
 
    UE_API virtual ~FRenderAssetUpdate();
 
    virtual ETaskState TickInternal(EThreadType InCurrentThread, bool bCheckForSuspension) = 0;
 
    void MarkAsCancelled()
    {
        // StreamableAsset = nullptr; // TODO once Cancel supports it!
 
        if (TaskState != TS_Done) // do not cancel if we have already completed, see FORT-345212.
        {
            bIsCancelled = true;
        }
    }
 
    void MarkAsSuccessfullyFinished()
    {
        bSuccess = true;
    }
 
    UE_API void ScheduleGTTask();
    UE_API void ScheduleRenderTask();
    UE_API void ScheduleAsyncTask();
 
    friend class FRenderAssetUpdateTickGTTask;
 
    class FMipUpdateTask : public FNonAbandonableTask
    {
    public:
        FMipUpdateTask(FRenderAssetUpdate* InPendingUpdate) : PendingUpdate(InPendingUpdate) {}
 
        void DoWork();
 
        inline TStatId GetStatId() const
        {
            RETURN_QUICK_DECLARE_CYCLE_STAT(FMipUpdateTask, STATGROUP_ThreadPoolAsyncTasks);
        }
 
    protected:
        TRefCountPtr<FRenderAssetUpdate> PendingUpdate;
    };
 
    typedef FAutoDeleteAsyncTask<FMipUpdateTask> FAsyncMipUpdateTask;
 
    const FStreamableRenderResourceState ResourceState;
    // The resident first LOD resource index. With domain = [0, ResourceState.NumLODs[. NOT THE ASSET LOD INDEX!
    const int32 CurrentFirstLODIdx = INDEX_NONE;
    // The requested first LOD resource index. With domain = [0, ResourceState.NumLODs[. NOT THE ASSET LOD INDEX!
    const int32 PendingFirstLODIdx = INDEX_NONE;
    
    FCriticalSection CS;
 
    int32 ScheduledGTTasks;
 
    int32 ScheduledRenderTasks;
 
    int32 ScheduledAsyncTasks;
 
    const UStreamableRenderAsset* StreamableAsset = nullptr;
 
    FThreadSafeCounter  TaskSynchronization;
 
    bool bIsCancelled;
 
    bool bDeferExecution;
 
    bool bSuccess;
 
    volatile ETaskState TaskState;
 
private:
 
    mutable FThreadSafeCounter NumRefs;
};
 
template <typename TContext>
class TRenderAssetUpdate : public FRenderAssetUpdate
{
public:
 
    typedef TContext FContext;
 
    typedef TFunction<void(const FContext& Context)> FCallback;
 
    TRenderAssetUpdate(const UStreamableRenderAsset* InAsset);
 
    void PushTask(const FContext& Context, EThreadType InTaskThread, const FCallback& InTaskCallback, EThreadType InCancelationThread, const FCallback& InCancelationCallback);
 
    EThreadType GetRelevantThread() const final override { return bIsCancelled ? CancelationThread : TaskThread;  }
 
protected:
 
    EThreadType TaskThread;
    FCallback TaskCallback;
    EThreadType CancelationThread; // The thread on which the callbacks should be called.
    FCallback CancelationCallback;
 
    ETaskState TickInternal(EThreadType InCurrentThread, bool bCheckForSuspension) final override;
 
    void ClearCallbacks()
    {
        TaskThread = TT_None;
        TaskCallback = nullptr;
        CancelationThread = TT_None;
        CancelationCallback = nullptr;
    }
};
 
void SuspendRenderAssetStreaming();
void ResumeRenderAssetStreaming();
 
#undef UE_API