KeyFrameManipulator.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Curves/KeyHandle.h"
#include "Curves/IKeyFrameManipulator.h"
 
template<typename TimeType> struct TKeyTimeIterator;
 
template<typename TimeType>
class TKeyFrameManipulator : IKeyFrameManipulator<TimeType>
{
public:
    // Pass by value/ref parameter type
    typedef typename TCallTraits<TimeType>::ParamType TimeTypeRef;
 
    TKeyFrameManipulator(TArray<TimeType>* KeyTimesParam, FKeyHandleLookupTable* ExternalKeyHandleLUT = nullptr)
        : KeyTimes(KeyTimesParam)
        , KeyHandleLUT(ExternalKeyHandleLUT)
    {
        check(KeyTimes);
 
        if (!KeyHandleLUT)
        {
            KeyHandleLUT = &TemporaryKeyHandleLUT;
            for (int32 TimeIndex = 0; TimeIndex < KeyTimes->Num(); ++TimeIndex)
            {
                FKeyHandle Handle = KeyHandleLUT->AllocateHandle(TimeIndex);
            }
        }
    }
 
    TKeyFrameManipulator(const TKeyFrameManipulator& Rhs)
        : KeyTimes(Rhs.KeyTimes)
        , KeyHandleLUT(Rhs.KeyHandleLUT == &Rhs.TemporaryKeyHandleLUT ? &TemporaryKeyHandleLUT : Rhs.KeyHandleLUT)
        , TemporaryKeyHandleLUT(Rhs.TemporaryKeyHandleLUT)
    {}
 
    TKeyFrameManipulator& operator=(const TKeyFrameManipulator& Rhs)
    {
        if (&Rhs != this)
        {
            KeyTimes = Rhs.KeyTimes;
            KeyHandleLUT = Rhs.KeyHandleLUT == &Rhs.TemporaryKeyHandleLUT ? &TemporaryKeyHandleLUT : Rhs.KeyHandleLUT;
            TemporaryKeyHandleLUT = Rhs.TemporaryKeyHandleLUT;
        }
        return *this;
    }
 
    TKeyFrameManipulator(TKeyFrameManipulator&& Rhs)
        : KeyTimes(Rhs.KeyTimes)
        , KeyHandleLUT(Rhs.KeyHandleLUT == &Rhs.TemporaryKeyHandleLUT ? &TemporaryKeyHandleLUT : Rhs.KeyHandleLUT)
        , TemporaryKeyHandleLUT(MoveTemp(Rhs.TemporaryKeyHandleLUT))
    {}
 
    TKeyFrameManipulator& operator=(TKeyFrameManipulator&& Rhs)
    {
        if (&Rhs != this)
        {
            KeyTimes = Rhs.KeyTimes;
            KeyHandleLUT = Rhs.KeyHandleLUT == &Rhs.TemporaryKeyHandleLUT ? &TemporaryKeyHandleLUT : Rhs.KeyHandleLUT;
            TemporaryKeyHandleLUT = MoveTemp(Rhs.TemporaryKeyHandleLUT);
        }
        return *this;
    }
 
    virtual ~TKeyFrameManipulator() {}
 
private:
 
    virtual void OnKeyAdded(int32 Index) {}
    virtual void OnKeyRelocated(int32 OldIndex, int32 NewIndex) {}
    virtual void OnKeyRemoved(int32 Index) {}
    virtual void OnReset() {}
 
private:
 
    virtual FKeyHandle AddKeyImpl(TimeTypeRef InTime) override { return AddKey(InTime); }
    virtual void SetKeyTimeImpl(FKeyHandle KeyHandle, TimeTypeRef NewTime) override { SetKeyTime(KeyHandle, NewTime); }
    virtual void RemoveKeyImpl(FKeyHandle KeyHandle) override { RemoveKey(KeyHandle); }
    virtual TOptional<TimeType> GetKeyTimeImpl(FKeyHandle KeyHandle) const override { return GetKeyTime(KeyHandle); }
    virtual TOptional<FKeyHandle> FindKeyImpl(const TFunctionRef<bool(TimeTypeRef)>& InPredicate) const override { return FindKey(InPredicate); }
    virtual TKeyTimeIterator<TimeType> IterateKeysImpl() const override { return IterateKeys(); }
 
public:
 
