Texture.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Containers/IndirectArray.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "Misc/Guid.h"
#include "Templates/SubclassOf.h"
#include "Interfaces/Interface_AssetUserData.h"
#include "Interfaces/Interface_AsyncCompilation.h"
#include "RenderCommandFence.h"
#include "Serialization/EditorBulkData.h"
#include "Engine/TextureDefines.h"
#include "MaterialValueType.h"
#include "Engine/StreamableRenderAsset.h"
#include "UObject/PerPlatformProperties.h"
#include "ImageCore.h"
#if WITH_EDITORONLY_DATA
#include "Misc/TVariant.h"
#include "ObjectCacheEventSink.h"
#include "DerivedDataCacheKeyProxy.h"
#endif
 
#if WITH_EDITOR
#include "Templates/DontCopy.h"
#endif
 
#include "Texture.generated.h"
 
namespace FOodleDataCompression {enum class ECompressor : uint8; enum class ECompressionLevel : int8; }
enum class EVTProducerPriority : uint8;
 
class FTextureReference;
class FTextureResource;
class ITargetPlatform;
class ITargetPlatformSettings;
class UAssetUserData;
struct FPropertyChangedEvent;
struct FTextureBuildSettings;
 
#if WITH_EDITORONLY_DATA
namespace UE::DerivedData { struct FValueId; }
#endif
 
USTRUCT()
struct FTextureSourceLayerColorInfo
{
    GENERATED_USTRUCT_BODY();
 
    UPROPERTY(VisibleAnywhere, Category = TextureSource)
    FLinearColor ColorMin = FLinearColor(EForceInit::ForceInitToZero);
 
    UPROPERTY(VisibleAnywhere, Category = TextureSource)
    FLinearColor ColorMax = FLinearColor(EForceInit::ForceInitToZero);
};
 
USTRUCT()
struct FTextureSourceBlock
{
    GENERATED_USTRUCT_BODY()
 
    ENGINE_API FTextureSourceBlock();
 
    UPROPERTY(VisibleAnywhere, Category = TextureSource)
    int32 BlockX;
 
    UPROPERTY(VisibleAnywhere, Category = TextureSource)
    int32 BlockY;
 
    UPROPERTY(VisibleAnywhere, Category = TextureSource)
    int32 SizeX;
 
    UPROPERTY(VisibleAnywhere, Category = TextureSource)
    int32 SizeY;
 
    UPROPERTY(VisibleAnywhere, Category = TextureSource)
    int32 NumSlices;
 
    UPROPERTY(VisibleAnywhere, Category = TextureSource)
    int32 NumMips;
};
 
USTRUCT()
struct FTextureSource
{
    GENERATED_USTRUCT_BODY()
 
    
    ENGINE_API FTextureSource();
 
    // should match ERawImageFormat::GetBytesPerPixel
    ENGINE_API static int64 GetBytesPerPixel(ETextureSourceFormat Format);
    // should match ERawImageFormat::IsHDR
    inline static bool IsHDR(ETextureSourceFormat Format) { return UE::TextureDefines::IsHDR(Format); }
    
    enum class ELockState : uint8
    {
        None,
        ReadOnly,
        ReadWrite
    };
 
#if WITH_EDITOR
    // FwdDecl for member structs
    struct FMipData;
 
    ENGINE_API void InitBlocked(const ETextureSourceFormat* InLayerFormats,
        const FTextureSourceBlock* InBlocks,
        int32 InNumLayers,
        int32 InNumBlocks,
        const uint8** InDataPerBlock);
 
    ENGINE_API void InitBlocked(const ETextureSourceFormat* InLayerFormats,
        const FTextureSourceBlock* InBlocks,
        int32 InNumLayers,
        int32 InNumBlocks,
        UE::Serialization::FEditorBulkData::FSharedBufferWithID NewData);
 
    ENGINE_API void InitLayered(
        int32 NewSizeX,
        int32 NewSizeY,
        int32 NewNumSlices,
        int32 NewNumLayers,
        int32 NewNumMips,
        const ETextureSourceFormat* NewLayerFormat,
        const uint8* NewData = NULL
        );
 
    ENGINE_API void InitLayered(
        int32 NewSizeX,
        int32 NewSizeY,
        int32 NewNumSlices,
        int32 NewNumLayers,
        int32 NewNumMips,
        const ETextureSourceFormat* NewLayerFormat,
        UE::Serialization::FEditorBulkData::FSharedBufferWithID NewData
    );
 
    ENGINE_API void Init(
        int32 NewSizeX,
        int32 NewSizeY,
        int32 NewNumSlices,
        int32 NewNumMips,
        ETextureSourceFormat NewFormat,
        const uint8* NewData = NULL
        );
    
    ENGINE_API void Init(const FImageView & Image);
 
    ENGINE_API void Init(
        int32 NewSizeX,
        int32 NewSizeY,
        int32 NewNumSlices,
        int32 NewNumMips,
        ETextureSourceFormat NewFormat,
        UE::Serialization::FEditorBulkData::FSharedBufferWithID NewData
    );
 
    ENGINE_API void Init2DWithMipChain(
        int32 NewSizeX,
        int32 NewSizeY,
        ETextureSourceFormat NewFormat
        );
 
    ENGINE_API void InitLayered2DWithMipChain(
        int32 NewSizeX,
        int32 NewSizeY,
        int32 NewNumLayers,
        const ETextureSourceFormat* NewFormat
    );
 
    ENGINE_API void InitCubeWithMipChain(
        int32 NewSizeX,
        int32 NewSizeY,
        ETextureSourceFormat NewFormat
        );
 
    ENGINE_API void InitWithCompressedSourceData(
        int32 NewSizeX,
        int32 NewSizeY,
        int32 NewNumMips,
        ETextureSourceFormat NewFormat,
        const TArrayView64<uint8> NewSourceData,
        ETextureSourceCompressionFormat NewSourceFormat
    );
 
    ENGINE_API void InitWithCompressedSourceData(
        int32 NewSizeX,
        int32 NewSizeY,
        int32 NewNumMips,
        ETextureSourceFormat NewFormat,
        UE::Serialization::FEditorBulkData::FSharedBufferWithID NewSourceData,
        ETextureSourceCompressionFormat NewSourceFormat
    );
 
    ENGINE_API FTextureSource CopyTornOff() const;
    
    ENGINE_API void Compress();
 
    ENGINE_API void ForceGenerateGuid();
 
    ENGINE_API const uint8* LockMipReadOnly(int32 BlockIndex, int32 LayerIndex, int32 MipIndex);
 
    ENGINE_API uint8* LockMip(int32 BlockIndex, int32 LayerIndex, int32 MipIndex);
 
    ENGINE_API void UnlockMip(int32 BlockIndex, int32 LayerIndex, int32 MipIndex);
 
    ENGINE_API bool GetMipData(TArray64<uint8>& OutMipData, int32 BlockIndex, int32 LayerIndex, int32 MipIndex, class IImageWrapperModule* ImageWrapperModule = nullptr);
    
    inline bool GetMipData(TArray64<uint8>& OutMipData, int32 MipIndex, class IImageWrapperModule* ImageWrapperModule = nullptr)
    {
        return GetMipData(OutMipData, 0, 0, MipIndex, ImageWrapperModule);
    }
 
    ENGINE_API bool GetMipImage(FImage & OutImage, int32 BlockIndex, int32 LayerIndex, int32 MipIndex);
    
    inline bool GetMipImage(FImage & OutImage, int32 MipIndex)
    {
        return GetMipImage(OutImage, 0, 0, MipIndex);
    }
 
    ENGINE_API FMipData GetMipData(class IImageWrapperModule* ImageWrapperModule);
 
    ENGINE_API bool GetMipImageInfo(FImageInfo & OutImageInfo, int32 BlockIndex, int32 LayerIndex, int32 MipIndex) const;
 
    ENGINE_API int64 CalcMipSize(int32 BlockIndex, int32 LayerIndex, int32 MipIndex) const;
    
    ENGINE_API int64 CalcMipOffset(int32 BlockIndex, int32 LayerIndex, int32 MipIndex) const;
 
    ENGINE_API int64 GetBytesPerPixel(int32 LayerIndex = 0) const;
 
    UE_DEPRECATED(5.5,"Prefer AreAllBlocksPowerOfTwo, or IsBlockPowerOfTwo if you really only want one block")
    bool IsPowerOfTwo(int32 BlockIndex = 0) const { return IsBlockPowerOfTwo(BlockIndex); }
    
    ENGINE_API bool IsBlockPowerOfTwo(int32 BlockIndex) const;
    ENGINE_API bool AreAllBlocksPowerOfTwo() const;
 
    ENGINE_API bool IsValid() const;
 
