StreamableRenderAsset.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "Misc/App.h"
#include "Engine/TextureStreamingTypes.h"
#include "Serialization/BulkData.h"
#include "Templates/RefCounting.h"
#include "Streaming/StreamableRenderResourceState.h"
#include "PerQualityLevelProperties.h"
#include "StreamableRenderAsset.generated.h"
 
#define STREAMABLERENDERASSET_NODEFAULT(FuncName) LowLevelFatalError(TEXT("UStreamableRenderAsset::%s has no default implementation"), TEXT(#FuncName))
 // Allows yield to lower priority threads
#define RENDER_ASSET_STREAMING_SLEEP_DT (0.010f)
 
namespace Nanite
{
    class FCoarseMeshStreamingManager;
}
 
enum class EStreamableRenderAssetType : uint8
{
    None,
    Texture,
    StaticMesh,
    SkeletalMesh,
    LandscapeMeshMobile UE_DEPRECATED(5.1, "LandscapeMeshMobile is now deprecated and will be removed."),
    NaniteCoarseMesh,
};
 
UCLASS(Abstract, MinimalAPI)
class UStreamableRenderAsset : public UObject
{
    GENERATED_UCLASS_BODY()
 
public:
 
    ENGINE_API virtual ~UStreamableRenderAsset();
 
    virtual int32 GetLODGroupForStreaming() const
    {
        return 0;
    }
 
    virtual int32 CalcCumulativeLODSize(int32 NumLODs) const
    {
        STREAMABLERENDERASSET_NODEFAULT(CalcCumulativeLODSize);
        return -1;
    }
 
    virtual FIoFilenameHash GetMipIoFilenameHash(const int32 MipIndex) const
    {
        STREAMABLERENDERASSET_NODEFAULT(GetMipIoFilenameHash);
        return INVALID_IO_FILENAME_HASH;
    }
 
    virtual bool DoesMipDataExist(const int32 MipIndex) const
    {
        STREAMABLERENDERASSET_NODEFAULT(DoesMipDataExist);
        return false;
    }
 
    ENGINE_API void CancelPendingStreamingRequest();
 
    ENGINE_API bool HasPendingInitOrStreaming(bool bWaitForLODTransition = false) const;
 
    bool IsPendingStreamingRequestLocked() const;
 
    virtual bool StreamOut(int32 NewMipCount)
    {
        STREAMABLERENDERASSET_NODEFAULT(StreamOut);
        return false;
    }
 
    virtual bool StreamIn(int32 NewMipCount, bool bHighPrio)
    {
        STREAMABLERENDERASSET_NODEFAULT(StreamIn);
        return false;
    }
 
    virtual void InvalidateLastRenderTimeForStreaming() {}
 
    virtual float GetLastRenderTimeForStreaming() const { return FLT_MAX; }
 
    virtual bool ShouldMipLevelsBeForcedResident() const
    {
        return bGlobalForceMipLevelsToBeResident
            || bForceMiplevelsToBeResident
            || ForceMipLevelsToBeResidentTimestamp >= FApp::GetCurrentTime();
    }
 
    ENGINE_API void RegisterMipLevelChangeCallback(UPrimitiveComponent* Component, int32 LODIdx, float TimeoutSecs, bool bOnStreamIn, FLODStreamingCallback&& Callback);
 
    ENGINE_API void RegisterMipLevelChangeCallback(UPrimitiveComponent* Component, float TimeoutStartSecs, FLODStreamingCallback&& CallbackStreamingStart, float TimeoutDoneSecs, FLODStreamingCallback&& CallbackStreamingDone);
 
    ENGINE_API void RemoveMipLevelChangeCallback(UPrimitiveComponent* Component);
 
    ENGINE_API void RemoveAllMipLevelChangeCallbacks();
 
    ENGINE_API void TickMipLevelChangeCallbacks(TArray<UStreamableRenderAsset*>* DeferredTickCBAssets);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    ENGINE_API void SetForceMipLevelsToBeResident(float Seconds, int32 CinematicLODGroupMask = 0);
 
    virtual int32 GetCachedLODBias() const 
    { 
        return 0; 
    }
 
    inline const FStreamableRenderResourceState& GetStreamableResourceState() const 
    { 
        return CachedSRRState; 
    }
 
    inline bool RenderResourceSupportsStreaming() const { return CachedSRRState.bSupportsStreaming && CachedSRRState.MaxNumLODs > CachedSRRState.NumNonStreamingLODs; }
 
    inline bool IsStreamable() const { return StreamingIndex != INDEX_NONE; }
 
    ENGINE_API void LinkStreaming();
    ENGINE_API void UnlinkStreaming();
 
    ENGINE_API bool IsFullyStreamedIn();
 
    inline int32 GetStreamingIndex() const { return StreamingIndex; }
 
    ENGINE_API void WaitForPendingInitOrStreaming(bool bWaitForLODTransition = false, bool bSendCompletionEvents = false);
 
