Geometry.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "Layout/Margin.h"
#include "Layout/PaintGeometry.h"
#include "Layout/SlateRect.h"
#include "Layout/SlateRotatedRect.h"
#include "Layout/SlateRotatedRect.h"
#include "Math/TransformCalculus.h"
#include "Math/TransformCalculus2D.h"
#include "Math/UnrealMathSSE.h"
#include "Math/Vector2D.h"
#include "Rendering/SlateLayoutTransform.h"
#include "Rendering/SlateRenderTransform.h"
#include "Templates/SharedPointer.h"
#include "UObject/ObjectMacros.h"
#include "Types/SlateVector2.h"
 
#include "Geometry.generated.h"
 
class FArrangedWidget;
class FLayoutGeometry;
class SWidget;
template <typename T> struct TIsPODType;
 
USTRUCT(BlueprintType)
struct FGeometry
{
    GENERATED_USTRUCT_BODY()
 
public:
 
    SLATECORE_API FGeometry();
 
    FGeometry(const FGeometry& RHS) = default;
 
    SLATECORE_API FGeometry& operator=(const FGeometry& RHS);
 
    FGeometry( const UE::Slate::FDeprecateVector2DParameter& OffsetFromParent, const UE::Slate::FDeprecateVector2DParameter& ParentAbsolutePosition, const UE::Slate::FDeprecateVector2DParameter& InLocalSize, float InScale )
        : Size(InLocalSize)
        , Scale(1.0f)
        , AbsolutePosition(0.0f, 0.0f)
        , bHasRenderTransform(false)
    {
        // Since OffsetFromParent is given as a LocalSpaceOffset, we MUST convert this offset into the space of the parent to construct a valid layout transform.
        // The extra TransformPoint below does this by converting the local offset to an offset in parent space.
        FVector2f LayoutOffset = TransformPoint(InScale, UE::Slate::CastToVector2f(OffsetFromParent));
 
        FSlateLayoutTransform ParentAccumulatedLayoutTransform(InScale, UE::Slate::CastToVector2f(ParentAbsolutePosition));
        FSlateLayoutTransform LocalLayoutTransform(LayoutOffset);
        FSlateLayoutTransform AccumulatedLayoutTransform = Concatenate(LocalLayoutTransform, ParentAccumulatedLayoutTransform);
        AccumulatedRenderTransform = TransformCast<FSlateRenderTransform>(AccumulatedLayoutTransform);
        // HACK to allow us to make FGeometry public members immutable to catch misuse.
        const_cast<FVector2f&>( AbsolutePosition ) = FVector2f(AccumulatedLayoutTransform.GetTranslation());
        const_cast<float&>( Scale ) = AccumulatedLayoutTransform.GetScale();
        const_cast<FVector2f&>( Position ) = FVector2f(LocalLayoutTransform.GetTranslation());
    }
 
private:
    FGeometry( 
        const UE::Slate::FDeprecateVector2DParameter& InLocalSize, 
        const FSlateLayoutTransform& InLocalLayoutTransform, 
        const FSlateRenderTransform& InLocalRenderTransform, 
        const UE::Slate::FDeprecateVector2DParameter& InLocalRenderTransformPivot, 
        const FSlateLayoutTransform& ParentAccumulatedLayoutTransform, 
        const FSlateRenderTransform& ParentAccumulatedRenderTransform)
        : Size(InLocalSize)
        , Scale(1.0f)
        , AbsolutePosition(0.0f, 0.0f)
        , AccumulatedRenderTransform(
            Concatenate(
                // convert the pivot to local space and make it the origin
                Inverse(TransformPoint(FScale2D(UE::Slate::CastToVector2f(InLocalSize)), UE::Slate::CastToVector2f(InLocalRenderTransformPivot))),
                // apply the render transform in local space centered around the pivot
                InLocalRenderTransform,
                // translate the pivot point back.
                TransformPoint(FScale2D(UE::Slate::CastToVector2f(InLocalSize)), UE::Slate::CastToVector2f(InLocalRenderTransformPivot)),
                // apply the layout transform next.
                InLocalLayoutTransform,
                // finally apply the parent accumulated transform, which takes us to the root.
                ParentAccumulatedRenderTransform
            )
        ), bHasRenderTransform(true)
    {
        FSlateLayoutTransform AccumulatedLayoutTransform = Concatenate(InLocalLayoutTransform, ParentAccumulatedLayoutTransform);
        // HACK to allow us to make FGeometry public members immutable to catch misuse.
        const_cast<FVector2f&>( AbsolutePosition ) = FVector2f(AccumulatedLayoutTransform.GetTranslation());
        const_cast<float&>( Scale ) = AccumulatedLayoutTransform.GetScale();
        const_cast<FVector2f&>( Position ) = FVector2f(InLocalLayoutTransform.GetTranslation());
    }
 
