Code/Sandbox/Plugins/CryDesigner/DesignerSession.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "DesignerSession.h"
   5
   6 #include "Util/DesignerSettings.h"
   7 #include "Util/Converter.h"
   8 #include "Core/Helper.h"
   9
  10 #include "IEditor.h"
  11 #include "Material/MaterialManager.h"
  12
  13 #include "Core/ModelCompiler.h"
  14 #include "Objects/DesignerObject.h"
  15 #include "Objects/AreaSolidObject.h"
  16 #include "Objects/ClipVolumeObject.h"
  17 #include "Objects/EntityObject.h"
  18 #include "Objects/BrushObject.h"
  19 #include "RecursionLoopGuard.h"
  20
  21 namespace Designer
  22 {
  23
  24 DesignerSession* DesignerSession::s_session = nullptr;
  25
  26 DesignerSession::DesignerSession()
  27         : m_bActiveSession(false)
  28         , m_bSessionFinished(false)
  29 {
  30         GetIEditor()->GetMaterialManager()->AddListener(this);
  31
  32         // Brush to Designer
  33         GetIEditor()->GetObjectManager()->RegisterTypeConverter(RUNTIME_CLASS(CBrushObject), "Designer", [](CBaseObject* pObject)
  34                 {
  35                         Converter converter;
  36                         if (!converter.ConvertToDesignerObject())
  37                                 CryWarning(VALIDATOR_MODULE_EDITOR, VALIDATOR_ERROR, "The selected object(s) can't be converted.");
  38           });
  39
  40         // Entity to Designer
  41         GetIEditor()->GetObjectManager()->RegisterTypeConverter(RUNTIME_CLASS(CEntityObject), "Designer", [](CBaseObject* pObject)
  42                 {
  43                         Converter converter;
  44                         if (!converter.ConvertToDesignerObject())
  45                                 CryWarning(VALIDATOR_MODULE_EDITOR, VALIDATOR_ERROR, "The selected object(s) can't be converted.");
  46           });
  47 }
  48
  49 DesignerSession::~DesignerSession()
  50 {
  51         GetIEditor()->GetMaterialManager()->RemoveListener(this);
  52 }
  53
  54 DesignerSession* DesignerSession::GetInstance()
  55 {
  56         if (!s_session)
  57         {
  58                 s_session = new DesignerSession();
  59         }
  60
  61         return s_session;
  62 }
  63
  64 Model* DesignerSession::GetModel() const
  65 {
  66         if (!m_pBaseObject)
  67                 return nullptr;
  68
  69         Model* pModel;
  70         if (Designer::GetModel(m_pBaseObject, pModel))
  71                 return pModel;
  72
  73         DESIGNER_ASSERT(0);
  74         return nullptr;
  75 }
  76
  77 CBaseObject* DesignerSession::GetBaseObject() const
  78 {
  79         return m_pBaseObject;
  80 }
  81
  82 MainContext DesignerSession::GetMainContext()
  83 {
  84         MainContext mc(m_pBaseObject, GetCompiler(), GetModel());
  85         mc.pSelected = &m_pSelectedElements;
  86         return mc;
  87 }
  88
  89 ModelCompiler* DesignerSession::GetCompiler() const
  90 {
  91         DESIGNER_ASSERT(m_pBaseObject);
  92         if (!m_pBaseObject)
  93                 return nullptr;
  94
  95         ModelCompiler* pCompiler;
  96         if (Designer::GetCompiler(m_pBaseObject, pCompiler))
  97                 return pCompiler;
  98
  99         DESIGNER_ASSERT(0);
 100         return nullptr;
 101 }
 102
 103 void DesignerSession::SetBaseObject(CBaseObject* pBaseObject)
 104 {
 105         if (m_pBaseObject == pBaseObject)
 106                 return;
 107         m_pBaseObject = pBaseObject;
 108         signalDesignerEvent(eDesignerNotify_ObjectSelect, 0);
 109 }
 110
 111 void DesignerSession::OnEditorNotifyEvent(EEditorNotifyEvent event)
 112 {
 113         bool bExclusiveModeBeforeSave = false;
 114         ElementSet* pSelected = GetSelectedElements();
 115         switch (event)
 116         {
 117         case eNotify_OnBeginGameMode:
 118         case eNotify_OnBeginBindViewport:
 119                 gDesignerSettings.bExclusiveMode = false;
 120                 gExclusiveModeSettings.EnableExclusiveMode(gDesignerSettings.bExclusiveMode);
 121                 pSelected->Clear();
 122                 gDesignerSettings.Update(true);
 123                 signalDesignerEvent(eDesignerNotify_SettingsChanged, nullptr);
 124                 break;
 125
 126         case eNotify_OnBeginLoad:
 127         case eNotify_OnBeginNewScene:
 128         case eNotify_OnBeginSceneOpen:
 129                 // make sure we clear the cache here
 130                 ClearCache();
 131         // fallthrough
 132         case eNotify_OnBeginSceneSave:
 133                 bExclusiveModeBeforeSave = gDesignerSettings.bExclusiveMode;
 134                 if (gDesignerSettings.bExclusiveMode)
 135                 {
 136                         gDesignerSettings.bExclusiveMode = false;
 137                         gExclusiveModeSettings.EnableExclusiveMode(gDesignerSettings.bExclusiveMode);
 138                 }
 139                 break;
 140
 141         case eNotify_OnEndSceneSave:
 142                 if (bExclusiveModeBeforeSave)
 143                 {
 144                         gDesignerSettings.bExclusiveMode = true;
 145                         gExclusiveModeSettings.EnableExclusiveMode(gDesignerSettings.bExclusiveMode);
 146                         bExclusiveModeBeforeSave = false;
 147                 }
 148                 break;
 149         case eNotify_OnSelectionChange:
 150                 {
 151                         const CSelectionGroup* sel = GetIEditor()->GetObjectManager()->GetSelection();
 152                         const int count = sel->GetCount();
 153                         bool startSession = count > 0;
 154                         for (int i = 0; i < count; i++)
 155                         {
 156                                 CBaseObject* obj = sel->GetObject(i);
 157                                 if (!Designer::CanDesignerEditObject(obj))
 158                                         startSession = false;
 159                                 /*else if(obj->IsKindOf(RUNTIME_CLASS(AreaSolidObject))
 160                                    {
 161                                    //this was on the area solid BeginEditParams(), not sure where to put this now...
 162                                    Designer::GetModel(obj)->SetFlag(GetModel()->GetFlag() | eModelFlag_DisplayBackFace);
 163                                    ApplyPostProcess(MainContext(this, GetCompiler(), GetModel()), ePostProcess_Mesh);
 164                                    }*/
 165                         }
 166
 167                         if (startSession)
 168                                 BeginSession();
 169                         else
 170                                 EndSession();
 171                 }
 172
 173         }
 174 }
 175
 176 void DesignerSession::SetCurrentSubMatID(int idx)
 177 {
 178         //move to session
 179         m_currentMaterialIntex = idx;
 180         MaterialChangeEvent evt = { idx };
 181         signalDesignerEvent(eDesignerNotify_SubMaterialSelectionChanged, &evt);
 182 }
 183
 184 void DesignerSession::ClearCache()
 185 {
 186         m_pBaseObject = nullptr;
 187         m_currentMaterialIntex = 0;
 188
 189         m_pExcludedEdgeManager.Clear();
 190         m_pSelectedElements.Clear();
 191
 192         m_pSelectionMesh = nullptr;
 193 }
 194
 195 void DesignerSession::OnDataBaseItemEvent(
 196   IDataBaseItem* pItem,
 197   EDataBaseItemEvent event)
 198 {
 199         DatabaseEvent evt;
 200         evt.evt = event;
 201         evt.pItem = pItem;
 202
 203         signalDesignerEvent(eDesignerNotify_SubMaterialSelectionChanged, &evt);
 204
 205         auto pObject = GetBaseObject();
 206         if (pObject)
 207         {
 208                 if (pObject->GetMaterial() == (IEditorMaterial*)pItem || pObject->GetRenderMaterial() == (IEditorMaterial*)pItem)
 209                         signalDesignerEvent(eDesignerNotify_RefreshSubMaterialList, nullptr);
 210         }
 211 }
 212
 213 int DesignerSession::GetCurrentSubMatID() const
 214 {
 215         return m_currentMaterialIntex;
 216 }
 217
 218 ElementSet* DesignerSession::GetSelectedElements()
 219 {
 220         return &m_pSelectedElements;
 221 }
 222
 223 void DesignerSession::ClearPolygonSelections()
 224 {
 225         m_pSelectionMesh = nullptr;
 226 }
 227
 228 _smart_ptr<PolygonMesh> DesignerSession::GetSelectionMesh()
 229 {
 230         return m_pSelectionMesh;
 231 }
 232
 233 void DesignerSession::UpdateSelectionMeshFromSelectedElements(MainContext& mc)
 234 {
 235         if (!mc.pModel || !mc.pCompiler)
 236                 return;
 237
 238         std::vector<PolygonPtr> polygonlist;
 239
 240         ElementSet* pSelectedElement = DesignerSession::GetInstance()->GetSelectedElements();
 241
 242         for (int k = 0, iElementSize(pSelectedElement->GetCount()); k < iElementSize; ++k)
 243         {
 244                 if (pSelectedElement->Get(k).IsPolygon())
 245                         polygonlist.push_back(pSelectedElement->Get(k).m_pPolygon);
 246         }
 247
 248         if (m_pSelectionMesh == NULL)
 249                 m_pSelectionMesh = new PolygonMesh;
 250
 251         int renderFlag = mc.pCompiler->GetRenderFlags();
 252         int viewDist = mc.pCompiler->GetViewDistRatio();
 253         uint32 minSpec = mc.pObject->GetMinSpec();
 254         uint32 materialLayerMask = mc.pObject->GetMaterialLayersMask();
 255         BrushMatrix34 worldTM = mc.pObject->GetWorldTM();
 256
 257         m_pSelectionMesh->SetPolygons(polygonlist, false, worldTM, renderFlag, viewDist, minSpec, materialLayerMask);
 258 }
 259
 260 void DesignerSession::UpdateSelectionMesh(
 261   PolygonPtr pPolygon,
 262   ModelCompiler* pCompiler,
 263   CBaseObject* pObj,
 264   bool bForce)
 265 {
 266         std::vector<PolygonPtr> polygons;
 267         if (pPolygon)
 268                 polygons.push_back(pPolygon);
 269         UpdateSelectionMesh(polygons, pCompiler, pObj, bForce);
 270 }
 271
 272 void DesignerSession::UpdateSelectionMesh(
 273   std::vector<PolygonPtr> polygons,
 274   ModelCompiler* pCompiler,
 275   CBaseObject* pObj,
 276   bool bForce)
 277 {
 278         if (m_pSelectionMesh == NULL)
 279                 m_pSelectionMesh = new PolygonMesh;
 280
 281         int renderFlag = pCompiler->GetRenderFlags();
 282         int viewDist = pCompiler->GetViewDistRatio();
 283         uint32 minSpec = pObj->GetMinSpec();
 284         uint32 materialLayerMask = pObj->GetMaterialLayersMask();
 285         BrushMatrix34 worldTM = pObj->GetWorldTM();
 286
 287         if (!polygons.empty())
 288                 m_pSelectionMesh->SetPolygons(polygons, bForce, worldTM, renderFlag, viewDist, minSpec, materialLayerMask);
 289         else
 290                 m_pSelectionMesh->SetPolygon(NULL, bForce, worldTM, renderFlag, viewDist, minSpec, materialLayerMask);
 291 }
 292
 293 void DesignerSession::ReleaseSelectionMesh()
 294 {
 295         if (m_pSelectionMesh)
 296         {
 297                 m_pSelectionMesh->ReleaseResources();
 298                 m_pSelectionMesh = nullptr;
 299         }
 300 }
 301
 302 void DesignerSession::BeginSession()
 303 {
 304         // This will clear selection caches every time a new object is selected, which
 305         // is not what we usually want, but will suffice until we rip selection state
 306         // into the Model itself, rather than the session
 307         ClearCache();
 308
 309         const CSelectionGroup* pSelection = GetIEditor()->GetObjectManager()->GetSelection();
 310         SetBaseObject(pSelection->GetObject(0));
 311
 312         if (!m_bActiveSession)
 313         {
 314                 Model* model;
 315                 model = GetModel();
 316                 model->SetShelf(eShelf_Base);
 317
 318                 if (gDesignerSettings.bExclusiveMode)
 319                 {
 320                         if (model && model->IsEmpty())
 321                         {
 322                                 gDesignerSettings.bExclusiveMode = false;
 323                                 gDesignerSettings.Update(true);
 324                         }
 325                         else
 326                         {
 327                                 gExclusiveModeSettings.EnableExclusiveMode(true);
 328                         }
 329                 }
 330
 331                 signalDesignerEvent(eDesignerNotify_BeginDesignerSession, nullptr);
 332
 333                 m_bActiveSession = true;
 334         }
 335 }
 336
 337 ExcludedEdgeManager* DesignerSession::GetExcludedEdgeManager()
 338 {
 339         return &m_pExcludedEdgeManager;
 340 }
 341
 342 std::vector<EDesignerTool> DesignerSession::GetIncompatibleSubtools()
 343 {
 344         if (!m_pBaseObject)
 345                 return std::vector<EDesignerTool>();
 346
 347         if (m_pBaseObject->IsKindOf(RUNTIME_CLASS(DesignerObject)))
 348         {
 349                 DesignerObject* pModelObj = static_cast<DesignerObject*>(m_pBaseObject.get());
 350                 return pModelObj->GetIncompatibleSubtools();
 351         }
 352         else if (m_pBaseObject->IsKindOf(RUNTIME_CLASS(AreaSolidObject)))
 353         {
 354                 AreaSolidObject* pArea = static_cast<AreaSolidObject*>(m_pBaseObject.get());
 355                 return pArea->GetIncompatibleSubtools();
 356         }
 357         else if (m_pBaseObject->IsKindOf(RUNTIME_CLASS(ClipVolumeObject)))
 358         {
 359                 ClipVolumeObject* pVolume = static_cast<ClipVolumeObject*>(m_pBaseObject.get());
 360                 return pVolume->GetIncompatibleSubtools();
 361         }
 362
 363         // should never happen but...
 364         return std::vector<EDesignerTool>();
 365 }
 366
 367 void DesignerSession::EndSession()
 368 {
 369         RECURSION_GUARD(m_bSessionFinished);
 370         if (m_bActiveSession)
 371         {
 372                 // disable at once, this saves us from recursive calls when destroying empty designer objects on tool exit
 373                 m_bActiveSession = false;
 374
 375                 // quit any designer tools if we still have one.
 376                 // usually session ends when we select another object type, so we usually are in
 377                 // object mode tool already but it can also happen when we undo out of the session.
 378                 // In that case, designer won't have data to work with so we need to ensure the tool has quit.
 379                 if (GetDesigner())
 380                 {
 381                         GetIEditor()->SetEditTool(nullptr);
 382                 }
 383
 384                 gExclusiveModeSettings.EnableExclusiveMode(false);
 385                 signalDesignerEvent(eDesignerNotify_EndDesignerSession, nullptr);
 386                 ClearCache();
 387         }
 388 }
 389
 390 bool DesignerSession::GetIsActive()
 391 {
 392         return m_bActiveSession;
 393 }
 394
 395 }