GameObject.h

#pragma once
 
 
#include <Foundation/Containers/HybridArray.h>
#include <Foundation/Containers/SmallArray.h>
#include <Foundation/SimdMath/SimdConversion.h>
#include <Foundation/Time/Time.h>
#include <Foundation/Types/TagSet.h>
 
#include <Core/World/ComponentManager.h>
#include <Core/World/GameObjectDesc.h>
 
// Avoid conflicts with windows.h
#ifdef SendMessage
#  undef SendMessage
#endif
 
enum class plVisibilityState : plUInt8;
 
class PL_CORE_DLL plGameObject final
{
private:
  enum
  {
#if PL_ENABLED(PL_PLATFORM_32BIT)
    NUM_INPLACE_COMPONENTS = 12
#else
    NUM_INPLACE_COMPONENTS = 6
#endif
  };
 
  friend class plWorld;
  friend class plInternal::WorldData;
  friend class plMemoryUtils;
 
  plGameObject();
  plGameObject(const plGameObject& other);
  ~plGameObject();
 
  void operator=(const plGameObject& other);
 
public:
  class PL_CORE_DLL ConstChildIterator
  {
  public:
    const plGameObject& operator*() const;
    const plGameObject* operator->() const;
 
    operator const plGameObject*() const;
 
    void Next();
 
    bool IsValid() const;
 
    void operator++();
 
  private:
    friend class plGameObject;
 
    ConstChildIterator(plGameObject* pObject, const plWorld* pWorld);
 
    plGameObject* m_pObject = nullptr;
    const plWorld* m_pWorld = nullptr;
  };
 
  class PL_CORE_DLL ChildIterator : public ConstChildIterator
  {
  public:
    plGameObject& operator*();
    plGameObject* operator->();
 
    operator plGameObject*();
 
  private:
    friend class plGameObject;
 
    ChildIterator(plGameObject* pObject, const plWorld* pWorld);
  };
 
  plGameObjectHandle GetHandle() const;
 
  void MakeDynamic();
 
  void MakeStatic();
 
  bool IsDynamic() const;
 
  bool IsStatic() const;
 
  void SetActiveFlag(bool bEnabled);
 
  bool GetActiveFlag() const;
 
  bool IsActive() const;
 
  void SetCreatedByPrefab() { m_Flags.Add(plObjectFlags::CreatedByPrefab); }
 
  bool WasCreatedByPrefab() const { return m_Flags.IsSet(plObjectFlags::CreatedByPrefab); }
 
  void SetName(plStringView sName);
  void SetName(const plHashedString& sName);
  plStringView GetName() const;
  bool HasName(const plTempHashedString& sName) const;
 
  void SetGlobalKey(plStringView sGlobalKey);
  void SetGlobalKey(const plHashedString& sGlobalKey);
  plStringView GetGlobalKey() const;
 
  void EnableChildChangesNotifications();
  void DisableChildChangesNotifications();
 
  void EnableParentChangesNotifications();
  void DisableParentChangesNotifications();
 
  enum class TransformPreservation
  {
    PreserveLocal,
    PreserveGlobal
  };
 
  void SetParent(const plGameObjectHandle& hParent, plGameObject::TransformPreservation preserve = TransformPreservation::PreserveGlobal);
 
  plGameObject* GetParent();
 
  const plGameObject* GetParent() const;
 
  void AddChild(const plGameObjectHandle& hChild, plGameObject::TransformPreservation preserve = TransformPreservation::PreserveGlobal);
 
  void AddChildren(const plArrayPtr<const plGameObjectHandle>& children, plGameObject::TransformPreservation preserve = TransformPreservation::PreserveGlobal);
 
  void DetachChild(const plGameObjectHandle& hChild, plGameObject::TransformPreservation preserve = TransformPreservation::PreserveGlobal);
 
  void DetachChildren(const plArrayPtr<const plGameObjectHandle>& children, plGameObject::TransformPreservation preserve = TransformPreservation::PreserveGlobal);
 
  plUInt32 GetChildCount() const;
 
  ChildIterator GetChildren();
 
  ConstChildIterator GetChildren() const;
 
  plGameObject* FindChildByName(const plTempHashedString& sName, bool bRecursive = true);
 
  plGameObject* FindChildByPath(plStringView sPath);
 
  plGameObject* SearchForChildByNameSequence(plStringView sObjectSequence, const plRTTI* pExpectedComponent = nullptr);
 
