TextureResource.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
/*=============================================================================
    Texture.h: Unreal texture related classes.
=============================================================================*/
 
#include "CoreMinimal.h"
#include "HAL/ThreadSafeCounter.h"
#include "Containers/IndirectArray.h"
#include "Stats/Stats.h"
#include "Containers/List.h"
#include "Async/AsyncWork.h"
#include "Async/AsyncFileHandle.h"
#include "RHI.h"
#include "RenderResource.h"
#include "Serialization/BulkData.h"
#include "Serialization/DerivedData.h"
#include "Engine/TextureDefines.h"
#include "UnrealClient.h"
#include "Templates/UniquePtr.h"
#include "VirtualTexturing.h"
 
class FTexture2DResourceMem;
class UTexture;
class UTexture2D;
class UTexture2DArray;
class IVirtualTexture;
struct FTexturePlatformData;
class FStreamableTextureResource;
class FTexture2DResource;
class FTexture3DResource;
class FTexture2DArrayResource;
class FVirtualTexture2DResource;
struct IPooledRenderTarget;
enum class EVTProducerPriority : uint8;
 
#define MAX_TEXTURE_SOURCE_SLICES 6
 
struct FTexture2DMipMap
{
    UE::FDerivedData DerivedData;
    FByteBulkData BulkData;
 
    uint16 SizeX = 0;
    uint16 SizeY = 0;
    uint16 SizeZ = 0;
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    FTexture2DMipMap() = default;
    FTexture2DMipMap(uint32 InSizeX, uint32 InSizeY, uint32 InSizeZ = 0)
        : SizeX((uint16)InSizeX), SizeY((uint16)InSizeY), SizeZ((uint16)InSizeZ)
    {
        if (InSizeX > 0xFFFF || InSizeY > 0xFFFF || InSizeZ > 0xFFFF)
        {
            LowLevelFatalError(TEXT("texture mip size doesn't fit in 16 bits! %ux%ux%u"), InSizeX, InSizeY, InSizeZ);
        }
    }
    FTexture2DMipMap(FTexture2DMipMap&&) = default;
    FTexture2DMipMap(const FTexture2DMipMap&) = default;
    FTexture2DMipMap& operator=(FTexture2DMipMap&&) = default;
    FTexture2DMipMap& operator=(const FTexture2DMipMap&) = default;
    ~FTexture2DMipMap() = default;
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    ENGINE_API void Serialize(FArchive& Ar, UObject* Owner, int32 MipIndex, bool bSerializeMipData);
 
#if WITH_EDITORONLY_DATA
    EFileRegionType FileRegionType = EFileRegionType::None;
 
    UE_DEPRECATED(5.1, "Use DerivedData.HasData().")
    bool bPagedToDerivedData = false;
 
    inline bool IsPagedToDerivedData() const { return DerivedData.HasData(); }
 
    UE_DEPRECATED(5.1, "Setting DerivedData is sufficient to control this state.")
    inline void SetPagedToDerivedData(bool InValue)
    {
    }
 
    int64 StoreInDerivedDataCache(FStringView Key, FStringView Name, bool bReplaceExisting);
#endif // #if WITH_EDITORONLY_DATA
};
 
class FTextureResource : public FTexture
{
public:
 
    FTextureResource() {}
    virtual ~FTextureResource() {}
 
    virtual bool IsProxy() const { return false; }
 
    // Dynamic cast methods.
    virtual FTexture2DResource* GetTexture2DResource() { return nullptr; }
    virtual FTexture3DResource* GetTexture3DResource() { return nullptr; }
    virtual FTexture2DArrayResource* GetTexture2DArrayResource() { return nullptr; }
    virtual FStreamableTextureResource* GetStreamableTextureResource() { return nullptr; }
    virtual FVirtualTexture2DResource* GetVirtualTexture2DResource() { return nullptr; }
    // Dynamic cast methods (const).
    virtual const FTexture2DResource* GetTexture2DResource() const { return nullptr; }
    virtual const FTexture3DResource* GetTexture3DResource() const { return nullptr; }
    virtual const FTexture2DArrayResource* GetTexture2DArrayResource() const { return nullptr; }
    virtual const FStreamableTextureResource* GetStreamableTextureResource() const { return nullptr; }
    virtual const FVirtualTexture2DResource* GetVirtualTexture2DResource() const { return nullptr; }
 
