MovieSceneEvaluationState.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/ContainerAllocationPolicies.h"
#include "Containers/Map.h"
#include "CoreMinimal.h"
#include "Delegates/Delegate.h"
#include "Delegates/MulticastDelegateBase.h"
#include "EntitySystem/MovieSceneSharedPlaybackState.h"
#include "Evaluation/IMovieScenePlaybackCapability.h"
#include "Evaluation/MovieSceneEvaluationKey.h"
#include "Evaluation/PersistentEvaluationData.h"
#include "HAL/Platform.h"
#include "HAL/PlatformCrt.h"
#include "Misc/Guid.h"
#include "MovieSceneSequence.h"
#include "MovieSceneSequenceID.h"
#include "Templates/UniquePtr.h"
#include "Templates/UnrealTypeTraits.h"
#include "UObject/WeakObjectPtr.h"
#include "UObject/WeakObjectPtrTemplates.h"
 
#define UE_API MOVIESCENE_API
 
class IMovieScenePlayer;
class UMovieSceneSequence;
class UObject;
struct FMovieSceneEvaluationKey;
struct FMovieSceneObjectBindingID;
struct FSharedPersistentDataKey;
struct IPersistentEvaluationData;
 
namespace UE::MovieScene
{
 
    struct FInstanceHandle;
    struct FSharedPlaybackState;
 
    struct IObjectBindingNotifyPlaybackCapability
    {
        UE_DECLARE_MOVIESCENE_PLAYBACK_CAPABILITY_API(MOVIESCENE_API, IObjectBindingNotifyPlaybackCapability)
 
        
        virtual void NotifyBindingsChanged() {}
 
        virtual void NotifyBindingUpdate(const FGuid& InBindingId, FMovieSceneSequenceIDRef InSequenceID, TArrayView<TWeakObjectPtr<>> BoundObjects) {}
    };
 
    struct IStaticBindingOverridesPlaybackCapability
    {
        UE_DECLARE_MOVIESCENE_PLAYBACK_CAPABILITY_API(MOVIESCENE_API, IStaticBindingOverridesPlaybackCapability)
 
        virtual ~IStaticBindingOverridesPlaybackCapability() {}
 
        virtual FMovieSceneEvaluationOperand* GetBindingOverride(const FMovieSceneEvaluationOperand& InOperand) = 0;
        virtual void AddBindingOverride(const FMovieSceneEvaluationOperand& InOperand, const FMovieSceneEvaluationOperand& InOverrideOperand) = 0;
        virtual void RemoveBindingOverride(const FMovieSceneEvaluationOperand& InOperand) = 0;
    };
 
    struct FStaticBindingOverrides : public IStaticBindingOverridesPlaybackCapability
    {
        UE_API virtual FMovieSceneEvaluationOperand* GetBindingOverride(const FMovieSceneEvaluationOperand& InOperand) override;
        UE_API virtual void AddBindingOverride(const FMovieSceneEvaluationOperand& InOperand, const FMovieSceneEvaluationOperand& InOverrideOperand) override;
        UE_API virtual void RemoveBindingOverride(const FMovieSceneEvaluationOperand& InOperand) override;
 
    private:
        TMap<FMovieSceneEvaluationOperand, FMovieSceneEvaluationOperand> BindingOverrides;
 
        friend class ::IMovieScenePlayer;
    };
 
}  // namespace UE::MovieScene
 
