SlateRHIResourceManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Stats/Stats.h"
#include "Textures/TextureAtlas.h"
#include "UObject/GCObject.h"
#include "UObject/ObjectKey.h"
#include "Containers/Queue.h"
#include "Rendering/ShaderResourceManager.h"
#include "Rendering/RenderingCommon.h"
#include "Rendering/DrawElements.h"
#include "Materials/MaterialInterface.h"
#include "Tickable.h"
#include "SlateElementVertexBuffer.h"
 
class FSlateAtlasedTextureResource;
class FSlateDynamicTextureResource;
class FSlateMaterialResource;
class FSlateUTextureResource;
class ISlateStyle;
class UTexture;
class FSceneInterface;
class FSlateVectorGraphicsCache;
 
struct FMaterialKey
{
    FObjectKey Material;
    const FVector2f ImageSize;
    int32 MaskKey;
 
    FMaterialKey(const UMaterialInterface* InMaterial, const FVector2f InImageSize, int32 InMaskKey)
        : Material(InMaterial)
        , ImageSize(InImageSize)
        , MaskKey(InMaskKey)
    {}
 
    friend bool operator==(const FMaterialKey& Lhs, const FMaterialKey& Rhs)
    {
        return Lhs.Material == Rhs.Material && Lhs.ImageSize == Rhs.ImageSize && Lhs.MaskKey == Rhs.MaskKey;
    }
 
    friend uint32 GetTypeHash(const FMaterialKey& Key)
    {
        return HashCombine(GetTypeHash(Key.Material), HashCombine(GetTypeHash(Key.ImageSize), Key.MaskKey));
    }
};
 
struct FDynamicResourceMap
{
public:
    FDynamicResourceMap();
 
    TSharedPtr<FSlateDynamicTextureResource> GetDynamicTextureResource( FName ResourceName ) const;
 
    TSharedPtr<FSlateUTextureResource> GetUTextureResource( UTexture* TextureObject ) const;
 
    TSharedPtr<FSlateAtlasedTextureResource> GetAtlasedTextureResource(UTexture* InObject) const;
 
    TSharedPtr<FSlateMaterialResource> GetMaterialResource( const FMaterialKey& InKey ) const;
 
    void AddUTextureResource( UTexture* TextureObject, TSharedRef<FSlateUTextureResource> InResource );
    void RemoveUTextureResource( UTexture* TextureObject );
 
    void AddDynamicTextureResource( FName ResourceName, TSharedRef<FSlateDynamicTextureResource> InResource);
    void RemoveDynamicTextureResource( FName ResourceName );
 
    void AddMaterialResource( const FMaterialKey& InKey, TSharedRef<FSlateMaterialResource> InResource );
    void RemoveMaterialResource( const FMaterialKey& InKey );
 
    void AddAtlasedTextureResource(UTexture* TextureObject, TSharedRef<FSlateAtlasedTextureResource> InResource);
    void RemoveAtlasedTextureResource(UTexture* TextureObject);
 
    FSlateShaderResourceProxy* FindOrCreateAtlasedProxy(UObject* InObject);
 
    void Empty();
 
    void EmptyUTextureResources();
    void EmptyMaterialResources();
    void EmptyDynamicTextureResources();
 
    void ReleaseResources();
 
    uint32 GetNumObjectResources() const { return TextureMap.Num() + MaterialMap.Num(); }
 
public:
    void RemoveExpiredTextureResources(TArray< TSharedPtr<FSlateUTextureResource> >& RemovedTextures);
    void RemoveExpiredMaterialResources(TArray< TSharedPtr<FSlateMaterialResource> >& RemovedMaterials);
 
private:
    TMap<FName, TSharedPtr<FSlateDynamicTextureResource> > NativeTextureMap;
    
    typedef TMap<TWeakObjectPtr<UTexture>, TSharedPtr<FSlateUTextureResource> > FTextureResourceMap;
    FTextureResourceMap TextureMap;
 
    typedef TMap<FMaterialKey, TSharedPtr<FSlateMaterialResource> > FMaterialResourceMap;
    FMaterialResourceMap MaterialMap;
 
    typedef TMap<TWeakObjectPtr<UObject>, TSharedPtr<FSlateAtlasedTextureResource> > FObjectResourceMap;
    FObjectResourceMap ObjectMap;
};
 
class FSlateRHIResourceManager : public ISlateAtlasProvider, public FSlateShaderResourceManager, public FTickableGameObject
{
public:
    FSlateRHIResourceManager();
    virtual ~FSlateRHIResourceManager();
 
    virtual int32 GetNumAtlasPages() const override;
    virtual FSlateShaderResource* GetAtlasPageResource(const int32 InIndex) const override;
    virtual bool IsAtlasPageResourceAlphaOnly(const int32 InIndex) const override;
#if WITH_ATLAS_DEBUGGING
    virtual FAtlasSlotInfo GetAtlasSlotInfoAtPosition(FIntPoint InPosition, int32 AtlasIndex) const override;
#endif
 