    FGeometry(
        const UE::Slate::FDeprecateVector2DParameter& InLocalSize,
        const FSlateLayoutTransform& InLocalLayoutTransform,
        const FSlateLayoutTransform& ParentAccumulatedLayoutTransform,
        const FSlateRenderTransform& ParentAccumulatedRenderTransform,
        bool bParentHasRenderTransform)
        : Size(UE::Slate::CastToVector2f(InLocalSize))
        , Scale(1.0f)
        , AbsolutePosition(0.0f, 0.0f)
        , AccumulatedRenderTransform(Concatenate(InLocalLayoutTransform, ParentAccumulatedRenderTransform))
        , bHasRenderTransform(bParentHasRenderTransform)
    {
        FSlateLayoutTransform AccumulatedLayoutTransform = Concatenate(InLocalLayoutTransform, ParentAccumulatedLayoutTransform);
        // HACK to allow us to make FGeometry public members immutable to catch misuse.
        const_cast<FVector2f&>( AbsolutePosition ) = FVector2f(AccumulatedLayoutTransform.GetTranslation());
        const_cast<float&>( Scale ) = AccumulatedLayoutTransform.GetScale();
        const_cast<FVector2f&>( Position ) = FVector2f(InLocalLayoutTransform.GetTranslation());
    }
 
public:
 
    bool operator==( const FGeometry& Other ) const
    {
        return
            this->Size == Other.Size && 
            this->AbsolutePosition == Other.AbsolutePosition &&
            this->Position == Other.Position &&
            this->Scale == Other.Scale;
    }
    
    bool operator!=( const FGeometry& Other ) const
    {
        return !( this->operator==(Other) );
    }
 
public:
    inline static FGeometry MakeRoot(const UE::Slate::FDeprecateVector2DParameter& InLocalSize, const FSlateLayoutTransform& LayoutTransform)
    {
        return FGeometry(InLocalSize, LayoutTransform, FSlateLayoutTransform(), FSlateRenderTransform(), false);
    }
    inline static FGeometry MakeRoot(const UE::Slate::FDeprecateVector2DParameter& InLocalSize, const FSlateLayoutTransform& LayoutTransform, const FSlateRenderTransform& RenderTransform)
    {
        return FGeometry(InLocalSize, LayoutTransform, FSlateLayoutTransform(), FSlateRenderTransform(), !RenderTransform.IsIdentity());
    }
    inline FGeometry MakeChild(const UE::Slate::FDeprecateVector2DParameter& InLocalSize, const FSlateLayoutTransform& LayoutTransform, const FSlateRenderTransform& RenderTransform, const UE::Slate::FDeprecateVector2DParameter& RenderTransformPivot) const
    {
        return FGeometry(InLocalSize, LayoutTransform, RenderTransform, RenderTransformPivot, GetAccumulatedLayoutTransform(), GetAccumulatedRenderTransform());
    }
 
    FORCEINLINE_DEBUGGABLE FGeometry MakeChild(const UE::Slate::FDeprecateVector2DParameter& InLocalSize, const FSlateLayoutTransform& LayoutTransform) const
    {
        return FGeometry(InLocalSize, LayoutTransform, GetAccumulatedLayoutTransform(), GetAccumulatedRenderTransform(), bHasRenderTransform);
    }
    FORCEINLINE_DEBUGGABLE FGeometry MakeChild(const FSlateRenderTransform& RenderTransform, const UE::Slate::FDeprecateVector2DParameter& RenderTransformPivot = FVector2f(0.5f, 0.5f)) const
    {
        return FGeometry(GetLocalSize(), FSlateLayoutTransform(), RenderTransform, RenderTransformPivot, GetAccumulatedLayoutTransform(), GetAccumulatedRenderTransform());
    }
 
 
    FArrangedWidget MakeChild(const TSharedRef<SWidget>& ChildWidget, const FLayoutGeometry& LayoutGeometry) const;
 
