SlateFontInfo.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Class.h"
#include "Fonts/CompositeFont.h"
#include "HAL/IConsoleManager.h"
#include "SlateFontInfo.generated.h"
 
namespace FontConstants
{
    inline const uint32 RenderDPI = 96;
}
 
enum class EFontFallback : uint8
{
    FF_NoFallback,
    FF_LastResortFallback,
    FF_Max
};
 
USTRUCT(BlueprintType)
struct FFontOutlineSettings
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=OutlineSettings, meta=(ClampMin="0", ClampMax="1024"))
    int32 OutlineSize;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = OutlineSettings, meta = (DisplayName="Mitered Corners"))
    bool bMiteredCorners;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = OutlineSettings)
    bool bSeparateFillAlpha;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = OutlineSettings)
    bool bApplyOutlineToDropShadows;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=SlateStyleRules, meta=(AllowedClasses="/Script/Engine.MaterialInterface"))
    TObjectPtr<UObject> OutlineMaterial;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=OutlineSettings)
    FLinearColor OutlineColor;
 
    FFontOutlineSettings()
        : OutlineSize(0)
        , bMiteredCorners(false)
        , bSeparateFillAlpha(false)
        , bApplyOutlineToDropShadows(false)
        , OutlineMaterial(nullptr)
        , OutlineColor(FLinearColor::Black)
    {}
 
    FFontOutlineSettings(int32 InOutlineSize, FLinearColor InColor = FLinearColor::Black)
        : OutlineSize(InOutlineSize)
        , bMiteredCorners(false)
        , bSeparateFillAlpha(false)
        , bApplyOutlineToDropShadows(false)
        , OutlineMaterial(nullptr)
        , OutlineColor(InColor)
    {}
 
    inline bool IsIdenticalToForCaching(const FFontOutlineSettings& Other) const
    {
        // Ignore OutlineMaterial && OutlineColor because they do not affect the cached glyph.
        return OutlineSize == Other.OutlineSize
            &&  bMiteredCorners == Other.bMiteredCorners
            &&  bSeparateFillAlpha == Other.bSeparateFillAlpha;
    }
 
    inline bool IsIdenticalTo(const FFontOutlineSettings& Other) const
    {
        return
            OutlineSize == Other.OutlineSize &&
            bMiteredCorners == Other.bMiteredCorners &&
            bSeparateFillAlpha == Other.bSeparateFillAlpha &&
            bApplyOutlineToDropShadows == Other.bApplyOutlineToDropShadows &&
            OutlineMaterial == Other.OutlineMaterial &&
            OutlineColor == Other.OutlineColor;
    }
 
    friend inline uint32 GetTypeHash(const FFontOutlineSettings& OutlineSettings)
    {
        uint32 Hash = 0;
        // Ignore OutlineMaterial && OutlineColor because they do not affect the cached glyph.
        Hash = HashCombine(Hash, GetTypeHash(OutlineSettings.OutlineSize));
        Hash = HashCombine(Hash, GetTypeHash(OutlineSettings.bMiteredCorners));
        Hash = HashCombine(Hash, GetTypeHash(OutlineSettings.bSeparateFillAlpha));
        return Hash;
    }
 
    bool IsVisible() const
    {
        return OutlineSize > 0 && OutlineColor.A > 0;
    }
 
#if WITH_EDITORONLY_DATA
    bool Serialize(FArchive& Ar);
    void PostSerialize(const FArchive& Ar);
#endif
 
    static SLATECORE_API FFontOutlineSettings NoOutline;
};
 
#if WITH_EDITORONLY_DATA
template<>
struct TStructOpsTypeTraits<FFontOutlineSettings>
    : public TStructOpsTypeTraitsBase2<FFontOutlineSettings>
{
    enum
    {
        WithSerializer = true,
        WithPostSerialize = true,
    };
};
#endif
 
USTRUCT(BlueprintType, meta = (HasNativeMake = "/Script/SlateRHIRenderer.SlateFontBlueprintLibrary.MakeSlateFontInfo"))
struct FSlateFontInfo
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=SlateStyleRules, meta=(AllowedClasses="/Script/Engine.Font", DisplayName="Font Family"))
    TObjectPtr<const UObject> FontObject;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=SlateStyleRules, meta=(AllowedClasses="/Script/Engine.MaterialInterface"))
    TObjectPtr<UObject> FontMaterial;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=SlateStyleRules)
    FFontOutlineSettings OutlineSettings;
 
    TSharedPtr<const FCompositeFont> CompositeFont;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=SlateStyleRules, meta=(DisplayName="Typeface", EditCondition="FontObject"))
    FName TypefaceFontName;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=SlateStyleRules, meta=(ClampMin=1, ClampMax=1000))
    float Size;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=SlateStyleRules, meta=(ClampMin=-1000, ClampMax=10000))
    int32 LetterSpacing = 0;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=SlateStyleRules, meta=(ClampMin=-5, ClampMax=5))
    float SkewAmount = 0.0f;
 
    EFontFallback FontFallback;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=SlateStyleRules, meta=(DisplayName="Monospacing"))
    bool bForceMonospaced = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=SlateStyleRules)
    bool bMaterialIsStencil = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=SlateStyleRules, meta=(ClampMin=0, EditCondition = "bForceMonospaced==true", EditConditionHides))
    float MonospacedWidth = 1.0f;
 
