TextureDerivedDataTask.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*==============================================================================
    TextureDerivedDataTask.h: Tasks to update texture DDC.
==============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
 
#if WITH_EDITOR
 
#include "Async/AsyncWork.h"
#include "DerivedDataCacheKeyProxy.h"
#include "Engine/Texture2D.h"
#include "IImageWrapperModule.h"
#include "ImageCore.h"
#include "TextureCompiler.h"
#include "Misc/EnumClassFlags.h"
#include "TextureCompressorModule.h"
#include "TextureEncodingSettings.h"
 
#endif // WITH_EDITOR
 
 
enum
{
    NUM_INLINE_DERIVED_MIPS = 7,
};
 
#if WITH_EDITOR
 
namespace UE::DerivedData { class FBuildOutput; }
 
void GetTextureDerivedDataKeySuffix(const UTexture& Texture, const FTextureBuildSettings* BuildSettingsPerLayer, FString& OutKeySuffix);
int64 PutDerivedDataInCache(FTexturePlatformData* DerivedData, const FString& DerivedDataKeySuffix, const FStringView& TextureName, bool bForceAllMipsToBeInlined, bool bReplaceExistingDDC);
 
enum class ETextureCacheFlags : uint32
{
    None            = 0x00,
    Async           = 0x01,
    ForceRebuild    = 0x02,
    
    InlineMips      = 0x08, 
    AllowAsyncBuild = 0x10,
    ForDDCBuild     = 0x20,
    RemoveSourceMipDataAfterCache = 0x40,
    AllowAsyncLoading = 0x80,
    ForVirtualTextureStreamingBuild = 0x100,
};
 
ENUM_CLASS_FLAGS(ETextureCacheFlags);
 
// Everything required to get the texture source data.
struct FTextureSourceLayerData
{
    ERawImageFormat::Type ImageFormat = ERawImageFormat::Invalid;
    EGammaSpace SourceGammaSpace = EGammaSpace::Invalid;
};
 
struct FTextureSourceBlockData
{
    TArray<TArray<FImage>> MipsPerLayer; // @@ use FImageView instead
    int32 BlockX = 0;
    int32 BlockY = 0;
    int32 SizeInBlocksX = 1; // Normally each blocks covers a 1x1 block area
    int32 SizeInBlocksY = 1;
    int32 SizeX = 0;
    int32 SizeY = 0;
    int32 NumMips = 0;
    int32 NumSlices = 0;
    int32 MipBias = 0;
};
 
struct FTextureSourceData
{
    FTextureSourceData()
        : SizeInBlocksX(0)
        , SizeInBlocksY(0)
        , BlockSizeX(0)
        , BlockSizeY(0)
        , bValid(false)
    {}
 
    // Clear the current source data and make it into a placeholder texture.
    void InitAsPlaceholder();
 
    void Init(UTexture& InTexture, TextureMipGenSettings InMipGenSettings, bool bInCubeMap, bool bInTextureArray, bool bInVolumeTexture, ETexturePowerOfTwoSetting::Type InPow2Setting, int32 InResizeDuringBuildX, int32 InResizeDuringBuildY, bool bAllowAsyncLoading);
    bool IsValid() const { return bValid; }
 
    // ImageWrapperModule is not used
    void GetSourceMips(FTextureSource& Source, IImageWrapperModule* InImageWrapper = nullptr);
 
    void ReleaseMemory()
    {
        TRACE_CPUPROFILER_EVENT_SCOPE(Texture.ReleaseMemory);
 
        Blocks.Empty();
        Layers.Empty();
        bValid = false;
    }
 
    TArray<TPair<FLinearColor, FLinearColor>> LayerChannelMinMax; // Key == Min, Value == Max
 
    FString TextureFullName;
    TArray<FTextureSourceLayerData> Layers;
    TArray<FTextureSourceBlockData> Blocks;
    int32 SizeInBlocksX;
    int32 SizeInBlocksY;
    int32 BlockSizeX;
    int32 BlockSizeY;
    bool bValid;
};
 
class FTextureCacheDerivedDataWorker : public FNonAbandonableTask
{
    ITextureCompressorModule* Compressor;
    IImageWrapperModule* ImageWrapper;
    FTexturePlatformData* DerivedData;
    UTexture& Texture;
 
    FString TexturePathName;
 
    TArray<FTextureBuildSettings> BuildSettingsPerLayerFetchFirst;
    TArray<FTextureBuildSettings> BuildSettingsPerLayerFetchOrBuild;
 
    // Metadata for the different fetches we could do. Stored to DerivedData once we know.
    FTexturePlatformData::FTextureEncodeResultMetadata FetchFirstMetadata;
    FTexturePlatformData::FTextureEncodeResultMetadata FetchOrBuildMetadata;
 
    FString KeySuffix;
 
    FTextureSourceData TextureData;
    FTextureSourceData CompositeTextureData;
    ETextureCacheFlags CacheFlags;
    int64 BytesCached = 0;
    int64 RequiredMemoryEstimate = -1;
 
    bool bSucceeded = false;
    bool bTriedAndFailed = false;
    bool bLoadedFromDDC = false;
    UE::Tasks::FCancellationToken CancellationToken;
 
public:
 
