MovieSceneEntityManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Algo/AllOf.h"
#include "Algo/AnyOf.h"
#include "Async/TaskGraphInterfaces.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/BitArray.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/SparseArray.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "EntitySystem/MovieSceneComponentTypeHandler.h"
#include "EntitySystem/MovieSceneComponentTypeInfo.h"
#include "EntitySystem/MovieSceneEntityFactoryTypes.h"
#include "EntitySystem/MovieSceneEntityIDs.h"
#include "EntitySystem/MovieSceneEntitySystemTypes.h"
#include "EntitySystem/MovieSceneMaybeAtomic.h"
#include "Evaluation/MovieScenePlayback.h"
#include "HAL/CriticalSection.h"
#include "HAL/PlatformCrt.h"
#include "Misc/AssertionMacros.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/InlineValue.h"
#include "MovieSceneSequenceID.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/StrongObjectPtr.h"
#include "UObject/UObjectArray.h"
 
#include <initializer_list>
 
class FArchive;
class FReferenceCollector;
class UObjectBase;
struct FGuid;
struct FMovieSceneExportedEntity;
 
namespace UE
{
namespace MovieScene
{
 
struct FChildEntityInitializer;
struct FComponentRegistry;
struct FEntityAllocationIteratorProxy;
struct FFreeEntityOperation;
struct FMutualEntityInitializer;
struct IComponentTypeHandler;
struct IMovieSceneEntityMutation;
template <typename T> struct TReadOptional;
template <typename T> struct TWriteOptional;
struct IMovieSceneConditionalEntityMutation;
 
enum class EMutuallyInclusiveComponentType : uint8;
 
enum class EEntityRecursion : uint8
{
    This      = 1 << 0,
    Children  = 1 << 1,
    Full      = This | Children,
};
ENUM_CLASS_FLAGS(EEntityRecursion);
 
class FEntityManager : public FUObjectArray::FUObjectDeleteListener
{
public:
 
    MOVIESCENE_API FEntityManager();
    MOVIESCENE_API ~FEntityManager();
 
    FEntityManager(const FEntityManager&) = delete;
    void operator=(const FEntityManager&) = delete;
 
    FEntityManager(FEntityManager&&) = delete;
    void operator=(FEntityManager&&) = delete;
 
 
    FComponentRegistry* GetComponents() const
    {
        return ComponentRegistry;
    }
 
