MovieSceneFloatChannel.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Channels/MovieSceneChannelEditorData.h"
#include "Channels/MovieSceneCurveChannelCommon.h"
#include "Channels/MovieScenePiecewiseCurve.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/EnumAsByte.h"
#include "CoreTypes.h"
#include "Curves/KeyHandle.h"
#include "Curves/RealCurve.h"
#include "Curves/RichCurve.h"
#include "HAL/PlatformCrt.h"
#include "KeyParams.h"
#include "Math/Range.h"
#include "Misc/FrameNumber.h"
#include "Misc/FrameRate.h"
#include "Misc/FrameTime.h"
#include "Misc/Optional.h"
#include "MovieSceneChannel.h"
#include "MovieSceneChannelData.h"
#include "MovieSceneChannelTraits.h"
#include "Serialization/StructuredArchive.h"
#include "Templates/Tuple.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/Class.h"
#include "UObject/ObjectMacros.h"
 
#include "MovieSceneFloatChannel.generated.h"
 
class FArchive;
struct FPropertyTag;
template<typename> struct TMovieSceneCurveChannelImpl;
template <typename T> struct TIsPODType;
 
namespace UE::MovieScene
{
    MOVIESCENE_API void OnRemapChannelKeyTime(const FMovieSceneChannel* Channel, const IRetimingInterface& Retimer, FFrameNumber PreviousTime, FFrameNumber CurrentTime, FMovieSceneFloatValue& InOutValue);
 
    namespace Interpolation
    {
        struct FCachedInterpolation;
    }
}
 
USTRUCT()
struct FMovieSceneFloatValue
{
    GENERATED_BODY()
 
    FMovieSceneFloatValue()
        : Value(0.f), InterpMode(RCIM_Cubic), TangentMode(RCTM_Auto), PaddingByte(0)
    {}
 
    explicit FMovieSceneFloatValue(float InValue)
        : Value(InValue), InterpMode(RCIM_Cubic), TangentMode(RCTM_Auto), PaddingByte(0)
    {}
 
    bool Serialize(FArchive& Ar);
    MOVIESCENE_API bool operator==(const FMovieSceneFloatValue& Other) const;
    MOVIESCENE_API bool operator!=(const FMovieSceneFloatValue& Other) const;
    friend FArchive& operator<<(FArchive& Ar, FMovieSceneFloatValue& P)
    {
        P.Serialize(Ar);
        return Ar;
    }
 
    UPROPERTY(EditAnywhere, Category = "Key")
    float Value;
 
    UPROPERTY(EditAnywhere, Category = "Key")
    FMovieSceneTangentData Tangent;
 
    UPROPERTY(EditAnywhere, Category = "Key")
    TEnumAsByte<ERichCurveInterpMode> InterpMode;
 
    UPROPERTY(EditAnywhere, Category = "Key")
    TEnumAsByte<ERichCurveTangentMode> TangentMode;
 
    UPROPERTY()
    uint8 PaddingByte;
 
    // This is required because TMovieSceneCurveChannelImpl<ChannelType>::Serialize dumps us as a byte array so we need padding to be initialized to avoid indeterminism in the cooked build
    uint8 UnserializedPaddingBytes[1] = {0};
};
static_assert(
    sizeof(FMovieSceneFloatValue) ==
    sizeof(FMovieSceneFloatValue::Value) + sizeof(FMovieSceneFloatValue::Tangent) + sizeof(FMovieSceneFloatValue::InterpMode) + sizeof(FMovieSceneFloatValue::TangentMode) + sizeof(FMovieSceneFloatValue::PaddingByte) + sizeof(FMovieSceneFloatValue::UnserializedPaddingBytes),
    "Adjust padding size to avoid cooked build indeterminism with uninitialized padded data");
 
template<>
struct TIsPODType<FMovieSceneFloatValue>
{
    enum { Value = true };
};
 
 
template<>
struct TStructOpsTypeTraits<FMovieSceneFloatValue>
    : public TStructOpsTypeTraitsBase2<FMovieSceneFloatValue>
{
    enum
    {
        WithSerializer = true,
        WithCopy = false,
        WithIdenticalViaEquality = true,
    };
    static constexpr EPropertyObjectReferenceType WithSerializerObjectReferences = EPropertyObjectReferenceType::None;
};
 
 
USTRUCT()
struct FMovieSceneFloatChannel : public FMovieSceneChannel
{
    GENERATED_BODY()
 
    typedef float CurveValueType;
    typedef FMovieSceneFloatValue ChannelValueType;
 
    MOVIESCENE_API FMovieSceneFloatChannel();
 
    MOVIESCENE_API virtual ~FMovieSceneFloatChannel();
 
