SlateInvalidationRoot.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/GCObject.h"
#include "WidgetProxy.h"
#include "FastUpdate/SlateInvalidationRootHandle.h"
#include "FastUpdate/SlateInvalidationWidgetIndex.h"
#include "FastUpdate/SlateInvalidationWidgetSortOrder.h"
#include "Rendering/DrawElements.h"
 
struct FSlateCachedElementData;
class FSlateInvalidationWidgetList;
class FSlateInvalidationWidgetPreHeap;
class FSlateInvalidationWidgetPrepassHeap;
class FSlateInvalidationWidgetPostHeap;
class FSlateWindowElementList;
class FWidgetStyle;
 
namespace UE::Slate::Private
{
    struct FSlateInvalidationPaintFastPathContext;
}
 
#define UE_SLATE_DEBUGGING_CLEAR_ALL_FAST_PATH_DATA 0
 
struct FSlateInvalidationContext
{
    FSlateInvalidationContext(FSlateWindowElementList& InWindowElementList, const FWidgetStyle& InWidgetStyle)
        : ViewOffset(0.0f, 0.0f)
        , PaintArgs(nullptr)
        , WidgetStyle(InWidgetStyle)
        , WindowElementList(&InWindowElementList)
        , LayoutScaleMultiplier(1.0f)
        , IncomingLayerId(0)
        , bParentEnabled(true)
        , bAllowFastPathUpdate(false)
    {
    } 
 
    FSlateRect CullingRect;
    UE::Slate::FDeprecateVector2DResult ViewOffset;
    const FPaintArgs* PaintArgs;
    const FWidgetStyle& WidgetStyle;
    FSlateWindowElementList* WindowElementList;
    float LayoutScaleMultiplier;
    int32 IncomingLayerId;
    bool bParentEnabled;
    bool bAllowFastPathUpdate;
};
 
enum class ESlateInvalidationPaintType
{
    None,
    Slow,
    Fast,
};
 
struct FSlateInvalidationResult
{
    FSlateInvalidationResult()
        : ViewOffset(0.0f, 0.0f)
        , MaxLayerIdPainted(0)
        , bRepaintedWidgets(false)
    {}
 
    UE::Slate::FDeprecateVector2DResult ViewOffset;
    int32 MaxLayerIdPainted;
    bool bRepaintedWidgets;
};
 
class FSlateInvalidationRoot : public FGCObject, public FNoncopyable
{
    friend class FSlateUpdateFastWidgetPathTask;
    friend class FSlateUpdateFastPathAndHitTestGridTask;
    friend class FWidgetProxyHandle;
 
public:
    SLATECORE_API FSlateInvalidationRoot();
    SLATECORE_API virtual ~FSlateInvalidationRoot();
 
    //~ Begin FGCObject interface
    SLATECORE_API virtual void AddReferencedObjects(FReferenceCollector& Collector) override;
    SLATECORE_API virtual FString GetReferencerName() const override;
    //~ End FGCObject interface
 
    SLATECORE_API void InvalidateRootChildOrder(const SWidget* Investigator = nullptr);
    SLATECORE_API void InvalidateRootLayout(const SWidget* Investigator = nullptr);
    SLATECORE_API void InvalidateScreenPosition(const SWidget* Investigator = nullptr);
 
    bool NeedsSlowPath() const { return bNeedsSlowPath; }
 
    FHittestGrid* GetHittestGrid() const { return RootHittestGrid; }
    FSlateCachedElementData& GetCachedElements() { return *CachedElementData; }
    const FSlateCachedElementData& GetCachedElements() const { return *CachedElementData; }
    const SWidget* GetInvalidationRootWidget() const { return InvalidationRootWidget; }
    FSlateInvalidationRootHandle GetInvalidationRootHandle() const { return InvalidationRootHandle; }
    const FSlateInvalidationWidgetList& GetFastPathWidgetList() const { return *FastWidgetPathList; }
    SLATECORE_API const TSharedPtr<SWidget> GetFastPathWidgetListRoot() const;
 
    SLATECORE_API FSlateInvalidationResult PaintInvalidationRoot(const FSlateInvalidationContext& Context);
 
    void OnWidgetDestroyed(const SWidget* Widget);
 
    SLATECORE_API void Advanced_ResetInvalidation(bool bClearResourcesImmediately);
 
#if WITH_SLATE_DEBUGGING
    ESlateInvalidationPaintType GetLastPaintType() const { return LastPaintType; }
    void SetLastPaintType(ESlateInvalidationPaintType Value) { LastPaintType = Value; }
 
