RichCurve.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 "UObject/Class.h"
#include "Curves/KeyHandle.h"
#include "Curves/RealCurve.h"
#include "Chaos/Curve.h"
#include "RichCurve.generated.h"
 
UENUM(BlueprintType)
enum ERichCurveTangentMode : int
{
    RCTM_Auto UMETA(DisplayName="Auto"),
    RCTM_User UMETA(DisplayName="User"),
    RCTM_Break UMETA(DisplayName="Break"),
    RCTM_None UMETA(Hidden),
    RCTM_SmartAuto UMETA(DisplayName = "Smart Auto"),
};
 
 
UENUM(BlueprintType)
enum ERichCurveTangentWeightMode : int
{
    RCTWM_WeightedNone UMETA(DisplayName="None"),
    RCTWM_WeightedArrive UMETA(DisplayName="Arrive"),
    RCTWM_WeightedLeave UMETA(DisplayName="Leave"),
    RCTWM_WeightedBoth UMETA(DisplayName="Both")
};
 
UENUM()
enum ERichCurveCompressionFormat : int
{
    RCCF_Empty UMETA(DisplayName = "Empty"),
 
    RCCF_Constant UMETA(DisplayName = "Constant"),
 
    RCCF_Linear UMETA(DisplayName = "Linear"),
 
    RCCF_Cubic UMETA(DisplayName = "Cubic"),
 
    RCCF_Mixed UMETA(DisplayName = "Mixed"),
 
    RCCF_Weighted UMETA(DisplayName = "Weighted"),
};
 
UENUM()
enum ERichCurveKeyTimeCompressionFormat : int
{
    RCKTCF_uint16 UMETA(DisplayName = "uint16"),
 
    RCKTCF_float32 UMETA(DisplayName = "float32"),
};
 
