MovieScenePreAnimatedStateExtension.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 "Containers/Map.h"
#include "Containers/SortedMap.h"
#include "Containers/SparseArray.h"
#include "CoreTypes.h"
#include "EntitySystem/MovieScenePropertySystemTypes.h"
#include "EntitySystem/MovieSceneSequenceInstanceHandle.h"
#include "Evaluation/MovieSceneAnimTypeID.h"
#include "Evaluation/PreAnimatedState/IMovieScenePreAnimatedStorage.h"
#include "Evaluation/PreAnimatedState/MovieScenePreAnimatedStateTypes.h"
#include "Evaluation/PreAnimatedState/MovieScenePreAnimatedStorageID.h"
#include "Misc/AssertionMacros.h"
#include "Templates/Less.h"
#include "Templates/SharedPointer.h"
#include "Templates/UniquePtr.h"
#include "UObject/ObjectKey.h"
 
class FReferenceCollector;
class UMovieSceneEntitySystemLinker;
class UObject;
struct FMovieSceneAnimTypeID;
struct FScopedPreAnimatedCaptureSource;
struct IMovieScenePreAnimatedGlobalTokenProducer;
struct IMovieScenePreAnimatedTokenProducer;
 
namespace UE
{
namespace MovieScene
{
 
struct FAnimTypePreAnimatedStateObjectStorage;
struct FAnimTypePreAnimatedStateRootStorage;
struct FPreAnimatedEntityCaptureSource;
struct FPreAnimatedEvaluationHookCaptureSources;
struct FPreAnimatedStateEntry;
struct FPreAnimatedStateExtension;
struct FPreAnimatedTemplateCaptureSources;
struct FPreAnimatedTrackInstanceCaptureSources;
struct FPreAnimatedTrackInstanceInputCaptureSources;
struct FRestoreStateParams;
struct FSharedPlaybackState;
struct IPreAnimatedCaptureSource;
struct IPreAnimatedStorage;
 
struct IPreAnimatedStateGroupManager
{
    virtual ~IPreAnimatedStateGroupManager(){}
    virtual void InitializeGroupManager(FPreAnimatedStateExtension* Extension) = 0;
    virtual void OnGroupDestroyed(FPreAnimatedStorageGroupHandle Group) = 0;
    virtual void GatherStaleStorageGroups(TArray<FPreAnimatedStorageGroupHandle>& StaleGroupStorage) const = 0;
};
 
 
struct FPreAnimatedStateExtension
{
public:
 
    MOVIESCENE_API FPreAnimatedStateExtension();
    MOVIESCENE_API ~FPreAnimatedStateExtension();
 
public:
 
    MOVIESCENE_API void Initialize(UMovieSceneEntitySystemLinker* InLinker);
 
    template<typename StorageType>
    static TPreAnimatedStorageID<StorageType> RegisterStorage()
    {
        FPreAnimatedStorageID StorageID = RegisterStorageInternal();
        return static_cast<const TPreAnimatedStorageID<StorageType>&>(StorageID);
    }
 
public:
 