    struct FPerformanceStat
    {
        double WidgetsPreUpdate = 0.0;
        double WidgetsAttribute = 0.0;
        double WidgetsPrepass = 0.0;
        double WidgetsUpdate = 0.0;
        double InvalidationProcessing = 0.0;
    };
    FPerformanceStat GetPerformanceStat() const { return PerformanceStat; }
#endif
 
protected:
    virtual TSharedRef<SWidget> GetRootWidget() = 0;
    virtual int32 PaintSlowPath(const FSlateInvalidationContext& Context) = 0;
 
    void SetInvalidationRootWidget(SWidget& InInvalidationRootWidget) { InvalidationRootWidget = &InInvalidationRootWidget; }
    void SetInvalidationRootHittestGrid(FHittestGrid& InHittestGrid) { RootHittestGrid = &InHittestGrid; }
    int32 GetCachedMaxLayerId() const { return CachedMaxLayerId; }
 
    SLATECORE_API bool ProcessInvalidation();
 
    SLATECORE_API void ClearAllFastPathData(bool bClearResourcesImmediately);
 
    virtual void OnRootInvalidated() { }
 
    SLATECORE_API void SetNeedsSlowPath(bool InNeedsSlowPath);
 
private:
    FSlateInvalidationWidgetList& GetFastPathWidgetList() { return *FastWidgetPathList; }
    void HandleInvalidateAllWidgets(bool bClearResourcesImmediately);
 
    bool PaintFastPath(const FSlateInvalidationContext& Context);
    bool PaintFastPath_UpdateNextWidget(const FSlateInvalidationContext& Context, UE::Slate::Private::FSlateInvalidationPaintFastPathContext& FastPathContext);
    void PaintFastPath_FixupLayerId(UE::Slate::Private::FSlateInvalidationPaintFastPathContext& FastPathContext, const FWidgetProxy& InvalidationWidget, const int32 NewOutgoingLayerId);
    void PaintFastPath_FixupParentLayerId(UE::Slate::Private::FSlateInvalidationPaintFastPathContext& FastPathContext, const FWidgetProxy& InvalidationWidget, const int32 NewOutgoingLayerId);
    void PaintFastPath_AddUniqueSortedToFinalUpdateList(const FSlateInvalidationWidgetIndex InvalidationWidgetIndex);
 
    void InvalidateWidget(FWidgetProxy& Proxy, EInvalidateWidgetReason InvalidateReason);
 
    void BuildFastPathWidgetList(const TSharedRef<SWidget>& RootWidget);
    void AdjustWidgetsDesktopGeometry(UE::Slate::FDeprecateVector2DParameter WindowToDesktopTransform);
 
    void ProcessPreUpdate();
    void ProcessAttributeUpdate();
    void ProcessPrepassUpdate();
    bool ProcessPostUpdate();
 
private:
    TUniquePtr<FSlateInvalidationWidgetList> FastWidgetPathList;
 
    TUniquePtr<FSlateInvalidationWidgetPreHeap> WidgetsNeedingPreUpdate;
 
    TUniquePtr<FSlateInvalidationWidgetPrepassHeap> WidgetsNeedingPrepassUpdate;
 
    TUniquePtr<FSlateInvalidationWidgetPostHeap> WidgetsNeedingPostUpdate;
 
    TArray<FSlateInvalidationWidgetHeapElement> FinalUpdateList;
 
    FVector2f CachedViewOffset;
 
    FSlateCachedElementData* CachedElementData;
 
    SWidget* InvalidationRootWidget;
 
    FHittestGrid* RootHittestGrid;
 
    int32 CachedMaxLayerId;
 
    FSlateInvalidationRootHandle InvalidationRootHandle;
 
    bool bNeedsSlowPath;
    bool bNeedScreenPositionShift;
    bool bProcessingPreUpdate;
    bool bProcessingAttributeUpdate;
    bool bProcessingPrepassUpdate;
    bool bProcessingPostUpdate;
    bool bBuildingWidgetList;
    bool bProcessingChildOrderInvalidation;
 
#if WITH_SLATE_DEBUGGING
    ESlateInvalidationPaintType LastPaintType;
    FPerformanceStat PerformanceStat;
#endif
#if UE_SLATE_DEBUGGING_CLEAR_ALL_FAST_PATH_DATA
    TArray<const SWidget*> FastWidgetPathToClearedBecauseOfDelay;
#endif
};