MovieSceneChannel.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Delegates/Delegate.h"
#include "HAL/Platform.h"
#include "Math/Range.h"
#include "Misc/CoreDefines.h"
#include "Misc/FrameNumber.h"
#include "Misc/FrameRate.h"
#include "Curves/KeyHandle.h"
#include "UObject/ObjectMacros.h"
 
#include "MovieSceneChannel.generated.h"
 
struct FFrameNumber;
struct FFrameRate;
struct FKeyDataOptimizationParams;
struct FMovieSceneChannel;
 
namespace UE::MovieScene
{
    struct IRetimingInterface;
}
 
/*
*  Events that are fired when adding, deleting or moving keys
*/
struct FKeyAddOrDeleteEventItem
{
    FKeyAddOrDeleteEventItem(int32 InIndex, FFrameNumber InFrame) : Index(InIndex), Frame(InFrame) {};
    int32 Index;
    FFrameNumber Frame;;
};
 
struct FKeyMoveEventItem
{
    FKeyMoveEventItem(int32 InIndex, FFrameNumber InFrame, int32 InNewIndex, FFrameNumber InNewFrame) : Index(InIndex), Frame(InFrame), NewIndex(InNewIndex), NewFrame(InNewFrame) {};
    int32 Index;
    FFrameNumber Frame;
    int32 NewIndex;
    FFrameNumber NewFrame;
};
/*
*  Class to help with pre/post cycling of values
*/
namespace UE
{
namespace MovieScene
{
struct FCycleParams
{
    double ValueOffset;
    FFrameTime Time;
    int32 CycleCount;
    int32 Duration;
    bool bMirrorCurve;
 
    FCycleParams(FFrameTime InTime, int32 InDuration)
        : ValueOffset(0.0)
        , Time(InTime)
        , CycleCount(0)
        , Duration(InDuration)
        , bMirrorCurve(false)
    {}
 
    inline void ComputePreValueOffset(double FirstValue, double LastValue)
    {
        // CycleCount is negative for pre-extrap
        ValueOffset = (LastValue - FirstValue) * CycleCount;
    }
    inline void ComputePostValueOffset(double FirstValue, double LastValue)
    {
        ValueOffset = (LastValue - FirstValue) * CycleCount;
    }
    inline bool ShouldMirrorCurve() const
    {
        return bMirrorCurve;
    }
    inline void Oscillate(int32 MinFrame, int32 MaxFrame)
    {
        if (FMath::Abs(CycleCount) % 2 == 1)
        {
            bMirrorCurve = true;
 
            const int64 Offset = int64(MaxFrame) - int64(Time.FrameNumber.Value);
            Time = FFrameTime(MinFrame) + FFrameTime(static_cast<int32>(Offset)) - FFrameTime(0, Time.GetSubFrame());
        }
    }
};
MOVIESCENE_API  FCycleParams CycleTime(FFrameNumber MinFrame, FFrameNumber MaxFrame, FFrameTime InTime);
 
} // namespace MovieScene
} // namespace UE
/*
* Note if any Channel uses these delegate's they need a custom serializer to make sure they stick around on undo/redo. Dynamic delegates are too heavy.
*/
DECLARE_MULTICAST_DELEGATE_TwoParams(FMovieSceneChannelDataKeyAddedEvent, FMovieSceneChannel*, const TArray<FKeyAddOrDeleteEventItem>& Items);
DECLARE_MULTICAST_DELEGATE_TwoParams(FMovieSceneChannelDataKeyDeletedEvent, FMovieSceneChannel*, const TArray<FKeyAddOrDeleteEventItem>& Items);
DECLARE_MULTICAST_DELEGATE_TwoParams(FMovieSceneChannelDataKeyMovedEvent, FMovieSceneChannel*, const TArray<FKeyMoveEventItem>& Items);
 
USTRUCT()
struct FMovieSceneChannel
{
    GENERATED_BODY()
 
    FMovieSceneChannel() {}
 
    virtual ~FMovieSceneChannel() {}
 
    MOVIESCENE_API void GetKeyTime(const FKeyHandle InHandle, FFrameNumber& OutKeyTime);
 
    MOVIESCENE_API void SetKeyTime(const FKeyHandle InHandle, const FFrameNumber InKeyTime);
 
    virtual void GetKeys(const TRange<FFrameNumber>& WithinRange, TArray<FFrameNumber>* OutKeyTimes, TArray<FKeyHandle>* OutKeyHandles)
    {}
 
    virtual void GetKeyTimes(TArrayView<const FKeyHandle> InHandles, TArrayView<FFrameNumber> OutKeyTimes)
    {}
 
    virtual void SetKeyTimes(TArrayView<const FKeyHandle> InHandles, TArrayView<const FFrameNumber> InKeyTimes)
    {}
 
    virtual void DuplicateKeys(TArrayView<const FKeyHandle> InHandles, TArrayView<FKeyHandle> OutNewHandles)
    {}
 
    virtual void DeleteKeys(TArrayView<const FKeyHandle> InHandles)
    {}
 
    virtual void DeleteKeysFrom(FFrameNumber InTime, bool bDeleteKeysBefore)
    {}
 
    UE_DEPRECATED(5.6, "Please use RemapTimes")
    MOVIESCENE_API virtual void ChangeFrameResolution(FFrameRate SourceRate, FFrameRate DestinationRate);
 
    virtual void RemapTimes(const UE::MovieScene::IRetimingInterface& Retimer)
    {}
 
    virtual TRange<FFrameNumber> ComputeEffectiveRange() const
    {
        return TRange<FFrameNumber>::Empty();
    }
 
    virtual int32 GetNumKeys() const
    {
        return 0;
    }
 
    virtual void Reset()
    {}
 
    virtual void Offset(FFrameNumber DeltaPosition)
    {}
 
    virtual void Optimize(const FKeyDataOptimizationParams& InParameters)
    {}
 
    virtual void ClearDefault()
    {}
 
    virtual void PostEditChange() {}
 
    virtual FKeyHandle GetHandle(int32 Index)
    {
        return FKeyHandle();
    }
 
    virtual int32 GetIndex(FKeyHandle Handle)
    {
        return INDEX_NONE;
    }
 
public:
 
    FMovieSceneChannelDataKeyAddedEvent& OnKeyAddedEvent() { return KeyAddedEvent; }
    FMovieSceneChannelDataKeyDeletedEvent& OnKeyDeletedEvent() { return KeyDeletedEvent; }
    FMovieSceneChannelDataKeyMovedEvent& OnKeyMovedEvent() { return KeyMovedEvent; }
 
protected:
    FMovieSceneChannelDataKeyAddedEvent KeyAddedEvent;
 
    FMovieSceneChannelDataKeyDeletedEvent KeyDeletedEvent;
 
    FMovieSceneChannelDataKeyMovedEvent KeyMovedEvent;
 
};