    ENGINE_API void WaitForStreaming(bool bWaitForLODTransition = false, bool bSendCompletionEvents = false);
 
    void TickStreaming(bool bSendCompletionEvents = false, TArray<UStreamableRenderAsset*>* DeferredTickCBAssets = nullptr);
 
    virtual EStreamableRenderAssetType GetRenderAssetType() const { return EStreamableRenderAssetType::None; }
 
    ENGINE_API virtual void BeginDestroy() override;
    ENGINE_API virtual bool IsReadyForFinishDestroy() override;
 
    const FPerQualityLevelInt& GetNoRefStreamingLODBias() const
    {
        return NoRefStreamingLODBias;
    }
 
    void SetNoRefStreamingLODBias(FPerQualityLevelInt NewValue)
    {
        NoRefStreamingLODBias = MoveTemp(NewValue);
    }
 
    ENGINE_API int32 GetCurrentNoRefStreamingLODBias() const;
 
protected:
    
    // Also returns false if the render resource is non existent, to prevent stalling on an event that will never complete.
    virtual bool HasPendingRenderResourceInitialization() const { return false; }
 
    virtual bool HasPendingLODTransition() const { return false; }
 
    struct FLODStreamingCallbackPayload
    {
        UPrimitiveComponent* Component;
        double DeadlineStart;
        double DeadlineDone;
        int32 ExpectedResidentMips;
        bool bOnStreamIn;
        bool bIsExpectedResidentMipPayload;
        FLODStreamingCallback CallbackStart;
        FLODStreamingCallback CallbackDone;
 
        FLODStreamingCallbackPayload(UPrimitiveComponent* InComponent, double InDeadlineDone, int32 ExpectedResidentMips, bool bInOnStreamIn, FLODStreamingCallback&& InCallbackStreamingDone)
            : Component(InComponent)
            , DeadlineStart(InDeadlineDone)
            , DeadlineDone(InDeadlineDone)
            , ExpectedResidentMips(ExpectedResidentMips)
            , bOnStreamIn(bInOnStreamIn)
            , bIsExpectedResidentMipPayload(true)
            , CallbackStart()
            , CallbackDone(MoveTemp(InCallbackStreamingDone))
        {}
 
        FLODStreamingCallbackPayload(UPrimitiveComponent* InComponent, double InDeadlineStart, FLODStreamingCallback&& InCallbackStreamingStart, double InDeadlineDone, FLODStreamingCallback&& InCallbackStreamingDone)
            : Component(InComponent)
            , DeadlineStart(InDeadlineStart)
            , DeadlineDone(InDeadlineDone)
            , ExpectedResidentMips()
            , bOnStreamIn()
            , bIsExpectedResidentMipPayload(false)
            , CallbackStart(MoveTemp(InCallbackStreamingStart))
            , CallbackDone(MoveTemp(InCallbackStreamingDone))
        {}
    };
 
    TArray<FLODStreamingCallbackPayload> MipChangeCallbacks;
 
    TRefCountPtr<class FRenderAssetUpdate> PendingUpdate;
 
    UPROPERTY(transient)
    double ForceMipLevelsToBeResidentTimestamp;
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = LevelOfDetail, AdvancedDisplay)
    int32 NumCinematicMipLevels;
 
protected:
    UPROPERTY()
    FPerQualityLevelInt NoRefStreamingLODBias;
 
    UPROPERTY(transient, duplicatetransient, NonTransactional)
    int32 StreamingIndex = INDEX_NONE;
    
    friend class FAsyncRenderAssetStreamingData;
    friend class FSimpleStreamableAssetManager;
    TSharedPtr<int32, ESPMode::ThreadSafe> SimpleStreamableAssetManagerIndex = MakeShared<int32, ESPMode::ThreadSafe>(INDEX_NONE);
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = LevelOfDetail, AssetRegistrySearchable, AdvancedDisplay)
    uint8 NeverStream : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = LevelOfDetail, meta = (DisplayName = "Global Force Resident Mip Levels"), AdvancedDisplay)
    uint8 bGlobalForceMipLevelsToBeResident : 1;
 
    UPROPERTY(transient, NonTransactional)
    uint8 bHasStreamingUpdatePending : 1;
 
    UPROPERTY(transient)
    uint8 bForceMiplevelsToBeResident : 1;
 
    UPROPERTY(transient)
    uint8 bIgnoreStreamingMipBias : 1;
 
    UPROPERTY(transient)
    uint8 bMarkAsEditorStreamingPool : 1;
    
protected:
    UPROPERTY(transient)
    uint8 bUseCinematicMipLevels : 1;
 
    FStreamableRenderResourceState CachedSRRState;
 
    friend struct FRenderAssetStreamingManager;
    friend struct FStreamingRenderAsset;
    friend class Nanite::FCoarseMeshStreamingManager;
};