    // Current mip count. We use "current" to specify that it is not computed from SizeX() which is the size when fully streamed in.
    inline int32 GetCurrentMipCount() const
    {
        return TextureRHI.IsValid() ? TextureRHI->GetNumMips() : 0;
    }
 
    inline bool IsTextureRHIPartiallyResident() const
    {
        return TextureRHI.IsValid() && !!(TextureRHI->GetFlags() & TexCreate_Virtual);
    }
 
    inline FRHITexture* GetTexture2DRHI() const
    {
        return TextureRHI.IsValid() ? TextureRHI->GetTexture2D() : nullptr;
    }
 
    inline FRHITexture* GetTexture3DRHI() const
    {
        return TextureRHI.IsValid() ? TextureRHI->GetTexture3D() : nullptr;
    }
 
    inline FRHITexture* GetTexture2DArrayRHI() const
    {
        return TextureRHI.IsValid() ? TextureRHI->GetTexture2DArray() : nullptr;
    }
 
    void SetTextureReference(FRHITextureReference* TextureReference)
    {
        TextureReferenceRHI = TextureReference;
    }
 
    FRHITextureReference* GetTextureReference() const
    {
        return TextureReferenceRHI;
    }
 
#if STATS
    /* The Stat_ FName corresponding to each TEXTUREGROUP */
    static FName TextureGroupStatFNames[TEXTUREGROUP_MAX];
#endif
 
protected :
    // A FRHITextureReference to update whenever the FTexture::TextureRHI changes.
    // It allows to prevent dereferencing the UAsset pointers when updating a texture resource.
    FTextureReferenceRHIRef TextureReferenceRHI;
};
 
class FVirtualTexture2DResource : public FTextureResource
{
public:
    ENGINE_API FVirtualTexture2DResource();
    ENGINE_API FVirtualTexture2DResource(const UTexture2D* InOwner, struct FVirtualTextureBuiltData* InVTData, int32 FirstMipToUse);
    ENGINE_API virtual ~FVirtualTexture2DResource();
 
    ENGINE_API virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
    ENGINE_API virtual void ReleaseRHI() override;
 
    // Dynamic cast methods.
    virtual FVirtualTexture2DResource* GetVirtualTexture2DResource() { return this; }
    // Dynamic cast methods (const).
    virtual const FVirtualTexture2DResource* GetVirtualTexture2DResource() const { return this; }
 
#if WITH_EDITOR
    ENGINE_API virtual void InitializeEditorResources(FRHICommandListBase& RHICmdList, IVirtualTexture* InVirtualTexture);
#endif
 
    ENGINE_API virtual uint32 GetSizeX() const override;
    ENGINE_API virtual uint32 GetSizeY() const override;
 
    const FVirtualTextureProducerHandle& GetProducerHandle() const { return ProducerHandle; }
 
    class IAllocatedVirtualTexture* GetAllocatedVT() const { return AllocatedVT; }
    ENGINE_API class IAllocatedVirtualTexture* AcquireAllocatedVT();
    ENGINE_API void ReleaseAllocatedVT();
 
    ENGINE_API virtual EPixelFormat GetFormat(uint32 LayerIndex) const;
    ENGINE_API virtual FIntPoint GetSizeInBlocks() const;
    ENGINE_API virtual uint32 GetNumTilesX() const;
    ENGINE_API virtual uint32 GetNumTilesY() const;
    ENGINE_API virtual uint32 GetNumMips() const;
    ENGINE_API virtual uint32 GetNumLayers() const;
    ENGINE_API virtual uint32 GetTileSize() const; //no borders
    ENGINE_API virtual uint32 GetBorderSize() const;
    uint32 GetAllocatedvAddress() const;
 
