MovieScene.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "EditorSequenceNavigationDefs.h"
#include "EventHandlers/MovieSceneDataEventContainer.h"
#include "Decorations/MovieSceneDecorationContainer.h"
#include "HAL/PlatformCrt.h"
#include "Internationalization/Text.h"
#include "Math/Color.h"
#include "Math/Range.h"
#include "Misc/FrameNumber.h"
#include "Misc/FrameRate.h"
#include "Misc/Guid.h"
#include "MovieSceneBinding.h"
#include "MovieSceneFrameMigration.h"
#include "MovieSceneFwd.h"
#include "MovieSceneMarkedFrame.h"
#include "MovieSceneObjectBindingID.h"
#include "MovieScenePossessable.h"
#include "MovieSceneSequenceID.h"
#include "MovieSceneSignedObject.h"
#include "MovieSceneSpawnable.h"
#include "MovieSceneTimeController.h"
#include "MovieSceneTrack.h"
#include "Templates/Casts.h"
#include "Templates/SharedPointer.h"
#include "Templates/SubclassOf.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/NameTypes.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ObjectPtr.h"
#include "UObject/SoftObjectPath.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/UnrealNames.h"
#include "UObject/WeakObjectPtrTemplates.h"
 
#include "MovieScene.generated.h"
 
class FArchive;
class FObjectPreSaveContext;
class UClass;
class UMovieSceneClock;
class UK2Node;
class UMovieSceneFolder;
class UMovieSceneSection;
class UMovieSceneTrack;
class UMovieSceneGroupCondition;
namespace UE { namespace MovieScene { class ISequenceDataEventHandler; } }
struct FMovieSceneChannelMetaData;
struct FMovieSceneTimeController;
struct FMovieSceneTimecodeSource;
template <typename FuncType> class TFunctionRef;
 
//delegates for use when some data in the MovieScene changes, WIP right now, hopefully will replace delegates on ISequencer
//and be used for moving towards a true MVC system
DECLARE_MULTICAST_DELEGATE_TwoParams(FMovieSceneOnChannelChanged, const FMovieSceneChannelMetaData* MetaData, UMovieSceneSection*)
 
 
 
USTRUCT()
struct FMovieSceneExpansionState
{
    GENERATED_BODY()
 
    FMovieSceneExpansionState(bool bInExpanded = true) : bExpanded(bInExpanded) {}
 
    UPROPERTY()
    bool bExpanded;
};
 
USTRUCT()
struct FMovieSceneEditorData
{
    GENERATED_USTRUCT_BODY()
 
    FMovieSceneEditorData()
        : ViewStart(0.0), ViewEnd(0.0)
        , WorkStart(0.0), WorkEnd(0.0)
    {}
 
    TRange<double> GetViewRange() const
    {
        return TRange<double>(ViewStart, ViewEnd);
    }
 
    TRange<double> GetWorkingRange() const
    {
        return TRange<double>(WorkStart, WorkEnd);
    }
 
    UPROPERTY()
    TMap<FString, FMovieSceneExpansionState> ExpansionStates;
 
    UPROPERTY()
    TArray<FString> PinnedNodes;
 
    UPROPERTY(Transient)
    double ViewStart;
    UPROPERTY(Transient)
    double ViewEnd;
 
    UPROPERTY(Transient)
    double WorkStart;
    UPROPERTY(Transient)
    double WorkEnd;
 
    UPROPERTY()
    TSet<FFrameNumber> MarkedFrames_DEPRECATED;
    UPROPERTY()
    FFloatRange WorkingRange_DEPRECATED;
    UPROPERTY()
    FFloatRange ViewRange_DEPRECATED;
 
    UPROPERTY()
    FNavigationToolSaveState NavigationToolState;
 
    UPROPERTY(Transient)
    TArray<FString> SoloNodes;
 
    UPROPERTY(Transient)
    TArray<FString> MuteNodes;
};
 
 
USTRUCT()
struct FMovieSceneTrackLabels
{
    GENERATED_BODY()
 
    UPROPERTY()
    TArray<FString> Strings;
 
    void FromString(const FString& LabelString)
    {
        LabelString.ParseIntoArray(Strings, TEXT(" "));
    }
 
    FString ToString() const
    {
        return FString::Join(Strings, TEXT(" "));
    }
};
 
 
USTRUCT()
struct FMovieSceneObjectBindingIDs
{
    GENERATED_BODY()
 
