StreamableTextureResource.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
/*=============================================================================
    StreamableTextureResource.h: Unreal texture related classes.
=============================================================================*/
 
#include "CoreMinimal.h"
#include "TextureResource.h"
#include "Streaming/StreamableRenderResourceState.h"
#include "Engine/Texture.h"
 
bool CanCreateWithPartiallyResidentMips(ETextureCreateFlags TexCreateFlags);
 
class FStreamableTextureResource : public FTextureResource
{
public:
 
    FStreamableTextureResource(UTexture* InOwner, const FTexturePlatformData* InPlatformData, const FStreamableRenderResourceState& InPostInitState, bool bAllowPartiallyResidentMips);
 
    // Dynamic cast methods.
    virtual FStreamableTextureResource* GetStreamableTextureResource() { return this; }
    // Dynamic cast methods (const).
    virtual const FStreamableTextureResource* GetStreamableTextureResource() const { return this; }
 
    virtual uint32 GetSizeX() const final override { return SizeX; }
    virtual uint32 GetSizeY() const final override { return SizeY; }
    // Depth for 3D texture or ArraySize for texture 2d arrays
    virtual uint32 GetSizeZ() const final override { return SizeZ; }
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
    virtual void ReleaseRHI() final override;
 
    // This is only coherent sync on the rendering thread. To get the gamethread coherent value, use UStreamableRenderResource.CacheStreamableResourceState
    inline FStreamableRenderResourceState GetState() const
    { 
        checkSlow(IsInRenderingThread())
        return IsInitialized() ? State : FStreamableRenderResourceState(); 
    }
 
    // Get the state it will be in after InitRHI() gets called. Used to synchronize UStreamableRenderResource.CacheStreamableResourceState in CreateResource().
    inline FStreamableRenderResourceState GetPostInitState() const
    { 
        checkSlow(IsInGameThread() && !IsInitialized());
        return State; 
    }
 
    void FinalizeStreaming(FRHICommandListBase& RHICmdList, FRHITexture* InTextureRHI);
    UE_DEPRECATED(5.7, "A RHICmdList argument is now required.")
    void FinalizeStreaming(FRHITexture* InTextureRHI);
 
    // Return the platform data mips, zero based on the resource mip count and not to the asset mip count.
    TArrayView<const FTexture2DMipMap*> GetPlatformMipsView() const;
    const FTexture2DMipMap* GetPlatformMip(int32 MipIdx) const;
 
    inline EPixelFormat GetPixelFormat() const { return PixelFormat; }
 
    // Return the texture creation flags, does not include TexCreate_Virtual as it could change per mip. Use IsTextureRHIPartiallyResident() instead.
    inline ETextureCreateFlags GetCreationFlags() const { return CreationFlags; }
 
    inline const FName& GetTextureName() const { return TextureName; }
 
    inline TextureGroup GetLODGroup() const { return LODGroup; }
 
    void RefreshSamplerStates();
 
    // Get the current first mip index, of this renderthread resource. Non streaming asset always return 0.
    inline int32 GetCurrentFirstMip() const
    {
        return State.IsValid() ? State.ResidentFirstLODIdx() : 0;
    }
 
    inline uint32 GetExtData() const { return PlatformData->GetExtData(); }
 
    virtual uint64 GetPlatformMipsSize(uint32 NumMips) const = 0;
 
protected:
 
    virtual void CreateTexture(FRHICommandListBase& RHICmdList) = 0;
    virtual void CreatePartiallyResidentTexture(FRHICommandListBase& RHICmdList) = 0;
 
    const FTexturePlatformData* PlatformData;
 
    FStreamableRenderResourceState State;
 
    TEnumAsByte<ESamplerFilter> Filter = SF_Point;
    TEnumAsByte<ESamplerAddressMode> AddressU = AM_Wrap;
    TEnumAsByte<ESamplerAddressMode> AddressV = AM_Wrap;
    TEnumAsByte<ESamplerAddressMode> AddressW = AM_Wrap;
    float MipBias = 0;
 
    uint32 SizeX = 0;
    uint32 SizeY = 0;
    uint32 SizeZ = 0;
 
    FName TextureName;
    EMipFadeSettings MipFadeSetting = MipFade_Normal;
    TextureGroup LODGroup = TEXTUREGROUP_World;
    EPixelFormat PixelFormat = PF_Unknown;
    ETextureCreateFlags  CreationFlags = TexCreate_None;
    bool bUsePartiallyResidentMips = false;
 
    int8 MaxAniso = 0;
 
#if STATS
private:
    void CalcRequestedMipsSize();
    void IncrementTextureStats() const;
    void DecrementTextureStats() const;
 
    FName LODGroupStatName;
    uint64 TextureSize = 0;
    bool bIsNeverStream = false;
#endif
};