USTRUCT(BlueprintType)
struct FRichCurveKey
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Key")
    TEnumAsByte<ERichCurveInterpMode> InterpMode;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Key")
    TEnumAsByte<ERichCurveTangentMode> TangentMode;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Key")
    TEnumAsByte<ERichCurveTangentWeightMode> TangentWeightMode;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Key")
    float Time;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Key")
    float Value;
 
    UPROPERTY()
    float ArriveTangent;
 
    UPROPERTY()
    float ArriveTangentWeight;
 
    UPROPERTY()
    float LeaveTangent;
 
    UPROPERTY()
    float LeaveTangentWeight;
 
    FRichCurveKey()
        : InterpMode(RCIM_Linear)
        , TangentMode(RCTM_Auto)
        , TangentWeightMode(RCTWM_WeightedNone)
        , Time(0.f)
        , Value(0.f)
        , ArriveTangent(0.f)
        , ArriveTangentWeight(0.f)
        , LeaveTangent(0.f)
        , LeaveTangentWeight(0.f)
    { }
 
    FRichCurveKey(float InTime, float InValue)
        : InterpMode(RCIM_Linear)
        , TangentMode(RCTM_Auto)
        , TangentWeightMode(RCTWM_WeightedNone)
        , Time(InTime)
        , Value(InValue)
        , ArriveTangent(0.f)
        , ArriveTangentWeight(0.f)
        , LeaveTangent(0.f)
        , LeaveTangentWeight(0.f)
    { }
 
    FRichCurveKey(float InTime, float InValue, float InArriveTangent, const float InLeaveTangent, ERichCurveInterpMode InInterpMode)
        : InterpMode(InInterpMode)
        , TangentMode(RCTM_Auto)
        , TangentWeightMode(RCTWM_WeightedNone)
        , Time(InTime)
        , Value(InValue)
        , ArriveTangent(InArriveTangent)
        , ArriveTangentWeight(0.f)
        , LeaveTangent(InLeaveTangent)
        , LeaveTangentWeight(0.f)
    { }
 
    ENGINE_API FRichCurveKey(const FInterpCurvePoint<float>& InPoint);
    ENGINE_API FRichCurveKey(const FInterpCurvePoint<FVector2D>& InPoint, int32 ComponentIndex);
    ENGINE_API FRichCurveKey(const FInterpCurvePoint<FVector>& InPoint, int32 ComponentIndex);
    ENGINE_API FRichCurveKey(const FInterpCurvePoint<FTwoVectors>& InPoint, int32 ComponentIndex);
 
    ENGINE_API bool Serialize(FArchive& Ar);
    ENGINE_API bool operator==(const FRichCurveKey& Other) const;
    ENGINE_API bool operator!=(const FRichCurveKey& Other) const;
 
    friend FArchive& operator<<(FArchive& Ar, FRichCurveKey& P)
    {
        P.Serialize(Ar);
        return Ar;
    }
};
 
 
template<>
struct TIsPODType<FRichCurveKey>
{
    enum { Value = true };
};
 
 
template<>
struct TStructOpsTypeTraits<FRichCurveKey>
    : public TStructOpsTypeTraitsBase2<FRichCurveKey>
{
    enum
    {
        WithSerializer = true,
        WithCopy = false,
        WithIdenticalViaEquality = true,
    };
    static constexpr EPropertyObjectReferenceType WithSerializerObjectReferences = EPropertyObjectReferenceType::None;
};
 
 
USTRUCT()
struct FRichCurve
    : public FRealCurve
{
    GENERATED_USTRUCT_BODY()
 
public:
 
    ENGINE_API TArray<FRichCurveKey> GetCopyOfKeys() const;
 
    ENGINE_API const TArray<FRichCurveKey>& GetConstRefOfKeys() const;
 
    ENGINE_API TArray<FRichCurveKey>::TConstIterator GetKeyIterator() const;
    
    ENGINE_API FRichCurveKey& GetKey(FKeyHandle KeyHandle);
    ENGINE_API FRichCurveKey GetKey(FKeyHandle KeyHandle) const;
    ENGINE_API const FRichCurveKey& GetKeyRef(FKeyHandle KeyHandle) const;
    
    ENGINE_API FRichCurveKey GetFirstKey() const;
    ENGINE_API FRichCurveKey GetLastKey() const;
 
    ENGINE_API FRichCurveKey* GetFirstMatchingKey(const TArray<FKeyHandle>& KeyHandles);
 
    ENGINE_API virtual FKeyHandle AddKey(float InTime, float InValue, const bool bUnwindRotation = false, FKeyHandle KeyHandle = FKeyHandle()) final override;
 
    ENGINE_API void ReserveKeys(const int32 Number);
 
    ENGINE_API void SetKeys(const TArray<FRichCurveKey>& InKeys);
 
    ENGINE_API void DeleteKey(FKeyHandle KeyHandle) final override;
 
    ENGINE_API virtual FKeyHandle UpdateOrAddKey(float InTime, float InValue, const bool bUnwindRotation = false, float KeyTimeTolerance = UE_KINDA_SMALL_NUMBER) final override;
 
    ENGINE_API virtual void SetKeyTime(FKeyHandle KeyHandle, float NewTime) final override;
 
    ENGINE_API virtual float GetKeyTime(FKeyHandle KeyHandle) const final override;
 
    ENGINE_API virtual void SetKeyValue(FKeyHandle KeyHandle, float NewValue, bool bAutoSetTangents = true) final override;
 
    ENGINE_API virtual float GetKeyValue(FKeyHandle KeyHandle) const final override;
 
    ENGINE_API virtual TPair<float, float> GetKeyTimeValuePair(FKeyHandle KeyHandle) const final override;
 
    ENGINE_API bool IsConstant(float Tolerance = UE_SMALL_NUMBER) const;
 
    bool IsEmpty() const { return Keys.Num() == 0; }
 
    ENGINE_API virtual void SetKeyInterpMode(FKeyHandle KeyHandle, ERichCurveInterpMode NewInterpMode) final override;
    ENGINE_API void SetKeyInterpMode(FKeyHandle KeyHandle, ERichCurveInterpMode NewInterpMode, bool bAutoSetTangents);
 
    ENGINE_API void SetKeyTangentMode(FKeyHandle KeyHandle, ERichCurveTangentMode NewTangentMode, bool bAutoSetTangents = true);
 
    ENGINE_API void SetKeyTangentWeightMode(FKeyHandle KeyHandle, ERichCurveTangentWeightMode NewTangentWeightMode, bool bAutoSetTangents = true);
 
    ENGINE_API virtual ERichCurveInterpMode GetKeyInterpMode(FKeyHandle KeyHandle) const final override;
 
    ENGINE_API ERichCurveTangentMode GetKeyTangentMode(FKeyHandle KeyHandle) const;
 
    ENGINE_API virtual void GetTimeRange(float& MinTime, float& MaxTime) const final override;
 
    ENGINE_API virtual void GetValueRange(float& MinValue, float& MaxValue) const final override;
 
    ENGINE_API virtual void Reset() final override;
 
    ENGINE_API virtual void RemapTimeValue(float& InTime, float& CycleValueOffset) const final override;
 
    ENGINE_API virtual float Eval(float InTime, float InDefaultValue = 0.0f) const final override;
 
    ENGINE_API void AutoSetTangents(float Tension = 0.f);
 
    ENGINE_API virtual void ReadjustTimeRange(float NewMinTimeRange, float NewMaxTimeRange, bool bInsert/* whether insert or remove*/, float OldStartTime, float OldEndTime) final override;
 
    ENGINE_API bool operator == (const FRichCurve& Curve) const;
 
    ENGINE_API virtual void BakeCurve(float SampleRate) final override;
    ENGINE_API virtual void BakeCurve(float SampleRate, float FirstKeyTime, float LastKeyTime) final override;
 
    ENGINE_API void RemoveRedundantAutoTangentKeys(float Tolerance);
    ENGINE_API virtual void RemoveRedundantKeys(float Tolerance, FFrameRate SampleRate) final override;
 
    ENGINE_API void RemoveRedundantAutoTangentKeys(float Tolerance, float FirstKeyTime, float LastKeyTime);
    ENGINE_API virtual void RemoveRedundantKeys(float Tolerance, float FirstKeyTime, float LastKeyTime, FFrameRate SampleRate) final override;
 
    ENGINE_API void CompressCurve(struct FCompressedRichCurve& OutCurve, float ErrorThreshold = 0.0001f, float SampleRate = 120.0) const;
 
    virtual FIndexedCurve* Duplicate() const final { return new FRichCurve(*this); }
 
    ENGINE_API void ConvertToChaosCurve(Chaos::FLinearCurve& OutCurve) const;
 
private:
    ENGINE_API void RemoveRedundantKeysInternal(float Tolerance, int32 InStartKeepKey, int32 InEndKeepKey, FFrameRate SampleRate);
    ENGINE_API virtual int32 GetKeyIndex(float KeyTime, float KeyTimeTolerance) const override final;
 
public:
 
    // FIndexedCurve interface
 
    virtual int32 GetNumKeys() const final override { return Keys.Num(); }
 
public:
 
    UPROPERTY(EditAnywhere, EditFixedSize, Category="Curve", meta=(EditFixedOrder))
    TArray<FRichCurveKey> Keys;
};
 
