DrawElements.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Rendering/DrawElementCoreTypes.h"
#include "Rendering/DrawElementTypes.h"
#include "Rendering/DrawElementPayloads.h"
#include "Tasks/Task.h"
 
class FSlateRenderBatch;
class FSlateDrawLayerHandle;
class FSlateResourceHandle;
class FSlateWindowElementList;
class SWidget;
class SWindow;
struct FSlateBrush;
struct FSlateDataPayload;
struct FSlateGradientStop;
 
struct FSlateCachedFastPathRenderingData
{
    ~FSlateCachedFastPathRenderingData()
    {
        CachedClipStates.Reset();
    }
 
    TArray<FSlateCachedClipState, TInlineAllocator<1>> CachedClipStates;
    FSlateVertexArray Vertices;
    FSlateIndexArray Indices;
};
 
struct FSlateCachedElementData;
 
struct FSlateCachedElementList
{
    FSlateCachedElementList(FSlateCachedElementData* InParentData, const SWidget* InWidget)
        : OwningWidget(InWidget)
        , ParentData(InParentData)
        , CachedRenderingData(nullptr)
    {
    }
 
    void Initialize()
    {
        CachedRenderingData = new FSlateCachedFastPathRenderingData;
    }
 
    SLATECORE_API ~FSlateCachedElementList();
 
    void ClearCachedElements();
 
    FSlateCachedElementData* GetOwningData() { return ParentData; }
 
    FSlateRenderBatch& AddRenderBatch(int32 InLayer, const FShaderParams& InShaderParams, const FSlateShaderResource* InResource, ESlateDrawPrimitive InPrimitiveType, ESlateShader InShaderType, ESlateDrawEffect InDrawEffects, ESlateBatchDrawFlag InDrawFlags, int8 SceneIndex);
 
    void AddCachedClipState(FSlateCachedClipState& ClipStateToCache);
 
    void AddReferencedObjects(FReferenceCollector& Collector);
 
    SLATECORE_API bool IsEmpty();
 
    SLATECORE_API int32 NumElements();
private:
    SLATECORE_API void DestroyCachedData();
 
public:
    FSlateDrawElementMap DrawElements;
 
    TArray<int32> CachedRenderBatchIndices;
 
    const SWidget* OwningWidget;
 
    FSlateCachedElementData* ParentData;
 
    FSlateCachedFastPathRenderingData* CachedRenderingData;
};
 
 
struct FSlateCachedElementsHandle
{
    friend struct FSlateCachedElementData;
 
    static FSlateCachedElementsHandle Invalid;
    void ClearCachedElements();
    void RemoveFromCache();
 
    bool IsOwnedByWidget(const SWidget* Widget) const;
 
    bool IsValid() const { return Ptr.IsValid(); }
    bool HasCachedElements() const;
 
    bool operator!=(FSlateCachedElementsHandle& Other) const { return Ptr != Other.Ptr; }
 
    FSlateCachedElementsHandle() {}
private:
    FSlateCachedElementsHandle(TSharedRef<FSlateCachedElementList>& DataPtr)
        : Ptr(DataPtr)
    {
    }
 
private:
    TWeakPtr<FSlateCachedElementList> Ptr;
};
 
struct FSlateCachedElementData
{
    friend class FSlateElementBatcher;
    friend struct FSlateCachedElementsHandle;
 
    void Empty();
 
    FSlateCachedElementsHandle AddCache(const SWidget* Widget);
 
    static const FSlateClippingState* GetClipStateFromParent(const FSlateClippingManager& ParentClipManager);
 
    SLATECORE_API void ValidateWidgetOwner(TSharedPtr<FSlateCachedElementList> List, const SWidget* CurrentWidget);
 
