Canvas.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/Object.h"
#include "Engine/EngineTypes.h"
#include "CanvasItem.h"
#include "CanvasTypes.h"
#include "Canvas.generated.h"
 
class UMaterialInterface;
class UReporterGraph;
class UTexture;
class FSceneView;
 
USTRUCT(BlueprintType)
struct FCanvasIcon
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=CanvasIcon)
    TObjectPtr<class UTexture> Texture;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=CanvasIcon)
    float U;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=CanvasIcon)
    float V;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=CanvasIcon)
    float UL;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=CanvasIcon)
    float VL;
 
    FCanvasIcon()
        : Texture(nullptr)
        , U(0)
        , V(0)
        , UL(0)
        , VL(0)
    { }
 
};
 
struct FDisplayDebugManager
{
private:
    FCanvasTextItem DebugTextItem;
    FVector2f CurrentPos;
    float NextColumXPos;
    float MaxCharHeight;
    FVector2f InitialPos;
    class UCanvas* Canvas;
    int32 ColumnCount;
public:
    FDisplayDebugManager()
        : DebugTextItem(FCanvasTextItem(FVector2D(0, 0), FText::GetEmpty(), nullptr, FLinearColor::White))
        , CurrentPos(FVector2f::ZeroVector)
        , NextColumXPos(0.f)
        , MaxCharHeight(0.f)
        , InitialPos(FVector2f::ZeroVector)
        , Canvas(nullptr)
        , ColumnCount(0)
    {
        DebugTextItem.EnableShadow(FLinearColor::Black);
    }
 
    void Initialize(class UCanvas* InCanvas, const UFont* NewFont, FVector2D InInitialPosition)
    {
        SetFont(NewFont);
        Canvas = InCanvas;
        InitialPos = (FVector2f)InInitialPosition;
        CurrentPos = InitialPos;
        NextColumXPos = 0.f;
        ColumnCount = 0;
    }
 
    void SetFont(const UFont* NewFont)
    {
        if (NewFont && (NewFont != DebugTextItem.Font))
        {
            DebugTextItem.Font = NewFont;
            MaxCharHeight = DebugTextItem.Font->GetMaxCharHeight();
        }
    }
 
    void SetDrawColor(const FColor& NewColor)
    {
        DebugTextItem.SetColor(NewColor.ReinterpretAsLinear());
    }
 
    void SetLinearDrawColor(const FLinearColor& NewColor)
    {
        DebugTextItem.SetColor(NewColor);
    }
 
    void ENGINE_API DrawString(const FString& InDebugString, const float& OptionalXOffset = 0.f);
 
    void AddColumnIfNeeded();
 
    float GetTextScale() const;
 
    float GetYStep() const
    {
        return MaxCharHeight * 1.15f * GetTextScale();
    }
 
    float GetXPos() const
    {
        return CurrentPos.X;
    }
 
    float GetYPos() const
    {
        return CurrentPos.Y;
    }
 
    float& GetYPosRef()
    {
        return CurrentPos.Y;
    }
 
    void SetYPos(const float NewYPos)
    {
        CurrentPos.Y = NewYPos;
    }
 
    float GetMaxCharHeight() const
    {
        return MaxCharHeight;
    }
 
    float& GetMaxCharHeightRef()
    {
        return MaxCharHeight;
    }
 
    void ShiftYDrawPosition(const float& YOffset)
    {
        CurrentPos.Y += YOffset;
        AddColumnIfNeeded();
    }
};
 
