FontCacheFreeType.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Fonts/FontCache.h"
#include "Templates/IsIntegral.h"
#include "Templates/IsFloatingPoint.h"
#include "Misc/Optional.h"
 
#ifndef WITH_FREETYPE
    #define WITH_FREETYPE   0
#endif // WITH_FREETYPE
 
 
#ifndef WITH_FREETYPE_V210
    #define WITH_FREETYPE_V210  0
#endif // WITH_FREETYPE_V210
 
 
#if PLATFORM_COMPILER_HAS_GENERIC_KEYWORD
    #define generic __identifier(generic)
#endif  //PLATFORM_COMPILER_HAS_GENERIC_KEYWORD
 
 
#if WITH_FREETYPE
    THIRD_PARTY_INCLUDES_START
    #include "ft2build.h"
 
    // FreeType style include
    #include FT_FREETYPE_H
#if WITH_FREETYPE_V210
    #include FT_DRIVER_H
#endif  // WITH_FREETYPE_V210
    #include FT_GLYPH_H
    #include FT_MODULE_H
    #include FT_BITMAP_H
    #include FT_ADVANCES_H
    #include FT_STROKER_H
    #include FT_SIZES_H
    THIRD_PARTY_INCLUDES_END
#endif // WITH_FREETYPE
 
 
#if PLATFORM_COMPILER_HAS_GENERIC_KEYWORD
    #undef generic
#endif  //PLATFORM_COMPILER_HAS_GENERIC_KEYWORD
 
namespace FreeTypeUtils
{
 
#if WITH_FREETYPE
 
bool IsFaceEligibleForSdf(FT_Face InFace);
 
bool IsGlyphEligibleForSdf(FT_GlyphSlot InGlyph);
 
FT_F26Dot6 Floor26Dot6(const FT_F26Dot6 InValue);
 
FT_F26Dot6 Ceil26Dot6(const FT_F26Dot6 InValue);
 
FT_F26Dot6 Round26Dot6(const FT_F26Dot6 InValue);
 
FT_Fixed DetermineEmScale(const uint16 InEmSize, const FT_F26Dot6 InPpem);
 
FT_Fixed DeterminePpemAndEmScale(const uint16 InEmSize, const float InFontSize, const float InFontScale);
 
 
uint32 ComputeFontPixelSize(float InFontSize, float InFontScale);
 
void ApplySizeAndScale(FT_Face InFace, const float InFontSize, const float InFontScale);
 
void ApplySizeAndScale(FT_Face InFace, const uint32 RequiredFontPixelSize);
 
FT_Error LoadGlyph(FT_Face InFace, const uint32 InGlyphIndex, const int32 InLoadFlags, const float InFontSize, const float InFontScale);
FT_Error LoadGlyph(FT_Face InFace, const uint32 InGlyphIndex, const int32 InLoadFlags, const uint32 RequiredFontPixelSize);
 
FT_Pos GetHeight(FT_Face InFace, const EFontLayoutMethod InLayoutMethod);
 
FT_Pos GetScaledHeight(FT_Face InFace, const EFontLayoutMethod InLayoutMethod);
 
FT_Pos GetAscender(FT_Face InFace, const EFontLayoutMethod InLayoutMethod);
 
FT_Pos GetDescender(FT_Face InFace, const EFontLayoutMethod InLayoutMethod);
 
float GetBitmapAtlasScale(FT_Face InFace);
 
float GetBitmapRenderScale(FT_Face InFace);
 
#endif // WITH_FREETYPE
 
template <typename TRetType, typename TParamType>
FORCEINLINE typename TEnableIf<TIsIntegral<TParamType>::Value, TRetType>::Type Convert26Dot6ToRoundedPixel(TParamType InValue)
{
    return static_cast<TRetType>((InValue + (1<<5)) >> 6);
}
 
template <typename TRetType, typename TParamType>
FORCEINLINE typename TEnableIf<TIsFloatingPoint<TParamType>::Value, TRetType>::Type Convert26Dot6ToRoundedPixel(TParamType InValue)
{
    return static_cast<TRetType>(FMath::RoundToInt(InValue / 64.0f));
}
 
template <typename TRetType, typename TParamType>
FORCEINLINE typename TEnableIf<TIsIntegral<TParamType>::Value, TRetType>::Type ConvertPixelTo26Dot6(TParamType InValue)
{
    return static_cast<TRetType>(InValue << 6);
}
 
template <typename TRetType, typename TParamType>
FORCEINLINE typename TEnableIf<TIsFloatingPoint<TParamType>::Value, TRetType>::Type ConvertPixelTo26Dot6(TParamType InValue)
{
    return static_cast<TRetType>(InValue * 64);
}
 
template <typename TRetType, typename TParamType>
FORCEINLINE typename TEnableIf<TIsIntegral<TParamType>::Value, TRetType>::Type ConvertPixelTo16Dot16(TParamType InValue)
{
    return static_cast<TRetType>(InValue << 16);
}
 
template <typename TRetType, typename TParamType>
FORCEINLINE typename TEnableIf<TIsFloatingPoint<TParamType>::Value, TRetType>::Type ConvertPixelTo16Dot16(TParamType InValue)
{
    return static_cast<TRetType>(InValue * 65536);
}
 
}
 
 
class FFreeTypeLibrary
{
public:
    FFreeTypeLibrary();
    ~FFreeTypeLibrary();
 
#if WITH_FREETYPE
    FORCEINLINE FT_Library GetLibrary() const
    {
        return FTLibrary;
    }
#endif // WITH_FREETYPE
 
private:
    // Non-copyable
    FFreeTypeLibrary(const FFreeTypeLibrary&);
    FFreeTypeLibrary& operator=(const FFreeTypeLibrary&);
 
#if WITH_FREETYPE
    FT_Library FTLibrary;
    FT_Memory CustomMemory;
#endif // WITH_FREETYPE
};
 
 
class FFreeTypeFace
{
public:
    FFreeTypeFace(const FFreeTypeLibrary* InFTLibrary, FFontFaceDataConstRef InMemory, const int32 InFaceIndex, const EFontLayoutMethod InLayoutMethod);
    FFreeTypeFace(const FFreeTypeLibrary* InFTLibrary, const FString& InFilename, const int32 InFaceIndex, const EFontLayoutMethod InLayoutMethod);
    FFreeTypeFace(const EFontLayoutMethod InLayoutMethod);
    ~FFreeTypeFace();
 