    template<EElementType ElementType>
    TSlateDrawElement<ElementType>& AddCachedElement(FSlateCachedElementsHandle& CacheHandle, const FSlateClippingManager& ParentClipManager, const SWidget* CurrentWidget)
    {
        using FSlateElementType = TSlateDrawElement<ElementType>;
 
        TSharedPtr<FSlateCachedElementList> List = CacheHandle.Ptr.Pin(); 
 
#if WITH_SLATE_DEBUGGING
        ValidateWidgetOwner(List, CurrentWidget);
#endif
 
        FSlateDrawElementArray<FSlateElementType>& Container = List->DrawElements.Get<(uint8)ElementType>();
        FSlateElementType& NewElement = Container.AddDefaulted_GetRef();
        NewElement.SetIsCached(true);
 
        // Check if slow vs checking a flag on the list to see if it contains new data.
        ListsWithNewData.AddUnique(List.Get());
 
        const FSlateClippingState* ExistingClipState = FSlateCachedElementData::GetClipStateFromParent(ParentClipManager);
 
        if (ExistingClipState)
        {
            // We need to cache this clip state for the next time the element draws
            FSlateCachedClipState& CachedClipState = FindOrAddCachedClipState(ExistingClipState);
            List->AddCachedClipState(CachedClipState);
            NewElement.SetCachedClippingState(&CachedClipState.ClippingState.Get());
        }
 
        return NewElement;
    }
 
    FSlateRenderBatch& AddCachedRenderBatch(FSlateRenderBatch&& NewBatch, int32& OutIndex);
    void RemoveCachedRenderBatches(const TArray<int32>& CachedRenderBatchIndices);
 
    FSlateCachedClipState& FindOrAddCachedClipState(const FSlateClippingState* RefClipState);
    void CleanupUnusedClipStates();
 
    const TSparseArray<FSlateRenderBatch>& GetCachedBatches() const { return CachedBatches; }
    const TArray<TSharedPtr<FSlateCachedElementList>>& GetCachedElementLists() const { return CachedElementLists; }
 
    void AddReferencedObjects(FReferenceCollector& Collector);
 
    TArrayView<FSlateCachedElementList* const> GetListsWithNewData() const { return MakeArrayView(ListsWithNewData.GetData(), ListsWithNewData.Num()); }
private:
    void RemoveList(FSlateCachedElementsHandle& CacheHandle);
 
private:
 
    TSparseArray<FSlateRenderBatch> CachedBatches;
 
    TArray<TSharedPtr<FSlateCachedElementList>> CachedElementLists;
 
    TArray<FSlateCachedElementList*, TInlineAllocator<50>> ListsWithNewData;
 
    TArray<FSlateCachedClipState> CachedClipStates;
};
 
class FSlateWindowElementList : public FNoncopyable
{
    friend class FSlateElementBatcher;
public:
    SLATECORE_API explicit FSlateWindowElementList(const TSharedPtr<SWindow>& InPaintWindow);
 
    SLATECORE_API ~FSlateWindowElementList();
 
    SWindow* GetPaintWindow() const
    {
        check(IsInGameThread() || IsInSlateThread());
        return WeakPaintWindow.IsValid() ? RawPaintWindow : nullptr;
    }
 
    SWindow* GetRenderWindow() const
    {
        check(IsInGameThread() || IsInSlateThread());
        // Note: This assumes that the PaintWindow is safe to pin and is not accessed by another thread
        return RenderTargetWindow != nullptr ? RenderTargetWindow : GetPaintWindow();
    }
 
    const FSlateDrawElementMap& GetUncachedDrawElements() const
    {
        return UncachedDrawElements;
    }
 
    UE::Slate::FDeprecateVector2DResult GetWindowSize() const
    {
        return UE::Slate::FDeprecateVector2DResult(WindowSize);
    }
    
    template<EElementType ElementType = EElementType::ET_NonMapped>
    TSlateDrawElement<ElementType>& AddUninitialized()
    {
        using FSlateElementType = TSlateDrawElement<ElementType>;
 
        const bool bAllowCache = CachedElementDataListStack.Num() > 0 && WidgetDrawStack.Num() && !WidgetDrawStack.Top().bIsVolatile;
 
        if (bAllowCache)
        {
            // @todo get working with slate debugging
            return AddCachedElement<ElementType>();
        }
        else
        {
            FSlateDrawElementMap& Elements = UncachedDrawElements;
            FSlateDrawElementArray<FSlateElementType>& Container = Elements.Get<(uint8)ElementType>();
            const int32 InsertIdx = Container.AddDefaulted();
 
#if WITH_SLATE_DEBUGGING
            FSlateDebuggingElementTypeAddedEventArgs ElementTypeAddedArgs{*this, InsertIdx, ElementType};
            FSlateDebugging::ElementTypeAdded.Broadcast(ElementTypeAddedArgs);
#endif
 
            FSlateElementType& NewElement = Container[InsertIdx];
            return NewElement;
        }
    }
 
