RealCurve.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Curves/IndexedCurve.h"
#include "Misc/FrameRate.h"
#include "RealCurve.generated.h"
 
UENUM(BlueprintType)
enum ERichCurveInterpMode : int
{
    RCIM_Linear UMETA(DisplayName = "Linear"),
    RCIM_Constant UMETA(DisplayName = "Constant"),
    RCIM_Cubic UMETA(DisplayName = "Cubic"),
    RCIM_None UMETA(Hidden)
};
 
UENUM(BlueprintType)
enum ERichCurveExtrapolation : int
{
    RCCE_Cycle UMETA(DisplayName = "Cycle"),
    RCCE_CycleWithOffset UMETA(DisplayName = "CycleWithOffset"),
    RCCE_Oscillate UMETA(DisplayName = "Oscillate"),
    RCCE_Linear UMETA(DisplayName = "Linear"),
    RCCE_Constant UMETA(DisplayName = "Constant"),
    RCCE_None UMETA(DisplayName = "None")
};
 
 
struct FCurveAttributes
{
    FCurveAttributes()
    {
        bHasPreExtrapolation  = 0;
        bHasPostExtrapolation = 0;
        PreExtrapolation = ERichCurveExtrapolation::RCCE_None;
        PostExtrapolation = ERichCurveExtrapolation::RCCE_None;
    }
 
    bool HasPreExtrapolation() const  { return bHasPreExtrapolation;  }
    bool HasPostExtrapolation() const { return bHasPostExtrapolation; }
 
    ERichCurveExtrapolation GetPreExtrapolation() const  { check(bHasPreExtrapolation);  return PreExtrapolation;  }
    ERichCurveExtrapolation GetPostExtrapolation() const { check(bHasPostExtrapolation); return PostExtrapolation; }
 
    FCurveAttributes& SetPreExtrapolation(ERichCurveExtrapolation InPreExtrapolation)   { bHasPreExtrapolation = 1;  PreExtrapolation = InPreExtrapolation;   return *this; }
    FCurveAttributes& SetPostExtrapolation(ERichCurveExtrapolation InPostExtrapolation) { bHasPostExtrapolation = 1; PostExtrapolation = InPostExtrapolation; return *this; }
    void UnsetPreExtrapolation()  { bHasPreExtrapolation = 0;  }
    void UnsetPostExtrapolation() { bHasPostExtrapolation = 0; }
 
    static FCurveAttributes MaskCommon(const FCurveAttributes& A, const FCurveAttributes& B)
    {
        FCurveAttributes NewAttributes;
 
        if (A.bHasPreExtrapolation && B.bHasPreExtrapolation && A.PreExtrapolation == B.PreExtrapolation)
        {
            NewAttributes.SetPreExtrapolation(A.PreExtrapolation);
        }
 
        if (A.bHasPostExtrapolation && B.bHasPostExtrapolation && A.PostExtrapolation == B.PostExtrapolation)
        {
            NewAttributes.SetPostExtrapolation(A.PostExtrapolation);
        }
 
        return NewAttributes;
    }
 
    friend bool operator==(const FCurveAttributes& Left, const FCurveAttributes& Right)
    {
        return Left.bHasPreExtrapolation == Right.bHasPreExtrapolation
            && Left.bHasPostExtrapolation == Right.bHasPostExtrapolation
            && (!Left.bHasPreExtrapolation || Left.PreExtrapolation == Right.PreExtrapolation)
            && (!Left.bHasPostExtrapolation || Left.PostExtrapolation == Right.PostExtrapolation);
    }
    friend bool operator!=(const FCurveAttributes& Left, const FCurveAttributes& Right) { return !(Left == Right); }
 
private:
 
    uint8 bHasPreExtrapolation : 1;
    uint8 bHasPostExtrapolation : 1;
 
    ERichCurveExtrapolation PreExtrapolation;
    ERichCurveExtrapolation PostExtrapolation;
};
 