    void SetComponentRegistry(FComponentRegistry* InComponents)
    {
        ComponentRegistry = InComponents;
    }
 
public:
 
 
    MOVIESCENE_API void Destroy();
 
 
    MOVIESCENE_API FMovieSceneEntityID AllocateEntity();
 
 
    MOVIESCENE_API void FreeEntity(FMovieSceneEntityID EntityID);
 
 
    MOVIESCENE_API int32 FreeEntities(const FEntityComponentFilter& Filter, TSet<FMovieSceneEntityID>* OutFreedEntities = nullptr);
 
 
    MOVIESCENE_API int32 FreeEntities(const FFreeEntityOperation& Operation, TSet<FMovieSceneEntityID>* OutFreedEntities = nullptr);
 
 
    MOVIESCENE_API FEntityDataLocation AllocateContiguousEntities(const FComponentMask& EntityComponentMask, int32* InOutNum);
 
 
    MOVIESCENE_API FEntityInfo AllocateEntity(const FComponentMask& EntityComponentMask);
 
 
    MOVIESCENE_API FEntityInfo GetEntity(FMovieSceneEntityID EntityID) const;
 
 
    MOVIESCENE_API FEntityHandle GetEntityHandle(FMovieSceneEntityID EntityID);
 
 
    bool IsAllocated(FMovieSceneEntityID EntityID) const
    {
        return EntityID && EntityLocations.IsValidIndex(EntityID.AsIndex());
    }
 
 
    MOVIESCENE_API bool IsHandleValid(FEntityHandle EntityID) const;
 
 
    MOVIESCENE_API EEntityThreadingModel ComputeThreadingModel() const;
 
 
    MOVIESCENE_API void UpdateThreadingModel();
 
 
    MOVIESCENE_API EEntityThreadingModel GetThreadingModel() const;
 
public:
 
 
    template<typename T, typename ValueType>
    void AddComponent(FMovieSceneEntityID EntityID, TComponentTypeID<T> ComponentTypeID, ValueType&& InValue)
    {
        AddComponent(EntityID, ComponentTypeID);
 
        FEntityInfo Entry = GetEntity(EntityID);
        if (Entry.Data.Allocation != nullptr)
        {
            const FComponentHeader& Header = Entry.Data.Allocation->GetComponentHeaderChecked(ComponentTypeID);
 
            FScopedHeaderWriteLock WriteLock(&Header, Entry.Data.Allocation->GetCurrentLockMode(), FEntityAllocationWriteContext::NewAllocation());
 
            T* Component = reinterpret_cast<T*>(Header.GetValuePtr(Entry.Data.ComponentOffset));
            *Component = Forward<ValueType>(InValue);
        }
    }
 
 
    MOVIESCENE_API void AddComponent(FMovieSceneEntityID EntityID, FComponentTypeID ComponentTypeID);
    MOVIESCENE_API void AddComponent(FMovieSceneEntityID EntityID, FComponentTypeID ComponentTypeID, EEntityRecursion Recursion);
 
 
    MOVIESCENE_API void AddComponents(FMovieSceneEntityID EntityID, const FComponentMask& EntityComponentMask);
    MOVIESCENE_API void AddComponents(FMovieSceneEntityID EntityID, const FComponentMask& EntityComponentMask, EEntityRecursion Recursion);
 
 
    MOVIESCENE_API void RemoveComponent(FMovieSceneEntityID EntityID, FComponentTypeID ComponentTypeID);
    MOVIESCENE_API void RemoveComponent(FMovieSceneEntityID EntityID, FComponentTypeID ComponentTypeID, EEntityRecursion Recursion);
 
 
    MOVIESCENE_API void RemoveComponents(FMovieSceneEntityID EntityID, const FComponentMask& ComponentsToRemove);
    MOVIESCENE_API void RemoveComponents(FMovieSceneEntityID EntityID, const FComponentMask& ComponentsToRemove, EEntityRecursion Recursion);
 
 
    MOVIESCENE_API bool CopyComponent(FMovieSceneEntityID SrcEntityID, FMovieSceneEntityID DstEntityID, FComponentTypeID ComponentTypeID);
 
 
    MOVIESCENE_API void CopyComponents(FMovieSceneEntityID SrcEntityID, FMovieSceneEntityID DstEntityID, const FComponentMask& ComponentsToCopy);
 
 
    MOVIESCENE_API bool HasComponent(FMovieSceneEntityID EntityID, FComponentTypeID ComponentTypeID) const;
 
 
    MOVIESCENE_API const FComponentMask& GetEntityType(FMovieSceneEntityID InEntity) const;
 
 
    MOVIESCENE_API void ChangeEntityType(FMovieSceneEntityID InEntity, const FComponentMask& InNewMask);
 
 
    MOVIESCENE_API void FilterComponents(FMovieSceneEntityID EntityID, const FComponentMask& EntitiesToKeep);
 
 
    MOVIESCENE_API void CombineComponents(FMovieSceneEntityID DestinationEntityID, FMovieSceneEntityID SourceEntityID, const FComponentMask* OptionalMask = nullptr);
 
 
    MOVIESCENE_API FMovieSceneEntityID DuplicateEntity(FMovieSceneEntityID InOther);
 
 
    MOVIESCENE_API void OverwriteEntityWithDuplicate(FMovieSceneEntityID& InOutEntity, FMovieSceneEntityID InEntityToDuplicate);
 
 
    int32 DefineInstancedChildInitializer(TInlineValue<FChildEntityInitializer>&& InInitializer)
    {
        check(InInitializer.IsValid());
        return InstancedChildInitializers.Add(MoveTemp(InInitializer));
    }
 
    MOVIESCENE_API void InitializeChildAllocation(const FComponentMask& ParentType, const FComponentMask& ChildType, const FEntityAllocation* ParentAllocation, TArrayView<const int32> ParentAllocationOffsets, const FEntityRange& InChildEntityRange);
 
    void DestroyInstancedChildInitializer(int32 Index)
    {
        InstancedChildInitializers.RemoveAt(Index);
    }
 
    MOVIESCENE_API void AddMutualComponents();
 
