FontCacheCompositeFont.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Async/AsyncWork.h"
#include "CoreMinimal.h"
#include "Fonts/CompositeFont.h"
 
class FFreeTypeFace;
class FFreeTypeLibrary;
struct FSlateFontInfo;
 
class FCachedTypefaceData
{
public:
    FCachedTypefaceData();
 
    FCachedTypefaceData(const FTypeface& InTypeface, const float InScalingFactor = 1.0f);
 
    FORCEINLINE const FTypeface& GetTypeface() const
    {
        check(Typeface);
        return *Typeface;
    }
 
    const FFontData* GetPrimaryFontData() const;
 
    const FFontData* GetFontData(const FName& InName) const;
 
    FORCEINLINE float GetScalingFactor() const
    {
        return ScalingFactor;
    }
 
    void GetCachedFontData(TArray<const FFontData*>& OutFontData) const;
 
private:
    struct FCachedFontData
    {
        FCachedFontData()
            : Name()
            , FontData(nullptr)
        {
        }
 
        FCachedFontData(const FName InName, const FFontData* InFontData)
            : Name(InName)
            , FontData(InFontData)
        {
        }
 
        static FName BinarySearchKey(const FCachedFontData& InCachedFontData)
        {
            return InCachedFontData.Name;
        }
 
        static bool KeySortPredicate(const FName& InOne, const FName& InTwo)
        {
            // CompareIndexes is much faster than Compare since we don't care about these being sorted alphabetically
            return InOne.CompareIndexes(InTwo) < 0;
        }
 
        static bool SortPredicate(const FCachedFontData& InOne, const FCachedFontData& InTwo)
        {
            return KeySortPredicate(InOne.Name, InTwo.Name);
        }
 
        FName Name;
 
        const FFontData* FontData;
    };
 
    const FTypeface* Typeface;
 
    TArray<FCachedFontData, TInlineAllocator<1>> CachedFontData;
 
    float ScalingFactor;
};
 
 
class FCachedCompositeFontData
{
public:
    FCachedCompositeFontData();
 
    FCachedCompositeFontData(const FCompositeFont& InCompositeFont);
 
    FORCEINLINE const FCompositeFont& GetCompositeFont() const
    {
        check(CompositeFont);
        return *CompositeFont;
    }
 
    FORCEINLINE const FCachedTypefaceData* GetDefaultTypeface() const
    {
        return CachedTypefaces[CachedTypeface_DefaultIndex].Get();
    }
 
    FORCEINLINE const FCachedTypefaceData* GetFallbackTypeface() const
    {
        return CachedTypefaces[CachedTypeface_FallbackIndex].Get();
    }
 
    const FCachedTypefaceData* GetTypefaceForCodepoint(const UTF32CHAR InCodepoint) const;
 
    void GetCachedFontData(TArray<const FFontData*>& OutFontData) const;
 
    void RefreshFontRanges();
 
private:
    struct FCachedFontRange
    {
        FCachedFontRange()
            : Range(FInt32Range::Empty())
            , CachedTypeface()
        {
        }
 
        FCachedFontRange(const FInt32Range& InRange, TSharedPtr<FCachedTypefaceData> InCachedTypeface)
            : Range(InRange)
            , CachedTypeface(MoveTemp(InCachedTypeface))
        {
        }
 
        static int32 BinarySearchKey(const FCachedFontRange& InCachedFontRange)
        {
            return InCachedFontRange.Range.GetLowerBoundValue();
        }
 
        static bool SortPredicate(const FCachedFontRange& InOne, const FCachedFontRange& InTwo)
        {
            check(!InOne.Range.IsEmpty() && !InTwo.Range.IsEmpty());
            return InOne.Range.GetLowerBoundValue() < InTwo.Range.GetLowerBoundValue();
        }
 
        FInt32Range Range;
 
        TSharedPtr<FCachedTypefaceData> CachedTypeface;
    };
 
    static const int32 CachedTypeface_DefaultIndex = 0;
    static const int32 CachedTypeface_FallbackIndex = 1;
    static const int32 CachedTypeface_FirstSubTypefaceIndex = 2;
 
    const FCompositeFont* CompositeFont;
 
    TArray<TSharedPtr<FCachedTypefaceData>, TInlineAllocator<2>> CachedTypefaces;
 
    TArray<FCachedFontRange> CachedPriorityFontRanges;
 
    TArray<FCachedFontRange> CachedFontRanges;
};
 
 
class FCompositeFontCache
{
public:
    FCompositeFontCache(const FFreeTypeLibrary* InFTLibrary);
 
    ~FCompositeFontCache();
 
    const FFontData& GetDefaultFontData(const FSlateFontInfo& InFontInfo);
 
    const FFontData& GetFontDataForCodepoint(const FSlateFontInfo& InFontInfo, const UTF32CHAR InCodepoint, float& OutScalingFactor);
 
    bool HasLoadedFontForCodepoint(const FSlateFontInfo& InFontInfo, const UTF32CHAR InCodepoint);
 
    TSharedPtr<FFreeTypeFace> GetFontFace(const FFontData& InFontData);
 
    const TSet<FName>& GetFontAttributes(const FFontData& InFontData);
 
    void FlushCompositeFont(const FCompositeFont& InCompositeFont);
 
    void FlushCache();
 
    void Update();
 
    SIZE_T GetFontDataAssetResidentMemory(const UObject* FontDataAsset) const;
 
private:
    const FCachedCompositeFontData* GetCachedCompositeFont(const FCompositeFont* const InCompositeFont);
 
    FORCEINLINE const FCachedTypefaceData* GetDefaultCachedTypeface(const FCompositeFont* const InCompositeFont)
    {
        const FCachedCompositeFontData* const CachedCompositeFont = GetCachedCompositeFont(InCompositeFont);
        return (CachedCompositeFont) ? CachedCompositeFont->GetDefaultTypeface() : nullptr;
    }
 
    FORCEINLINE const FCachedTypefaceData* GetFallbackCachedTypeface(const FCompositeFont* const InCompositeFont)
    {
        const FCachedCompositeFontData* const CachedCompositeFont = GetCachedCompositeFont(InCompositeFont);
        return (CachedCompositeFont) ? CachedCompositeFont->GetFallbackTypeface() : nullptr;
    }
 
    FORCEINLINE const FCachedTypefaceData* GetCachedTypefaceForCodepoint(const FCompositeFont* const InCompositeFont, const UTF32CHAR InCodepoint)
    {
        const FCachedCompositeFontData* const CachedCompositeFont = GetCachedCompositeFont(InCompositeFont);
        return (CachedCompositeFont) ? CachedCompositeFont->GetTypefaceForCodepoint(InCodepoint) : nullptr;
    }
 
    const FFontData* GetBestMatchFontForAttributes(const FCachedTypefaceData* const InCachedTypefaceData, const TSet<FName>& InFontAttributes);
 
    bool DoesFontDataSupportCodepoint(const FFontData& InFontData, const UTF32CHAR InCodepoint);
 
    void HandleCultureChanged();
 
    const FFreeTypeLibrary* FTLibrary;
 
    TMap<const FCompositeFont*, TSharedPtr<FCachedCompositeFontData>> CompositeFontToCachedDataMap;
 
    TMap<FFontData, TSharedPtr<FFreeTypeFace>> FontFaceMap;
 
    TArray<class FAsyncTask<class FAsyncLoadFontFaceData>*> LoadFontFaceTasks;
 
    friend class FAsyncLoadFontFaceData;
};