    FArrangedWidget MakeChild(const TSharedRef<SWidget>& ChildWidget, const UE::Slate::FDeprecateVector2DParameter& InLocalSize, const FSlateLayoutTransform& LayoutTransform) const;
 
#if UE_ENABLE_SLATE_VECTOR_DEPRECATION_MECHANISMS
 
    UE_DEPRECATED(5.2, "Use FGeometry MakeChild(const FVector2f& InLocalSize, const FSlateLayoutTransform& InLayoutTransform) instead.")
    inline FGeometry MakeChild(const FVector2D& ChildOffset, const FVector2D& InLocalSize, float ChildScale = 1.0f) const
    {
        // Since ChildOffset is given as a LocalSpaceOffset, we MUST convert this offset into the space of the parent to construct a valid layout transform.
        // The extra TransformPoint below does this by converting the local offset to an offset in parent space.
        return FGeometry(UE::Slate::CastToVector2f(InLocalSize), FSlateLayoutTransform(ChildScale, TransformPoint(ChildScale, UE::Slate::CastToVector2f(ChildOffset))), GetAccumulatedLayoutTransform(), GetAccumulatedRenderTransform(), bHasRenderTransform);
    }
 
#endif
 
    FArrangedWidget MakeChild(const TSharedRef<SWidget>& ChildWidget, const UE::Slate::FDeprecateVector2DParameter& ChildOffset, const UE::Slate::FDeprecateVector2DParameter& InLocalSize, float ChildScale = 1.0f) const;
 
    FORCEINLINE_DEBUGGABLE FPaintGeometry ToPaintGeometry() const
    {
        return FPaintGeometry(GetAccumulatedLayoutTransform(), GetAccumulatedRenderTransform(), FVector2f(Size), bHasRenderTransform);
    }
 
    FORCEINLINE_DEBUGGABLE FPaintGeometry ToPaintGeometry(const UE::Slate::FDeprecateVector2DParameter& InLocalSize, const FSlateLayoutTransform& InLayoutTransform) const
    {
        FSlateLayoutTransform NewAccumulatedLayoutTransform = Concatenate(InLayoutTransform, GetAccumulatedLayoutTransform());
        return FPaintGeometry(NewAccumulatedLayoutTransform, Concatenate(InLayoutTransform, GetAccumulatedRenderTransform()), UE::Slate::CastToVector2f(InLocalSize), bHasRenderTransform);
    }
 
    FORCEINLINE_DEBUGGABLE FPaintGeometry ToPaintGeometry(const UE::Slate::FDeprecateVector2DParameter& InLocalSize, const FSlateLayoutTransform& InLayoutTransform, const FSlateRenderTransform& RenderTransform, const UE::Slate::FDeprecateVector2DParameter& RenderTransformPivot = FVector2f(0.5f, 0.5f)) const
    {
        return MakeChild(InLocalSize, InLayoutTransform, RenderTransform, RenderTransformPivot).ToPaintGeometry();
    }
 
    FORCEINLINE_DEBUGGABLE FPaintGeometry ToPaintGeometry(const FSlateLayoutTransform& LayoutTransform) const
    {
        return ToPaintGeometry(FVector2f(Size), LayoutTransform);
    }
 
#if UE_ENABLE_SLATE_VECTOR_DEPRECATION_MECHANISMS
 