    MOVIESCENE_API void AddMutualComponents(const FEntityComponentFilter& InFilter);
 
public:
 
 
    template<typename T>
    TComponentLock<TReadOptional<T>> ReadComponent(FMovieSceneEntityID Entity, TComponentTypeID<T> ComponentTypeID) const
    {
        check(Entity);
 
        if (!ComponentTypeID)
        {
            return TComponentLock<TReadOptional<T>>();
        }
 
        FEntityLocation Location = EntityLocations[Entity.AsIndex()];
        if (!Location.IsValid() || !EntityAllocationMasks[Location.GetAllocationIndex()].Contains(ComponentTypeID))
        {
            return TComponentLock<TReadOptional<T>>();
        }
 
        FEntityAllocation* Allocation = EntityAllocations[Location.GetAllocationIndex()];
        const int32 ComponentOffset = Location.GetEntryIndexWithinAllocation();
 
        EComponentHeaderLockMode LockMode = GetThreadingModel() == EEntityThreadingModel::NoThreading
            ? EComponentHeaderLockMode::LockFree
            : EComponentHeaderLockMode::Mutex;
 
        for (FComponentHeader& Header : Allocation->GetComponentHeaders())
        {
            if (Header.ComponentType == ComponentTypeID)
            {
                return TComponentLock<TReadOptional<T>>(&Header, LockMode, ComponentOffset);
            }
        }
 
        return TComponentLock<TReadOptional<T>>();
    }
 
 
    template<typename T>
    T ReadComponentChecked(FMovieSceneEntityID Entity, TComponentTypeID<T> ComponentTypeID) const
    {
        TComponentLock<TReadOptional<T>> Value = ReadComponent(Entity, ComponentTypeID);
        check(Value);
        return *Value;
    }
 
 
    template<typename T>
    TComponentLock<TWriteOptional<T>> WriteComponent(FMovieSceneEntityID Entity, TComponentTypeID<T> ComponentTypeID)
    {
        check(Entity);
 
        if (!ComponentTypeID)
        {
            return TComponentLock<TWriteOptional<T>>();
        }
 
        FEntityLocation Location = EntityLocations[Entity.AsIndex()];
        if (!Location.IsValid() || !EntityAllocationMasks[Location.GetAllocationIndex()].Contains(ComponentTypeID))
        {
            return TComponentLock<TWriteOptional<T>>();
        }
 
        FEntityAllocation* Allocation = EntityAllocations[Location.GetAllocationIndex()];
        const int32 ComponentOffset = Location.GetEntryIndexWithinAllocation();
 
        EComponentHeaderLockMode LockMode = GetThreadingModel() == EEntityThreadingModel::NoThreading
            ? EComponentHeaderLockMode::LockFree
            : EComponentHeaderLockMode::Mutex;
 
        for (FComponentHeader& Header : Allocation->GetComponentHeaders())
        {
            if (Header.ComponentType == ComponentTypeID)
            {
                return TComponentLock<TWriteOptional<T>>(&Header, LockMode, FEntityAllocationWriteContext(*this), ComponentOffset);
            }
        }
 
        return TComponentLock<TWriteOptional<T>>();
    }
 
 
    template<typename T, typename ValueType>
    void WriteComponentChecked(FMovieSceneEntityID Entity, TComponentTypeID<T> ComponentTypeID, ValueType&& Value)
    {
        TComponentLock<TWriteOptional<T>> ComponentPtr = WriteComponent(Entity, ComponentTypeID);
        check(ComponentPtr);
        *ComponentPtr = Forward<ValueType>(Value);
    }
 
public:
 
    void SetGatherThread(ENamedThreads::Type InGatherThread)
    {
        GatherThread = InGatherThread;
    }
 
    ENamedThreads::Type GetGatherThread() const
    {
        return GatherThread;
    }
 
    void SetDispatchThread(ENamedThreads::Type InDispatchThread)
    {
        DispatchThread = InDispatchThread;
    }
 
    ENamedThreads::Type GetDispatchThread() const
    {
        return DispatchThread;
    }
 
