AttributeCurve.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 "Curves/KeyHandle.h"
#include "Curves/IndexedCurve.h"
#include "Serialization/Archive.h"
 
#include "Animation/WrappedAttribute.h"
#include "Animation/IAttributeBlendOperator.h"
 
#include "AttributeCurve.generated.h"
 
namespace UE { namespace Anim { class IAttributeBlendOperator; struct Attributes; } }
namespace UE::UAF { class FDecompressionTools; }
 
typedef UE::Anim::TWrappedAttribute<FDefaultAllocator> FWrappedAttribute;
 
USTRUCT()
struct FAttributeKey
{
    GENERATED_USTRUCT_BODY()
public:
     
    FAttributeKey(float InTime = 0.f) : Time(InTime) {}
 
    UPROPERTY(EditAnywhere, Category = Key)
    float Time;
 
    template<typename AttributeType>
    const AttributeType& GetValue() const
    {
        return Value.GetRef<AttributeType>();
    }
 
    template<typename AttributeType>
    const AttributeType* GetValuePtr() const
    {
        return Value.GetPtr<AttributeType>();
    }
 
    
    friend FArchive& operator<<(FArchive& Ar, FAttributeKey& P)
    {
        Ar << P.Time;
        return Ar;
    }
 
protected:
    FWrappedAttribute Value;
 
    friend struct FAttributeCurve;
};
 
USTRUCT(BlueprintType)
struct FAttributeCurve : public FIndexedCurve
{
    GENERATED_USTRUCT_BODY()
public:
    FAttributeCurve() : ScriptStruct(nullptr), bShouldInterpolate(false), Operator(nullptr) {}
    FAttributeCurve(UScriptStruct* InScriptStruct) : ScriptStructPath(InScriptStruct), ScriptStruct(InScriptStruct), bShouldInterpolate(false), Operator(nullptr) {}
 
    ENGINE_API FAttributeCurve(const FAttributeCurve& OtherCurve);
 
    virtual ~FAttributeCurve() { }
 
    ENGINE_API bool Serialize(FArchive& Ar);
 
    virtual int32 GetNumKeys() const override final { return Keys.Num(); }
    virtual FAttributeCurve* Duplicate() const final { return new FAttributeCurve(*this); }
    ENGINE_API virtual void SetKeyTime(FKeyHandle KeyHandle, float NewTime) override final;
    ENGINE_API virtual float GetKeyTime(FKeyHandle KeyHandle) const override final;
    ENGINE_API void SetScriptStruct(UScriptStruct* InScriptStruct);
    const UScriptStruct* GetScriptStruct() const { return ScriptStruct; }
 
    ENGINE_API bool CanEvaluate() const;
 
    template<typename AttributeType>
    AttributeType Evaluate(float Time) const
    {
        AttributeType EvaluatedValue;
        EvaluateToPtr(AttributeType::StaticStruct(), Time, (uint8*)&EvaluatedValue);
        return EvaluatedValue;
    }
 
    ENGINE_API bool HasAnyData() const;
 
    ENGINE_API void Reset();
 
    ENGINE_API TArray<FAttributeKey>::TConstIterator GetKeyIterator() const;
 
    template<typename AttributeType>
    FKeyHandle AddTypedKey(float InTime, const AttributeType& InValue, FKeyHandle InKeyHandle = FKeyHandle())
    {
        check(AttributeType::StaticStruct() == ScriptStruct); 
        return AddKey(InTime, &InValue, InKeyHandle);
    }
 
    ENGINE_API void DeleteKey(FKeyHandle KeyHandle);
 
    template<typename AttributeType>
    FKeyHandle UpdateOrAddTypedKey(float InTime, const AttributeType& InValue, float KeyTimeTolerance = UE_KINDA_SMALL_NUMBER)
    {
        check(AttributeType::StaticStruct() == ScriptStruct);
        return UpdateOrAddKey(InTime, &InValue, KeyTimeTolerance);
    }
 
    FKeyHandle UpdateOrAddTypedKey(float InTime, const void* InValue, const UScriptStruct* ValueType, float KeyTimeTolerance = UE_KINDA_SMALL_NUMBER)
    {
        check(ValueType == ScriptStruct);
        return UpdateOrAddKey(InTime, InValue, KeyTimeTolerance);
    }
            
    ENGINE_API FAttributeKey& GetKey(FKeyHandle KeyHandle);
    ENGINE_API const FAttributeKey& GetKey(FKeyHandle KeyHandle) const;
 
    ENGINE_API FKeyHandle FindKey(float KeyTime, float KeyTimeTolerance = UE_KINDA_SMALL_NUMBER) const;
 
    ENGINE_API FKeyHandle FindKeyBeforeOrAt(float KeyTime) const;
 
    ENGINE_API void RemoveRedundantKeys();
    ENGINE_API void SetKeys(TArrayView<const float> InTimes, TArrayView<const void*> InValues);
 
    template<typename AttributeType>
    void GetTypedKeys(TArray<const AttributeType*>& OutKeys) const
    {
        for (const FAttributeKey& Key : Keys)
        {
            OutKeys.Add(Key.Value.GetPtr<AttributeType>());
        }
    }
 
    ENGINE_API TArray<FAttributeKey> GetCopyOfKeys() const;
    ENGINE_API const TArray<FAttributeKey>& GetConstRefOfKeys() const;
 
    ENGINE_API void ReadjustTimeRange(float NewMinTimeRange, float NewMaxTimeRange, bool bInsert/* whether insert or remove*/, float OldStartTime, float OldEndTime);
 
protected:
    ENGINE_API void EvaluateToPtr(const UScriptStruct* InScriptStruct, float Time, uint8* InOutDataPtr) const;
 
    ENGINE_API FKeyHandle UpdateOrAddKey(float InTime, const void* InValue, float KeyTimeTolerance = UE_KINDA_SMALL_NUMBER);
 
    ENGINE_API FKeyHandle AddKey(float InTime, const void* InValue, FKeyHandle InKeyHandle = FKeyHandle());
protected:
    UPROPERTY(EditAnywhere, Category = "Custom Attributes")
    TArray<FAttributeKey> Keys; 
 
    /* Path to UScriptStruct to be loaded */
    UPROPERTY(VisibleAnywhere, Category = "Custom Attributes")
    FSoftObjectPath ScriptStructPath;
 
    /* Transient UScriptStruct instance representing the underlying value type for the curve */
    UPROPERTY(EditAnywhere, Transient, Category = "Custom Attributes")
    TObjectPtr<UScriptStruct> ScriptStruct;
 
    UPROPERTY(EditAnywhere, Transient, Category = "Custom Attributes")
    bool bShouldInterpolate;
 
    const UE::Anim::IAttributeBlendOperator* Operator;
 
    friend class UAnimSequence;
    friend struct UE::Anim::Attributes;
    friend UE::UAF::FDecompressionTools;
};
 
template<>
struct TStructOpsTypeTraits<FAttributeCurve> : public TStructOpsTypeTraitsBase2<FAttributeCurve>
{
    enum
    {
        WithSerializer = true,
    };
};