ComponentManager.h

#pragma once
 
#include <Foundation/Containers/HybridArray.h>
#include <Foundation/Containers/IdTable.h>
#include <Foundation/Logging/Log.h>
#include <Foundation/Memory/BlockStorage.h>
#include <Foundation/Reflection/Reflection.h>
#include <Foundation/Types/Delegate.h>
 
#include <Core/World/Component.h>
#include <Core/World/Declarations.h>
#include <Core/World/WorldModule.h>
 
class PL_CORE_DLL plComponentManagerBase : public plWorldModule
{
  PL_ADD_DYNAMIC_REFLECTION(plComponentManagerBase, plWorldModule);
 
protected:
  plComponentManagerBase(plWorld* pWorld);
  virtual ~plComponentManagerBase();
 
public:
  bool IsValidComponent(const plComponentHandle& hComponent) const;
 
  bool TryGetComponent(const plComponentHandle& hComponent, plComponent*& out_pComponent);
 
  bool TryGetComponent(const plComponentHandle& hComponent, const plComponent*& out_pComponent) const;
 
  plUInt32 GetComponentCount() const;
 
  plComponentHandle CreateComponent(plGameObject* pOwnerObject);
 
  template <typename ComponentType>
  plComponentHandle CreateComponent(plGameObject* pOwnerObject, ComponentType*& out_pComponent);
 
  void DeleteComponent(const plComponentHandle& hComponent);
 
  void DeleteComponent(plComponent* pComponent);
 
  virtual void CollectAllComponents(plDynamicArray<plComponentHandle>& out_allComponents, bool bOnlyActive) = 0;
 
  virtual void CollectAllComponents(plDynamicArray<plComponent*>& out_allComponents, bool bOnlyActive) = 0;
 
protected:
  // internal methods
  friend class plWorld;
  friend class plInternal::WorldData;
 
  virtual void Deinitialize() override;
 
protected:
  friend class plWorldReader;
 
  plComponentHandle CreateComponentNoInit(plGameObject* pOwnerObject, plComponent*& out_pComponent);
  void InitializeComponent(plComponent* pComponent);
  void DeinitializeComponent(plComponent* pComponent);
  void PatchIdTable(plComponent* pComponent);
 
  virtual plComponent* CreateComponentStorage() = 0;
  virtual void DeleteComponentStorage(plComponent* pComponent, plComponent*& out_pMovedComponent) = 0;
 
 
  plIdTable<plComponentId, plComponent*> m_Components;
};
 
template <typename T, plBlockStorageType::Enum StorageType>
class plComponentManager : public plComponentManagerBase
{
public:
  using ComponentType = T;
  using SUPER = plComponentManagerBase;
 
  plComponentManager(plWorld* pWorld);
  virtual ~plComponentManager();
 
  bool TryGetComponent(const plComponentHandle& hComponent, ComponentType*& out_pComponent);
 
  bool TryGetComponent(const plComponentHandle& hComponent, const ComponentType*& out_pComponent) const;
 
  typename plBlockStorage<ComponentType, plInternal::DEFAULT_BLOCK_SIZE, StorageType>::Iterator GetComponents(plUInt32 uiStartIndex = 0);
 
  typename plBlockStorage<ComponentType, plInternal::DEFAULT_BLOCK_SIZE, StorageType>::ConstIterator GetComponents(plUInt32 uiStartIndex = 0) const;
 
  static plWorldModuleTypeId TypeId();
 
  virtual void CollectAllComponents(plDynamicArray<plComponentHandle>& out_allComponents, bool bOnlyActive) override;
  virtual void CollectAllComponents(plDynamicArray<plComponent*>& out_allComponents, bool bOnlyActive) override;
 
protected:
  friend ComponentType;
  friend class plComponentManagerFactory;
 
  virtual plComponent* CreateComponentStorage() override;
  virtual void DeleteComponentStorage(plComponent* pComponent, plComponent*& out_pMovedComponent) override;
 
  void RegisterUpdateFunction(UpdateFunctionDesc& desc);
 
  plBlockStorage<ComponentType, plInternal::DEFAULT_BLOCK_SIZE, StorageType> m_ComponentStorage;
};
 
 
 
