HittestGrid.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "FastUpdate/SlateInvalidationWidgetSortOrder.h"
#include "Layout/SlateRect.h"
#include "Layout/ArrangedWidget.h"
#include "Layout/Clipping.h"
#include "Input/Events.h"
#include "StructUtils/InstancedStruct.h"
#include "Widgets/SWidget.h"
 
class FArrangedChildren;
struct FNavigationMethod;
 
class ICustomHitTestPath
{
public:
    virtual ~ICustomHitTestPath(){}
 
    virtual TArray<FWidgetAndPointer> GetBubblePathAndVirtualCursors( const FGeometry& InGeometry, FVector2D DesktopSpaceCoordinate, bool bIgnoreEnabledStatus ) const = 0;
 
    virtual void ArrangeCustomHitTestChildren( FArrangedChildren& ArrangedChildren ) const = 0;
 
    virtual TOptional<FVirtualPointerPosition> TranslateMouseCoordinateForCustomHitTestChild(const SWidget& ChildWidget, const FGeometry& MyGeometry, const FVector2D ScreenSpaceMouseCoordinate, const FVector2D LastScreenSpaceMouseCoordinate) const = 0;
};
 
class FHittestGrid : public FNoncopyable
{
    friend struct FNavigationMethod;
    friend struct FNavigationMethodOrthogonal;
    friend struct FNavigationRouting;
 
public:
 
    SLATECORE_API FHittestGrid();
 
    SLATECORE_API TArray<FWidgetAndPointer> GetBubblePath(UE::Slate::FDeprecateVector2DParameter DesktopSpaceCoordinate, float CursorRadius, bool bIgnoreEnabledStatus, int32 UserIndex = INDEX_NONE);
 
    SLATECORE_API bool SetHittestArea(const UE::Slate::FDeprecateVector2DParameter& HittestPositionInDesktop, const UE::Slate::FDeprecateVector2DParameter& HittestDimensions, const UE::Slate::FDeprecateVector2DParameter& HitestOffsetInWindow = FVector2f::ZeroVector);
 
    SLATECORE_API void InsertCustomHitTestPath(const SWidget* InWidget, const TSharedRef<ICustomHitTestPath>& CustomHitTestPath);
 
    void SetUserIndex(int32 UserIndex) { CurrentUserIndex = UserIndex; }
 
    void SetCullingRect(const FSlateRect& InCullingRect) { CullingRect = InCullingRect; }
 
    void SetOwner(const SWidget* InOwner) { check(Owner == nullptr || Owner == InOwner); Owner = InOwner; }
 
    int32 GetUserIndex() const { return CurrentUserIndex; }
 
    SLATECORE_API TSharedPtr<SWidget> FindNextFocusableWidget(const FArrangedWidget& StartingWidget, const EUINavigation Direction, const FNavigationReply& NavigationReply, const FArrangedWidget& RuleWidget, int32 UserIndex);
 
    UE::Slate::FDeprecateVector2DResult GetGridSize() const { return GridSize; }
    UE::Slate::FDeprecateVector2DResult GetGridOrigin() const { return GridOrigin; }
    UE::Slate::FDeprecateVector2DResult GetGridWindowOrigin() const { return GridWindowOrigin; }
 
    SLATECORE_API FSlateRect GetWidgetRenderBoundingRect(const TSharedPtr<SWidget>& Widget) const;
 
    SLATECORE_API bool IsValidCellCoord(const FIntPoint& CellCoord) const;
    SLATECORE_API bool IsValidCellCoord(const int32 XCoord, const int32 YCoord) const;
    
    const FVector2f& GetCellSize() const { return CellSize; }
 
    SLATECORE_API void Clear();
 
    SLATECORE_API void AddWidget(const SWidget* InWidget, int32 InBatchPriorityGroup, int32 InLayerId, FSlateInvalidationWidgetSortOrder InSecondarySort);
 
    SLATECORE_API void RemoveWidget(const SWidget* InWidget);
    
    SLATECORE_API void UpdateWidget(const SWidget* InWidget, FSlateInvalidationWidgetSortOrder InSecondarySort);
 
    SLATECORE_API bool ContainsWidget(const SWidget* InWidget) const;
 
    SLATECORE_API void AddGrid(const TSharedRef<const FHittestGrid>& OtherGrid);
 
    SLATECORE_API void RemoveGrid(const TSharedRef<const FHittestGrid>& OtherGrid);
 
    SLATECORE_API void RemoveGrid(const SWidget* OtherGridOwner);
 