    ENGINE_API void GetBlock(int32 Index, FTextureSourceBlock& OutBlock) const;
 
    ENGINE_API FIntPoint GetLogicalSize() const;
 
    ENGINE_API FIntPoint GetSizeInBlocks() const;
    
    /* Total number of pixels in the top mip level over all blocks+layers.
    This is the pixel count of the source data, not the size of the built virtual canvas. */
    ENGINE_API int64 GetTotalTopMipPixelCount() const;
 
    ENGINE_API FString GetIdString() const;
 
    ENGINE_API FString GetSourceCompressionAsString() const;
 
    inline ETextureSourceCompressionFormat GetSourceCompression() const { return CompressionFormat; }
    inline bool IsSourceCompressed() const { return GetSourceCompression() != ETextureSourceCompressionFormat::TSCF_None; }
    ENGINE_API void RemoveCompression();
 
    ENGINE_API EGammaSpace GetGammaSpace(int LayerIndex) const;
    
    ENGINE_API ETextureClass GetTextureClass() const;
 
    ENGINE_API int GetMippedNumSlices(int NumSlices,int MipIndex) const;
 
    ENGINE_API void ExportCustomProperties(FOutputDevice& Out, uint32 Indent);
    ENGINE_API void ImportCustomProperties(const TCHAR* SourceText, FFeedbackContext* Warn);
 
    inline FGuid GetPersistentId() const { return BulkData.GetIdentifier(); }
    ENGINE_API FGuid GetId() const;
    inline int64 GetSizeX() const { return SizeX; }
    inline int64 GetSizeY() const { return SizeY; }
    inline int32 GetNumSlices() const { return NumSlices; }
    inline int32 GetNumMips() const { return NumMips; }
    inline int32 GetNumLayers() const { return NumLayers; }
    inline int32 GetNumBlocks() const { return Blocks.Num() + 1; }
    inline ETextureSourceFormat GetFormat(int32 LayerIndex = 0) const { return (LayerIndex == 0) ? Format : LayerFormat[LayerIndex]; }
    
    // Warning: bLongLatCubemap is not correct.  LongLat Cubemaps often have bLongLatCubemap == false
    // bLongLatCubemap is sometimes set to true for cube arrays to disambiguate the case of 6 longlat cubemaps in an array
    ENGINE_API bool IsCubeOrCubeArray() const;
    ENGINE_API bool IsVolume() const;
    ENGINE_API bool IsLongLatCubemap() const;
    // returns volume depth, or 1 if not a volume
    ENGINE_API int GetVolumeSizeZ() const;
 
    //note: simple queries on BulkData are not taking the BulkDataLock , nor does BulkData internally mutex protect these
    inline int64 GetSizeOnDisk() const { return BulkData.GetPayloadSize(); }
    inline bool HasPayloadData() const { return BulkData.HasPayloadData(); } // this is the same as GetSizeOnDisk() != 0
    
    ENGINE_API void Reset();
 
    // Apply a visitor to the bulkdata : prefer GetBulkDataPayload() instead.
    ENGINE_API void OperateOnLoadedBulkData(TFunctionRef<void (const FSharedBuffer& BulkDataBuffer)> Operation);
 
    // GetBulkDataPayload returns the raw bulkdata memory in compressed form, not decompressed (use LockMip or GetMipData for that)
    //  the shared buffer should be treated as read only!
    //  to modify, make a copy and call Init() on the source with the changed copy
    ENGINE_API FSharedBuffer GetBulkDataPayload();
        
    //  broken function, did the opposite of its name (was == DoesPayloadNeedLoading, which is usually == HasPayloadData)
    UE_DEPRECATED(5.5, "IsBulkDataLoaded was broken, do not use")
    inline bool IsBulkDataLoaded() const { return true; }
 
    UE_DEPRECATED(5.0, "There is no longer a need to call LoadBulkDataWithFileReader, FTextureSource::BulkData can now load the data on demand without it.")
    inline bool LoadBulkDataWithFileReader() { return true; }
    
    UE_DEPRECATED(5.5, "RemoveBulkData did not actually remove bulkdata; use ReleaseBulkDataCachedMemory if that's what you wanted")
    inline void RemoveBulkData() { }
    
    ENGINE_API void SetId(const FGuid& InId, bool bInGuidIsHash);
 
    inline int64 CalcMipSize(int32 MipIndex) const { return CalcMipSize(0, 0, MipIndex); }
    inline const uint8* LockMipReadOnly(int32 MipIndex) { return LockMipReadOnly(0, 0, MipIndex); }
    inline uint8* LockMip(int32 MipIndex) { return LockMip(0, 0, MipIndex); }
    inline void UnlockMip(int32 MipIndex) { UnlockMip(0, 0, MipIndex); }
 
    inline void SetOwner(UTexture* InOwner) { Owner = InOwner; }
 
    struct FMipAllocation
    {
        FMipAllocation() = default;
        FMipAllocation(FSharedBuffer SrcData);
 
        // Do not actually do anything for copy constructor or assignments, this is required for as long as
        // we need to support the old bulkdata code path (although previously storing these allocations as
        // raw pointers would allow it to be assigned, this would most likely cause a mismatch in lock counts,
        // either in FTextureSource or the underlying bulkdata and was never actually safe)
        FMipAllocation(const FMipAllocation&) {}
        FMipAllocation& operator =(const FMipAllocation&) { return *this; }
 
        // We do allow rvalue assignment
        ENGINE_API FMipAllocation(FMipAllocation&&);
        ENGINE_API FMipAllocation& operator =(FMipAllocation&&);
 
        ~FMipAllocation() = default;
 
        void Reset();
 
        bool IsNull() const { return ReadOnlyReference.IsNull(); }
 
        int64 GetSize() const { return ReadOnlyReference.GetSize(); }
 
        const FSharedBuffer& GetDataReadOnly() const { return ReadOnlyReference; }
 
        UE_DEPRECATED(5.4, "Use GetDataReadWriteView instead")
        uint8* GetDataReadWrite() { return (uint8*)GetDataReadWriteView().GetData(); }
 
        FMutableMemoryView GetDataReadWriteView();
 
        FSharedBuffer Release();
 
    private:
        void CreateReadWriteBuffer(const void* SrcData, int64 DataLength);
 
        struct FDeleterFree
        {
            void operator()(uint8* Ptr) const
            {
                if (Ptr)
                {
                    FMemory::Free(Ptr);
                }
            }
        };
 
        FSharedBuffer                   ReadOnlyReference;
        TUniquePtr<uint8, FDeleterFree> ReadWriteBuffer;
    };
 
    struct FMipData
    {
        FMipData(FMipData&& Other)
            : TextureSource(Other.TextureSource)
        {
            MipData = MoveTemp(Other.MipData);
        }
 
        ~FMipData() = default;
 
        FMipData() = delete;
        FMipData(const FMipData&) = delete;
        FMipData& operator=(const FMipData&) = delete;
        FMipData& operator=(FMipData&& Other) = delete;
 
        ENGINE_API bool GetMipData(TArray64<uint8>& OutMipData, int32 BlockIndex, int32 LayerIndex, int32 MipIndex) const;
 
        ENGINE_API FSharedBuffer GetMipData(int32 BlockIndex, int32 LayerIndex, int32 MipIndex) const;
        ENGINE_API FSharedBuffer GetMipDataWithInfo(int32 InBlockIndex, int32 InLayerIndex, int32 InMipIndex, FImageInfo& OutMipImageInfo) const;
 
        // note: FImageView does not hold a ref on the FSharedBuffer memory it points at
        //  you must keep the FMipData around or hold a ref on the FSharedBuffer elsewhere
        inline FImageView GetMipDataImageView(int32 BlockIndex, int32 LayerIndex, int32 MipIndex) const
        {
            FImageInfo Info;
            FSharedBuffer Buffer = GetMipDataWithInfo(BlockIndex,LayerIndex,MipIndex,Info);
            return FImageView(Info,const_cast<void *>(Buffer.GetData()));
        }
 
        inline bool IsValid() const { return !MipData.IsNull(); }
 
        inline void ResetData() { MipData.Reset(); }
 
        inline FSharedBuffer GetData() const { return MipData; }
 
    private:
        // We only want to allow FTextureSource to create FMipData objects
        friend struct FTextureSource;
 
        ENGINE_API FMipData(const FTextureSource& InSource, FSharedBuffer InData);
 
        const FTextureSource& TextureSource;
        FSharedBuffer MipData;
    };
    
    struct FMipLock
    {
        // constructor locks the mip (can fail, check IsValid())
        ENGINE_API FMipLock(ELockState InLockState,FTextureSource * InTextureSource,int32 InBlockIndex, int32 InLayerIndex, int32 InMipIndex);
        ENGINE_API FMipLock(ELockState InLockState,FTextureSource * InTextureSource,int32 InMipIndex);
        
