CompositeFont.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Fonts/FontRasterizationMode.h"
#include "UObject/ObjectMacros.h"
#include "UObject/GCObject.h"
#include "UObject/Class.h"
#include "CompositeFont.generated.h"
 
class UFontBulkData;
struct FFontFaceData;
 
namespace UE
{
namespace Slate
{
class FPreprocessedFontGeometry;
}
}
 
UENUM()
enum class EFontHinting : uint8
{
    Default,
    Auto,
    AutoLight,
    Monochrome,
    None,
};
 
UENUM()
enum class EFontLoadingPolicy : uint8
{
    LazyLoad,
    Stream,
    Inline,
};
 
UENUM()
enum class EFontLayoutMethod : uint8
{
    Metrics,
    BoundingBox,
};
 
typedef TSharedPtr<FFontFaceData, ESPMode::ThreadSafe> FFontFaceDataPtr;
typedef TSharedRef<FFontFaceData, ESPMode::ThreadSafe> FFontFaceDataRef;
typedef TSharedPtr<const FFontFaceData, ESPMode::ThreadSafe> FFontFaceDataConstPtr;
typedef TSharedRef<const FFontFaceData, ESPMode::ThreadSafe> FFontFaceDataConstRef;
 
struct FFontFaceData
{
public:
    SLATECORE_API FFontFaceData();
 
    SLATECORE_API FFontFaceData(TArray<uint8>&& InData);
 
    SLATECORE_API ~FFontFaceData();
 
    bool HasData() const
    {
        return Data.Num() > 0;
    }
 
    SLATECORE_API void SetData(TArray<uint8>&& InData);
    
    SLATECORE_API void SetPreprocessedFontGeometries(TArray<UE::Slate::FPreprocessedFontGeometry>&& InPreprocessedFontGeometries);
 
    const TArray<uint8>& GetData() const
    {
        return Data;
    }
 
    TArrayView<const UE::Slate::FPreprocessedFontGeometry> GetPreprocessedFontGeometries() const
    {
        return PreprocessedFontGeometries;
    }
 
    SLATECORE_API SIZE_T GetAllocatedSize() const;
 
    SLATECORE_API void Serialize(FArchive& Ar);
 
    static FFontFaceDataRef MakeFontFaceData()
    {
        return MakeShared<FFontFaceData, ESPMode::ThreadSafe>();
    }
 
    static FFontFaceDataRef MakeFontFaceData(TArray<uint8>&& InData)
    {
        return MakeShared<FFontFaceData, ESPMode::ThreadSafe>(MoveTemp(InData));
    }
 
private:
    SLATECORE_API void TrackMemoryUsage() const;
    SLATECORE_API void UntrackMemoryUsage() const;
 
    TArray<uint8> Data;
 
    TArray<UE::Slate::FPreprocessedFontGeometry> PreprocessedFontGeometries;
};
 
struct FFontRasterizationSettings
{
    EFontRasterizationMode Mode = EFontRasterizationMode::Bitmap;
    int32 DistanceFieldPpem = 0;
};
 
USTRUCT()
struct FFontData
{
    GENERATED_USTRUCT_BODY()
 
    
    SLATECORE_API FFontData();
 
    SLATECORE_API explicit FFontData(const UObject* const InFontFaceAsset, const int32 InSubFaceIndex = 0);
 
    SLATECORE_API FFontData(FString InFontFilename, const EFontHinting InHinting, const EFontLoadingPolicy InLoadingPolicy, const int32 InSubFaceIndex = 0);
 
    SLATECORE_API bool HasFont() const;
 
    SLATECORE_API const FString& GetFontFilename() const;
 
    SLATECORE_API EFontHinting GetHinting() const;
 
    SLATECORE_API EFontLoadingPolicy GetLoadingPolicy() const;
 
    SLATECORE_API int32 GetSubFaceIndex() const;
 
