FontCache.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "SlateGlobals.h"
#include "Fonts/ShapedTextFwd.h"
#include "UObject/ObjectMacros.h"
#include "Fonts/SlateFontInfo.h"
#include "Fonts/FontRasterizationMode.h"
#include "Fonts/FontSdfSettings.h"
#include "Textures/TextureAtlas.h"
#include "Fonts/FontTypes.h"
#include "FontCache.generated.h"
 
class FCompositeFontCache;
class FFreeTypeAdvanceCache;
class FFreeTypeCacheDirectory;
class FFreeTypeFace;
class FFreeTypeGlyphCache;
class FFreeTypeKerningCache;
class FFreeTypeLibrary;
class FShapedGlyphFaceData;
class FSlateFontCache;
class FSlateFontRenderer;
class FSlateShaderResource;
class FSlateTextShaper;
class FSlateSdfGenerator;
 
SLATECORE_API bool IsSlateSdfTextFeatureEnabled();
 
enum class EFontCacheAtlasDataType : uint8
{
    Regular = 0,
 
    Outline,
 
    Num,
};
 
 
UENUM(BlueprintType)
enum class ETextShapingMethod : uint8
{
     Auto = 0,
 
    KerningOnly,
 
    FullShaping,
};
 
SLATECORE_API ETextShapingMethod GetDefaultTextShapingMethod();
 
struct FShapedGlyphFontAtlasData
{
    int16 VerticalOffset = 0;
    int16 HorizontalOffset = 0;
    uint16 StartU = 0;
    uint16 StartV = 0;
    uint16 USize = 0;
    uint16 VSize = 0;
    uint8 TextureIndex = 0;
    bool SupportsOutline = false;
    bool Valid = false;
};
 
struct FSdfGlyphFontAtlasData
{
    int16 VerticalOffset = 0;
    int16 HorizontalOffset = 0;
    uint16 StartU = 0;
    uint16 StartV = 0;
    uint16 USize = 0;
    uint16 VSize = 0;
    float EmOuterSpread = 0.f;
    float EmInnerSpread = 0.f;
 
    struct FMetrics
    {
        float BearingX = 0.f;
        float BearingY = 0.f;
        float Width = 0.f;
        float Height = 0.f;
    };
    FMetrics Metrics;
    uint8 TextureIndex = 0;
    bool bSupportsSdf = false;
    bool bPendingRespawn = false;
    bool Valid = false;
};
 
struct FShapedGlyphEntry
{
    friend class FSlateFontCache;
 
    TSharedPtr<FShapedGlyphFaceData> FontFaceData;
    uint32 GlyphIndex = 0;
    int32 SourceIndex = 0;
    int16 XAdvance = 0;
    int16 YAdvance = 0;
    int16 XOffset = 0;
    int16 YOffset = 0;
    int8 Kerning = 0;
    uint8 NumCharactersInGlyph = 0;
    uint8 NumGraphemeClustersInGlyph = 0;
    TextBiDi::ETextDirection TextDirection = TextBiDi::ETextDirection::LeftToRight;
    bool bIsVisible = false;
    
    SLATECORE_API bool HasValidGlyph() const;
 
    SLATECORE_API float GetBitmapRenderScale() const;
 
private:
    mutable TWeakPtr<FShapedGlyphFontAtlasData> CachedAtlasData[(uint8)EFontCacheAtlasDataType::Num][2];
    mutable TWeakPtr<FSdfGlyphFontAtlasData> CachedSdfFontAtlasData[2];
    mutable FSdfGlyphFontAtlasData::FMetrics CachedSdfMetrics[2];
};
 
struct FShapedGlyphEntryKey
{
    friend struct FFontCacheStatsKey;
    friend class FSlateFontCache;
 
public:
    FShapedGlyphEntryKey(const FShapedGlyphFaceData& InFontFaceData, uint32 InGlyphIndex, const FFontOutlineSettings& InOutlineSettings);
 