        // move constructor
        ENGINE_API FMipLock(FMipLock&&);
 
        // destructor unlocks
        ENGINE_API ~FMipLock();
        
        ELockState LockState;
        FTextureSource * TextureSource;
        int32 BlockIndex;
        int32 LayerIndex;
        int32 MipIndex;
        FImageView Image;
 
        const void * GetRawData() const
        {
            check( LockState != ELockState::None );
            return Image.RawData;
        }
        void * GetMutableData() const
        {
            check( LockState == ELockState::ReadWrite );
            return Image.RawData;
        }
        int64 GetDataSize() const { return Image.GetImageSizeBytes(); }
 
        bool IsValid() const
        {
            // two criteria should be the same :
            bool bNotNull = Image.RawData != nullptr;
            bool bNotNone = LockState != ELockState::None;
            check( bNotNull == bNotNone );
            return bNotNull;
        }
 
    private:
        
        // no copying or default construct
        FMipLock() = delete;
        FMipLock(const FMipLock&) = delete;
        FMipLock& operator=(const FMipLock&) = delete;
        FMipLock& operator=(FMipLock&& Other) = delete;
    };
#endif // WITH_EDITOR
 
private:
    friend class UTexture;
    friend class UTexture2D;
    friend class UTextureCube;
    friend class UVolumeTexture;
    friend class UTexture2DArray;
    friend class UTextureCubeArray;
 
#if WITH_EDITOR
    TDontCopy<FCriticalSection> BulkDataLock;
    UTexture* Owner;
    ETextureClass TornOffTextureClass;
    TArray<EGammaSpace, TInlineAllocator<1>> TornOffGammaSpace;
    /* For debugging : */
    FString TornOffOwnerName;
#endif
    UE::Serialization::FEditorBulkData BulkData;
    
    uint32 NumLockedMips;
 
    ELockState LockState;
 
    void CheckTextureIsUnlocked(const TCHAR* DebugMessage);
 
#if WITH_EDITOR
    FMipAllocation LockedMipData;
 
    // Internal implementation for locking the mip data, called by LockMipReadOnly or LockMip.
    FMutableMemoryView LockMipInternal(int32 BlockIndex, int32 LayerIndex, int32 MipIndex, ELockState RequestedLockState, FImageInfo & OutImageInfo);
        
    // ImageWrapperModule is not used
    FSharedBuffer Decompress(class IImageWrapperModule* ImageWrapperModule = nullptr) const;
    FSharedBuffer TryDecompressData() const;
    FSharedBuffer DoUEDeltaTransform(FSharedBuffer InBuffer,bool bForward) const;
        
    /* total size of source data in bytes */
    int64 CalcTotalSize() const;
    /* size of block in bytes, over all layers */
    int64 CalcBlockSize(int32 BlockIndex) const;
    int64 CalcLayerSize(int32 BlockIndex, int32 LayerIndex) const;
    int64 CalcBlockSize(const FTextureSourceBlock& Block) const;
    int64 CalcLayerSize(const FTextureSourceBlock& Block, int32 LayerIndex) const;
    
    void InitLayeredImpl(
        int32 NewSizeX,
        int32 NewSizeY,
        int32 NewNumSlices,
        int32 NewNumLayers,
        int32 NewNumMips,
        const ETextureSourceFormat* NewLayerFormat);
 
    void InitBlockedImpl(const ETextureSourceFormat* InLayerFormats,
        const FTextureSourceBlock* InBlocks,
        int32 InNumLayers,
        int32 InNumBlocks);
 
    bool EnsureBlocksAreSorted();
 
public:
    // UpdateChannelLinearMinMax runs FImageCore::ComputeChannelLinearMinMax on all blocks and layers (but only mip0), returns false
    //   if the source was unable to be locked and leaves the channel minmax as unknown. 
    // Compute just gets the values and leaves the cached minax in the Source untouched.
    ENGINE_API bool UpdateChannelLinearMinMax();
    ENGINE_API bool ComputeChannelLinearMinMax(int32 InLayerIndex, FLinearColor& OutMinColor, FLinearColor& OutMaxColor) const;
 
    ENGINE_API void GetLayerColorInfo(TArray<FTextureSourceLayerColorInfo> & OutLayerColorInfo) const;
    ENGINE_API void SetLayerColorInfo(const TArray<FTextureSourceLayerColorInfo> & InLayerColorInfo);
    ENGINE_API void ResetLayerColorInfo();
    ENGINE_API bool HasLayerColorInfo() const;
 
    // As per UpdateChannelLinearMinMax(), except acts on incoming new data rather than locking existing mips.
    // InNewTextureData must be uncompressed
    // UpdateChannelMinMaxFromIncomingTextureData does not use the BulkData or CompressionFormat on the TextureSource
    //  but it does use the dimensions/blocks/etc. they must be set before calling this.
    // returns true/false for success/failure.
    // failure may occur if the size of InNewTextureData does not match the dimensions set in the Texturesource
    ENGINE_API bool UpdateChannelMinMaxFromIncomingTextureData(FMemoryView InNewTextureData);
 
    ENGINE_API void UseHashAsGuid();
 
    UE_DEPRECATED(5.5, "Remove call to ReleaseSourceMemory.")
    inline void ReleaseSourceMemory() { }
 
    UE_DEPRECATED(5.5, "Remove call to HasHadBulkDataCleared.")
    inline bool HasHadBulkDataCleared() const { return false; }
#endif // WITH_EDITOR
 
private:
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(VisibleAnywhere, Category=TextureSource)
    FGuid Id;
 
    UPROPERTY(VisibleAnywhere, Category = TextureSource)
    int32 BaseBlockX;
 
    UPROPERTY(VisibleAnywhere, Category = TextureSource)
    int32 BaseBlockY;
 
    UPROPERTY(VisibleAnywhere, Category=TextureSource)
    int32 SizeX;
 
    UPROPERTY(VisibleAnywhere, Category=TextureSource)
    int32 SizeY;
 
    UPROPERTY(VisibleAnywhere, Category=TextureSource)
    int32 NumSlices;
 
    UPROPERTY(VisibleAnywhere, Category=TextureSource)
    int32 NumMips;
 
    UPROPERTY(VisibleAnywhere, Category = TextureSource)
    int32 NumLayers;
 
    UPROPERTY()
    bool bPNGCompressed_DEPRECATED;
 
    UPROPERTY(VisibleAnywhere, Category = TextureSource)
    bool bLongLatCubemap;
 
    UPROPERTY(VisibleAnywhere, Category = TextureSource)
    TEnumAsByte<enum ETextureSourceCompressionFormat> CompressionFormat;
 
    UPROPERTY(VisibleAnywhere, Category=TextureSource)
    bool bGuidIsHash;
 
    UPROPERTY(VisibleAnywhere, Category=TextureSource)
    TArray<FTextureSourceLayerColorInfo> LayerColorInfo_LockProtected;
 
    UPROPERTY(VisibleAnywhere, Category=TextureSource)
    TEnumAsByte<enum ETextureSourceFormat> Format;
 
    UPROPERTY(VisibleAnywhere, Category = TextureSource)
    TArray< TEnumAsByte<enum ETextureSourceFormat> > LayerFormat;
 
    UPROPERTY(VisibleAnywhere, Category = TextureSource)
    TArray<FTextureSourceBlock> Blocks;
 
    UPROPERTY()
    TArray<int64> BlockDataOffsets;
 
#endif // WITH_EDITORONLY_DATA
};
 
struct FOptTexturePlatformData
{
    uint32 ExtData;
    uint32 NumMipsInTail;
 
    FOptTexturePlatformData()
        : ExtData(0)
        , NumMipsInTail(0)
    {}
 
    inline bool operator == (FOptTexturePlatformData const& RHS) const 
    {
        return ExtData == RHS.ExtData
            && NumMipsInTail == RHS.NumMipsInTail;
    }
 
    inline bool operator != (FOptTexturePlatformData const& RHS) const
    {
        return !(*this == RHS);
    }
 
    friend inline FArchive& operator << (FArchive& Ar, FOptTexturePlatformData& Data)
    {
        Ar << Data.ExtData;
        Ar << Data.NumMipsInTail;
        return Ar;
    }
};
 
USTRUCT()
struct FTexturePlatformData
{
    GENERATED_USTRUCT_BODY()
 
    
    int32 SizeX;
    int32 SizeY;
    uint32 PackedData;
    EPixelFormat PixelFormat;
    FOptTexturePlatformData OptData;
    TIndirectArray<struct FTexture2DMipMap> Mips;
    struct FVirtualTextureBuiltData* VTData=nullptr;
 
