TextureAtlas.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Containers/List.h"
#include "Layout/SlateRect.h"
 
#define WITH_ATLAS_DEBUGGING (WITH_EDITOR || IS_PROGRAM) && !UE_BUILD_SHIPPING
 
class FSlateShaderResource;
 
enum class ESlateFontAtlasContentType
{
    Alpha,
    Color,
    Msdf
};
 
enum ESlateTextureAtlasPaddingStyle
{
    NoPadding,
    DilateBorder,
    PadWithZero,
};
 
enum class ESlateTextureAtlasThreadId
{
    Unknown = -1,
    Game = 0,
    Render = 1,
};
 
SLATECORE_API ESlateTextureAtlasThreadId GetCurrentSlateTextureAtlasThreadId();
 
SLATECORE_API uint32 GetSlateFontAtlasContentBytesPerPixel(ESlateFontAtlasContentType InContentType);
 
struct FAtlasedTextureSlot : public TIntrusiveLinkedList<FAtlasedTextureSlot>
{
    uint32 X;
    uint32 Y;
    uint32 Width;
    uint32 Height;
    uint8 Padding;
 
    FAtlasedTextureSlot( uint32 InX, uint32 InY, uint32 InWidth, uint32 InHeight, uint8 InPadding )
        : TIntrusiveLinkedList<FAtlasedTextureSlot>()
        , X(InX)
        , Y(InY)
        , Width(InWidth)
        , Height(InHeight)
        , Padding(InPadding)
    {
    }
};
 
class FSlateTextureAtlas
{
public:
    SLATECORE_API FSlateTextureAtlas( uint32 InWidth, uint32 InHeight, uint32 InBytesPerPixel, ESlateTextureAtlasPaddingStyle InPaddingStyle, bool bInUpdatesAfterInitialization );
 
    SLATECORE_API virtual ~FSlateTextureAtlas();
 
    SLATECORE_API void EmptyAtlasData();
 
    SLATECORE_API const FAtlasedTextureSlot* AddTexture(uint32 TextureWidth, uint32 TextureHeight, const TArray<uint8>& Data);
 
    uint32 GetWidth() const { return AtlasWidth; }
    uint32 GetHeight() const { return AtlasHeight; }
 
    SLATECORE_API void MarkTextureDirty();
    
    virtual void ConditionalUpdateTexture() = 0;
 
    virtual void ReleaseResources() = 0;
 
    virtual FSlateShaderResource* GetAtlasTexture() const = 0;
 
#if WITH_ATLAS_DEBUGGING
    SLATECORE_API const FAtlasedTextureSlot* GetSlotAtPosition(FIntPoint InPosition) const;
#endif
protected:
    SLATECORE_API const FAtlasedTextureSlot* FindSlotForTexture( uint32 InWidth, uint32 InHeight );
 
    static int32 GetFreeSlotSearchIndex(uint32 InWidth, uint32 InHeight);
 
    void AddFreeSlot(uint32 InX, uint32 InY, uint32 InWidth, uint32 InHeight);
 
    SLATECORE_API void InitAtlasData();
 
    struct FCopyRowData
    {
        const uint8* SrcData;
        uint8* DestData;
        uint32 SrcRow;
        uint32 DestRow;
        uint32 RowWidth;
        uint32 SrcTextureWidth;
        uint32 DestTextureWidth;
    };
 
    SLATECORE_API void CopyRow( const FCopyRowData& CopyRowData );
 
    SLATECORE_API void ZeroRow( const FCopyRowData& CopyRowData );
 
    SLATECORE_API void CopyDataIntoSlot( const FAtlasedTextureSlot* SlotToCopyTo, const TArray<uint8>& Data );
 
private:
    inline uint8 GetPaddingAmount() const
    {
        return (PaddingStyle == ESlateTextureAtlasPaddingStyle::NoPadding) ? 0 : 1;
    }
protected:
    TArray<uint8> AtlasData;
    FAtlasedTextureSlot* AtlasUsedSlots;
    TArray<FAtlasedTextureSlot*> AtlasEmptySlotsMap;
    uint32 AtlasWidth;
    uint32 AtlasHeight;
    uint32 BytesPerPixel;
    ESlateTextureAtlasPaddingStyle PaddingStyle;
 
    bool bNeedsUpdate;
    bool bUpdatesAfterInitialization;
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    ESlateTextureAtlasThreadId AtlasOwnerThread;
#endif
};
 
struct FAtlasSlotInfo
{
    FAtlasSlotInfo()
        : AtlasSlotRect()
        , TextureName(NAME_None)
    {}
 
    bool operator!= (const FAtlasSlotInfo& Other) const
    {
        return AtlasSlotRect != Other.AtlasSlotRect & TextureName != Other.TextureName;
    }
 
    FSlateRect AtlasSlotRect;
    FName TextureName;
};
 
 
class ISlateTextureAtlasFactory
{
public:
    virtual ~ISlateTextureAtlasFactory() {}
    virtual TUniquePtr<FSlateTextureAtlas> CreateTextureAtlas(int32 AtlasSize, int32 AtlasStride, ESlateTextureAtlasPaddingStyle PaddingStyle, bool bUpdatesAfterInitialization) const = 0;
 
    virtual TUniquePtr<FSlateShaderResource> CreateNonAtlasedTexture(const uint32 InWidth, const uint32 InHeight, const TArray<uint8>& InRawData) const = 0;
 
    virtual void ReleaseTextureAtlases(const TArray<TUniquePtr<FSlateTextureAtlas>>& InTextureAtlases, const TArray<TUniquePtr<FSlateShaderResource>>& InNonAtlasedTextures, const bool bWaitForRelease) const = 0;
};
 
struct FAtlasFlushParams
{
    int32 InitialMaxAtlasPagesBeforeFlushRequest = 1;
    int32 InitialMaxNonAtlasPagesBeforeFlushRequest = 1;
    int32 GrowAtlasFrameWindow = 1;
    int32 GrowNonAtlasFrameWindow = 1;
};
 
class FSlateFlushableAtlasCache
{
public:
    FSlateFlushableAtlasCache(const FAtlasFlushParams* InFlushParams);
 
    virtual ~FSlateFlushableAtlasCache() {}
 
    virtual void RequestFlushCache(const FString& Reason) = 0;
 
    void ResetFlushCounters();
 
    void UpdateFlushCounters(int32 NumGrayscale, int32 NumColor, int32 NumMsdf, int32 NumNonAtlased);
 
private:
    bool UpdateInternal(int32 CurrentNum, int32& MaxNum, int32 InitialMax, int32 FrameWindowNum);
private:
    const FAtlasFlushParams* FlushParams;
 
    int32 CurrentMaxGrayscaleAtlasPagesBeforeFlushRequest;
 
    int32 CurrentMaxColorAtlasPagesBeforeFlushRequest;
 
    int32 CurrentMaxMsdfAtlasPagesBeforeFlushRequest;
 
    int32 CurrentMaxNonAtlasedTexturesBeforeFlushRequest;
 
    uint64 FrameCounterLastFlushRequest;
};
 
class ISlateAtlasProvider
{
public:
    virtual ~ISlateAtlasProvider() {}
 
    virtual int32 GetNumAtlasPages() const = 0;
 
    virtual class FSlateShaderResource* GetAtlasPageResource(const int32 InIndex) const = 0;
 
    virtual bool IsAtlasPageResourceAlphaOnly(const int32 InIndex) const = 0;
    
#if WITH_ATLAS_DEBUGGING
    virtual FAtlasSlotInfo GetAtlasSlotInfoAtPosition(FIntPoint InPosition, int32 AtlasIndex) const = 0;
#endif
};