    MOVIESCENE_API UE::MovieScene::Interpolation::FInterpolationExtents ComputeExtents(FFrameTime StartTime, FFrameTime EndTime) const;
    
    MOVIESCENE_API UE::MovieScene::FPiecewiseCurve AsPiecewiseCurve(bool bWithPreAndPostInfinityExtrap = true) const;
 
    inline TMovieSceneChannelData<FMovieSceneFloatValue> GetData()
    {
        return TMovieSceneChannelData<FMovieSceneFloatValue>(&Times, &Values, this, &KeyHandles);
    }
 
    inline TMovieSceneChannelData<const FMovieSceneFloatValue> GetData() const
    {
        return TMovieSceneChannelData<const FMovieSceneFloatValue>(&Times, &Values);
    }
 
    inline TArrayView<const FFrameNumber> GetTimes() const
    {
        return Times;
    }
 
    inline TArrayView<const FMovieSceneFloatValue> GetValues() const
    {
        return Values;
    }
 
    MOVIESCENE_API bool Evaluate(FFrameTime InTime, float& OutValue) const;
 
    MOVIESCENE_API UE::MovieScene::Interpolation::FCachedInterpolation GetInterpolationForTime(FFrameTime InTime) const;
 
    MOVIESCENE_API void Set(TArray<FFrameNumber> InTimes, TArray<FMovieSceneFloatValue> InValues);
 
    MOVIESCENE_API void SetKeysOnly(TArrayView<FFrameNumber> InTimes, TArrayView<FMovieSceneFloatValue> InValues);
public:
 
    // ~ FMovieSceneChannel Interface
    MOVIESCENE_API virtual void GetKeys(const TRange<FFrameNumber>& WithinRange, TArray<FFrameNumber>* OutKeyTimes, TArray<FKeyHandle>* OutKeyHandles) override;
    MOVIESCENE_API virtual void GetKeyTimes(TArrayView<const FKeyHandle> InHandles, TArrayView<FFrameNumber> OutKeyTimes) override;
    MOVIESCENE_API virtual void SetKeyTimes(TArrayView<const FKeyHandle> InHandles, TArrayView<const FFrameNumber> InKeyTimes) override;
    MOVIESCENE_API virtual void DuplicateKeys(TArrayView<const FKeyHandle> InHandles, TArrayView<FKeyHandle> OutNewHandles) override;
    MOVIESCENE_API virtual void DeleteKeys(TArrayView<const FKeyHandle> InHandles) override;
    MOVIESCENE_API virtual void DeleteKeysFrom(FFrameNumber InTime, bool bDeleteKeysBefore) override;
    MOVIESCENE_API virtual void RemapTimes(const UE::MovieScene::IRetimingInterface& Retimer) override;
    MOVIESCENE_API virtual TRange<FFrameNumber> ComputeEffectiveRange() const override;
    MOVIESCENE_API virtual int32 GetNumKeys() const override;
    MOVIESCENE_API virtual void Reset() override;
    MOVIESCENE_API virtual void Offset(FFrameNumber DeltaPosition) override;
    MOVIESCENE_API virtual void Optimize(const FKeyDataOptimizationParams& InParameters) override;
    MOVIESCENE_API virtual void ClearDefault() override;
    MOVIESCENE_API virtual void PostEditChange() override;
    MOVIESCENE_API virtual FKeyHandle GetHandle(int32 Index) override;
    MOVIESCENE_API virtual int32 GetIndex(FKeyHandle Handle) override;
 
public:
 
    inline bool HasAnyData() const
    {
        return Times.Num() != 0 || bHasDefaultValue == true;
    }
 
    inline void SetDefault(float InDefaultValue)
    {
        bHasDefaultValue = true;
        DefaultValue = InDefaultValue;
    }
 
    inline TOptional<float> GetDefault() const
    {
        return bHasDefaultValue ? TOptional<float>(DefaultValue) : TOptional<float>();
    }
 
    inline void RemoveDefault()
    {
        bHasDefaultValue = false;
    }
 
public:
 
    MOVIESCENE_API bool Serialize(FArchive& Ar);
#if WITH_EDITORONLY_DATA
    MOVIESCENE_API void PostSerialize(const FArchive& Ar);
#endif
    friend FArchive& operator<<(FArchive& Ar, FMovieSceneFloatChannel& Me)
    {
        Me.Serialize(Ar);
        return Ar;
    }
 
    MOVIESCENE_API bool SerializeFromMismatchedTag(const FPropertyTag& Tag, FStructuredArchive::FSlot Slot);
 
    MOVIESCENE_API int32 AddConstantKey(FFrameNumber InTime, float InValue);
 
    MOVIESCENE_API int32 AddLinearKey(FFrameNumber InTime, float InValue);
 
