GameObjectDocument.h

#pragma once
#include <EditorFramework/Assets/AssetDocument.h>
#include <EditorFramework/DocumentWindow/EngineDocumentWindow.moc.h>
#include <EditorFramework/EditorFrameworkDLL.h>
#include <Foundation/SimdMath/SimdTransform.h>
#include <ToolsFoundation/Document/Document.h>
#include <ToolsFoundation/Object/DocumentObjectManager.h>
#include <ToolsFoundation/Object/ObjectMetaData.h>
#include <ToolsFoundation/Project/ToolsProject.h>
 
class plAssetFileHeader;
class plGameObjectEditTool;
class plGameObjectDocument;
 
struct PL_EDITORFRAMEWORK_DLL TransformationChanges
{
  enum Enum
  {
    Translation = PL_BIT(0),
    Rotation = PL_BIT(1),
    Scale = PL_BIT(2),
    UniformScale = PL_BIT(3),
    All = 0xFF
  };
};
 
struct PL_EDITORFRAMEWORK_DLL plGameObjectEvent
{
  enum class Type
  {
    RenderSelectionOverlayChanged,
    RenderVisualizersChanged,
    RenderShapeIconsChanged,
    AddAmbientLightChanged,
    SimulationSpeedChanged,
    PickTransparentChanged,
 
    ActiveEditToolChanged,
 
    TriggerShowSelectionInScenegraph,
    TriggerFocusOnSelection_Hovered,
    TriggerFocusOnSelection_All,
 
    TriggerSnapSelectionPivotToGrid,
    TriggerSnapEachSelectedObjectToGrid,
 
    GameModeChanged,
 
    GizmoTransformMayBeInvalid, 
  };
 
  Type m_Type;
};
 
struct plGameObjectDocumentEvent
{
  enum class Type
  {
    GameMode_Stopped,
    GameMode_StartingSimulate,
    GameMode_StartingPlay,
    GameMode_StartingExternal, 
  };
 
  Type m_Type;
  plGameObjectDocument* m_pDocument = nullptr;
};
 
class PL_EDITORFRAMEWORK_DLL plGameObjectMetaData : public plReflectedClass
{
  PL_ADD_DYNAMIC_REFLECTION(plGameObjectMetaData, plReflectedClass);
 
public:
  enum ModifiedFlags
  {
    CachedName = PL_BIT(2),
    AllFlags = 0xFFFFFFFF
  };
 
  plGameObjectMetaData() = default;
 
  plString m_CachedNodeName;
  QIcon m_Icon;
};
 
struct PL_EDITORFRAMEWORK_DLL plSelectedGameObject
{
  const plDocumentObject* m_pObject;
  plVec3 m_vLocalScaling;
  float m_fLocalUniformScaling;
  plTransform m_GlobalTransform;
};
 
class PL_EDITORFRAMEWORK_DLL plGameObjectDocument : public plAssetDocument
{
  PL_ADD_DYNAMIC_REFLECTION(plGameObjectDocument, plAssetDocument);
 
public:
  plGameObjectDocument(plStringView sDocumentPath, plDocumentObjectManager* pObjectManager,
    plAssetDocEngineConnection engineConnectionType = plAssetDocEngineConnection::FullObjectMirroring);
  ~plGameObjectDocument();
 
 
  virtual plEditorInputContext* GetEditorInputContextOverride() override;
 
protected:
  void SubscribeGameObjectEventHandlers();
  void UnsubscribeGameObjectEventHandlers();
 
  void GameObjectDocumentEventHandler(const plGameObjectDocumentEvent& e);
 
public:
  void SetActiveEditTool(const plRTTI* pEditToolType);
 
  plGameObjectEditTool* GetActiveEditTool() const { return m_pActiveEditTool; }
 
  bool IsActiveEditTool(const plRTTI* pEditToolType) const;
 
  void SetEditToolConfigDelegate(plDelegate<void(plGameObjectEditTool*)> configDelegate);
 
  void SetGizmoWorldSpace(bool bWorldSpace);
  bool GetGizmoWorldSpace() const;
 
  void SetGizmoMoveParentOnly(bool bMoveParent);
  bool GetGizmoMoveParentOnly() const;
 
  void ComputeTopLevelSelectedGameObjects(plDeque<plSelectedGameObject>& out_selection);
 
  virtual void HandleEngineMessage(const plEditorEngineDocumentMsg* pMsg) override;
 
private:
  void DeallocateEditTools();
 
  plDelegate<void(plGameObjectEditTool*)> m_EditToolConfigDelegate;
  plGameObjectEditTool* m_pActiveEditTool = nullptr;
  plMap<const plRTTI*, plGameObjectEditTool*> m_CreatedEditTools;
 
 
 
public:
  void TriggerShowSelectionInScenegraph() const;
  void TriggerFocusOnSelection(bool bAllViews) const;
  void TriggerSnapPivotToGrid() const;
  void TriggerSnapEachObjectToGrid() const;
  void SnapCameraToObject();
  void MoveCameraHere();
 