    inline bool operator==(const FShapedGlyphEntryKey& Other) const
    {
        return FontFace == Other.FontFace 
            && FontRenderSize == Other.FontRenderSize
            && OutlineRenderSize == Other.OutlineRenderSize
            && OutlineMiteredCorners == Other.OutlineMiteredCorners
            && OutlineSeparateFillAlpha == Other.OutlineSeparateFillAlpha
            && GlyphIndex == Other.GlyphIndex
            && FontSkew == Other.FontSkew;
    }
 
    inline bool operator!=(const FShapedGlyphEntryKey& Other) const
    {
        return !(*this == Other);
    }
 
    friend inline uint32 GetTypeHash(const FShapedGlyphEntryKey& Key)
    {
        return Key.KeyHash;
    }
 
private:
    TWeakPtr<FFreeTypeFace> FontFace;
    uint32 FontRenderSize;
    int32 OutlineRenderSize;
    bool OutlineMiteredCorners;
    bool OutlineSeparateFillAlpha;
    uint32 GlyphIndex;
    uint32 KeyHash;
    float FontSkew;
};
 
struct FSdfGlyphEntryKey
{
public:
    FSdfGlyphEntryKey(const TWeakPtr<FFreeTypeFace> InFontFace, uint32 InGlyphIndex, ESlateFontAtlasContentType InAtlasContentType, int32 InPpem, float InEmOuterSpread, float InEmInnerSpread);
 
    inline bool operator==(const FSdfGlyphEntryKey& Other) const
    {
        return FontFace == Other.FontFace
            && GlyphIndex == Other.GlyphIndex
            && AtlasContentType == Other.AtlasContentType
            && Ppem == Other.Ppem
            && SpreadCategory == Other.SpreadCategory;
    }
 
    inline bool operator!=(const FSdfGlyphEntryKey& Other) const
    {
        return !(*this == Other);
    }
 
    friend inline uint32 GetTypeHash(const FSdfGlyphEntryKey& Key)
    {
        return Key.KeyHash;
    }
 
    const TWeakPtr<FFreeTypeFace> FontFace;
    const uint32 GlyphIndex;
    const ESlateFontAtlasContentType AtlasContentType;
    const int32 Ppem;
    const int32 SpreadCategory;
 
private:
    uint32 KeyHash;
 
    static int32 GetSpreadCategory(float InEmOuterSpread, float InEmInnerSpread);
};
 
struct FSdfGlyphTaskKey
{
public:
    inline FSdfGlyphTaskKey(const FSdfGlyphEntryKey& InSdfGlyphEntryKey, float InEmOuterSpread, float InEmInnerSpread);
 
    inline bool operator==(const FSdfGlyphTaskKey& Other) const
    {
        return SdfGlyphEntryKey == Other.SdfGlyphEntryKey
            && EmOuterSpread == Other.EmOuterSpread
            && EmInnerSpread == Other.EmInnerSpread;
    }
 
    inline bool operator!=(const FSdfGlyphTaskKey& Other) const
    {
        return !(*this == Other);
    }
 
    friend inline uint32 GetTypeHash(const FSdfGlyphTaskKey& Key)
    {
        return Key.KeyHash;
    }
 
    const FSdfGlyphEntryKey SdfGlyphEntryKey;
    float EmOuterSpread;
    float EmInnerSpread;
 
private:
    uint32 KeyHash;
};
 
class FShapedGlyphSequence
{
public:
    struct FSourceTextRange
    {
        FSourceTextRange(const int32 InTextStart, const int32 InTextLen)
            : TextStart(InTextStart)
            , TextLen(InTextLen)
        {
        }
 
        int32 TextStart;
        int32 TextLen;
    };
 
    explicit FShapedGlyphSequence()
        : GlyphsToRender()
        , TextBaseline(0)
        , MaxTextHeight(0)
        , bMaterialIsStencil(false)
        , FontMaterial(nullptr)
        , OutlineSettings()
        , SequenceWidth(0)
        , GlyphFontFaces()
        , SourceIndicesToGlyphData(FSourceTextRange(0, 0))
        , CachedFontSkew(0.f)
    { }
 