  void SearchForChildrenByNameSequence(plStringView sObjectSequence, const plRTTI* pExpectedComponent, plHybridArray<plGameObject*, 8>& out_objects);
 
  plWorld* GetWorld();
  const plWorld* GetWorld() const;
 
 
  enum class UpdateBehaviorIfStatic
  {
    None,              
    UpdateImmediately, 
  };
 
  void SetLocalPosition(plVec3 vPosition);
  plVec3 GetLocalPosition() const;
 
  void SetLocalRotation(plQuat qRotation);
  plQuat GetLocalRotation() const;
 
  void SetLocalScaling(plVec3 vScaling);
  plVec3 GetLocalScaling() const;
 
  void SetLocalUniformScaling(float fScaling);
  float GetLocalUniformScaling() const;
 
  plTransform GetLocalTransform() const;
 
  void SetGlobalPosition(const plVec3& vPosition);
  plVec3 GetGlobalPosition() const;
 
  void SetGlobalRotation(const plQuat& qRotation);
  plQuat GetGlobalRotation() const;
 
  void SetGlobalScaling(const plVec3& vScaling);
  plVec3 GetGlobalScaling() const;
 
  void SetGlobalTransform(const plTransform& transform);
  plTransform GetGlobalTransform() const;
 
  plTransform GetLastGlobalTransform() const;
 
  // Simd variants of above methods
  void SetLocalPosition(const plSimdVec4f& vPosition, UpdateBehaviorIfStatic updateBehavior = UpdateBehaviorIfStatic::UpdateImmediately);
  const plSimdVec4f& GetLocalPositionSimd() const;
 
  void SetLocalRotation(const plSimdQuat& qRotation, UpdateBehaviorIfStatic updateBehavior = UpdateBehaviorIfStatic::UpdateImmediately);
  const plSimdQuat& GetLocalRotationSimd() const;
 
  void SetLocalScaling(const plSimdVec4f& vScaling, UpdateBehaviorIfStatic updateBehavior = UpdateBehaviorIfStatic::UpdateImmediately);
  const plSimdVec4f& GetLocalScalingSimd() const;
 
  void SetLocalUniformScaling(const plSimdFloat& fScaling, UpdateBehaviorIfStatic updateBehavior = UpdateBehaviorIfStatic::UpdateImmediately);
  plSimdFloat GetLocalUniformScalingSimd() const;
 
  plSimdTransform GetLocalTransformSimd() const;
 
  void SetGlobalPosition(const plSimdVec4f& vPosition);
  const plSimdVec4f& GetGlobalPositionSimd() const;
 
  void SetGlobalRotation(const plSimdQuat& qRotation);
  const plSimdQuat& GetGlobalRotationSimd() const;
 
  void SetGlobalScaling(const plSimdVec4f& vScaling);
  const plSimdVec4f& GetGlobalScalingSimd() const;
 
  void SetGlobalTransform(const plSimdTransform& transform);
  const plSimdTransform& GetGlobalTransformSimd() const;
 
  const plSimdTransform& GetLastGlobalTransformSimd() const;
 
  plVec3 GetGlobalDirForwards() const;
  plVec3 GetGlobalDirRight() const;
  plVec3 GetGlobalDirUp() const;
 
#if PL_ENABLED(PL_GAMEOBJECT_VELOCITY)
  void SetLastGlobalTransform(const plSimdTransform& transform);
 
  plVec3 GetLinearVelocity() const;
 
  plVec3 GetAngularVelocity() const;
#endif
 
  void UpdateGlobalTransform();
 
  void EnableStaticTransformChangesNotifications();
  void DisableStaticTransformChangesNotifications();
 
 
  plBoundingBoxSphere GetLocalBounds() const;
  plBoundingBoxSphere GetGlobalBounds() const;
 
  const plSimdBBoxSphere& GetLocalBoundsSimd() const;
  const plSimdBBoxSphere& GetGlobalBoundsSimd() const;
 
  void UpdateLocalBounds();
 
  void UpdateGlobalBounds();
 
  void UpdateGlobalTransformAndBounds();
 
 
  plSpatialDataHandle GetSpatialData() const;
 
  void EnableComponentChangesNotifications();
  void DisableComponentChangesNotifications();
 
  template <typename T>
  bool TryGetComponentOfBaseType(T*& out_pComponent);
 
