World.h

#pragma once
 
#include <Core/World/Implementation/WorldData.h>
 
struct plEventMessage;
class plEventMessageHandlerComponent;
 
class PL_CORE_DLL plWorld final
{
public:
  plWorld(plWorldDesc& ref_desc);
  ~plWorld();
 
  void Clear();
 
  plStringView GetName() const;
 
  plUInt32 GetIndex() const;
 
 
  plGameObjectHandle CreateObject(const plGameObjectDesc& desc);
 
  plGameObjectHandle CreateObject(const plGameObjectDesc& desc, plGameObject*& out_pObject);
 
  void DeleteObjectNow(const plGameObjectHandle& hObject, bool bAlsoDeleteEmptyParents = true);
 
  void DeleteObjectDelayed(const plGameObjectHandle& hObject, bool bAlsoDeleteEmptyParents = true);
 
  const plEvent<const plGameObject*>& GetObjectDeletionEvent() const;
 
  bool IsValidObject(const plGameObjectHandle& hObject) const;
 
  [[nodiscard]] bool TryGetObject(const plGameObjectHandle& hObject, plGameObject*& out_pObject);
 
  [[nodiscard]] bool TryGetObject(const plGameObjectHandle& hObject, const plGameObject*& out_pObject) const;
 
  [[nodiscard]] bool TryGetObjectWithGlobalKey(const plTempHashedString& sGlobalKey, plGameObject*& out_pObject);
 
  [[nodiscard]] bool TryGetObjectWithGlobalKey(const plTempHashedString& sGlobalKey, const plGameObject*& out_pObject) const;
 
 
  plUInt32 GetObjectCount() const;
 
  plInternal::WorldData::ObjectIterator GetObjects();
 
  plInternal::WorldData::ConstObjectIterator GetObjects() const;
 
  using VisitorFunc = plInternal::WorldData::VisitorFunc;
 
  enum TraversalMethod
  {
    BreadthFirst,
    DepthFirst
  };
 
  void Traverse(VisitorFunc visitorFunc, TraversalMethod method = DepthFirst);
 
 
  template <typename ModuleType>
  ModuleType* GetOrCreateModule();
 
  plWorldModule* GetOrCreateModule(const plRTTI* pRtti);
 
  template <typename ModuleType>
  void DeleteModule();
 
  void DeleteModule(const plRTTI* pRtti);
 
  template <typename ModuleType>
  ModuleType* GetModule();
 
  template <typename ModuleType>
  const ModuleType* GetModule() const;
 
  template <typename ModuleType>
  const ModuleType* GetModuleReadOnly() const;
 
  plWorldModule* GetModule(const plRTTI* pRtti);
 
  const plWorldModule* GetModule(const plRTTI* pRtti) const;
 
 
  template <typename ManagerType>
  ManagerType* GetOrCreateComponentManager();
 
  plComponentManagerBase* GetOrCreateManagerForComponentType(const plRTTI* pComponentRtti);
 
  template <typename ManagerType>
  void DeleteComponentManager();
 
  template <typename ManagerType>
  ManagerType* GetComponentManager();
 
  template <typename ManagerType>
  const ManagerType* GetComponentManager() const;
 
  plComponentManagerBase* GetManagerForComponentType(const plRTTI* pComponentRtti);
 
  const plComponentManagerBase* GetManagerForComponentType(const plRTTI* pComponentRtti) const;
 
  bool IsValidComponent(const plComponentHandle& hComponent) const;
 
  template <typename ComponentType>
  [[nodiscard]] bool TryGetComponent(const plComponentHandle& hComponent, ComponentType*& out_pComponent);
 
  template <typename ComponentType>
  [[nodiscard]] bool TryGetComponent(const plComponentHandle& hComponent, const ComponentType*& out_pComponent) const;
 
  plComponentInitBatchHandle CreateComponentInitBatch(plStringView sBatchName, bool bMustFinishWithinOneFrame = true);
 
  void DeleteComponentInitBatch(const plComponentInitBatchHandle& hBatch);
 