    SLATECORE_API FSlateDrawElement& AddUninitializedLookup(EElementType InElementType = EElementType::ET_NonMapped);
 
 
    //--------------------------------------------------------------------------
    // CLIPPING
    //--------------------------------------------------------------------------
 
    SLATECORE_API int32 PushClip(const FSlateClippingZone& InClipZone);
    SLATECORE_API int32 GetClippingIndex() const;
    int32 GetClippingStackDepth() const { return ClippingManager.GetStackDepth(); }
    SLATECORE_API TOptional<FSlateClippingState> GetClippingState() const;
    SLATECORE_API void PopClip();
    SLATECORE_API void PopClipToStackIndex(int32 Index);
 
 
    FSlateClippingManager& GetClippingManager() { return ClippingManager; }
    const FSlateClippingManager& GetClippingManager() const { return ClippingManager; }
 
    //--------------------------------------------------------------------------
    // PIXEL SNAPPING
    //--------------------------------------------------------------------------
 
    SLATECORE_API int32 PushPixelSnappingMethod(EWidgetPixelSnapping InPixelSnappingMethod);
    SLATECORE_API void PopPixelSnappingMethod();
    SLATECORE_API EWidgetPixelSnapping GetPixelSnappingMethod() const;
    
    //--------------------------------------------------------------------------
    // DEFERRED PAINTING
    //--------------------------------------------------------------------------
 
    struct FDeferredPaint
    {
    public:
        SLATECORE_API FDeferredPaint(const TSharedRef<const SWidget>& InWidgetToPaint, const FPaintArgs& InArgs, const FGeometry InAllottedGeometry, const FWidgetStyle& InWidgetStyle, bool InParentEnabled);
 
        SLATECORE_API int32 ExecutePaint(int32 LayerId, FSlateWindowElementList& OutDrawElements, const FSlateRect& MyCullingRect) const;
 
        SLATECORE_API FDeferredPaint Copy(const FPaintArgs& InArgs);
 
    private:
        // Used for making copies.
        FDeferredPaint(const FDeferredPaint& Copy, const FPaintArgs& InArgs);
 
        const TWeakPtr<const SWidget> WidgetToPaintPtr;
        const FPaintArgs Args;
        const FGeometry AllottedGeometry;
        const FWidgetStyle WidgetStyle;
        const bool bParentEnabled;
    };
 
    SLATECORE_API void QueueDeferredPainting(const FDeferredPaint& InDeferredPaint);
 
    int32 PaintDeferred(int32 LayerId, const FSlateRect& MyCullingRect);
 
    bool ShouldResolveDeferred() const { return bNeedsDeferredResolve; }
 
    SLATECORE_API void BeginDeferredGroup();
    SLATECORE_API void EndDeferredGroup();
 
    TArray< TSharedPtr<FDeferredPaint> > GetDeferredPaintList() const { return DeferredPaintList; }
 
 
    //--------------------------------------------------------------------------
    // FAST PATH
    //--------------------------------------------------------------------------
 
    SLATECORE_API void PushPaintingWidget(const SWidget& CurrentWidget, int32 StartingLayerId, FSlateCachedElementsHandle& CurrentCacheHandle);
 
    SLATECORE_API FSlateCachedElementsHandle PopPaintingWidget(const SWidget& CurrentWidget);
 
    void PushCachedElementData(FSlateCachedElementData& CachedElementData);
    void PopCachedElementData();
 
    //--------------------------------------------------------------------------
    // OTHER
    //--------------------------------------------------------------------------
    
