MassObserverManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "MassEntityHandle.h"
#include "MassProcessingTypes.h"
#include "MassEntityTypes.h"
#include "MassArchetypeTypes.h"
#include "Misc/Fork.h"
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
// the following is a new header, but it contains some types moved over from other places, and including
// said header ties everything together. Engine code has been updated to not require it
#include "MassObserverNotificationTypes.h"
#endif // UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "MassObserverManager.generated.h"
 
 
struct FMassObserverExecutionContext;
struct FMassEntityManager;
struct FMassArchetypeEntityCollection;
class UMassProcessor;
class UMassObserverProcessor;
namespace UE::Mass
{
    struct FProcessingContext;
    namespace ObserverManager
    {
        struct FDeprecationHelper;
        struct FBufferedNotificationExecutioner;
        struct FBufferedCreationNotificationExecutioner;
 
        struct FBufferedNotification;
        struct FCreationNotificationHandle;
        struct FObserverLock;
        struct FCreationContext;
    }
}
 
USTRUCT()
struct FMassObserversMap
{
    GENERATED_BODY()
 
    // a helper accessor simplifying access while still keeping Container private
    TMap<TObjectPtr<const UScriptStruct>, FMassRuntimePipeline>& operator*()
    {
        return Container;
    }
 
    void DebugAddUniqueProcessors(TArray<const UMassProcessor*>& OutProcessors) const;
 
private:
    UPROPERTY()
    TMap<TObjectPtr<const UScriptStruct>, FMassRuntimePipeline> Container;
};
 
USTRUCT()
struct FMassObserverManager
{
    GENERATED_BODY()
 
    
    using FObserverLock = UE::Mass::ObserverManager::FObserverLock;
    using FBufferedNotification = UE::Mass::ObserverManager::FBufferedNotification;
    using FCreationNotificationHandle = UE::Mass::ObserverManager::FCreationNotificationHandle;
    using FCreationContext = UE::Mass::ObserverManager::FCreationContext;
 
    MASSENTITY_API FMassObserverManager();
 
    FMassEntityManager& GetEntityManager();
 
    const FMassFragmentBitSet* GetObservedFragmentBitSets() const { return ObservedFragments; }
    const FMassFragmentBitSet& GetObservedFragmentsBitSet(const EMassObservedOperation Operation) const 
    { 
        return ObservedFragments[(uint8)Operation]; 
    }
 
    const FMassTagBitSet* GetObservedTagBitSets() const { return ObservedTags; }
    const FMassTagBitSet& GetObservedTagsBitSet(const EMassObservedOperation Operation) const 
    { 
        return ObservedTags[(uint8)Operation]; 
    }
    
    bool HasObserversForBitSet(const FMassFragmentBitSet& InQueriedBitSet, const EMassObservedOperation Operation) const
    {
        return ObservedFragments[(uint8)Operation].HasAny(InQueriedBitSet);
    }
 
    bool HasObserversForBitSet(const FMassTagBitSet& InQueriedBitSet, const EMassObservedOperation Operation) const
    {
        return ObservedTags[(uint8)Operation].HasAny(InQueriedBitSet);
    }
 
    bool HasObserversForComposition(const FMassArchetypeCompositionDescriptor& Composition, const EMassObservedOperation Operation) const
    {
        return HasObserversForBitSet(Composition.GetFragments(), Operation) || HasObserversForBitSet(Composition.GetTags(), Operation);
    }
 
    MASSENTITY_API bool OnPostEntitiesCreated(const FMassArchetypeEntityCollection& EntityCollection);
 
    MASSENTITY_API bool OnPostEntityCreated(const FMassEntityHandle Entity, const FMassArchetypeCompositionDescriptor& Composition);
 
    MASSENTITY_API bool OnPreEntitiesDestroyed(const FMassArchetypeEntityCollection& EntityCollection);
 
    MASSENTITY_API bool OnPreEntitiesDestroyed(UE::Mass::FProcessingContext& ProcessingContext, const FMassArchetypeEntityCollection& EntityCollection);
 