    ENGINE_API virtual FIntPoint GetPhysicalTextureSize(uint32 LayerIndex) const;
 
protected:
    FName TextureName;
    FName PackageName;
    uint32 FullNameHash = 0;
    TEnumAsByte<ESamplerFilter> Filter = SF_Point;
    TEnumAsByte<ESamplerAddressMode> AddressU = AM_Wrap;
    TEnumAsByte<ESamplerAddressMode> AddressV = AM_Wrap;
    ETextureCreateFlags TexCreateFlags = ETextureCreateFlags::None;
    bool bSinglePhysicalSpace = false;
    bool bRequiresSinglePhysicalPool = false;
    EVTProducerPriority VirtualTextureStreamingPriority;
    int32 FirstMipToUse = 0;
    struct FVirtualTextureBuiltData* VTData = nullptr;
    class IAllocatedVirtualTexture* AllocatedVT = nullptr;
    FVirtualTextureProducerHandle ProducerHandle;
};
 
class FTexture2DDynamicResource : public FTextureResource
{
public:
    ENGINE_API FTexture2DDynamicResource(class UTexture2DDynamic* InOwner);
 
    ENGINE_API virtual uint32 GetSizeX() const override;
 
    ENGINE_API virtual uint32 GetSizeY() const override;
 
    ENGINE_API virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
 
    ENGINE_API virtual void ReleaseRHI() override;
 
    ENGINE_API FTextureRHIRef GetTexture2DRHI();
 
#if !UE_SERVER
    ENGINE_API void WriteRawToTexture_RenderThread(TArrayView64<const uint8> RawData);
#endif
 
private:
    class UTexture2DDynamic* Owner;
    FTextureRHIRef Texture2DRHI;
};
 
class FDeferredUpdateResource
{
public:
 
    FDeferredUpdateResource()
        :   UpdateListLink(NULL)
        ,   bOnlyUpdateOnce(false)
    { }
 
public:
 
    ENGINE_API static void UpdateResources( FRHICommandListImmediate& RHICmdList );
 
    ENGINE_API void FlushDeferredResourceUpdate( FRHICommandListImmediate& RHICmdList );
 
    static void ResetNeedsUpdate()
    {
        bNeedsUpdate = true;
    }
 
    static bool IsUpdateNeeded()
    {
        return bNeedsUpdate;
    }
 
    ENGINE_API void ResetSceneTextureExtentsHistory();
protected:
 
    virtual void UpdateDeferredResource( FRHICommandListImmediate& RHICmdList, bool bClearRenderTarget=true ) = 0;
 
    ENGINE_API void AddToDeferredUpdateList( bool OnlyUpdateOnce );
 
    ENGINE_API void RemoveFromDeferredUpdateList();
 
private:
 
    static TLinkedList<FDeferredUpdateResource*>*& GetUpdateList();
    TLinkedList<FDeferredUpdateResource*> UpdateListLink;
    ENGINE_API static bool bNeedsUpdate;
    bool bOnlyUpdateOnce;
};
 
class FTextureRenderTargetResource : public FTextureResource, public FRenderTarget, public FDeferredUpdateResource
{
public:
    FTextureRenderTargetResource()
    {}
 
    ENGINE_API static bool IsSupportedFormat( EPixelFormat Format );
 
    // FRenderTarget implementation
    virtual const FTextureRHIRef& GetShaderResourceTexture() const override;
 
    // FTextureRenderTargetResource interface
    
    virtual class FTextureRenderTarget2DResource* GetTextureRenderTarget2DResource() { return nullptr; }
    virtual class FTextureRenderTarget2DArrayResource* GetTextureRenderTarget2DArrayResource() { return nullptr; }
    virtual class FTextureRenderTargetVolumeResource* GetTextureRenderTargetVolumeResource() { return nullptr; }
    virtual class FTextureRenderTargetCubeResource* GetTextureRenderTargetCubeResource() { return nullptr; }
 
    virtual void ClampSize(int32 SizeX,int32 SizeY) {}
 