    FORCEINLINE bool IsFaceValid() const
    {
#if WITH_FREETYPE
        return FTFace != nullptr;
#else
        return false;
#endif // WITH_FREETYPE
    }
 
    FORCEINLINE bool IsFaceLoading() const
    {
#if WITH_FREETYPE
        return bPendingAsyncLoad;
#else
        return false;
#endif // WITH_FREETYPE
    }
 
    FORCEINLINE bool SupportsSdf() const
    {
#if WITH_FREETYPE
        return FreeTypeUtils::IsFaceEligibleForSdf(FTFace);
#else
        return false;
#endif // WITH_FREETYPE
    }
 
#if WITH_FREETYPE
    FORCEINLINE FT_Face GetFace() const
    {
#if WITH_ATLAS_DEBUGGING
        check(OwnerThread == GetCurrentSlateTextureAtlasThreadId());
#endif
        return FTFace;
    }
 
    FORCEINLINE FT_Pos GetHeight() const
    {
        return FreeTypeUtils::GetHeight(FTFace, LayoutMethod);
    }
 
    FORCEINLINE FT_Pos GetScaledHeight(bool bAllowOverride) const
    {
        if (bAllowOverride && (IsAscentOverridden || IsDescentOverridden))
            return GetAscender(true) - GetDescender(true);
        return FreeTypeUtils::GetScaledHeight(FTFace, LayoutMethod);
    }
 
    FORCEINLINE FT_Pos GetAscender(bool bAllowOverride) const
    {
        if (bAllowOverride && IsAscentOverridden)
        {
            FT_F26Dot6 ScaledAscender = FT_MulFix(AscentOverrideValue, FTFace->size->metrics.y_scale);
            return (ScaledAscender + 0b111111) & ~0b111111; //(26.6 fixed point ceil). Using ceiling of scaled ascend, as recommended by Freetype, to avoid grid fitting/hinting issues.
        }
        return FreeTypeUtils::GetAscender(FTFace, LayoutMethod);
    }
 
    FORCEINLINE FT_Pos GetDescender(bool bAllowOverride) const
    {
        if (bAllowOverride && IsDescentOverridden)
        {
            FT_F26Dot6 ScaledDescender =  FT_MulFix(DescentOverrideValue, FTFace->size->metrics.y_scale);
            return ScaledDescender & ~0b111111; //(26.6 fixed point floor). Using floor of scaled descend, as recommended by Freetype, to avoid grid fitting/hinting issues.
        }
        return FreeTypeUtils::GetDescender(FTFace, LayoutMethod);
    }
 
