CanvasTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    Canvas.h: Unreal canvas definition.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "GameTime.h"
#include "SceneTypes.h"
#include "UObject/ObjectMacros.h"
#include "Engine/EngineTypes.h"
#include "HitProxies.h"
#include "CanvasTypes.generated.h"
 
class FBatchedElementParameters;
class FBatchedElements;
class FRDGBuilder;
class FRHICommandListImmediate;
class FCanvasBatchedElementRenderItem;
class FCanvasRenderContext;
class FCanvasRenderThreadScope;
class FCanvasItem;
class FTexture;
class FMaterialRenderProxy;
class FRenderTarget;
class FSceneInterface;
class IBreakIterator;
class UFont;
class FRDGTexture;
namespace ERHIFeatureLevel { enum Type : int; }
struct FMeshPassProcessorRenderState;
using FRDGTextureRef = FRDGTexture*;
enum EShaderPlatform : uint16;
 
USTRUCT()
struct FTextSizingParameters
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    float DrawX;
 
    UPROPERTY()
    float DrawY;
 
    UPROPERTY()
    float DrawXL;
 
    UPROPERTY()
    float DrawYL;
 
    UPROPERTY()
    FVector2D Scaling;
 
    UPROPERTY()
    TObjectPtr<const UFont> DrawFont;
 
    UPROPERTY()
    FVector2D SpacingAdjust;
 
    FTextSizingParameters()
        : DrawX(0)
        , DrawY(0)
        , DrawXL(0)
        , DrawYL(0)
        , Scaling(ForceInit)
        , DrawFont(NULL)
        , SpacingAdjust(ForceInit)
    {
    }
 
 
        FTextSizingParameters( float inDrawX, float inDrawY, float inDrawXL, float inDrawYL, const UFont* inFont=NULL )
        : DrawX(inDrawX), DrawY(inDrawY), DrawXL(inDrawXL), DrawYL(inDrawYL)
        , Scaling(1.f,1.f), DrawFont(inFont)
        , SpacingAdjust( 0.0f, 0.0f )
        {
        }
        FTextSizingParameters( const UFont* inFont, float ScaleX, float ScaleY)
        : DrawX(0.f), DrawY(0.f), DrawXL(0.f), DrawYL(0.f)
        , Scaling(ScaleX,ScaleY), DrawFont(inFont)
        , SpacingAdjust( 0.0f, 0.0f )
        {
        }
    
};
 
USTRUCT()
struct FWrappedStringElement
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    FString Value;
 
    UPROPERTY()
    FVector2D LineExtent;
 
    FWrappedStringElement()
        : LineExtent(ForceInit)
    {
    }
 
    FWrappedStringElement(FString&& InValue, float Width, float Height )
        : Value(MoveTemp(InValue)), LineExtent(Width,Height)
    {}
 
    FWrappedStringElement(const FString& InValue, float Width, float Height)
        : Value(CopyTemp(InValue)), LineExtent(Width, Height)
    {}
    
};
 
class FCanvasWordWrapper
{
public:
    typedef TArray< TPair<int32, int32> > FWrappedLineData;
 
private:
    struct FWrappingState
    {
        FWrappingState( FStringView InString,
                        const FTextSizingParameters& InParameters,
                        TArray<FWrappedStringElement>& InResults,
                        FWrappedLineData* const InWrappedLineData)
            : String(InString)
            , Parameters(InParameters)
            , StartIndex(0)
            , Results(InResults)
            , WrappedLineData(InWrappedLineData)
        {}
 
        FStringView String;
        const FTextSizingParameters& Parameters;
        int32 StartIndex;
        TArray<FWrappedStringElement>& Results;
        FWrappedLineData* const WrappedLineData;
    };
 
public:
    ENGINE_API FCanvasWordWrapper();
 
    ENGINE_API void Execute(FStringView InString, const FTextSizingParameters& InParameters, TArray<FWrappedStringElement>& OutStrings, FWrappedLineData* const OutWrappedLineData);
 
private:
    bool ProcessLine(FWrappingState& WrappingState);
 
    bool DoesSubstringFit(FWrappingState& WrappingState, const int32 EndIndex);
 
    int32 FindIndexAtOrAfterWrapWidth(FWrappingState& WrappingState);
 
    void AddLine(FWrappingState& WrappingState, const int32 EndIndex);
 
