MovieSceneChannelData.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Channels/MovieSceneChannel.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "CoreTypes.h"
#include "Curves/KeyHandle.h"
#include "Math/Range.h"
#include "Math/RangeBound.h"
#include "Misc/AssertionMacros.h"
#include "Misc/FrameNumber.h"
#include "Misc/FrameTime.h"
#include "Templates/UnrealTemplate.h"
#include "Templates/UnrealTypeTraits.h"
#include "UObject/Class.h"
#include "UObject/ObjectMacros.h"
#include "IMovieSceneRetimingInterface.h"
#include "Algo/RemoveIf.h"
 
#include "MovieSceneChannelData.generated.h"
 
struct FFrameRate;
struct FKeyDataOptimizationParams;
 
namespace UE::MovieScene
{
    template<typename ValueType>
    void OnRemapChannelKeyTime(const FMovieSceneChannel* Channel, const IRetimingInterface& Retimer, FFrameNumber PreviousTime, FFrameNumber CurrentTime, ValueType& InOutValue)
    {}
}
 
USTRUCT()
struct FMovieSceneKeyHandleMap : public FKeyHandleLookupTable
{
    GENERATED_BODY()
 
public:
    FMovieSceneKeyHandleMap() = default;
    FMovieSceneKeyHandleMap(const FMovieSceneKeyHandleMap& RHS){}
    FMovieSceneKeyHandleMap& operator=(const FMovieSceneKeyHandleMap& RHS)
    {
        Reset();
        return *this;
    }
};
 
template<>
struct TStructOpsTypeTraits<FMovieSceneKeyHandleMap>
    : public TStructOpsTypeTraitsBase2<FMovieSceneKeyHandleMap>
{
    enum
    {
        WithSerializer = true,
    };
    static constexpr EPropertyObjectReferenceType WithSerializerObjectReferences = EPropertyObjectReferenceType::None;
};
 
namespace UE
{
namespace MovieScene
{
    MOVIESCENE_API void EvaluateTime(TArrayView<const FFrameNumber> InTimes, FFrameTime InTime, int32& OutIndex1, int32& OutIndex2);
 
 
    MOVIESCENE_API void EvaluateTime(TArrayView<const FFrameNumber> InTimes, FFrameTime InTime, int32& OutIndex1, int32& OutIndex2, double& OutInterp);
 
 
    MOVIESCENE_API void FindRange(TArrayView<const FFrameNumber> InTimes, FFrameNumber PredicateTime, FFrameNumber InTolerance, int32 MaxNum, int32& OutMin, int32& OutMax);
 
} // namespace MovieScene
} // namespace UE
 
 
struct FMovieSceneChannelData
{
    inline TArrayView<const FFrameNumber> GetTimes() const
    {
        return *Times;
    }
 
    inline TArrayView<FFrameNumber> GetTimes()
    {
        return *Times;
    }
 
    MOVIESCENE_API FKeyHandle GetHandle(int32 Index);
 
    MOVIESCENE_API int32 GetIndex(FKeyHandle Handle);
 
    MOVIESCENE_API int32 FindKey(FFrameNumber InTime, FFrameNumber InTolerance = 0);
 
    MOVIESCENE_API void FindKeys(FFrameNumber InTime, int32 MaxNum, int32& OutMinIndex, int32& OutMaxIndex, int32 InTolerance);
 
    MOVIESCENE_API TRange<FFrameNumber> GetTotalRange() const;
 
    UE_DEPRECATED(5.6, "Please use RemapTimes")
    MOVIESCENE_API void ChangeFrameResolution(FFrameRate SourceRate, FFrameRate DestinationRate);
 
    MOVIESCENE_API void GetKeys(const TRange<FFrameNumber>& WithinRange, TArray<FFrameNumber>* OutKeyTimes, TArray<FKeyHandle>* OutKeyHandles);
 
    MOVIESCENE_API void GetKeyTimes(TArrayView<const FKeyHandle> InHandles, TArrayView<FFrameNumber> OutKeyTimes);
 