    FORCEINLINE float GetBitmapAtlasScale() const
    {
        return FreeTypeUtils::GetBitmapAtlasScale(FTFace);
    }
 
    FORCEINLINE float GetBitmapRenderScale() const
    {
        return FreeTypeUtils::GetBitmapRenderScale(FTFace);
    }
#endif // WITH_FREETYPE
 
    FORCEINLINE const TSet<FName>& GetAttributes() const
    {
        return Attributes;
    }
 
    FORCEINLINE EFontLayoutMethod GetLayoutMethod() const
    {
        return LayoutMethod;
    }
 
    SIZE_T GetAllocatedMemorySize() const;
 
    const UE::Slate::FPreprocessedFontGeometry* GetPreprocessedFontGeometry() const;
 
    void OverrideAscent(bool InOverride, int32 Value = 0)
    {
#if WITH_FREETYPE
        IsAscentOverridden = InOverride;
        AscentOverrideValue = FreeTypeUtils::ConvertPixelTo26Dot6<FT_F26Dot6>(Value);
#endif //WITH_FREETYPE
    }
 
    void OverrideDescent(bool InOverride, int32 Value = 0)
    {
#if WITH_FREETYPE
        IsDescentOverridden = InOverride;
        DescentOverrideValue = FreeTypeUtils::ConvertPixelTo26Dot6<FT_F26Dot6>(Value);
#endif //WITH_FREETYPE
    }
 
    void FailAsyncLoad();
    void CompleteAsyncLoad(const FFreeTypeLibrary* InFTLibrary, FFontFaceDataConstRef InMemory, const int32 InFaceIndex);
 
    static TArray<FString> GetAvailableSubFaces(const FFreeTypeLibrary* InFTLibrary, FFontFaceDataConstRef InMemory);
    static TArray<FString> GetAvailableSubFaces(const FFreeTypeLibrary* InFTLibrary, const FString& InFilename);
 
private:
 
#if WITH_FREETYPE
    void ParseAttributes();
#endif // WITH_FREETYPE
 
    // Non-copyable
    FFreeTypeFace(const FFreeTypeFace&);
    FFreeTypeFace& operator=(const FFreeTypeFace&);
 
#if WITH_FREETYPE
    FT_Face FTFace;
    FFontFaceDataConstPtr Memory;
 
    bool bPendingAsyncLoad = false;
 
    struct FFTStreamHandler
    {
        FFTStreamHandler();
        FFTStreamHandler(const FString& InFilename);
        ~FFTStreamHandler();
        static void CloseFile(FT_Stream InStream);
        static unsigned long ReadData(FT_Stream InStream, unsigned long InOffset, unsigned char* InBuffer, unsigned long InCount);
 
        IFileHandle* FileHandle;
        int64 FontSizeBytes;
    };
 
    FFTStreamHandler FTStreamHandler;
    FT_StreamRec FTStream;
    FT_Open_Args FTFaceOpenArgs;
 
    bool IsAscentOverridden = false;
    bool IsDescentOverridden = false;
    FT_F26Dot6 AscentOverrideValue = 0;
    FT_F26Dot6 DescentOverrideValue = 0;
 
#if WITH_ATLAS_DEBUGGING
    ESlateTextureAtlasThreadId OwnerThread;
#endif
#endif // WITH_FREETYPE
 
    TSet<FName> Attributes;
 
    EFontLayoutMethod LayoutMethod;
};
 
 
class FFreeTypeGlyphCache
{
public:
#if WITH_FREETYPE
    FFreeTypeGlyphCache(FT_Face InFace, const int32 InLoadFlags, const uint32 InFontRenderSize);
 
    struct FCachedGlyphData
    {
        FT_Short Height;
        FT_Glyph_Metrics GlyphMetrics;
        FT_Size_Metrics SizeMetrics; 
        TArray<FT_Vector> OutlinePoints;
    };
 
    bool FindOrCache(const uint32 InGlyphIndex, FCachedGlyphData& OutCachedGlyphData);
#endif // WITH_FREETYPE
 
private:
#if WITH_FREETYPE
    FT_Face Face;
    const int32 LoadFlags;
    const uint32 FontRenderSize;
    TMap<uint32, FCachedGlyphData> GlyphDataMap;
#endif // WITH_FREETYPE
};
 
 
class FFreeTypeAdvanceCache
{
public:
#if WITH_FREETYPE
    FFreeTypeAdvanceCache();
    FFreeTypeAdvanceCache(FT_Face InFace, const int32 InLoadFlags, const uint32 InFontRenderSize);
 