USTRUCT()
struct FCompressedRichCurve
{
    GENERATED_USTRUCT_BODY()
 
    
    TEnumAsByte<ERichCurveCompressionFormat> CompressionFormat;
 
    TEnumAsByte<ERichCurveKeyTimeCompressionFormat> KeyTimeCompressionFormat;
 
    TEnumAsByte<ERichCurveExtrapolation> PreInfinityExtrap;
 
    TEnumAsByte<ERichCurveExtrapolation> PostInfinityExtrap;
 
    union TConstantValueNumKeys
    {
        float ConstantValue;
        int32 NumKeys;
 
        TConstantValueNumKeys() : NumKeys(0) {}
    };
 
    TConstantValueNumKeys ConstantValueNumKeys;
 
    TArray<uint8> CompressedKeys;
 
    FCompressedRichCurve()
        : CompressionFormat(RCCF_Empty)
        , KeyTimeCompressionFormat(RCKTCF_float32)
        , PreInfinityExtrap(RCCE_None)
        , PostInfinityExtrap(RCCE_None)
        , ConstantValueNumKeys()
        , CompressedKeys()
    {}
 
    ENGINE_API float Eval(float InTime, float InDefaultValue = 0.0f) const;
 
    ENGINE_API void PopulateCurve(FRichCurve& OutCurve) const;
 