    MOVIESCENE_API void Offset(FFrameNumber DeltaTime);
 
protected:
 
    MOVIESCENE_API FMovieSceneChannelData(FMovieSceneChannel* InChannel, TArray<FFrameNumber>* InTimes, FKeyHandleLookupTable* InKeyHandles);
 
    UE_DEPRECATED(5.5, "Constructor that takes an optional FMovieSceneChannel is now deprecated. FMovieSceneChannel is now required.")
    MOVIESCENE_API FMovieSceneChannelData(TArray<FFrameNumber>* InTimes, FKeyHandleLookupTable* InKeyHandles, FMovieSceneChannel* InChannel = nullptr);
 
    MOVIESCENE_API int32 MoveKeyInternal(int32 KeyIndex, FFrameNumber InNewTime);
 
    MOVIESCENE_API int32 AddKeyInternal(FFrameNumber InTime);
 
    MOVIESCENE_API void ReplaceKeyHandlesInternal(TConstArrayView<int32> KeyIndices, TConstArrayView<FKeyHandle> NewHandles);
 
protected:
 
    TArray<FFrameNumber>* Times;
 
    FKeyHandleLookupTable* KeyHandles;
 
    FMovieSceneChannel* OwningChannel;
 
};
 
template<typename ValueType>
struct TMovieSceneChannelData : FMovieSceneChannelData
{
    typedef typename TCallTraits<ValueType>::ParamType ParamType;
 
 
    UE_DEPRECATED(5.5, "Constructor that takes an optional FMovieSceneChannel is now deprecated. FMovieSceneChannel is now required.")
    TMovieSceneChannelData(TArray<FFrameNumber>* InTimes, TArray<ValueType>* InValues, FKeyHandleLookupTable* InKeyHandles, FMovieSceneChannel* InChannel = nullptr)
        : FMovieSceneChannelData(InChannel, InTimes, InKeyHandles), Values(InValues) 
    {
        check(Times && Values);
    }
 
 
    TMovieSceneChannelData(TArray<FFrameNumber>* InTimes, TArray<ValueType>* InValues, FMovieSceneChannel* InChannel, FKeyHandleLookupTable* InKeyHandles)
        : FMovieSceneChannelData(InChannel, InTimes, InKeyHandles), Values(InValues)
    {
        check(Times && Values);
    }
    
 
    operator TMovieSceneChannelData<const ValueType>()
    {
        return TMovieSceneChannelData<const ValueType>(Times, Values);
    }
 
    inline TArrayView<const ValueType> GetValues() const
    {
        return *Values;
    }
 
    inline TArrayView<ValueType> GetValues()
    {
        return *Values;
    }
 
    int32 AddKey(FFrameNumber InTime, ParamType InValue)
    {
        int32 KeyIndex = AddKeyInternal(InTime);
        Values->Insert(InValue, KeyIndex);
        if (OwningChannel && OwningChannel->OnKeyAddedEvent().IsBound())
        {
            TArray<FKeyAddOrDeleteEventItem> Items;
            Items.Add(FKeyAddOrDeleteEventItem(KeyIndex, InTime));
            OwningChannel->OnKeyAddedEvent().Broadcast(OwningChannel, Items);
            
        }
        return KeyIndex;
    }
 
    int32 MoveKey(int32 KeyIndex, FFrameNumber NewTime, bool bRemoveDuplicateKeys = false)
    {
        return MoveKey(KeyIndex, NewTime, bRemoveDuplicateKeys, [](const FKeyHandle& KeyHandle){ return true; });
    }
 