struct plComponentUpdateType
{
  enum Enum
  {
    Always,
    WhenSimulating
  };
};
 
template <typename ComponentType, plComponentUpdateType::Enum UpdateType, plBlockStorageType::Enum StorageType = plBlockStorageType::FreeList>
class plComponentManagerSimple final : public plComponentManager<ComponentType, StorageType>
{
public:
  plComponentManagerSimple(plWorld* pWorld);
 
  virtual void Initialize() override;
 
  void SimpleUpdate(const plWorldModule::UpdateContext& context);
 
private:
  static void SimpleUpdateName(plStringBuilder& out_sName);
};
 
 
#define PL_ADD_COMPONENT_FUNCTIONALITY(componentType, baseType, managerType)                        \
public:                                                                                             \
  using ComponentManagerType = managerType;                                                         \
  virtual plWorldModuleTypeId GetTypeId() const override { return s_TypeId; }                       \
  static PL_ALWAYS_INLINE plWorldModuleTypeId TypeId() { return s_TypeId; }                         \
  virtual plComponentMode::Enum GetMode() const override;                                           \
  static plComponentHandle CreateComponent(plGameObject* pOwnerObject, componentType*& pComponent); \
  static void DeleteComponent(componentType* pComponent);                                           \
  void DeleteComponent();                                                                           \
                                                                                                    \
private:                                                                                            \
  friend managerType;                                                                               \
  static plWorldModuleTypeId s_TypeId
 
#define PL_ADD_ABSTRACT_COMPONENT_FUNCTIONALITY(componentType, baseType)                     \
public:                                                                                      \
  virtual plWorldModuleTypeId GetTypeId() const override { return plWorldModuleTypeId(-1); } \
  static PL_ALWAYS_INLINE plWorldModuleTypeId TypeId() { return plWorldModuleTypeId(-1); }
 
#define PL_DECLARE_COMPONENT_TYPE(componentType, baseType, managerType) \
  PL_ADD_DYNAMIC_REFLECTION(componentType, baseType);                   \
  PL_ADD_COMPONENT_FUNCTIONALITY(componentType, baseType, managerType);
 
#define PL_DECLARE_ABSTRACT_COMPONENT_TYPE(componentType, baseType) \
  PL_ADD_DYNAMIC_REFLECTION(componentType, baseType);               \
  PL_ADD_ABSTRACT_COMPONENT_FUNCTIONALITY(componentType, baseType);
 
 
#define PL_BEGIN_COMPONENT_TYPE(componentType, version, mode)                                                                                  \
  plWorldModuleTypeId componentType::s_TypeId =                                                                                                \
    plWorldModuleFactory::GetInstance()->RegisterWorldModule<typename componentType::ComponentManagerType, componentType>();                   \
  plComponentMode::Enum componentType::GetMode() const { return mode; }                                                                        \
  plComponentHandle componentType::CreateComponent(plGameObject* pOwnerObject, componentType*& out_pComponent)                                 \
  {                                                                                                                                            \
    return pOwnerObject->GetWorld()->GetOrCreateComponentManager<ComponentManagerType>()->CreateComponent(pOwnerObject, out_pComponent);       \
  }                                                                                                                                            \
  void componentType::DeleteComponent(componentType* pComponent) { pComponent->GetOwningManager()->DeleteComponent(pComponent->GetHandle()); } \
  void componentType::DeleteComponent() { GetOwningManager()->DeleteComponent(GetHandle()); }                                                  \
  PL_BEGIN_DYNAMIC_REFLECTED_TYPE(componentType, version, plRTTINoAllocator)
 
#define PL_BEGIN_ABSTRACT_COMPONENT_TYPE(componentType, version) PL_BEGIN_ABSTRACT_DYNAMIC_REFLECTED_TYPE(componentType, version)
 
#define PL_END_COMPONENT_TYPE PL_END_DYNAMIC_REFLECTED_TYPE
#define PL_END_ABSTRACT_COMPONENT_TYPE PL_END_ABSTRACT_DYNAMIC_REFLECTED_TYPE
 
#include <Core/World/Implementation/ComponentManager_inl.h>