    SLATECORE_API FShapedGlyphSequence(TArray<FShapedGlyphEntry> InGlyphsToRender,
                         const int16 InTextBaseline,
                         const uint16 InMaxTextHeight,
                         const UObject* InFontMaterial,
                         const bool InMaterialIsStencil,
                         const FFontOutlineSettings& InOutlineSettings,
                         const FSourceTextRange& InSourceTextRange);
    SLATECORE_API ~FShapedGlyphSequence();
 
    SLATECORE_API SIZE_T GetAllocatedSize() const;
 
    const TArray<FShapedGlyphEntry>& GetGlyphsToRender() const
    {
        return GlyphsToRender;
    }
 
    int16 GetTextBaseline() const
    {
        return TextBaseline;
    }
 
    uint16 GetMaxTextHeight() const
    {
        return MaxTextHeight;
    }
 
    const UObject* GetFontMaterial() const
    {
        return FontMaterial;
    }
 
    bool IsMaterialStencil() const
    {
        return bMaterialIsStencil;
    }
 
    const FFontOutlineSettings& GetFontOutlineSettings() const
    {
        return OutlineSettings;
    }
 
    SLATECORE_API bool IsDirty() const;
 
    float GetFontSkew() const;
 
    SLATECORE_API int32 GetMeasuredWidth() const;
 
    SLATECORE_API TOptional<int32> GetMeasuredWidth(const int32 InStartIndex, const int32 InEndIndex, const bool InIncludeKerningWithPrecedingGlyph = true) const;
 
    struct FGlyphOffsetResult
    {
        FGlyphOffsetResult()
            : Glyph(nullptr)
            , GlyphOffset(0)
            , CharacterIndex(0)
        {
        }
 
        explicit FGlyphOffsetResult(const int32 InCharacterIndex)
            : Glyph(nullptr)
            , GlyphOffset(0)
            , CharacterIndex(InCharacterIndex)
        {
        }
 
        FGlyphOffsetResult(const FShapedGlyphEntry* InGlyph, const int32 InGlyphOffset)
            : Glyph(InGlyph)
            , GlyphOffset(InGlyphOffset)
            , CharacterIndex(InGlyph->SourceIndex)
        {
        }
 
        const FShapedGlyphEntry* Glyph;
        int32 GlyphOffset;
        int32 CharacterIndex;
    };
 
    SLATECORE_API FGlyphOffsetResult GetGlyphAtOffset(FSlateFontCache& InFontCache, const int32 InHorizontalOffset, const int32 InStartOffset = 0) const;
 
    SLATECORE_API TOptional<FGlyphOffsetResult> GetGlyphAtOffset(FSlateFontCache& InFontCache, const int32 InStartIndex, const int32 InEndIndex, const int32 InHorizontalOffset, const int32 InStartOffset = 0, const bool InIncludeKerningWithPrecedingGlyph = true) const;
 
    SLATECORE_API TOptional<int8> GetKerning(const int32 InIndex) const;
 
    SLATECORE_API FShapedGlyphSequencePtr GetSubSequence(const int32 InStartIndex, const int32 InEndIndex) const;
 
    SLATECORE_API void AddReferencedObjects(FReferenceCollector& Collector);
 
private:
    SLATECORE_API FShapedGlyphSequence(const FShapedGlyphSequence&);
    SLATECORE_API FShapedGlyphSequence& operator=(const FShapedGlyphSequence&);
 
    SLATECORE_API bool HasFoundGlyphAtOffset(FSlateFontCache& InFontCache, const int32 InHorizontalOffset, const FShapedGlyphEntry& InCurrentGlyph, const int32 InCurrentGlyphIndex, int32& InOutCurrentOffset, const FShapedGlyphEntry*& OutMatchedGlyph) const;
 
