InterpCurvePoint.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "HAL/UnrealMemory.h"
#include "Math/UnrealMathUtility.h"
#include "Math/Color.h"
#include "Math/Vector2D.h"
#include "Containers/EnumAsByte.h"
#include "Math/Vector.h"
#include "Math/Quat.h"
#include "Math/TwoVectors.h"
 
enum EInterpCurveMode
{
    CIM_Linear,
 
    CIM_CurveAuto,
 
    CIM_Constant,
 
    CIM_CurveUser,
 
    CIM_CurveBreak,
 
    CIM_CurveAutoClamped,
 
    CIM_Unknown
};
 
 
template< class T > class FInterpCurvePoint
{
public:
 
    float InVal;
 
    T OutVal;
 
    T ArriveTangent; 
 
    T LeaveTangent; 
 
    TEnumAsByte<EInterpCurveMode> InterpMode; 
 
public:
 
    [[nodiscard]] FInterpCurvePoint() = default;
 
    [[nodiscard]] FInterpCurvePoint( const float In, const T &Out );
 
    [[nodiscard]] FInterpCurvePoint( const float In, const T &Out, const T &InArriveTangent, const T &InLeaveTangent, const EInterpCurveMode InInterpMode );
 
    [[nodiscard]] explicit UE_FORCEINLINE_HINT FInterpCurvePoint(EForceInit);
 
public:
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsCurveKey() const;
 
public:
 
    friend FArchive& operator<<( FArchive& Ar, FInterpCurvePoint& Point )
    {
        Ar << Point.InVal << Point.OutVal;
        Ar << Point.ArriveTangent << Point.LeaveTangent;
        Ar << Point.InterpMode;
        return Ar;
    }
 
    [[nodiscard]] friend bool operator==( const FInterpCurvePoint& Point1, const FInterpCurvePoint& Point2 )
    {
        return (Point1.InVal == Point2.InVal &&
                Point1.OutVal == Point2.OutVal &&
                Point1.ArriveTangent == Point2.ArriveTangent &&
                Point1.LeaveTangent == Point2.LeaveTangent &&
                Point1.InterpMode == Point2.InterpMode);
    }
 
    [[nodiscard]] friend bool operator!=(const FInterpCurvePoint& Point1, const FInterpCurvePoint& Point2)
    {
        return !(Point1 == Point2);
    }
};
 
 
/* FInterpCurvePoint inline functions
 *****************************************************************************/
 
template< class T > 
inline FInterpCurvePoint<T>::FInterpCurvePoint( const float In, const T &Out )
    : InVal(In)
    , OutVal(Out)
{
    FMemory::Memset( &ArriveTangent, 0, sizeof(T) );    
    FMemory::Memset( &LeaveTangent, 0, sizeof(T) );
 
    InterpMode = CIM_Linear;
}
 
 
template< class T > 
inline FInterpCurvePoint<T>::FInterpCurvePoint( const float In, const T &Out, const T &InArriveTangent, const T &InLeaveTangent, const EInterpCurveMode InInterpMode)
    : InVal(In)
    , OutVal(Out)
    , ArriveTangent(InArriveTangent)
    , LeaveTangent(InLeaveTangent)
    , InterpMode(InInterpMode)
{ }
 
template< class T >
inline FInterpCurvePoint<T>::FInterpCurvePoint(EForceInit)
{
    InVal = 0.0f;
    FMemory::Memset(&OutVal, 0, sizeof(T));
    FMemory::Memset(&ArriveTangent, 0, sizeof(T));
    FMemory::Memset(&LeaveTangent, 0, sizeof(T));
    InterpMode = CIM_Linear;
}
 
template< class T > 
UE_FORCEINLINE_HINT bool FInterpCurvePoint<T>::IsCurveKey() const
{
    return ((InterpMode == CIM_CurveAuto) || (InterpMode == CIM_CurveAutoClamped) || (InterpMode == CIM_CurveUser) || (InterpMode == CIM_CurveBreak));
}
 