  template <typename T>
  bool TryGetComponentOfBaseType(const T*& out_pComponent) const;
 
  bool TryGetComponentOfBaseType(const plRTTI* pType, plComponent*& out_pComponent);
 
  bool TryGetComponentOfBaseType(const plRTTI* pType, const plComponent*& out_pComponent) const;
 
  template <typename T>
  void TryGetComponentsOfBaseType(plDynamicArray<T*>& out_components);
 
  template <typename T>
  void TryGetComponentsOfBaseType(plDynamicArray<const T*>& out_components) const;
 
  void TryGetComponentsOfBaseType(const plRTTI* pType, plDynamicArray<plComponent*>& out_components);
 
  void TryGetComponentsOfBaseType(const plRTTI* pType, plDynamicArray<const plComponent*>& out_components) const;
 
  plArrayPtr<plComponent* const> GetComponents();
 
  plArrayPtr<const plComponent* const> GetComponents() const;
 
  plUInt16 GetComponentVersion() const;
 
 
  bool SendMessage(plMessage& ref_msg);
 
  bool SendMessage(plMessage& ref_msg) const;
 
  bool SendMessageRecursive(plMessage& ref_msg);
 
  bool SendMessageRecursive(plMessage& ref_msg) const;
 
 
  void PostMessage(const plMessage& msg, plTime delay, plObjectMsgQueueType::Enum queueType = plObjectMsgQueueType::NextFrame) const;
 
  void PostMessageRecursive(const plMessage& msg, plTime delay, plObjectMsgQueueType::Enum queueType = plObjectMsgQueueType::NextFrame) const;
 
  bool SendEventMessage(plMessage& ref_msg, const plComponent* pSenderComponent);
 
  bool SendEventMessage(plMessage& ref_msg, const plComponent* pSenderComponent) const;
 
  void PostEventMessage(plMessage& ref_msg, const plComponent* pSenderComponent, plTime delay, plObjectMsgQueueType::Enum queueType = plObjectMsgQueueType::NextFrame) const;
 
 
  const plTagSet& GetTags() const;
 
  void SetTags(const plTagSet& tags);
 
  void SetTag(const plTag& tag);
 
  void RemoveTag(const plTag& tag);
 
  const plUInt16& GetTeamID() const { return m_uiTeamID; }
 
  void SetTeamID(plUInt16 uiId);
 
  plUInt32 GetStableRandomSeed() const;
 
  void SetStableRandomSeed(plUInt32 uiSeed);
 
  plVisibilityState GetVisibilityState(plUInt32 uiNumFramesBeforeInvisible = 5) const;
 
private:
  friend class plComponentManagerBase;
  friend class plGameObjectTest;
 
  // only needed until reflection can deal with plStringView
  void SetNameInternal(const char* szName);
  const char* GetNameInternal() const;
  void SetGlobalKeyInternal(const char* szKey);
  const char* GetGlobalKeyInternal() const;
 
  bool SendMessageInternal(plMessage& msg, bool bWasPostedMsg);
  bool SendMessageInternal(plMessage& msg, bool bWasPostedMsg) const;
  bool SendMessageRecursiveInternal(plMessage& msg, bool bWasPostedMsg);
  bool SendMessageRecursiveInternal(plMessage& msg, bool bWasPostedMsg) const;
 
  PL_ALLOW_PRIVATE_PROPERTIES(plGameObject);
 
  // Add / Detach child used by the reflected property keep their local transform as
  // updating that is handled by the editor.
  void Reflection_AddChild(plGameObject* pChild);
  void Reflection_DetachChild(plGameObject* pChild);
  plHybridArray<plGameObject*, 8> Reflection_GetChildren() const;
  void Reflection_AddComponent(plComponent* pComponent);
  void Reflection_RemoveComponent(plComponent* pComponent);
  plHybridArray<plComponent*, NUM_INPLACE_COMPONENTS> Reflection_GetComponents() const;
 
  plObjectMode::Enum Reflection_GetMode() const;
  void Reflection_SetMode(plObjectMode::Enum mode);
 
  plGameObject* Reflection_GetParent() const;
  void Reflection_SetGlobalPosition(const plVec3& vPosition);
  void Reflection_SetGlobalRotation(const plQuat& qRotation);
  void Reflection_SetGlobalScaling(const plVec3& vScaling);
  void Reflection_SetGlobalTransform(const plTransform& transform);
 
