MovieSceneSequence.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "UniversalObjectLocatorFwd.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "Evaluation/MovieSceneCompletionMode.h"
#include "Internationalization/Text.h"
#include "Misc/AssertionMacros.h"
#include "Misc/Guid.h"
#include "MovieSceneFwd.h"
#include "MovieSceneObjectBindingID.h" // only for FMovieSceneObjectBindingID in .gen.cpp
#include "MovieSceneSection.h" // only for FMovieSceneTimecodeSource in .gen.cpp
#include "MovieSceneSequenceID.h"
#include "MovieSceneSignedObject.h"
#include "UniversalObjectLocatorResolveParams.h"
#include "MovieSceneTrack.h"
#include "Templates/SubclassOf.h"
#include "UObject/NameTypes.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ObjectPtr.h"
#include "UObject/UObjectGlobals.h"
 
#include "MovieSceneSequence.generated.h"
 
class FArchive;
class FObjectPreSaveContext;
class IMovieScenePlayer;
class ITargetPlatform;
class UMovieScene;
class UMovieSceneCompiledData;
class UMovieSceneEntitySystemLinker;
class UMovieSceneTrack;
class UObject;
struct FFrame;
struct FMovieSceneObjectCache;
struct FMovieScenePossessable;
struct FMovieSceneTimecodeSource;
struct FUniversalObjectLocator;
struct FMovieSceneBindingReferences;
struct FMovieSceneDynamicBinding;
 
#if WITH_EDITOR
struct FSlateBrush;
#endif
 
 
namespace UE::MovieScene
{
    struct FSharedPlaybackState;
}
 
