Clipping.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Layout/SlateRect.h"
#include "Rendering/RenderingCommon.h"
#include "Clipping.generated.h"
 
UENUM(BlueprintType)
enum class EWidgetClipping : uint8
{
    Inherit,
    ClipToBounds,
    ClipToBoundsWithoutIntersecting UMETA(DisplayName = "Clip To Bounds - Without Intersecting (Advanced)"),
    ClipToBoundsAlways UMETA(DisplayName = "Clip To Bounds - Always (Advanced)"),
    OnDemand UMETA(DisplayName = "On Demand (Advanced)")
};
 
 
class FSlateClippingZone
{
public:
 
    FVector2f TopLeft;
    FVector2f TopRight;
    FVector2f BottomLeft;
    FVector2f BottomRight;
 
    SLATECORE_API explicit FSlateClippingZone(const FShortRect& AxisAlignedRect);
    SLATECORE_API explicit FSlateClippingZone(const FSlateRect& AxisAlignedRect);
    SLATECORE_API explicit FSlateClippingZone(const FGeometry& BoundingGeometry);
    SLATECORE_API explicit FSlateClippingZone(const FPaintGeometry& PaintingGeometry);
    SLATECORE_API FSlateClippingZone(const UE::Slate::FDeprecateVector2DParameter& InTopLeft, const UE::Slate::FDeprecateVector2DParameter& InTopRight, const UE::Slate::FDeprecateVector2DParameter& InBottomLeft, const UE::Slate::FDeprecateVector2DParameter& InBottomRight);
    FSlateClippingZone() {}
 
    inline bool GetShouldIntersectParent() const
    {
        return bIntersect;
    }
 
    inline void SetShouldIntersectParent(bool bValue)
    {
        bIntersect = bValue;
    }
 
    inline bool GetAlwaysClip() const
    {
        return bAlwaysClip;
    }
 
    inline void SetAlwaysClip(bool bValue)
    {
        bAlwaysClip = bValue;
    }
 
    inline bool IsAxisAligned() const
    {
        return bIsAxisAligned;
    }
 
    inline bool HasZeroArea() const
    {
        if (bIsAxisAligned)
        {
            FVector2f Difference = TopLeft - BottomRight;
            return FMath::IsNearlyZero(Difference.X) || FMath::IsNearlyZero(Difference.Y);
        }
 
        return false;
    }
 
    SLATECORE_API bool IsPointInside(const UE::Slate::FDeprecateVector2DParameter& Point) const;
 
    SLATECORE_API FSlateClippingZone Intersect(const FSlateClippingZone& Other) const;
 
    SLATECORE_API FSlateRect GetBoundingBox() const;
 
    bool operator==(const FSlateClippingZone& Other) const
    {
        return bIsAxisAligned == Other.bIsAxisAligned &&
            bIntersect == Other.bIntersect &&
            bAlwaysClip == Other.bAlwaysClip &&
            TopLeft == Other.TopLeft &&
            TopRight == Other.TopRight &&
            BottomLeft == Other.BottomLeft &&
            BottomRight == Other.BottomRight;
    }
 
    uint32 ComputeHash() const
    {
        return HashCombine(
            HashCombine(GetTypeHash(TopLeft), GetTypeHash(TopRight)),
            HashCombine(GetTypeHash(BottomLeft), GetTypeHash(BottomRight))
        );
    }
 
    FSlateClippingZone ConvertRelativeToAbsolute(const UE::Slate::FDeprecateVector2DParameter& WindowOffset) const
    {
        FSlateClippingZone Absolute(TopLeft + WindowOffset, TopRight + WindowOffset, BottomLeft + WindowOffset, BottomRight + WindowOffset);
        Absolute.bIsAxisAligned = bIsAxisAligned;
        Absolute.bIntersect = bIntersect;
        Absolute.bAlwaysClip = bAlwaysClip;
 
        return Absolute;
    }
private:
    SLATECORE_API void InitializeFromArbitraryPoints(const UE::Slate::FDeprecateVector2DParameter& InTopLeft, const UE::Slate::FDeprecateVector2DParameter& InTopRight, const UE::Slate::FDeprecateVector2DParameter& InBottomLeft, const UE::Slate::FDeprecateVector2DParameter& InBottomRight);
 
private:
    uint8 bIsAxisAligned : 1;
    uint8 bIntersect : 1;
    uint8 bAlwaysClip : 1;
 
    friend inline uint32 GetTypeHash(const FSlateClippingZone& Zone)
    {
        return Zone.ComputeHash();
    }
};
 
template<> struct TIsPODType<FSlateClippingZone> { enum { Value = true }; };
 
enum class EClippingMethod : uint8
{
    Scissor,
    Stencil
};
 
enum class EClippingFlags : uint8
{
    None        = 0,
    AlwaysClip  = 1 << 0
};
 