#if WITH_EDITORONLY_DATA
private:
 
    UPROPERTY()
    FName FontName_DEPRECATED;
 
    UPROPERTY()
    EFontHinting Hinting_DEPRECATED;
#endif
 
public:
 
    SLATECORE_API FSlateFontInfo();
 
    ~FSlateFontInfo() {}
 
    SLATECORE_API FSlateFontInfo( TSharedPtr<const FCompositeFont> InCompositeFont, const float InSize, const FName& InTypefaceFontName = NAME_None, const FFontOutlineSettings& InOutlineSettings = FFontOutlineSettings());
 
    SLATECORE_API FSlateFontInfo( const UObject* InFontObject, const float InSize, const FName& InTypefaceFontName = NAME_None, const FFontOutlineSettings& InOutlineSettings = FFontOutlineSettings());
 
    UE_DEPRECATED(5.6, "Use constructor with FCompositeFont instead.")
    SLATECORE_API FSlateFontInfo( const FString& InFontName, float InSize, EFontHinting InHinting = EFontHinting::Default, const FFontOutlineSettings& InOutlineSettings = FFontOutlineSettings());
 
    UE_DEPRECATED(5.6, "Use constructor with FCompositeFont instead.")
    SLATECORE_API FSlateFontInfo( const FName& InFontName, float InSize, EFontHinting InHinting = EFontHinting::Default );
 
    UE_DEPRECATED(5.6, "Use constructor with FCompositeFont instead.")
    SLATECORE_API FSlateFontInfo( const ANSICHAR* InFontName, float InSize, EFontHinting InHinting = EFontHinting::Default );
 
    UE_DEPRECATED(5.6, "Use constructor with FCompositeFont instead.")
    SLATECORE_API FSlateFontInfo( const WIDECHAR* InFontName, float InSize, EFontHinting InHinting = EFontHinting::Default );
 
public:
    inline bool IsLegacyIdenticalTo(const FSlateFontInfo& Other) const
    {
        return FontObject == Other.FontObject
            && OutlineSettings.IsIdenticalToForCaching(Other.OutlineSettings)
            && CompositeFont == Other.CompositeFont
            && TypefaceFontName == Other.TypefaceFontName
            && GetClampSize() == Other.GetClampSize();
    }
 
    inline  bool IsIdenticalTo(const FSlateFontInfo& Other) const
    {
        return FontObject == Other.FontObject
            && FontMaterial == Other.FontMaterial
            && OutlineSettings.IsIdenticalTo(Other.OutlineSettings)
            && CompositeFont == Other.CompositeFont
            && TypefaceFontName == Other.TypefaceFontName
            && Size == Other.Size
            && LetterSpacing == Other.LetterSpacing
            && SkewAmount == Other.SkewAmount
            && bForceMonospaced == Other.bForceMonospaced
            && (bForceMonospaced ? MonospacedWidth == Other.MonospacedWidth : true);
    }
 
    inline bool operator==(const FSlateFontInfo& Other) const
    {
        return IsIdenticalTo(Other);
    }
 
    SLATECORE_API bool HasValidFont() const;
 
    SLATECORE_API const FCompositeFont* GetCompositeFont() const;
 
    SLATECORE_API float GetClampSize() const;
 
    SLATECORE_API float GetClampSkew() const;
 
    friend inline uint32 GetLegacyTypeHash(const FSlateFontInfo& FontInfo)
    {
        uint32 Hash = 0;
        Hash = HashCombine(Hash, GetTypeHash(FontInfo.FontObject));
        Hash = HashCombine(Hash, GetTypeHash(FontInfo.CompositeFont));
        Hash = HashCombine(Hash, GetTypeHash(FontInfo.TypefaceFontName));
        Hash = HashCombine(Hash, GetTypeHash(FontInfo.GetClampSize()));
        return Hash;
    }
 
    friend inline uint32 GetTypeHash( const FSlateFontInfo& FontInfo )
    {
        uint32 Hash = 0;
        Hash = HashCombine(Hash, GetTypeHash(FontInfo.FontObject));
        Hash = HashCombine(Hash, GetTypeHash(FontInfo.CompositeFont));
        Hash = HashCombine(Hash, GetTypeHash(FontInfo.FontMaterial));
        Hash = HashCombine(Hash, GetTypeHash(FontInfo.TypefaceFontName));
        Hash = HashCombine(Hash, GetTypeHash(FontInfo.GetClampSize()));
        Hash = HashCombine(Hash, GetTypeHash(FontInfo.LetterSpacing));
        Hash = HashCombine(Hash, GetTypeHash(FontInfo.GetClampSkew()));
        Hash = HashCombine(Hash, GetTypeHash(FontInfo.OutlineSettings));
        return Hash;
    }
 
#if WITH_EDITORONLY_DATA
    SLATECORE_API void PostSerialize(const FArchive& Ar);
#endif
 
    SLATECORE_API void AddReferencedObjects(FReferenceCollector& Collector);
 
private:
 
    void UpgradeLegacyFontInfo(FName LegacyFontName, EFontHinting LegacyHinting);
};
 
#if WITH_EDITORONLY_DATA
template<>
struct TStructOpsTypeTraits<FSlateFontInfo>
    : public TStructOpsTypeTraitsBase2<FSlateFontInfo>
{
    enum 
    {
        WithPostSerialize = true,
    };
};
#endif