RenderingCommon.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Stats/Stats.h"
#include "Layout/SlateRect.h"
#include "Layout/SlateRotatedRect.h"
#include "Input/CursorReply.h"
#include "Input/Reply.h"
#include "Input/NavigationReply.h"
#include "Input/PopupMethodReply.h"
#include "PixelFormat.h"
#include "Rendering/DrawElementCoreTypes.h"
#include "Rendering/SlateRendererTypes.h"
#include "SlateGlobals.h"
#include <type_traits>
#include <utility>
 
#include "RenderingCommon.generated.h"
 
class FRHICommandListImmediate;
class FRHIBuffer;
class FRDGBuilder;
class FRDGTexture;
class FSlateElementBatcher;
class FSlateInstanceBufferUpdate;
class FWidgetStyle;
class SWidget;
 
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Num Cached Element Lists"), STAT_SlateNumCachedElementLists, STATGROUP_Slate, SLATECORE_API);
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Num Cached Elements"), STAT_SlateNumCachedElements, STATGROUP_Slate, SLATECORE_API);
 
DECLARE_CYCLE_STAT_EXTERN(TEXT("PreFill Buffers"), STAT_SlatePreFullBufferTime, STATGROUP_Slate, SLATECORE_API);
 
#define UE_SLATE_VERIFY_PIXELSIZE UE_BUILD_DEBUG
 
#define SLATE_USE_32BIT_INDICES !PLATFORM_USES_GLES
 
#if SLATE_USE_32BIT_INDICES
typedef uint32 SlateIndex;
#else
typedef uint16 SlateIndex;
#endif
enum class ESlateDrawPrimitive : uint8
{
    None,
    LineList,
    TriangleList,
};
 
enum class ESlateShader : uint8
{
    Default = 0,
    Border = 1,
    GrayscaleFont = 2,
    ColorFont = 3,
    LineSegment = 4,
    Custom = 5,
    PostProcess = 6,
    RoundedBox = 7,
    SdfFont = 8,
    MsdfFont = 9,
};
 
enum class ESlateDrawEffect : uint8
{
    None                    = 0,
    NoBlending          = 1 << 0,
    PreMultipliedAlpha  = 1 << 1,
    NoGamma             = 1 << 2,
    InvertAlpha         = 1 << 3,
 
    // ^^ These Match ESlateBatchDrawFlag ^^
 
    NoPixelSnapping     = 1 << 4,
    DisabledEffect      = 1 << 5,
    IgnoreTextureAlpha  = 1 << 6,
 
    ReverseGamma            = 1 << 7
};
 
ENUM_CLASS_FLAGS(ESlateDrawEffect);
 
enum class ESlateBatchDrawFlag : uint16
{
    None                    = 0,
    NoBlending          = 1 << 0,
    PreMultipliedAlpha  = 1 << 1,
    NoGamma             = 1 << 2,
    InvertAlpha         = 1 << 3,
 
    // ^^ These Match ESlateDrawEffect ^^
 
    Wireframe           = 1 << 4,
    TileU               = 1 << 5,
    TileV               = 1 << 6,
    ReverseGamma        = 1 << 7,
    HDR                 = 1 << 8
};
 
ENUM_CLASS_FLAGS(ESlateBatchDrawFlag);
 
enum class ESlateLineJoinType : uint8
{
    // Joins line segments with a sharp edge (miter)
    Sharp = 0,
    // Simply stitches together line segments
    Simple = 1,
};
 
 
UENUM()
enum class EColorVisionDeficiency : uint8
{
    NormalVision UMETA(DisplayName="Normal Vision"),
    Deuteranope UMETA(DisplayName="Deuteranope (green weak/blind) (7% of males, 0.4% of females)"),
    Protanope UMETA(DisplayName="Protanope (red weak/blind) (2% of males, 0.01% of females)"),
    Tritanope UMETA(DisplayName="Tritanope (blue weak/blind) (0.0003% of males)"),
};
 
 
enum class ESlateVertexRounding : uint8
{
    Disabled,
    Enabled
};
 
enum class ESlateViewportDynamicRange : uint8
{
    SDR,
    HDR
};
 
class FSlateRenderBatch;
 
 
struct FShaderParams
{
    FVector4f PixelParams;
    FVector4f PixelParams2;
    FVector4f PixelParams3;
 