    template<typename StorageType>
    TSharedPtr<StorageType> FindStorage(TPreAnimatedStorageID<StorageType> InStorageID) const
    {
        TSharedPtr<IPreAnimatedStorage> TypedStorage = StorageImplementations.FindRef(InStorageID);
        return StaticCastSharedPtr<StorageType>(TypedStorage);
    }
 
 
    template<typename StorageType>
    void AddStorage(TPreAnimatedStorageID<StorageType> InStorageID, TSharedPtr<StorageType> InStorage)
    {
        check(!StorageImplementations.Contains(InStorageID));
        StorageImplementations.Add(InStorageID, InStorage);
    }
 
 
    template<typename StorageType>
    TSharedPtr<StorageType> GetOrCreateStorage()
    {
        return GetOrCreateStorage(StorageType::StorageID);
    }
 
 
    template<typename StorageType>
    TSharedPtr<StorageType> GetOrCreateStorage(TPreAnimatedStorageID<StorageType> InStorageID)
    {
        TSharedPtr<StorageType> Existing = FindStorage(InStorageID);
        if (!Existing)
        {
            Existing = MakeShared<StorageType>();
            Existing->Initialize(InStorageID, this);
            AddStorage(InStorageID, Existing);
        }
 
        return Existing;
    }
 
 
    TSharedPtr<IPreAnimatedStorage> GetStorageChecked(FPreAnimatedStorageID InStorageID) const
    {
        return StorageImplementations.FindChecked(InStorageID);
    }
 
public:
 
 
    template<typename GroupManagerType>
    TSharedPtr<GroupManagerType> FindGroupManager() const
    {
        return StaticCastSharedPtr<GroupManagerType>(GroupManagers.FindRef(GroupManagerType::GroupManagerID).Pin());
    }
 
 
    template<typename GroupManagerType>
    TSharedPtr<GroupManagerType> GetOrCreateGroupManager()
    {
        TSharedPtr<IPreAnimatedStateGroupManager> Existing = GroupManagers.FindRef(GroupManagerType::GroupManagerID).Pin();
 
        if (!Existing)
        {
            Existing = MakeShared<GroupManagerType>();
            Existing->InitializeGroupManager(this);
            GroupManagers.Add(GroupManagerType::GroupManagerID, Existing);
        }
 
        return StaticCastSharedPtr<GroupManagerType>(Existing);
    }
 
    MOVIESCENE_API FPreAnimatedStorageGroupHandle AllocateGroup(TSharedPtr<IPreAnimatedStateGroupManager> GroupManager);
 
    MOVIESCENE_API void FreeGroup(FPreAnimatedStorageGroupHandle Index);
 
public:
 
    bool IsCapturingGlobalState() const
    {
        return NumRequestsForGlobalState > 0;
    }
 
    bool AreEntriesInvalidated() const
    {
        return bEntriesInvalidated;
    }
 
    void ResetEntryInvalidation()
    {
        bEntriesInvalidated = false;
    }
 
public:
 
    MOVIESCENE_API void RestoreGlobalState(const FRestoreStateParams& Params);
 
    MOVIESCENE_API void DiscardGlobalState(const FRestoreStateParams& Params);
 
    MOVIESCENE_API void RestoreStateForGroup(FPreAnimatedStorageGroupHandle GroupHandle, const FRestoreStateParams& Params);
 
    void DiscardStaleObjectState();
 
    MOVIESCENE_API void ReplaceObjectForGroup(FPreAnimatedStorageGroupHandle GroupHandle, const FObjectKey& OldObject, const FObjectKey& NewObject);
 
 
    MOVIESCENE_API void DiscardTransientState();
 
    MOVIESCENE_API void DiscardStateForGroup(FPreAnimatedStorageGroupHandle GroupHandle);
 
    MOVIESCENE_API void DiscardStateForStorage(FPreAnimatedStorageID StorageID, FPreAnimatedStorageIndex StorageIndex);
 
    MOVIESCENE_API bool ContainsAnyStateForInstanceHandle(FRootInstanceHandle RootInstanceHandle) const;
 
public:
 
    // These methods for globally saving pre-animated state shouldn't be used directly:
    //
    // - use FScopedPreAnimatedCaptureSource to capture from a specific source.
    //
    // - use the similar methods on SharedPlaybackState->GetPreAnimatedState() to save only when it's
    //   needed for that given sequence instance.
    //
    MOVIESCENE_API void SavePreAnimatedState(FMovieSceneAnimTypeID InTokenType, const IMovieScenePreAnimatedGlobalTokenProducer& Producer);
    MOVIESCENE_API void SavePreAnimatedState(UObject& InObject, FMovieSceneAnimTypeID InTokenType, const IMovieScenePreAnimatedTokenProducer& Producer);
 
    MOVIESCENE_API void SavePreAnimatedStateDirectly(FMovieSceneAnimTypeID InTokenType, const IMovieScenePreAnimatedGlobalTokenProducer& Producer);
    MOVIESCENE_API void SavePreAnimatedStateDirectly(UObject& InObject, FMovieSceneAnimTypeID InTokenType, const IMovieScenePreAnimatedTokenProducer& Producer);
 
public:
 