    int32 FindFirstMandatoryBreakBetween(FWrappingState& WrappingState, const int32 WrapIndex);
    int32 FindLastBreakCandidateBetween(const int32 StartIndex, const int32 WrapIndex);
    int32 FindEndOfLastWholeGraphemeCluster(const int32 StartIndex, const int32 WrapIndex);
 
private:
    TSharedPtr<IBreakIterator> GraphemeBreakIterator;
    TSharedPtr<IBreakIterator> LineBreakIterator;
};
 
class FCanvas
{
public:
 
    enum EElementType
    {
        ET_Line,
        ET_Triangle,
        ET_MAX
    };
 
    enum ECanvasAllowModes
    {
        // flushing and rendering
        Allow_Flush = 1 << 0,
        // delete the render batches when rendering
        Allow_DeleteOnRender = 1 << 1
    };
 
    enum ECanvasDrawMode
    {
        CDM_DeferDrawing,
        CDM_ImmediateDrawing
    };
 
    ENGINE_API static FCanvas* Create(FRDGBuilder& GraphBuilder, FRDGTextureRef InRenderTarget, FHitProxyConsumer* InHitProxyConsumer, const FGameTime& Time, ERHIFeatureLevel::Type InFeatureLevel, float InDPIScale = 1.0f);
 
    ENGINE_API FCanvas(FRenderTarget* InRenderTarget, FHitProxyConsumer* InHitProxyConsumer, UWorld* InWorld, ERHIFeatureLevel::Type InFeatureLevel, ECanvasDrawMode DrawMode = CDM_DeferDrawing, float InDPIScale = 1.0f);
 
    ENGINE_API FCanvas(FRenderTarget* InRenderTarget, FHitProxyConsumer* InHitProxyConsumer, const FGameTime& Time, ERHIFeatureLevel::Type InFeatureLevel, float InDPIScale = 1.0f);
    
    ENGINE_API ~FCanvas();
 
 
    ENGINE_API static ESimpleElementBlendMode BlendToSimpleElementBlend(EBlendMode BlendMode);
    ENGINE_API FBatchedElements* GetBatchedElements(EElementType InElementType, FBatchedElementParameters* InBatchedElementParameters = NULL, const FTexture* Texture = NULL, ESimpleElementBlendMode BlendMode = SE_BLEND_MAX, const FDepthFieldGlowInfo& GlowInfo = FDepthFieldGlowInfo(), bool bApplyDPIScale = true);
 
    ENGINE_API void AddTileRenderItem(float X, float Y, float SizeX, float SizeY, float U, float V, float SizeU, float SizeV, const FMaterialRenderProxy* MaterialRenderProxy, FHitProxyId HitProxyId, bool bFreezeTime, FColor InColor);
 
    ENGINE_API void AddTriangleRenderItem(const FCanvasUVTri& Tri, const FMaterialRenderProxy* MaterialRenderProxy, FHitProxyId HitProxyId, bool bFreezeTime);
 
    ENGINE_API void Flush_RenderThread(FRHICommandListImmediate& RHICmdList, bool bForce = false);
    ENGINE_API void Flush_RenderThread(FRDGBuilder& GraphBuilder, bool bForce = false);
 
    ENGINE_API void Flush_GameThread(bool bForce = false);
 
    ENGINE_API void PushRelativeTransform(const FMatrix& Transform);
 
    ENGINE_API void PushAbsoluteTransform(const FMatrix& Transform);
 
    ENGINE_API void PopTransform();
 
    ENGINE_API void SetBaseTransform(const FMatrix& Transform);
 
    ENGINE_API static FMatrix CalcBaseTransform2D(uint32 ViewSizeX, uint32 ViewSizeY);
 
    ENGINE_API static FMatrix CalcBaseTransform3D(uint32 ViewSizeX, uint32 ViewSizeY, float fFOV, float NearPlane);
 
    ENGINE_API static FMatrix CalcViewMatrix(uint32 ViewSizeX, uint32 ViewSizeY, float fFOV);
 
    ENGINE_API static FMatrix CalcProjectionMatrix(uint32 ViewSizeX, uint32 ViewSizeY, float fFOV, float NearPlane);
 
    FMatrix GetTransform() const
    {
        return TransformStack.Top().GetMatrix() * TransformStack[0].GetMatrix().InverseFast();
    }
 
    const FMatrix& GetBottomTransform() const
    {
        return TransformStack[0].GetMatrix();
    }
 
    const FMatrix& GetFullTransform() const
    {
        return TransformStack.Top().GetMatrix();
    }
 
    ENGINE_API void CopyTransformStack(const FCanvas& Copy);
 