    enum class EEnumerateGlyphsResult : uint8 { EnumerationFailed, EnumerationAborted, EnumerationComplete };
    typedef TFunctionRef<bool(const FShapedGlyphEntry&, int32)> FForEachShapedGlyphEntryCallback;
    SLATECORE_API EEnumerateGlyphsResult EnumerateLogicalGlyphsInSourceRange(const int32 InStartIndex, const int32 InEndIndex, const FForEachShapedGlyphEntryCallback& InGlyphCallback) const;
    SLATECORE_API EEnumerateGlyphsResult EnumerateVisualGlyphsInSourceRange(const int32 InStartIndex, const int32 InEndIndex, const FForEachShapedGlyphEntryCallback& InGlyphCallback) const;
 
    struct FSourceIndexToGlyphData
    {
        FSourceIndexToGlyphData()
            : GlyphIndex(INDEX_NONE)
            , AdditionalGlyphIndices()
        {
        }
 
        explicit FSourceIndexToGlyphData(const int32 InGlyphIndex)
            : GlyphIndex(InGlyphIndex)
            , AdditionalGlyphIndices()
        {
        }
 
        bool IsValid() const
        {
            return GlyphIndex != INDEX_NONE;
        }
 
        int32 GetLowestGlyphIndex() const
        {
            return GlyphIndex;
        };
 
        int32 GetHighestGlyphIndex() const
        {
            return (AdditionalGlyphIndices.Num() > 0) ? AdditionalGlyphIndices.Last() : GlyphIndex;
        }
 
        int32 GlyphIndex;
        TArray<int32> AdditionalGlyphIndices;
    };
 
    struct FSourceIndicesToGlyphData
    {
    public:
        explicit FSourceIndicesToGlyphData(const FSourceTextRange& InSourceTextRange)
            : SourceTextRange(InSourceTextRange)
            , GlyphDataArray()
        {
            GlyphDataArray.SetNum(InSourceTextRange.TextLen);
        }
 
        inline int32 GetSourceTextStartIndex() const
        {
            return SourceTextRange.TextStart;
        }
 
        inline int32 GetSourceTextEndIndex() const
        {
            return SourceTextRange.TextStart + SourceTextRange.TextLen;
        }
 
        inline FSourceIndexToGlyphData* GetGlyphData(const int32 InSourceTextIndex)
        {
            const int32 InternalIndex = InSourceTextIndex - SourceTextRange.TextStart;
            return (GlyphDataArray.IsValidIndex(InternalIndex)) ? &GlyphDataArray[InternalIndex] : nullptr;
        }
 
        inline const FSourceIndexToGlyphData* GetGlyphData(const int32 InSourceTextIndex) const
        {
            const int32 InternalIndex = InSourceTextIndex - SourceTextRange.TextStart;
            return (GlyphDataArray.IsValidIndex(InternalIndex)) ? &GlyphDataArray[InternalIndex] : nullptr;
        }
 
        inline SIZE_T GetAllocatedSize() const
        {
            return GlyphDataArray.GetAllocatedSize();
        }
 
    private:
        FSourceTextRange SourceTextRange;
        TArray<FSourceIndexToGlyphData> GlyphDataArray;
    };
 
    TArray<FShapedGlyphEntry> GlyphsToRender;
    int16 TextBaseline;
    uint16 MaxTextHeight;
    bool bMaterialIsStencil;
    TObjectPtr<const UObject> FontMaterial;
    FFontOutlineSettings OutlineSettings;
    int32 SequenceWidth;
    TArray<TWeakPtr<FFreeTypeFace>> GlyphFontFaces;
    FSourceIndicesToGlyphData SourceIndicesToGlyphData;
    float CachedFontSkew;
 
#if SLATE_CHECK_UOBJECT_SHAPED_GLYPH_SEQUENCE
    // Used to guard against crashes when the material object is deleted. This is expensive so we do not do it in shipping
    TWeakObjectPtr<const UObject> FontMaterialWeakPtr;
    TWeakObjectPtr<const UObject> SdfFontMaterialOverrideWeakPtr;
    TWeakObjectPtr<const UObject> OutlineMaterialWeakPtr;
    FName DebugFontMaterialName;
    FName DebugSdfFontMaterialOverrideName;
    FName DebugOutlineMaterialName;
#endif
};
 