CORE_API float ClampFloatTangent( float PrevPointVal, float PrevTime, float CurPointVal, float CurTime, float NextPointVal, float NextTime );
 
 
template< class T, class U > 
inline void AutoCalcTangent( const T& PrevP, const T& P, const T& NextP, const U& Tension, T& OutTan )
{
    OutTan = (1.f - Tension) * ( (P - PrevP) + (NextP - P) );
}
 
 
template< class U > 
inline void AutoCalcTangent( const FQuat& PrevP, const FQuat& P, const FQuat& NextP, const U& Tension, FQuat& OutTan  )
{
    FQuat::CalcTangents(PrevP, P, NextP, Tension, OutTan);
}
 
 
template< class T >
inline void ComputeCurveTangent( float PrevTime, const T& PrevPoint,
                            float CurTime, const T& CurPoint,
                            float NextTime, const T& NextPoint,
                            float Tension,
                            bool bWantClamping,
                            T& OutTangent )
{
    // NOTE: Clamping not supported for non-float vector types (bWantClamping is ignored)
 
    AutoCalcTangent( PrevPoint, CurPoint, NextPoint, Tension, OutTangent );
 
    const float PrevToNextTimeDiff = FMath::Max< float >( UE_KINDA_SMALL_NUMBER, NextTime - PrevTime );
 
    OutTangent /= PrevToNextTimeDiff;
}
 
 
template< class T >
inline void ComputeClampableFloatVectorCurveTangent( float PrevTime, const T& PrevPoint,
                                                float CurTime, const T& CurPoint,
                                                float NextTime, const T& NextPoint,
                                                float Tension,
                                                bool bWantClamping,
                                                T& OutTangent )
{
    // Clamp the tangents if we need to do that
    if( bWantClamping )
    {
        // NOTE: We always treat the type as an array of floats
        float* PrevPointVal = ( float* )&PrevPoint;
        float* CurPointVal = ( float* )&CurPoint;
        float* NextPointVal = ( float* )&NextPoint;
        float* OutTangentVal = ( float* )&OutTangent;
        for( int32 CurValPos = 0; CurValPos < sizeof( T ); CurValPos += sizeof( float ) )
        {
            // Clamp it!
            const float ClampedTangent =
                ClampFloatTangent(
                    *PrevPointVal, PrevTime,
                    *CurPointVal, CurTime,
                    *NextPointVal, NextTime );
 
            // Apply tension value
            *OutTangentVal = ( 1.0f - Tension ) * ClampedTangent;
 
 
            // Advance pointers
            ++OutTangentVal;
            ++PrevPointVal;
            ++CurPointVal;
            ++NextPointVal;
        }
    }
    else
    {
        // No clamping needed
        AutoCalcTangent( PrevPoint, CurPoint, NextPoint, Tension, OutTangent );
 
        const float PrevToNextTimeDiff = FMath::Max< float >( UE_KINDA_SMALL_NUMBER, NextTime - PrevTime );
 
        OutTangent /= PrevToNextTimeDiff;
    }
}
 
 
inline void ComputeCurveTangent( float PrevTime, const float& PrevPoint,
                                    float CurTime, const float& CurPoint,
                                    float NextTime, const float& NextPoint,
                                    float Tension,
                                    bool bWantClamping,
                                    float& OutTangent )
{
    ComputeClampableFloatVectorCurveTangent(
        PrevTime, PrevPoint,
        CurTime, CurPoint,
        NextTime, NextPoint,
        Tension, bWantClamping, OutTangent );
}
 
 
inline void ComputeCurveTangent( float PrevTime, const FVector& PrevPoint,
                                    float CurTime, const FVector& CurPoint,
                                    float NextTime, const FVector& NextPoint,
                                    float Tension,
                                    bool bWantClamping,
                                    FVector& OutTangent )
{
    ComputeClampableFloatVectorCurveTangent(
        PrevTime, PrevPoint,
        CurTime, CurPoint,
        NextTime, NextPoint,
        Tension, bWantClamping, OutTangent );
}
 
 
inline void ComputeCurveTangent( float PrevTime, const FVector2D& PrevPoint,
                                    float CurTime, const FVector2D& CurPoint,
                                    float NextTime, const FVector2D& NextPoint,
                                    float Tension,
                                    bool bWantClamping,
                                    FVector2D& OutTangent )
{
    ComputeClampableFloatVectorCurveTangent(
        PrevTime, PrevPoint,
        CurTime, CurPoint,
        NextTime, NextPoint,
        Tension, bWantClamping, OutTangent );
}
 
 
inline void ComputeCurveTangent( float PrevTime, const FTwoVectors& PrevPoint,
                                    float CurTime, const FTwoVectors& CurPoint,
                                    float NextTime, const FTwoVectors& NextPoint,
                                    float Tension,
                                    bool bWantClamping,
                                    FTwoVectors& OutTangent )
{
    ComputeClampableFloatVectorCurveTangent(
        PrevTime, PrevPoint,
        CurTime, CurPoint,
        NextTime, NextPoint,
        Tension, bWantClamping, OutTangent );
}
 
