MovieSceneSpawnRegister.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Map.h"
#include "CoreMinimal.h"
#include "Evaluation/IMovieScenePlaybackCapability.h"
#include "HAL/Platform.h"
#include "HAL/PlatformCrt.h"
#include "IMovieSceneObjectSpawner.h"
#include "Internationalization/Internationalization.h"
#include "Internationalization/Text.h"
#include "Misc/AssertionMacros.h"
#include "Misc/Guid.h"
#include "Misc/OptionalFwd.h"
#include "MovieSceneFwd.h"
#include "MovieSceneSequenceID.h"
#include "Templates/SharedPointer.h"
#include "Templates/TypeHash.h"
#include "Templates/ValueOrError.h"
#include "UObject/WeakObjectPtr.h"
#include "UObject/WeakObjectPtrTemplates.h"
 
class UClass;
class UObject;
template <typename FuncType> class TFunctionRef;
 
enum class ESpawnOwnership : uint8;
 
class IMovieScenePlayer;
class ISequencer;
class UActorFactory;
class UMovieScene;
class USequencerSettings;
struct FMovieSceneEvaluationState;
struct FMovieSceneSpawnable;
struct FTransformData;
class UMovieSceneSpawnableBindingBase;
 
namespace UE::MovieScene
{
    struct FSharedPlaybackState;
}  // namespace UE::MovieScene
 
class FMovieSceneSpawnRegister : public TSharedFromThis<FMovieSceneSpawnRegister>
{
public:
 
    using FSharedPlaybackState = UE::MovieScene::FSharedPlaybackState;
 
    UE_DECLARE_MOVIESCENE_PLAYBACK_CAPABILITY_API(MOVIESCENE_API, FMovieSceneSpawnRegister)
 
    MOVIESCENE_API FMovieSceneSpawnRegister();
    MOVIESCENE_API FMovieSceneSpawnRegister(const FMovieSceneSpawnRegister&);
 
    MOVIESCENE_API virtual ~FMovieSceneSpawnRegister();
 
    MOVIESCENE_API TWeakObjectPtr<> FindSpawnedObject(const FGuid& BindingId, FMovieSceneSequenceIDRef TemplateID, int BindingIndex) const;
 
    MOVIESCENE_API virtual UObject* SpawnObject(const FGuid& BindingId, UMovieScene& MovieScene, FMovieSceneSequenceIDRef Template, TSharedRef<const FSharedPlaybackState> SharedPlaybackState, int32 BindingIndex);
 
    MOVIESCENE_API bool DestroySpawnedObject(const FGuid& BindingId, FMovieSceneSequenceIDRef TemplateID, TSharedRef<const FSharedPlaybackState> SharedPlaybackState, int32 BindingIndex);
 
    void DestroyObjectDirectly(UObject& InObject) { DestroySpawnedObject(InObject, nullptr); }
 
    MOVIESCENE_API void DestroyObjectsByPredicate(TSharedRef<const FSharedPlaybackState> SharedPlaybackState, const TFunctionRef<bool(const FGuid&, ESpawnOwnership, FMovieSceneSequenceIDRef, int32)>& Predicate);
 
    MOVIESCENE_API void ForgetExternallyOwnedSpawnedObjects(TSharedRef<const FSharedPlaybackState> SharedPlaybackState);
 
public:
 
    MOVIESCENE_API void CleanUp(TSharedRef<const FSharedPlaybackState> SharedPlaybackState);
 
    MOVIESCENE_API void CleanUpSequence(FMovieSceneSequenceIDRef TemplateID, TSharedRef<const FSharedPlaybackState> SharedPlaybackState);
 
    MOVIESCENE_API void OnSequenceExpired(FMovieSceneSequenceIDRef TemplateID, TSharedRef<const FSharedPlaybackState> SharedPlaybackState);
 
public:
 
    // Backwards compatible API, to be deprecated later
 