    template<typename TCanRemove> requires std::is_invocable_r_v<bool, TCanRemove, const FKeyHandle&>
    int32 MoveKey(int32 KeyIndex, FFrameNumber NewTime, bool bRemoveDuplicateKeys, TCanRemove&& CanRemove)
    {
        if (bRemoveDuplicateKeys)
        {
            FKeyHandle KeyHandle = GetHandle(KeyIndex);
 
            TArray<FKeyHandle> KeysToRemove;
            TArray<FFrameNumber> DummyTimes;
            GetKeys(TRange<FFrameNumber>(NewTime, NewTime), &DummyTimes, &KeysToRemove);
            KeysToRemove.Remove(KeyHandle);
            KeysToRemove.SetNum(Algo::RemoveIf(KeysToRemove, CanRemove));
 
            if (KeysToRemove.Num() > 0)
            {
                DeleteKeys(KeysToRemove);
            }
 
            KeyIndex = GetIndex(KeyHandle);
        }
 
        if (KeyIndex == INDEX_NONE)
        {
            return KeyIndex;
        }
 
        int32 NewIndex = MoveKeyInternal(KeyIndex, NewTime);
        if (NewIndex != KeyIndex)
        {
            // We have to remove the key and re-add it in the right place
            // This could probably be done better by just shuffling up/down the items that need to move, without ever changing the size of the array
            ValueType OldValue = (*Values)[KeyIndex];
            Values->RemoveAt(KeyIndex, EAllowShrinking::No);
            Values->Insert(OldValue, NewIndex);
        }
 
        return NewIndex;
    }
 
    int32 SetKeyTime(int32 KeyIndex, FFrameNumber InNewTime)
    {
        return MoveKey(KeyIndex, InNewTime);
    }
 
 
 
    void RemapTimes(const UE::MovieScene::IRetimingInterface& Retimer)
    {
        using namespace UE::MovieScene;
 
        const int32 Num = Times->Num();
        if (Num == 0)
        {
            return;
        }
 
        bool bIsSorted = true;
        {
            int32 Index = 0;
 
            // Remap the first time
            {
                FFrameNumber& NewTime  = (*Times)[Index];
                FFrameNumber  OldTime  = NewTime;
 
                NewTime = Retimer.RemapTime(OldTime);
                OnRemapChannelKeyTime(OwningChannel, Retimer, OldTime, NewTime, (*Values)[Index]);
            }
            ++Index;
 
            // Remap others keeping track of whether we need resorting
            for ( ; Index < Num; ++Index)
            {
                FFrameNumber& NewTime  = (*Times)[Index];
                FFrameNumber  OldTime  = NewTime;
                FFrameNumber  Previous = (*Times)[Index-1];
 
                NewTime = Retimer.RemapTime(OldTime);
                bIsSorted &= NewTime >= Previous;
 
                OnRemapChannelKeyTime(OwningChannel, Retimer, OldTime, NewTime, (*Values)[Index]);
            }
        }
 
        if (!bIsSorted)
        {
            // Have to re-sort all the keys...
            TArray<int32, TInlineAllocator<128>> Indices;
            for (int32 Index = 0; Index < Num; ++Index)
            {
                Indices.Add(Index);
            }
 
            Algo::Sort(Indices, [this](int32 A, int32 B){
                return (*Times)[A] < (*Times)[B];
            });
 
            for (int32 Index = 0; Index < Num; ++Index)
            {
                KeyHandles->MoveHandle(Index, Indices[Index]);
            }
 
            // Move all the keys by repeatedly swapping until we get the correct index
            for (int32 Index = 0; Index < Num; ++Index)
            {
                while (Indices[Index] != Index)
                {
                    const int32 DestIndex = Indices[Index];
                    Swap((*Times)[Index], (*Times)[DestIndex]);
                    Swap((*Values)[Index], (*Values)[DestIndex]);
                    Swap(Indices[Index], Indices[DestIndex]);
                }
            }
        }
    }
 
    void ReplaceKeyHandle(int32 KeyIndex, FKeyHandle NewHandle)
    {
        ReplaceKeyHandles(TConstArrayView<int32>(&KeyIndex, 1), TConstArrayView<FKeyHandle>(&NewHandle, 1));
    }
    void ReplaceKeyHandles(TConstArrayView<int32> KeyIndices, TConstArrayView<FKeyHandle> NewHandles)
    {
        ReplaceKeyHandlesInternal(KeyIndices, NewHandles);
    }
 
