ActorManager.h

#pragma once
 
#include <Core/CoreDLL.h>
 
#include <Foundation/Communication/Event.h>
#include <Foundation/Configuration/Singleton.h>
#include <Foundation/Reflection/Reflection.h>
#include <Foundation/Types/UniquePtr.h>
 
struct plActorManagerImpl;
class plActor;
class plActorApiService;
 
struct plActorEvent
{
  enum class Type
  {
    AfterActorCreation,
    AfterActorActivation, 
    BeforeActorDestruction,
  };
 
  Type m_Type;
  plActor* m_pActor = nullptr;
};
 
class PL_CORE_DLL plActorManager final
{
  PL_DECLARE_SINGLETON(plActorManager);
 
public:
  plActorManager();
  ~plActorManager();
 
  static plCopyOnBroadcastEvent<const plActorEvent&> s_ActorEvents;
 
  void Update();
 
  void Shutdown();
 
  enum class DestructionMode
  {
    Immediate, 
    Queued     
  };
 
  void AddActor(plUniquePtr<plActor>&& pActor);
 
  void DestroyActor(plActor* pActor, DestructionMode mode = DestructionMode::Immediate);
 
  void DestroyAllActors(const void* pCreatedBy, DestructionMode mode = DestructionMode::Immediate);
 
  void GetAllActors(plHybridArray<plActor*, 8>& out_allActors);
 
  void DestroyQueuedActors();
 
  void AddApiService(plUniquePtr<plActorApiService>&& pService);
  void DestroyApiService(plActorApiService* pService, DestructionMode mode = DestructionMode::Immediate);
  void DestroyAllApiServices(DestructionMode mode = DestructionMode::Immediate);
  void DestroyQueuedActorApiServices();
 
  plActorApiService* GetApiService(const plRTTI* pType);
 
  template <typename Type>
  Type* GetApiService()
  {
    return static_cast<Type*>(GetApiService(plGetStaticRTTI<Type>()));
  }
 
private:
  void ActivateQueuedApiServices();
  void UpdateAllApiServices();
  void UpdateAllActors();
 
  // used during actor updates to force actor destruction to be queued until the actor updating is finished
  bool m_bForceQueueActorDestruction = false;
  plUniquePtr<plActorManagerImpl> m_pImpl;
};