    TRefCountPtr<const struct FSharedImage> CPUCopy;
 
#if WITH_EDITORONLY_DATA
 
    // When in the editor we have some data that is stored in the derived data
    // that we don't want to save in the runtime cooked data:
    // 1. bSourceMipsAlphaDetected - this is part of the calculation for whether to choose
    //      e.g. BC1 or BC3.
    // 2. Interim hash data for cook diff tags - this is used for diff tracking for hunting down
    //      determinism issues.
    // We only have this data if the textures were rebuilt after adding it (I didn't invalidate the ddc for this),
    // hence bSourceMipsAlphaDetectedValid. The Hashes are zero if the data isn't present. 
    uint64 PreEncodeMipsHash=0; // XxHash64
 
    TVariant<FString, UE::DerivedData::FCacheKeyProxy> DerivedDataKey;
 
    // Stores information about how we generated this encoded texture.
    // Mostly relevant to Oodle, however notably does actually tell
    // you _which_ encoder was used.
    struct FTextureEncodeResultMetadata
    {
        // Returned from ITextureFormat
        FName Encoder;
 
        // This is the format the texture will be using on the device so that when
        // we decode for viewing we know what it originally was. In some cases this can only be known
        // if we have source alpha information so it might remain PF_Unknown even when bIsValid is true.
        EPixelFormat EncodedFormat = PF_Unknown;
 
        // This struct is not always filled out, allow us to check for invalid data.
        bool bIsValid = false;
 
        // If this is false, the remaining fields are invalid (as encode speed governs
        // the various Oodle specific values right now.)
        bool bSupportsEncodeSpeed = false;
 
        // If true, then the encoding settings were overridden in the texture editor
        // for encoding experimentation, and thus RDOSource and EncodeSpeed should 
        // be ignored.
        bool bWasEditorCustomEncoding = false;
 
        enum class OodleRDOSource : uint8
        {
            Default,    // We defaulted back to the project settings
            LODGroup,   // We used the LCA off the LOD group to generate a lambda
            Texture,    // We used the LCA off the texture to generate a lambda.
        };
 
        OodleRDOSource RDOSource = OodleRDOSource::Default;
 
        // The resulting RDO lambda, 0 means no RDO.
        uint8 OodleRDO = 0;
 
        // enum ETextureEncodeEffort
        uint8 OodleEncodeEffort = 0;
 
        // enum ETextureUniversalTiling
        uint8 OodleUniversalTiling = 0;
 
        // Which encode speed we ended up using. Must be either ETextureEncodeSpeed::Final or ETextureEncodeSpeed::Fast.
        uint8 EncodeSpeed = 0;
    };
 
    FTextureEncodeResultMetadata ResultMetadata;
 
    struct FStructuredDerivedDataKey
    {
        FIoHash TilingBuildDefinitionKey; // All zeroes if not shared linear tiling
        FIoHash DeTilingBuildDefinitionKey; // All zeroes if not tiled.
        FIoHash DecodeBuildDefinitionKey; // All zeroes if not decoding for pc.
        FIoHash BuildDefinitionKey;
        FGuid SourceGuid;
        FGuid CompositeSourceGuid;
 
        bool operator==(const FStructuredDerivedDataKey& Other) const
        {
            return  DecodeBuildDefinitionKey == Other.DecodeBuildDefinitionKey && 
                    TilingBuildDefinitionKey == Other.TilingBuildDefinitionKey && 
                    DeTilingBuildDefinitionKey == Other.DeTilingBuildDefinitionKey &&
                    BuildDefinitionKey == Other.BuildDefinitionKey && 
                    SourceGuid == Other.SourceGuid && 
                    CompositeSourceGuid == Other.CompositeSourceGuid;
        }
 
        bool operator!=(const FStructuredDerivedDataKey& Other) const
        {
            return  DecodeBuildDefinitionKey != Other.DecodeBuildDefinitionKey ||
                    DeTilingBuildDefinitionKey != Other.DeTilingBuildDefinitionKey ||
                    TilingBuildDefinitionKey != Other.TilingBuildDefinitionKey || 
                    BuildDefinitionKey != Other.BuildDefinitionKey || 
                    SourceGuid != Other.SourceGuid || 
                    CompositeSourceGuid != Other.CompositeSourceGuid;
        }
    };
 
    TVariant<FString, FStructuredDerivedDataKey> FetchOrBuildDerivedDataKey;
    TVariant<FString, FStructuredDerivedDataKey> FetchFirstDerivedDataKey;
 
    struct FTextureAsyncCacheDerivedDataTask* AsyncTask;
 
#endif
 
    ENGINE_API FTexturePlatformData();
 
    ENGINE_API ~FTexturePlatformData();
 
private:
    static constexpr uint32 BitMask_CubeMap    = 1u << 31u;
    static constexpr uint32 BitMask_HasOptData = 1u << 30u;
    static constexpr uint32 BitMask_HasCpuCopy = 1u << 29u;
    static constexpr uint32 BitMask_NumSlices  = BitMask_HasCpuCopy - 1u;
 
public:
    bool IsReadyForAsyncPostLoad() const;
 
    bool TryLoadMips(int32 FirstMipToLoad, void** OutMipData, FStringView DebugContext);
    bool TryLoadMipsWithSizes(int32 FirstMipToLoad, void** OutMipData, int64 * OutMipSize, FStringView DebugContext);
 
    void Serialize(FArchive& Ar, class UTexture* Owner);
 
#if WITH_EDITORONLY_DATA
    FString GetDerivedDataMipKeyString(int32 MipIndex, const FTexture2DMipMap& Mip) const;
    static UE::DerivedData::FValueId MakeMipId(int32 MipIndex);
#endif // WITH_EDITORONLY_DATA
 
    void SerializeCooked(FArchive& Ar, class UTexture* Owner, bool bStreamable, const bool bSerializeMipData);
    
    inline void SetPackedData(int32 InNumSlices, bool bInHasOptData, bool bInCubeMap, bool bInHasCpuCopy)
    {
        PackedData = (InNumSlices & BitMask_NumSlices) | (bInCubeMap ? BitMask_CubeMap : 0) | (bInHasOptData ? BitMask_HasOptData : 0) | (bInHasCpuCopy ? BitMask_HasCpuCopy : 0);
    }
 
    inline bool GetHasOptData() const
    {
        return (PackedData & BitMask_HasOptData) == BitMask_HasOptData;
    }
 
    inline void SetOptData(FOptTexturePlatformData Data)
    {
        // Set the opt data flag to true if the specified data is non-default.
        bool bHasOptData = Data != FOptTexturePlatformData();
        PackedData = (bHasOptData ? BitMask_HasOptData : 0) | (PackedData & (~BitMask_HasOptData));
 
        OptData = Data;
    }
 
    inline bool GetHasCpuCopy() const
    {
        return (PackedData & BitMask_HasCpuCopy) == BitMask_HasCpuCopy;
    }
 
    inline void SetHasCpuCopy(bool bInHasCpuCopy)
    {
        PackedData = (bInHasCpuCopy ? BitMask_HasCpuCopy : 0) | (PackedData & (~BitMask_HasCpuCopy));
    }
 
    inline bool IsCubemap() const
    {
        return (PackedData & BitMask_CubeMap) == BitMask_CubeMap; 
    }
 
    inline void SetIsCubemap(bool bCubemap)
    {
        PackedData = (bCubemap ? BitMask_CubeMap : 0) | (PackedData & (~BitMask_CubeMap));
    }
    
    inline int32 GetNumSlices() const 
    {
        return (int32)(PackedData & BitMask_NumSlices);
    }
 
    inline void SetNumSlices(int32 NumSlices)
    {
        PackedData = (NumSlices & BitMask_NumSlices) | (PackedData & (~BitMask_NumSlices));
    }
 
    inline int32 GetNumMipsInTail() const
    {
        return OptData.NumMipsInTail;
    }
 
    inline int32 GetExtData() const
    {
        return OptData.ExtData;
    }
 
#if WITH_EDITOR
    // Clears the data such that a new Cache() call can load new data in to the structure.
    void Reset();
 
    bool IsAsyncWorkComplete() const;
 