    FShaderParams()
        : PixelParams(0, 0, 0, 0)
        , PixelParams2(0, 0, 0, 0)
        , PixelParams3(0, 0, 0, 0)
    {}
 
    FShaderParams(const FVector4f& InPixelParams, const FVector4f& InPixelParams2 = FVector4f(0), const FVector4f& InPixelParams3 = FVector4f(0))
        : PixelParams(InPixelParams)
        , PixelParams2(InPixelParams2)
        , PixelParams3(InPixelParams3)
    {}
 
    bool operator==(const FShaderParams& Other) const
    {
        return PixelParams == Other.PixelParams && PixelParams2 == Other.PixelParams2 && PixelParams3 == Other.PixelParams3;
    }
 
    static FShaderParams MakePixelShaderParams(const FVector4f& PixelShaderParams, const FVector4f& InPixelShaderParams2 = FVector4f(0), const FVector4f& InPixelShaderParams3 = FVector4f(0))
    {
        return FShaderParams(PixelShaderParams, InPixelShaderParams2, InPixelShaderParams3);
    }
};
 
 
struct FSlateVertex
{
    float TexCoords[4]; 
 
    FVector2f MaterialTexCoords;
 
    FVector2f Position;
 
    FColor Color;
    
    FColor SecondaryColor;
 
    uint16 PixelSize[2];
 
    FSlateVertex() 
    {}
 
public:
 
    template<ESlateVertexRounding Rounding>
    inline static FSlateVertex Make(const FSlateRenderTransform& RenderTransform, const FVector2f InLocalPosition, const FVector2f InTexCoord, const FVector2f InTexCoord2, const FColor InColor, const FColor SecondaryColor = FColor())
    {
        FSlateVertex Vertex;
        Vertex.TexCoords[0] = InTexCoord.X;
        Vertex.TexCoords[1] = InTexCoord.Y;
        Vertex.TexCoords[2] = InTexCoord2.X;
        Vertex.TexCoords[3] = InTexCoord2.Y;
        Vertex.InitCommon<Rounding>(RenderTransform, InLocalPosition, InColor, SecondaryColor);
 
        return Vertex;
    }
 
    template<ESlateVertexRounding Rounding>
    inline static FSlateVertex Make(const FSlateRenderTransform& RenderTransform, const FVector2f InLocalPosition, const FVector2f InTexCoord, const FColor& InColor, const FColor SecondaryColor = FColor())
    {
        FSlateVertex Vertex;
        Vertex.TexCoords[0] = InTexCoord.X;
        Vertex.TexCoords[1] = InTexCoord.Y;
        Vertex.TexCoords[2] = 1.0f;
        Vertex.TexCoords[3] = 1.0f;
        Vertex.InitCommon<Rounding>(RenderTransform, InLocalPosition, InColor, SecondaryColor);
 
        return Vertex;
    }
 
    template<ESlateVertexRounding Rounding>
    inline static FSlateVertex Make(const FSlateRenderTransform& RenderTransform, const FVector2f InLocalPosition, const FVector4f InTexCoords, const FVector2f InMaterialTexCoords, const FColor InColor, const FColor SecondaryColor = FColor())
    {
        FSlateVertex Vertex;
        Vertex.TexCoords[0] = InTexCoords.X;
        Vertex.TexCoords[1] = InTexCoords.Y;
        Vertex.TexCoords[2] = InTexCoords.Z;
        Vertex.TexCoords[3] = InTexCoords.W;
        Vertex.MaterialTexCoords = InMaterialTexCoords;
        Vertex.InitCommon<Rounding>(RenderTransform, InLocalPosition, InColor, SecondaryColor);
 
        return Vertex;
    }
 