    MOVIESCENE_API FPreAnimatedEntityCaptureSource* GetEntityMetaData() const;
    MOVIESCENE_API FPreAnimatedEntityCaptureSource* GetOrCreateEntityMetaData();
 
    MOVIESCENE_API FPreAnimatedTrackInstanceCaptureSources* GetTrackInstanceMetaData() const;
    MOVIESCENE_API FPreAnimatedTrackInstanceCaptureSources* GetOrCreateTrackInstanceMetaData();
 
    MOVIESCENE_API FPreAnimatedTrackInstanceInputCaptureSources* GetTrackInstanceInputMetaData() const;
    MOVIESCENE_API FPreAnimatedTrackInstanceInputCaptureSources* GetOrCreateTrackInstanceInputMetaData();
 
    MOVIESCENE_API FPreAnimatedTemplateCaptureSources* GetTemplateMetaData() const;
    MOVIESCENE_API FPreAnimatedTemplateCaptureSources* GetOrCreateTemplateMetaData();
 
    MOVIESCENE_API FPreAnimatedEvaluationHookCaptureSources* GetEvaluationHookMetaData() const;
    MOVIESCENE_API FPreAnimatedEvaluationHookCaptureSources* GetOrCreateEvaluationHookMetaData();
 
    MOVIESCENE_API bool HasActiveCaptureSource() const;
 
    MOVIESCENE_API void AddWeakCaptureSource(TWeakPtr<IPreAnimatedCaptureSource> InWeakMetaData);
    MOVIESCENE_API void RemoveWeakCaptureSource(TWeakPtr<IPreAnimatedCaptureSource> InWeakMetaData);
 
    MOVIESCENE_API void EnsureMetaData(const FPreAnimatedStateEntry& Entry);
    MOVIESCENE_API void AddSourceMetaData(const FPreAnimatedStateEntry& Entry);
    MOVIESCENE_API bool MetaDataExists(const FPreAnimatedStateEntry& Entry) const;
 
    MOVIESCENE_API void AddMetaData(const FPreAnimatedStateMetaData& MetaData);
    MOVIESCENE_API void RemoveMetaData(const FPreAnimatedStateMetaData& MetaData);
    MOVIESCENE_API void UpdateMetaData(const FPreAnimatedStateMetaData& MetaData);
 
    MOVIESCENE_API EPreAnimatedStorageRequirement GetStorageRequirement(const FPreAnimatedStateEntry& Entry) const;
 
private:
 
    MOVIESCENE_API void FreeGroupInternal(FPreAnimatedStorageGroupHandle Handle);
 
    MOVIESCENE_API void AddReferencedObjects(UMovieSceneEntitySystemLinker*, FReferenceCollector& ReferenceCollector);
 
    using FContributionRemover = TFunctionRef<void(IPreAnimatedStorage&, FPreAnimatedStorageIndex)>;
    void HandleMetaDataToRemove(
            const FRestoreStateParams& Params, 
            TArrayView<FPreAnimatedStateMetaData> MetaDataToRemove, 
            FContributionRemover RemoveFunc);
 
public:
 
    void OnObjectsReplaced(const TMap<UObject*, UObject*>& ReplacementMap);
 
    uint32 NumRequestsForGlobalState;
 
private:
 
    TUniquePtr<FPreAnimatedEntityCaptureSource> EntityCaptureSource;
 
    TUniquePtr<FPreAnimatedTrackInstanceCaptureSources> TrackInstanceCaptureSource;
 
    TUniquePtr<FPreAnimatedTrackInstanceInputCaptureSources> TrackInstanceInputCaptureSource;
 
    TUniquePtr<UE::MovieScene::FPreAnimatedTemplateCaptureSources> TemplateCaptureSource;
 
    TUniquePtr<UE::MovieScene::FPreAnimatedEvaluationHookCaptureSources> EvaluationHookCaptureSource;
 
    TArray<TWeakPtr<IPreAnimatedCaptureSource>> WeakExternalCaptureSources;
 