    MOVIESCENE_API void Compact();
 
 
    MOVIESCENE_API int32 MutateAll(const FEntityComponentFilter& Filter, const IMovieSceneEntityMutation& Mutation, EMutuallyInclusiveComponentType MutualTypes = EMutuallyInclusiveComponentType::Mandatory);
 
 
    MOVIESCENE_API int32 MutateConditional(const FEntityComponentFilter& Filter, const IMovieSceneConditionalEntityMutation& Mutation, EMutuallyInclusiveComponentType MutualTypes = EMutuallyInclusiveComponentType::Mandatory);
 
 
    MOVIESCENE_API void TouchEntity(FMovieSceneEntityID EntityID);
 
 
    MOVIESCENE_API void AddChild(FMovieSceneEntityID ParentID, FMovieSceneEntityID ChildID);
 
 
    MOVIESCENE_API void GetImmediateChildren(FMovieSceneEntityID ParentID, TArray<FMovieSceneEntityID>& OutChildren) const;
 
 
    MOVIESCENE_API void GetChildren_ParentFirst(FMovieSceneEntityID ParentID, TArray<FMovieSceneEntityID>& OutChildren) const;
 
 
    template<typename IteratorType>
    void IterateImmediateChildren(FMovieSceneEntityID ParentID, IteratorType&& Iterator) const
    {
        for (auto ChildIt = ParentToChild.CreateConstKeyIterator(ParentID); ChildIt; ++ChildIt)
        {
            Iterator(ChildIt.Value());
        }
    }
 
 
    template<typename IteratorType>
    void IterateChildren_ParentFirst(FMovieSceneEntityID ParentID, IteratorType&& Iterator) const
    {
        for (auto ChildIt = ParentToChild.CreateConstKeyIterator(ParentID); ChildIt; ++ChildIt)
        {
            Iterator(ChildIt.Value());
            IterateChildren_ParentFirst(ChildIt.Value(), Iterator);
        }
    }
 
public:
 
 
    MOVIESCENE_API void CountMemory(FArchive& Ar, FMovieSceneEntityID EntityID);
 
 
    static MOVIESCENE_API IComponentTypeHandler* FindComponentTypeHandler(const FGuid& ComponentGuid);
 
public:
 
    MOVIESCENE_API FEntityAllocationIteratorProxy Iterate(const FEntityComponentFilter* InFilter) const;
 
 
    MOVIESCENE_API bool Contains(const FEntityComponentFilter& InFilter) const;
 
 
    bool ContainsComponent(FComponentTypeID ComponentTypeID) const
    {
        return GetAccumulatedMask().Contains(ComponentTypeID);
    }
 
 
    bool ContainsAnyComponent(std::initializer_list<FComponentTypeID> ComponentTypeIDs) const
    {
        const FComponentMask& Mask = GetAccumulatedMask();
        return Algo::AnyOf(ComponentTypeIDs, [&Mask](FComponentTypeID In){ return Mask.Contains(In); });
    }
 
    bool ContainsAnyComponent(const FComponentMask& ComponentTypeIDs) const
    {
        const FComponentMask& Mask = GetAccumulatedMask();
        return FComponentMask::BitwiseAND(Mask, ComponentTypeIDs, EBitwiseOperatorFlags::MinSize).First() != FComponentTypeID::Invalid();
    }
 
    bool ContainsAllComponents(std::initializer_list<FComponentTypeID> ComponentTypeIDs) const
    {
        const FComponentMask& Mask = GetAccumulatedMask();
        return Algo::AllOf(ComponentTypeIDs, [&Mask](FComponentTypeID In){ return Mask.Contains(In); });
    }
 
 
    MOVIESCENE_API void AccumulateMask(const FEntityComponentFilter& InFilter, FComponentMask& OutMask) const;
 
 
    MOVIESCENE_API const FComponentMask& GetAccumulatedMask() const;
 
 
    MOVIESCENE_API void EnterIteration() const;
    MOVIESCENE_API void ExitIteration() const;
 
    void CheckCanChangeStructure() const
    {
        checkf(IterationCount.Load(ThreadingModel) == 0, TEXT("Mutation of entities is not permissible while entities are being iterated"));
        checkf(LockdownState == ELockdownState::Unlocked, TEXT("Structural changes to the entity manager are not permitted while it is locked down"));
    }
 
    bool IsLockedDown() const
    {
        return LockdownState == ELockdownState::Locked;
    }
 
    void LockDown()
    {
        LockdownState = ELockdownState::Locked;
    }
 
    void ReleaseLockDown()
    {
        LockdownState = ELockdownState::Unlocked;
    }
 
    const FEntityComponentFilter& GetGlobalIterationFilter() const
    {
        return GlobalIterationFilter;
    }
 