    template<ESlateVertexRounding Rounding>
    inline static FSlateVertex Make(const FSlateRenderTransform& RenderTransform, const FVector2f InLocalPosition, const FVector2f InLocalSize, float Scale, const FVector4f InTexCoords, const FColor InColor, const FColor SecondaryColor = FColor())
    {
        FSlateVertex Vertex;
        Vertex.TexCoords[0] = InTexCoords.X;
        Vertex.TexCoords[1] = InTexCoords.Y;
        Vertex.TexCoords[2] = InTexCoords.Z;
        Vertex.TexCoords[3] = InTexCoords.W;
        Vertex.MaterialTexCoords = FVector2f(InLocalPosition.X / InLocalSize.X, InLocalPosition.Y / InLocalSize.Y);
        Vertex.InitCommon<Rounding>(RenderTransform, InLocalPosition, InColor, SecondaryColor);
 
        const int32 PixelSizeX = FMath::RoundToInt(InLocalSize.X * Scale);
        const int32 PixelSizeY = FMath::RoundToInt(InLocalSize.Y * Scale);
        Vertex.PixelSize[0] = (uint16)PixelSizeX;
        Vertex.PixelSize[1] = (uint16)PixelSizeY;
 
#if UE_SLATE_VERIFY_PIXELSIZE
        ensureMsgf((int32)Vertex.PixelSize[0] == PixelSizeX, TEXT("Conversion of PixelSizeX is bigger than 16. Cast:%d, int16:%d, int32:%d")
            , (int32)Vertex.PixelSize[0], Vertex.PixelSize[0], PixelSizeX);
        ensureMsgf((int32)Vertex.PixelSize[1] == PixelSizeY, TEXT("Conversion of PixelSizeY is bigger than 16. Cast:%d, int16:%d, int32:%d")
            , (int32)Vertex.PixelSize[1], Vertex.PixelSize[1], PixelSizeY);
#endif
 
        return Vertex;
    }
    
    inline static FSlateVertex Make(const FSlateRenderTransform& RenderTransform, const FVector2f InLocalPosition, const FVector2f InTexCoord, const FVector2f InTexCoord2, const FColor InColor, const FColor SecondaryColor = FColor(), const ESlateVertexRounding InRounding = ESlateVertexRounding::Disabled)
    {
        return InRounding == ESlateVertexRounding::Enabled
            ? FSlateVertex::Make<ESlateVertexRounding::Enabled>(RenderTransform, InLocalPosition, InTexCoord, InTexCoord2, InColor, SecondaryColor)
            : FSlateVertex::Make<ESlateVertexRounding::Disabled>(RenderTransform, InLocalPosition, InTexCoord, InTexCoord2, InColor, SecondaryColor);
    }
 
    
    inline static FSlateVertex Make(const FSlateRenderTransform& RenderTransform, const FVector2f InLocalPosition, const FVector2f InTexCoord, const FColor& InColor, const FColor SecondaryColor = FColor(), const ESlateVertexRounding InRounding = ESlateVertexRounding::Disabled)
    {
        return InRounding == ESlateVertexRounding::Enabled
            ? FSlateVertex::Make<ESlateVertexRounding::Enabled>(RenderTransform, InLocalPosition, InTexCoord, InColor, SecondaryColor)
            : FSlateVertex::Make<ESlateVertexRounding::Disabled>(RenderTransform, InLocalPosition, InTexCoord, InColor, SecondaryColor);
    }
 
    
    inline static FSlateVertex Make(const FSlateRenderTransform& RenderTransform, const FVector2f InLocalPosition, const FVector4f InTexCoords, const FVector2f InMaterialTexCoords, const FColor InColor, const FColor SecondaryColor = FColor(), const ESlateVertexRounding InRounding = ESlateVertexRounding::Disabled)
    {
        return InRounding == ESlateVertexRounding::Enabled
            ? FSlateVertex::Make<ESlateVertexRounding::Enabled>(RenderTransform, InLocalPosition, InTexCoords, InMaterialTexCoords, InColor, SecondaryColor)
            : FSlateVertex::Make<ESlateVertexRounding::Disabled>(RenderTransform, InLocalPosition, InTexCoords, InMaterialTexCoords, InColor, SecondaryColor);
    }
 
    
    inline static FSlateVertex Make(const FSlateRenderTransform& RenderTransform, const FVector2f InLocalPosition, const FVector2f InLocalSize, float Scale, const FVector4f InTexCoords, const FColor InColor, const FColor SecondaryColor = FColor(), const ESlateVertexRounding InRounding = ESlateVertexRounding::Disabled)
    {
        return InRounding == ESlateVertexRounding::Enabled
            ? FSlateVertex::Make<ESlateVertexRounding::Enabled>(RenderTransform, InLocalPosition, InLocalSize, Scale, InTexCoords, InColor, SecondaryColor)
            : FSlateVertex::Make<ESlateVertexRounding::Disabled>(RenderTransform, InLocalPosition, InLocalSize, Scale, InTexCoords, InColor, SecondaryColor);
    }
 
