Interval.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Templates/IsArithmetic.h"
#include "Templates/UnrealTypeTraits.h"
#include "Math/NumericLimits.h"
#include "Math/UnrealMathUtility.h"
 
template <typename ElementType> struct TIntervalTraits
{
    static_assert(TIsArithmetic<ElementType>::Value, "Incompatible TInterval element type.");
 
    static ElementType Max()
    {
        return TNumericLimits<ElementType>::Max();
    }
 
    static ElementType Lowest()
    {
        return TNumericLimits<ElementType>::Lowest();
    }
};
 
template<typename ElementType> struct TInterval
{
    ElementType Min;
    
    ElementType Max;
        
public:
 
    [[nodiscard]] TInterval()
        : Min(TIntervalTraits<ElementType>::Max())
        , Max(TIntervalTraits<ElementType>::Lowest())
    { }
 
    [[nodiscard]] TInterval( ElementType InMin, ElementType InMax )
        : Min(InMin)
        , Max(InMax)
    { }
 
public:
 
    void operator+= ( ElementType X )
    {
        if (IsValid())
        {
            Min += X;
            Max += X;
        }
    }
 
    void operator-= ( ElementType X )
    {
        if (IsValid())
        {
            Min -= X;
            Max -= X;
        }
    }
 
    [[nodiscard]] bool operator==(const TInterval& Other) const
    {
        return Min == Other.Min && Max == Other.Max;
    }
 
    [[nodiscard]] bool operator!=(const TInterval& Other) const
    {
        return (Min != Other.Min) || (Max != Other.Max);
    }
 
public:
    
    [[nodiscard]] ElementType Size() const
    {
        return (Max - Min);
    }
 
    [[nodiscard]] bool IsValid() const
    {
        return (Min <= Max);
    }
    
    [[nodiscard]] bool Contains( const ElementType& Element ) const
    {
        return IsValid() && (Element >= Min && Element <= Max);
    }
 
    void Expand( ElementType ExpandAmount )
    {
        if (IsValid())
        {
            Min -= ExpandAmount;
            Max += ExpandAmount;
        }
    }
 
    void Include( ElementType X )
    {
        if (!IsValid())
        {
            Min = X;
            Max = X;
        }
        else
        {
            if (X < Min)
            {
                Min = X;
            }
 
            if (X > Max)
            {
                Max = X;
            }
        }
    }
 
    [[nodiscard]] ElementType Interpolate( float Alpha ) const
    {
        if (IsValid())
        {
            return Min + ElementType(Alpha*Size());
        }
        
        return ElementType();
    }
 
    [[nodiscard]] ElementType Clamp( ElementType X ) const
    {
        if (!IsValid())
        {
            return ElementType();
        }
 
        return FMath::Clamp(X, Min, Max);
    }
    
    [[nodiscard]] ElementType GetRangePct(ElementType X) const
    {
        if (!IsValid())
        {
            return ElementType();
        }
 
        return FMath::GetRangePct(Min, Max, X);
    }
public:
 
    [[nodiscard]] friend TInterval Intersect( const TInterval& A, const TInterval& B )
    {
        if (A.IsValid() && B.IsValid())
        {
            return TInterval(FMath::Max(A.Min, B.Min), FMath::Min(A.Max, B.Max));
        }
 
        return TInterval();
    }
 
    friend class FArchive& operator<<( class FArchive& Ar, TInterval& Interval )
    {
        return Ar << Interval.Min << Interval.Max;
    }
    
    friend uint32 GetTypeHash(const TInterval& Interval)
    {
        return HashCombine(GetTypeHash(Interval.Min), GetTypeHash(Interval.Max));
    }
};
 
/* Default intervals for built-in types
 *****************************************************************************/
 
#define DEFINE_INTERVAL_WRAPPER_STRUCT(Name, ElementType) \
    struct Name : TInterval<ElementType> \
    { \
    private: \
        typedef TInterval<ElementType> Super; \
         \
    public:  \
        Name() \
            : Super() \
        { \
        } \
         \
        Name( const Super& Other ) \
            : Super( Other ) \
        { \
        } \
         \
        Name( ElementType InMin, ElementType InMax ) \
            : Super( InMin, InMax ) \
        { \
        } \
         \
        friend Name Intersect( const Name& A, const Name& B ) \
        { \
            return Intersect( static_cast<const Super&>( A ), static_cast<const Super&>( B ) ); \
        } \
    }; \
     \
    template <> \
    struct TIsBitwiseConstructible<Name, TInterval<ElementType>> \
    { \
        enum { Value = true }; \
    }; \
     \
    template <> \
    struct TIsBitwiseConstructible<TInterval<ElementType>, Name> \
    { \
        enum { Value = true }; \
    };
 
DEFINE_INTERVAL_WRAPPER_STRUCT(FFloatInterval, float)
DEFINE_INTERVAL_WRAPPER_STRUCT(FDoubleInterval, double)
DEFINE_INTERVAL_WRAPPER_STRUCT(FInt32Interval, int32)