struct FMovieSceneObjectCache
{
    using FSharedPlaybackState = UE::MovieScene::FSharedPlaybackState;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnBindingInvalidated, const FGuid&);
    FOnBindingInvalidated OnBindingInvalidated;
 
    MOVIESCENE_API TArrayView<TWeakObjectPtr<>> FindBoundObjects(const FGuid& InBindingID, TSharedRef<const FSharedPlaybackState> InSharedPlaybackState);
 
    MOVIESCENE_API TArrayView<const TWeakObjectPtr<>> IterateBoundObjects(const FGuid& InBindingID) const;
 
    MOVIESCENE_API void SetSequence(UMovieSceneSequence& InSequence, FMovieSceneSequenceIDRef InSequenceID, TSharedRef<const FSharedPlaybackState> SharedPlaybackState);
 
    MOVIESCENE_API FGuid FindObjectId(UObject& InObject, TSharedRef<const FSharedPlaybackState> SharedPlaybackState);
 
    MOVIESCENE_API FGuid FindCachedObjectId(UObject& InObject, TSharedRef<const FSharedPlaybackState> SharedPlaybackState);
 
    MOVIESCENE_API void InvalidateExpiredObjects();
 
    MOVIESCENE_API void Invalidate(const FGuid& InGuid);
 
    MOVIESCENE_API void Invalidate(const FGuid& InGuid, FMovieSceneSequenceIDRef InSequenceID);
 
    MOVIESCENE_API void InvalidateIfValid(const FGuid& InGuid);
 
 
    /* Gets the current activation on the provided binding. If no binding lifetime track is present, true will be returned.
     * @param InGuid            The object binding ID
     */
    MOVIESCENE_API bool GetBindingActivation(const FGuid& InGuid) const;
 
    /* Sets the binding to either active or inactive. Inactive bindings will invalidate and not resolve while inactive.
     * @param InGuid            The object binding ID
     * @param bActive           Where to activate or deactivate the binding.
     */
    MOVIESCENE_API void SetBindingActivation(const FGuid& InGuid, bool bActive);
 
    void Clear(TSharedRef<const FSharedPlaybackState> SharedPlaybackState);
 
    UMovieSceneSequence* GetSequence() const { return WeakSequence.Get(); }
 
    uint32 GetSerialNumber() const { return SerialNumber; }
 
    void FilterObjectBindings(UObject* PredicateObject, TSharedRef<const FSharedPlaybackState> SharedPlaybackState, TArray<FMovieSceneObjectBindingID>* OutBindings);
 
public:
 
    // Backwards compatible API, to be deprecated later
 
    MOVIESCENE_API TArrayView<TWeakObjectPtr<>> FindBoundObjects(const FGuid& InBindingID, IMovieScenePlayer& Player);
    MOVIESCENE_API void SetSequence(UMovieSceneSequence& InSequence, FMovieSceneSequenceIDRef InSequenceID, IMovieScenePlayer& Player);
    MOVIESCENE_API FGuid FindObjectId(UObject& InObject, IMovieScenePlayer& Player);
    MOVIESCENE_API FGuid FindCachedObjectId(UObject& InObject, IMovieScenePlayer& Player);
    MOVIESCENE_API void Clear(IMovieScenePlayer& Player);
    MOVIESCENE_API void FilterObjectBindings(UObject* PredicateObject, IMovieScenePlayer& Player, TArray<FMovieSceneObjectBindingID>* OutBindings);
 
private:
    void UpdateBindings(const FGuid& InGuid, TSharedRef<const FSharedPlaybackState> SharedPlaybackState);
 
    bool InvalidateInternal(const FGuid& InGuid);
 
    bool InvalidateIfValidInternal(const FGuid& InGuid);
 
    void UpdateSerialNumber();
 
    struct FBoundObjects
    {
        bool bUpToDate;
        TArray<TWeakObjectPtr<>, TInlineAllocator<1>> Objects;
    };
 
