MovieSceneTestDataBuilders.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Channels/MovieSceneChannelHandle.h"
#include "Channels/MovieSceneChannelTraits.h"
#include "Channels/MovieSceneChannelProxy.h"
#include "CoreTypes.h"
#include "Generators/MovieSceneEasingCurves.h"
#include "IMovieScenePlayer.h"
#include "KeyParams.h"
#include "MovieScene.h"
#include "MovieSceneSection.h"
#include "MovieSceneSequence.h"
#include "Templates/EnableIf.h"
#include "Templates/PointerIsConvertibleFromTo.h"
#include "Tracks/MovieScenePropertyTrack.h"
 
#include "MovieSceneTestDataBuilders.generated.h"
 
UCLASS(MinimalAPI)
class UMovieSceneTestSequence : public UMovieSceneSequence
{
    GENERATED_BODY()
 
public:
    UPROPERTY()
    TObjectPtr<UMovieScene> MovieScene;
 
public:
    MOVIESCENETRACKS_API void Initialize();
 
    MOVIESCENETRACKS_API FGuid AddObjectBinding(TObjectPtr<UObject> InObject);
 
public:
    virtual void BindPossessableObject(const FGuid& ObjectId, UObject& PossessedObject, UObject* Context) override {}
    virtual bool CanPossessObject(UObject& Object, UObject* InPlaybackContext) const override { return true; }
    MOVIESCENETRACKS_API virtual void LocateBoundObjects(const FGuid& ObjectId, UObject* Context, TArray<UObject*, TInlineAllocator<1>>& OutObjects) const override;
    virtual UMovieScene* GetMovieScene() const override { return MovieScene; }
    virtual UObject* GetParentObject(UObject* Object) const override { return nullptr; }
    virtual void UnbindPossessableObjects(const FGuid& ObjectId) override {}
    virtual void UnbindObjects(const FGuid& ObjectId, const TArray<UObject*>& InObjects, UObject* Context) override {}
    virtual void UnbindInvalidObjects(const FGuid& ObjectId, UObject* Context) override {}
 
private:
    UPROPERTY()
    TArray<TObjectPtr<UObject>> BoundObjects;
 
    UPROPERTY()
    TArray<FGuid> BindingGuids;
};
 
namespace UE::MovieScene::Test
{
 
template<typename TrackClass> struct FSequenceTrackBuilder;
template<typename TrackClass> struct FSequenceSectionBuilder;
 
struct FSequenceBuilder
{
    TObjectPtr<UMovieSceneTestSequence> Sequence;
    FGuid CurrentBinding;
 
    FSequenceBuilder()
    {
        Sequence = NewObject<UMovieSceneTestSequence>();
        Sequence->Initialize();
    }
 
    FSequenceBuilder& AddObjectBinding(TObjectPtr<UObject> InObject)
    {
        CurrentBinding = Sequence->AddObjectBinding(InObject);
        return *this;
    }
 
    FSequenceBuilder& AddObjectBinding(TObjectPtr<UObject> InObject, FGuid& OutBindingID)
    {
        AddObjectBinding(InObject);
        OutBindingID = CurrentBinding;
        return *this;
    }
 
    template<typename TrackClass>
    FSequenceTrackBuilder<TrackClass> AddRootTrack()
    {
        UMovieScene* MovieScene = Sequence->GetMovieScene();
        TrackClass* Track = MovieScene->AddTrack<TrackClass>();
        return FSequenceTrackBuilder<TrackClass>(*this, Track);
    }
 
    template<typename TrackClass>
    FSequenceTrackBuilder<TrackClass> AddTrack()
    {
        checkf(CurrentBinding.IsValid(), TEXT("Specify an object binding first with AddObjectBinding"));
        UMovieScene* MovieScene = Sequence->GetMovieScene();
        TrackClass* Track = MovieScene->AddTrack<TrackClass>(CurrentBinding);
        return FSequenceTrackBuilder<TrackClass>(*this, Track);
    }
 
    template<typename TrackClass>
    FSequenceTrackBuilder<TrackClass> AddPropertyTrack(FName InPropertyName)
    {
        checkf(CurrentBinding.IsValid(), TEXT("Specify an object binding first with AddObjectBinding"));
        UMovieScene* MovieScene = Sequence->GetMovieScene();
        TrackClass* Track = MovieScene->AddTrack<TrackClass>(CurrentBinding);
        Track->SetPropertyNameAndPath(InPropertyName, InPropertyName.ToString());
        return FSequenceTrackBuilder<TrackClass>(*this, Track);
    }
};
 
template<typename TrackClass>
struct FSequenceTrackBuilder
{
    FSequenceBuilder& Parent;
    TObjectPtr<TrackClass> Track;
 
    FSequenceTrackBuilder(FSequenceBuilder& InParent, TrackClass* InTrack)
        : Parent(InParent), Track(InTrack)
    {}
 
    FSequenceTrackBuilder& Assign(TrackClass*& OutTrack)
    {
        OutTrack = Track;
        return *this;
    }
 
    template<typename Func>
    FSequenceBuilder& Do(Func&& Callback)
    {
        Callback(Track);
        return *this;
    }
 
    FSequenceSectionBuilder<TrackClass> AddSection(FFrameNumber InStart, FFrameNumber InEnd, int32 InRowIndex = INDEX_NONE)
    {
        UMovieSceneSection* NewSection = Track->CreateNewSection();
        NewSection->SetRange(TRange<FFrameNumber>(InStart, InEnd));
        if (InRowIndex != INDEX_NONE)
        {
            NewSection->SetRowIndex(InRowIndex);
        }
        Track->AddSection(*NewSection);
        return FSequenceSectionBuilder<TrackClass>(*this, NewSection);
    }
 