    ENGINE_API void SetRenderTarget_GameThread(FRenderTarget* NewRenderTarget);
 
    inline FRenderTarget* GetRenderTarget() const
    {
        return RenderTarget;
    }
 
    ENGINE_API void SetRenderTargetRect(const FIntRect& ViewRect);
 
    ENGINE_API void SetRenderTargetScissorRect( const FIntRect& ScissorRect );
 
    void SetRenderTargetDirty(bool bDirty)
    {
        bRenderTargetDirty = bDirty;
    }
 
    ENGINE_API void SetHitProxy(HHitProxy* HitProxy);
 
    // HitProxy Accessors.  
 
    FHitProxyId GetHitProxyId() const { return CurrentHitProxy ? CurrentHitProxy->Id : FHitProxyId(); }
    FHitProxyConsumer* GetHitProxyConsumer() const { return HitProxyConsumer; }
    bool IsHitTesting() const { return HitProxyConsumer != NULL; }
 
    FSceneInterface* GetScene() const { return Scene; }
 
    void PushDepthSortKey(int32 InSortKey)
    {
        DepthSortKeyStack.Push(InSortKey);
    };
 
    int32 PopDepthSortKey()
    {
        int32 Result = 0;
        if (DepthSortKeyStack.Num() > 0)
        {
            Result = DepthSortKeyStack.Pop();
        }
        else
        {
            // should always have one entry
            PushDepthSortKey(0);
        }
        return Result;
    };
 
    int32 TopDepthSortKey()
    {
        checkSlow(DepthSortKeyStack.Num() > 0);
        return DepthSortKeyStack.Top();
    }
 
    void SetAllowedModes(uint32 InAllowedModes)
    {
        AllowedModes = InAllowedModes;
    }
    uint32 GetAllowedModes() const
    {
        return AllowedModes;
    }
 
    bool HasBatchesToRender() const;
 
    void ClearBatchesToRender();
 
    ERHIFeatureLevel::Type GetFeatureLevel() const { return FeatureLevel; }
 
    ENGINE_API EShaderPlatform GetShaderPlatform() const;
 
public:
    float AlphaModulate;
 
    class FTransformEntry
    {
    public:
        FTransformEntry(const FMatrix& InMatrix)
            : Matrix(InMatrix)
        {
            MatrixCRC = FCrc::MemCrc_DEPRECATED(&Matrix, sizeof(FMatrix));
        }
        inline void SetMatrix(const FMatrix& InMatrix)
        {
            Matrix = InMatrix;
            MatrixCRC = FCrc::MemCrc_DEPRECATED(&Matrix, sizeof(FMatrix));
        }
        inline const FMatrix& GetMatrix() const
        {
            return Matrix;
        }
        inline uint32 GetMatrixCRC() const
        {
            return MatrixCRC;
        }
    private:
        FMatrix Matrix;
        uint32 MatrixCRC;
    };
 
    inline const TArray<FTransformEntry>& GetTransformStack() const
    {
        return TransformStack;
    }
    inline const FIntRect& GetViewRect() const
    {
        return ViewRect;
    }
 
    inline void SetScaledToRenderTarget(bool bScale = true)
    {
        bScaledToRenderTarget = bScale;
    }
    inline bool IsScaledToRenderTarget() const { return bScaledToRenderTarget; }
 
    inline void SetStereoRendering(bool bStereo = true)
    {
        bStereoRendering = bStereo;
    }
    inline bool IsStereoRendering() const { return bStereoRendering; }
 
    inline void SetUseInternalTexture(const bool bInUseInternalTexture)
    {
        bUseInternalTexture = bInUseInternalTexture;
    }
 
    inline bool IsUsingInternalTexture() const { return bUseInternalTexture; }
 
    inline void SetWriteDestinationAlpha(const bool bInForceWriteAlpha)
    {
        bWriteDestinationAlpha = bInForceWriteAlpha;
    }
 
    inline bool IsWriteDestinationAlphaSet() const { return bWriteDestinationAlpha; }
 
    inline void SetParentCanvasSize(FIntPoint InParentSize)
    {
        ParentSize = InParentSize;
    }
 
    inline FIntPoint GetParentCanvasSize() const { return ParentSize; }
 
    float GetDPIScale() const { return  bStereoRendering ? 1.0f : DPIScale; }
public:
    TSharedPtr<FCanvasWordWrapper> WordWrapper;
 
private:
 