    UE_DEPRECATED(5.2, "Use FPaintGeometry ToPaintGeometry(const FVector2f& InLocalSize, const FSlateLayoutTransform& InLayoutTransform) instead.")
    FORCEINLINE_DEBUGGABLE FPaintGeometry ToPaintGeometry(const UE::Slate::FDeprecateVector2DParameter& InLocalOffset, const UE::Slate::FDeprecateVector2DParameter& InLocalSize, float InLocalScale = 1.0f) const
    {
        // Since ChildOffset is given as a LocalSpaceOffset, we MUST convert this offset into the space of the parent to construct a valid layout transform.
        // The extra TransformPoint below does this by converting the local offset to an offset in parent space.
        return ToPaintGeometry(InLocalSize, FSlateLayoutTransform(InLocalScale, TransformPoint(InLocalScale, UE::Slate::CastToVector2f(InLocalOffset))));
    }
 
#endif
 
    inline FPaintGeometry ToOffsetPaintGeometry(const UE::Slate::FDeprecateVector2DParameter& LocalOffset) const
    {
        return ToPaintGeometry(FSlateLayoutTransform(UE::Slate::CastToVector2f(LocalOffset)));
    }
 
    inline FPaintGeometry ToInflatedPaintGeometry(const UE::Slate::FDeprecateVector2DParameter& InflateAmount) const
    {
        FVector2f InflateAmount2f = UE::Slate::CastToVector2f(InflateAmount);
        // This essentially adds (or subtracts) a border around the widget. We scale the size then offset by the border amount.
        // Note this is not scaling child widgets, so the scale is not changing.
        FVector2f NewSize = FVector2f(Size) + InflateAmount2f* 2;
        return ToPaintGeometry(NewSize, FSlateLayoutTransform(-InflateAmount2f));
    }
 
    inline bool IsUnderLocation(const UE::Slate::FDeprecateVector2DParameter& AbsoluteCoordinate) const
    {
        // this render transform invert is a little expensive. We might consider caching it?
        FSlateRotatedRect Rect = TransformRect(GetAccumulatedRenderTransform(), FSlateRotatedRect(FSlateRect(FVector2f(0.0f, 0.0f), FVector2f(Size))));
        return Rect.IsUnderLocation(AbsoluteCoordinate);
    }
 
    FORCEINLINE_DEBUGGABLE UE::Slate::FDeprecateVector2DResult AbsoluteToLocal(UE::Slate::FDeprecateVector2DParameter AbsoluteCoordinate) const
    {
        // this render transform invert is a little expensive. We might consider caching it.
        return UE::Slate::FDeprecateVector2DResult(TransformPoint(Inverse(GetAccumulatedRenderTransform()), UE::Slate::CastToVector2f(AbsoluteCoordinate)));
    }
 
    inline UE::Slate::FDeprecateVector2DResult LocalToAbsolute(UE::Slate::FDeprecateVector2DParameter LocalCoordinate) const
    {
        return UE::Slate::FDeprecateVector2DResult(TransformPoint(GetAccumulatedRenderTransform(), UE::Slate::CastToVector2f(LocalCoordinate)));
    }
 
    inline UE::Slate::FDeprecateVector2DResult LocalToRoundedLocal(UE::Slate::FDeprecateVector2DParameter LocalCoordinate) const
    {
        const FVector2f AbsoluteCoordinate = LocalToAbsolute(UE::Slate::CastToVector2f(LocalCoordinate));
        const FVector2f AbsoluteCoordinateRounded = FVector2f(FMath::RoundToFloat(AbsoluteCoordinate.X), FMath::RoundToFloat(AbsoluteCoordinate.Y));
 
        return AbsoluteToLocal(AbsoluteCoordinateRounded);
    }
    
    FORCEINLINE_DEBUGGABLE FSlateRect GetLayoutBoundingRect() const
    {
        return GetLayoutBoundingRect(FSlateRect(FVector2f(0.0f, 0.0f), FVector2f(Size)));
    }
 
    FORCEINLINE_DEBUGGABLE FSlateRect GetLayoutBoundingRect(const FMargin& LocalSpaceExtendBy) const
    {
        return GetLayoutBoundingRect(FSlateRect(FVector2f::ZeroVector, FVector2f(Size)).ExtendBy(LocalSpaceExtendBy));
    }
 
    FORCEINLINE_DEBUGGABLE FSlateRect GetLayoutBoundingRect(const FSlateRect& LocalSpaceRect) const
    {
        return TransformRect(GetAccumulatedLayoutTransform(), FSlateRotatedRect(LocalSpaceRect)).ToBoundingRect();
    }
 