  bool DetermineDynamicMode(plComponent* pComponentToIgnore = nullptr) const;
  void ConditionalMakeStatic(plComponent* pComponentToIgnore = nullptr);
  void MakeStaticInternal();
 
  void UpdateGlobalTransformAndBoundsRecursive();
  void UpdateLastGlobalTransform();
 
  void OnMsgDeleteGameObject(plMsgDeleteGameObject& msg);
 
  void AddComponent(plComponent* pComponent);
  void RemoveComponent(plComponent* pComponent);
  void FixComponentPointer(plComponent* pOldPtr, plComponent* pNewPtr);
 
  // Updates the active state of this object and all children and attached components recursively, depending on the enabled states.
  void UpdateActiveState(bool bParentActive);
 
  void SendNotificationMessage(plMessage& msg);
 
  struct PL_CORE_DLL alignas(16) TransformationData
  {
    PL_DECLARE_POD_TYPE();
 
    plGameObject* m_pObject;
    TransformationData* m_pParentData;
 
#if PL_ENABLED(PL_PLATFORM_32BIT)
    plUInt64 m_uiPadding;
#endif
 
    plSimdVec4f m_localPosition;
    plSimdQuat m_localRotation;
    plSimdVec4f m_localScaling; // x,y,z = non-uniform scaling, w = uniform scaling
 
    plSimdTransform m_globalTransform;
 
#if PL_ENABLED(PL_GAMEOBJECT_VELOCITY)
    plSimdTransform m_lastGlobalTransform;
#endif
 
    plSimdBBoxSphere m_localBounds; // m_BoxHalfExtents.w != 0 indicates that the object should be always visible
    plSimdBBoxSphere m_globalBounds;
 
    plSpatialDataHandle m_hSpatialData;
    plUInt32 m_uiSpatialDataCategoryBitmask;
 
    plUInt32 m_uiStableRandomSeed = 0;
 
#if PL_ENABLED(PL_GAMEOBJECT_VELOCITY)
    plUInt32 m_uiLastGlobalTransformUpdateCounter = 0;
#else
    plUInt32 m_uiPadding2[1];
#endif
 
    void UpdateLocalTransform();
 
    void UpdateGlobalTransformRecursive(plUInt32 uiUpdateCounter);
 
    void UpdateGlobalTransformNonRecursive(plUInt32 uiUpdateCounter);
 
    void UpdateGlobalTransformWithoutParent(plUInt32 uiUpdateCounter);
 
    void UpdateGlobalTransformWithParent(plUInt32 uiUpdateCounter);
 
    void UpdateGlobalBounds(plSpatialSystem* pSpatialSystem);
    void UpdateGlobalBounds();
    void UpdateGlobalBoundsAndSpatialData(plSpatialSystem& ref_spatialSystem);
 
    void UpdateLastGlobalTransform(plUInt32 uiUpdateCounter);
 
    void RecreateSpatialData(plSpatialSystem& ref_spatialSystem);
  };
 
  plGameObjectId m_InternalId;
  plHashedString m_sName;
 
#if PL_ENABLED(PL_PLATFORM_32BIT)
  plUInt32 m_uiNamePadding;
#endif
 
  plBitflags<plObjectFlags> m_Flags;
 
  plUInt32 m_uiParentIndex = 0;
  plUInt32 m_uiFirstChildIndex = 0;
  plUInt32 m_uiLastChildIndex = 0;
 
  plUInt32 m_uiNextSiblingIndex = 0;
  plUInt32 m_uiPrevSiblingIndex = 0;
  plUInt32 m_uiChildCount = 0;
 
  plUInt16 m_uiHierarchyLevel = 0;
 
  plUInt16 m_uiTeamID = 0;
 
  TransformationData* m_pTransformationData = nullptr;
 
#if PL_ENABLED(PL_PLATFORM_32BIT)
  plUInt32 m_uiPadding = 0;
#endif
 
  plSmallArrayBase<plComponent*, NUM_INPLACE_COMPONENTS> m_Components;
 
  struct ComponentUserData
  {
    plUInt16 m_uiVersion;
    plUInt16 m_uiUnused;
  };
 
  plTagSet m_Tags;
};
 
PL_DECLARE_REFLECTABLE_TYPE(PL_CORE_DLL, plGameObject);
 
#include <Core/World/Implementation/GameObject_inl.h>