    // Compresses the texture using the given compressor and adds the result to the DDC.
    // This might not be synchronous, and might be called from a worker thread!
    //
    // If Compressor is 0, uses the default texture compressor module. Must be nonzero
    // if called from a worker thread.
    //
    // InFlags are ETextureCacheFlags.
    // InSettingsPerLayerFetchFirst can be nullptr - if not, then the caceh will check if
    // the corresponding texture exists in the DDC before trying the FetchOrBuild settings.
    // FetchFirst is ignored if forcerebuild is passed as a flag.
    // InSettingsPerLayerFetchOrBuild is required. If a texture matching the settings exists
    // in the ddc, it is used, otherwise it is built.
    void Cache(
        class UTexture& InTexture,
        const FTextureBuildSettings* InSettingsPerLayerFetchFirst,
        const FTextureBuildSettings* InSettingsPerLayerFetchOrBuild,
        const FTexturePlatformData::FTextureEncodeResultMetadata* OutResultMetadataPerLayerFetchFirst,
        const FTexturePlatformData::FTextureEncodeResultMetadata* OutResultMetadataPerLayerFetchOrBuild,
        uint32 InFlags,
        class ITextureCompressorModule* Compressor);
    void FinishCache();
    bool TryCancelCache();
    void CancelCache();
    ENGINE_API bool TryInlineMipData(int32 FirstMipToLoad = 0, FStringView DebugContext=FStringView());
    void TouchStreamingMipDDCData(int32 InMipCount, FStringView DebugContext);
    ENGINE_API TFuture<TTuple<uint64, uint64>> LaunchEstimateOnDiskSizeTask(
        FOodleDataCompression::ECompressor InOodleCompressor,
        FOodleDataCompression::ECompressionLevel InOodleCompressionLevel,
        uint32 InCompressionBlockSize,
        FStringView InDebugContext);
    bool AreDerivedMipsAvailable(FStringView Context) const;
    bool AreDerivedVTChunksAvailable(FStringView Context) const;
    UE_DEPRECATED(5.0, "Use AreDerivedMipsAvailable with the context instead.")
    bool AreDerivedMipsAvailable() const;
    UE_DEPRECATED(5.0, "Use AreDerivedVTChunksAvailable with the context instead.")
    bool AreDerivedVTChunksAvailable() const;
#endif
 
    int32 GetNumNonStreamingMips(bool bIsStreamingPossible) const;
    int32 GetNumNonOptionalMips() const;
    bool CanBeLoaded() const;
 
    // Only because we don't want to expose FVirtualTextureBuiltData
    ENGINE_API int32 GetNumVTMips() const;
    ENGINE_API EPixelFormat GetLayerPixelFormat(uint32 LayerIndex) const;
 
    ENGINE_API int64 GetPayloadSize(int32 MipBias) const;
 
private:
 
    bool CanUseCookedDataPath() const;
};
 
USTRUCT()
struct FTextureFormatSettings
{
    GENERATED_USTRUCT_BODY()
 
    FTextureFormatSettings()
        : CompressionSettings(TC_Default)
        , CompressionNoAlpha(false)
        , CompressionForceAlpha(false)
        , CompressionNone(false)
        , CompressionYCoCg(false)
        , SRGB(false)
    {}
 
    bool operator==(const FTextureFormatSettings& other) const = default;
 
    UPROPERTY()
    TEnumAsByte<enum TextureCompressionSettings> CompressionSettings;
 
    UPROPERTY()
    uint8 CompressionNoAlpha : 1;
 
    UPROPERTY()
    uint8 CompressionForceAlpha : 1;
 
    UPROPERTY()
    uint8 CompressionNone : 1;
 
    UPROPERTY()
    uint8 CompressionYCoCg : 1;
 
    UPROPERTY()
    uint8 SRGB : 1;
};
 
 
USTRUCT(BlueprintType)
struct FTextureSourceColorSettings
{
    GENERATED_USTRUCT_BODY()
 
    
    ENGINE_API FTextureSourceColorSettings();
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = ColorManagement)
    ETextureSourceEncoding EncodingOverride;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = ColorManagement)
    ETextureColorSpace ColorSpace;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = ColorManagement, meta = (EditCondition = "ColorSpace == ETextureColorSpace::TCS_Custom"))
    FVector2D RedChromaticityCoordinate;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = ColorManagement, meta = (EditCondition = "ColorSpace == ETextureColorSpace::TCS_Custom"))
    FVector2D GreenChromaticityCoordinate;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = ColorManagement, meta = (EditCondition = "ColorSpace == ETextureColorSpace::TCS_Custom"))
    FVector2D BlueChromaticityCoordinate;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = ColorManagement, meta = (EditCondition = "ColorSpace == ETextureColorSpace::TCS_Custom"))
    FVector2D WhiteChromaticityCoordinate;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = ColorManagement)
    ETextureChromaticAdaptationMethod ChromaticAdaptationMethod;
 
#if WITH_EDITORONLY_DATA
    ENGINE_API void UpdateColorSpaceChromaticities();
#endif
};
 
UCLASS(abstract, MinimalAPI, BlueprintType)
class UTexture : public UStreamableRenderAsset, public IInterface_AssetUserData, public IInterface_AsyncCompilation
{
    GENERATED_UCLASS_BODY()
 
    /*--------------------------------------------------------------------------
        Editor only properties used to build the runtime texture data.
    --------------------------------------------------------------------------*/
 
#if WITH_EDITORONLY_DATA
    /* Dynamic textures will have ! Source.IsValid() ;
    Also in UEFN , Textures from the cooked-only texture library.  Always check Source.IsValid before using Source. */
    UPROPERTY()
    FTextureSource Source;
#endif
 
private:
    UPROPERTY()
    FGuid LightingGuid;
 
public:
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FString SourceFilePath_DEPRECATED;
 
    UPROPERTY(VisibleAnywhere, Instanced, Category=ImportSettings)
    TObjectPtr<class UAssetImportData> AssetImportData;
 
public:
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Adjustments, meta=(DisplayName = "Brightness"))
    float AdjustBrightness;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Adjustments, meta=(DisplayName = "Brightness Curve"))
    float AdjustBrightnessCurve;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Adjustments, meta=(DisplayName = "Vibrance", ClampMin = "0.0", ClampMax = "1.0"))
    float AdjustVibrance;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Adjustments, meta=(DisplayName = "Saturation"))
    float AdjustSaturation;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Adjustments, meta=(DisplayName = "RGBCurve"))
    float AdjustRGBCurve;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Adjustments, meta=(DisplayName = "Hue", ClampMin = "0.0", ClampMax = "360.0"))
    float AdjustHue;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Adjustments, meta=(DisplayName = "Min Alpha"))
    float AdjustMinAlpha;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Adjustments, meta=(DisplayName = "Max Alpha"))
    float AdjustMaxAlpha;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Compression, meta=(DisplayName="Compress Without Alpha"))
    uint32 CompressionNoAlpha:1;
    
    UPROPERTY()
    uint32 CompressionForceAlpha:1;
 
    UPROPERTY()
    uint32 CompressionNone:1;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Transient, SkipSerialization, Category=Compression, meta=(NoResetToDefault), meta=(DisplayName="Editor Show Final Encode"))
    uint32 CompressFinal:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Transient, SkipSerialization, Category=Compression, meta=(NoResetToDefault), meta=(DisplayName="Editor Defer Compression"))
    uint32 DeferCompression:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Compression, AdvancedDisplay)
    TEnumAsByte<ETextureLossyCompressionAmount> LossyCompressionAmount;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Compression, AdvancedDisplay, meta=(NoResetToDefault))
    FName OodleTextureSdkVersion;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Compression, meta=(DisplayName="Maximum Texture Size", ClampMin = "0.0"), AdvancedDisplay)
    int32 MaxTextureSize;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Compression, meta = (DisplayName = "ASTC Compression Quality"), AdvancedDisplay)
    TEnumAsByte<enum ETextureCompressionQuality> CompressionQuality;
 
    UPROPERTY(EditAnywhere, Category=Compression, meta=(NoResetToDefault), meta=(DisplayName = "Compression Cache ID"), AdvancedDisplay)
    FGuid CompressionCacheId;
 
    UPROPERTY()
    uint32 bDitherMipMapAlpha_DEPRECATED:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Texture, AdvancedDisplay)
    bool bDoScaleMipsForAlphaCoverage = false;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Texture, meta=(ClampMin = "0", ClampMax = "1.0", EditCondition="bDoScaleMipsForAlphaCoverage"), AdvancedDisplay)
    FVector4 AlphaCoverageThresholds = FVector4(0,0,0,0);
 
    // for GUI hover text : 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Texture, meta=(DisplayName = "Use Improved Image Processing"), AdvancedDisplay)
    bool bUseNewMipFilter = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=LevelOfDetail, AdvancedDisplay)
    uint32 bPreserveBorder:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Texture, AdvancedDisplay)
    uint32 bFlipGreenChannel:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Texture, meta = (DisplayName = "Padding and Resizing"))
    TEnumAsByte<enum ETexturePowerOfTwoSetting::Type> PowerOfTwoMode;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Texture, meta = (EditCondition = "(PowerOfTwoMode == ETexturePowerOfTwoSetting::PadToPowerOfTwo || PowerOfTwoMode == ETexturePowerOfTwoSetting::PadToSquarePowerOfTwo) && !bPadWithBorderColor", EditConditionHides))
    FColor PaddingColor;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Texture, meta = (EditCondition = "PowerOfTwoMode == ETexturePowerOfTwoSetting::PadToPowerOfTwo || PowerOfTwoMode == ETexturePowerOfTwoSetting::PadToSquarePowerOfTwo", EditConditionHides))
    bool bPadWithBorderColor;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Texture, meta = (EditCondition = "PowerOfTwoMode == ETexturePowerOfTwoSetting::ResizeToSpecificResolution", EditConditionHides))
    int32 ResizeDuringBuildX;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Texture, meta = (EditCondition = "PowerOfTwoMode == ETexturePowerOfTwoSetting::ResizeToSpecificResolution", EditConditionHides))
    int32 ResizeDuringBuildY;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Adjustments)
    bool bChromaKeyTexture;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Adjustments, meta=(EditCondition="bChromaKeyTexture", ClampMin="0"))
    float ChromaKeyThreshold;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Adjustments, meta=(EditCondition="bChromaKeyTexture"))
    FColor ChromaKeyColor;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=LevelOfDetail)
    TEnumAsByte<enum TextureMipGenSettings> MipGenSettings;
 
    UE_DEPRECATED(5.3, "Use GetCompositeTexture() and SetCompositeTexture() instead.")
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Compositing, meta = (AllowPrivateAccess, RequiredAssetDataTags = "IsSourceValid=True"), Setter = SetCompositeTexture, Getter = GetCompositeTexture)
    TObjectPtr<class UTexture> CompositeTexture;
 