    void RemoveKey(int32 KeyIndex)
    {
        check(Times->IsValidIndex(KeyIndex));
        if (OwningChannel && OwningChannel->OnKeyDeletedEvent().IsBound())
        {
            const FFrameNumber Time = (*Times)[KeyIndex];
            TArray<FKeyAddOrDeleteEventItem> Items;
            Items.Add(FKeyAddOrDeleteEventItem(KeyIndex, Time));
            OwningChannel->OnKeyDeletedEvent().Broadcast(OwningChannel, Items);
        }
        Times->RemoveAt(KeyIndex, EAllowShrinking::No);
        Values->RemoveAt(KeyIndex, EAllowShrinking::No);
 
        if (KeyHandles)
        {
            KeyHandles->DeallocateHandle(KeyIndex);
        }
    }
 
    FKeyHandle UpdateOrAddKey(FFrameNumber InTime, ParamType InValue)
    {
        int32 ExistingKey = FindKey(InTime);
        if (ExistingKey != INDEX_NONE)
        {
            (*Values)[ExistingKey] = InValue;
        }
        else
        {
            ExistingKey = AddKey(InTime, InValue);
        }
 
        return GetHandle(ExistingKey);
    }
 
    void UpdateOrAddKeys(const TArrayView<const FFrameNumber> InTimes, const TArrayView<ValueType> InValues)
    {
        check(InTimes.Num() == InValues.Num());
        const int32 UpdateNum = InTimes.Num();
        int32 CurrIdx = 0;
        int32 UpdateIdx = 0;
 
        while (true)
        {
            if (UpdateIdx == UpdateNum)
            {
                // No more keys to insert
                break;
            }
 
            if (CurrIdx == Times->Num())
            {
                // Append the rest of the keys to the end
                Times->Append(InTimes.RightChop(UpdateIdx));
                Values->Append(InValues.RightChop(UpdateIdx));
                break;
            }
            if ((*Times)[CurrIdx] == InTimes[UpdateIdx])
            {
                // Replace value at the associated time
                (*Values)[CurrIdx] = InValues[UpdateIdx];
                CurrIdx++;
                UpdateIdx++;
                continue;
            }
            if ((*Times)[CurrIdx] > InTimes[UpdateIdx])
            {
                // Insert new time value pair
                Times->Insert(InTimes[UpdateIdx], CurrIdx);
                Values->Insert(InValues[UpdateIdx], CurrIdx);
                CurrIdx++;
                UpdateIdx++;
                continue;
            }
            if ((*Times)[CurrIdx] < InTimes[UpdateIdx])
            {
                // Not found insertion slot yet
                CurrIdx++;
                continue;
            }
        }
        KeyHandles->Reset();
        for (int32 Index = 0; Index < Times->Num(); ++Index)
        {
            KeyHandles->AllocateHandle(Index);
        }
    }
 
    void SetKeyTimes(TArrayView<const FKeyHandle> InHandles, TArrayView<const FFrameNumber> InKeyTimes)
    {
        check(InHandles.Num() == InKeyTimes.Num());
 
        for (int32 Index = 0; Index < InHandles.Num(); ++Index)
        {
            const int32 KeyIndex = GetIndex(InHandles[Index]);
            if (KeyIndex != INDEX_NONE)
            {
                MoveKey(KeyIndex, InKeyTimes[Index]);
            }
        }
    }
 
    void DuplicateKeys(TArrayView<const FKeyHandle> InHandles, TArrayView<FKeyHandle> OutNewHandles)
    {
        for (int32 Index = 0; Index < InHandles.Num(); ++Index)
        {
            const int32 KeyIndex = GetIndex(InHandles[Index]);
            if (KeyIndex == INDEX_NONE)
            {
                // we must add a handle even if the supplied handle does not relate to a key in this channel
                OutNewHandles[Index] = FKeyHandle::Invalid();
            }
            else
            {
                // Do not cache value and time arrays since they can be reallocated during this loop
                auto KeyCopy = (*Values)[KeyIndex];
                int32 NewKeyIndex = AddKey((*Times)[KeyIndex], MoveTemp(KeyCopy));
                OutNewHandles[Index] = GetHandle(NewKeyIndex);
            }
        }
    }
 