    TWeakPtr<FAnimTypePreAnimatedStateObjectStorage> WeakGenericObjectStorage;
    TWeakPtr<FAnimTypePreAnimatedStateRootStorage> WeakGenericRootStorage;
 
private:
 
    friend struct ::FScopedPreAnimatedCaptureSource;
 
    struct FAggregatePreAnimatedStateMetaData
    {
        FAggregatePreAnimatedStateMetaData(FPreAnimatedStateCachedValueHandle InValueHandle)
            : ValueHandle(InValueHandle)
        {}
 
        FPreAnimatedStateCachedValueHandle ValueHandle;
 
        FInstanceHandle TerminalInstanceHandle;
        uint16 NumContributors = 0;
        uint16 NumRestoreContributors = 0;
        bool bWantedRestore = false;
        bool bEligibleForGlobalRestore = false;
    };
 
    MOVIESCENE_API FAggregatePreAnimatedStateMetaData* FindMetaData(const FPreAnimatedStateEntry& Entry);
    MOVIESCENE_API const FAggregatePreAnimatedStateMetaData* FindMetaData(const FPreAnimatedStateEntry& Entry) const;
 
    MOVIESCENE_API FAggregatePreAnimatedStateMetaData* GetOrAddMetaDataInternal(const FPreAnimatedStateEntry& Entry);
 
    struct FPreAnimatedGroupMetaData
    {
        TSharedPtr<IPreAnimatedStateGroupManager> GroupManagerPtr;
        TArray<FAggregatePreAnimatedStateMetaData, TInlineAllocator<4>> AggregateMetaData;
    };
 
    TSparseArray<FPreAnimatedGroupMetaData> GroupMetaData;
 
    TMap<FPreAnimatedStateCachedValueHandle, FAggregatePreAnimatedStateMetaData> UngroupedMetaData;
 
    TSortedMap<FPreAnimatedStorageID, TSharedPtr<IPreAnimatedStorage>> StorageImplementations;
    TSortedMap<FPreAnimatedStorageID, TWeakPtr<IPreAnimatedStateGroupManager>> GroupManagers;
 
    UMovieSceneEntitySystemLinker* Linker;
 
    bool bEntriesInvalidated;
 
private:
 
    static MOVIESCENE_API FPreAnimatedStorageID RegisterStorageInternal();
};
 
 
template<typename KeyType>
struct TPreAnimatedStateGroupManager : IPreAnimatedStateGroupManager, TSharedFromThis<TPreAnimatedStateGroupManager<KeyType>>
{
    void InitializeGroupManager(FPreAnimatedStateExtension* InExtension) override
    {
        Extension = InExtension;
    }
 
    void OnGroupDestroyed(FPreAnimatedStorageGroupHandle Group) override
    {
        KeyType Temp = StorageGroupsToKey.FindChecked(Group);
 
        StorageGroupsByKey.Remove(Temp);
        StorageGroupsToKey.Remove(Group);
    }
 
    
    virtual void GatherStaleStorageGroups(TArray<FPreAnimatedStorageGroupHandle>& StaleGroupStorage) const override
    {
        
    }
 
    FPreAnimatedStorageGroupHandle FindGroupForKey(const KeyType& InKey) const
    {
        return StorageGroupsByKey.FindRef(InKey);
    }
 
    FPreAnimatedStorageGroupHandle MakeGroupForKey(const KeyType& InKey)
    {
        FPreAnimatedStorageGroupHandle GroupHandle = StorageGroupsByKey.FindRef(InKey);
        if (GroupHandle)
        {
            return GroupHandle;
        }
 
        GroupHandle = Extension->AllocateGroup(this->AsShared());
        StorageGroupsByKey.Add(InKey, GroupHandle);
        StorageGroupsToKey.Add(GroupHandle, InKey);
        return GroupHandle;
    }
 
protected:
 
    TMap<KeyType, FPreAnimatedStorageGroupHandle> StorageGroupsByKey;
    TMap<FPreAnimatedStorageGroupHandle, KeyType> StorageGroupsToKey;
 
    FPreAnimatedStateExtension* Extension;
};
 
} // namespace MovieScene
} // namespace UE