  void BeginAddingComponentsToInitBatch(const plComponentInitBatchHandle& hBatch);
 
  void EndAddingComponentsToInitBatch(const plComponentInitBatchHandle& hBatch);
 
  void SubmitComponentInitBatch(const plComponentInitBatchHandle& hBatch);
 
  bool IsComponentInitBatchCompleted(const plComponentInitBatchHandle& hBatch, double* pCompletionFactor = nullptr);
 
  void CancelComponentInitBatch(const plComponentInitBatchHandle& hBatch);
 
 
  void SendMessage(const plGameObjectHandle& hReceiverObject, plMessage& ref_msg);
 
  void SendMessageRecursive(const plGameObjectHandle& hReceiverObject, plMessage& ref_msg);
 
  void PostMessage(const plGameObjectHandle& hReceiverObject, const plMessage& msg, plTime delay,
    plObjectMsgQueueType::Enum queueType = plObjectMsgQueueType::NextFrame) const;
 
  void PostMessageRecursive(const plGameObjectHandle& hReceiverObject, const plMessage& msg, plTime delay,
    plObjectMsgQueueType::Enum queueType = plObjectMsgQueueType::NextFrame) const;
 
  void SendMessage(const plComponentHandle& hReceiverComponent, plMessage& ref_msg);
 
  void PostMessage(const plComponentHandle& hReceiverComponent, const plMessage& msg, plTime delay,
    plObjectMsgQueueType::Enum queueType = plObjectMsgQueueType::NextFrame) const;
 
  void FindEventMsgHandlers(const plMessage& msg, plGameObject* pSearchObject, plDynamicArray<plComponent*>& out_components);
 
  void FindEventMsgHandlers(const plMessage& msg, const plGameObject* pSearchObject, plDynamicArray<const plComponent*>& out_components) const;
 
 
  void SetWorldSimulationEnabled(bool bEnable);
 
  bool GetWorldSimulationEnabled() const;
 
  void Update();
 
  const plSharedPtr<plTask>& GetUpdateTask();
 
  plUInt32 GetUpdateCounter() const;
 
  plSpatialSystem* GetSpatialSystem();
 
  const plSpatialSystem* GetSpatialSystem() const;
 
 
  void GetCoordinateSystem(const plVec3& vGlobalPosition, plCoordinateSystem& out_coordinateSystem) const;
 
  void SetCoordinateSystemProvider(const plSharedPtr<plCoordinateSystemProvider>& pProvider);
 
  plCoordinateSystemProvider& GetCoordinateSystemProvider();
 
  const plCoordinateSystemProvider& GetCoordinateSystemProvider() const;
 
 
  plClock& GetClock();
 
  const plClock& GetClock() const;
 
  plRandom& GetRandomNumberGenerator();
 
 
  plAllocator* GetAllocator();
 
  plInternal::WorldLargeBlockAllocator* GetBlockAllocator();
 
  plDoubleBufferedLinearAllocator* GetStackAllocator();
 
  plInternal::WorldData::ReadMarker& GetReadMarker() const;
 
  plInternal::WorldData::WriteMarker& GetWriteMarker();
 
  void SetMaxInitializationTimePerFrame(plTime maxInitTime);
 
  void SetUserData(void* pUserData);
 
  void* GetUserData() const;
 
  using ReferenceResolver = plDelegate<plGameObjectHandle(const void*, plComponentHandle hThis, plStringView sProperty)>;
 
  void SetGameObjectReferenceResolver(const ReferenceResolver& resolver);
 
  const ReferenceResolver& GetGameObjectReferenceResolver() const;
 
  using ResourceReloadContext = plInternal::WorldData::ResourceReloadContext;
  using ResourceReloadFunc = plInternal::WorldData::ResourceReloadFunc;
 
  void AddResourceReloadFunction(plTypelessResourceHandle hResource, plComponentHandle hComponent, void* pUserData, ResourceReloadFunc function);
  void RemoveResourceReloadFunction(plTypelessResourceHandle hResource, plComponentHandle hComponent, void* pUserData);
 