    FSequenceBuilder& Pop() { return Parent; }
};
 
template<typename ParentTrackClass>
struct FSequenceSectionBuilder
{
    FSequenceTrackBuilder<ParentTrackClass>& Parent;
    TObjectPtr<UMovieSceneSection> Section;
 
    FSequenceSectionBuilder(FSequenceTrackBuilder<ParentTrackClass>& InParent, UMovieSceneSection* InSection)
        : Parent(InParent), Section(InSection)
    {}
 
    FSequenceSectionBuilder& Assign(UMovieSceneSection*& OutSection)
    {
        OutSection = Section;
        return *this;
    }
 
    template<typename SectionClass>
    FSequenceSectionBuilder& Assign(SectionClass*& OutSection)
    {
        OutSection = Cast<SectionClass>(Section);
        return *this;
    }
 
    FSequenceSectionBuilder& SetBlendType(EMovieSceneBlendType InBlendType)
    {
        Section->SetBlendType(InBlendType);
        return *this;
    }
 
    FSequenceSectionBuilder& SetEaseIn(int32 InDurationTicks, EMovieSceneBuiltInEasing InEasingType = EMovieSceneBuiltInEasing::Linear)
    {
        FMovieSceneEasingSettings& Easing = Section->Easing;
        Easing.bManualEaseIn = true;
        Easing.ManualEaseInDuration = InDurationTicks;
        if (UMovieSceneBuiltInEasingFunction* Function = Cast<UMovieSceneBuiltInEasingFunction>(Easing.EaseIn.GetObject()))
        {
            Function->Type = InEasingType;
        }
        return *this;
    }
 
    FSequenceSectionBuilder& SetEaseOut(int32 InDurationTicks, EMovieSceneBuiltInEasing InEasingType = EMovieSceneBuiltInEasing::Linear)
    {
        FMovieSceneEasingSettings& Easing = Section->Easing;
        Easing.bManualEaseOut = true;
        Easing.ManualEaseOutDuration = InDurationTicks;
        if (UMovieSceneBuiltInEasingFunction* Function = Cast<UMovieSceneBuiltInEasingFunction>(Easing.EaseOut.GetObject()))
        {
            Function->Type = InEasingType;
        }
        return *this;
    }
 
    template<typename ChannelType, typename ValueType>
    FSequenceSectionBuilder& AddKey(
            int32 InChannelIndex,
            FFrameNumber InTime,
            ValueType InValue,
            EMovieSceneKeyInterpolation Interpolation = EMovieSceneKeyInterpolation::Auto)
    {
        FMovieSceneChannelProxy& ChannelProxy = Section->GetChannelProxy();
        ChannelType* Channel = ChannelProxy.GetChannel<ChannelType>(InChannelIndex);
        return AddKeys(Channel, TArray<FFrameNumber>({ InTime }), TArray<ValueType>({ InValue }), Interpolation);
    }
 
    template<typename ChannelType, typename ValueType>
    FSequenceSectionBuilder& AddKeys(
            int32 InChannelIndex,
            const TArray<FFrameNumber>& InTimes,
            const TArray<ValueType>& InValues,
            EMovieSceneKeyInterpolation Interpolation = EMovieSceneKeyInterpolation::Auto)
    {
        FMovieSceneChannelProxy& ChannelProxy = Section->GetChannelProxy();
        ChannelType* Channel = ChannelProxy.GetChannel<ChannelType>(InChannelIndex);
        return AddKeys(Channel, InTimes, InValues, Interpolation);
    }
 
#if WITH_EDITOR
    template<typename ChannelType, typename ValueType>
    FSequenceSectionBuilder& AddKeys(
            FName InChannelName, 
            const TArray<FFrameNumber>& InTimes,
            const TArray<ValueType>& InValues,
            EMovieSceneKeyInterpolation Interpolation = EMovieSceneKeyInterpolation::Auto)
    {
        FMovieSceneChannelProxy& ChannelProxy = Section->GetChannelProxy();
        TMovieSceneChannelHandle<ChannelType> ChannelHandle = ChannelProxy.GetChannelByName<ChannelType>(InChannelName);
        return AddKeys(ChannelHandle.Get(), InTimes, InValues, Interpolation);
    }
#endif
 
    template<typename ChannelType, typename ValueType>
    FSequenceSectionBuilder& AddKeys(
            ChannelType* InChannel,
            const TArray<FFrameNumber>& InTimes, 
            const TArray<ValueType>& InValues, 
            EMovieSceneKeyInterpolation Interpolation = EMovieSceneKeyInterpolation::Auto)
    {
        ensure(InTimes.Num() == InValues.Num());
        int32 Num = FMath::Min(InTimes.Num(), InValues.Num());
        for (int32 Index = 0; Index < Num; ++Index)
        {
            AddKeyToChannel(InChannel, InTimes[Index], InValues[Index], Interpolation);
        }
        return *this;
    }
 
    template<typename Func>
    FSequenceSectionBuilder& Do(Func&& Callback)
    {
        Callback(Section);
        return *this;
    }
 
    template<typename SectionClass, typename Func>
    FSequenceSectionBuilder& Do(Func&& Callback)
    {
        Callback(Cast<SectionClass>(Section));
        return *this;
    }
 
    FSequenceTrackBuilder<ParentTrackClass>& Pop() { return Parent; }
};
 
} // namespace UE::MovieScene::Test