enum class ETrackSupport
{
    NotSupported,
    Supported,
    Default
};
 
 
UCLASS(abstract, MinimalAPI, Config = Engine, BlueprintType)
class UMovieSceneSequence
    : public UMovieSceneSignedObject
{
public:
 
    using FSharedPlaybackState = UE::MovieScene::FSharedPlaybackState;
 
    GENERATED_BODY()
 
    MOVIESCENE_API UMovieSceneSequence(const FObjectInitializer& Init);
 
public:
 
    MOVIESCENE_API virtual bool MakeLocatorForObject(UObject* Object, UObject* Context, FUniversalObjectLocator& OutLocator) const;
 
    MOVIESCENE_API FMovieSceneBindingReferences* GetBindingReferences();
 
    MOVIESCENE_API virtual const FMovieSceneBindingReferences* GetBindingReferences() const;
 
    UE_DEPRECATED(5.5, "UnloadBoundObject no longer supported")
    void UnloadBoundObject(const UE::UniversalObjectLocator::FResolveParams& ResolveParams, const FGuid& ObjectId, int32 BindingIndex) {}
 
 
    virtual void BindPossessableObject(const FGuid& ObjectId, UObject& PossessedObject, UObject* Context) PURE_VIRTUAL(UMovieSceneSequence::BindPossessableObject,);
 
    virtual bool CanPossessObject(UObject& Object, UObject* InPlaybackContext) const PURE_VIRTUAL(UMovieSceneSequence::CanPossessObject, return false;);
 
    UE_DEPRECATED(5.4, "Please call the FResolveParams overload")
    virtual void LocateBoundObjects(const FGuid& ObjectId, UObject* Context, TArray<UObject*, TInlineAllocator<1>>& OutObjects) const {}
 
    UE_DEPRECATED(5.5, "Please use the version that also takes a SharedPlaybackState")
    MOVIESCENE_API void LocateBoundObjects(const FGuid& ObjectId, const UE::UniversalObjectLocator::FResolveParams& ResolveParams, TArray<UObject*, TInlineAllocator<1>>& OutObjects) const;
 
    UE_DEPRECATED(5.5, "Please use the version that also takes a SharedPlaybackState")
    TArray<UObject*, TInlineAllocator<1>> LocateBoundObjects(const FGuid& ObjectId, const UE::UniversalObjectLocator::FResolveParams& Context) const
    {
        TArray<UObject*, TInlineAllocator<1>> OutObjects;
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        LocateBoundObjects(ObjectId, Context, OutObjects);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
        return OutObjects;
    }
 
    MOVIESCENE_API virtual void LocateBoundObjects(const FGuid& ObjectId, const UE::UniversalObjectLocator::FResolveParams& ResolveParams, TSharedPtr<const FSharedPlaybackState> SharedPlaybackState, TArray<UObject*, TInlineAllocator<1>>& OutObjects) const;
 
    MOVIESCENE_API FGuid FindPossessableObjectId(UObject& Object, UObject* Context) const;
 
    UE_DEPRECATED(5.5, "Use the version that takes a SharedPlaybackState")
    MOVIESCENE_API virtual FGuid FindBindingFromObject(UObject* InObject, UObject* Context) const;
 
    virtual FGuid FindBindingFromObject(UObject* InObject, TSharedRef<const FSharedPlaybackState> SharedPlaybackState) const { return FGuid(); }
 
    virtual void GatherExpiredObjects(const FMovieSceneObjectCache& InObjectCache, TArray<FGuid>& OutInvalidIDs) const {}
 
    virtual UMovieScene* GetMovieScene() const PURE_VIRTUAL(UMovieSceneSequence::GetMovieScene(), return nullptr;);
 
    virtual UObject* GetParentObject(UObject* Object) const PURE_VIRTUAL(UMovieSceneSequence::GetParentObject(), return nullptr;);
 
    virtual bool AllowsSpawnableObjects() const { return false; }
 
    virtual bool AllowsCustomBindings() const { return false; }
 
    virtual void UnbindPossessableObjects(const FGuid& ObjectId) PURE_VIRTUAL(UMovieSceneSequence::UnbindPossessableObjects, );
 
    virtual void UnbindObjects(const FGuid& ObjectId, const TArray<UObject*>& InObjects, UObject* Context) PURE_VIRTUAL(UMovieSceneSequence::UnbindObjects, );
 
    virtual void UnbindInvalidObjects(const FGuid& ObjectId, UObject* Context) PURE_VIRTUAL(UMovieSceneSequence::UnbindInvalidObjects, );
 
    virtual UObject* MakeSpawnableTemplateFromInstance(UObject& InSourceObject, FName ObjectName) { return nullptr; }
 
    virtual bool CanRebindPossessable(const FMovieScenePossessable& InPossessable) const { return false; }
 
    virtual bool CanAnimateObject(UObject& InObject) const { return true; }
 
    virtual FGuid CreatePossessable(UObject* ObjectToPossess) { return FGuid(); }
 
    virtual FGuid CreateSpawnable(UObject* ObjectToSpawn) { return FGuid(); }
 
    virtual UObject* CreateDirectorInstance(TSharedRef<const FSharedPlaybackState> SharedPlaybackState, FMovieSceneSequenceID SequenceID) { return nullptr; }
 
    UE_DEPRECATED(5.4, "Please use the version that takes a SharedPlaybackState")
    UObject* CreateDirectorInstance(IMovieScenePlayer& Player, FMovieSceneSequenceID SequenceID);
 
    MOVIESCENE_API virtual EMovieSceneServerClientMask OverrideNetworkMask(EMovieSceneServerClientMask InDefaultMask) const;
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Sequence")
    MOVIESCENE_API FMovieSceneObjectBindingID FindBindingByTag(FName InBindingName) const;
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Sequence")
    MOVIESCENE_API const TArray<FMovieSceneObjectBindingID>& FindBindingsByTag(FName InBindingName) const;
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Sequence")
    MOVIESCENE_API FMovieSceneTimecodeSource GetEarliestTimecodeSource() const;
 
#if WITH_EDITOR
    virtual void IterateDynamicBindings(TFunction<void(const FGuid&, FMovieSceneDynamicBinding&)> InCallback) {}
 
    virtual const FSlateBrush* GetCustomBrushForBinding(FGuid BindingID) const { return nullptr; }
#endif
 
public:
 
    MOVIESCENE_API virtual void PostLoad() override;
    MOVIESCENE_API virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
    MOVIESCENE_API virtual void BeginDestroy() override;
    MOVIESCENE_API virtual void PostDuplicate(bool bDuplicateForPIE) override;
 
    MOVIESCENE_API virtual void Serialize(FArchive& Ar) override;
 
public:
 
    bool AreParentContextsSignificant() const
    {
        return bParentContextsAreSignificant;
    }
 
    bool IsPlayableDirectly() const
    {
        return bPlayableDirectly;
    }
 
    void SetPlayableDirectly(bool bInPlayableDirectly)
    {
        Modify();
        bPlayableDirectly = bInPlayableDirectly;
    }
    
    EMovieSceneSequenceFlags GetFlags() const
    {
        return SequenceFlags;
    }
 
    void SetSequenceFlags(EMovieSceneSequenceFlags InFlags)
    {
        SequenceFlags = InFlags;
    }
 
    UMovieSceneCompiledData* GetCompiledData() const;
    UMovieSceneCompiledData* GetOrCreateCompiledData();
 
private:
 
#if WITH_EDITOR
    void OptimizeForCook();
#endif
 
    UPROPERTY(Instanced)
    TObjectPtr<UMovieSceneCompiledData> CompiledData;
 
public:
 
    /* The default completion mode for this movie scene when a section's completion mode is set to project default */
    UPROPERTY(config)
    EMovieSceneCompletionMode DefaultCompletionMode;
 
protected:
 
    UPROPERTY()
    bool bParentContextsAreSignificant;
 
    UPROPERTY()
    bool bPlayableDirectly;
 
    UPROPERTY()
    EMovieSceneSequenceFlags SequenceFlags;
 
public:
 
#if WITH_EDITOR
 
    virtual FText GetDisplayName() const { return FText::FromName(GetFName()); }
    
    /*
     * Sequences can determine whether they support a particular track type
     */
    MOVIESCENE_API ETrackSupport IsTrackSupported(TSubclassOf<UMovieSceneTrack> InTrackClass) const;
 
    virtual ETrackSupport IsTrackSupportedImpl(TSubclassOf<UMovieSceneTrack> InTrackClass) const { return ETrackSupport::Default; }
 
    /*
     * Sequences can determine whether they support a particular filter type
     */
    MOVIESCENE_API bool IsFilterSupported(const FString& InFilterName) const;
 
    virtual bool IsFilterSupportedImpl(const FString& InFilterName) const { return true; }
 
#endif
 
    MOVIESCENE_API bool IsSubSequenceCompatible(const UMovieSceneSequence& SubSequence) const;
 
    virtual bool IsCompatibleSubSequence(const UMovieSceneSequence& SubSequence) const { return true; }
 
    virtual bool IsCompatibleAsSubSequence(const UMovieSceneSequence& ParentSequence) const { return true; }
};