SimpleCurve.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Curves/RealCurve.h"
#include "SimpleCurve.generated.h"
 
USTRUCT()
struct FSimpleCurveKey
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, Category="Key")
    float Time;
 
    UPROPERTY(EditAnywhere, Category="Key")
    float Value;
 
    FSimpleCurveKey()
        : Time(0.f)
        , Value(0.f)
    { }
 
    FSimpleCurveKey(float InTime, float InValue)
        : Time(InTime)
        , Value(InValue)
    { }
 
    ENGINE_API bool Serialize(FArchive& Ar);
    ENGINE_API bool operator==(const FSimpleCurveKey& Other) const;
    ENGINE_API bool operator!=(const FSimpleCurveKey& Other) const;
 
    friend FArchive& operator<<(FArchive& Ar, FSimpleCurveKey& P)
    {
        P.Serialize(Ar);
        return Ar;
    }
};
 
 
template<>
struct TIsPODType<FSimpleCurveKey>
{
    enum { Value = true };
};
 
 
template<>
struct TStructOpsTypeTraits<FSimpleCurveKey>
    : public TStructOpsTypeTraitsBase2<FSimpleCurveKey>
{
    enum
    {
        WithSerializer = true,
        WithCopy = false,
        WithIdenticalViaEquality = true,
    };
    static constexpr EPropertyObjectReferenceType WithSerializerObjectReferences = EPropertyObjectReferenceType::None;
};
 
 
USTRUCT()
struct FSimpleCurve
    : public FRealCurve
{
    GENERATED_USTRUCT_BODY()
 
    FSimpleCurve() 
        : FRealCurve()
        , InterpMode(RCIM_Linear)
    { }
 
public:
 
    ENGINE_API TArray<FSimpleCurveKey> GetCopyOfKeys() const;
 
    ENGINE_API const TArray<FSimpleCurveKey>& GetConstRefOfKeys() const;
 
    ENGINE_API TArray<FSimpleCurveKey>::TConstIterator GetKeyIterator() const;
    
    ENGINE_API FSimpleCurveKey& GetKey(FKeyHandle KeyHandle);
    ENGINE_API FSimpleCurveKey GetKey(FKeyHandle KeyHandle) const;
    
    ENGINE_API FSimpleCurveKey GetFirstKey() const;
    ENGINE_API FSimpleCurveKey GetLastKey() const;
 
    ENGINE_API FSimpleCurveKey* GetFirstMatchingKey(const TArray<FKeyHandle>& KeyHandles);
 
    ENGINE_API FKeyHandle AddKey(float InTime, float InValue, const bool bUnwindRotation = false, FKeyHandle KeyHandle = FKeyHandle()) final override;
 
    ENGINE_API void SetKeys(const TArray<FSimpleCurveKey>& InKeys);
 
    ENGINE_API virtual 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;
 
    virtual void SetKeyInterpMode(FKeyHandle, ERichCurveInterpMode NewInterpMode) final override { SetKeyInterpMode(NewInterpMode); }
 
    void SetKeyInterpMode(ERichCurveInterpMode NewInterpMode)
    { 
        if (ensureMsgf(NewInterpMode != RCIM_Cubic, TEXT("SimpleCurves cannot use cubic interpolation")))
        {
            InterpMode = NewInterpMode;
        }
    }
 
    virtual ERichCurveInterpMode GetKeyInterpMode(FKeyHandle KeyHandle) const final override { return GetKeyInterpMode(); }
 
    ERichCurveInterpMode GetKeyInterpMode() const { return InterpMode; }
 
    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 virtual void ReadjustTimeRange(float NewMinTimeRange, float NewMaxTimeRange, bool bInsert/* whether insert or remove*/, float OldStartTime, float OldEndTime) final override;
 
    ENGINE_API bool operator == (const FSimpleCurve& 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 virtual void RemoveRedundantKeys(float Tolerance, FFrameRate SampleRate = FFrameRate(0,0)) final override;
    ENGINE_API virtual void RemoveRedundantKeys(float Tolerance, float FirstKeyTime, float LastKeyTime, FFrameRate SampleRate = FFrameRate(0,0)) final override;
 
    virtual FIndexedCurve* Duplicate() const final { return new FSimpleCurve(*this); }
 
protected:
    ENGINE_API virtual int32 GetKeyIndex(float KeyTime, float KeyTimeTolerance) const override final;
 
private:
    ENGINE_API void RemoveRedundantKeysInternal(float Tolerance, int32 InStartKeepKey, int32 InEndKeepKey);
 
    ENGINE_API float EvalForTwoKeys(const FSimpleCurveKey& Key1, const FSimpleCurveKey& Key2, const float InTime) const;
 
public:
 
    // FIndexedCurve interface
 
    virtual int32 GetNumKeys() const final override { return Keys.Num(); }
 
public:
 
    UPROPERTY()
    TEnumAsByte<ERichCurveInterpMode> InterpMode;
 
    UPROPERTY(EditAnywhere, EditFixedSize, Category="Curve", meta=(EditFixedOrder))
    TArray<FSimpleCurveKey> Keys;
};