MovieSceneClipboard.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "CoreMinimal.h"
#include "Evaluation/MovieSceneTimeTransform.h"
#include "HAL/Platform.h"
#include "Internationalization/Text.h"
#include "Misc/AssertionMacros.h"
#include "Misc/DateTime.h"
#include "Misc/FrameNumber.h"
#include "Misc/FrameRate.h"
#include "Misc/FrameTime.h"
#include "Misc/InlineValue.h"
#include "Misc/Optional.h"
#include "MovieSceneTrack.h"
#include "Templates/Function.h"
#include "Templates/UnrealTemplate.h"
#include "Templates/UnrealTypeTraits.h"
#include "UObject/NameTypes.h"
#include "UObject/Object.h"
#include "UObject/UnrealNames.h"
 
#if WITH_EDITOR
 
 
namespace MovieSceneClipboard
{
    template<typename T> static FName GetKeyTypeName()
    {
        // Use the template type here to stop the compiler generating the code unless it's actually used
        static_assert(!std::is_same_v<T, T>, "This function must be specialized to use with the specified type");
        return NAME_None;
    }
}
 
class UMovieSceneTrack;
 
class FMovieSceneClipboardKey
{
public:
    template<typename T>
    FMovieSceneClipboardKey(FFrameNumber InTime, T InValue)
        : Time(InTime)
        , Data(TKey<T>(MoveTemp(InValue)))
    {
    }
 
    MOVIESCENE_API FMovieSceneClipboardKey(const FMovieSceneClipboardKey& In);
    MOVIESCENE_API FMovieSceneClipboardKey& operator=(const FMovieSceneClipboardKey& In);
 
    MOVIESCENE_API FFrameNumber GetTime() const;
 
    MOVIESCENE_API void SetTime(FFrameNumber InTime);
 
    template<typename T>
    T GetValue() const
    {
        T Default = T();
        TryGetValue<T>(Default);
        return Default;
    }
 
    template<typename T>
    bool TryGetValue(T& Value) const
    {
        if (!Data.IsValid())
        {
            return false;
        }
 
        // Check for same type
        if (Data->GetTypeName() == MovieSceneClipboard::GetKeyTypeName<T>())
        {
            Value = static_cast<const TKey<T>&>(Data.GetValue()).Value;
            return true;
        }
 
        // Check for conversion possibility
        FConversionFunction* ConversionFunction = Data->FindConversionTo(MovieSceneClipboard::GetKeyTypeName<T>());
        if (ConversionFunction)
        {
            FMovieSceneClipboardKey Key = ConversionFunction->operator()(*this);
            Value = static_cast<const TKey<T>&>(Key.Data.GetValue()).Value;
            return true;
        }
 
        return false;
    }
 
private:
 
    typedef TFunction<FMovieSceneClipboardKey(const FMovieSceneClipboardKey&)> FConversionFunction;
 
    struct IKey
    {
        virtual ~IKey() {}
        virtual void CopyTo(TInlineValue<IKey, 64>& OutDest) const = 0;
        virtual FConversionFunction* FindConversionTo(FName DestinationTypeName) const = 0;
        virtual FName GetTypeName() const = 0;
    };
 
    template<typename T>
    struct TKey : IKey
    {
        TKey(T InValue) : Value(MoveTemp(InValue)) {}
 
        virtual FConversionFunction* FindConversionTo(FName DestinationTypeName) const
        {
            TMap<FName, FConversionFunction>* ConversionBucket = ConversionMap.Find(MovieSceneClipboard::GetKeyTypeName<T>());
            if (ConversionBucket)
            {
                return ConversionBucket->Find(DestinationTypeName);
            }
            return nullptr;
        }
 
        virtual FName GetTypeName() const
        {
            return MovieSceneClipboard::GetKeyTypeName<T>();
        }
 
        virtual void CopyTo(TInlineValue<IKey, 64>& OutDest) const
        {
            OutDest = TKey(Value);
        }
 
        T Value;
    };
 
    FFrameNumber Time;
 
    TInlineValue<IKey, 64> Data;
 
public:
 
    template<typename FromType, typename ToType>
    static void DefineConversion(TFunction<ToType(const FromType&)> InFunction)
    {
        auto Facade = [=](const FMovieSceneClipboardKey& InKey) -> FMovieSceneClipboardKey {
            const TKey<FromType>& TypedKey = static_cast<const TKey<FromType>&>(InKey.Data.GetValue());
 
            return FMovieSceneClipboardKey(InKey.GetTime(), InFunction(TypedKey.Value));
        };
 
        ConversionMap
            .Add(MovieSceneClipboard::GetKeyTypeName<FromType>())
            .Add(MovieSceneClipboard::GetKeyTypeName<ToType>(), Facade);
    }
 
private:
    static MOVIESCENE_API TMap<FName, TMap<FName, FConversionFunction>> ConversionMap;
};
 
class FMovieSceneClipboardKeyTrack
{
public:
 
    template<typename KeyType>
    static FMovieSceneClipboardKeyTrack Create(FName InName, FFrameNumber KeyOffset = 0)
    {
        FMovieSceneClipboardKeyTrack Track;
        Track.TypeName = MovieSceneClipboard::GetKeyTypeName<KeyType>();
        Track.Name = MoveTemp(InName);
        Track.KeyOffset = KeyOffset;
        return Track;
    }
 
public:
 