    FEntityComponentFilter& ModifyGlobalIterationFilter()
    {
        ensureMsgf(!IsLockedDown() && IterationCount.Load(ThreadingModel) == 0, TEXT("Manipulating the global iteration filter while locked down or iterating is not recommended"));
        return GlobalIterationFilter;
    }
 
    void IncrementSystemSerial(uint64 IncAmount = 1)
    {
        SystemSerialNumber += IncAmount;
    }
 
    uint64 GetSystemSerial() const
    {
        return SystemSerialNumber;
    }
 
    bool HasStructureChangedSince(uint64 CachedSerial) const
    {
        return CachedSerial == 0 || StructureMutationSystemSerialNumber > CachedSerial;
    }
 
    void MimicStructureChanged()
    {
        OnStructureChanged();
    }
 
public:
 
    void SetDebugName(FString&& InNewDebugName)
    {
        ManagerDebugName = MoveTemp(InNewDebugName);
    }
 
 
    MOVIESCENE_API void AddReferencedObjects(FReferenceCollector& ReferenceCollector);
 
    
    MOVIESCENE_API void ReplaceEntityID(FMovieSceneEntityID& InOutEntity, FMovieSceneEntityID EntityToDiscard);
 
    uint32 GetHandleGeneration() const
    {
        if (bHandleGenerationStale)
        {
            ++CurrentHandleGeneration;
        }
        bHandleGenerationStale = false;
        return CurrentHandleGeneration;
    }
 
private:
    friend struct FEntityInitializer; 
 
    enum class EMemoryType
    {
        Uninitialized,
        DefaultConstructed
    };
    MOVIESCENE_API void OnStructureChanged();
 
    MOVIESCENE_API FEntityAllocation* CreateEntityAllocation(const FComponentMask& EntityComponentMask, uint16 InitialCapacity, uint16 MaxCapacity, FEntityAllocation* MigrateComponentDataFrom = nullptr);
    MOVIESCENE_API int32 CreateEntityAllocationEntry(const FComponentMask& EntityComponentMask, uint16 InitialCapacity, uint16 MaxCapacity);
 
    MOVIESCENE_API int32 GetOrCreateAllocationWithSlack(const FComponentMask& EntityComponentMask, int32* InOutDesiredSlack = nullptr);
    MOVIESCENE_API int32 CreateAllocationWithSlack(const FComponentMask& EntityComponentMask, int32* InOutDesiredSlack = nullptr);
    MOVIESCENE_API int32 MigrateEntity(int32 DestIndex, int32 SourceIndex, int32 SourceEntryIndexWithinAllocation);
 
    MOVIESCENE_API void CopyComponents(int32 DestAllocationIndex, int32 DestEntityIndex, int32 SourceAllocationIndex, int32 SourceEntityIndex, const FComponentMask* OptionalMask = nullptr);
 
    MOVIESCENE_API int32 AddEntityToAllocation(int32 AllocationIndex, FMovieSceneEntityID ID, EMemoryType MemoryType = EMemoryType::DefaultConstructed);
    MOVIESCENE_API void RemoveEntityFromAllocation(int32 AllocationIndex, int32 SourceEntryIndexWithinAllocation);
 
    MOVIESCENE_API FEntityAllocation* MigrateAllocation(int32 AllocationIndex, const FComponentMask& NewComponentMask);
 
    MOVIESCENE_API void CombineAllocations(int32 DestinationIndex, int32 SourceIndex);
 
    FEntityAllocation* GetAllocation(int32 AllocationIndex) const
    {
        return EntityAllocations[AllocationIndex];
    }
 
    MOVIESCENE_API int32 ReserveAllocation(int32 AllocationIndex, int32 NumToReserve);
    MOVIESCENE_API FEntityAllocation* GrowAllocation(int32 AllocationIndex, int32 MinNumToGrowBy = 1);
 
    MOVIESCENE_API void DestroyAllocation(FEntityAllocation* Allocation, bool bDestructComponentData = true);
 
    MOVIESCENE_API virtual void NotifyUObjectDeleted(const UObjectBase* Object, int32 Index) override;
    MOVIESCENE_API virtual void OnUObjectArrayShutdown() override;
    MOVIESCENE_API virtual FString GetReferencerName() const;
 