private:
    class UTexture* KnownCompositeTexture = nullptr;
 
    ENGINE_API void OutdatedKnownCompositeTextureDetected() const;
    ENGINE_API void NotifyIfCompositeTextureChanged();
 
public:
    void SetCompositeTexture(UTexture* InCompositeTexture)
    {
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        CompositeTexture = InCompositeTexture;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
        NotifyIfCompositeTextureChanged();
    }
 
    UTexture* GetCompositeTexture() const
    {
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        // This should never happen and is a last resort, we should have caught the property overwrite well before we reach this code
        // but this can happen from legacy code that use reflection to set the property without using the new _InContainer functions
        // which will bypass the setter we put in place.
        if (KnownCompositeTexture != CompositeTexture)
        {
            OutdatedKnownCompositeTextureDetected();
        }
        return CompositeTexture;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    /* defines how the CompositeTexture is applied, e.g. CTM_RoughnessFromNormalAlpha */
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Compositing, AdvancedDisplay)
    TEnumAsByte<enum ECompositeTextureMode> CompositeTextureMode;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Compositing, AdvancedDisplay)
    float CompositePower;
 
    UPROPERTY()
    TArray<FTextureFormatSettings> LayerFormatSettings;
 
#endif // WITH_EDITORONLY_DATA
 
    /*--------------------------------------------------------------------------
        Properties needed at runtime below.
    --------------------------------------------------------------------------*/
 
    /*
     * Level scope index of this texture. It is used to reduce the amount of lookup to map a texture to its level index.
     * Useful when building texture streaming data, as well as when filling the texture streamer with precomputed data.
     * It relates to FStreamingTextureBuildInfo::TextureLevelIndex and also the index in ULevel::StreamingTextureGuids. 
     * Default value of -1, indicates that the texture has an unknown index (not yet processed). At level load time, 
     * -2 is also used to indicate that the texture has been processed but no entry were found in the level table.
     * After any of these processes, the LevelIndex is reset to INDEX_NONE. Making it ready for the next level task.
     */
    UPROPERTY(transient, duplicatetransient, NonTransactional)
    int32 LevelIndex = INDEX_NONE;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=LevelOfDetail, meta=(DisplayName="LOD Bias"), AssetRegistrySearchable)
    int32 LODBias;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Compression, AssetRegistrySearchable)
    TEnumAsByte<enum TextureCompressionSettings> CompressionSettings;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Texture, AssetRegistrySearchable, AdvancedDisplay)
    TEnumAsByte<enum TextureFilter> Filter;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Texture, AssetRegistrySearchable, AdvancedDisplay)
    ETextureMipLoadOptions MipLoadOptions;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Texture, AdvancedDisplay, meta=(EditCondition = "bUseVirtualTextureStreamingPriority"))
    EVTProducerPriority VirtualTextureStreamingPriority;
 
    UPROPERTY(EditAnywhere, Category = Texture, AdvancedDisplay, meta=(EditCondition = "VirtualTextureStreaming"))
    uint8 VirtualTexturePrefetchMips = 0;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Compression, AdvancedDisplay)
    TEnumAsByte<enum TextureCookPlatformTilingSettings> CookPlatformTilingSettings;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Compression, meta = (DisplayName = "Preserve Extremes When Compressing With Oodle"), AdvancedDisplay)
    bool bOodlePreserveExtremes = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=LevelOfDetail, meta=(DisplayName="Texture Group"), AssetRegistrySearchable)
    TEnumAsByte<enum TextureGroup> LODGroup;
 
    UFUNCTION()
    virtual bool AreDownscalePropertiesEditable() const { return false; }
 
    UPROPERTY(EditAnywhere, Category=LevelOfDetail, AdvancedDisplay, meta=(ClampMin="0.0", ClampMax="8.0", EditCondition=AreDownscalePropertiesEditable))
    FPerPlatformFloat Downscale;
 
    UPROPERTY(EditAnywhere, Category=LevelOfDetail, AdvancedDisplay, meta=(EditCondition=AreDownscalePropertiesEditable))
    ETextureDownscaleOptions DownscaleOptions;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Texture, meta=(DisplayName="Availability"), AssetRegistrySearchable)
    ETextureAvailability Availability;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Texture, meta=(DisplayName="sRGB"), AssetRegistrySearchable)
    uint8 SRGB:1;
 
#if WITH_EDITORONLY_DATA
    /* Normalize colors in Normal Maps after mip generation for better and sharper quality; recommended on if not required to match legacy behavior. */
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Texture, meta=(DisplayName="Normalize after making mips", EditCondition="CompressionSettings==1"), AdvancedDisplay)
    uint8 bNormalizeNormals:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Texture, meta=(DisplayName="sRGB Use Legacy Gamma", EditCondition="SRGB"), AdvancedDisplay)
    uint8 bUseLegacyGamma:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Texture, AdvancedDisplay)
    FTextureSourceColorSettings SourceColorSettings;
 
    /* Store the FUE5MainStreamObjectVersion of the Texture uasset loaded for debugging (== LatestVersion if not loaded) */
    int LoadedMainStreamObjectVersion;
 
    uint8 bIsImporting : 1;
    
    uint8 bCustomPropertiesImported : 1;
 
    // When we are open in an asset editor, we have a pointer to a custom encoding
    // object which can optionally cause us to do something other than Fast/Final encode settings.
    TWeakPtr<class FTextureEditorCustomEncode> TextureEditorCustomEncoding;
 
    // Override the platform to cache for, instead of using "running plaform". NAME_None to use default editor platform.
    FName OverrideRunningPlatformName;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY()
    uint8 bNoTiling:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Texture, AssetRegistrySearchable, AdvancedDisplay)
    uint8 VirtualTextureStreaming : 1;
 
    UPROPERTY(EditAnywhere, Category = LevelOfDetail, AdvancedDisplay, meta=(EditCondition = "VirtualTextureStreaming", InlineEditConditionToggle))
    uint32 bUseVirtualTextureStreamingPriority : 1;
 
#if WITH_EDITOR
    UFUNCTION(BlueprintCallable, Category = Texture)
    void SetVirtualTextureStreaming(bool bVirtualTextureStreaming);
#endif
 
    UPROPERTY()
    uint8 CompressionYCoCg : 1;
 
    UPROPERTY(transient)
    uint8 bNotOfflineProcessed : 1;
 
    UFUNCTION(BlueprintCallable, meta = (DisplayName = "GetMemorySize"), Category = "Rendering|Texture")
    int64 Blueprint_GetMemorySize() const;
    
    UFUNCTION(BlueprintCallable, BlueprintPure=false, meta = (DisplayName = "GetTextureSourceDiskAndMemorySize"), Category = "Rendering|Texture")
    void Blueprint_GetTextureSourceDiskAndMemorySize(int64 & OutDiskSize,int64 & OutMemorySize) const;
 
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category = "Rendering|Texture")
    bool ComputeTextureSourceChannelMinMax(FLinearColor & OutColorMin, FLinearColor & OutColorMax) const;
 
    UFUNCTION(BlueprintCallable, meta = (DisplayName = "GetTextureSourceIdString"), Category = "Rendering|Texture")
    bool Blueprint_GetTextureSourceIdString(FString& OutTextureSourceId);
 