    // GetSizeX/GetSizeY are from "FTexture" interface.
    //   the FTexture implementations return zero; force them to be implemented:
    virtual uint32 GetSizeX() const override = 0;
    virtual uint32 GetSizeY() const override = 0;
    // also GetSizeZ()
    // GetSizeXY from "FRenderTarget"
    //virtual FIntPoint GetSizeXY() const override = 0;
 
    virtual float GetDisplayGamma() const override;
 
    virtual FRHIGPUMask GetGPUMask(FRHICommandListImmediate& RHICmdList) const final override
    {
        return GPUMask & ActiveGPUMask;
    }
 
    // Changes the GPUMask used when updating the texture with multi-GPU.
    void SetActiveGPUMask(FRHIGPUMask InGPUMask)
    {
        check(IsInRenderingThread());
        check(GPUMask.ContainsAll(InGPUMask));
        ActiveGPUMask = InGPUMask;
    }
 
protected:
    void SetGPUMask(FRHIGPUMask InGPUMask)
    {
        check(IsInRenderingThread());
        ActiveGPUMask = GPUMask = InGPUMask;
    }
 
private:
    FRHIGPUMask GPUMask;
    FRHIGPUMask ActiveGPUMask;  // GPU mask copied from parent render target for multi-GPU
};
 
class FTextureRenderTarget2DResource : public FTextureRenderTargetResource
{
public:
    
    FTextureRenderTarget2DResource(const class UTextureRenderTarget2D* InOwner);
    virtual ~FTextureRenderTarget2DResource();
 
    inline FLinearColor GetClearColor()
    {
        return ClearColor;
    }
 
    inline EPixelFormat GetFormat() const
    {
        return Format;
    }
 
    ETextureCreateFlags GetCreateFlags();
 
    // FTextureRenderTargetResource interface
 
    virtual class FTextureRenderTarget2DResource* GetTextureRenderTarget2DResource() override
    {
        return this;
    }
 
    virtual void ClampSize(int32 SizeX,int32 SizeY) override;
    
    // FRenderResource interface.
 
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
 
    virtual void ReleaseRHI() override;
 
    // FDeferredClearResource interface
 
    // FRenderTarget interface.
    virtual uint32 GetSizeX() const override;
 
    virtual uint32 GetSizeY() const override;
 
    virtual FIntPoint GetSizeXY() const override;
 
    virtual float GetDisplayGamma() const override;
 
    FUnorderedAccessViewRHIRef GetUnorderedAccessViewRHI() { return UnorderedAccessViewRHI; }
 
protected:
    friend class UTextureRenderTarget2D;
    virtual void UpdateDeferredResource(FRHICommandListImmediate& RHICmdList, bool bClearRenderTarget=true) override;
    void Resize(int32 NewSizeX, int32 NewSizeY, int32 NewNumMips);
 
    friend class FScene;
    friend class FSceneCapturePass;
    inline void Resize(FRHICommandListBase& RHICmdList, int32 NewSizeX, int32 NewSizeY, bool bAutoGenerateMips)
    {
        int32 NewNumMips = bAutoGenerateMips ? FMath::FloorLog2(FMath::Max(NewSizeX, NewSizeY)) + 1 : 1;
        if (TargetSizeX != NewSizeX || TargetSizeY != NewSizeY || TargetNumMips != NewNumMips)
        {
            TargetSizeX = NewSizeX;
            TargetSizeY = NewSizeY;
            TargetNumMips = NewNumMips;
            UpdateRHI(RHICmdList);
        }
    }
 
private:
    const class UTextureRenderTarget2D* Owner;
    UE_DEPRECATED(5.1, "Texture2DRHI is deprecated. Use TextureRHI instead.")
    FTextureRHIRef Texture2DRHI;
    FUnorderedAccessViewRHIRef UnorderedAccessViewRHI;
    FLinearColor ClearColor;
    EPixelFormat Format;
    int32 TargetSizeX,TargetSizeY;
    int32 TargetNumMips;
    TRefCountPtr<IPooledRenderTarget> MipGenerationCache;
};
 
class FTextureRenderTargetCubeResource : public FTextureRenderTargetResource
{
public:
 