private:
 
    TWeakObjectPtr<UMovieSceneSequence> WeakSequence;
 
    FMovieSceneSequenceID SequenceID;
 
    template<typename ValueType>
    struct TFastGuidKeyFuncs : BaseKeyFuncs<TPair<FGuid,ValueType>,FGuid,false>
    {
        typedef typename TTypeTraits<FGuid>::ConstPointerType KeyInitType;
        typedef const TPairInitializer<typename TTypeTraits<FGuid>::ConstInitType, typename TTypeTraits<ValueType>::ConstInitType>& ElementInitType;
 
        static inline KeyInitType GetSetKey(ElementInitType Element)
        {
            return Element.Key;
        }
        static inline bool Matches(KeyInitType A,KeyInitType B)
        {
            return A == B;
        }
        static inline uint32 GetKeyHash(KeyInitType Key)
        {
            return Key.A ^ Key.B ^ Key.C ^ Key.D;
        }
    };
 
    TMap<FGuid, FBoundObjects, FDefaultSetAllocator, TFastGuidKeyFuncs<FBoundObjects>> BoundObjects;
 
    typedef TArray<FGuid, TInlineAllocator<4>> FGuidArray;
    TMap<FGuid, FGuidArray, FDefaultSetAllocator, TFastGuidKeyFuncs<FGuidArray>> ChildBindings;
    
    TMap<FMovieSceneObjectBindingID, FGuidArray, FDefaultSetAllocator> ReverseMappedBindings;
 
    /* A set of inactive binding ids based on Binding Lifetime track. While inactive, these will be prevented from resolving.*/
    TSet<FGuid> InactiveBindingIds;
 
    uint32 SerialNumber = 0;
 
    bool bReentrantUpdate = false;
};
 
struct FMovieSceneEvaluationState : public UE::MovieScene::IPlaybackCapability
{
    using FSharedPlaybackState = UE::MovieScene::FSharedPlaybackState;
 
    UE_DECLARE_MOVIESCENE_PLAYBACK_CAPABILITY_API(MOVIESCENE_API, FMovieSceneEvaluationState)
 
    FMovieSceneEvaluationState() = default;
    FMovieSceneEvaluationState(const FMovieSceneEvaluationState&) = delete;
    FMovieSceneEvaluationState& operator=(const FMovieSceneEvaluationState&) = delete;
 
    MOVIESCENE_API void AssignSequence(FMovieSceneSequenceIDRef InSequenceID, UMovieSceneSequence& InSequence, TSharedRef<const FSharedPlaybackState> SharedPlaybackState);
 
    MOVIESCENE_API UMovieSceneSequence* FindSequence(FMovieSceneSequenceIDRef InSequenceID) const;
 
    MOVIESCENE_API FMovieSceneSequenceID FindSequenceId(UMovieSceneSequence* InSequence) const;
    MOVIESCENE_API FMovieSceneSequenceID FindSequenceId(const UMovieSceneSequence* InSequence) const;
 
    MOVIESCENE_API FGuid FindObjectId(UObject& Object, FMovieSceneSequenceIDRef InSequenceID, TSharedRef<const FSharedPlaybackState> SharedPlaybackState);
 
    MOVIESCENE_API FGuid FindCachedObjectId(UObject& Object, FMovieSceneSequenceIDRef InSequenceID, TSharedRef<const FSharedPlaybackState> SharedPlaybackState);
 
    MOVIESCENE_API void FilterObjectBindings(UObject* PredicateObject, TSharedRef<const FSharedPlaybackState> SharedPlaybackState, TArray<FMovieSceneObjectBindingID>* OutBindings);
 
    inline FMovieSceneObjectCache* FindObjectCache(FMovieSceneSequenceIDRef SequenceID)
    {
        if (FVersionedObjectCache* Cache = ObjectCaches.Find(SequenceID))
        {
            return &Cache->ObjectCache;
        }
        return nullptr;
    }
 
    inline const FMovieSceneObjectCache* FindObjectCache(FMovieSceneSequenceIDRef SequenceID) const
    {
        if (const FVersionedObjectCache* Cache = ObjectCaches.Find(SequenceID))
        {
            return &Cache->ObjectCache;
        }
        return nullptr;
    }
 
    inline FMovieSceneObjectCache& GetObjectCache(FMovieSceneSequenceIDRef SequenceID)
    {
        FVersionedObjectCache* Cache = ObjectCaches.Find(SequenceID);
        if (!Cache)
        {
            Cache = &ObjectCaches.Add(SequenceID, FVersionedObjectCache());
        }
        return Cache->ObjectCache;
    }
 