    SLATECORE_API void SetSubFaceIndex(const int32 InSubFaceIndex);
 
    SLATECORE_API EFontLayoutMethod GetLayoutMethod() const;
 
    SLATECORE_API bool IsAscendOverridden() const;
 
    SLATECORE_API int32 GetAscendOverriddenValue() const;
 
    SLATECORE_API bool IsDescendOverridden() const;
 
    SLATECORE_API int32 GetDescendOverriddenValue() const;
 
    SLATECORE_API int32 GetStrikeBrushHeightPercentage() const;
 
    SLATECORE_API FFontFaceDataConstPtr GetFontFaceData() const;
 
    SLATECORE_API const UObject* GetFontFaceAsset() const;
 
    SLATECORE_API FFontRasterizationSettings GetFontRasterizationSettings() const;
 
#if WITH_EDITORONLY_DATA
    SLATECORE_API bool HasLegacyData() const;
 
    SLATECORE_API void ConditionalUpgradeFontDataToBulkData(UObject* InOuter);
 
    SLATECORE_API void ConditionalUpgradeBulkDataToFontFace(UObject* InOuter, UClass* InFontFaceClass, const FName InFontFaceName);
#endif // WITH_EDITORONLY_DATA
 
    SLATECORE_API bool operator==(const FFontData& Other) const;
 
    SLATECORE_API bool operator!=(const FFontData& Other) const;
 
    friend inline uint32 GetTypeHash(const FFontData& Key)
    {
        uint32 KeyHash = 0;
 
        if (Key.FontFaceAsset)
        {
            KeyHash = HashCombine(KeyHash, GetTypeHash(Key.FontFaceAsset));
        }
        else
        {
            KeyHash = HashCombine(KeyHash, Key.FontFilenameHash);
            KeyHash = HashCombine(KeyHash, GetTypeHash(Key.Hinting));
            KeyHash = HashCombine(KeyHash, GetTypeHash(Key.LoadingPolicy));
        }
        KeyHash = HashCombine(KeyHash, GetTypeHash(Key.SubFaceIndex));
 
        return KeyHash;
    }
 
    SLATECORE_API bool Serialize(FArchive& Ar);
    friend FArchive& operator<<(FArchive& Ar, FFontData& InFontData)
    {
        InFontData.Serialize(Ar);
        return Ar;
    }
 
    SLATECORE_API void AddReferencedObjects(FReferenceCollector& Collector);
 
private:
    UPROPERTY()
    FString FontFilename;
 
    uint32  FontFilenameHash;
 
    UPROPERTY()
    EFontHinting Hinting;
 
    UPROPERTY()
    EFontLoadingPolicy LoadingPolicy;
 
    UPROPERTY()
    int32 SubFaceIndex;
 
    UPROPERTY()
    TObjectPtr<const UObject> FontFaceAsset;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TObjectPtr<UFontBulkData> BulkDataPtr_DEPRECATED;
 
    UPROPERTY()
    TArray<uint8> FontData_DEPRECATED;
#endif // WITH_EDITORONLY_DATA
};
 
template<>
struct TStructOpsTypeTraits<FFontData> : public TStructOpsTypeTraitsBase2<FFontData>
{
    enum
    {
        WithSerializer = true,
        WithIdenticalViaEquality = true,
    };
};
 
USTRUCT()
struct FTypefaceEntry
{
    GENERATED_USTRUCT_BODY()
 
    
    FTypefaceEntry()
    {
    }
 
    FTypefaceEntry(const FName& InFontName)
        : Name(InFontName)
    {
    }
 
    FTypefaceEntry(const FName& InFontName, FString InFontFilename, const EFontHinting InHinting, const EFontLoadingPolicy InLoadingPolicy)
        : Name(InFontName)
        , Font(MoveTemp(InFontFilename), InHinting, InLoadingPolicy)
    {
    }
 
    UPROPERTY()
    FName Name;
 
