MovieSceneDoubleChannel.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Channels/MovieSceneCurveChannelCommon.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 "Misc/EnumClassFlags.h"
 
#include "MovieSceneDoubleChannel.generated.h"
 
class FArchive;
struct FPropertyTag;
struct FMovieSceneDoubleValue;
template<typename> struct TMovieSceneCurveChannelImpl;
template <typename T> struct TIsPODType;
 
namespace UE::MovieScene
{
    enum class EInverseEvaluateFlags : uint8;
    struct FPiecewiseCurve;
    MOVIESCENE_API void OnRemapChannelKeyTime(const FMovieSceneChannel* Channel, const IRetimingInterface& Retimer, FFrameNumber PreviousTime, FFrameNumber CurrentTime, FMovieSceneDoubleValue& InOutValue);
}
namespace UE::MovieScene::Interpolation
{
    struct FCachedInterpolation;
    struct FInterpolationExtents;
}
 
 
USTRUCT()
struct FMovieSceneDoubleValue
{
    GENERATED_BODY()
 
    FMovieSceneDoubleValue()
        : Value(0.f), InterpMode(RCIM_Cubic), TangentMode(RCTM_Auto), PaddingByte(0)
    {}
 
    explicit FMovieSceneDoubleValue(double InValue)
        : Value(InValue), InterpMode(RCIM_Cubic), TangentMode(RCTM_Auto), PaddingByte(0)
    {}
 
    bool Serialize(FArchive& Ar);
    MOVIESCENE_API bool operator==(const FMovieSceneDoubleValue& Other) const;
    MOVIESCENE_API bool operator!=(const FMovieSceneDoubleValue& Other) const;
    friend FArchive& operator<<(FArchive& Ar, FMovieSceneDoubleValue& P)
    {
        P.Serialize(Ar);
        return Ar;
    }
 
    UPROPERTY(EditAnywhere, Category = "Key")
    double 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(FMovieSceneDoubleValue) == 
    sizeof(FMovieSceneDoubleValue::Value) + sizeof(FMovieSceneDoubleValue::Tangent) + sizeof(FMovieSceneDoubleValue::InterpMode) + sizeof(FMovieSceneDoubleValue::TangentMode) + sizeof(FMovieSceneDoubleValue::PaddingByte) + sizeof(FMovieSceneDoubleValue::UnserializedPaddingBytes),
    "Adjust padding size to avoid cooked build indeterminism with uninitialized padded data");
 
template<>
struct TIsPODType<FMovieSceneDoubleValue>
{
    enum { Value = true };
};
 
 
template<>
struct TStructOpsTypeTraits<FMovieSceneDoubleValue>
    : public TStructOpsTypeTraitsBase2<FMovieSceneDoubleValue>
{
    enum
    {
        WithSerializer = true,
        WithCopy = false,
        WithIdenticalViaEquality = true,
    };
    static constexpr EPropertyObjectReferenceType WithSerializerObjectReferences = EPropertyObjectReferenceType::None;
};
 
 
USTRUCT()
struct FMovieSceneDoubleChannel : public FMovieSceneChannel
{
    GENERATED_BODY()
 
    typedef double CurveValueType;
    typedef FMovieSceneDoubleValue ChannelValueType;
 
    FMovieSceneDoubleChannel() 
        : PreInfinityExtrap(RCCE_Constant)
        , PostInfinityExtrap(RCCE_Constant)
        , DefaultValue(0.0)
        , bHasDefaultValue(false)
#if WITH_EDITORONLY_DATA
        , bShowCurve(false)
#endif
    {}
 
    MOVIESCENE_API UE::MovieScene::FPiecewiseCurve AsPiecewiseCurve(bool bWithPreAndPostInfinityExtrap = true) const;
 
    inline TMovieSceneChannelData<FMovieSceneDoubleValue> GetData()
    {
        return TMovieSceneChannelData<FMovieSceneDoubleValue>(&Times, &Values, this, &KeyHandles);
    }
 
    inline TMovieSceneChannelData<const FMovieSceneDoubleValue> GetData() const
    {
        return TMovieSceneChannelData<const FMovieSceneDoubleValue>(&Times, &Values);
    }
 
    inline TArrayView<const FFrameNumber> GetTimes() const
    {
        return Times;
    }
 
    inline TArrayView<const FMovieSceneDoubleValue> GetValues() const
    {
        return Values;
    }
 
    MOVIESCENE_API bool Evaluate(FFrameTime InTime, double& OutValue) const;
 
    MOVIESCENE_API bool Evaluate(FFrameTime InTime, float& OutValue) const;
 
    MOVIESCENE_API UE::MovieScene::Interpolation::FCachedInterpolation GetInterpolationForTime(FFrameTime InTime) const;
 
 
    MOVIESCENE_API UE::MovieScene::Interpolation::FInterpolationExtents ComputeExtents(FFrameTime StartTime, FFrameTime EndTime) const;
 
 
    MOVIESCENE_API TOptional<FFrameTime> InverseEvaluate(double Value, FFrameTime TimeHint, UE::MovieScene::EInverseEvaluateFlags Flags) const;
 
 
    MOVIESCENE_API bool InverseEvaluateBetween(double Value, FFrameTime StartTime, FFrameTime EndTime, const TFunctionRef<bool(FFrameTime)>& Visitor) const;
 
 
    MOVIESCENE_API int32 GetCycleCount(FFrameTime InTime) const;
 
 
    MOVIESCENE_API TRange<FFrameNumber> GetCycleRange(int32 InCycleCount) const;
 
public:
    MOVIESCENE_API void Set(TArray<FFrameNumber> InTimes, TArray<FMovieSceneDoubleValue> InValues);
 