    MASSENTITY_API bool OnPreEntityDestroyed(const FMassArchetypeCompositionDescriptor& ArchetypeComposition, const FMassEntityHandle Entity);
 
    bool OnPostCompositionAdded(const FMassEntityHandle Entity, const FMassArchetypeCompositionDescriptor& Composition)
    {
        return OnCompositionChanged(Entity, Composition, EMassObservedOperation::AddElement);
    }
    bool OnPreCompositionRemoved(const FMassEntityHandle Entity, const FMassArchetypeCompositionDescriptor& Composition)
    {
        return OnCompositionChanged(Entity, Composition, EMassObservedOperation::RemoveElement);
    }
 
protected:
    struct FCollectionRefOrHandle
    {
        UE_NONCOPYABLE(FCollectionRefOrHandle);
 
        static FMassArchetypeEntityCollection DummyCollection;
        explicit FCollectionRefOrHandle(FMassEntityHandle InEntityHandle)
            : EntityHandle(InEntityHandle)
            , EntityCollection(DummyCollection)
        {   
        }
 
        explicit FCollectionRefOrHandle(const FMassArchetypeEntityCollection& InEntityCollection)
            : EntityCollection(InEntityCollection)
        {   
        }
 
        FMassEntityHandle EntityHandle;
        const FMassArchetypeEntityCollection& EntityCollection;
    };
    MASSENTITY_API bool OnCompositionChanged(FCollectionRefOrHandle&& EntityCollection, const FMassArchetypeCompositionDescriptor& Composition
        , const EMassObservedOperation Operation, UE::Mass::FProcessingContext* ProcessingContext = nullptr);
 
public:
    bool OnCompositionChanged(const FMassArchetypeEntityCollection& EntityCollection, const FMassArchetypeCompositionDescriptor& Composition
        , const EMassObservedOperation Operation, UE::Mass::FProcessingContext* ProcessingContext = nullptr)
    {
        TRACE_CPUPROFILER_EVENT_SCOPE(MassObserver_OnCompositionChanged_Collection);
        return OnCompositionChanged(FCollectionRefOrHandle(EntityCollection), Composition, Operation, ProcessingContext);
    }
 
    bool OnCompositionChanged(FMassEntityHandle EntityHandle, const FMassArchetypeCompositionDescriptor& Composition
        , const EMassObservedOperation Operation, UE::Mass::FProcessingContext* ProcessingContext = nullptr)
    {
        TRACE_CPUPROFILER_EVENT_SCOPE(MassObserver_OnCompositionChanged_Entity);
        return OnCompositionChanged(FCollectionRefOrHandle(EntityHandle), Composition, Operation, ProcessingContext);
    }
 
    template<typename T, typename U = std::decay_t<T>> requires (std::is_same_v<U, FMassFragmentBitSet> || std::is_same_v<U, FMassTagBitSet>)
    bool OnCompositionChanged(const FMassArchetypeEntityCollection& EntityCollection, T&& BitSet
        , const EMassObservedOperation Operation, UE::Mass::FProcessingContext* ProcessingContext = nullptr)
    {
        return OnCompositionChanged(EntityCollection, FMassArchetypeCompositionDescriptor(MoveTemp(BitSet)), Operation, ProcessingContext);
    }
 
    template<typename T, typename U = std::decay_t<T>> requires (std::is_same_v<U, FMassFragmentBitSet> || std::is_same_v<U, FMassTagBitSet>)
    bool OnCompositionChanged(const FMassEntityHandle Entity, T&& BitSet
        , const EMassObservedOperation Operation, UE::Mass::FProcessingContext* ProcessingContext = nullptr)
    {
        return OnCompositionChanged(Entity, FMassArchetypeCompositionDescriptor(MoveTemp(BitSet)), Operation, ProcessingContext);
    }
 