  plStatus CreateGameObjectHere();
 
  void ScheduleSendObjectSelection();
 
  void SendObjectSelection();
 
public:
  bool GetAddAmbientLight() const { return m_bAddAmbientLight; }
  void SetAddAmbientLight(bool b);
 
  float GetSimulationSpeed() const { return m_fSimulationSpeed; }
  void SetSimulationSpeed(float f);
 
  bool GetRenderSelectionOverlay() const { return m_CurrentMode.m_bRenderSelectionOverlay; }
  void SetRenderSelectionOverlay(bool b);
 
  bool GetRenderVisualizers() const { return m_CurrentMode.m_bRenderVisualizers; }
  void SetRenderVisualizers(bool b);
 
  bool GetRenderShapeIcons() const { return m_CurrentMode.m_bRenderShapeIcons; }
  void SetRenderShapeIcons(bool b);
 
  bool GetPickTransparent() const { return m_bPickTransparent; }
  void SetPickTransparent(bool b);
 
 
  void SetGlobalTransform(const plDocumentObject* pObject, const plTransform& t, plUInt8 uiTransformationChanges) const;
 
  void SetGlobalTransformParentOnly(const plDocumentObject* pObject, const plTransform& t, plUInt8 uiTransformationChanges) const;
 
  plTransform GetGlobalTransform(const plDocumentObject* pObject) const;
 
  static plTransform QueryLocalTransform(const plDocumentObject* pObject);
  static plSimdTransform QueryLocalTransformSimd(const plDocumentObject* pObject);
 
  plTransform ComputeGlobalTransform(const plDocumentObject* pObject) const;
 
  virtual plResult ComputeObjectTransformation(const plDocumentObject* pObject, plTransform& out_result) const override;
 
 
  void DetermineNodeName(const plDocumentObject* pObject, const plUuid& prefabGuid, plStringBuilder& out_sResult, QIcon* out_pIcon = nullptr) const;
 
  void QueryCachedNodeName(
    const plDocumentObject* pObject, plStringBuilder& out_sResult, plUuid* out_pPrefabGuid = nullptr, QIcon* out_pIcon = nullptr) const;
 
  void GenerateFullDisplayName(const plDocumentObject* pRoot, plStringBuilder& out_sFullPath) const;
 
 
public:
  mutable plEvent<const plGameObjectEvent&> m_GameObjectEvents;
  mutable plUniquePtr<plObjectMetaData<plUuid, plGameObjectMetaData>> m_GameObjectMetaData;
 
  static plEvent<const plGameObjectDocumentEvent&> s_GameObjectDocumentEvents;
 
protected:
  void InvalidateGlobalTransformValue(const plDocumentObject* pObject) const;
  virtual void SendGameWorldToEngine();
 
  virtual void InitializeAfterLoading(bool bFirstTimeCreation) override;
  virtual void AttachMetaDataBeforeSaving(plAbstractObjectGraph& graph) const override;
  virtual void RestoreMetaDataAfterLoading(const plAbstractObjectGraph& graph, bool bUndoable) override;
 
public:
  void SelectionManagerEventHandler(const plSelectionManagerEvent& e);
  void ObjectPropertyEventHandler(const plDocumentObjectPropertyEvent& e);
  void ObjectStructureEventHandler(const plDocumentObjectStructureEvent& e);
  void ObjectEventHandler(const plDocumentObjectEvent& e);
 
protected:
  struct PL_EDITORFRAMEWORK_DLL GameModeData
  {
    bool m_bRenderSelectionOverlay;
    bool m_bRenderVisualizers;
    bool m_bRenderShapeIcons;
  };
  GameModeData m_CurrentMode;
 
private:
  bool m_bAddAmbientLight = false;
  bool m_bGizmoWorldSpace = true; // whether the gizmo is in local/global space mode
  bool m_bGizmoMoveParentOnly = false;
  bool m_bPickTransparent = true;
 
  float m_fSimulationSpeed = 1.0f;
 
  using TransformTable = plHashTable<const plDocumentObject*, plSimdTransform, plHashHelper<const plDocumentObject*>, plAlignedAllocatorWrapper>;
  mutable TransformTable m_GlobalTransforms;
 
  // when new objects are created the engine sometimes needs to catch up creating sub-objects (e.g. for reference prefabs)
  // therefore when the selection is changed in the first frame, it might not be fully correct
  // by sending it a second time, we can fix that easily
  plInt8 m_iResendSelection = 0;
 
protected:
  plEventSubscriptionID m_SelectionManagerEventHandlerID;
  plEventSubscriptionID m_ObjectPropertyEventHandlerID;
  plEventSubscriptionID m_ObjectStructureEventHandlerID;
  plEventSubscriptionID m_ObjectEventHandlerID;
};