    void DeleteKeys(TArrayView<const FKeyHandle> InHandles)
    {
        for (int32 Index = 0; Index < InHandles.Num(); ++Index)
        {
            const int32 KeyIndex = GetIndex(InHandles[Index]);
            if (KeyIndex != INDEX_NONE)
            {
                RemoveKey(KeyIndex);
            }
        }
    }
 
 
    void DeleteKeysFrom(FFrameNumber InTime, bool bDeleteKeysBefore)
    {
        TArray<FFrameNumber> OutKeyTimes;
        TArray<FKeyHandle> OutKeyHandles;
        GetKeys(TRange<FFrameNumber>::All(), &OutKeyTimes, &OutKeyHandles);
 
        TArray<FKeyHandle> KeysToRemove;
        for (int32 Index = 0; Index < OutKeyTimes.Num(); ++Index)
        {
            if (bDeleteKeysBefore)
            {
                if (OutKeyTimes[Index] < InTime)
                {
                    KeysToRemove.Add(OutKeyHandles[Index]);
                }
            }
            else
            {
                if (OutKeyTimes[Index] > InTime)
                {
                    KeysToRemove.Add(OutKeyHandles[Index]);
                }
            }
        }
 
        DeleteKeys(KeysToRemove);
    }
 
    void Reset()
    {
        if (OwningChannel && OwningChannel->OnKeyDeletedEvent().IsBound())
        {
            TArray<FKeyAddOrDeleteEventItem> Items;
            for (int32 Index = 0; Index < Times->Num(); ++Index)
            {
                const FFrameNumber Time = (*Times)[Index];
                Items.Add(FKeyAddOrDeleteEventItem(Index, Time));
            }
            OwningChannel->OnKeyDeletedEvent().Broadcast(OwningChannel, Items);
        }
        Times->Reset();
        Values->Reset();
        if (KeyHandles)
        {
            KeyHandles->Reset();
        }
    }
 
private:
 
    TArray<ValueType>* Values;
 
};
 
 
template<typename ValueType>
struct TMovieSceneChannelData<const ValueType>
{
    typedef typename TCallTraits<ValueType>::ParamType ParamType;
 
 
    TMovieSceneChannelData(const TArray<FFrameNumber>* InTimes, const TArray<ValueType>* InValues)
        : Times(InTimes), Values(InValues)
    {
        check(Times && Values);
    }
 
    inline TArrayView<const FFrameNumber> GetTimes() const
    {
        return *Times;
    }
 
    inline TArrayView<const ValueType> GetValues() const
    {
        return *Values;
    }
 
    int32 FindKey(FFrameNumber InTime, FFrameNumber InTolerance = 0) const
    {
        int32 MinIndex = 0, MaxIndex = 0;
        UE::MovieScene::FindRange(*Times, InTime, InTolerance, 1, MinIndex, MaxIndex);
        return MinIndex;
    }
 
    void FindKeys(FFrameNumber InTime, int32 MaxNum, int32& OutMinIndex, int32& OutMaxIndex, FFrameNumber InTolerance) const
    {
        UE::MovieScene::FindRange(*Times, InTime, InTolerance, MaxNum, OutMinIndex, OutMaxIndex);
    }
 
    TRange<FFrameNumber> GetTotalRange() const
    {
        return Times->Num() ? TRange<FFrameNumber>((*Times)[0], TRangeBound<FFrameNumber>::Inclusive((*Times)[Times->Num()-1])) : TRange<FFrameNumber>::Empty();
    }
 
private:
 
    const TArray<FFrameNumber>* Times;
 
    const TArray<ValueType>* Values;
};