UCLASS(transient, BlueprintType, MinimalAPI)
class UCanvas
    : public UObject
{
    GENERATED_UCLASS_BODY()
 
    // Modifiable properties.
    UPROPERTY()
    float OrgX;     // Origin for drawing in X.
 
    UPROPERTY()
    float OrgY;    // Origin for drawing in Y.
 
    UPROPERTY()
    float ClipX;    // Bottom right clipping region.
 
    UPROPERTY()
    float ClipY;    // Bottom right clipping region.
        
    UPROPERTY()
    FColor DrawColor;    // Color for drawing.
 
    UPROPERTY()
    uint32 bCenterX:1;    // Whether to center the text horizontally (about CurX)
 
    UPROPERTY()
    uint32 bCenterY:1;    // Whether to center the text vertically (about CurY)
 
    UPROPERTY()
    uint32 bNoSmooth:1;    // Don't bilinear filter.
 
    UPROPERTY()
    int32 SizeX;        // Zero-based actual dimensions X.
 
    UPROPERTY()
    int32 SizeY;        // Zero-based actual dimensions Y.
 
    // Internal.
    UPROPERTY()
    FPlane ColorModulate; 
 
    UPROPERTY()
    TObjectPtr<class UTexture2D> DefaultTexture; //Default texture to use 
 
    UPROPERTY()
    TObjectPtr<class UTexture2D> GradientTexture0; //Default texture to use 
 
    UPROPERTY()
    TObjectPtr<class UReporterGraph> ReporterGraph;
 
    int32 UnsafeSizeX;   // Canvas size before safe frame adjustment
    int32 UnsafeSizeY;  // Canvas size before safe frame adjustment
 
    //cached data for safe zone calculation.  Some platforms have very expensive functions
    //to grab display metrics
    int32 SafeZonePadX;
    int32 SafeZonePadY;
    int32 SafeZonePadEX;
    int32 SafeZonePadEY;
    int32 CachedDisplayWidth;
    int32 CachedDisplayHeight;
 
    FDisplayDebugManager DisplayDebugManager;
public:
    FCanvas* Canvas;
    FSceneView* SceneView;
    FMatrix ViewProjectionMatrix;
    FQuat HmdOrientation;
 
    // UCanvas interface.
    
    ENGINE_API void Init(int32 InSizeX, int32 InSizeY, FSceneView* InSceneView, FCanvas* InCanvas);
 
    ENGINE_API virtual void BeginDestroy() override;
 
    ENGINE_API void SetView(FSceneView* InView);
 
    ENGINE_API void Update();
 
    /* Applies the current Platform's safe zone to the current Canvas position. Automatically called by Update. */
    ENGINE_API void ApplySafeZoneTransform();
    ENGINE_API void PopSafeZoneTransform();
 
    /* Updates cached SafeZone data from the device.  Call when main device is resized. */
    ENGINE_API void UpdateSafeZoneData();
 
    /* Function to go through all constructed canvas items and update their safe zone data. */
    static ENGINE_API void UpdateAllCanvasSafeZoneData();
 
    ENGINE_API void DrawTile(UTexture* Tex, float X, float Y, float XL, float YL, float U, float V, float UL, float VL, EBlendMode BlendMode=BLEND_Translucent);
 
    static ENGINE_API void ClippedStrLen(const UFont* Font, float ScaleX, float ScaleY, int32& XL, int32& YL, FStringView Text);
 
    ENGINE_API void VARARGS WrappedStrLenf(const UFont* Font, float ScaleX, float ScaleY, int32& XL, int32& YL, const TCHAR* Fmt, ...);
        
    ENGINE_API int32 WrappedPrint(bool Draw, float X, float Y, int32& out_XL, int32& out_YL, const UFont* Font, float ScaleX, float ScaleY, bool bCenterTextX, bool bCenterTextY, FStringView Text, const FFontRenderInfo& RenderInfo) ;
    
    ENGINE_API float DrawText(const UFont* InFont, FStringView InText, float X, float Y, float XScale = 1.f, float YScale = 1.f, const FFontRenderInfo& RenderInfo = FFontRenderInfo());
    ENGINE_API float DrawText(const UFont* InFont, const FText& InText, float X, float Y, float XScale = 1.f, float YScale = 1.f, const FFontRenderInfo& RenderInfo = FFontRenderInfo());
 
#if !PLATFORM_TCHAR_IS_UTF8CHAR
 
    UE_DEPRECATED(5.5, "Passing an ANSI string to DrawText has been deprecated outside of UTF-8 mode. Please use the overload that takes a TCHAR string.")
    ENGINE_API float DrawText(const UFont* InFont, FAnsiStringView InText, float X, float Y, float XScale = 1.f, float YScale = 1.f, const FFontRenderInfo& RenderInfo = FFontRenderInfo());
 
#endif // !PLATFORM_TCHAR_IS_UTF8CHAR
 
    enum ELastCharacterIndexFormat
    {
        // The last whole character before the horizontal offset
        LastWholeCharacterBeforeOffset,
        // The character directly at the offset
        CharacterAtOffset,
        // Not used
        Unused,
    };
 
    static ENGINE_API void MeasureStringInternal(FTextSizingParameters& Parameters, FStringView Text, const int32 StopAfterHorizontalOffset, const ELastCharacterIndexFormat CharIndexFormat, int32& OutLastCharacterIndex);
 
    UE_DEPRECATED(5.4, "Use MeasureStringInternal with FStringView instead.")
    static ENGINE_API void MeasureStringInternal(FTextSizingParameters& Parameters, const TCHAR* const Text, const int32 TextLength, const int32 StopAfterHorizontalOffset, const ELastCharacterIndexFormat CharIndexFormat, int32& OutLastCharacterIndex);
 
    static ENGINE_API void CanvasStringSize(FTextSizingParameters& Parameters, FStringView Text);
 
    static ENGINE_API void WrapString(FCanvasWordWrapper& Wrapper, FTextSizingParameters& Parameters, const float InCurX, FStringView Text, TArray<FWrappedStringElement>& out_Lines, FCanvasWordWrapper::FWrappedLineData* const OutWrappedLineData = nullptr);
 
    ENGINE_API void WrapString(FTextSizingParameters& Parameters, const float InCurX, FStringView Text, TArray<FWrappedStringElement>& out_Lines, FCanvasWordWrapper::FWrappedLineData* const OutWrappedLineData = nullptr);
 
    ENGINE_API FVector Project(FVector Location, bool bClampToZeroPlane = true) const;
 
    ENGINE_API void Deproject(FVector2D ScreenPos, /*out*/ FVector& WorldOrigin, /*out*/ FVector& WorldDirection) const;
 
    static ENGINE_API void StrLen(const UFont* InFont, FStringView InText, float& XL, float& YL, bool bDPIAware, FCanvas* InCanvas);
    static ENGINE_API void StrLen(const UFont* InFont, FStringView InText, double& XL, double& YL, bool bDPIAware, FCanvas* InCanvas);
    
#if !PLATFORM_TCHAR_IS_UTF8CHAR
 
    UE_DEPRECATED(5.5, "Passing an ANSI string to StrLen has been deprecated outside of UTF-8 mode. Please use the overload that takes a TCHAR string.")
    static ENGINE_API void StrLen(const UFont* InFont, FAnsiStringView InText, float& XL, float& YL, bool bDPIAware, FCanvas* InCanvas);
    UE_DEPRECATED(5.5, "Passing an ANSI string to StrLen has been deprecated outside of UTF-8 mode. Please use the overload that takes a TCHAR string.")
    static ENGINE_API void StrLen(const UFont* InFont, FAnsiStringView InText, double& XL, double& YL, bool bDPIAware, FCanvas* InCanvas);
 
#endif // !PLATFORM_TCHAR_IS_UTF8CHAR
 
    ENGINE_API void StrLen(const UFont* InFont, FStringView InText, float& XL, float& YL, bool bDPIAware = false);
    ENGINE_API void StrLen(const UFont* InFont, FStringView InText, double& XL, double& YL, bool bDPIAware = false);
    
#if !PLATFORM_TCHAR_IS_UTF8CHAR
 
    UE_DEPRECATED(5.5, "Passing an ANSI string to StrLen has been deprecated outside of UTF-8 mode. Please use the overload that takes a TCHAR string.")
    ENGINE_API void StrLen(const UFont* InFont, FAnsiStringView InText, float& XL, float& YL, bool bDPIAware = false);
    UE_DEPRECATED(5.5, "Passing an ANSI string to StrLen has been deprecated outside of UTF-8 mode. Please use the overload that takes a TCHAR string.")
    ENGINE_API void StrLen(const UFont* InFont, FAnsiStringView InText, double& XL, double& YL, bool bDPIAware = false);
 
#endif // !PLATFORM_TCHAR_IS_UTF8CHAR
 
    ENGINE_API void TextSize( const UFont* InFont, FStringView InText, float& XL, float& YL, float ScaleX=1.f, float ScaleY=1.f);
    ENGINE_API void TextSize( const UFont* InFont, FStringView InText, double& XL, double& YL, double ScaleX=1.f, double ScaleY=1.f);
    
#if !PLATFORM_TCHAR_IS_UTF8CHAR
 
    UE_DEPRECATED(5.5, "Passing an ANSI string to TextSize has been deprecated outside of UTF-8 mode. Please use the overload that takes a TCHAR string.")
    ENGINE_API void TextSize( const UFont* InFont, FAnsiStringView InText, float& XL, float& YL, float ScaleX=1.f, float ScaleY=1.f);
    UE_DEPRECATED(5.5, "Passing an ANSI string to TextSize has been deprecated outside of UTF-8 mode. Please use the overload that takes a TCHAR string.")
    ENGINE_API void TextSize( const UFont* InFont, FAnsiStringView InText, double& XL, double& YL, double ScaleX=1.f, double ScaleY=1.f);
 
#endif // !PLATFORM_TCHAR_IS_UTF8CHAR
 
    ENGINE_API void SetLinearDrawColor(FLinearColor InColor, float OpacityOverride=-1.f);
 
    ENGINE_API void SetDrawColor(uint8 R, uint8 G, uint8 B, uint8 A = 255);
 
    ENGINE_API void SetDrawColor(FColor const& C);
 
    ENGINE_API FFontRenderInfo CreateFontRenderInfo(bool bClipText = false, bool bEnableShadow = false, FLinearColor GlowColor = FLinearColor(), FVector2D GlowOuterRadius = FVector2D(), FVector2D GlowInnerRadius = FVector2D());
    
    ENGINE_API virtual void Reset(bool bKeepOrigin = false);
 
    ENGINE_API void SetClip(float X, float Y);
 
    ENGINE_API void GetCenter(float& outX, float& outY) const;
    ENGINE_API void GetCenter(double& outX, double& outY) const;
    
    static ENGINE_API FCanvasIcon MakeIcon(class UTexture* Texture, float U = 0.f, float V = 0.f, float UL = 0.f, float VL = 0.f);
 
    ENGINE_API void DrawScaledIcon(FCanvasIcon Icon, float X, float Y, FVector Scale);
    
    ENGINE_API void DrawIcon(FCanvasIcon Icon, float X, float Y, float Scale = 0.f);
 
    ENGINE_API virtual void DrawDebugGraph(const FString& Title, float ValueX, float ValueY, float UL_X, float UL_Y, float W, float H, FVector2D RangeX, FVector2D RangeY);
 
    ENGINE_API void DrawItem( FCanvasItem& Item );
 
    ENGINE_API void DrawItem( FCanvasItem& Item, const FVector2D& InPosition );
    
    ENGINE_API void DrawItem( FCanvasItem& Item, float X, float Y );
 
    ENGINE_API TWeakObjectPtr<class UReporterGraph>  GetReporterGraph();
 
    float GetDPIScale() const { return Canvas->GetDPIScale(); }
 
    UFUNCTION(BlueprintCallable, Category=Canvas, meta=(DisplayName="Draw Line", ScriptName="DrawLine"))
    ENGINE_API void K2_DrawLine(FVector2D ScreenPositionA=FVector2D::ZeroVector, FVector2D ScreenPositionB=FVector2D::ZeroVector, float Thickness=1.0f, FLinearColor RenderColor=FLinearColor::White);
 
    UFUNCTION(BlueprintCallable, Category=Canvas, meta=(DisplayName="Draw Texture", ScriptName="DrawTexture"))
    ENGINE_API void K2_DrawTexture(UTexture* RenderTexture, FVector2D ScreenPosition, FVector2D ScreenSize, FVector2D CoordinatePosition, FVector2D CoordinateSize=FVector2D::UnitVector, FLinearColor RenderColor=FLinearColor::White, EBlendMode BlendMode=BLEND_Translucent, float Rotation=0.f, FVector2D PivotPoint=FVector2D(0.5f,0.5f));
 
    UFUNCTION(BlueprintCallable, Category=Canvas, meta=(DisplayName="Draw Material", ScriptName="DrawMaterial"))
    ENGINE_API void K2_DrawMaterial(UMaterialInterface* RenderMaterial, FVector2D ScreenPosition, FVector2D ScreenSize, FVector2D CoordinatePosition, FVector2D CoordinateSize=FVector2D::UnitVector, float Rotation=0.f, FVector2D PivotPoint=FVector2D(0.5f,0.5f));
 
    UFUNCTION(BlueprintCallable, Category=Canvas, meta=(DisplayName="Draw Text", ScriptName="DrawText"))
    ENGINE_API void K2_DrawText(UFont* RenderFont, const FString& RenderText, FVector2D ScreenPosition, FVector2D Scale=FVector2D(1.0f,1.0f), FLinearColor RenderColor=FLinearColor::White, float Kerning=0.0f, FLinearColor ShadowColor=FLinearColor::Black, FVector2D ShadowOffset=FVector2D::UnitVector, bool bCentreX=false, bool bCentreY=false, bool bOutlined=false, FLinearColor OutlineColor=FLinearColor::Black);
    
    UFUNCTION(BlueprintCallable, Category=Canvas, meta=(DisplayName="Draw Border", ScriptName="DrawBorder"))
    ENGINE_API void K2_DrawBorder(UTexture* BorderTexture, UTexture* BackgroundTexture, UTexture* LeftBorderTexture, UTexture* RightBorderTexture, UTexture* TopBorderTexture, UTexture* BottomBorderTexture, FVector2D ScreenPosition, FVector2D ScreenSize, FVector2D CoordinatePosition, FVector2D CoordinateSize=FVector2D::UnitVector, FLinearColor RenderColor=FLinearColor::White, FVector2D BorderScale=FVector2D(0.1f,0.1f), FVector2D BackgroundScale=FVector2D(0.1f,0.1f), float Rotation=0.0f, FVector2D PivotPoint=FVector2D(0.5f,0.5f), FVector2D CornerSize=FVector2D::ZeroVector);
 
    UFUNCTION(BlueprintCallable, Category=Canvas, meta=(DisplayName="Draw Box", ScriptName="DrawBox"))
    ENGINE_API void K2_DrawBox(FVector2D ScreenPosition, FVector2D ScreenSize, float Thickness=1.0f, FLinearColor RenderColor=FLinearColor::White);
 
    UFUNCTION(BlueprintCallable, Category=Canvas, meta=(DisplayName="Draw Triangles", ScriptName="DrawTriangles"))
    ENGINE_API void K2_DrawTriangle(UTexture* RenderTexture, TArray<FCanvasUVTri> Triangles);
 
    UFUNCTION(BlueprintCallable, Category = Canvas, meta = (DisplayName = "Draw Material Triangles", ScriptName = "DrawMaterialTriangles"))
    ENGINE_API void K2_DrawMaterialTriangle(UMaterialInterface* RenderMaterial, TArray<FCanvasUVTri> Triangles);
    UFUNCTION(BlueprintCallable, Category=Canvas, meta=(DisplayName="Draw Polygon", ScriptName="DrawPolygon"))
    ENGINE_API void K2_DrawPolygon(UTexture* RenderTexture, FVector2D ScreenPosition, FVector2D Radius=FVector2D::UnitVector, int32 NumberOfSides=3, FLinearColor RenderColor=FLinearColor::White);
 
    UFUNCTION(BlueprintCallable, Category=Canvas, meta=(DisplayName="Project", ScriptName="Project"))
    ENGINE_API FVector K2_Project(FVector WorldLocation);
 
    UFUNCTION(BlueprintCallable, Category=Canvas, meta=(DisplayName="Deproject", ScriptName="Deproject"))
    ENGINE_API void K2_Deproject(FVector2D ScreenPosition, FVector& WorldOrigin, FVector& WorldDirection);
 
    UFUNCTION(BlueprintCallable, Category=Canvas, meta=(DisplayName="Wrapped Text Size", ScriptName="WrappedTextSize"))
    ENGINE_API FVector2D K2_StrLen(UFont* RenderFont, const FString& RenderText);
 
    UFUNCTION(BlueprintCallable, Category=Canvas, meta=(DisplayName="Clipped Text Size", ScriptName="ClippedTextSize"))
    ENGINE_API FVector2D K2_TextSize(UFont* RenderFont, const FString& RenderText, FVector2D Scale=FVector2D::UnitVector);
};