TextureMipAllocator.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
TextureMipAllocator.h: Base class for implementing a mip allocation strategy used by FTextureStreamIn.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "RHIFwd.h"
#include "Streaming/TextureMipDataProvider.h"
 
class FTextureMipAllocator
{
public:
 
    enum class ETickState : uint32
    {
        AllocateMips,   // Call AllocateMips(), which must provide destination memory for the mips to be written to.
        UploadMips,     // Call UploadMips(), which must release temporary buffers and update/upload the texture to the gpu.
        Done            // Nothing to do.
    };
 
    enum class ETickThread : uint32
    {
        Async,          // Tick must run on an async thread.
        Render,         // Tick must run on the renderthread.
        None,           // No tick must run, only valid in ETickState::Done. 
    };
 
    // Constructor, defining the first tick step and thread.
    FTextureMipAllocator(UTexture* Texture, ETickState InTickState, ETickThread InTickThread);
    FTextureMipAllocator(const FTextureMipAllocator&);
    FTextureMipAllocator(FTextureMipAllocator&&);
    virtual ~FTextureMipAllocator();
 
    // Get the next tick state and thread for the mip allocator. Used by FTextureStreamIn to schedule correctly the update between FTextureMipAllocator and FTextureMipDataProvider.
    FORCEINLINE ETickState GetNextTickState() const { return NextTickState; }
    FORCEINLINE ETickThread GetNextTickThread() const { return NextTickThread; }
 
    virtual bool AllocateMips(const FTextureUpdateContext& Context, FTextureMipInfoArray& OutMipInfos, const FTextureUpdateSyncOptions& SyncOptions) = 0;
    
    virtual bool UploadMips(const FTextureUpdateContext& Context, const FTextureUpdateSyncOptions& SyncOptions) = 0;
 
    bool FinalizeMips(const FTextureUpdateContext& Context, const FTextureUpdateSyncOptions& SyncOptions);
 
    // Wrapper around virtual Cancel.
    void ExecuteCancel(const FTextureUpdateSyncOptions& SyncOptions);
 
    // Wrapper around virtual GetCancelThread.
    ETickThread ExecuteGetCancelThread() const;
 
    const FTextureRHIRef& GetIntermediateTextureRHI() const { return IntermediateTextureRHI; }
 
protected:
 
    virtual void Cancel(const FTextureUpdateSyncOptions& SyncOptions) = 0;
 
    // Returns on which thread Cancel() must be called in the texture update (from FTextureStreamIn) to release resources safely and correctly. ETickThread::None when ready to delete this.
    virtual ETickThread GetCancelThread() const = 0;
 
    // Helper to set the next tick state and thread. Validates that the progression is coherent.
    FORCEINLINE void AdvanceTo(ETickState InState, ETickThread InThread)
    {
        // State must advance or at least stay to the same step.
        check((uint32)NextTickState <= (uint32)InState);
        // Thread must be valid unless in done state.
        check((InState == ETickState::Done) == (InThread == ETickThread::None));
 
        NextTickState = InState;
        NextTickThread = InThread;
    }
 
    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;
 
    FTextureRHIRef IntermediateTextureRHI;
 
private:
 
    // The next tick function that should be called.
    ETickState NextTickState = ETickState::Done;
    // The next tick thread from where to call the tick function.
    ETickThread NextTickThread = ETickThread::None;
};