    UPROPERTY()
    FFontData Font;
};
 
USTRUCT()
struct FTypeface
{
    GENERATED_USTRUCT_BODY()
 
    
    FTypeface()
    {
    }
 
    FTypeface(const FName& InFontName, FString InFontFilename, const EFontHinting InHinting, const EFontLoadingPolicy InLoadingPolicy)
    {
        Fonts.Emplace(InFontName, MoveTemp(InFontFilename), InHinting, InLoadingPolicy);
    }
 
    FTypeface& AppendFont(const FName& InFontName, FString InFontFilename, const EFontHinting InHinting, const EFontLoadingPolicy InLoadingPolicy)
    {
        Fonts.Emplace(InFontName, MoveTemp(InFontFilename), InHinting, InLoadingPolicy);
        return *this;
    }
 
    UPROPERTY()
    TArray<FTypefaceEntry> Fonts;
};
 
USTRUCT()
struct FCompositeFallbackFont
{
    GENERATED_USTRUCT_BODY()
 
    
    FCompositeFallbackFont()
        : Typeface()
        , ScalingFactor(1.0f)
    {
    }
 
    UPROPERTY()
    FTypeface Typeface;
 
    UPROPERTY()
    float ScalingFactor;
};
 
USTRUCT()
struct FCompositeSubFont : public FCompositeFallbackFont
{
    GENERATED_USTRUCT_BODY()
 
    
    FCompositeSubFont()
    {
    }
 
    UPROPERTY()
    TArray<FInt32Range> CharacterRanges;
 
    UPROPERTY()
    FString Cultures;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FName EditorName;
#endif
};
 
USTRUCT()
struct FCompositeFont
{
    GENERATED_USTRUCT_BODY()
 
    
    FCompositeFont()
        : DefaultTypeface()
        , SubTypefaces()
#if WITH_EDITORONLY_DATA
        , HistoryRevision(0)
#endif  // WITH_EDITORONLY_DATA
    {
    }
 
    FCompositeFont(const FName& InFontName, FString InFontFilename, const EFontHinting InHinting, const EFontLoadingPolicy InLoadingPolicy)
        : DefaultTypeface(InFontName, MoveTemp(InFontFilename), InHinting, InLoadingPolicy)
        , SubTypefaces()
#if WITH_EDITORONLY_DATA
        , HistoryRevision(0)
#endif  // WITH_EDITORONLY_DATA
    {
    }
 
#if WITH_EDITORONLY_DATA
    void MakeDirty()
    {
        ++HistoryRevision;
    }
#endif  // WITH_EDITORONLY_DATA
 
    UPROPERTY()
    FTypeface DefaultTypeface;
 
    UPROPERTY()
    FCompositeFallbackFont FallbackTypeface;
 
    UPROPERTY()
    TArray<FCompositeSubFont> SubTypefaces;
 
    UPROPERTY(EditAnywhere, Category = RuntimeFont)
    bool bEnableAscentDescentOverride = true;
 
#if WITH_EDITORONLY_DATA
    int32 HistoryRevision;
#endif  // WITH_EDITORONLY_DATA
 
    bool IsAscentDescentOverrideEnabled() const
    {
        return bEnableAscentDescentOverride;
    }
};
 
struct FStandaloneCompositeFont : public FCompositeFont, public FGCObject
{
    FStandaloneCompositeFont()
    {
    }
 
    FStandaloneCompositeFont(const FName& InFontName, FString InFontFilename, const EFontHinting InHinting, const EFontLoadingPolicy InLoadingPolicy)
        : FCompositeFont(InFontName, MoveTemp(InFontFilename), InHinting, InLoadingPolicy)
    {
    }
 
    // FGCObject interface
    SLATECORE_API virtual void AddReferencedObjects(FReferenceCollector& Collector) override;
    SLATECORE_API virtual FString GetReferencerName() const override;
};