    inline void SetTexCoords(const FVector4f InTexCoords)
    {
        TexCoords[0] = InTexCoords.X;
        TexCoords[1] = InTexCoords.Y;
        TexCoords[2] = InTexCoords.Z;
        TexCoords[3] = InTexCoords.W;
    }
 
    inline void SetPosition(const FVector2f InPosition)
    {
        Position = InPosition;
    }
 
private:
 
    template<ESlateVertexRounding Rounding>
    inline void InitCommon(const FSlateRenderTransform& RenderTransform, const FVector2f InLocalPosition, const FColor InColor, const FColor InSecondaryColor)
    {
        Position = TransformPoint(RenderTransform, InLocalPosition);
 
        if constexpr ( Rounding == ESlateVertexRounding::Enabled )
        {
            Position.X = FMath::RoundToFloat(Position.X);
            Position.Y = FMath::RoundToFloat(Position.Y);
        }
 
        Color = InColor;
        SecondaryColor = InSecondaryColor;
    }
};
 
template<> struct TIsPODType<FSlateVertex> { enum { Value = true }; };
static_assert(std::is_trivially_destructible_v<FSlateVertex>, "FSlateVertex should be trivially destructible");
static_assert(std::is_trivially_copyable_v<FSlateVertex> == true, "FSlateVertex should be trivially copyable");
 
struct FShortRect
{
    FShortRect()
        : Left(0)
        , Top(0)
        , Right(0)
        , Bottom(0)
    {
    }
    
    FShortRect(uint16 InLeft, uint16 InTop, uint16 InRight, uint16 InBottom)
        : Left(InLeft)
        , Top(InTop)
        , Right(InRight)
        , Bottom(InBottom)
    {
    }
    
    explicit FShortRect(const FSlateRect& Rect)
        : Left((uint16)FMath::Clamp(Rect.Left, 0.0f, 65535.0f))
        , Top((uint16)FMath::Clamp(Rect.Top, 0.0f, 65535.0f))
        , Right((uint16)FMath::Clamp(Rect.Right, 0.0f, 65535.0f))
        , Bottom((uint16)FMath::Clamp(Rect.Bottom, 0.0f, 65535.0f))
    {
    }
 
    bool operator==(const FShortRect& RHS) const { return Left == RHS.Left && Top == RHS.Top && Right == RHS.Right && Bottom == RHS.Bottom; }
    bool operator!=(const FShortRect& RHS) const { return !(*this == RHS); }
    bool DoesIntersect( const FShortRect& B ) const
    {
        const bool bDoNotOverlap =
            B.Right < Left || Right < B.Left ||
            B.Bottom < Top || Bottom < B.Top;
 
        return ! bDoNotOverlap;
    }
 
    bool DoesIntersect(const FSlateRect& B) const
    {
        const bool bDoNotOverlap =
            B.Right < Left || Right < B.Left ||
            B.Bottom < Top || Bottom < B.Top;
 
        return !bDoNotOverlap;
    }
 
    FVector2f GetTopLeft() const { return FVector2f(Left, Top); }
    FVector2f GetBottomRight() const { return FVector2f(Right, Bottom); }
 
    uint16 Left;
    uint16 Top;
    uint16 Right;
    uint16 Bottom;
};
 
template<> struct TIsPODType<FShortRect> { enum { Value = true }; };
static_assert(std::is_trivially_destructible_v<FShortRect>, "FShortRect should be trivially destructible");
 
namespace UE::Slate
{
    template<typename IndexType, IndexType...Indices>
    auto MakeTupleIndiciesInner(std::integer_sequence<IndexType, Indices...>)
    {
        return MakeTuple<IndexType>(Indices...);
    };
 
    template<typename IndexType, std::size_t Num, typename Indices = std::make_integer_sequence<IndexType, Num>>
    auto MakeTupleIndicies()
    {
        return MakeTupleIndiciesInner(Indices{});
    };
};
 
#if STATS
 
typedef TArray<FSlateVertex, FSlateStatTrackingMemoryAllocator<FRenderingBufferStatTracker>> FSlateVertexArray;
typedef TArray<SlateIndex, FSlateStatTrackingMemoryAllocator<FRenderingBufferStatTracker>> FSlateIndexArray;
 
#else
 
typedef TArray<FSlateVertex> FSlateVertexArray;
typedef TArray<SlateIndex> FSlateIndexArray;
 
#endif // STATS
 