    UPROPERTY()
    TArray<FMovieSceneObjectBindingID> IDs;
};
 
USTRUCT()
struct FMovieSceneSectionGroup
{
    GENERATED_BODY()
public:
    /* @return Whether the section is part of this group */
    MOVIESCENE_API bool Contains(const UMovieSceneSection& Section) const;
    
    /* Add the section to this group */
    MOVIESCENE_API void Add(UMovieSceneSection& Section);
 
    /* Remove the section from this group */
    MOVIESCENE_API void Remove(const UMovieSceneSection& Section);
 
    /* Add all members of a group to this group */
    MOVIESCENE_API void Append(const FMovieSceneSectionGroup& SectionGroup);
 
    /* Removes any sections which the pointers are stale or otherwise not valid */
    MOVIESCENE_API void Clean();
 
    int32 Num() const { return Sections.Num(); }
 
protected:
    UPROPERTY()
    TArray<TWeakObjectPtr<UMovieSceneSection> > Sections;
 
public:
    inline bool operator==(const FMovieSceneSectionGroup& Other) const
    {
        return &Sections == &Other.Sections;
    }
    inline bool operator!=(const FMovieSceneSectionGroup& Other) const
    {
        return &Sections != &Other.Sections;
    }
 
    inline TArray<TWeakObjectPtr<UMovieSceneSection> >::RangedForIteratorType      begin() { return Sections.begin(); }
    inline TArray<TWeakObjectPtr<UMovieSceneSection> >::RangedForConstIteratorType begin() const { return Sections.begin(); }
    inline TArray<TWeakObjectPtr<UMovieSceneSection> >::RangedForIteratorType      end() { return Sections.end(); }
    inline TArray<TWeakObjectPtr<UMovieSceneSection> >::RangedForConstIteratorType end() const { return Sections.end(); }
};
 
UCLASS(MinimalAPI)
class UMovieSceneNodeGroup : public UObject
{
    GENERATED_BODY()
 
    virtual bool IsEditorOnly() const override { return true; }
 
#if WITH_EDITORONLY_DATA
public:
    const FName GetName() const { return Name; }
    MOVIESCENE_API void SetName(const FName& Name);
 
    MOVIESCENE_API void AddNode(const FString& Path);
    MOVIESCENE_API void RemoveNode(const FString& Path);
    TArrayView<FString> GetNodes() { return Nodes; }
    MOVIESCENE_API bool ContainsNode(const FString& Path) const;
 
    MOVIESCENE_API void UpdateNodePath(const FString& OldPath, const FString& NewPath);
 
    bool GetEnableFilter() const { return bEnableFilter; }
    MOVIESCENE_API void SetEnableFilter(bool bInEnableFilter);
 
    DECLARE_EVENT(UMovieSceneNodeGroup, FOnNodeGroupChanged)
    FOnNodeGroupChanged& OnNodeGroupChanged() { return OnNodeGroupChangedEvent; }
 
private:
    UPROPERTY()
    FName Name;
 
    UPROPERTY()
    TArray<FString> Nodes;
 
    bool bEnableFilter;
 
    FOnNodeGroupChanged OnNodeGroupChangedEvent;
 
    inline bool operator==(const UMovieSceneNodeGroup& Other) const
    {
        return &Nodes == &Other.Nodes;
    }
    inline bool operator!=(const UMovieSceneNodeGroup& Other) const
    {
        return &Nodes != &Other.Nodes;
    }
#endif
};
 
UCLASS(MinimalAPI)
class UMovieSceneNodeGroupCollection : public UObject
{
    GENERATED_BODY()
 
    virtual bool IsEditorOnly() const override { return true; }
 
#if WITH_EDITORONLY_DATA
public:
    MOVIESCENE_API virtual void PostLoad() override;
    MOVIESCENE_API virtual void PostEditUndo() override;
 
    MOVIESCENE_API void AddNodeGroup(UMovieSceneNodeGroup* NodeGroup);
    MOVIESCENE_API void RemoveNodeGroup(UMovieSceneNodeGroup* NodeGroup);
 
    bool Contains(UMovieSceneNodeGroup* NodeGroup) const { return NodeGroups.Contains(NodeGroup); }
    const int32 Num() const { return NodeGroups.Num(); }
    bool HasAnyActiveFilter() const { return bAnyActiveFilter; }
 