    TArray<int32> DepthSortKeyStack;    
    TArray<FTransformEntry> TransformStack; 
    FIntRect ViewRect;
    FIntRect ScissorRect;
    FRenderTarget* RenderTarget;
    FHitProxyConsumer* HitProxyConsumer;
    TRefCountPtr<HHitProxy> CurrentHitProxy;
    /* Optional scene for rendering. */
    FSceneInterface* Scene;
    uint32 AllowedModes;
    bool bRenderTargetDirty;    
    FGameTime Time;
    bool bScaledToRenderTarget;
    ERHIFeatureLevel::Type FeatureLevel;
 
    bool bStereoRendering;
 
    bool bUseInternalTexture;
 
    bool bWriteDestinationAlpha;
 
    FIntPoint ParentSize;
 
    ECanvasDrawMode DrawMode;
 
    float DPIScale;
 
    void Construct();
 
public: 
 
    const FGameTime& GetTime() const
    {
        return Time;
    }
    
    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 void Clear(const FLinearColor& Color);
 
 
 
    ENGINE_API void DrawTile(double X, double Y, double SizeX, double SizeY, float U, float V, float SizeU, float SizeV, const FLinearColor& Color, const FTexture* Texture = NULL, bool AlphaBlend = true);
    ENGINE_API void DrawTile(double X, double Y, double SizeX, double SizeY, float U, float V, float SizeU, float SizeV, const FLinearColor& Color, const FTexture* Texture, ESimpleElementBlendMode BlendMode);
 
    ENGINE_API int32 DrawShadowedString(double StartX, double StartY, FStringView Text, const UFont* Font, const FLinearColor& Color, const FLinearColor& ShadowColor = FLinearColor::Black );
    
    ENGINE_API int32 DrawShadowedText(double StartX, double StartY, const FText& Text, const UFont* Font, const FLinearColor& Color, const FLinearColor& ShadowColor = FLinearColor::Black );
 
    ENGINE_API void WrapString( FTextSizingParameters& Parameters, const float InCurX, FStringView Text, TArray<FWrappedStringElement>& out_Lines, FCanvasWordWrapper::FWrappedLineData* const OutWrappedLineData = nullptr);
 
    ENGINE_API void DrawNGon(const FVector2D& Center, const FColor& Color, int32 NumSides, float Radius);
 
    class FCanvasSortElement
    {
    public:
        FCanvasSortElement(int32 InDepthSortKey=0)
            :   DepthSortKey(InDepthSortKey)
        {}
 
        bool operator==(const FCanvasSortElement& Other) const
        {
            return DepthSortKey == Other.DepthSortKey;
        }
 
        int32 DepthSortKey;
        TArray<class FCanvasBaseRenderItem*> RenderBatchArray;
    };
    
    TArray<FCanvasSortElement> SortedElements;
    TMap<int32,int32> SortedElementLookupMap;
 
    int32 LastElementIndex;
    
    ENGINE_API FCanvasSortElement& GetSortElement(int32 DepthSortKey);
 
    friend class FCanvasRenderContext;
    friend class FCanvasRenderThreadScope;
};
 
class FCanvasBaseRenderItem
{
public:
    virtual ~FCanvasBaseRenderItem()
    {}
 
    virtual bool Render_RenderThread(FCanvasRenderContext& RenderContext, FMeshPassProcessorRenderState& DrawRenderState, const FCanvas* Canvas) = 0;
    
    virtual bool Render_GameThread(const FCanvas* Canvas, FCanvasRenderThreadScope& RenderScope) = 0;
    
    virtual class FCanvasBatchedElementRenderItem* GetCanvasBatchedElementRenderItem() { return NULL; }
    
    virtual class FCanvasTileRendererItem* GetCanvasTileRendererItem() { return NULL; }
 
    virtual class FCanvasTriangleRendererItem* GetCanvasTriangleRendererItem() { return NULL; }
};
 
 
extern ENGINE_API void StringSize( const UFont* Font, int32& XL, int32& YL, FStringView Text);
 
struct FScreenMessageWriter
{
    FScreenMessageWriter(FCanvas& InCanvas, int32 InY)
        : Canvas(InCanvas)
        , Y(InY)
    {}
 
    inline void EmptyLine()
    {
        Y += 14;
    }
 
    ENGINE_API void DrawLine(const FText& Message, int32 X = 10, const FLinearColor& Color = FLinearColor(1.0f, 0.05f, 0.05f, 1.0f));
 
    FCanvas& Canvas;
    int32 Y;
};