class ISlateViewport
{
public:
    virtual ~ISlateViewport() {}
 
    virtual void OnDrawViewport( const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, class FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) { }
    
    virtual FIntPoint GetSize() const = 0;
 
    virtual class FSlateShaderResource* GetViewportRenderTargetTexture() const = 0;
 
    virtual EPixelFormat GetSceneTargetFormat() const { return EPixelFormat::PF_Unknown; };
 
    virtual bool IsViewportTextureAlphaOnly() const
    {
        return false;
    }
 
    virtual bool IsStereoscopic3D() const
    {
        return false;
    }
    
    virtual bool UseSeparateRenderTarget() const
    {
        return false;
    }
 
    virtual ESlateViewportDynamicRange GetViewportDynamicRange() const
    {
        return ESlateViewportDynamicRange::SDR;
    }
 
    virtual void Tick(const FGeometry& AllottedGeometry, double InCurrentTime, float DeltaTime )
    {
    }
 
    virtual bool RequiresVsync() const = 0;
 
    virtual bool AllowScaling() const
    {
        return true;
    }
 
    virtual FCursorReply OnCursorQuery( const FGeometry& MyGeometry, const FPointerEvent& CursorEvent )
    {
        return FCursorReply::Unhandled();
    }
 
    virtual TOptional<TSharedRef<SWidget>> OnMapCursor(const FCursorReply& CursorReply)
    {
        return TOptional<TSharedRef<SWidget>>();
    }
 
    virtual bool IsSoftwareCursorVisible() const
    {
        return false;
    }
 
    virtual FVector2D GetSoftwareCursorPosition() const
    {
        return FVector2D::ZeroVector;
    }
 