    FTextureRenderTargetCubeResource(const class UTextureRenderTargetCube* InOwner)
        :   Owner(InOwner)
    {
    }
 
    virtual class FTextureRenderTargetCubeResource* GetTextureRenderTargetCubeResource()
    {
        return this;
    }
 
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
 
    virtual void ReleaseRHI() override;
 
    // FRenderTarget interface.
 
    virtual uint32 GetSizeX() const override;
 
    virtual uint32 GetSizeY() const override;
 
    virtual FIntPoint GetSizeXY() const override;
 
    FUnorderedAccessViewRHIRef GetUnorderedAccessViewRHI() { return UnorderedAccessViewRHI; }
 
    float GetDisplayGamma() const override;
 
    UE_DEPRECATED(5.4, "Use FRenderTarget's ReadPixels, which is functionally equivalent")
    ENGINE_API bool ReadPixels(TArray< FColor >& OutImageData, FReadSurfaceDataFlags InFlags, FIntRect InRect = FIntRect(0, 0, 0, 0));
 
    UE_DEPRECATED(5.4, "Use FRenderTarget's ReadFloat16Pixels, which is functionally equivalent")
    ENGINE_API bool ReadPixels(TArray<FFloat16Color>& OutImageData, FReadSurfaceDataFlags InFlags, FIntRect InRect = FIntRect(0, 0, 0, 0));
 
protected:
    friend class UTextureRenderTargetCube;
    virtual void UpdateDeferredResource(FRHICommandListImmediate& RHICmdList, bool bClearRenderTarget=true) override;
 
private:
    const class UTextureRenderTargetCube* Owner;
 
    UE_DEPRECATED(5.1, "TextureCubeRHI is deprecated. Use TextureRHI instead.")
    FTextureRHIRef TextureCubeRHI;
 
    UE_DEPRECATED(5.1, "CubeFaceSurfaceRHI is deprecated. Use TextureRHI instead.")
    FTextureRHIRef CubeFaceSurfaceRHI;
 
    UE_DEPRECATED(5.1, "RenderTargetCubeRHI is deprecated. Use TextureRHI instead.")
    FTextureRHIRef RenderTargetCubeRHI;
 
    FUnorderedAccessViewRHIRef UnorderedAccessViewRHI;
 
    ECubeFace CurrentTargetFace;
};
 
ENGINE_API FName GetDefaultTextureFormatName( const class ITargetPlatform* TargetPlatform, const class UTexture* Texture, int32 LayerIndex, bool bSupportCompressedVolumeTexture, int32 Unused_BlockSize, bool bSupportFilteredFloat32Textures);
ENGINE_API FName GetDefaultTextureFormatName( const class ITargetPlatformSettings* TargetPlatformSettings, const class ITargetPlatformControls* TargetPlatformControls, const class UTexture* Texture, int32 LayerIndex, bool bSupportCompressedVolumeTexture, int32 Unused_BlockSize, bool bSupportFilteredFloat32Textures);
 
ENGINE_API void GetDefaultTextureFormatNamePerLayer(TArray<FName>& OutFormatNames, const class ITargetPlatform* TargetPlatform, const class UTexture* Texture, bool bSupportCompressedVolumeTexture, int32 Unused_BlockSize, bool bSupportFilteredFloat32Textures);
ENGINE_API void GetDefaultTextureFormatNamePerLayer(TArray<FName>& OutFormatNames, const class ITargetPlatformSettings* TargetPlatformSettings, const class ITargetPlatformControls* TargetPlatformControls, const class UTexture* Texture, bool bSupportCompressedVolumeTexture, int32 Unused_BlockSize, bool bSupportFilteredFloat32Textures);
 
// returns all the texture formats which can be returned by GetDefaultTextureFormatName
ENGINE_API void GetAllDefaultTextureFormats( const class ITargetPlatform* TargetPlatform, TArray<FName>& OutFormats);
ENGINE_API void GetAllDefaultTextureFormats( const class ITargetPlatformSettings* TargetPlatformSettings, TArray<FName>& OutFormats);