    MASSENTITY_API void AddObserverInstance(TNotNull<const UScriptStruct*> ElementType, EMassObservedOperationFlags OperationFlags, TNotNull<UMassProcessor*> ObserverProcessor);
    MASSENTITY_API void AddObserverInstance(const UScriptStruct& ElementType, EMassObservedOperation Operation, UMassProcessor& ObserverProcessor);
    MASSENTITY_API void AddObserverInstance(TNotNull<UMassObserverProcessor*> ObserverProcessor);
    MASSENTITY_API void RemoveObserverInstance(TNotNull<const UScriptStruct*> ElementType, EMassObservedOperationFlags OperationFlags, TNotNull<UMassProcessor*> ObserverProcessor);
    MASSENTITY_API void RemoveObserverInstance(const UScriptStruct& ElementType, EMassObservedOperation Operation, UMassProcessor& ObserverProcessor);
 
    MASSENTITY_API void ReleaseCreationHandle(UE::Mass::ObserverManager::FCreationNotificationHandle InCreationNotificationHandle);
 
    MASSENTITY_API void DebugGatherUniqueProcessors(TArray<const UMassProcessor*>& OutProcessors) const;
 
protected:
    friend FMassEntityManager;
    MASSENTITY_API explicit FMassObserverManager(FMassEntityManager& Owner);
 
    MASSENTITY_API void Initialize();
    MASSENTITY_API void DeInitialize();
 
    friend UE::Mass::ObserverManager::FBufferedNotificationExecutioner;
    friend UE::Mass::ObserverManager::FBufferedCreationNotificationExecutioner;
 
    static MASSENTITY_API void HandleElementsImpl(UE::Mass::FProcessingContext& ProcessingContext, TConstArrayView<FMassArchetypeEntityCollection> EntityCollections
        , FMassObserverExecutionContext&& ObserverContext, FMassObserversMap& HandlersContainer);
 
    MASSENTITY_API bool OnCollectionsCreatedImpl(UE::Mass::FProcessingContext& ProcessingContext, TConstArrayView<FMassArchetypeEntityCollection> EntityCollections);
 
    MASSENTITY_API void OnPostFork(EForkProcessRole);
 
    MASSENTITY_API void OnModulePackagesUnloaded(TConstArrayView<UPackage*> Packages);
 
    //TSharedRef<FObserverLock> GetOrMakeObserverLock(TConstArrayView<FMassEntityHandle> ReservedEntities, FMassArchetypeEntityCollection&& EntityCollection);
    MASSENTITY_API TSharedRef<FObserverLock> GetOrMakeObserverLock();
    TSharedPtr<FObserverLock> GetObserverLock() const;
    bool IsLocked() const { return ActiveObserverLock.IsValid(); }
    MASSENTITY_API TSharedRef<FCreationContext> GetOrMakeCreationContext();
    MASSENTITY_API TSharedRef<FCreationContext> GetOrMakeCreationContext(TConstArrayView<FMassEntityHandle> ReservedEntities, FMassArchetypeEntityCollection&& EntityCollection);
    TSharedPtr<FCreationContext> GetCreationContext() const;
    
    //-----------------------------------------------------------------------------
    // Observers locking logic
    //-----------------------------------------------------------------------------
    friend FObserverLock;
 
    MASSENTITY_API void ResumeExecution(FObserverLock& LockBeingReleased);
 
    TWeakPtr<FObserverLock> ActiveObserverLock;
    int32 LocksCount = 0;
    TWeakPtr<FCreationContext> ActiveCreationContext;
 
    FMassFragmentBitSet ObservedFragments[(uint8)EMassObservedOperation::MAX];
    FMassTagBitSet ObservedTags[(uint8)EMassObservedOperation::MAX];
 
    UPROPERTY()
    FMassObserversMap FragmentObservers[(uint8)EMassObservedOperation::MAX];
 
    UPROPERTY()
    FMassObserversMap TagObservers[(uint8)EMassObservedOperation::MAX];
 
    FDelegateHandle ModulesUnloadedHandle;
 