void CORE_API CurveFloatFindIntervalBounds( const FInterpCurvePoint<float>& Start, const FInterpCurvePoint<float>& End, float& CurrentMin, float& CurrentMax );
 
 
void CORE_API CurveVector2DFindIntervalBounds( const FInterpCurvePoint<FVector2D>& Start, const FInterpCurvePoint<FVector2D>& End, FVector2D& CurrentMin, FVector2D& CurrentMax );
 
 
void CORE_API CurveVectorFindIntervalBounds( const FInterpCurvePoint<FVector>& Start, const FInterpCurvePoint<FVector>& End, FVector& CurrentMin, FVector& CurrentMax );
 
 
void CORE_API CurveTwoVectorsFindIntervalBounds(const FInterpCurvePoint<FTwoVectors>& Start, const FInterpCurvePoint<FTwoVectors>& End, FTwoVectors& CurrentMin, FTwoVectors& CurrentMax);
 
 
void CORE_API CurveLinearColorFindIntervalBounds( const FInterpCurvePoint<FLinearColor>& Start, const FInterpCurvePoint<FLinearColor>& End, FLinearColor& CurrentMin, FLinearColor& CurrentMax );
 
 
template< class T, class U > 
inline void CurveFindIntervalBounds( const FInterpCurvePoint<T>& Start, const FInterpCurvePoint<T>& End, T& CurrentMin, T& CurrentMax, const U& Dummy )
{ }
 
 
template< class U > 
inline void CurveFindIntervalBounds( const FInterpCurvePoint<float>& Start, const FInterpCurvePoint<float>& End, float& CurrentMin, float& CurrentMax, const U& Dummy )
{
    CurveFloatFindIntervalBounds(Start, End, CurrentMin, CurrentMax);
}
 
 
template< class U > 
void CurveFindIntervalBounds( const FInterpCurvePoint<FVector2D>& Start, const FInterpCurvePoint<FVector2D>& End, FVector2D& CurrentMin, FVector2D& CurrentMax, const U& Dummy )
{
    CurveVector2DFindIntervalBounds(Start, End, CurrentMin, CurrentMax);
}
 
 
template< class U > 
inline void CurveFindIntervalBounds( const FInterpCurvePoint<FVector>& Start, const FInterpCurvePoint<FVector>& End, FVector& CurrentMin, FVector& CurrentMax, const U& Dummy )
{
    CurveVectorFindIntervalBounds(Start, End, CurrentMin, CurrentMax);
}
 
 
template< class U > 
inline void CurveFindIntervalBounds( const FInterpCurvePoint<FTwoVectors>& Start, const FInterpCurvePoint<FTwoVectors>& End, FTwoVectors& CurrentMin, FTwoVectors& CurrentMax, const U& Dummy )
{
    CurveTwoVectorsFindIntervalBounds(Start, End, CurrentMin, CurrentMax);
}
 
 
template< class U > 
inline void CurveFindIntervalBounds( const FInterpCurvePoint<FLinearColor>& Start, const FInterpCurvePoint<FLinearColor>& End, FLinearColor& CurrentMin, FLinearColor& CurrentMax, const U& Dummy )
{
    CurveLinearColorFindIntervalBounds(Start, End, CurrentMin, CurrentMax);
}
 
// Native implementation of NOEXPORT FInterpCurvePoint structures
typedef FInterpCurvePoint<float> FInterpCurvePointFloat;
typedef FInterpCurvePoint<FVector2D> FInterpCurvePointVector2D;
typedef FInterpCurvePoint<FVector> FInterpCurvePointVector;
typedef FInterpCurvePoint<FQuat> FInterpCurvePointQuat;
typedef FInterpCurvePoint<FTwoVectors> FInterpCurvePointTwoVectors;
typedef FInterpCurvePoint<FLinearColor> FInterpCurvePointLinearColor;