    // Encapsulates the StaticEval arguments
    struct FStaticEvalArgs
    {
        ERichCurveCompressionFormat CompressionFormat = RCCF_Empty;
        ERichCurveKeyTimeCompressionFormat KeyTimeCompressionFormat = RCKTCF_float32;
 
        ERichCurveExtrapolation PreInfinityExtrap = RCCE_None;
        ERichCurveExtrapolation PostInfinityExtrap = RCCE_None;
 
        TConstantValueNumKeys ConstantValueNumKeys;
 
        const uint8* CompressedKeys = nullptr;
 
        float Time = 0.0f;
 
        float DefaultValue = 0.0f;
    };
 
    static ENGINE_API float StaticEval(const FStaticEvalArgs& Args);
 
    UE_DEPRECATED(5.6, "Please use StaticEval with the packed arguments structure as it has improved performance")
    static ENGINE_API float StaticEval(ERichCurveCompressionFormat CompressionFormat, ERichCurveKeyTimeCompressionFormat KeyTimeCompressionFormat, ERichCurveExtrapolation PreInfinityExtrap, ERichCurveExtrapolation PostInfinityExtrap, TConstantValueNumKeys ConstantValueNumKeys, const uint8* CompressedKeys, float InTime, float InDefaultValue = 0.0f);
 
    ENGINE_API bool Serialize(FArchive& Ar);
    ENGINE_API bool operator==(const FCompressedRichCurve& Other) const;
    bool operator!=(const FCompressedRichCurve& Other) const { return !(*this == Other); }
 
    friend FArchive& operator<<(FArchive& Ar, FCompressedRichCurve& Curve)
    {
        Curve.Serialize(Ar);
        return Ar;
    }
};
 
/*
 * Override serialization for compressed rich curves to handle the union
 */
template<>
struct TStructOpsTypeTraits<FCompressedRichCurve>
    : public TStructOpsTypeTraitsBase2<FCompressedRichCurve>
{
    enum
    {
        WithSerializer = true,
        WithCopy = false,
        WithIdenticalViaEquality = true,
    };
    static constexpr EPropertyObjectReferenceType WithSerializerObjectReferences = EPropertyObjectReferenceType::None;
};
 
template<class T>
struct FRichCurveEditInfoTemplate
{
    FName CurveName;
 
    T CurveToEdit;
 
    FRichCurveEditInfoTemplate()
        : CurveName(NAME_None)
        , CurveToEdit(nullptr)
    { }
 
    FRichCurveEditInfoTemplate(T InCurveToEdit)
        : CurveName(NAME_None)
        , CurveToEdit(InCurveToEdit)
    { }
 
    FRichCurveEditInfoTemplate(T InCurveToEdit, FName InCurveName)
        : CurveName(InCurveName)
        , CurveToEdit(InCurveToEdit)
    { }
 
    inline bool operator==(const FRichCurveEditInfoTemplate<T>& Other) const
    {
        return Other.CurveName.IsEqual(CurveName) && Other.CurveToEdit == CurveToEdit;
    }
 
    uint32 GetTypeHash() const
    {
        return HashCombine(GetTypeHashHelper(CurveName), PointerHash(CurveToEdit));
    }
 
    friend inline uint32 GetTypeHash(const FRichCurveEditInfoTemplate<T>& RichCurveEditInfo)
    {
        return RichCurveEditInfo.GetTypeHash();
    }
};
 
 
// Rename and deprecate
typedef FRichCurveEditInfoTemplate<FRealCurve*>         FRichCurveEditInfo;
typedef FRichCurveEditInfoTemplate<const FRealCurve*>   FRichCurveEditInfoConst;