    MOVIESCENE_API void SetKeysOnly(TArrayView<FFrameNumber> InTimes, TArrayView<FMovieSceneDoubleValue> 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(double InDefaultValue)
    {
        bHasDefaultValue = true;
        DefaultValue = InDefaultValue;
    }
 
    inline TOptional<double> GetDefault() const
    {
        return bHasDefaultValue ? TOptional<double>(DefaultValue) : TOptional<double>();
    }
 
    inline void RemoveDefault()
    {
        bHasDefaultValue = false;
    }
 
public:
 
    MOVIESCENE_API bool Serialize(FArchive& Ar);
    friend FArchive& operator<<(FArchive& Ar, FMovieSceneDoubleChannel& Me)
    {
        Me.Serialize(Ar);
        return Ar;
    }
 
    MOVIESCENE_API bool SerializeFromMismatchedTag(const FPropertyTag& Tag, FStructuredArchive::FSlot Slot);
 
    MOVIESCENE_API int32 AddConstantKey(FFrameNumber InTime, double InValue);
 
    MOVIESCENE_API int32 AddLinearKey(FFrameNumber InTime, double InValue);
 
    MOVIESCENE_API int32 AddCubicKey(FFrameNumber InTime, double 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, double ValueThreshold, FFrameRate TickResolution, TArray<TTuple<double, double>>& InOutPoints) const; 
 
    MOVIESCENE_API void AddKeys(const TArray<FFrameNumber>& InTimes, const TArray<FMovieSceneDoubleValue>& InValues);
 
    MOVIESCENE_API void UpdateOrAddKeys(const TArrayView<const FFrameNumber> InTimes, const TArrayView<FMovieSceneDoubleValue> 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<FMovieSceneDoubleValue> Values;
 
    UPROPERTY()
    double DefaultValue;
 
    UPROPERTY()
    bool bHasDefaultValue;
 
    UPROPERTY(Transient)
    FMovieSceneKeyHandleMap KeyHandles;
 
    UPROPERTY()
    FFrameRate TickResolution;
 
#if WITH_EDITORONLY_DATA
 
    UPROPERTY()
    bool bShowCurve;
 
#endif
 
    friend struct TMovieSceneCurveChannelImpl<FMovieSceneDoubleChannel>;
    using FMovieSceneDoubleChannelImpl = TMovieSceneCurveChannelImpl<FMovieSceneDoubleChannel>;
};
 
template<>
struct TStructOpsTypeTraits<FMovieSceneDoubleChannel> : public TStructOpsTypeTraitsBase2<FMovieSceneDoubleChannel>
{
    enum 
    { 
        WithStructuredSerializeFromMismatchedTag = true, 
        WithSerializer = true
    };
    static constexpr EPropertyObjectReferenceType WithSerializerObjectReferences = EPropertyObjectReferenceType::None;
};
 
template<>
struct TMovieSceneChannelTraits<FMovieSceneDoubleChannel> : TMovieSceneChannelTraitsBase<FMovieSceneDoubleChannel>
{
#if WITH_EDITOR
 
    typedef TMovieSceneExternalValue<double> ExtendedEditorDataType;
 
#endif
};
 
MOVIESCENE_API EMovieSceneKeyInterpolation GetInterpolationMode(FMovieSceneDoubleChannel* InChannel, const FFrameNumber& InTime, EMovieSceneKeyInterpolation DefaultInterpolationMode);
 
MOVIESCENE_API FKeyHandle AddKeyToChannel(FMovieSceneDoubleChannel* Channel, FFrameNumber InFrameNumber, double InValue, EMovieSceneKeyInterpolation Interpolation);
 
 
MOVIESCENE_API void Dilate(FMovieSceneDoubleChannel* InChannel, FFrameNumber Origin, double DilationFactor);
 
 
MOVIESCENE_API bool ValueExistsAtTime(const FMovieSceneDoubleChannel* InChannel, FFrameNumber InFrameNumber, const FMovieSceneDoubleValue& InValue);
MOVIESCENE_API bool ValueExistsAtTime(const FMovieSceneDoubleChannel* InChannel, FFrameNumber InFrameNumber, double Value);
MOVIESCENE_API bool ValueExistsAtTime(const FMovieSceneDoubleChannel* InChannel, FFrameNumber InFrameNumber, float Value);
MOVIESCENE_API void AssignValue(FMovieSceneDoubleChannel* InChannel, FKeyHandle InKeyHandle, double InValue);
MOVIESCENE_API void AssignValue(FMovieSceneDoubleChannel* InChannel, FKeyHandle InKeyHandle, float InValue);
MOVIESCENE_API void InvertValue(double& InOutValue);
MOVIESCENE_API void ReciprocalValue(double& InOutValue);
MOVIESCENE_API void TransformValue(double& InOutValue, const FMovieSceneChannelTraitsTransform<double>& Transform);