    FORCEINLINE_DEBUGGABLE FSlateRect GetRenderBoundingRect() const
    {
        return GetRenderBoundingRect(FSlateRect(FVector2f(0.0f, 0.0f), FVector2f(Size)));
    }
 
    FORCEINLINE_DEBUGGABLE FSlateRect GetRenderBoundingRect(const FMargin& LocalSpaceExtendBy) const
    {
        return GetRenderBoundingRect(FSlateRect(FVector2f::ZeroVector, FVector2f(Size)).ExtendBy(LocalSpaceExtendBy));
    }
 
    FORCEINLINE_DEBUGGABLE FSlateRect GetRenderBoundingRect(const FSlateRect& LocalSpaceRect) const
    {
        return TransformRect(GetAccumulatedRenderTransform(), FSlateRotatedRect(LocalSpaceRect)).ToBoundingRect();
    }
    
    SLATECORE_API FString ToString() const;
 
    inline UE::Slate::FDeprecateVector2DResult GetDrawSize() const
    {
        return UE::Slate::FDeprecateVector2DResult(TransformVector(GetAccumulatedLayoutTransform(), FVector2f(Size)));
    }
 
    inline UE::Slate::FDeprecateVector2DResult GetLocalSize() const { return Size; }
 
    inline const FSlateRenderTransform& GetAccumulatedRenderTransform() const { return AccumulatedRenderTransform; }
 
    inline FSlateLayoutTransform GetAccumulatedLayoutTransform() const
    {
        return FSlateLayoutTransform(Scale, AbsolutePosition);
    }
 
    FORCEINLINE_DEBUGGABLE void AppendTransform(const FSlateLayoutTransform& LayoutTransform)
    {
        FSlateLayoutTransform AccumulatedLayoutTransform = ::Concatenate(GetAccumulatedLayoutTransform(), LayoutTransform);
        AccumulatedRenderTransform = ::Concatenate(AccumulatedRenderTransform, LayoutTransform);
        const_cast<FVector2f&>( AbsolutePosition ) = FVector2f(AccumulatedLayoutTransform.GetTranslation());
        const_cast<float&>( Scale ) = AccumulatedLayoutTransform.GetScale();
    }
 
    inline UE::Slate::FDeprecateVector2DResult GetAbsolutePosition() const
    {
        return UE::Slate::FDeprecateVector2DResult(AccumulatedRenderTransform.TransformPoint(FVector2f::ZeroVector));
    }
 
    inline UE::Slate::FDeprecateVector2DResult GetAbsoluteSize() const
    {
        return UE::Slate::FDeprecateVector2DResult(AccumulatedRenderTransform.TransformVector(FVector2f(GetLocalSize())));
    }
 
    inline UE::Slate::FDeprecateVector2DResult GetAbsolutePositionAtCoordinates(const UE::Slate::FDeprecateVector2DParameter& NormalCoordinates) const
    {
        return UE::Slate::FDeprecateVector2DResult(AccumulatedRenderTransform.TransformPoint(FVector2f(NormalCoordinates) * FVector2f(GetLocalSize())));
    }
 
    inline UE::Slate::FDeprecateVector2DResult GetLocalPositionAtCoordinates(const UE::Slate::FDeprecateVector2DParameter& NormalCoordinates) const
    {
        return UE::Slate::FDeprecateVector2DResult(Position + (FVector2f(NormalCoordinates) * GetLocalSize()));
    }
 
    bool HasRenderTransform() const { return bHasRenderTransform; }
 
public:
    const FDeprecateSlateVector2D /*Local*/Size;
 
    const float /*Absolute*/Scale;
 
    const FVector2f AbsolutePosition = FVector2f::ZeroVector;   
 
    const FVector2f /*Local*/Position = FVector2f::ZeroVector;
 
private:
 
    FSlateRenderTransform AccumulatedRenderTransform;
 
    const uint8 bHasRenderTransform : 1;
};
 
 
template <> struct TIsPODType<FGeometry> { enum { Value = true }; };