  static constexpr plUInt64 GetMaxNumGameObjects();
  static constexpr plUInt64 GetMaxNumHierarchyLevels();
  static constexpr plUInt64 GetMaxNumComponentsPerType();
  static constexpr plUInt64 GetMaxNumWorldModules();
  static constexpr plUInt64 GetMaxNumComponentTypes();
  static constexpr plUInt64 GetMaxNumWorlds();
 
public:
  static plUInt32 GetWorldCount();
 
  static plWorld* GetWorld(plUInt32 uiIndex);
 
  static plWorld* GetWorld(const plGameObjectHandle& hObject);
 
  static plWorld* GetWorld(const plComponentHandle& hComponent);
 
private:
  friend class plGameObject;
  friend class plWorldModule;
  friend class plComponentManagerBase;
  friend class plComponent;
  PL_ALLOW_PRIVATE_PROPERTIES(plWorld);
 
  plGameObject* Reflection_TryGetObjectWithGlobalKey(plTempHashedString sGlobalKey);
  plClock* Reflection_GetClock();
 
  void CheckForReadAccess() const;
  void CheckForWriteAccess() const;
 
  plGameObject* GetObjectUnchecked(plUInt32 uiIndex) const;
 
  void SetParent(plGameObject* pObject, plGameObject* pNewParent,
    plGameObject::TransformPreservation preserve = plGameObject::TransformPreservation::PreserveGlobal);
  void LinkToParent(plGameObject* pObject);
  void UnlinkFromParent(plGameObject* pObject);
 
  void SetObjectGlobalKey(plGameObject* pObject, const plHashedString& sGlobalKey);
  plStringView GetObjectGlobalKey(const plGameObject* pObject) const;
 
  void PostMessage(const plGameObjectHandle& receiverObject, const plMessage& msg, plObjectMsgQueueType::Enum queueType, plTime delay, bool bRecursive) const;
  void ProcessQueuedMessage(const plInternal::WorldData::MessageQueue::Entry& entry);
  void ProcessQueuedMessages(plObjectMsgQueueType::Enum queueType);
 
  template <typename World, typename GameObject, typename Component>
  static void FindEventMsgHandlers(World& world, const plMessage& msg, GameObject pSearchObject, plDynamicArray<Component>& out_components);
 
  void RegisterUpdateFunction(const plWorldModule::UpdateFunctionDesc& desc);
  void DeregisterUpdateFunction(const plWorldModule::UpdateFunctionDesc& desc);
  void DeregisterUpdateFunctions(plWorldModule* pModule);
 
  void AddComponentToInitialize(plComponentHandle hComponent);
 
  void UpdateFromThread();
  void UpdateSynchronous(const plArrayPtr<plInternal::WorldData::RegisteredUpdateFunction>& updateFunctions);
  void UpdateAsynchronous();
 
  // returns if the batch was completely initialized
  bool ProcessInitializationBatch(plInternal::WorldData::InitBatch& batch, plTime endTime);
  void ProcessComponentsToInitialize();
  void ProcessUpdateFunctionsToRegister();
  plResult RegisterUpdateFunctionInternal(const plWorldModule::UpdateFunctionDesc& desc);
 
  void DeleteDeadObjects();
  void DeleteDeadComponents();
 
  void PatchHierarchyData(plGameObject* pObject, plGameObject::TransformPreservation preserve);
  void RecreateHierarchyData(plGameObject* pObject, bool bWasDynamic);
 
  void ProcessResourceReloadFunctions();
 
  bool ReportErrorWhenStaticObjectMoves() const;
 
  float GetInvDeltaSeconds() const;
 
  plSharedPtr<plTask> m_pUpdateTask;
 
  plInternal::WorldData m_Data;
 
  using QueuedMsgMetaData = plInternal::WorldData::QueuedMsgMetaData;
 
  plUInt32 m_uiIndex;
  static plStaticArray<plWorld*, PL_MAX_WORLDS> s_Worlds;
};
 
PL_DECLARE_REFLECTABLE_TYPE(PL_CORE_DLL, plWorld);
 
#include <Core/World/Implementation/World_inl.h>