    MOVIESCENE_API void UpdateNodePath(const FString& OldPath, const FString& NewPath);
 
    DECLARE_EVENT(UMovieSceneNodeGroupCollection, FOnNodeGroupCollectionChanged)
    FOnNodeGroupCollectionChanged& OnNodeGroupCollectionChanged() { return OnNodeGroupCollectionChangedEvent; }
 
private:
 
    MOVIESCENE_API void Refresh();
 
    UPROPERTY()
    TArray<TObjectPtr<UMovieSceneNodeGroup>> NodeGroups;
 
    bool bAnyActiveFilter;
 
    MOVIESCENE_API void OnNodeGroupChanged();
 
    FOnNodeGroupCollectionChanged OnNodeGroupCollectionChangedEvent;
 
public:
 
    inline auto begin() { return NodeGroups.begin(); }
    inline auto begin() const { return NodeGroups.begin(); }
    inline auto end()   { return NodeGroups.end(); }
    inline auto end()   const { return NodeGroups.end(); }
#endif
};
 
UCLASS(DefaultToInstanced, MinimalAPI)
class UMovieScene
    : public UMovieSceneDecorationContainerObject
{
    GENERATED_UCLASS_BODY()
 
public:
 
    MOVIESCENE_API virtual void Serialize( FArchive& Ar ) override;
    MOVIESCENE_API virtual bool IsPostLoadThreadSafe() const override;
    MOVIESCENE_API virtual void PostInitProperties() override;
    MOVIESCENE_API virtual void PostLoad() override;
#if WITH_EDITORONLY_DATA
    static MOVIESCENE_API void DeclareConstructClasses(TArray<FTopLevelAssetPath>& OutConstructClasses, const UClass* SpecificSubclass);
#endif
 
 
#if WITH_EDITOR
    MOVIESCENE_API virtual void PostEditUndo() override;
#endif
 
public:
 
    UE::MovieScene::TDataEventContainer<UE::MovieScene::ISequenceDataEventHandler> EventHandlers;
 
    MOVIESCENE_API FGuid AddSpawnable(const FString& Name, UObject& ObjectTemplate);
 
    /*
     * Adds an existing spawnable to this movie scene.
     *
     * @param InNewSpawnable The posssesable to add.
     * @param InNewBinding The object binding to add.
     */
    MOVIESCENE_API void AddSpawnable(const FMovieSceneSpawnable& InNewSpawnable, const FMovieSceneBinding& InNewBinding);
 
    MOVIESCENE_API bool RemoveSpawnable(const FGuid& Guid);
 
    MOVIESCENE_API FMovieSceneSpawnable* FindSpawnable( const TFunctionRef<bool(FMovieSceneSpawnable&)>& InPredicate );
 
    MOVIESCENE_API FMovieSceneSpawnable* FindSpawnable(const FGuid& Guid);
 
    MOVIESCENE_API FMovieSceneSpawnable& GetSpawnable(int32 Index);
 
    MOVIESCENE_API int32 GetSpawnableCount() const;
    
public:
 
    MOVIESCENE_API FGuid AddPossessable(const FString& Name, UClass* Class);
 
    /*
     * Adds an existing possessable to this movie scene.
     *
     * @param InNewPossessable The posssesable to add.
     * @param InNewBinding The object binding to add.
     */
    MOVIESCENE_API void AddPossessable(const FMovieScenePossessable& InNewPossessable, const FMovieSceneBinding& InNewBinding);
 
    MOVIESCENE_API bool RemovePossessable(const FGuid& PossessableGuid);
    
    /*
    * Replace an existing possessable with another 
    */
    MOVIESCENE_API bool ReplacePossessable(const FGuid& OldGuid, const FMovieScenePossessable& InNewPosessable);
 
    MOVIESCENE_API struct FMovieScenePossessable* FindPossessable(const FGuid& Guid);
 
    MOVIESCENE_API FMovieScenePossessable* FindPossessable( const TFunctionRef<bool(FMovieScenePossessable&)>& InPredicate );
 
    MOVIESCENE_API FMovieScenePossessable& GetPossessable(const int32 Index);
 
    MOVIESCENE_API int32 GetPossessableCount() const;
 
public:
 
    MOVIESCENE_API UMovieSceneTrack* AddTrack(TSubclassOf<UMovieSceneTrack> TrackClass, const FGuid& ObjectGuid);
 
    MOVIESCENE_API bool AddGivenTrack(UMovieSceneTrack* InTrack, const FGuid& ObjectGuid);
 
    template<typename TrackClass>
    TrackClass* AddTrack(const FGuid& ObjectGuid)
    {
        return Cast<TrackClass>(AddTrack(TrackClass::StaticClass(), ObjectGuid));
    }
 
    MOVIESCENE_API UMovieSceneTrack* FindTrack(TSubclassOf<UMovieSceneTrack> TrackClass, const FGuid& ObjectGuid, const FName& TrackName = NAME_None) const;
    
    template<typename TrackClass>
    TrackClass* FindTrack(const FGuid& ObjectGuid, const FName& TrackName = NAME_None) const
    {
        return Cast<TrackClass>(FindTrack(TrackClass::StaticClass(), ObjectGuid, TrackName));
    }
 
    MOVIESCENE_API TArray<UMovieSceneTrack*> FindTracks(TSubclassOf<UMovieSceneTrack> TrackClass, const FGuid& ObjectGuid, const FName& TrackName = NAME_None) const;
 
    MOVIESCENE_API bool RemoveTrack(UMovieSceneTrack& Track);
 
    MOVIESCENE_API bool FindTrackBinding(const UMovieSceneTrack& InTrack, FGuid& OutGuid) const;
 
#if WITH_EDITOR
 
    DECLARE_DELEGATE_RetVal_OneParam(bool, FIsTrackClassAllowedEvent, UClass*);
 
    static MOVIESCENE_API FIsTrackClassAllowedEvent IsTrackClassAllowedEvent;
 
    static MOVIESCENE_API bool IsTrackClassAllowed(UClass* InClass);
 
    DECLARE_DELEGATE_RetVal_OneParam(bool, FIsCustomBindingClassAllowedEvent, UClass*);
 
    static MOVIESCENE_API FIsCustomBindingClassAllowedEvent IsCustomBindingClassAllowedEvent;
 
    static MOVIESCENE_API bool IsCustomBindingClassAllowed(UClass* InClass);
 
    DECLARE_DELEGATE_RetVal_OneParam(bool, FIsConditionClassAllowedEvent, const UClass*);
 
    static MOVIESCENE_API FIsConditionClassAllowedEvent IsConditionClassAllowedEvent;
 
    static MOVIESCENE_API bool IsConditionClassAllowed(const UClass* InClass);
 
 
    void OnDynamicBindingUserDefinedPinRenamed(UK2Node* InNode, FName OldPinName, FName NewPinName)
    {
        FixupDynamicBindingPayloadParameterNameEvent.Broadcast(this, InNode, OldPinName, NewPinName);
    }
 
    DECLARE_MULTICAST_DELEGATE_FourParams(FFixupDynamicBindingPayloadParameterNameEvent, UMovieScene*, UK2Node*, FName, FName);
 
    static MOVIESCENE_API FFixupDynamicBindingPayloadParameterNameEvent FixupDynamicBindingPayloadParameterNameEvent;
 
    void OnDirectorBlueprintConditionUserDefinedPinRenamed(UK2Node* InNode, FName OldPinName, FName NewPinName)
    {
        FixupDirectorBlueprintConditionPayloadParameterNameEvent.Broadcast(this, InNode, OldPinName, NewPinName);
    }
 
    DECLARE_MULTICAST_DELEGATE_FourParams(FFixupDirectorBlueprintConditionPayloadParameterNameEvent, UMovieScene*, UK2Node*, FName, FName);
 
    static MOVIESCENE_API FFixupDirectorBlueprintConditionPayloadParameterNameEvent FixupDirectorBlueprintConditionPayloadParameterNameEvent;
 
#endif
 
public:
 
    MOVIESCENE_API UMovieSceneTrack* AddTrack(TSubclassOf<UMovieSceneTrack> TrackClass);
    
    template<typename TrackClass>
    TrackClass* AddTrack()
    {
        return Cast<TrackClass>(AddTrack(TrackClass::StaticClass()));
    }
 
    MOVIESCENE_API bool AddGivenTrack(UMovieSceneTrack* InTrack);
 
    MOVIESCENE_API UMovieSceneTrack* FindTrack(TSubclassOf<UMovieSceneTrack> TrackClass) const;
 
    template<typename TrackClass>
    TrackClass* FindTrack() const
    {
        return Cast<TrackClass>(FindTrack(TrackClass::StaticClass()));
    }
 
    const TArray<UMovieSceneTrack*>& GetTracks() const
    {
        return Tracks;
    }
 
    MOVIESCENE_API bool ContainsTrack(const UMovieSceneTrack& Track) const;
 
    MOVIESCENE_API void MoveBindingContents(const FGuid& SourceBindingId, const FGuid& DestinationBindingId);
 
    MOVIESCENE_API FMovieSceneBinding* FindBinding(const FGuid& ForGuid);
 
    MOVIESCENE_API const FMovieSceneBinding* FindBinding(const FGuid& ForGuid) const;
 
public:
 
    // @todo sequencer: the following methods really shouldn't be here
 
    MOVIESCENE_API UMovieSceneTrack* AddCameraCutTrack( TSubclassOf<UMovieSceneTrack> TrackClass );
    
    MOVIESCENE_API UMovieSceneTrack* GetCameraCutTrack() const;
 
    MOVIESCENE_API void RemoveCameraCutTrack();
 
    MOVIESCENE_API void SetCameraCutTrack(UMovieSceneTrack* Track);
 
public:
 
    MOVIESCENE_API TArray<UMovieSceneSection*> GetAllSections() const;
 
    const TArray<FMovieSceneBinding>& GetBindings() const
    {
        return ObjectBindings;
    }
 
    UE_DEPRECATED(5.7, "Getting non-const access to GetBindings is no longer allowed. Please use const GetBindings()")
    TArray<FMovieSceneBinding>& GetBindings()
    {
        return ObjectBindings;
    }
 
    TRange<FFrameNumber> GetSelectionRange() const
    {
        return SelectionRange.Value;
    }
 
    MOVIESCENE_API FText GetObjectDisplayName(const FGuid& ObjectId) const;
 
    TRange<FFrameNumber> GetPlaybackRange() const
    {
        return PlaybackRange.Value;
    }
 
    FFrameRate GetTickResolution() const
    {
        return TickResolution;
    }
 
    MOVIESCENE_API void SetTickResolutionDirectly(FFrameRate InTickResolution);
 
    FFrameRate GetDisplayRate() const
    {
        return DisplayRate;
    }
 
    void SetDisplayRate(FFrameRate InDisplayRate)
    {
        DisplayRate = InDisplayRate;
    }
 
    EMovieSceneEvaluationType GetEvaluationType() const
    {
        return EvaluationType;
    }
 
    void SetEvaluationType(EMovieSceneEvaluationType InNewEvaluationType)
    {
        EvaluationType = InNewEvaluationType;
 
        if (EvaluationType == EMovieSceneEvaluationType::FrameLocked && ClockSource == EUpdateClockSource::Tick)
        {
            ClockSource = EUpdateClockSource::Platform;
        }
    }
 
    EUpdateClockSource GetClockSource() const
    {
        return ClockSource;
    }
 
    UMovieSceneClock* GetCustomClock() const
    {
        return ClockSource == EUpdateClockSource::Custom ? CustomClock : nullptr;
    }
 
    template<typename T>
    T* GetCustomClockAs() const
    {
        return Cast<T>(GetCustomClock());
    }
 
    MOVIESCENE_API TSharedPtr<FMovieSceneTimeController> MakeCustomTimeController(UObject* PlaybackContext);
 
    MOVIESCENE_API void SetClockSource(EUpdateClockSource InNewClockSource);
 
    UE_DEPRECATED(5.6, "Please call SetCustomClock with an instance of UMovieSceneExternalClock")
    MOVIESCENE_API void SetClockSource(UObject* InNewClockSource);
 
    MOVIESCENE_API void SetCustomClock(UMovieSceneClock* InNewClockSource);
 
    MOVIESCENE_API FMovieSceneTimecodeSource GetEarliestTimecodeSource() const;
 
    /*
    * Replace an existing binding with another 
    */
    MOVIESCENE_API void ReplaceBinding(const FGuid& OldGuid, const FGuid& NewGuid, const FString& Name);
 
    /*
    * Replace an existing binding with another. Assumes ownership of any
    * tracks listed in the binding. Does nothing if no binding can be found.
    * @param BindingToReplaceGuid   Binding Guid that should be replaced
    * @param NewBinding             Binding Data that should replace the original one specified by BindingToReplaceGuid.
    */
    MOVIESCENE_API void ReplaceBinding(const FGuid& BindingToReplaceGuid, const FMovieSceneBinding& NewBinding);
 
#if WITH_EDITORONLY_DATA
    TMap<FString, FMovieSceneTrackLabels>& GetObjectsToLabels()
    {
        return ObjectsToLabels;
    }
 
    void SetSelectionRange(TRange<FFrameNumber> Range)
    {
        SelectionRange.Value = Range;
    }
 
    MOVIESCENE_API void SetObjectDisplayName(const FGuid& ObjectId, const FText& DisplayName);
 
    MOVIESCENE_API TArrayView<UMovieSceneFolder* const> GetRootFolders();
 
    MOVIESCENE_API void GetRootFolders(TArray<UMovieSceneFolder*>& InRootFolders);
 
    MOVIESCENE_API int32 GetNumRootFolders() const;
 
    MOVIESCENE_API UMovieSceneFolder* GetRootFolder(int32 FolderIndex) const;
 
    MOVIESCENE_API void AddRootFolder(UMovieSceneFolder* Folder);
 
    MOVIESCENE_API int32 RemoveRootFolder(UMovieSceneFolder* Folder);
 
    MOVIESCENE_API bool RemoveRootFolder(int32 FolderIndex);
 
    MOVIESCENE_API void EmptyRootFolders();
 
    UE_DEPRECATED(5.7, "GetSoloNodes is now deprecated. Use FindDecoration")
    TArray<FString>& GetSoloNodes() { return EditorData.SoloNodes; }
 
    UE_DEPRECATED(5.7, "GetMuteNodes is now deprecated. Use FindDecoration")
    TArray<FString>& GetMuteNodes() { return EditorData.MuteNodes; }
    
    //WIP Set of Delegates
    FMovieSceneOnChannelChanged& OnChannelChanged() { return OnChannelChangedDelegate; }
#endif
 
    MOVIESCENE_API void SetPlaybackRange(FFrameNumber Start, int32 Duration, bool bAlwaysMarkDirty = true);
 
    MOVIESCENE_API void SetPlaybackRange(const TRange<FFrameNumber>& NewRange, bool bAlwaysMarkDirty = true);
 
    MOVIESCENE_API void SetWorkingRange(double Start, double End);
 
    MOVIESCENE_API void SetViewRange(double Start, double End);
 
#if WITH_EDITORONLY_DATA
 
public:
 
    /*
    * @return Returns whether this movie scene is read only
    */
    bool IsReadOnly() const { return bReadOnly; }
 
    void SetReadOnly(bool bInReadOnly) { bReadOnly = bInReadOnly; }
 
    MOVIESCENE_API bool IsPlaybackRangeLocked() const;
 
    MOVIESCENE_API void SetPlaybackRangeLocked(bool bLocked);
 
    MOVIESCENE_API bool AreMarkedFramesLocked() const;
 
    MOVIESCENE_API void SetMarkedFramesLocked(bool bLocked);
 
    FMovieSceneEditorData& GetEditorData()
    {
        return EditorData;
    }
    const FMovieSceneEditorData& GetEditorData() const
    {
        return EditorData;
    }
 
    void SetEditorData(FMovieSceneEditorData& InEditorData)
    {
        EditorData = InEditorData;
    }
 
    /*
     * @return Whether the section is in a group
     */
    MOVIESCENE_API bool IsSectionInGroup(const UMovieSceneSection& InSection) const;
 
    /*
     * Create a group containing InSections, merging any existing groups the sections are in
     */
    MOVIESCENE_API void GroupSections(const TArray<UMovieSceneSection*> InSections);
 
    /*
     * Remove InSection from any group it currently is in
     */
    MOVIESCENE_API void UngroupSection(const UMovieSceneSection& InSection);
 
    /*
     * @return The group containing the InSection, or a nullptr if InSection is not grouped.
     */
    MOVIESCENE_API const FMovieSceneSectionGroup* GetSectionGroup(const UMovieSceneSection& InSection) const;
 
    /*
     * Cleans stale UMovieSceneSection pointers, and removes any section groups which are no longer valid, e.g. contain less that two valid sections
     */
    MOVIESCENE_API void CleanSectionGroups();
 
    UMovieSceneNodeGroupCollection& GetNodeGroups() { return *NodeGroupCollection; }
 
#endif  // WITH_EDITORONLY_DATA
 
public:
 
    /*
     * @return Return the user marked frames
     */
    const TArray<FMovieSceneMarkedFrame>& GetMarkedFrames() const { return MarkedFrames; }
 
    /*
     * Sets the frame number for the given marked frame index. Does not maintain sort. Call SortMarkedFrames
     *
     * @InMarkIndex The given user marked frame index to edit
     * @InFrameNumber The frame number to set
     */
    MOVIESCENE_API void SetMarkedFrame(int32 InMarkIndex, FFrameNumber InFrameNumber);
 
    /*
     * Add a given user marked frame.
     * A unique label will be generated if the marked frame label is empty
     *
     * @InMarkedFrame The given user marked frame to add
     * @return The index to the newly added marked frame
     */
    MOVIESCENE_API int32 AddMarkedFrame(const FMovieSceneMarkedFrame& InMarkedFrame);
 
    /*
     * Delete the user marked frame by index.
     *
     * @DeleteIndex The index to the user marked frame to delete
     */
    MOVIESCENE_API void DeleteMarkedFrame(int32 DeleteIndex);
 
    /*
     * Delete all user marked frames
     */
    MOVIESCENE_API void DeleteMarkedFrames();
 
    /*
     * Sort the marked frames in chronological order
     */
    MOVIESCENE_API void SortMarkedFrames();
 
    /*
     * Find the user marked frame by label
     *
     * @InLabel The label to the user marked frame to find
     */
    MOVIESCENE_API int32 FindMarkedFrameByLabel(const FString& InLabel) const;
 
    /*
     * Find the user marked frame by frame number
     *
     * @InFrameNumber The frame number of the user marked frame to find
     */
    MOVIESCENE_API int32 FindMarkedFrameByFrameNumber(FFrameNumber InFrameNumber) const;
 
    /*
     * Find the next/previous user marked frame from the given frame number
     *
     * @InFrameNumber The frame number to find the next/previous user marked frame from
     * @bForward Find forward from the given frame number.
     */
    MOVIESCENE_API int32 FindNextMarkedFrame(FFrameNumber InFrameNumber, bool bForward);
 
#if WITH_EDITORONLY_DATA
    /*
     * Set whether this scene's marked frames should be shown globally
     */
    void SetGloballyShowMarkedFrames(bool bShowMarkedFrames) { bGloballyShowMarkedFrames = bShowMarkedFrames; }
 
    /*
     * Toggle whether this scene's marked frames should be shown globally
     */
    void ToggleGloballyShowMarkedFrames() { bGloballyShowMarkedFrames = !bGloballyShowMarkedFrames; }
 
    /*
     * Returns whether this scene's marked frames should be shown globally
     */
    bool GetGloballyShowMarkedFrames() const { return bGloballyShowMarkedFrames; }
#endif
 
    /*
     * Retrieve all the tagged binding groups for this movie scene
     */
    const TMap<FName, FMovieSceneObjectBindingIDs>& AllTaggedBindings() const
    {
        return BindingGroups;
    }
 
    /*
     * Add a new binding group for the specified name
     */
    MOVIESCENE_API void AddNewBindingTag(const FName& NewTag);
 
    /*
     * Tag the specified binding ID with the specified name
     */
    MOVIESCENE_API void TagBinding(const FName& NewTag, const UE::MovieScene::FFixedObjectBindingID& BindingToTag);
 
    /*
     * Remove a tag from the specified object binding
     */
    MOVIESCENE_API void UntagBinding(const FName& Tag, const UE::MovieScene::FFixedObjectBindingID& Binding);
 
    /*
     * Remove the specified tag from any binding and forget about it completely
     */
    MOVIESCENE_API void RemoveTag(const FName& TagToRemove);
 
    /* Called during compilation to add a new generated condition to store in the movie scene. */
    void AddGeneratedCondition(UMovieSceneGroupCondition* InGeneratedCondition) { GeneratedConditions.Add(InGeneratedCondition); }
 
    /* Called by the compiler to empty the list of generated conditions*/
    void ResetGeneratedConditions() { GeneratedConditions.Reset(); }
 
protected:
 
    MOVIESCENE_API void RemoveBinding(const FGuid& Guid);
 
 
    int32 IndexOfBinding(const FGuid& ForGuid) const;
 
    int32 IndexOfSpawnable(const FGuid& ForGuid) const;
 
 
    int32 IndexOfPossessable(const FGuid& ForGuid) const;
 
protected:
 
    MOVIESCENE_API virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
    MOVIESCENE_API virtual void OnDecorationAdded(UObject* NewDecoration) override;
    MOVIESCENE_API virtual void OnDecorationRemoved(UObject* NewDecoration) override;
 
    MOVIESCENE_API void UpgradeTimeRanges();
 
private:
 
#if WITH_EDITOR
    MOVIESCENE_API void OptimizeForCook();
    MOVIESCENE_API void RemoveNullTracks();
#endif
 
private:
 
    UPROPERTY()
    TArray<FMovieSceneSpawnable> Spawnables;
 
    UPROPERTY()
    TArray<FMovieScenePossessable> Possessables;
 
    UPROPERTY()
    TArray<FMovieSceneBinding> ObjectBindings;
 
    UPROPERTY()
    TMap<FName, FMovieSceneObjectBindingIDs> BindingGroups;
 
    UPROPERTY(Instanced)
    TArray<TObjectPtr<UMovieSceneTrack>> Tracks;
 
    UPROPERTY(Instanced)
    TObjectPtr<UMovieSceneTrack> CameraCutTrack;
 
    UPROPERTY(Instanced)
    TObjectPtr<UMovieSceneClock> CustomClock;
 
    UPROPERTY()
    FMovieSceneFrameRange SelectionRange;
 
    UPROPERTY()
    FMovieSceneFrameRange PlaybackRange;
 
    UPROPERTY()
    FFrameRate TickResolution;
 
    UPROPERTY()
    FFrameRate DisplayRate;
 
    UPROPERTY()
    EMovieSceneEvaluationType EvaluationType;
 
    UPROPERTY()
    EUpdateClockSource ClockSource;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FSoftObjectPath CustomClockSourcePath_DEPRECATED;
#endif
 
    UPROPERTY()
    TArray<FMovieSceneMarkedFrame> MarkedFrames;
 
    /* List of compiler generated group conditions, stored here to prevent garbage collection. */
    UPROPERTY()
    TArray<TObjectPtr<UMovieSceneGroupCondition>> GeneratedConditions;
 
#if WITH_EDITORONLY_DATA
 
    UPROPERTY()
    bool bReadOnly;
 
    UPROPERTY()
    bool bPlaybackRangeLocked;
 
    UPROPERTY()
    bool bMarkedFramesLocked;
 
    UPROPERTY()
    TMap<FString, FText> ObjectsToDisplayNames;
 
    UPROPERTY()
    TMap<FString, FMovieSceneTrackLabels> ObjectsToLabels;
 
    UPROPERTY()
    FMovieSceneEditorData EditorData;
 
    UPROPERTY()
    TArray<TObjectPtr<UMovieSceneFolder>> RootFolders;
 
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "Solo nodes are now saved in FMovieSceneEditorData as transient"))
    TArray<FString> SoloNodes_DEPRECATED;
 
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "Mute nodes are now saved in FMovieSceneEditorData as transient"))
    TArray<FString> MuteNodes_DEPRECATED;
 
    UPROPERTY()
    TArray<FMovieSceneSectionGroup> SectionGroups;
 
    UPROPERTY()
    TObjectPtr<UMovieSceneNodeGroupCollection> NodeGroupCollection;
 
    UPROPERTY()
    bool bGloballyShowMarkedFrames;
 
private:
 
    UPROPERTY()
    float InTime_DEPRECATED;
 
    UPROPERTY()
    float OutTime_DEPRECATED;
 
    UPROPERTY()
    float StartTime_DEPRECATED;
 
    UPROPERTY()
    float EndTime_DEPRECATED;
 
    UPROPERTY()
    bool bForceFixedFrameIntervalPlayback_DEPRECATED;
 
    UPROPERTY()
    float FixedFrameInterval_DEPRECATED;
 
    UPROPERTY()
    TArray<TObjectPtr<UMovieSceneTrack>> MasterTracks_DEPRECATED;
 
    //delegates
    private:
    FMovieSceneOnChannelChanged OnChannelChangedDelegate;
#endif
};