    SLATECORE_API void ResetElementList();
 
 
    FSlateBatchData& GetBatchData()
    {
        FinishMergeRenderBatches();
        return BatchData;
    }
 
    FSlateBatchData& GetBatchDataHDR()
    {
        FinishMergeRenderBatches();
        return BatchDataHDR;
    }
 
    SLATECORE_API void SetRenderTargetWindow(SWindow* InRenderTargetWindow);
 
    void AddReferencedObjects(FReferenceCollector& Collector);
    
    SLATECORE_API void SetIsInGameLayer(bool bInGameLayer);
    SLATECORE_API bool GetIsInGameLayer();
 
    TArrayView<FSlateCachedElementList* const> GetCurrentCachedElementWithNewData() const
    { 
        if (GetCurrentCachedElementData() != nullptr)
        {
            return CachedElementDataList[CachedElementDataListStack.Top()]->GetListsWithNewData();
        }
        else
        {
            return TArrayView<FSlateCachedElementList* const>();
        }
    }
private:
    template<EElementType ElementType>
    TSlateDrawElement<ElementType>& AddCachedElement()
    {
        FSlateCachedElementData* CurrentCachedElementData = GetCurrentCachedElementData();
        check(CurrentCachedElementData);
 
        FWidgetDrawElementState& CurrentWidgetState = WidgetDrawStack.Top();
        check(!CurrentWidgetState.bIsVolatile);
 
        if (!CurrentWidgetState.CacheHandle.IsValid())
        {
            CurrentWidgetState.CacheHandle = CurrentCachedElementData->AddCache(CurrentWidgetState.Widget);
        }
 
        return CurrentCachedElementData->AddCachedElement<ElementType>(CurrentWidgetState.CacheHandle, GetClippingManager(), CurrentWidgetState.Widget);
    }
 
    TArrayView<FSlateCachedElementData* const> GetCachedElementDataList() const { return MakeArrayView(CachedElementDataList.GetData(), CachedElementDataList.Num()); }
 
    FSlateCachedElementData* GetCurrentCachedElementData() const { return CachedElementDataListStack.Num() ? CachedElementDataList[CachedElementDataListStack.Top()] : nullptr; }
 
    SLATECORE_API void StartMergeRenderBatches();
    SLATECORE_API void FinishMergeRenderBatches();
 
private:
    TWeakPtr<SWindow> WeakPaintWindow;
    SWindow* RawPaintWindow;
 
    FMemStackBase MemManager;
    STAT(int32 MemManagerAllocatedMemory;)
    SWindow* RenderTargetWindow;
 
    FSlateBatchData BatchData;
 
    FSlateBatchData BatchDataHDR;
 
    UE::Tasks::FTask MergeBatchDataTask;
 
    FSlateClippingManager ClippingManager;
 
    TArray<EWidgetPixelSnapping, TInlineAllocator<4>> PixelSnappingMethodStack;
    
    TArray< TSharedPtr<FDeferredPaint> > DeferredPaintList;
 
    bool bNeedsDeferredResolve;
    TArray<int32> ResolveToDeferredIndex;
 
    // Begin Fast Path
 
    struct FWidgetDrawElementState
    {
        FWidgetDrawElementState(FSlateCachedElementsHandle& InCurrentHandle, bool bInIsVolatile, const SWidget* InWidget)
            : CacheHandle(InCurrentHandle)
            , Widget(InWidget)
            , bIsVolatile(bInIsVolatile)
        {
        }
 
        FSlateCachedElementsHandle CacheHandle;
        const SWidget* Widget;
        bool bIsVolatile;
    };
 
    FSlateDrawElementMap UncachedDrawElements;
 
    TArray<FWidgetDrawElementState, TInlineAllocator<50>> WidgetDrawStack;
    TArray<FSlateCachedElementData*, TInlineAllocator<4>> CachedElementDataList;
    TArray<int32, TInlineAllocator<4>> CachedElementDataListStack;
    // End Fast Path
 
    FVector2f WindowSize;
 
    bool bIsInGameLayer;
};