IKeyFrameManipulator.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Curves/KeyHandle.h"
 
template<typename TimeType> class TKeyFrameManipulator;
template<typename TimeType> struct TKeyTimeIterator;
 
template<typename TimeType = float>
class IKeyFrameManipulator
{
public:
 
    // Pass by value/ref parameter type
    typedef typename TCallTraits<TimeType>::ParamType TimeTypeRef;
 
    inline FKeyHandle AddKey(TimeTypeRef InTime)
    {
        return AddKeyImpl(InTime);
    }
 
    inline void SetKeyTime(FKeyHandle KeyHandle, TimeTypeRef NewTime)
    {
        SetKeyTimeImpl(KeyHandle, NewTime);
    }
 
 
    inline void RemoveKey(FKeyHandle KeyHandle)
    {
        RemoveKeyImpl(KeyHandle);
    }
 
    inline TOptional<TimeType> GetKeyTime(FKeyHandle KeyHandle) const
    {
        return GetKeyTimeImpl(KeyHandle);
    }
 
    inline TOptional<FKeyHandle> FindKey(TimeTypeRef KeyTime, TimeTypeRef KeyTimeTolerance) const
    {
        auto Predicate = [=](TimeTypeRef InTime) { return FMath::IsNearlyEqual(KeyTime, KeyTimeTolerance); };
        return FindKeyImpl(Predicate);
    }
 
private:
 
    virtual FKeyHandle AddKeyImpl(TimeTypeRef InTime) = 0;
 
    virtual void SetKeyTimeImpl(FKeyHandle KeyHandle, TimeTypeRef NewTime) = 0;
 
    virtual void RemoveKeyImpl(FKeyHandle KeyHandle) = 0;
 
    virtual TOptional<TimeType> GetKeyTimeImpl(FKeyHandle KeyHandle) const = 0;
 
    virtual TOptional<FKeyHandle> FindKeyImpl(const TFunctionRef<bool(TimeTypeRef)>& InPredicate) const = 0;
 
    virtual TKeyTimeIterator<TimeType> IterateKeysImpl() const = 0;
};
 
template<typename> class TKeyFrameManipulator;
 
template<typename TimeType>
struct TKeyTimeIterator
{
    TKeyTimeIterator(const TKeyFrameManipulator<TimeType>& InManipulator)
        : Manipulator(InManipulator)
        , Index(0)
    {}
 
    inline TKeyTimeIterator& operator++()
    {
        ++Index;
        return *this;
    }
 
    inline explicit operator bool() const
    { 
        return Index < Manipulator.KeyTimes->Num();
    }
    inline bool operator !() const 
    {
        return !(bool)*this;
    }
 
    inline bool operator==(const TKeyTimeIterator& RHS) const
    {
        return Manipulator.KeyTimes == RHS.Manipulator.KeyTimes && Index == RHS.Index;
    }
 
    inline friend bool operator!=(const TKeyTimeIterator& LHS, const TKeyTimeIterator& RHS)
    {
        return !(LHS == RHS);
    }
 
    inline TimeType operator*() const
    {
        return (*Manipulator.KeyTimes)[Index];
    }
 
    FKeyHandle GetKeyHandle()
    {
        return Manipulator.KeyHandleLUT->FindOrAddKeyHandle(Index);
    }
 
    int32 GetStartIndex() const
    {
        return 0;
    }
 
    int32 GetEndIndex() const
    {
        return Manipulator.KeyTimes->Num();
    }
 
    inline friend TKeyTimeIterator<TimeType> begin(const TKeyTimeIterator<TimeType>& Iter)
    {
        TKeyTimeIterator<TimeType> NewIter = Iter;
        NewIter.Index = Iter.GetStartIndex();
        return NewIter;
    }
    inline friend TKeyTimeIterator<TimeType> end  (const TKeyTimeIterator<TimeType>& Iter)
    {
        TKeyTimeIterator<TimeType> NewIter = Iter;
        NewIter.Index = NewIter.GetEndIndex();
        return NewIter;
    }
 
private:
    const TKeyFrameManipulator<TimeType>& Manipulator;
    int32 Index;
};