struct FCharacterEntry
{
    TCHAR Character = 0;
    uint32 GlyphIndex = 0;
    const FFontData* FontData = nullptr;
    TSharedPtr<FFreeTypeKerningCache> KerningCache;
    float FontScale = 0.0f;
    float BitmapRenderScale = 0.0f;
    uint16 StartU = 0;
    uint16 StartV = 0;
    uint16 USize = 0;
    uint16 VSize = 0;
    int16 VerticalOffset = 0;
    int16 HorizontalOffset = 0;
    int16 GlobalDescender = 0;
    int16 XAdvance = 0;
    uint8 TextureIndex = 0;
    EFontFallback FallbackLevel = EFontFallback::FF_Max;
    bool HasKerning = false;
    bool SupportsOutline = false;
    bool Valid = false;
};
 
class FCharacterList
{
public:
    SLATECORE_API FCharacterList( const FSlateFontKey& InFontKey, FSlateFontCache& InFontCache );
 
    SLATECORE_API const FCharacterEntry& GetCharacter(TCHAR Character, const EFontFallback MaxFontFallback);
 
#if WITH_EDITORONLY_DATA
    SLATECORE_API bool IsStale() const;
#endif  // WITH_EDITORONLY_DATA
 
    SLATECORE_API int8 GetKerning(TCHAR FirstChar, TCHAR SecondChar, const EFontFallback MaxFontFallback);
 
    SLATECORE_API int8 GetKerning( const FCharacterEntry& FirstCharacterEntry, const FCharacterEntry& SecondCharacterEntry );
 
    SLATECORE_API uint16 GetMaxHeight() const;
 
    SLATECORE_API int16 GetBaseline() const;
 
private:
    bool CanCacheCharacter(TCHAR Character, const EFontFallback MaxFontFallback) const;
 
    const FCharacterEntry* CacheCharacter(TCHAR Character);
 
private:
    TMap<TCHAR, FCharacterEntry> MappedEntries;
 
    FSlateFontKey FontKey;
    FSlateFontCache& FontCache;
#if WITH_EDITORONLY_DATA
    int32 CompositeFontHistoryRevision;
#endif  // WITH_EDITORONLY_DATA
    mutable uint16 MaxHeight;
    mutable int16 Baseline;
};
 
class FSlateFontCache : public ISlateAtlasProvider, public FSlateFlushableAtlasCache
{
    friend FCharacterList;
 
public:
    SLATECORE_API FSlateFontCache( TSharedRef<ISlateFontAtlasFactory> InFontAtlasFactory, ESlateTextureAtlasThreadId InOwningThread);
    SLATECORE_API virtual ~FSlateFontCache();
 
    SLATECORE_API virtual int32 GetNumAtlasPages() const override;
    SLATECORE_API virtual FSlateShaderResource* GetAtlasPageResource(const int32 InIndex) const override;
    SLATECORE_API virtual bool IsAtlasPageResourceAlphaOnly(const int32 InIndex) const override;
#if WITH_ATLAS_DEBUGGING
    virtual FAtlasSlotInfo GetAtlasSlotInfoAtPosition(FIntPoint InPosition, int32 AtlasIndex) const override;
#endif
    SLATECORE_API FShapedGlyphSequenceRef ShapeBidirectionalText( const FString& InText, const FSlateFontInfo &InFontInfo, const float InFontScale, const TextBiDi::ETextDirection InBaseDirection, const ETextShapingMethod InTextShapingMethod ) const;
    SLATECORE_API FShapedGlyphSequenceRef ShapeBidirectionalText( const TCHAR* InText, const int32 InTextStart, const int32 InTextLen, const FSlateFontInfo &InFontInfo, const float InFontScale, const TextBiDi::ETextDirection InBaseDirection, const ETextShapingMethod InTextShapingMethod ) const;
 
