Component.h

#pragma once
 
 
#include <Core/World/Declarations.h>
#include <Foundation/Reflection/Reflection.h>
 
class plMessage;
class plWorldWriter;
class plWorldReader;
 
// TODO: windows.h workaround
#ifdef SendMessage
#  undef SendMessage
#endif
 
class PL_CORE_DLL plComponent : public plReflectedClass
{
  PL_ADD_DYNAMIC_REFLECTION(plComponent, plReflectedClass);
 
protected:
  plComponent();
  virtual ~plComponent();
 
public:
  void SetActiveFlag(bool bEnabled);
 
  bool GetActiveFlag() const;
 
  bool IsActive() const;
 
  bool IsActiveAndInitialized() const;
 
  bool IsActiveAndSimulating() const;
 
  plComponentManagerBase* GetOwningManager();
 
  const plComponentManagerBase* GetOwningManager() const;
 
  plGameObject* GetOwner();
 
  const plGameObject* GetOwner() const;
 
  plWorld* GetWorld();
 
  const plWorld* GetWorld() const;
 
 
  plComponentHandle GetHandle() const;
 
  plUInt32 GetUniqueID() const;
 
  void SetUniqueID(plUInt32 uiUniqueID);
 
 
  virtual void SerializeComponent(plWorldWriter& inout_stream) const;
 
  virtual void DeserializeComponent(plWorldReader& inout_stream);
 
 
  void EnsureInitialized();
 
  void EnsureSimulationStarted();
 
 
  PL_ALWAYS_INLINE bool SendMessage(plMessage& ref_msg) { return SendMessageInternal(ref_msg, false); }
  PL_ALWAYS_INLINE bool SendMessage(plMessage& ref_msg) const { return SendMessageInternal(ref_msg, false); }
 
  void PostMessage(const plMessage& msg, plTime delay = plTime::MakeZero(), plObjectMsgQueueType::Enum queueType = plObjectMsgQueueType::NextFrame) const;
 
  virtual bool HandlesMessage(const plMessage& msg) const;
 
  void SetUserFlag(plUInt8 uiFlagIndex, bool bSet);
 
  bool GetUserFlag(plUInt8 uiFlagIndex) const;
 
  void SetCreatedByPrefab() { m_ComponentFlags.Add(plObjectFlags::CreatedByPrefab); }
 
  bool WasCreatedByPrefab() const { return m_ComponentFlags.IsSet(plObjectFlags::CreatedByPrefab); }
 
protected:
  friend class plWorld;
  friend class plGameObject;
  friend class plComponentManagerBase;
 
  bool IsDynamic() const;
 
  virtual plWorldModuleTypeId GetTypeId() const = 0;
  virtual plComponentMode::Enum GetMode() const = 0;
 
  virtual void Initialize();
 
  virtual void Deinitialize();
 
  virtual void OnActivated();
 
  virtual void OnDeactivated();
 
  virtual void OnSimulationStarted();
 
  void EnableUnhandledMessageHandler(bool enable);
 
  virtual bool OnUnhandledMessage(plMessage& msg, bool bWasPostedMsg);
 
  virtual bool OnUnhandledMessage(plMessage& msg, bool bWasPostedMsg) const;
 
protected:
  const plRTTI* m_pMessageDispatchType = nullptr;
 
  bool IsInitialized() const;
  bool IsInitializing() const;
  bool IsSimulationStarted() const;
 
private:
  // updates the component's active state depending on the owner object's active state
  void UpdateActiveState(bool bOwnerActive);
 
  plGameObject* Reflection_GetOwner() const;
  plWorld* Reflection_GetWorld() const;
  void Reflection_Update(plTime deltaTime);
 
  bool SendMessageInternal(plMessage& msg, bool bWasPostedMsg);
  bool SendMessageInternal(plMessage& msg, bool bWasPostedMsg) const;
 
  plComponentId m_InternalId;
  plBitflags<plObjectFlags> m_ComponentFlags = plObjectFlags::ActiveFlag;
  plUInt32 m_uiUniqueID = plInvalidIndex;
 
  plComponentManagerBase* m_pManager = nullptr;
  plGameObject* m_pOwner = nullptr;
 
  static plWorldModuleTypeId s_TypeId;
};
 
struct plComponent_ScriptBaseClassFunctions
{
  enum Enum
  {
    Initialize,
    Deinitialize,
    OnActivated,
    OnDeactivated,
    OnSimulationStarted,
    Update,
 
    Count
  };
};
 
#include <Core/World/Implementation/Component_inl.h>