    FMassEntityManager& EntityManager;
 
#if WITH_MASSENTITY_DEBUG
    uint32 LockedNotificationSerialNumber = 1;
    uint32 DebugNonTrivialResumeExecutionCount = 0;
#endif // WITH_MASSENTITY_DEBUG
 
public:
    UE_DEPRECATED(5.5, "This flavor of OnPostEntitiesCreated is deprecated. Please use the one taking a TConstArrayView<FMassArchetypeEntityCollection> parameter instead")
    MASSENTITY_API bool OnPostEntitiesCreated(UE::Mass::FProcessingContext& InProcessingContext, const FMassArchetypeEntityCollection& EntityCollection);
    UE_DEPRECATED(5.6, "*FragmentOrTag* functions have been deprecated. Use OnCompositionChanged instead.")
    MASSENTITY_API void OnPostFragmentOrTagAdded(const UScriptStruct& FragmentOrTagType, const FMassArchetypeEntityCollection& EntityCollection);
    UE_DEPRECATED(5.6, "*FragmentOrTag* functions have been deprecated. Use OnCompositionChanged instead.")
    MASSENTITY_API void OnPreFragmentOrTagRemoved(const UScriptStruct& FragmentOrTagType, const FMassArchetypeEntityCollection& EntityCollection);
    UE_DEPRECATED(5.6, "*FragmentOrTag* functions have been deprecated. Use OnCompositionChanged instead.")
    MASSENTITY_API void OnFragmentOrTagOperation(const UScriptStruct& FragmentOrTagType, const FMassArchetypeEntityCollection& EntityCollection, const EMassObservedOperation Operation);
    UE_DEPRECATED(5.6, "Use the other OnPostEntitiesCreated implementation.")
    MASSENTITY_API bool OnPostEntitiesCreated(UE::Mass::FProcessingContext& InProcessingContext, TConstArrayView<FMassArchetypeEntityCollection> EntityCollections);
    UE_DEPRECATED(5.6, "Use the other OnCompositionChanged implementation.")
    MASSENTITY_API bool OnCompositionChanged(UE::Mass::FProcessingContext& InProcessingContext, const FMassArchetypeEntityCollection& EntityCollection
        , const FMassArchetypeCompositionDescriptor& Composition, const EMassObservedOperation Operation);
protected:
    UE_DEPRECATED(5.6, "Use HandleElementsImpl instead.")
    MASSENTITY_API void HandleSingleEntityImpl(const UScriptStruct& FragmentType, const FMassArchetypeEntityCollection& EntityCollection, FMassObserversMap& HandlersContainer);
    UE_DEPRECATED(5.7, "Use the implementation with the FMassObserverExecutionContext parameter")
    static void HandleElementsImpl(UE::Mass::FProcessingContext& ProcessingContext, TConstArrayView<FMassArchetypeEntityCollection> EntityCollections
        , TArrayView<const UScriptStruct*> ObservedTypes, FMassObserversMap& HandlersContainer);
    UE_DEPRECATED(5.7, "Use the HandleElementsImpl implementation with the FMassObserverExecutionContext parameter")
    static void HandleFragmentsImpl(UE::Mass::FProcessingContext& ProcessingContext, const FMassArchetypeEntityCollection& EntityCollection
        , TArrayView<const UScriptStruct*> ObservedTypes, FMassObserversMap& HandlersContainer);
 
    UE_DEPRECATED(5.7, "Rvalue ref implementation is no longer available, it didn't do anything special. Please use the other OnCollectionsCreatedImpl implementation instead.")
    MASSENTITY_API bool OnCollectionsCreatedImpl(UE::Mass::FProcessingContext& ProcessingContext, TArray<FMassArchetypeEntityCollection>&& EntityCollections);
 
    friend UE::Mass::ObserverManager::FDeprecationHelper;
};
 
template<>
struct TStructOpsTypeTraits<FMassObserverManager> : public TStructOpsTypeTraitsBase2<FMassObserverManager>
{
    enum
    {
        WithCopy = false,
    };
};
 
//----------------------------------------------------------------------//
// inlines
//----------------------------------------------------------------------//
inline FMassEntityManager& FMassObserverManager::GetEntityManager()
{
    return EntityManager;
}
 
inline TSharedPtr<FMassObserverManager::FObserverLock> FMassObserverManager::GetObserverLock() const
{
    return ActiveObserverLock.Pin();
}
 
inline TSharedPtr<FMassObserverManager::FCreationContext> FMassObserverManager::GetCreationContext() const
{
    return ActiveCreationContext.Pin();
}