    virtual FReply OnMouseButtonDown( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
    {
        return FReply::Unhandled();
    }
 
    virtual FReply OnMouseButtonUp( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
    {
        return FReply::Unhandled();
    }
 
 
    virtual void OnMouseEnter( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
    {
 
    }
 
    virtual void OnMouseLeave( const FPointerEvent& MouseEvent )
    {
        
    }
 
    virtual FReply OnMouseMove( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
    {
        return FReply::Unhandled();
    }
 
    virtual FReply OnMouseWheel( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
    {
        return FReply::Unhandled();
    }
 
    virtual FReply OnMouseButtonDoubleClick( const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent )
    {
        return FReply::Unhandled();
    }
 
    virtual FReply OnKeyDown( const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent )
    {
        return FReply::Unhandled();
    }
 
    virtual FReply OnKeyUp( const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent )
    {
        return FReply::Unhandled();
    }
 
    virtual FReply OnAnalogValueChanged( const FGeometry& MyGeometry, const FAnalogInputEvent& InAnalogInputEvent )
    {
        return FReply::Unhandled();
    }
 
    virtual FReply OnKeyChar( const FGeometry& MyGeometry, const FCharacterEvent& InCharacterEvent )
    {
        return FReply::Unhandled();
    }
 
    virtual FReply OnFocusReceived( const FFocusEvent& InFocusEvent )
    {
        return FReply::Unhandled();
    }
 
    virtual FReply OnTouchStarted( const FGeometry& MyGeometry, const FPointerEvent& InTouchEvent )
    {
        return FReply::Unhandled();
    }
 
    virtual FReply OnTouchMoved( const FGeometry& MyGeometry, const FPointerEvent& InTouchEvent )
    {
        return FReply::Unhandled();
    }
 
    virtual FReply OnTouchEnded( const FGeometry& MyGeometry, const FPointerEvent& InTouchEvent )
    {
        return FReply::Unhandled();
    }
 
    virtual FReply OnTouchForceChanged( const FGeometry& MyGeometry, const FPointerEvent& InTouchEvent )
    {
        return FReply::Unhandled();
    }
 
    virtual FReply OnTouchFirstMove( const FGeometry& MyGeometry, const FPointerEvent& InTouchEvent )
    {
        return FReply::Unhandled();
    }
 
    virtual FReply OnTouchGesture( const FGeometry& MyGeometry, const FPointerEvent& InGestureEvent )
    {
        return FReply::Unhandled();
    }
    
    virtual FReply OnMotionDetected( const FGeometry& MyGeometry, const FMotionEvent& InMotionEvent )
    {
        return FReply::Unhandled();
    }
 
    virtual TOptional<bool> OnQueryShowFocus(const EFocusCause InFocusCause) const
    {
        return TOptional<bool>();
    }
 
    virtual void OnFinishedPointerInput()
    {
    }
 
    virtual FPopupMethodReply OnQueryPopupMethod() const
    {
        return FPopupMethodReply::Unhandled();
    }
 
    virtual FNavigationReply OnNavigation( const FGeometry& MyGeometry, const FNavigationEvent& InNavigationEvent )
    {
        return FNavigationReply::Stop();
    }
 
    virtual bool HandleNavigation(const uint32 InUserIndex, TSharedPtr<SWidget> InDestination)
    {
        return false;
    }
 
    virtual void OnFocusLost( const FFocusEvent& InFocusEvent )
    {
    }
 
    virtual FReply OnRequestWindowClose()
    {
        return FReply::Unhandled();
    }
 
    virtual void OnViewportClosed()
    {
    }
 
    virtual TWeakPtr<SWidget> GetWidget()
    {
        return nullptr;
    }
 
    virtual FReply OnViewportActivated(const FWindowActivateEvent& InActivateEvent)
    {
        return FReply::Unhandled();
    }
 
    virtual void OnViewportDeactivated(const FWindowActivateEvent& InActivateEvent)
    {
    }
};
 
class ICustomSlateElement
{
public:
    virtual ~ICustomSlateElement() {}
 
    virtual void PostCustomElementAdded(FSlateElementBatcher& ElementBatcher) const {}
 
    struct FDrawPassInputs
    {
        FRDGTexture* OutputTexture = nullptr;
        FIntRect SceneViewRect;
        FMatrix44f ElementsMatrix;
        FVector2f ElementsOffset;
        EDisplayColorGamut HDRDisplayColorGamut = EDisplayColorGamut::sRGB_D65;
        ESlatePostRT UsedSlatePostBuffers = ESlatePostRT::None;
        bool bOutputIsHDRDisplay = false;
        bool bWireFrame = false;
    };
 
    virtual void Draw_RenderThread(FRDGBuilder& GraphBuilder, const FDrawPassInputs& Inputs) {};
 
    // Deprecated API
 
    struct UE_DEPRECATED(5.5, "Use ICustomSlateElement::Draw instead") FSlateCustomDrawParams
    {
        FMatrix44f ViewProjectionMatrix;
        FVector2f ViewOffset;
        FIntRect ViewRect;
        EDisplayColorGamut HDRDisplayColorGamut = EDisplayColorGamut::sRGB_D65;
        ESlatePostRT UsedSlatePostBuffers = ESlatePostRT::None;
        bool bWireFrame = false;
        bool bIsHDR = false;
    };
 
    UE_DEPRECATED(5.4, "Use ICustomSlateElement::Draw instead.")
    virtual void DrawRenderThread(FRHICommandListImmediate& RHICmdList, const void* RenderTarget) {}
 
    UE_DEPRECATED(5.5, "Use ICustomSlateElement::Draw instead.")
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    virtual void Draw_RenderThread(FRHICommandListImmediate& RHICmdList, const void* RenderTarget, const FSlateCustomDrawParams& Params) {}
PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    UE_DEPRECATED(5.5, "Use ICustomSlateElement::Draw instead.")
    virtual bool UsesAdditionalRHIParams() const { return false; }
 
};
 
/*
 * A proxy object used to access a slate per-instance data buffer on the render thread.
 */
class ISlateUpdatableInstanceBufferRenderProxy
{
protected:
    virtual ~ISlateUpdatableInstanceBufferRenderProxy() {};
 
public:
    virtual FRHIBuffer* GetRHI() const = 0;
 
    UE_DEPRECATED(5.5, "Use GetStreamSource instead")
    virtual void BindStreamSource(class FRHICommandList& RHICmdList, int32 StreamIndex, uint32 InstanceOffset) {}
};
 
typedef TArray<FVector4f> FSlateInstanceBufferData;
 
class ISlateUpdatableInstanceBuffer
{
public:
    virtual ~ISlateUpdatableInstanceBuffer() {};
    friend class FSlateInstanceBufferUpdate;
 
    virtual uint32 GetNumInstances() const = 0;
 
    virtual ISlateUpdatableInstanceBufferRenderProxy* GetRenderProxy() const = 0;
 
    virtual void Update(FSlateInstanceBufferData& Data) = 0;
};