FontTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "CoreMinimal.h"
#include "Delegates/Delegate.h"
#include "Fonts/SlateFontInfo.h"
#include "Math/UnrealMathSSE.h"
#include "Templates/SharedPointer.h"
#include "Templates/TypeHash.h"
#include "Textures/TextureAtlas.h"
 
class FSlateShaderResource;
 
 
DECLARE_MULTICAST_DELEGATE_OneParam(FOnReleaseFontResources, const class FSlateFontCache&);
 
 
struct FSlateFontKey
{
public:
    FSlateFontKey( const FSlateFontInfo& InInfo, const FFontOutlineSettings& InFontOutlineSettings, const float InScale )
        : FontInfo( InInfo )
        , OutlineSettings(InFontOutlineSettings)
        , Scale( InScale )
        , KeyHash( 0 )
    {
        KeyHash = HashCombine(KeyHash, GetLegacyTypeHash(FontInfo));
        KeyHash = HashCombine(KeyHash, GetTypeHash(OutlineSettings));
        KeyHash = HashCombine(KeyHash, GetTypeHash(Scale));
    }
 
    inline const FSlateFontInfo& GetFontInfo() const
    {
        return FontInfo;
    }
 
    inline float GetScale() const
    {
        return Scale;
    }
 
    inline const FFontOutlineSettings& GetFontOutlineSettings() const
    {
        return OutlineSettings;
    }
 
    inline bool IsIdenticalToForCaching(const FSlateFontKey& Other) const
    {
        return FontInfo.IsLegacyIdenticalTo(Other.FontInfo)
            && OutlineSettings.IsIdenticalToForCaching(Other.OutlineSettings)
            && Scale == Other.Scale;
    }
 
    friend inline uint32 GetTypeHash( const FSlateFontKey& Key )
    {
        return Key.KeyHash;
    }
 
private:
    FSlateFontInfo FontInfo;
    FFontOutlineSettings OutlineSettings;
    float Scale;
    uint32 KeyHash;
};
 
 
template<typename ValueType>
struct FSlateFontKeyFuncs : BaseKeyFuncs<TPair<FSlateFontKey, ValueType>, FSlateFontKey, false>
{
    typedef BaseKeyFuncs <
        TPair<FSlateFontKey, ValueType>,
        FSlateFontKey
    > Super;
    typedef typename Super::ElementInitType ElementInitType;
    typedef typename Super::KeyInitType     KeyInitType;
 
    inline static const FSlateFontKey& GetSetKey(ElementInitType Element)
    {
        return Element.Key;
    }
 
    inline static bool Matches(const FSlateFontKey& A, const FSlateFontKey& B)
    {
        return A.IsIdenticalToForCaching(B);
    }
 
    inline static uint32 GetKeyHash(const FSlateFontKey& Identifier)
    {
        return GetTypeHash(Identifier);
    }
};
 
 
struct FCharacterRenderData
{
    TArray<uint8> RawPixels;
    int16 SizeX = 0;
    int16 SizeY = 0;
    int16 VerticalOffset = 0;
    int16 HorizontalOffset = 0;
    ESlateFontAtlasContentType ContentType = ESlateFontAtlasContentType::Alpha;
    bool bSupportsOutline = false;
};
 
struct FDeferredCharacterRenderData
{
    int16 USize = 0;
    int16 VSize = 0;
    int16 StartU = 0;
    int16 StartV = 0;
    TArray<uint8> RawPixels;
};
 
class ISlateFontTexture
{
public:
    virtual ~ISlateFontTexture() {}
 
    virtual class FSlateShaderResource* GetSlateTexture() const = 0;
 
    virtual class FTextureResource* GetEngineTexture() = 0;
 
    virtual ESlateFontAtlasContentType GetContentType() const = 0;
 
    virtual void ReleaseRenderingResources() = 0;
 
    virtual void GetAtlasDataCopy(TArray<uint8>& OutData) const = 0;
};
 
class FSlateFontAtlas : public ISlateFontTexture, public FSlateTextureAtlas
{
public:
    SLATECORE_API FSlateFontAtlas(uint32 InWidth, uint32 InHeight, ESlateFontAtlasContentType InContentType, ESlateTextureAtlasPaddingStyle InPaddingStyle);
    SLATECORE_API virtual ~FSlateFontAtlas();
 
    //~ Begin ISlateFontTexture interface 
    SLATECORE_API virtual ESlateFontAtlasContentType GetContentType() const override final;
    virtual FSlateShaderResource* GetAtlasTexture() const override { return GetSlateTexture(); }
    virtual void ReleaseRenderingResources() { ReleaseResources(); }
    SLATECORE_API virtual void GetAtlasDataCopy(TArray<uint8>& OutData) const override;
    //~ End ISlateFontTexture interface
 
    SLATECORE_API void Flush();
 
    SLATECORE_API const struct FAtlasedTextureSlot* AddCharacter( const FCharacterRenderData& CharInfo );
 
    bool BeginDeferredAddCharacter( const int16 InSizeX, const int16 InSizeY, FDeferredCharacterRenderData& OutCharInfo);
    
    void EndDeferredAddCharacter( const FDeferredCharacterRenderData& CharInfo );
 
protected:
    ESlateFontAtlasContentType ContentType;
};
 
class ISlateFontAtlasFactory
{
public:
    virtual ~ISlateFontAtlasFactory() {}
    virtual FIntPoint GetAtlasSize(ESlateFontAtlasContentType InContentType) const = 0;
    virtual TSharedRef<FSlateFontAtlas> CreateFontAtlas(ESlateFontAtlasContentType InContentType) const = 0;
    virtual TSharedPtr<ISlateFontTexture> CreateNonAtlasedTexture(const uint32 InWidth, const uint32 InHeight, ESlateFontAtlasContentType InContentType, const TArray<uint8>& InRawData) const = 0;
};