private:
    UPROPERTY(transient)
    uint8 bAsyncResourceReleaseHasBeenStarted : 1;
 
protected:
    UPROPERTY(EditAnywhere, AdvancedDisplay, Instanced, Category = Texture)
    TArray<TObjectPtr<UAssetUserData>> AssetUserData;
 
public:
#if WITH_EDITOR
    TMap<FString,bool> DidSerializeStreamingMipsForPlatform;
#endif
 
private:
    class FTextureResource* PrivateResource;
    class FTextureResource* PrivateResourceRenderThread;
 
public:
    ENGINE_API UTexture(FVTableHelper& Helper);
    ENGINE_API virtual ~UTexture();
    
    ENGINE_API void SetResource(FTextureResource* Resource);
 
    ENGINE_API FTextureResource* GetResource();
 
    ENGINE_API const FTextureResource* GetResource() const;
 
    FTextureReference& TextureReference;
 
    FRenderCommandFence ReleaseFence;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnTextureSaved, class UTexture*);
    ENGINE_API static FOnTextureSaved PreSaveEvent;
 
    ENGINE_API virtual void ExportCustomProperties(FOutputDevice& Out, uint32 Indent) override;
    ENGINE_API virtual void ImportCustomProperties(const TCHAR* SourceText, FFeedbackContext* Warn) override;
    ENGINE_API virtual void PostEditImport() override;
 
    virtual ETextureClass GetTextureClass() const PURE_VIRTUAL(UTexture::GetTextureClass, return ETextureClass::Invalid; );
 
    ENGINE_API void ReleaseResource();
 
    virtual void UpdateResource() { UpdateResourceWithParams(EUpdateResourceFlags::None); }
 
    enum class EUpdateResourceFlags : uint32
    {
        None            =0,
        
        /* Forces the derived data for the texture to completely rebuild. Only applies to editor builds */
        ForceRebuild    =0x1,
        /* Forces any derived data fetch/rebuild to run on the calling thread. */
        Synchronous     =0x2
    };
 
    ENGINE_API virtual void UpdateResourceWithParams(EUpdateResourceFlags InFlags);
 
    virtual class FTextureResource* CreateResource() PURE_VIRTUAL(UTexture::CreateResource,return NULL;);
 
    UE_DEPRECATED(5.2, "UpdateCachedLODBias does nothing, remove call")
    void UpdateCachedLODBias()
    {
        // no longer cached, now does nothing
    }
    
    int32 GetCachedLODBias() const override
    {
        // this is the combined LOD Bias with cinematic bias
        return CalculateLODBias(true);
    }
 
    ENGINE_API int32 CalculateLODBias(bool bWithCinematicMipBias) const;
 
    virtual EMaterialValueType GetMaterialType() const PURE_VIRTUAL(UTexture::GetMaterialType,return MCT_Texture;);
 
    virtual bool IsCurrentlyVirtualTextured() const
    {
        return false;
    }
 
    UFUNCTION(BlueprintCallable, Category = Texture)
    ENGINE_API ETextureStreamingMethod GetTextureStreamingMethod() const;
 
    ENGINE_API virtual void GetVirtualTextureBuildSettings(struct FVirtualTextureBuildSettings& OutSettings) const;
 
#if WITH_EDITORONLY_DATA
    ENGINE_API bool RequiresVirtualTexturing() const;
#endif
 
    ENGINE_API static bool IsVirtualTexturingEnabled( const ITargetPlatformSettings * TargetPlatform = nullptr );
 
    virtual FTexturePlatformData** GetRunningPlatformData() { return NULL; }
    virtual TMap<FString, FTexturePlatformData*>* GetCookedPlatformData() { return NULL; }
 
    void CleanupCachedRunningPlatformData();
    
    ENGINE_API void GetBuiltTextureSize( const ITargetPlatform* TargetPlatform , int32 & OutSizeX, int32 & OutSizeY, int32 & OutSizeZ ) const;
    ENGINE_API void GetBuiltTextureSize( const class ITargetPlatformSettings* TargetPlatformSettings, const class ITargetPlatformControls* TargetPlatformControls, int32 & OutSizeX, int32 & OutSizeY, int32 & OutSizeZ ) const;
    
    void GetBuiltTextureSize( const ITargetPlatform* TargetPlatform , int32 & OutSizeX, int32 & OutSizeY) const
    {
        int32 IgnoredSizeZ;
        GetBuiltTextureSize(TargetPlatform,OutSizeX,OutSizeY,IgnoredSizeZ);
    }
    void GetBuiltTextureSize( const class ITargetPlatformSettings* TargetPlatformSettings, const class ITargetPlatformControls* TargetPlatformControls, int32 & OutSizeX, int32 & OutSizeY) const
    {
        int32 IgnoredSizeZ;
        GetBuiltTextureSize(TargetPlatformSettings,TargetPlatformControls,OutSizeX,OutSizeY,IgnoredSizeZ);
    }
    
    UFUNCTION(BlueprintCallable, meta = (DisplayName = "GetBuiltTextureSize"), Category = "Rendering|Texture")
    FVector3f Blueprint_GetBuiltTextureSize();
 
    ENGINE_API void SerializeCookedPlatformData(class FArchive& Ar, const bool bSerializeMipData = true);
 
    //~ Begin IInterface_AssetUserData Interface
    ENGINE_API virtual void AddAssetUserData(UAssetUserData* InUserData) override;
    ENGINE_API virtual void RemoveUserDataOfClass(TSubclassOf<UAssetUserData> InUserDataClass) override;
    ENGINE_API virtual UAssetUserData* GetAssetUserDataOfClass(TSubclassOf<UAssetUserData> InUserDataClass) override;
    ENGINE_API virtual const TArray<UAssetUserData*>* GetAssetUserDataArray() const override;
    //~ End IInterface_AssetUserData Interface
 
#if WITH_EDITOR
    void CachePlatformData(bool bAsyncCache = false, bool bAllowAsyncBuild = false, bool bAllowAsyncLoading = false, class ITextureCompressorModule* Compressor = nullptr, bool bForceRebuild = false);
 
    /* Returns if it is possible to build this texture for a given TargetPlatform (or any).
    This supercedes checking Source.IsValid()
    When this returns false, CachePlatformData will not attempt to build or cache the PlatformData.
    */
    bool CanBuildPlatformData(const ITargetPlatformSettings * TargetPlatform = nullptr) const;
 
    ENGINE_API virtual void BeginCacheForCookedPlatformData(  const ITargetPlatform* TargetPlatform ) override;
 
    ENGINE_API virtual bool IsCachedCookedPlatformDataLoaded( const ITargetPlatform* TargetPlatform ) override;
 
    ENGINE_API virtual void ClearCachedCookedPlatformData( const ITargetPlatform* TargetPlatform ) override;
 
    ENGINE_API virtual void ClearAllCachedCookedPlatformData() override;
 
    ENGINE_API virtual bool IsDefaultTexture() const;
 
    ENGINE_API void BeginCachePlatformData();
 
    ENGINE_API bool IsAsyncCacheComplete() const;
 
    ENGINE_API void FinishCachePlatformData();
 
    ENGINE_API void ForceRebuildPlatformData();
 
    UE_DEPRECATED(5.1,"Use GetBuildRequiredMemoryEstimate instead")
    ENGINE_API int64 GetBuildRequiredMemory() const;
 
    ENGINE_API void MarkPlatformDataTransient();
 
    ENGINE_API virtual uint32 GetMaximumDimension() const;
 
    ENGINE_API void GetLayerFormatSettings(int32 LayerIndex, FTextureFormatSettings& OutSettings) const;
    ENGINE_API void SetLayerFormatSettings(int32 LayerIndex, const FTextureFormatSettings& InSettings);
 
    ENGINE_API void GetDefaultFormatSettings(FTextureFormatSettings& OutSettings) const;
    
    ENGINE_API ETextureEncodeSpeed GetDesiredEncodeSpeed() const;
        
    ENGINE_API virtual void ValidateSettingsAfterImportOrEdit(bool * pRequiresNotifyMaterials = nullptr);
 
    /* Change the Oodle Texture Sdk Version used to encode this texture to latest.
    *  You should do this any time the texture is modified, such as on reimport, since the bits are changing anyway.
    */
    ENGINE_API virtual void UpdateOodleTextureSdkVersionToLatest(bool bDoPrePostEditChangeIfChanging = false);
    
    ENGINE_API virtual void SetModernSettingsForNewOrChangedTexture();
 
    ENGINE_API void GetPlatformTextureFormatNamesWithPrefix(const class ITargetPlatform* TargetPlatform,TArray< TArray<FName> >& OutFormats) const;