    struct FDebuggingFindNextFocusableWidgetArgs
    {
        struct FWidgetResult
        {
            const TSharedPtr<const SWidget> Widget;
            const FText Result;
            FWidgetResult(const TSharedPtr<const SWidget>& InWidget, FText InResult)
                : Widget(InWidget), Result(InResult) {}
        };
        const FArrangedWidget StartingWidget;
        const EUINavigation Direction;
        const FNavigationReply NavigationReply;
        const FArrangedWidget RuleWidget;
        const int32 UserIndex;
        const TSharedPtr<const SWidget> Result;
        TArray<FWidgetResult> IntermediateResults;
    };
 
#if WITH_SLATE_DEBUGGING
    DECLARE_MULTICAST_DELEGATE_TwoParams(FDebuggingFindNextFocusableWidget, const FHittestGrid* /*HittestGrid*/, const FDebuggingFindNextFocusableWidgetArgs& /*Info*/);
    static SLATECORE_API FDebuggingFindNextFocusableWidget OnFindNextFocusableWidgetExecuted;
 
    SLATECORE_API void LogGrid() const;
 
    enum class EDisplayGridFlags
    {
        None = 0,
        HideDisabledWidgets = 1 << 0,                   // Hide hit box for widgets that have IsEnabled false
        HideUnsupportedKeyboardFocusWidgets = 1 << 1,   // Hide hit box for widgets that have SupportsKeyboardFocus false
        UseFocusBrush = 1 << 2,
    };
    SLATECORE_API void DisplayGrid(int32 InLayer, const FGeometry& AllottedGeometry, FSlateWindowElementList& WindowElementList, EDisplayGridFlags DisplayFlags = EDisplayGridFlags::UseFocusBrush) const;
 
    SLATECORE_API void DisplayNavigation(int32 InLayer, const FGeometry& AllottedGeometry, FSlateWindowElementList& WindowElementList);
 
    struct FWidgetSortData
    {
        const TWeakPtr<SWidget> WeakWidget;
        int64 PrimarySort;
        FSlateInvalidationWidgetSortOrder SecondarySort;
    };
    SLATECORE_API TArray<FWidgetSortData> GetAllWidgetSortDatas() const;
#endif
 
private:
    struct FWidgetData
    {
        FWidgetData(const TWeakPtr<SWidget>& InWidget, const FIntPoint& InUpperLeftCell, const FIntPoint& InLowerRightCell, int64 InPrimarySort, FSlateInvalidationWidgetSortOrder InSecondarySort, int32 InUserIndex)
            : WeakWidget(InWidget)
            , UpperLeftCell(InUpperLeftCell)
            , LowerRightCell(InLowerRightCell)
            , PrimarySort(InPrimarySort)
            , SecondarySort(InSecondarySort)
            , UserIndex(InUserIndex)
        {}
        TWeakPtr<SWidget> WeakWidget;
        TWeakPtr<ICustomHitTestPath> CustomPath;
        FIntPoint UpperLeftCell;
        FIntPoint LowerRightCell;
        int64 PrimarySort;
        FSlateInvalidationWidgetSortOrder SecondarySort;
        int32 UserIndex;
 
        TSharedPtr<SWidget> GetWidget() const { return WeakWidget.Pin(); }
    };
 
    struct FWidgetIndex
    {
        FWidgetIndex()
            : Grid(nullptr)
            , WidgetIndex(INDEX_NONE)
        {}
        FWidgetIndex(const FHittestGrid* InHittestGrid, int32 InIndex)
            : Grid(InHittestGrid)
            , WidgetIndex(InIndex)
        {}
        bool IsValid() const { return Grid != nullptr && Grid->WidgetArray.IsValidIndex(WidgetIndex); }
        const FWidgetData& GetWidgetData() const;
        const FSlateRect& GetCullingRect() const { return Grid->CullingRect; }
        const FHittestGrid* GetGrid() const { return Grid; }
 
    private:
        const FHittestGrid* Grid;
        int32 WidgetIndex;
    };
 
    struct FIndexAndDistance : FWidgetIndex
    {
        FIndexAndDistance()
            : FWidgetIndex()
            , DistanceSqToWidget(0)
        {}
        FIndexAndDistance(FWidgetIndex WidgetIndex, float InDistanceSq)
            : FWidgetIndex(WidgetIndex)
            , DistanceSqToWidget(InDistanceSq)
        {}
        float GetDistanceSqToWidget() const { return DistanceSqToWidget; }
 
    private:
        float DistanceSqToWidget;
    };
 
    struct FGridTestingParams;
 
    struct FCell
    {
    public:
        FCell() = default;
 
        void AddIndex(int32 WidgetIndex);
        void RemoveIndex(int32 WidgetIndex);
        void Reset();
 
        const TArray<int32>& GetWidgetIndexes() const { return WidgetIndexes; }
        
    private:
        TArray<int32> WidgetIndexes;
    };
 
    struct FAppendedGridData
    {
        FAppendedGridData(const SWidget* InCachedOwner, const TWeakPtr<const FHittestGrid>& InGrid)
             : CachedOwner(InCachedOwner), Grid(InGrid)
        { }
        const SWidget* CachedOwner; // Cached owner of the grid
        TWeakPtr<const FHittestGrid> Grid;
    };
 