USTRUCT()
struct FRealCurve
    : public FIndexedCurve
{
    GENERATED_USTRUCT_BODY()
 
    FRealCurve() 
        : FIndexedCurve()
        , DefaultValue(MAX_flt)
        , PreInfinityExtrap(RCCE_Constant)
        , PostInfinityExtrap(RCCE_Constant)
    { }
 
public:
 
    bool HasAnyData() const
    {
        return DefaultValue != MAX_flt || GetNumKeys();
    }
 
    virtual FKeyHandle AddKey(float InTime, float InValue, const bool bUnwindRotation = false, FKeyHandle KeyHandle = FKeyHandle()) PURE_VIRTUAL(FRealCurve::AddKey, return FKeyHandle::Invalid(););
 
    virtual void DeleteKey(FKeyHandle KeyHandle) PURE_VIRTUAL(FRealCurve::DeleteKey,);
 
    virtual FKeyHandle UpdateOrAddKey(float InTime, float InValue, const bool bUnwindRotation = false, float KeyTimeTolerance = UE_KINDA_SMALL_NUMBER) PURE_VIRTUAL(FRealCurve::UpdateOrAddKey, return FKeyHandle::Invalid(););
 
    ENGINE_API FKeyHandle FindKey(float KeyTime, float KeyTimeTolerance = UE_KINDA_SMALL_NUMBER) const;
 
    ENGINE_API bool KeyExistsAtTime(float KeyTime, float KeyTimeTolerance = UE_KINDA_SMALL_NUMBER) const;
 
    virtual void SetKeyValue(FKeyHandle KeyHandle, float NewValue, bool bAutoSetTangents = true) PURE_VIRTUAL(FRealCurve::SetKeyValue,);
 
    virtual float GetKeyValue(FKeyHandle KeyHandle) const PURE_VIRTUAL(FRealCurve::GetKeyValue, return 0.f;);
 
    virtual TPair<float, float> GetKeyTimeValuePair(FKeyHandle KeyHandle) const PURE_VIRTUAL(FRealCurve::GetKeyTimeValuePair, return (TPair<float,float>(0.f,0.f)););
 
    virtual void SetKeyInterpMode(FKeyHandle KeyHandle, ERichCurveInterpMode NewInterpMode) PURE_VIRTUAL(FRealCurve::SetKeyInterpMode,);
 
    void SetDefaultValue(float InDefaultValue) { DefaultValue = InDefaultValue; }
 
    float GetDefaultValue() const { return DefaultValue; }
 
    void ClearDefaultValue() { DefaultValue = MAX_flt; }
 
    virtual ERichCurveInterpMode GetKeyInterpMode(FKeyHandle KeyHandle) const PURE_VIRTUAL(FRealCurve::GetTimeRange, return RCIM_None; );
 
    virtual void GetTimeRange(float& MinTime, float& MaxTime) const PURE_VIRTUAL(FRealCurve::GetTimeRange, );
 
    virtual void GetValueRange(float& MinValue, float& MaxValue) const PURE_VIRTUAL(FRealCurve::GetValueRange, );
 
    virtual void Reset() PURE_VIRTUAL(FRealCurve::Reset, );
 
    virtual void RemapTimeValue(float& InTime, float& CycleValueOffset) const PURE_VIRTUAL(FRealCurve::RemapTimeValue, );
 
    virtual float Eval(float InTime, float InDefaultValue = 0.0f) const PURE_VIRTUAL(FRealCurve::Eval, return 0.f;);
 
    virtual void ReadjustTimeRange(float NewMinTimeRange, float NewMaxTimeRange, bool bInsert/* whether insert or remove*/, float OldStartTime, float OldEndTime) PURE_VIRTUAL(FRealCurve::ReadjustTimeRange, );
 
    virtual void BakeCurve(float SampleRate) PURE_VIRTUAL(FRealCurve::BakeCurve, );
    virtual void BakeCurve(float SampleRate, float FirstKeyTime, float LastKeyTime) PURE_VIRTUAL(FRealCurve::BakeCurve, );
 
    virtual void RemoveRedundantKeys(float Tolerance, FFrameRate SampleRate = FFrameRate(0,0)) PURE_VIRTUAL(FRealCurve::RemoveRedundantKeys, );
    virtual void RemoveRedundantKeys(float Tolerance, float FirstKeyTime, float LastKeyTime, FFrameRate SampleRate = FFrameRate(0,0)) PURE_VIRTUAL(FRealCurve::RemoveRedundantKeys, );
 
protected:
    static ENGINE_API void CycleTime(float MinTime, float MaxTime, float& InTime, int& CycleCount);
    virtual int32 GetKeyIndex(float KeyTime, float KeyTimeTolerance) const PURE_VIRTUAL(FRealCurve::GetKeyIndex, return INDEX_NONE;);
 
public:
 
    UPROPERTY(EditAnywhere, Category = "Curve")
    float DefaultValue;
 
    UPROPERTY()
    TEnumAsByte<ERichCurveExtrapolation> PreInfinityExtrap;
 
    UPROPERTY()
    TEnumAsByte<ERichCurveExtrapolation> PostInfinityExtrap;
};
 
template<>
struct TStructOpsTypeTraits<FRealCurve> : public TStructOpsTypeTraitsBase2<FRealCurve>
{
    enum
    {
        WithPureVirtual = true,
    };
};