#endif // WITH_EDITOR
 
    EGammaSpace GetGammaSpace() const
    {
        // note: does not validate that the Format respects gamma (TextureSource::GetGammaSpace does)
        
        #if WITH_EDITORONLY_DATA
        // Pow22 only affects texture *Source* encoding of import
        // PlatformData is always sRGB even if bUseLegacyGamma was on
        if ( SRGB && bUseLegacyGamma )
        {
            return EGammaSpace::Pow22;
        }
        #endif
 
        return SRGB ? EGammaSpace::sRGB : EGammaSpace::Linear;
    }
 
    virtual float GetSurfaceWidth() const PURE_VIRTUAL(UTexture::GetSurfaceWidth,return 0;);
 
    virtual float GetSurfaceHeight() const PURE_VIRTUAL(UTexture::GetSurfaceHeight,return 0;);
 
    virtual float GetSurfaceDepth() const PURE_VIRTUAL(UTexture::GetSurfaceDepth, return 0;);
 
    virtual uint32 GetSurfaceArraySize() const PURE_VIRTUAL(UTexture::GetSurfaceArraySize, return 0;);
 
    virtual TextureAddress GetTextureAddressX() const { return TA_Wrap; }
    virtual TextureAddress GetTextureAddressY() const { return TA_Wrap; }
    virtual TextureAddress GetTextureAddressZ() const { return TA_Wrap; }
 
    virtual FGuid GetExternalTextureGuid() const
    {
        return FGuid();
    }
 
#if WITH_EDITOR
    //~ Begin AsyncCompilation Interface
    virtual bool IsCompiling() const override { return IsDefaultTexture(); }
    //~ End AsyncCompilation Interface
 
    // if texture is currently in async build action or queue, block until it is done
    //  note: Modify() and PreEditChange() do this.  You should usually be using PreEdit/PostEdit and not calling this directly.
    ENGINE_API virtual void BlockOnAnyAsyncBuild();
 
    //~ Begin UObject Interface.
    ENGINE_API virtual bool Modify(bool bAlwaysMarkDirty = true) override;
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    ENGINE_API virtual bool CanEditChange(const FProperty* InProperty) const override;
#endif // WITH_EDITOR
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    ENGINE_API virtual void PostInitProperties() override;
    ENGINE_API virtual void PostLoad() override;
    ENGINE_API virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
    ENGINE_API virtual void BeginDestroy() override;
    ENGINE_API virtual bool IsReadyForFinishDestroy() override;
    ENGINE_API virtual void FinishDestroy() override;
    ENGINE_API virtual void PostCDOContruct() override;
#if WITH_EDITORONLY_DATA
    ENGINE_API static void AppendToClassSchema(FAppendToClassSchemaContext& Context);
    ENGINE_API virtual void GetAssetRegistryTags(FAssetRegistryTagsContext Context) const override;
    UE_DEPRECATED(5.4, "Implement the version that takes FAssetRegistryTagsContext instead.")
    ENGINE_API virtual void GetAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const override;
#endif
    ENGINE_API virtual bool IsPostLoadThreadSafe() const override;
    //~ End UObject Interface.
 
    //~ Begin UStreamableRenderAsset Interface
    virtual int32 GetLODGroupForStreaming() const final override { return static_cast<int32>(LODGroup); }
    virtual EStreamableRenderAssetType GetRenderAssetType() const final override { return EStreamableRenderAssetType::Texture; }
    ENGINE_API virtual FIoFilenameHash GetMipIoFilenameHash(const int32 MipIndex) const final override;
    ENGINE_API virtual bool DoesMipDataExist(const int32 MipIndex) const final override;
    ENGINE_API virtual bool HasPendingRenderResourceInitialization() const final override;
    ENGINE_API virtual bool HasPendingLODTransition() const final override;
    ENGINE_API virtual void InvalidateLastRenderTimeForStreaming() final override;
    ENGINE_API virtual float GetLastRenderTimeForStreaming() const final override;
    ENGINE_API virtual bool ShouldMipLevelsBeForcedResident() const final override;
    //~ End UStreamableRenderAsset Interface
 
    ENGINE_API static void CancelPendingTextureStreaming();
 
    ENGINE_API virtual float GetAverageBrightness(bool bIgnoreTrueBlack, bool bUseGrayscale);
    
    // @todo document
    ENGINE_API static const TCHAR* GetTextureGroupString(TextureGroup InGroup);
 
    // @todo document
    ENGINE_API static const TCHAR* GetMipGenSettingsString(TextureMipGenSettings InEnum);
 
    // @param   bTextureGroup   true=TexturGroup, false=Texture otherwise
    ENGINE_API static TextureMipGenSettings GetMipGenSettingsFromString(const TCHAR* InStr, bool bTextureGroup);
 
    ENGINE_API static bool ForceUpdateTextureStreaming();
 
    bool HasHDRSource(int32 LayerIndex = 0) const
    {
#if WITH_EDITOR
        return FTextureSource::IsHDR(Source.GetFormat(LayerIndex));
#else
        return false;
#endif // WITH_EDITOR
    }
 
 
    bool IsNormalMap() const
    {
        return (CompressionSettings == TC_Normalmap);
    }
 
    bool IsUncompressed() const
    {
        return UE::TextureDefines::IsUncompressed(CompressionSettings);
    }
 
    ENGINE_API bool IsCookPlatformTilingDisabled(const ITargetPlatformSettings* TargetPlatformSettings) const;
 
    ENGINE_API bool IsCookPlatformTilingDisabled(const ITargetPlatform* TargetPlatform) const;
 
    virtual uint32 CalcTextureMemorySizeEnum( ETextureMipCount Enum ) const
    {
        return 0;
    }
 
    const FGuid& GetLightingGuid() const
    {
        return LightingGuid;
    }
 
    void SetLightingGuid()
    {
#if WITH_EDITORONLY_DATA
        LightingGuid = BuildLightingGuid();
#else
        LightingGuid = FGuid(0, 0, 0, 0);
#endif // WITH_EDITORONLY_DATA
    }
 
    void SetLightingGuid(const FGuid& Guid)
    {
        LightingGuid = Guid;
    }
 
    ENGINE_API void SetDeterministicLightingGuid();
 
#if WITH_EDITORONLY_DATA
    ENGINE_API virtual FGuid BuildLightingGuid();
    ENGINE_API FGuid BuildLightingGuidFromHash();
#endif
 
    ENGINE_API static class UEnum* GetPixelFormatEnum();
 
    static inline int32 GetStaticMinTextureResidentMipCount()
    {
        return GMinTextureResidentMipCount;
    }
 
    static void SetMinTextureResidentMipCount(int32 InMinTextureResidentMipCount);
 
    bool IsPossibleToStream() const;
 
#if WITH_EDITOR
    bool IsCandidateForTextureStreamingOnPlatformDuringCook(const ITargetPlatform* InTargetPlatform) const;
 
    /*
     * Downsize the 2D Image with the build settings for the texture until all dimensions are <= TargetSize.
     * This downsizes using the mip generation system and so will only cut sizes in half. Return false
     * if a parameter is invalid. Returns true if the output is <= TargetSize, whether or not downsizing occurred.
     */
    ENGINE_API bool DownsizeImageUsingTextureSettings(const ITargetPlatform* TargetPlatform, FImage& InOutImage, int32 TargetSize, int32 LayerIndex, bool & OutMadeChanges) const;
 
    /*
    */
    ENGINE_API void GetTargetPlatformBuildSettings(const ITargetPlatform* TargetPlatform, TArray<TArray<FTextureBuildSettings>>& OutSettingsPerFormatPerLayer) const;
 
#endif
 
    ENGINE_API static int32 GetMaximumDimensionOfNonVT();
 
protected:
 
    static ENGINE_API int32 GMinTextureResidentMipCount;
 
#if WITH_EDITOR
    // The Texture compiler might use TryCancelCachePlatformData on shutdown
    friend class FTextureCompilingManager;
 
    enum class ENotifyMaterialsEffectOnShaders
    {
        Default,
        DoesNotInvalidate
    };
    ENGINE_API bool TryCancelCachePlatformData();
 
    ENGINE_API void NotifyMaterials(const ENotifyMaterialsEffectOnShaders EffectOnShaders = ENotifyMaterialsEffectOnShaders::Default);
 
#endif //WITH_EDITOR
 
    void BeginFinalReleaseResource();
 
    FStreamableRenderResourceState GetResourcePostInitState(const FTexturePlatformData* PlatformData, bool bAllowStreaming, int32 MinRequestMipCount = 0, int32 MaxMipCount = 0, bool bSkipCanBeLoaded = false) const;
};