    MOVIESCENE_API void CheckInvariants();
 
    virtual SIZE_T GetAllocatedSize() const override
    {
        return 0;
    }
 
    friend struct FEntityAllocationProxy;
    friend struct FEntityAllocationIterator;
    friend struct FEntityAllocationIteratorProxy;
 
    friend FFreeEntityOperation;
 
    struct FEntityLocation
    {
        FEntityLocation()
            : AllocationIndex(INVALID)
            , EntryIndexWithinAllocation(0)
        {}
 
        void Reset()
        {
            AllocationIndex = INVALID;
            EntryIndexWithinAllocation = 0;
        }
 
        void Set(int32 InAllocationIndex, int32 InEntryIndexWithinAllocation)
        {
            check((InAllocationIndex & 0xFFFF0000) == 0 && (InEntryIndexWithinAllocation & 0xFFFF0000) == 0);
            AllocationIndex = (uint16)InAllocationIndex;
            EntryIndexWithinAllocation = (uint16)InEntryIndexWithinAllocation;
        }
 
        int32 GetAllocationIndex() const
        {
            return AllocationIndex;
        }
 
        int32 GetEntryIndexWithinAllocation() const
        {
            return EntryIndexWithinAllocation;
        }
 
        bool IsValid() const
        {
            return AllocationIndex != INVALID;
        }
 
        void SetParentID(FMovieSceneEntityID InParentID)
        {
            ParentID = InParentID;
        }
 
        FMovieSceneEntityID GetParentID() const
        {
            return ParentID;
        }
 
    private:
 
        static const uint16 INVALID = ~uint16(0);
        uint16 AllocationIndex;
        uint16 EntryIndexWithinAllocation;
 
        FMovieSceneEntityID ParentID;
    };
 
    TSparseArray<FComponentMask> EntityAllocationMasks;
 
    TBitArray<> AllocationsWithCapacity;
 
    TSparseArray<FEntityAllocation*> EntityAllocations;
 
    TSparseArray<FEntityLocation> EntityLocations;
 
    TMultiMap<FMovieSceneEntityID, FMovieSceneEntityID> ParentToChild;
 
    TSparseArray<TInlineValue<FChildEntityInitializer>> InstancedChildInitializers;
 
    TMap<FMovieSceneEntityID, uint32> EntityGenerationMap;
 
    FComponentMask AccumulatedMask;
    FEntityComponentFilter GlobalIterationFilter;
 
    FComponentRegistry* ComponentRegistry;
 
    FString ManagerDebugName;
 
    uint64 SystemSerialNumber;
 
    uint64 StructureMutationSystemSerialNumber;
 
#if UE_MOVIESCENE_ENTITY_DEBUG
    const bool* RichComponentDebuggingPtr;
#endif
 
    uint32 NextAllocationID;
 
    mutable uint32 CurrentHandleGeneration;
    mutable bool bHandleGenerationStale;
    mutable bool bAccumulatedMaskStale;
 
    mutable FEntitySystemMaybeAtomicInt32 IterationCount;
 
    ENamedThreads::Type GatherThread;
    ENamedThreads::Type DispatchThread;
    EEntityThreadingModel ThreadingModel;
 
    enum class ELockdownState
    {
        Locked, Unlocked
    };
 
    ELockdownState LockdownState;
};
 
 
struct FFreeEntityOperation
{
    FFreeEntityOperation(FEntityManager* InEntityManager)
        : EntityManager(InEntityManager)
    {}
 
    void MarkAllocationForFree(int32 AllocationIndex);
 
    void MarkEntityForFree(FMovieSceneEntityID EntityID);
 
private:
 
    struct FAllocationMask
    {
        TBitArray<> Mask;
        bool bDestroyAllocation = false;
    };
 
    struct FCommitData
    {
        TMap<int32, FAllocationMask> AllocationsToEntities;
 
        TArray<FMovieSceneEntityID> EmptyEntities;
    };
 
    FCommitData Commit() const;
 
    friend FEntityManager;
 
    TArray<int32> AllocationsToDestroy;
 
    TArray<FMovieSceneEntityID> LooseEntitiesToDestroy;
 
    FEntityManager* EntityManager;
};
 
extern MOVIESCENE_API FEntityManager* GEntityManagerForDebuggingVisualizers;
 
 
} // namespace MovieScene
} // namespace UE