    FKeyHandle AddKey(TimeTypeRef InTime)
    {
        int32 InsertIndex = ComputeInsertIndex(InTime);
 
        FKeyHandle Handle = InsertKeyImpl(InTime, InsertIndex);
        OnKeyAdded(InsertIndex);
 
        return Handle;
    }
 
    void SetKeyTime(FKeyHandle KeyHandle, TimeTypeRef NewTime)
    {
        const int32 ExistingIndex = KeyHandleLUT->GetIndex(KeyHandle);
        if (ExistingIndex == INDEX_NONE)
        {
            return;
        }
 
        (*KeyTimes)[ExistingIndex] = NewTime;
 
        int32 NewIndex = ComputeInsertIndex(NewTime, ExistingIndex);
        if (NewIndex != ExistingIndex)
        {
            // Need to move the key
            RelocateKeyImpl(ExistingIndex, NewIndex);
            OnKeyRelocated(ExistingIndex, NewIndex);
        }
    }
 
 
    void RemoveKey(FKeyHandle KeyHandle)
    {
        int32 RemoveAtIndex = GetIndex(KeyHandle);
        if (RemoveAtIndex != INDEX_NONE)
        {
            KeyTimes->RemoveAtSwap(RemoveAtIndex, EAllowShrinking::No);
            KeyHandleLUT->DeallocateHandle(RemoveAtIndex);
 
            OnKeyRemoved(RemoveAtIndex);
        }
    }
 
    void Reset()
    {
        KeyTimes->Empty();
        KeyHandleLUT->Reset();
        OnReset();
    }
 
public:
 
    TOptional<TimeType> GetKeyTime(FKeyHandle KeyHandle) const
    {
        const int32 Index = KeyHandleLUT->GetIndex(KeyHandle);
        return Index == INDEX_NONE ? TOptional<TimeType>() : (*KeyTimes)[Index];
    }
 
    TOptional<FKeyHandle> FindKey(const TFunctionRef<bool(TimeTypeRef)>& InPredicate) const
    {
        for (int32 Index = 0; Index < KeyTimes->Num(); ++Index)
        {
            if (InPredicate((*KeyTimes)[Index]))
            {
                return KeyHandleLUT->FindOrAddKeyHandle(Index);
            }
        }
 
        return TOptional<FKeyHandle>();
    }
 
    TKeyTimeIterator<TimeType> IterateKeys() const
    {
        return TKeyTimeIterator<TimeType>(*this);
    }
 
protected:
 
    int32 ComputeInsertIndex(TimeTypeRef InTime, int32 StartAtIndex = 0) const
    {
        for(; StartAtIndex < KeyTimes->Num() && (*KeyTimes)[StartAtIndex] < InTime; ++StartAtIndex);
        return StartAtIndex;
    }
 
    FKeyHandle InsertKeyImpl(TimeTypeRef Time, int32 InsertIndex) const
    {
        KeyTimes->Insert(Time, InsertIndex);
        return KeyHandleLUT->AllocateHandle(InsertIndex);
    }
 
    TimeType GetKeyTimeChecked(int32 KeyIndex) const
    {
        return (*KeyTimes)[KeyIndex];
    }
 
    int32 GetIndex(FKeyHandle KeyHandle) const
    {
        return KeyHandleLUT->GetIndex(KeyHandle);
    }
    
    FKeyHandle GetKeyHandleFromIndex(int32 Index) const
    {
        return KeyTimes->IsValidIndex(Index) ? KeyHandleLUT->FindOrAddKeyHandle(Index) : FKeyHandle();
    }
 
    void RelocateKeyImpl(int32 OldIndex, int32 NewIndex)
    {
        if (OldIndex == NewIndex || OldIndex < 0 || NewIndex < 0)
        {
            return;
        }
 
        check(KeyTimes->IsValidIndex(OldIndex));
 
        TimeType Time = (*KeyTimes)[OldIndex];
 
        KeyTimes->RemoveAtSwap(OldIndex, EAllowShrinking::No);
        KeyTimes->Insert(Time, NewIndex);
 
        KeyHandleLUT->MoveHandle(OldIndex, NewIndex);
    }
 
private:
 
    friend TKeyTimeIterator<TimeType>;
 
    TArray<TimeType>* KeyTimes;
 
    FKeyHandleLookupTable* KeyHandleLUT;
 
    mutable FKeyHandleLookupTable TemporaryKeyHandleLUT;
};