    SLATECORE_API FShapedGlyphSequenceRef ShapeUnidirectionalText( const FString& InText, const FSlateFontInfo &InFontInfo, const float InFontScale, const TextBiDi::ETextDirection InTextDirection, const ETextShapingMethod InTextShapingMethod ) const;
    SLATECORE_API FShapedGlyphSequenceRef ShapeUnidirectionalText( const TCHAR* InText, const int32 InTextStart, const int32 InTextLen, const FSlateFontInfo &InFontInfo, const float InFontScale, const TextBiDi::ETextDirection InTextDirection, const ETextShapingMethod InTextShapingMethod ) const;
 
    SLATECORE_API FShapedGlyphSequenceRef ShapeOverflowEllipsisText(const FSlateFontInfo& InFontInfo, const float InFontScale);
 
    SLATECORE_API class FCharacterList& GetCharacterList( const FSlateFontInfo &InFontInfo, float FontScale, const FFontOutlineSettings& InOutlineSettings = FFontOutlineSettings::NoOutline);
 
    SLATECORE_API FShapedGlyphFontAtlasData GetShapedGlyphFontAtlasData(const FShapedGlyphEntry& InShapedGlyph, const FFontOutlineSettings& InOutlineSettings);
    
    SLATECORE_API FSdfGlyphFontAtlasData GetSdfGlyphFontAtlasData(const FShapedGlyphEntry& InShapedGlyph, const FFontOutlineSettings& InOutlineSettings);
 
    UE_DEPRECATED(5.1, "GetOverflowEllipsisText is known to create dangling pointer. Use FShapedTextCache::FindOrAddOverflowEllipsisText.")
    SLATECORE_API FShapedGlyphSequenceRef GetOverflowEllipsisText(const FSlateFontInfo& InFontInfo, const float InFontScale);
 
public:
    SLATECORE_API void FlushObject( const UObject* const InObject );
 
    SLATECORE_API void FlushCompositeFont(const FCompositeFont& InCompositeFont);
 
    SLATECORE_API bool ConditionalFlushCache();
 
    SLATECORE_API void UpdateCache();
 
    SLATECORE_API void ReleaseResources();
 
    FOnReleaseFontResources& OnReleaseResources() { return OnReleaseResourcesDelegate; }
 
    ISlateFontTexture* GetFontTexture( uint32 Index ) { return &AllFontTextures[Index].Get(); }
 
    SLATECORE_API const FFontData& GetDefaultFontData( const FSlateFontInfo& InFontInfo ) const;
 
    SLATECORE_API const FFontData& GetFontDataForCodepoint( const FSlateFontInfo& InFontInfo, const UTF32CHAR InCodepoint, float& OutScalingFactor ) const;
 
    SLATECORE_API bool HasLoadedFontForCodepoint(const FSlateFontInfo& InFontInfo, const UTF32CHAR InCodepoint) const;
 
    SLATECORE_API uint16 GetMaxCharacterHeight( const FSlateFontInfo& InFontInfo, float FontScale ) const;
 
    SLATECORE_API int16 GetBaseline( const FSlateFontInfo& InFontInfo, float FontScale ) const;
 
    SLATECORE_API void GetUnderlineMetrics( const FSlateFontInfo& InFontInfo, const float FontScale, int16& OutUnderlinePos, int16& OutUnderlineThickness ) const;
 
    SLATECORE_API void GetStrikeMetrics( const FSlateFontInfo& InFontInfo, const float FontScale, int16& OutStrikeLinePos, int16& OutStrikeLineThickness ) const;
 
    SLATECORE_API int8 GetKerning( const FFontData& InFontData, const float InSize, TCHAR First, TCHAR Second, float Scale ) const;
 
    SLATECORE_API bool HasKerning( const FFontData& InFontData ) const;
 