    bool FindOrCache(const uint32 InGlyphIndex, FT_Fixed& OutCachedAdvance);
#endif // WITH_FREETYPE
 
    void FlushCache();
 
private:
#if WITH_FREETYPE
    FT_Face Face;
    const int32 LoadFlags;
    const uint32 FontRenderSize;
    TMap<uint32, FT_Fixed> AdvanceMap;
#endif // WITH_FREETYPE
};
 
 
class FFreeTypeKerningCache
{
public:
#if WITH_FREETYPE
    FFreeTypeKerningCache(FT_Face InFace, const int32 InKerningFlags, const uint32 InFontRenderSize);
 
    bool FindOrCache(const uint32 InFirstGlyphIndex, const uint32 InSecondGlyphIndex, FT_Vector& OutKerning);
#endif // WITH_FREETYPE
 
private:
#if WITH_FREETYPE
    struct FKerningPair
    {
        FKerningPair(const uint32 InFirstGlyphIndex, const uint32 InSecondGlyphIndex)
            : FirstGlyphIndex(InFirstGlyphIndex)
            , SecondGlyphIndex(InSecondGlyphIndex)
        {
        }
 
        FORCEINLINE bool operator==(const FKerningPair& Other) const
        {
            return FirstGlyphIndex == Other.FirstGlyphIndex 
                && SecondGlyphIndex == Other.SecondGlyphIndex;
        }
 
        FORCEINLINE bool operator!=(const FKerningPair& Other) const
        {
            return !(*this == Other);
        }
 
        friend inline uint32 GetTypeHash(const FKerningPair& Key)
        {
            uint32 KeyHash = 0;
            KeyHash = HashCombine(KeyHash, Key.FirstGlyphIndex);
            KeyHash = HashCombine(KeyHash, Key.SecondGlyphIndex);
            return KeyHash;
        }
 
        uint32 FirstGlyphIndex;
        uint32 SecondGlyphIndex;
    };
 
    FT_Face Face;
    const int32 KerningFlags;
    const uint32 FontRenderSize;
    TMap<FKerningPair, FT_Vector> KerningMap;
#endif // WITH_FREETYPE
};
 
 
class FFreeTypeCacheDirectory
{
public:
    FFreeTypeCacheDirectory();
#if WITH_FREETYPE
    TSharedRef<FFreeTypeGlyphCache> GetGlyphCache(FT_Face InFace, const int32 InLoadFlags, const uint32 InFontRenderSize);
 
    TSharedRef<FFreeTypeAdvanceCache> GetAdvanceCache(FT_Face InFace, const int32 InLoadFlags, const uint32 InFontRenderSize);
 
    TSharedPtr<FFreeTypeKerningCache> GetKerningCache(FT_Face InFace, const int32 InKerningFlags, const uint32 InFontRenderSize);
#endif // WITH_FREETYPE
 
    void FlushCache();
 
private:
#if WITH_FREETYPE
    /* Shared font key to look up internal caches; flag meaning changes but the internal type is the same. */
    class FFontKey
    {
    public:
        FFontKey(FT_Face InFace, const int32 InFlags, const uint32 InFontRenderSize)
            : Face(InFace)
            , Flags(InFlags)
            , FontRenderSize(InFontRenderSize)
            , KeyHash(0)
        {
            KeyHash = GetTypeHash(Face);
            KeyHash = HashCombine(KeyHash, GetTypeHash(Flags));
            KeyHash = HashCombine(KeyHash, GetTypeHash(FontRenderSize));
        }
 
        FORCEINLINE bool operator==(const FFontKey& Other) const
        {
            return Face == Other.Face
                && Flags == Other.Flags
                && FontRenderSize == Other.FontRenderSize;
        }
 
        FORCEINLINE bool operator!=(const FFontKey& Other) const
        {
            return !(*this == Other);
        }
 
        friend inline uint32 GetTypeHash(const FFontKey& Key)
        {
            return Key.KeyHash;
        }
 
    private:
        FT_Face Face;
        const int32 Flags;
        const uint32 FontRenderSize;
        uint32 KeyHash;
    };
 
    TMap<FFontKey, TSharedPtr<FFreeTypeGlyphCache>> GlyphCacheMap;
    TMap<FFontKey, TSharedPtr<FFreeTypeAdvanceCache>> AdvanceCacheMap;
    TMap<FFontKey, TSharedPtr<FFreeTypeKerningCache>> KerningCacheMap;
    TSharedPtr<FFreeTypeAdvanceCache> InvalidAdvanceCache;
#endif // WITH_FREETYPE
};