    virtual ETickableTickType GetTickableTickType() const override { return ETickableTickType::Always; }
    virtual bool IsTickableWhenPaused() const override { return true; }
    virtual bool IsTickableInEditor() const override { return true; }
    virtual TStatId GetStatId() const override { RETURN_QUICK_DECLARE_CYCLE_STAT(FSlateRHIResourceManager, STATGROUP_Tickables); }
    virtual void Tick(float DeltaSeconds) override;
 
    void LoadUsedTextures();
 
    void LoadStyleResources( const ISlateStyle& Style );
 
    void UpdateTextureAtlases();
    void ConditionalFlushAtlases();
 
    virtual FSlateShaderResourceProxy* GetShaderResource(const FSlateBrush& InBrush, FVector2f LocalSize, float DrawScale) override;
    virtual FSlateShaderResource* GetFontShaderResource( int32 InTextureAtlasIndex, FSlateShaderResource* FontTextureAtlas, const class UObject* FontMaterial ) override;
    virtual ISlateAtlasProvider* GetTextureAtlasProvider() override;
 
    TSharedPtr<FSlateUTextureResource> MakeDynamicUTextureResource( UTexture* InTextureObject);
    
    TSharedPtr<FSlateDynamicTextureResource> MakeDynamicTextureResource( FName ResourceName, uint32 Width, uint32 Height, const TArray< uint8 >& Bytes );
 
    TSharedPtr<FSlateDynamicTextureResource> MakeDynamicTextureResource(FName ResourceName, FSlateTextureDataRef TextureData);
 
    TSharedPtr<FSlateDynamicTextureResource> GetDynamicTextureResourceByName( FName ResourceName );
 
    bool ContainsTexture( const FName& ResourceName ) const;
 
    void ReleaseDynamicResource( const FSlateBrush& InBrush );
 
    virtual bool LoadTexture( const FName& TextureName, const FString& ResourcePath, uint32& Width, uint32& Height, TArray<uint8>& DecodedImage );
    virtual bool LoadTexture( const FSlateBrush& InBrush, uint32& Width, uint32& Height, TArray<uint8>& DecodedImage );
 
 
    void ReleaseResources();
 
    void ReloadTextures();
 
    int32 GetSceneCount();
    FSceneInterface* GetSceneAt(int32 Index);
    void AddSceneAt(FSceneInterface* Scene, int32 Index);
    void ClearScenes();
 
    FCriticalSection* GetResourceCriticalSection() { return &ResourceCriticalSection; }
 
private:
    void CreateVectorGraphicsCache();
 
    void OnPreGarbageCollect();
    void OnPostGarbageCollect();
 
    void TryToCleanupExpiredResources(bool bForceCleanup);
    void CleanupExpiredResources();
 
    void DeleteResources();
 
    void DeleteUObjectBrushResources();
 
    void DeleteBrushResourcesCommand();
 
    void CreateTextures( const TArray< const FSlateBrush* >& Resources );
 
    FSlateShaderResourceProxy* GenerateTextureResource( const FNewTextureInfo& Info, const FName TextureName );
    
    FSlateShaderResourceProxy* FindOrCreateDynamicTextureResource( const FSlateBrush& InBrush );
 
    FSlateMaterialResource* GetMaterialResource( const UObject* InMaterial, const FSlateBrush* InBrush, FSlateShaderResource* TextureMask, int32 InMaskKey );
 
    FSlateShaderResourceProxy* GetVectorResource(const FSlateBrush& Brush, FVector2f LocalSize, float DrawScale);
 
    void OnAppExit();
 
    UTexture* GetBadResourceTexture();
 
private:
    FCriticalSection ResourceCriticalSection;
 
    bool bResourceCriticalSectionLockedForGC;
 
    bool bExpiredResourcesNeedCleanup;
 
    FDynamicResourceMap DynamicResourceMap;
    TArray< TSharedPtr<FSlateUTextureResource> > UTextureFreeList;
    TArray< TSharedPtr<FSlateDynamicTextureResource> > DynamicTextureFreeList;
    TArray< TSharedPtr<FSlateMaterialResource> > MaterialResourceFreeList;
    TArray<class FSlateTextureAtlasRHI*> PrecachedTextureAtlases;
    TArray<class FSlateTexture2DRHIRef*> NonAtlasedTextures;
    uint32 AtlasSize;
    FIntPoint MaxAltasedTextureSize;
    UTexture* BadResourceTexture;
 
    TArray<FSceneInterface*> ActiveScenes;
 
    FAutoConsoleCommand DeleteResourcesCommand;
 
    TUniquePtr<FSlateVectorGraphicsCache> VectorGraphicsCache;
};