WorldModule.h

#pragma once
 
#include <Core/World/Declarations.h>
#include <Foundation/Configuration/Startup.h>
#include <Foundation/Strings/HashedString.h>
 
class plWorld;
 
class PL_CORE_DLL plWorldModule : public plReflectedClass
{
  PL_ADD_DYNAMIC_REFLECTION(plWorldModule, plReflectedClass);
 
protected:
  plWorldModule(plWorld* pWorld);
  virtual ~plWorldModule();
 
public:
  plWorld* GetWorld();
 
  const plWorld* GetWorld() const;
 
  plUInt32 GetWorldIndex() const;
 
protected:
  friend class plWorld;
  friend class plInternal::WorldData;
  friend class plMemoryUtils;
 
  struct UpdateContext
  {
    plUInt32 m_uiFirstComponentIndex = 0;
    plUInt32 m_uiComponentCount = 0;
  };
 
  using UpdateFunction = plDelegate<void(const UpdateContext&)>;
 
  struct UpdateFunctionDesc
  {
    struct Phase
    {
      using StorageType = plUInt8;
 
      enum Enum
      {
        PreAsync,
        Async,
        PostAsync,
        PostTransform,
        COUNT,
 
        Default = PreAsync
      };
    };
 
    UpdateFunctionDesc(const UpdateFunction& function, plStringView sFunctionName)
      : m_Function(function)
    {
      m_sFunctionName.Assign(sFunctionName);
    }
 
    UpdateFunction m_Function;                    
    plHashedString m_sFunctionName;               
    plHybridArray<plHashedString, 4> m_DependsOn; 
    plEnum<Phase> m_Phase;                        
    bool m_bOnlyUpdateWhenSimulating = false;     
    plUInt16 m_uiGranularity = 0;                 
    float m_fPriority = 0.0f;                     
  };
 
  void RegisterUpdateFunction(const UpdateFunctionDesc& desc);
 
  void DeregisterUpdateFunction(const UpdateFunctionDesc& desc);
 
  plAllocator* GetAllocator();
 
  plInternal::WorldLargeBlockAllocator* GetBlockAllocator();
 
  bool GetWorldSimulationEnabled() const;
 
protected:
  virtual void Initialize() {}
 
  virtual void Deinitialize() {}
 
  virtual void OnSimulationStarted() {}
 
  virtual void WorldClear() {}
 
  plWorld* m_pWorld;
};
 
 
class PL_CORE_DLL plWorldModuleFactory
{
public:
  static plWorldModuleFactory* GetInstance();
 
  template <typename ModuleType, typename RTTIType>
  plWorldModuleTypeId RegisterWorldModule();
 
  plWorldModuleTypeId GetTypeId(const plRTTI* pRtti);
 
  plWorldModule* CreateWorldModule(plUInt16 uiTypeId, plWorld* pWorld);
 
  void RegisterInterfaceImplementation(plStringView sInterfaceName, plStringView sImplementationName);
 
private:
  PL_MAKE_SUBSYSTEM_STARTUP_FRIEND(Core, WorldModuleFactory);
 
  using CreatorFunc = plWorldModule* (*)(plAllocator*, plWorld*);
 
  plWorldModuleFactory();
  plWorldModuleTypeId RegisterWorldModule(const plRTTI* pRtti, CreatorFunc creatorFunc);
 
  static void PluginEventHandler(const plPluginEvent& EventData);
  void FillBaseTypeIds();
  void ClearUnloadedTypeToIDs();
  void AdjustBaseTypeId(const plRTTI* pParentRtti, const plRTTI* pRtti, plUInt16 uiParentTypeId);
 
  plHashTable<const plRTTI*, plWorldModuleTypeId> m_TypeToId;
 
  struct CreatorFuncContext
  {
    PL_DECLARE_POD_TYPE();
 
    CreatorFunc m_Func;
    const plRTTI* m_pRtti;
  };
 
  plDynamicArray<CreatorFuncContext> m_CreatorFuncs;
 
  plHashTable<plString, plString> m_InterfaceImplementations;
};
 
#define PL_DECLARE_WORLD_MODULE()                                           \
public:                                                                     \
  static PL_ALWAYS_INLINE plWorldModuleTypeId TypeId() { return s_TypeId; } \
                                                                            \
private:                                                                    \
  static plWorldModuleTypeId s_TypeId;
 
#define PL_IMPLEMENT_WORLD_MODULE(moduleType) \
  plWorldModuleTypeId moduleType::s_TypeId = plWorldModuleFactory::GetInstance()->RegisterWorldModule<moduleType, moduleType>();
 
#define PL_CREATE_MODULE_UPDATE_FUNCTION_DESC(func, instance) plWorldModule::UpdateFunctionDesc(plWorldModule::UpdateFunction(&func, instance), #func)
 
#include <Core/World/Implementation/WorldModule_inl.h>