    //~ Helper functions
    SLATECORE_API void ClearInternal(int32 TotalCells);
 
    SLATECORE_API FIndexAndDistance GetHitIndexFromCellIndex(const FGridTestingParams& Params) const;
 
    SLATECORE_API bool IsDescendantOf(const SWidget* Parent, const FWidgetData& ChildData) const;
 
    template<typename TCompareFunc, typename TSourceSideFunc, typename TDestSideFunc>
    TSharedPtr<SWidget> FindFocusableWidget(const FSlateRect WidgetRect, const FSlateRect SweptRect, int32 AxisIndex, int32 Increment, const EUINavigation Direction, const FNavigationReply& NavigationReply, TCompareFunc CompareFunc, TSourceSideFunc SourceSideFunc, TDestSideFunc DestSideFunc, int32 UserIndex, TArray<FDebuggingFindNextFocusableWidgetArgs::FWidgetResult>* IntermediatedResultPtr, TSet<TSharedPtr<SWidget>>* DisabledDestinations) const;
 
    SLATECORE_API FIntPoint GetCellCoordinate(UE::Slate::FDeprecateVector2DParameter Position) const;
 
    FORCEINLINE FCell& CellAt(const int32 X, const int32 Y)
    {
        checkfSlow((Y*NumCells.X + X) < Cells.Num(), TEXT("HitTestGrid CellAt() failed: X= %d Y= %d NumCells.X= %d NumCells.Y= %d Cells.Num()= %d"), X, Y, NumCells.X, NumCells.Y, Cells.Num());
        return Cells[Y*NumCells.X + X];
    }
 
    FORCEINLINE const FCell& CellAt( const int32 X, const int32 Y ) const
    {
        checkfSlow((Y*NumCells.X + X) < Cells.Num(), TEXT("HitTestGrid CellAt() failed: X= %d Y= %d NumCells.X= %d NumCells.Y= %d Cells.Num()= %d"), X, Y, NumCells.X, NumCells.Y, Cells.Num());
        return Cells[Y*NumCells.X + X];
    }
 
    SLATECORE_API bool CanBeAppended(const FHittestGrid* OtherGrid) const;
 
    SLATECORE_API bool SameSize(const FHittestGrid* OtherGrid) const;
 
    using FCollapsedHittestGridArray = TArray<const FHittestGrid*, TInlineAllocator<16>>;
    SLATECORE_API void GetCollapsedHittestGrid(FCollapsedHittestGridArray& OutResult) const;
 
    using FCollapsedWidgetsArray = TArray<FWidgetIndex, TInlineAllocator<100>>;
    SLATECORE_API void GetCollapsedWidgets(FCollapsedWidgetsArray& Out, const int32 X, const int32 Y) const;
 
    SLATECORE_API void RemoveStaleAppendedHittestGrid();
 
    static constexpr bool IsCompatibleUserIndex(int32 RequestedUserIndex, int32 TestUserIndex)
    {
        // INDEX_NONE means the user index is compatible with all
        return RequestedUserIndex == INDEX_NONE || TestUserIndex == INDEX_NONE|| RequestedUserIndex == TestUserIndex;
    }
 
    TInstancedStruct<FNavigationMethod> GetNavigationMethod(const FArrangedWidget& StartingWidget);
    TSharedPtr<SWidget> FindNextFocusableWidgetDefault(const FArrangedWidget& StartingWidget, const EUINavigation Direction, const FNavigationReply& NavigationReply, const FArrangedWidget& RuleWidget, int32 UserIndex);
    TSharedPtr<SWidget> FindNextFocusableWidgetExperimental(const FArrangedWidget& StartingWidget, const EUINavigation Direction, const FNavigationReply& NavigationReply, const FArrangedWidget& RuleWidget, int32 UserIndex);
 
private:
    TMap<const SWidget*, int32> WidgetMap;
 
    TSparseArray<FWidgetData> WidgetArray;
 
    TArray<FCell> Cells;
 
    TArray<FAppendedGridData> AppendedGridArray;
 
    const SWidget* Owner;
 
    FSlateRect CullingRect;
 
    FIntPoint NumCells;
 
    FVector2f GridOrigin;
 
    FVector2f GridWindowOrigin;
 
    FVector2f GridSize;
 
    int32 CurrentUserIndex;
 
    static const FVector2f CellSize;
 
#if WITH_SLATE_DEBUGGING
    TInstancedStruct<FNavigationMethod> LastNavigationMethod;   
#endif
};
 
#if WITH_SLATE_DEBUGGING
ENUM_CLASS_FLAGS(FHittestGrid::EDisplayGridFlags);
#endif