    TWeakObjectPtr<> FindSpawnedObject(const FGuid& BindingId, FMovieSceneSequenceIDRef TemplateID) const { return FindSpawnedObject(BindingId, TemplateID, 0); }
    virtual UObject* SpawnObject(const FGuid& BindingId, UMovieScene& MovieScene, FMovieSceneSequenceIDRef Template, TSharedRef<const FSharedPlaybackState> SharedPlaybackState) { return SpawnObject(BindingId, MovieScene, Template, SharedPlaybackState, 0); }
    bool DestroySpawnedObject(const FGuid& BindingId, FMovieSceneSequenceIDRef TemplateID, TSharedRef<const FSharedPlaybackState> SharedPlaybackState) { return DestroySpawnedObject(BindingId, TemplateID, SharedPlaybackState, 0); }
    MOVIESCENE_API UObject* SpawnObject(const FGuid& BindingId, UMovieScene& MovieScene, FMovieSceneSequenceIDRef Template, IMovieScenePlayer& Player);
    MOVIESCENE_API bool DestroySpawnedObject(const FGuid& BindingId, FMovieSceneSequenceIDRef TemplateID, IMovieScenePlayer& Player);
    MOVIESCENE_API void DestroyObjectsByPredicate(TSharedRef<const FSharedPlaybackState> SharedPlaybackState, const TFunctionRef<bool(const FGuid&, ESpawnOwnership, FMovieSceneSequenceIDRef)>& Predicate);
    MOVIESCENE_API void DestroyObjectsByPredicate(IMovieScenePlayer& Player, const TFunctionRef<bool(const FGuid&, ESpawnOwnership, FMovieSceneSequenceIDRef)>& Predicate);
    MOVIESCENE_API void ForgetExternallyOwnedSpawnedObjects(FMovieSceneEvaluationState& State, IMovieScenePlayer& Player);
    MOVIESCENE_API void CleanUp(IMovieScenePlayer& Player);
    MOVIESCENE_API void CleanUpSequence(FMovieSceneSequenceIDRef TemplateID, IMovieScenePlayer& Player);
    MOVIESCENE_API void OnSequenceExpired(FMovieSceneSequenceIDRef TemplateID, IMovieScenePlayer& Player);
 
#if WITH_EDITOR
    
public:
 
    virtual bool CanSpawnObject(UClass* InClass) const { return false; }
 
    virtual TValueOrError<FNewSpawnable, FText> CreateNewSpawnableType(UObject& SourceObject, UMovieScene& OwnerMovieScene, UActorFactory* ActorFactory = nullptr) { return MakeError(NSLOCTEXT("SpawnRegister", "NotSupported", "Not supported")); }
 
    virtual void SaveDefaultSpawnableState(const FGuid& Guid, int32 BindingIndex, FMovieSceneSequenceIDRef TemplateID, TSharedRef<const FSharedPlaybackState> SharedPlaybackState) {}
 
    virtual void SetupDefaultsForSpawnable(UObject* SpawnedObject, const FGuid& Guid, const TOptional<FTransformData>& TransformData, TSharedRef<ISequencer> Sequencer, USequencerSettings* Settings) {}
 
    virtual void HandleConvertPossessableToSpawnable(UObject* OldObject, TSharedRef<const FSharedPlaybackState> SharedPlaybackState, TOptional<FTransformData>& OutTransformData) {}
 
    MOVIESCENE_API virtual bool CanConvertToPossessable(const FGuid& Guid, FMovieSceneSequenceIDRef TemplateID, TSharedRef<const FSharedPlaybackState> SharedPlaybackState, int32 BindingIndex=0) const;
 
public:
 