    MOVIESCENE_API int32 AddCubicKey(FFrameNumber InTime, float InValue, ERichCurveTangentMode TangentMode = RCTM_Auto, const FMovieSceneTangentData& Tangent = FMovieSceneTangentData());
 
    MOVIESCENE_API void AutoSetTangents(float Tension = 0.f);
 
    FFrameRate GetTickResolution() const { return TickResolution; }
    void SetTickResolution(FFrameRate InTickSolution) { TickResolution = InTickSolution; }
 
    MOVIESCENE_API void PopulateCurvePoints(double StartTimeSeconds, double EndTimeSeconds, double TimeThreshold, float ValueThreshold, FFrameRate TickResolution, TArray<TTuple<double, double>>& InOutPoints) const;  
 
    MOVIESCENE_API void AddKeys(const TArray<FFrameNumber>& InTimes, const TArray<FMovieSceneFloatValue>& InValues);
 
    MOVIESCENE_API void UpdateOrAddKeys(const TArrayView<const FFrameNumber> InTimes, const TArrayView<FMovieSceneFloatValue> InValues);
 
#if WITH_EDITORONLY_DATA
    /* Get whether to show this curve in the UI */
    MOVIESCENE_API bool GetShowCurve() const;
    /* Set whether to show this curve in the UI */
    MOVIESCENE_API void SetShowCurve(bool bInShowCurve);
#endif
 
public:
 
    UPROPERTY()
    TEnumAsByte<ERichCurveExtrapolation> PreInfinityExtrap;
 
    UPROPERTY()
    TEnumAsByte<ERichCurveExtrapolation> PostInfinityExtrap;
 
private:
 
    UPROPERTY(meta=(KeyTimes))
    TArray<FFrameNumber> Times;
 
    UPROPERTY(meta=(KeyValues))
    TArray<FMovieSceneFloatValue> Values;
 
    UPROPERTY()
    float DefaultValue;
 
    UPROPERTY()
    bool bHasDefaultValue;
 
    UPROPERTY(Transient)
    FMovieSceneKeyHandleMap KeyHandles;
 
    UPROPERTY()
    FFrameRate TickResolution;
 
#if WITH_EDITORONLY_DATA
 
    UPROPERTY()
    bool bShowCurve;
 
#endif
 
    friend struct TMovieSceneCurveChannelImpl<FMovieSceneFloatChannel>;
    using FMovieSceneFloatChannelImpl = TMovieSceneCurveChannelImpl<FMovieSceneFloatChannel>;
};
 
template<>
struct TStructOpsTypeTraits<FMovieSceneFloatChannel> : public TStructOpsTypeTraitsBase2<FMovieSceneFloatChannel>
{
    enum 
    { 
        WithStructuredSerializeFromMismatchedTag = true, 
        WithSerializer = true,
#if WITH_EDITORONLY_DATA
        WithPostSerialize = true,
#endif
    };
    static constexpr EPropertyObjectReferenceType WithSerializerObjectReferences = EPropertyObjectReferenceType::None;
};
 
template<>
struct TMovieSceneChannelTraits<FMovieSceneFloatChannel> : TMovieSceneChannelTraitsBase<FMovieSceneFloatChannel>
{
#if WITH_EDITOR
 
    typedef TMovieSceneExternalValue<float> ExtendedEditorDataType;
 
#endif
};
 
MOVIESCENE_API EMovieSceneKeyInterpolation GetInterpolationMode(FMovieSceneFloatChannel* InChannel, const FFrameNumber& InTime, EMovieSceneKeyInterpolation DefaultInterpolationMode);
 
MOVIESCENE_API FKeyHandle AddKeyToChannel(FMovieSceneFloatChannel* Channel, FFrameNumber InFrameNumber, float InValue, EMovieSceneKeyInterpolation Interpolation);
 
MOVIESCENE_API void Dilate(FMovieSceneFloatChannel* InChannel, FFrameNumber Origin, float DilationFactor);
 
 
MOVIESCENE_API bool ValueExistsAtTime(const FMovieSceneFloatChannel* InChannel, FFrameNumber InFrameNumber, float InValue);
MOVIESCENE_API bool ValueExistsAtTime(const FMovieSceneFloatChannel* InChannel, FFrameNumber InFrameNumber, const FMovieSceneFloatValue& InValue);
MOVIESCENE_API void AssignValue(FMovieSceneFloatChannel* InChannel, FKeyHandle InKeyHandle, float InValue);
MOVIESCENE_API void InvertValue(float& InOutValue);
MOVIESCENE_API void ReciprocalValue(float& InOutValue);
MOVIESCENE_API void TransformValue(float& InOutValue, const FMovieSceneChannelTraitsTransform<float>& Transform);