    SLATECORE_API bool CanLoadCodepoint(const FFontData& InFontData, const UTF32CHAR InCodepoint, EFontFallback MaxFallbackLevel = EFontFallback::FF_NoFallback) const;
 
    SLATECORE_API const TSet<FName>& GetFontAttributes( const FFontData& InFontData ) const;
 
    SLATECORE_API TArray<FString> GetAvailableFontSubFaces(FFontFaceDataConstRef InMemory) const;
    SLATECORE_API TArray<FString> GetAvailableFontSubFaces(const FString& InFilename) const;
 
    SLATECORE_API void RequestFlushCache(const FString& FlushReason);
 
    SLATECORE_API void FlushData();
 
    SLATECORE_API SIZE_T GetFontDataAssetResidentMemory(const UObject* FontDataAsset) const;
 
#if WITH_EDITOR && WITH_FREETYPE
    SLATECORE_API bool EnsurePreprocessedFontGeometry(FFontFaceDataRef FontFaceData);
#endif
 
private:
    // Non-copyable
    SLATECORE_API FSlateFontCache(const FSlateFontCache&);
    SLATECORE_API FSlateFontCache& operator=(const FSlateFontCache&);
 
    SLATECORE_API int32 GetAllFontTexturesIndex(const int32 InIndex) const;
 
    SLATECORE_API bool FlushCache();
 
    SLATECORE_API void FlushFontObjects();
 
    SLATECORE_API void HandleCultureChanged();
 
    SLATECORE_API bool AddNewEntry(const FShapedGlyphEntry& InShapedGlyph, const FFontOutlineSettings& InOutlineSettings, FShapedGlyphFontAtlasData& OutAtlasData);
 
    SLATECORE_API bool AddNewEntry(const FCharacterRenderData InRenderData, uint8& OutTextureIndex, uint16& OutGlyphX, uint16& OutGlyphY, uint16& OutGlyphWidth, uint16& OutGlyphHeight, uint8& OutPaddingOffset);
 
#if !UE_BUILD_SHIPPING
    SLATECORE_API void ConditionalDumpFontCacheStats() const;
#endif
 
private:
 
    TUniquePtr<FFreeTypeLibrary> FTLibrary;
 
    TUniquePtr<FFreeTypeCacheDirectory> FTCacheDirectory;
 
    TUniquePtr<FCompositeFontCache> CompositeFontCache;
 
    TUniquePtr<FSlateFontRenderer> FontRenderer;
 
    TUniquePtr<FSlateTextShaper> TextShaper;
 
    TUniquePtr<FSlateSdfGenerator> SdfGenerator;
 
    TMap<FSlateFontKey, TUniquePtr<FCharacterList>, FDefaultSetAllocator, FSlateFontKeyFuncs<TUniquePtr<FCharacterList>>> FontToCharacterListCache;
 
    TMap<FShapedGlyphEntryKey, TSharedRef<FShapedGlyphFontAtlasData>> ShapedGlyphToAtlasData;
 
    TMap<FSdfGlyphEntryKey, TSharedRef<FSdfGlyphFontAtlasData>> SdfGlyphToAtlasData;
 
    TMap<FSdfGlyphTaskKey, TSharedRef<FSdfGlyphFontAtlasData>> SdfTaskToAtlasData;
 
    TArray<uint8> GrayscaleFontAtlasIndices;
 
    TArray<uint8> ColorFontAtlasIndices;
 
    TArray<uint8> MsdfFontAtlasIndices;
 
    TArray<uint8> NonAtlasedTextureIndices;
 
    TArray<TSharedRef<ISlateFontTexture>> AllFontTextures;
 
    TSharedRef<ISlateFontAtlasFactory> FontAtlasFactory;
 
    volatile bool bFlushRequested;
 
    mutable FCriticalSection FontObjectsToFlushCS;
 
    TArray<const UObject*> FontObjectsToFlush;
 
    FOnReleaseFontResources OnReleaseResourcesDelegate;
 
    ESlateTextureAtlasThreadId OwningThread;
 
    FText EllipsisText;
 
};