    MOVIESCENE_API FMovieSceneClipboardKeyTrack(FMovieSceneClipboardKeyTrack&& In);
    MOVIESCENE_API FMovieSceneClipboardKeyTrack& operator=(FMovieSceneClipboardKeyTrack&& In);
 
    MOVIESCENE_API FMovieSceneClipboardKeyTrack(const FMovieSceneClipboardKeyTrack& In);
    MOVIESCENE_API FMovieSceneClipboardKeyTrack& operator=(const FMovieSceneClipboardKeyTrack& In);
 
    template<typename KeyType>
    bool IsKeyOfType() const
    {
        return TypeName == MovieSceneClipboard::GetKeyTypeName<KeyType>();
    }
 
    template<typename KeyType>
    void AddKey(FFrameNumber Time, KeyType Value)
    {
        Time -= KeyOffset;
 
        checkf(IsKeyOfType<KeyType>(), TEXT("Unable to add a key of a different value type to the track"));
        Keys.Add(FMovieSceneClipboardKey(Time, MoveTemp(Value)));
    }
 
    bool IterateKeys(TFunctionRef<bool(const FMovieSceneClipboardKey& Key)> Iter) const
    {
        for (const FMovieSceneClipboardKey& Key : Keys)
        {
            if (!Iter(Key))
            {
                return false;
            }
        }
        return true;
    }
    bool IterateKeys(TFunctionRef<bool(FMovieSceneClipboardKey& Key)> Iter)
    {
        for (FMovieSceneClipboardKey& Key : Keys)
        {
            if (!Iter(Key))
            {
                return false;
            }
        }
        return true;
    }
 
    MOVIESCENE_API const FName& GetName() const;
 
private:
 
    FMovieSceneClipboardKeyTrack()
    {}
 
    TArray<FMovieSceneClipboardKey> Keys;
 
    FName TypeName;
 
    FName Name;
 
    FFrameNumber KeyOffset;
};
 
struct FMovieSceneClipboardEnvironment
{
    FMovieSceneClipboardEnvironment()
        : CardinalTime(0)
        , DateTime(FDateTime::UtcNow())
    {}
 
    FFrameTime CardinalTime;
 
    FMovieSceneTimeTransform TimeTransform;
 
    FDateTime DateTime;
 
    FFrameRate TickResolution;
};
 
class FMovieSceneClipboard
{
public:
    MOVIESCENE_API FMovieSceneClipboard();
 
    MOVIESCENE_API FMovieSceneClipboard(FMovieSceneClipboard&& In);
    MOVIESCENE_API FMovieSceneClipboard& operator=(FMovieSceneClipboard&& In);
 
    MOVIESCENE_API FMovieSceneClipboard(const FMovieSceneClipboard& In);
    MOVIESCENE_API FMovieSceneClipboard& operator=(const FMovieSceneClipboard& In);
 
    MOVIESCENE_API const TArray<TArray<FMovieSceneClipboardKeyTrack>>& GetKeyTrackGroups() const;
 
    MOVIESCENE_API FText GetDisplayText() const;
 
    MOVIESCENE_API const FMovieSceneClipboardEnvironment& GetEnvironment() const;
 
    MOVIESCENE_API FMovieSceneClipboardEnvironment& GetEnvironment();
 
private:
    friend class FMovieSceneClipboardBuilder;
 
    FMovieSceneClipboardEnvironment Environment;
 
    TArray<TArray<FMovieSceneClipboardKeyTrack>> KeyTrackGroups;
};
 
class FMovieSceneClipboardBuilder
{
public:
 
    FFrameNumber KeyOffset;
 
    MOVIESCENE_API FMovieSceneClipboard Commit(TOptional<FFrameNumber> CopyRelativeTo);
 
    template<typename KeyType>
    FMovieSceneClipboardKeyTrack& FindOrAddKeyTrack(FName InName, UMovieSceneTrack& ParentTrack)
    {
        check(IsValid(&ParentTrack));
 
        TArray<FMovieSceneClipboardKeyTrack>& Tracks = TrackIndex.FindOrAdd(&ParentTrack);
 
        FMovieSceneClipboardKeyTrack* Existing = Tracks.FindByPredicate([&](const FMovieSceneClipboardKeyTrack& In){
            return In.GetName() == InName;
        });
 
        if (Existing)
        {
            return *Existing;
        }
 
        int32 Index = Tracks.Num();
        Tracks.Add(FMovieSceneClipboardKeyTrack::Create<KeyType>(MoveTemp(InName)));
        return Tracks.GetData()[Index];
    }
 
private:
    TMap<UMovieSceneTrack*, TArray<FMovieSceneClipboardKeyTrack>> TrackIndex;
};
 
namespace MovieSceneClipboard
{
    template<typename From, typename To>
    struct TImplicitConversionFacade
    {
        static To Cast(const From& Value) { return Value; }
    };
 
    template<typename From>
    struct TImplicitConversionFacade<From, bool>
    {
        static bool Cast(const From& Value) { return !!Value; }
    };
 
    template<typename From, typename To>
    void DefineExplicitConversion(TFunction<To(const From&)> InConversion)
    {
        FMovieSceneClipboardKey::DefineConversion<From, To>(InConversion);
    }
 
    template<typename From, typename To>
    void DefineImplicitConversion()
    {
        DefineExplicitConversion<From, To>(&TImplicitConversionFacade<From, To>::Cast);
    }
}
 
#endif