    // Backwards compatible API, to be deprecated later
#if WITH_EDITOR
    virtual void SaveDefaultSpawnableState(const FGuid& Guid, FMovieSceneSequenceIDRef TemplateID, TSharedRef<const FSharedPlaybackState> SharedPlaybackState) { SaveDefaultSpawnableState(Guid, 0, TemplateID, SharedPlaybackState); }
    MOVIESCENE_API virtual void SaveDefaultSpawnableState(FMovieSceneSpawnable& Spawnable, FMovieSceneSequenceIDRef TemplateID, TSharedRef<const FSharedPlaybackState> SharedPlaybackState);
    MOVIESCENE_API void SaveDefaultSpawnableState(FMovieSceneSpawnable& Spawnable, FMovieSceneSequenceIDRef TemplateID, IMovieScenePlayer& Player);
#endif
    MOVIESCENE_API void HandleConvertPossessableToSpawnable(UObject* OldObject, IMovieScenePlayer& Player, TOptional<FTransformData>& OutTransformData);
    MOVIESCENE_API UObject* SpawnObject(FMovieSceneSpawnable& Spawnable, FMovieSceneSequenceIDRef TemplateID, IMovieScenePlayer& Player);
    virtual bool CanConvertSpawnableToPossessable(FMovieSceneSpawnable& Spawnable) const { return true; }
 
#endif
 
protected:
 
    virtual UObject* SpawnObject(FMovieSceneSpawnable& Spawnable, FMovieSceneSequenceIDRef TemplateID, TSharedRef<const FSharedPlaybackState> SharedPlaybackState) = 0;
 
    UE_DEPRECATED(5.5, "Please use the version of this with BindingIndex")
    MOVIESCENE_API virtual void PreDestroyObject(UObject& Object, const FGuid& BindingId, FMovieSceneSequenceIDRef TemplateID);
 
    virtual void PreDestroyObject(UObject& Object, const FGuid& BindingId, int32 BindingIndex, FMovieSceneSequenceIDRef TemplateID) {}
 
    UE_DEPRECATED(5.5, "Please use the version of this with CustomSpawnableBinding")
    virtual void DestroySpawnedObject(UObject& Object) {}
 
    virtual void DestroySpawnedObject(UObject& Object, UMovieSceneSpawnableBindingBase* CustomSpawnableBinding) = 0;
 
protected:
 
    struct FSpawnedObject
    {
        FSpawnedObject(const FGuid& InGuid, UObject& InObject, ESpawnOwnership InOwnership)
            : Guid(InGuid)
            , Object(&InObject)
            , Ownership(InOwnership)
        {}
 
        FGuid Guid;
 
        TWeakObjectPtr<UObject> Object;
 
        ESpawnOwnership Ownership;
    };
 
    struct FMovieSceneSpawnRegisterKey
    {
        FMovieSceneSpawnRegisterKey(FMovieSceneSequenceIDRef InTemplateID, const FGuid& InBindingId, int32 InBindingIndex)
            : BindingId(InBindingId)
            , TemplateID(InTemplateID)
            , BindingIndex(InBindingIndex)
        {
        }
 
        bool operator==(const FMovieSceneSpawnRegisterKey& Other) const
        {
            return BindingId == Other.BindingId && TemplateID == Other.TemplateID && BindingIndex == Other.BindingIndex;
        }
        
        friend uint32 GetTypeHash(const FMovieSceneSpawnRegisterKey& Key)
        {
            return HashCombine(HashCombine(GetTypeHash(Key.BindingId), GetTypeHash(Key.TemplateID)), GetTypeHash(Key.BindingIndex));
        }
 
        FGuid BindingId;
 
        FMovieSceneSequenceID TemplateID;
 
        /* For level sequences using custom spawnable bindings, the index of the binding reference. */
        int32 BindingIndex = 0;
    };
 
protected:
 
    TMap<FMovieSceneSpawnRegisterKey, FSpawnedObject> Register;
 
    bool bCleaningUp = false;
};
 
class FNullMovieSceneSpawnRegister : public FMovieSceneSpawnRegister
{
public:
    virtual UObject* SpawnObject(FMovieSceneSpawnable&, FMovieSceneSequenceIDRef, TSharedRef<const FSharedPlaybackState>) override { check(false); return nullptr; }
    virtual void DestroySpawnedObject(UObject&, UMovieSceneSpawnableBindingBase* CustomSpawnableBinding) override {}
};