    FTextureCacheDerivedDataWorker(
        ITextureCompressorModule* InCompressor,
        FTexturePlatformData* InDerivedData,
        UTexture* InTexture,
        const FTextureBuildSettings* InSettingsPerLayerFetchFirst, // can be nullptr
        const FTextureBuildSettings* InSettingsPerLayerFetchOrBuild,
        const FTexturePlatformData::FTextureEncodeResultMetadata* InFetchFirstMetadata, // can be nullptr
        const FTexturePlatformData::FTextureEncodeResultMetadata* InFetchOrBuildMetadata, // can be nullptr
        ETextureCacheFlags InCacheFlags);
 
    void DoWork();
 
    void Finalize();
 
    int64 GetBytesCached() const
    {
        return BytesCached;
    }
 
    int64 GetRequiredMemoryEstimate() const
    {
        return RequiredMemoryEstimate;
    }
 
    bool WasLoadedFromDDC() const
    {
        return bLoadedFromDDC;
    }
 
    FORCEINLINE TStatId GetStatId() const
    {
        RETURN_QUICK_DECLARE_CYCLE_STAT(FTextureCacheDerivedDataWorker, STATGROUP_ThreadPoolAsyncTasks);
    }
 
    void MarkAsCanceled()
    {
        if (FTextureCompilingManager::Get().IsAsyncCompilationCancelable())
        {
            CancellationToken.Cancel();
        }
    }
};
 
struct FTextureAsyncCacheDerivedDataTask
{
    virtual ~FTextureAsyncCacheDerivedDataTask() = default;
    virtual void Finalize(bool& bOutFoundInCache, uint64& OutProcessedByteCount) = 0;
    virtual EQueuedWorkPriority GetPriority() const = 0;
    virtual bool SetPriority(EQueuedWorkPriority QueuedWorkPriority) = 0;
    virtual bool Cancel() = 0;
    virtual void Wait() = 0;
    virtual bool WaitWithTimeout(float TimeLimitSeconds) = 0;
    virtual bool Poll() const = 0;
};
 
//
// DDC1 async texture fetch/build task.
//
class FTextureAsyncCacheDerivedDataWorkerTask final : public FTextureAsyncCacheDerivedDataTask, public FAsyncTask<FTextureCacheDerivedDataWorker>
{
public:
    FTextureAsyncCacheDerivedDataWorkerTask(
        FQueuedThreadPool* InQueuedPool,
        ITextureCompressorModule* InCompressor,
        FTexturePlatformData* InDerivedData,
        UTexture* InTexture,
        const FTextureBuildSettings* InSettingsPerLayerFetchFirst,
        const FTextureBuildSettings* InSettingsPerLayerFetchOrBuild,
        const FTexturePlatformData::FTextureEncodeResultMetadata* InFetchFirstMetadata,
        const FTexturePlatformData::FTextureEncodeResultMetadata* InFetchOrBuildMetadata,
        ETextureCacheFlags InCacheFlags
        )
        : FAsyncTask<FTextureCacheDerivedDataWorker>(
            InCompressor,
            InDerivedData,
            InTexture,
            InSettingsPerLayerFetchFirst,
            InSettingsPerLayerFetchOrBuild,
            InFetchFirstMetadata,
            InFetchOrBuildMetadata,
            InCacheFlags
            )
        , QueuedPool(InQueuedPool)
    {
    }
 
    void Finalize(bool& bOutFoundInCache, uint64& OutProcessedByteCount) final
    {
        GetTask().Finalize();
        bOutFoundInCache = GetTask().WasLoadedFromDDC();
        OutProcessedByteCount = GetTask().GetBytesCached();
    }
 
    EQueuedWorkPriority GetPriority() const final
    {
        return FAsyncTask<FTextureCacheDerivedDataWorker>::GetPriority();
    }
 
    bool SetPriority(EQueuedWorkPriority QueuedWorkPriority) final
    {
        return FAsyncTask<FTextureCacheDerivedDataWorker>::Reschedule(QueuedPool, QueuedWorkPriority);
    }
 
    bool Cancel() final
    {
        return FAsyncTask<FTextureCacheDerivedDataWorker>::IsDone() || FAsyncTask<FTextureCacheDerivedDataWorker>::Cancel();
    }
 
    void Wait() final
    {
        FAsyncTask<FTextureCacheDerivedDataWorker>::EnsureCompletion();
    }
 
    bool WaitWithTimeout(float TimeLimitSeconds) final
    {
        return FAsyncTask<FTextureCacheDerivedDataWorker>::WaitCompletionWithTimeout(TimeLimitSeconds);
    }
 
    bool Poll() const final
    {
        return FAsyncTask<FTextureCacheDerivedDataWorker>::IsWorkDone();
    }
 
private:
    FQueuedThreadPool* QueuedPool;
};
 
// Creates the DDC2 texture fetch/build task.
FTextureAsyncCacheDerivedDataTask* CreateTextureBuildTask(
    UTexture& Texture,
    FTexturePlatformData& DerivedData,
    const FTextureBuildSettings* SettingsFetchFirst, // can be nullptr
    const FTextureBuildSettings& SettingsFetchOrBuild,
    const FTexturePlatformData::FTextureEncodeResultMetadata* FetchMetadata,
    const FTexturePlatformData::FTextureEncodeResultMetadata* FetchOrBuildMetadata,
    EQueuedWorkPriority Priority,
    ETextureCacheFlags Flags);
 
// This needs to match the key generated by the build, otherwise the build will get continually kicked
// by CachePlatformData().
FTexturePlatformData::FStructuredDerivedDataKey CreateTextureDerivedDataKey(
    UTexture& Texture,
    ETextureCacheFlags CacheFlags,
    const FTextureBuildSettings& Settings);
 
#endif // WITH_EDITOR