ENUM_CLASS_FLAGS(EClippingFlags)
 
 
class FSlateClippingState
{
public:
    SLATECORE_API FSlateClippingState(EClippingFlags InFlags = EClippingFlags::None);
    
    SLATECORE_API bool IsPointInside(const UE::Slate::FDeprecateVector2DParameter& Point) const;
 
#if WITH_SLATE_DEBUGGING
    inline void SetDebuggingStateIndex(int32 InStateIndex) const
    {
        Debugging_StateIndex = InStateIndex;
        Debugging_StateIndexFromFrame = GFrameNumber;
    }
#endif
 
    inline bool GetAlwaysClip() const { return EnumHasAllFlags(Flags, EClippingFlags::AlwaysClip); }
 
    inline bool GetShouldIntersectParent() const
    {
        if (GetClippingMethod() == EClippingMethod::Scissor)
        {
            return ScissorRect->GetShouldIntersectParent();
        }
        else
        {
            for (const FSlateClippingZone& Stencil : StencilQuads)
            {
                if (!Stencil.GetShouldIntersectParent())
                {
                    return false;
                }
            }
        }
 
        return true;
    }
 
    inline EClippingMethod GetClippingMethod() const
    {
        return ScissorRect.IsSet() ? EClippingMethod::Scissor : EClippingMethod::Stencil;
    }
 
    inline bool HasZeroArea() const
    {
        if (ScissorRect.IsSet())
        {
            return ScissorRect->HasZeroArea();
        }
 
        // Assume that stenciled clipping state has some area, don't bother computing it.
        return false;
    }
 
    bool operator==(const FSlateClippingState& Other) const
    {
        return Flags == Other.Flags &&
            ScissorRect == Other.ScissorRect &&
            StencilQuads == Other.StencilQuads;
    }
 
public:
    TArray<FSlateClippingZone> StencilQuads;
 
    TOptional<FSlateClippingZone> ScissorRect;
 
private:
 
    EClippingFlags Flags;
 
#if WITH_SLATE_DEBUGGING
    mutable int32 Debugging_StateIndex;
    mutable int32 Debugging_StateIndexFromFrame;
#endif
};
 
struct FClipStateHandle
{
public:
    FClipStateHandle()
        : CachedClipState(nullptr)
        , PrecachedClipIndex(INDEX_NONE)
    {}
 
    int32 GetPrecachedClipIndex() const { return PrecachedClipIndex; }
    const FSlateClippingState* GetCachedClipState() const { return CachedClipState; }
 
    bool operator==(const FClipStateHandle& Other) const
    {
        return CachedClipState == Other.CachedClipState && PrecachedClipIndex == Other.PrecachedClipIndex;
    }
 
    void SetPreCachedClipIndex(int32 InClipIndex)
    {
        PrecachedClipIndex = InClipIndex;
    }
 
    void SetCachedClipState(const FSlateClippingState* CachedState)
    {
        CachedClipState = CachedState;
        PrecachedClipIndex = INDEX_NONE;
    }
private:
    const FSlateClippingState* CachedClipState;
    int32 PrecachedClipIndex;
 
};
 
 
class FSlateCachedClipState
{
public:
    FSlateCachedClipState(const FSlateClippingState& InState)
        : ClippingState(MakeShared<FSlateClippingState, ESPMode::ThreadSafe>(InState))
    {}
 
    TSharedRef<FSlateClippingState, ESPMode::ThreadSafe> ClippingState;
};
 
 
class FSlateClippingManager
{
public:
    SLATECORE_API FSlateClippingManager();
 
    SLATECORE_API int32 PushClip(const FSlateClippingZone& InClippingZone);
    SLATECORE_API int32 PushClippingState(const FSlateClippingState& InClipState);
    SLATECORE_API int32 GetClippingIndex() const;
    SLATECORE_API TOptional<FSlateClippingState> GetActiveClippingState() const;
    const TArray<int32>& GetClippingStack() const { return ClippingStack; }
    SLATECORE_API const TArray<FSlateClippingState>& GetClippingStates() const;
    SLATECORE_API void PopClip();
    SLATECORE_API void PopToStackIndex(int32 Index);
    int32 GetClippingIndexAtStackIndex(int32 StackIndex) const { return ClippingStack.IsValidIndex(StackIndex) ? ClippingStack[StackIndex] : INDEX_NONE; }
    int32 GetStackDepth() const { return ClippingStack.Num(); }
    SLATECORE_API const FSlateClippingState* GetPreviousClippingState(bool bWillIntersectWithParent) const;
 
    SLATECORE_API void ResetClippingState();
 
private:
 
    SLATECORE_API FSlateClippingState CreateClippingState(const FSlateClippingZone& InClipRect) const;
 
private:
    TArray< int32 > ClippingStack;
 
    TArray< FSlateClippingState > ClippingStates;
};