    TArrayView<TWeakObjectPtr<>> FindBoundObjects(const FGuid& ObjectBindingID, FMovieSceneSequenceIDRef SequenceID, TSharedRef<const FSharedPlaybackState> SharedPlaybackState)
    {
        FMovieSceneObjectCache* Cache = FindObjectCache(SequenceID);
        if (Cache)
        {
            return Cache->FindBoundObjects(ObjectBindingID, SharedPlaybackState);
        }
 
        return TArrayView<TWeakObjectPtr<>>();
    }
 
    TArrayView<TWeakObjectPtr<>> FindBoundObjects(const FMovieSceneEvaluationOperand& Operand, TSharedRef<const FSharedPlaybackState> SharedPlaybackState)
    {
        return FindBoundObjects(Operand.ObjectBindingID, Operand.SequenceID, SharedPlaybackState);
    }
 
    MOVIESCENE_API void InvalidateExpiredObjects();
 
    MOVIESCENE_API void Invalidate(const FGuid& InGuid, FMovieSceneSequenceIDRef InSequenceID);
 
 
    /* Gets the current activation on the provided binding. If no binding lifetime track is present, true will be returned.
     * @param InGuid            The object binding ID
     * @param InSequenceID      The sequence ID to which the object binding belongs
     */
    MOVIESCENE_API bool GetBindingActivation(const FGuid& InGuid, FMovieSceneSequenceIDRef InSequenceID) const;
 
    /* Sets the binding to either active or inactive. Inactive bindings will invalidate and not resolve while inactive. 
     * @param InGuid            The object binding ID
     * @param InSequenceID      The sequence ID to which the object binding belongs
     * @param bActive           Where to activate or deactivate the binding.
     */
    MOVIESCENE_API void SetBindingActivation(const FGuid& InGuid, FMovieSceneSequenceIDRef InSequenceID, bool bActive);
 
    MOVIESCENE_API void ClearObjectCaches(TSharedRef<const FSharedPlaybackState> SharedPlaybackState);
 
    MOVIESCENE_API uint32 GetSerialNumber();
 
    TMap<FMovieSceneEvaluationKey, TUniquePtr<IPersistentEvaluationData>> PersistentEntityData;
 
    TMap<FSharedPersistentDataKey, TUniquePtr<IPersistentEvaluationData>> PersistentSharedData;
 
public:
 
    MOVIESCENE_API virtual void Initialize(TSharedRef<const FSharedPlaybackState> Owner) override;
    MOVIESCENE_API virtual void OnSubInstanceCreated(TSharedRef<const FSharedPlaybackState> Owner, const UE::MovieScene::FInstanceHandle InstanceHandle) override;
 
 
private:
 
    void RegisterObjectCacheEvents(UMovieSceneEntitySystemLinker* Linker, const UE::MovieScene::FInstanceHandle& InstanceHandle, const FMovieSceneSequenceID SequenceID);
 
public:
 
    // Backwards compatible API, to be deprecated later
 
    MOVIESCENE_API void AssignSequence(FMovieSceneSequenceIDRef InSequenceID, UMovieSceneSequence& InSequence, IMovieScenePlayer& Player);
    MOVIESCENE_API FGuid FindObjectId(UObject& Object, FMovieSceneSequenceIDRef InSequenceID, IMovieScenePlayer& Player);
    MOVIESCENE_API FGuid FindCachedObjectId(UObject& Object, FMovieSceneSequenceIDRef InSequenceID, IMovieScenePlayer& Player);
    MOVIESCENE_API void FilterObjectBindings(UObject* PredicateObject, IMovieScenePlayer& Player, TArray<FMovieSceneObjectBindingID>* OutBindings);
    MOVIESCENE_API void ClearObjectCaches(IMovieScenePlayer& Player);
 
private:
 
    struct FVersionedObjectCache
    {
        FMovieSceneObjectCache ObjectCache;
        FDelegateHandle OnInvalidateObjectBindingHandle;
        uint32 LastKnownSerial = 0;
    };
 
    TMap<FMovieSceneSequenceID, FVersionedObjectCache> ObjectCaches;
 
    uint32 SerialNumber = 0;
};
 
#undef UE_API