Code/Sandbox/Plugins/EditorCommon/LevelEditor/Tools/ObjectMode.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "ObjectMode.h"
   5 #include "Viewport.h"
   6 #include <Preferences/ViewportPreferences.h>
   7 #include "ViewManager.h"
   8 #include "Terrain/Heightmap.h"
   9 #include "GameEngine.h"
  10 #include "Objects/EntityObject.h"
  11 #include "Objects/CameraObject.h"
  12 #include "Controls/DynamicPopupMenu.h"
  13 #include "Objects/BrushObject.h"
  14 #include "DeepSelection.h"
  15 #include "SubObjectSelectionReferenceFrameCalculator.h"
  16 #include "Gizmos/IGizmoManager.h"
  17 #include "Objects/ParticleEffectObject.h"
  18 #include "Objects/PrefabObject.h"
  19 #include "Grid.h"
  20 #include "IUndoManager.h"
  21 #include "Objects/ISelectionGroup.h"
  22
  23 /////////////////////////////
  24 // CObjectManipulatorOwner
  25 /////////////////////////////
  26 CObjectManipulatorOwner::CObjectManipulatorOwner(CObjectMode* objectModeTool)
  27         : m_bIsVisible(true)
  28         , m_visibilityDirty(true)
  29 {
  30         m_manipulator = GetIEditor()->GetGizmoManager()->AddManipulator(this);
  31         m_manipulator->signalBeginDrag.Connect(objectModeTool, &CObjectMode::OnManipulatorBeginDrag);
  32         m_manipulator->signalDragging.Connect(objectModeTool, &CObjectMode::OnManipulatorDrag);
  33         m_manipulator->signalEndDrag.Connect(objectModeTool, &CObjectMode::OnManipulatorEndDrag);
  34
  35         GetIEditor()->GetObjectManager()->signalObjectsChanged.Connect(this, &CObjectManipulatorOwner::OnObjectsChanged);
  36         GetIEditor()->GetObjectManager()->signalSelectionChanged.Connect(this, &CObjectManipulatorOwner::OnSelectionChanged);
  37
  38         const ISelectionGroup* pSelection = GetIEditor()->GetISelectionGroup();
  39         int totCount = pSelection->GetCount();
  40
  41         // register to all selected objects on initialization
  42         for (int i = 0; i < totCount; ++i)
  43         {
  44                 CBaseObject* pObj = pSelection->GetObject(i);
  45                 pObj->signalChanged.Connect(this, &CObjectManipulatorOwner::OnObjectChanged);
  46         }
  47 }
  48
  49 CObjectManipulatorOwner::~CObjectManipulatorOwner()
  50 {
  51         GetIEditor()->GetObjectManager()->signalObjectsChanged.DisconnectObject(this);
  52         GetIEditor()->GetObjectManager()->signalSelectionChanged.DisconnectObject(this);
  53
  54         m_manipulator->signalBeginDrag.DisconnectAll();
  55         m_manipulator->signalDragging.DisconnectAll();
  56         m_manipulator->signalEndDrag.DisconnectAll();
  57         GetIEditor()->GetGizmoManager()->RemoveManipulator(m_manipulator);
  58
  59         m_manipulator = nullptr;
  60
  61         const ISelectionGroup* pSelection = GetIEditor()->GetISelectionGroup();
  62         int totCount = pSelection->GetCount();
  63
  64         // unregister from all selected objects
  65         for (int i = 0; i < totCount; ++i)
  66         {
  67                 CBaseObject* pObj = pSelection->GetObject(i);
  68                 pObj->signalChanged.DisconnectObject(this);
  69         }
  70 }
  71
  72 bool CObjectManipulatorOwner::GetManipulatorMatrix(Matrix34& tm)
  73 {
  74         const ISelectionGroup* pSelection = GetIEditor()->GetISelectionGroup();
  75         return pSelection->GetManipulatorMatrix(tm);
  76 }
  77
  78 void CObjectManipulatorOwner::GetManipulatorPosition(Vec3& position)
  79 {
  80         const ISelectionGroup* pSelection = GetIEditor()->GetISelectionGroup();
  81
  82         position.Set(0.0f, 0.0f, 0.0f);
  83
  84         int totCount = pSelection->GetCount();
  85         for (int i = 0; i < totCount; ++i)
  86         {
  87                 CBaseObject* pObj = pSelection->GetObject(i);
  88                 if (pObj->IsVisible() && !pObj->IsFrozen())
  89                 {
  90                         position += pObj->GetWorldPos();
  91                 }
  92         }
  93
  94         position *= (1.0f / totCount);
  95 }
  96
  97 void CObjectManipulatorOwner::OnObjectChanged(const CBaseObject* pObject, const CObjectEvent& event)
  98 {
  99         if (event.m_type == OBJECT_ON_TRANSFORM)
 100         {
 101                 // tag for update next cycle
 102                 m_manipulator->Invalidate();
 103         }
 104         else if (event.m_type == OBJECT_ON_VISIBILITY)
 105         {
 106                 m_manipulator->Invalidate();
 107                 m_visibilityDirty = true;
 108         }
 109 }
 110
 111 void CObjectManipulatorOwner::OnObjectsChanged(const std::vector<CBaseObject*>& objects, const CObjectEvent& event)
 112 {
 113         if (event.m_type == OBJECT_ON_TRANSFORM)
 114         {
 115                 // tag for update next cycle
 116                 m_manipulator->Invalidate();
 117         }
 118 }
 119
 120 void CObjectManipulatorOwner::OnSelectionChanged(const std::vector<CBaseObject*>& selected, const std::vector<CBaseObject*>& deselected)
 121 {
 122         CRY_PROFILE_FUNCTION(PROFILE_EDITOR);
 123         // unregister from all manipulated objects
 124         for (auto& pObject : deselected)
 125         {
 126                 pObject->signalChanged.DisconnectObject(this);
 127         }
 128
 129         for (auto& pObject : selected)
 130         {
 131                 pObject->signalChanged.Connect(this, &CObjectManipulatorOwner::OnObjectChanged);
 132         }
 133
 134         m_manipulator->Invalidate();
 135         m_visibilityDirty = true;
 136 }
 137
 138 bool CObjectManipulatorOwner::IsManipulatorVisible()
 139 {
 140         if (m_visibilityDirty)
 141         {
 142                 UpdateVisibilityState();
 143                 m_manipulator->Invalidate();
 144                 m_visibilityDirty = false;
 145         }
 146         return m_bIsVisible;
 147 }
 148
 149 void CObjectManipulatorOwner::UpdateVisibilityState()
 150 {
 151         const ISelectionGroup* pSelection = GetIEditor()->GetISelectionGroup();
 152         m_bIsVisible = false;
 153         int totCount = pSelection->GetCount();
 154         for (int i = 0; i < totCount; ++i)
 155         {
 156                 CBaseObject* pObj = pSelection->GetObject(i);
 157
 158                 if (pObj->IsVisible() && !pObj->IsFrozen())
 159                 {
 160                         m_bIsVisible = true;
 161                         break;
 162                 }
 163         }
 164 }
 165
 166 //////////////////////////////////////////////////////////////////////////
 167 IMPLEMENT_DYNCREATE(CObjectMode, CEditTool)
 168
 169 SDeepSelectionPreferences gDeepSelectionPreferences;
 170 REGISTER_PREFERENCES_PAGE_PTR(SDeepSelectionPreferences, &gDeepSelectionPreferences)
 171
 172 //////////////////////////////////////////////////////////////////////////
 173 CObjectMode::CObjectMode()
 174         : m_objectManipulatorOwner(this)
 175         , m_bDragThresholdExceeded(false)
 176 {
 177         m_openContext = false;
 178         m_commandMode = NothingMode;
 179         m_MouseOverObject = CryGUID::Null();
 180
 181         m_pDeepSelection = new CDeepSelection();
 182         m_bMoveByFaceNormManipShown = false;
 183         m_pHitObject = NULL;
 184
 185         m_bTransformChanged = false;
 186
 187         m_suspendHighlightChange = false;
 188         m_normalMoveGizmo = nullptr;
 189
 190         m_bGizmoDrag = false;
 191 }
 192
 193 //////////////////////////////////////////////////////////////////////////
 194 CObjectMode::~CObjectMode()
 195 {
 196         GetIEditor()->UnRegisterAllObjectModeSubTools();
 197         CAutoRegisterObjectModeSubToolHelper::UnregisterAll();
 198
 199         CBaseObject* pMouseOverObject = nullptr;
 200         if (m_MouseOverObject != CryGUID::Null())
 201         {
 202                 pMouseOverObject = GetIEditor()->GetObjectManager()->FindObject(m_MouseOverObject);
 203         }
 204
 205         if (pMouseOverObject)
 206         {
 207                 pMouseOverObject->SetHighlight(false);
 208         }
 209
 210         if (m_normalMoveGizmo)
 211         {
 212                 m_normalMoveGizmo->signalBeginDrag.DisconnectAll();
 213                 m_normalMoveGizmo->signalDragging.DisconnectAll();
 214                 m_normalMoveGizmo->signalEndDrag.DisconnectAll();
 215                 GetIEditor()->GetGizmoManager()->RemoveManipulator(m_normalMoveGizmo);
 216                 m_normalMoveGizmo = nullptr;
 217         }
 218 }
 219
 220 void CObjectMode::Activate()
 221 {
 222         CAutoRegisterObjectModeSubToolHelper::RegisterAll();
 223         GetIEditor()->RegisterAllObjectModeSubTools();
 224 }
 225
 226 void CObjectMode::RegisterSubTool(ISubTool* pSubTool)
 227 {
 228         m_subTools.insert(pSubTool);
 229 }
 230
 231 void CObjectMode::UnRegisterSubTool(ISubTool* pSubTool)
 232 {
 233         m_subTools.erase(pSubTool);
 234 }
 235
 236 void CObjectMode::DisplaySelectionPreview(SDisplayContext& dc)
 237 {
 238         IDisplayViewport* pDisplayViewport = dc.view;
 239         if (!pDisplayViewport)
 240                 return;
 241
 242         CViewport* pViewport = static_cast<CViewport*>(pDisplayViewport);
 243         if (!pViewport)
 244                 return;
 245
 246         IObjectManager* objMan = GetIEditor()->GetObjectManager();
 247
 248         CRect rc = pViewport->GetSelectionRectangle();
 249
 250         if (GetCommandMode() == SelectMode)
 251         {
 252                 if (rc.Width() > 1 && rc.Height() > 1)
 253                 {
 254                         GetIEditor()->GetObjectManager()->FindObjectsInRect(pViewport, rc, m_PreviewGUIDs);
 255
 256                         // Do not include child objects in the count of object candidates
 257                         int childNo = 0;
 258                         for (int objNo = 0; objNo < m_PreviewGUIDs.size(); ++objNo)
 259                         {
 260                                 auto foundObj = objMan->FindObject(m_PreviewGUIDs[objNo]);
 261                                 if (foundObj && foundObj->GetParent())
 262                                         ++childNo;
 263                         }
 264
 265                         // Draw Preview for objects
 266                         for (size_t i = 0; i < m_PreviewGUIDs.size(); ++i)
 267                         {
 268                                 CBaseObject* pObject = GetIEditor()->GetObjectManager()->FindObject(m_PreviewGUIDs[i]);
 269
 270                                 if (!pObject)
 271                                         continue;
 272
 273                                 if (pObject->GetType() & ~gViewportSelectionPreferences.objectSelectMask)
 274                                         continue;
 275
 276                                 pObject->DrawSelectionPreviewHighlight(dc);
 277                         }
 278                 }
 279         }
 280 }
 281
 282 //////////////////////////////////////////////////////////////////////////
 283 void CObjectMode::Display(SDisplayContext& dc)
 284 {
 285         // Selection Candidates Preview
 286         DisplaySelectionPreview(dc);
 287 }
 288
 289 //////////////////////////////////////////////////////////////////////////
 290 bool CObjectMode::MouseCallback(CViewport* view, EMouseEvent event, CPoint& point, int flags)
 291 {
 292         // Sub tools get to handle the event first, if it goes unhandled, object mode will then try to handle it
 293         for (ISubTool* pSubTool : m_subTools)
 294         {
 295                 if (pSubTool->HandleMouseEvent(view, event, point, flags))
 296                 {
 297                         return true;
 298                 }
 299         }
 300
 301         switch (event)
 302         {
 303         case eMouseLDown:
 304                 return OnLButtonDown(view, flags, point);
 305                 break;
 306         case eMouseLUp:
 307                 return OnLButtonUp(view, flags, point);
 308                 break;
 309         case eMouseLDblClick:
 310                 return OnLButtonDblClk(view, flags, point);
 311                 break;
 312         case eMouseRDown:
 313                 return OnRButtonDown(view, flags, point);
 314                 break;
 315         case eMouseRUp:
 316                 return OnRButtonUp(view, flags, point);
 317                 break;
 318         case eMouseMove:
 319         case eMouseEnter:
 320                 return OnMouseMove(view, flags, point);
 321                 break;
 322         case eMouseMDown:
 323                 return OnMButtonDown(view, flags, point);
 324                 break;
 325         case eMouseFocusLeave:
 326         case eMouseLeave:
 327                 SetObjectCursor(view, 0, IObjectManager::ESelectOp::eNone);
 328                 return true;
 329                 break;
 330         }
 331         return false;
 332 }
 333
 334 //////////////////////////////////////////////////////////////////////////
 335 bool CObjectMode::OnKeyDown(CViewport* view, uint32 nChar, uint32 nRepCnt, uint32 nFlags)
 336 {
 337         if (nChar == Qt::Key_Escape)
 338         {
 339                 GetIEditor()->ClearSelection();
 340                 CLevelEditorSharedState* pLevelEditor = GetIEditor()->GetLevelEditorSharedState();
 341
 342                 if (pLevelEditor->GetEditMode() == CLevelEditorSharedState::EditMode::SelectArea)
 343                         pLevelEditor->SetEditMode(CLevelEditorSharedState::EditMode::Select);
 344         }
 345         return false;
 346 }
 347
 348 //////////////////////////////////////////////////////////////////////////
 349 bool CObjectMode::OnKeyUp(CViewport* view, uint32 nChar, uint32 nRepCnt, uint32 nFlags)
 350 {
 351         return false;
 352 }
 353
 354 //////////////////////////////////////////////////////////////////////////
 355 bool CObjectMode::OnLButtonDown(CViewport* view, int nFlags, CPoint point)
 356 {
 357         if (m_bMoveByFaceNormManipShown)
 358         {
 359                 HideMoveByFaceNormGizmo();
 360         }
 361
 362         // CPointF ptMarker;
 363         CPoint ptCoord;
 364         int iCurSel = -1;
 365
 366         if (GetIEditor()->IsInGameMode())
 367         {
 368                 // Ignore clicks while in game.
 369                 return false;
 370         }
 371
 372         // Save the mouse down position
 373         m_cMouseDownPos = point;
 374
 375         m_bDragThresholdExceeded = false;
 376
 377         view->ResetSelectionRegion();
 378
 379         Vec3 pos = view->SnapToGrid(view->ViewToWorld(point));
 380         CLevelEditorSharedState::EditMode editMode = GetIEditor()->GetLevelEditorSharedState()->GetEditMode();
 381
 382         // Show marker position in the status bar
 383         //cry_sprintf(szNewStatusText, "X:%g Y:%g Z:%g",pos.x,pos.y,pos.z );
 384
 385         // Swap X/Y
 386         float unitSize = 1;
 387         CHeightmap* pHeightmap = GetIEditor()->GetHeightmap();
 388         if (pHeightmap)
 389                 unitSize = pHeightmap->GetUnitSize();
 390         float hx = pos.y / unitSize;
 391         float hy = pos.x / unitSize;
 392         float hz = GetIEditor()->GetTerrainElevation(pos.x, pos.y);
 393
 394         // Get control key status.
 395         const bool bAltClick = (nFlags & MK_ALT);
 396         const bool bCtrlClick = (nFlags & MK_CONTROL);
 397         const bool bShiftClick = (nFlags & MK_SHIFT);
 398
 399         const bool bAddSelect = bShiftClick;
 400         const bool bToggle = bCtrlClick;
 401         // Alt click might be beginning of marque deselection - so we must not remove selection
 402         const bool bNoRemoveSelection = bAddSelect || bToggle || bAltClick;
 403
 404         // Check deep selection mode activated
 405         // The Deep selection has two mode.
 406         // The normal mode pops the context menu, another is the cyclic selection on clinking.
 407         bool bTabPressed = CheckVirtualKey(VK_TAB);
 408         bool bZKeyPressed = CheckVirtualKey('Z');
 409
 410         CDeepSelection::EDeepSelectionMode dsMode =
 411           (bTabPressed ? (bZKeyPressed ? CDeepSelection::DSM_POP : CDeepSelection::DSM_CYCLE) : CDeepSelection::DSM_NONE);
 412
 413         bool bLockSelection = GetIEditor()->IsSelectionLocked();
 414
 415         int numUnselected = 0;
 416         int numSelected = 0;
 417
 418         //      m_activeAxis = 0;
 419
 420         HitContext hitInfo;
 421         hitInfo.view = view;
 422
 423         if (dsMode == CDeepSelection::DSM_POP)
 424         {
 425                 m_pDeepSelection->Reset(true);
 426                 m_pDeepSelection->SetMode(dsMode);
 427                 hitInfo.pDeepSelection = m_pDeepSelection;
 428         }
 429         else if (dsMode == CDeepSelection::DSM_CYCLE)
 430         {
 431                 if (!m_pDeepSelection->OnCycling(point))
 432                 {
 433                         // Start of the deep selection cycling mode.
 434                         m_pDeepSelection->Reset(false);
 435                         m_pDeepSelection->SetMode(dsMode);
 436                         hitInfo.pDeepSelection = m_pDeepSelection;
 437                 }
 438         }
 439         else
 440         {
 441                 if (m_pDeepSelection->GetPreviousMode() == CDeepSelection::DSM_NONE)
 442                         m_pDeepSelection->Reset(true);
 443
 444                 m_pDeepSelection->SetMode(CDeepSelection::DSM_NONE);
 445                 hitInfo.pDeepSelection = 0;
 446
 447         }
 448
 449         if (view->HitTest(point, hitInfo))
 450         {
 451                 if (hitInfo.axis != CLevelEditorSharedState::Axis::None)
 452                 {
 453                         GetIEditor()->GetLevelEditorSharedState()->SetAxisConstraint(hitInfo.axis);
 454                         // if edit mode is set to selection, then we treat gizmo as a selection component and we should not lock the selection
 455                         if (editMode != CLevelEditorSharedState::EditMode::Select)
 456                         {
 457                                 bLockSelection = true;
 458                         }
 459                 }
 460
 461                 //////////////////////////////////////////////////////////////////////////
 462                 // Deep Selection
 463                 CheckDeepSelection(hitInfo, view);
 464         }
 465
 466         CBaseObject* hitObj = hitInfo.object;
 467
 468         CLevelEditorSharedState::CoordSystem coordSys = GetIEditor()->GetLevelEditorSharedState()->GetCoordSystem();
 469         Vec3 gridPosition = (hitObj) ? hitObj->GetWorldPos() : pos;
 470
 471         if (coordSys == CLevelEditorSharedState::CoordSystem::UserDefined)
 472         {
 473                 Matrix34 userTM = Matrix34::CreateIdentity();
 474                 GetIEditor()->GetISelectionGroup()->GetManipulatorMatrix(userTM);
 475                 userTM.SetTranslation(Vec3(0, 0, 0));
 476                 userTM.SetTranslation(gridPosition);
 477                 view->SetConstructionMatrix(userTM);
 478         }
 479         else if (coordSys == CLevelEditorSharedState::CoordSystem::World || !hitObj)
 480         {
 481                 Matrix34 tm = Matrix34::CreateIdentity();
 482                 tm.SetTranslation(gridPosition);
 483                 view->SetConstructionMatrix(tm);
 484         }
 485         else if (coordSys == CLevelEditorSharedState::CoordSystem::Parent)
 486         {
 487                 if (hitInfo.object->GetParent())
 488                 {
 489                         Matrix34 parentTM = hitInfo.object->GetParent()->GetWorldTM();
 490                         parentTM.OrthonormalizeFast();
 491                         parentTM.SetTranslation(gridPosition);
 492                         view->SetConstructionMatrix(parentTM);
 493                 }
 494                 else
 495                 {
 496                         view->SetConstructionMatrix(hitInfo.object->GetWorldTM());
 497                 }
 498         }
 499         else if (coordSys == CLevelEditorSharedState::CoordSystem::Local)
 500         {
 501                 view->SetConstructionMatrix(hitInfo.object->GetWorldTM());
 502         }
 503
 504         if (gSnappingPreferences.IsSnapToTerrainEnabled() && GetIEditor()->GetLevelEditorSharedState()->GetAxisConstraint() != CLevelEditorSharedState::Axis::Z)
 505         {
 506                 m_mouseDownWorldPos = view->ViewToWorld(point);
 507         }
 508         else
 509         {
 510                 m_mouseDownWorldPos = view->MapViewToCP(point);
 511         }
 512
 513         if (editMode != CLevelEditorSharedState::EditMode::Tool)
 514         {
 515                 // Check for Move to position.
 516                 if (bCtrlClick && bShiftClick)
 517                 {
 518                         // Ctrl-Click on terrain will move selected objects to specified location.
 519                         MoveSelectionToPos(view, pos, bAltClick, point);
 520                         bLockSelection = true;
 521                 }
 522         }
 523
 524         if (editMode == CLevelEditorSharedState::EditMode::Move)
 525         {
 526                 if (!bNoRemoveSelection)
 527                         SetCommandMode(MoveMode);
 528
 529                 if (hitObj && hitObj->IsSelected() && !bNoRemoveSelection)
 530                         bLockSelection = true;
 531         }
 532         else if (editMode == CLevelEditorSharedState::EditMode::Rotate)
 533         {
 534                 if (!bNoRemoveSelection)
 535                         SetCommandMode(RotateMode);
 536                 if (hitObj && hitObj->IsSelected() && !bNoRemoveSelection)
 537                         bLockSelection = true;
 538         }
 539         else if (editMode == CLevelEditorSharedState::EditMode::Scale)
 540         {
 541                 if (!bNoRemoveSelection)
 542                 {
 543                         SetCommandMode(ScaleMode);
 544                 }
 545
 546                 if (hitObj && hitObj->IsSelected() && !bNoRemoveSelection)
 547                         bLockSelection = true;
 548         }
 549         else if (hitObj != 0 && GetIEditor()->GetSelectedObject() == hitObj && !bAddSelect && !bToggle)
 550         {
 551                 bLockSelection = true;
 552         }
 553
 554         if (!bLockSelection)
 555         {
 556                 // If not selection locked.
 557                 view->BeginUndo();
 558
 559                 IObjectManager* pObjectManager = GetIEditor()->GetObjectManager();
 560
 561                 if (!bNoRemoveSelection)
 562                 {
 563                         // Current selection should be cleared
 564                         numSelected = GetIEditor()->GetISelectionGroup()->GetCount();
 565                         pObjectManager->ClearSelection();
 566                 }
 567
 568                 if (hitObj)
 569                 {
 570                         numSelected = 1;
 571
 572                         if (!bToggle)
 573                         {
 574                                 pObjectManager->SelectObject(hitObj);
 575                         }
 576                         else
 577                         {
 578                                 if (hitObj->IsSelected())
 579                                 {
 580                                         pObjectManager->UnselectObject(hitObj);
 581                                 }
 582                                 else
 583                                 {
 584                                         pObjectManager->SelectObject(hitObj);
 585                                 }
 586                         }
 587                 }
 588                 if (view->IsUndoRecording())
 589                 {
 590                         view->AcceptUndo("Select Object(s)");
 591                 }
 592
 593                 if (numSelected == 0 || editMode == CLevelEditorSharedState::EditMode::Select || editMode == CLevelEditorSharedState::EditMode::SelectArea)
 594                 {
 595                         // If object is not selected.
 596                         // Capture mouse input for this window.
 597                         SetCommandMode(SelectMode);
 598                 }
 599         }
 600
 601         if (GetCommandMode() == MoveMode ||
 602             GetCommandMode() == RotateMode ||
 603             GetCommandMode() == ScaleMode)
 604         {
 605                 m_suspendHighlightChange = true;
 606                 view->BeginUndo();
 607         }
 608
 609         //////////////////////////////////////////////////////////////////////////
 610         // Change cursor, must be before Capture mouse.
 611         //////////////////////////////////////////////////////////////////////////
 612         SetObjectCursor(view, hitObj, bAddSelect ? IObjectManager::ESelectOp::eSelect : IObjectManager::ESelectOp::eNone);
 613
 614         m_bTransformChanged = false;
 615
 616         if (m_pDeepSelection->GetMode() == CDeepSelection::DSM_POP)
 617                 return OnLButtonUp(view, nFlags, point);
 618
 619         return true;
 620 }
 621
 622 //////////////////////////////////////////////////////////////////////////
 623 bool CObjectMode::OnLButtonUp(CViewport* view, int nFlags, CPoint point)
 624 {
 625         if (GetIEditor()->IsInGameMode())
 626         {
 627                 // Ignore clicks while in game.
 628                 return true;
 629         }
 630
 631         if (m_bTransformChanged)
 632         {
 633                 const ISelectionGroup* pSelection = GetIEditor()->GetISelectionGroup();
 634                 if (pSelection)
 635                         pSelection->FinishChanges();
 636                 m_bTransformChanged = false;
 637         }
 638
 639         // Undo may have been accepted already for MoveMode (if mouse has moved from original position), so view->IsUndoRecording()
 640         // will be false here, but we still need to cleanup. AcceptUndo is safe in any case because it checks if we are using undo.
 641         if (view->IsUndoRecording())
 642         {
 643                 if (GetCommandMode() == MoveMode)
 644                 {
 645                         view->AcceptUndo("Move Selection");
 646                 }
 647                 else if (GetCommandMode() == RotateMode)
 648                 {
 649                         view->AcceptUndo("Rotate Selection");
 650                 }
 651                 else if (GetCommandMode() == ScaleMode)
 652                 {
 653                         view->AcceptUndo("Scale Selection");
 654                 }
 655                 else
 656                 {
 657                         view->CancelUndo();
 658                 }
 659         }
 660
 661         if (GetCommandMode() == MoveMode)
 662         {
 663                 m_bDragThresholdExceeded = false;
 664         }
 665
 666         //////////////////////////////////////////////////////////////////////////
 667
 668         if (GetCommandMode() == SelectMode && (!GetIEditor()->IsSelectionLocked()))
 669         {
 670                 const bool bUnselect = (nFlags & MK_ALT);
 671                 const bool bToggle = (nFlags & MK_CONTROL);
 672
 673                 const IObjectManager::ESelectOp selectOp = bUnselect ? IObjectManager::ESelectOp::eUnselect :
 674                                                            (bToggle ? IObjectManager::ESelectOp::eToggle : IObjectManager::ESelectOp::eSelect);
 675
 676                 CRect selectRect = view->GetSelectionRectangle();
 677                 if (!selectRect.IsRectEmpty())
 678                 {
 679                         // Ignore too small rectangles.
 680                         if (selectRect.Width() > 5 && selectRect.Height() > 5)
 681                         {
 682                                 GetIEditor()->GetObjectManager()->SelectObjectsInRect(view, selectRect, selectOp);
 683                         }
 684                 }
 685
 686                 if (GetIEditor()->GetLevelEditorSharedState()->GetEditMode() == CLevelEditorSharedState::EditMode::SelectArea)
 687                 {
 688                         GetIEditor()->ClearSelection();
 689                 }
 690         }
 691
 692         // If command mode is still "NothingMode" this object was just created and placed and needs this update too.
 693         if (GetCommandMode() == ScaleMode || GetCommandMode() == MoveMode || GetCommandMode() == RotateMode || GetCommandMode() == NothingMode)
 694         {
 695                 m_suspendHighlightChange = false;
 696                 GetIEditor()->GetISelectionGroup()->ObjectModified();
 697         }
 698
 699         if (GetIEditor()->GetLevelEditorSharedState()->GetEditMode() != CLevelEditorSharedState::EditMode::SelectArea)
 700         {
 701                 view->ResetSelectionRegion();
 702         }
 703         // Reset selected rectangle.
 704         view->SetSelectionRectangle(CPoint(0, 0), CPoint(0, 0));
 705
 706         SetCommandMode(NothingMode);
 707
 708         return true;
 709 }
 710
 711 //////////////////////////////////////////////////////////////////////////
 712 bool CObjectMode::OnLButtonDblClk(CViewport* view, int nFlags, CPoint point)
 713 {
 714         // If shift clicked, Move the camera to this place.
 715         if (nFlags & MK_SHIFT)
 716         {
 717                 // Get the heightmap coordinates for the click position
 718                 Vec3 v = view->ViewToWorld(point);
 719                 if (!(v.x == 0 && v.y == 0 && v.z == 0))
 720                 {
 721                         Matrix34 tm = view->GetViewTM();
 722                         Vec3 p = tm.GetTranslation();
 723                         float height = p.z - GetIEditor()->GetTerrainElevation(p.x, p.y);
 724                         if (height < 1) height = 1;
 725                         p.x = v.x;
 726                         p.y = v.y;
 727                         p.z = GetIEditor()->GetTerrainElevation(p.x, p.y) + height;
 728                         tm.SetTranslation(p);
 729                         view->SetViewTM(tm);
 730                 }
 731         }
 732         else
 733         {
 734                 // Check if double clicked on object.
 735                 HitContext hitInfo;
 736                 view->HitTest(point, hitInfo);
 737
 738                 CBaseObject* hitObj = hitInfo.object;
 739                 if (hitObj)
 740                 {
 741                         // Fire double click event on hit object.
 742                         hitObj->OnEvent(EVENT_DBLCLICK);
 743                 }
 744         }
 745         return true;
 746 }
 747
 748 //////////////////////////////////////////////////////////////////////////
 749 bool CObjectMode::OnRButtonDown(CViewport* view, int nFlags, CPoint point)
 750 {
 751         if (gViewportPreferences.enableContextMenu)
 752         {
 753                 // Check if right clicked on object.
 754                 HitContext hitInfo;
 755                 if (view->HitTest(point, hitInfo) && hitInfo.object)
 756                 {
 757                         m_openContext = true;
 758                         m_rMouseDownPos = point;
 759                         return true;
 760                 }
 761         }
 762         return false;
 763 }
 764
 765 //////////////////////////////////////////////////////////////////////////
 766 bool CObjectMode::OnRButtonUp(CViewport* view, int nFlags, CPoint point)
 767 {
 768         if (m_openContext)
 769         {
 770                 m_openContext = false;
 771
 772                 // check if we are close to the original mouse position
 773                 int halfLength = gViewportPreferences.dragSquareSize / 2;
 774                 CRect rcDrag(m_rMouseDownPos.x, m_rMouseDownPos.y, m_rMouseDownPos.x, m_rMouseDownPos.y);
 775                 InflateRect(rcDrag, halfLength, halfLength);
 776
 777                 if (!PtInRect(rcDrag, point))
 778                         return false;
 779
 780                 // Check if right clicked on object.
 781                 HitContext hitInfo;
 782                 if (!view->HitTest(point, hitInfo))
 783                         return false;
 784                 if (!hitInfo.object)
 785                         return false;
 786
 787                 CDynamicPopupMenu menu;
 788                 hitInfo.object->OnContextMenu(&menu.GetRoot());
 789
 790                 if (!menu.GetRoot().Empty())
 791                 {
 792                         // suspend highlight change for the duration of the popup...
 793                         m_suspendHighlightChange = true;
 794
 795                         // and resume on close
 796                         menu.SetOnHideFunctor([ = ]
 797                         {
 798                                 if (GetIEditor()->GetLevelEditorSharedState()->GetEditTool() == this)
 799                                 {
 800                                   AllowHighlightChange();
 801                                 }
 802                         });
 803                         menu.SpawnAtCursor();
 804                 }
 805                 return true;
 806         }
 807         return false;
 808 }
 809
 810 //////////////////////////////////////////////////////////////////////////
 811 bool CObjectMode::OnMButtonDown(CViewport* view, int nFlags, CPoint point)
 812 {
 813         if (GetIEditor()->GetGameEngine()->GetSimulationMode())
 814         {
 815                 // Get control key status.
 816                 const bool bAltClick = (nFlags & MK_ALT);
 817                 const bool bCtrlClick = (nFlags & MK_CONTROL);
 818                 const bool bShiftClick = (nFlags & MK_SHIFT);
 819
 820                 if (bCtrlClick)
 821                 {
 822                         // In simulation mode awake objects under the cursor when Ctrl+MButton pressed.
 823                         AwakeObjectAtPoint(view, point);
 824                         return true;
 825                 }
 826         }
 827         return false;
 828 }
 829
 830 //////////////////////////////////////////////////////////////////////////
 831 void CObjectMode::AwakeObjectAtPoint(CViewport* view, CPoint point)
 832 {
 833         // In simulation mode awake objects under the cursor.
 834         // Check if double clicked on object.
 835         HitContext hitInfo;
 836         view->HitTest(point, hitInfo);
 837         CBaseObject* hitObj = hitInfo.object;
 838         if (hitObj)
 839         {
 840                 IPhysicalEntity* pent = hitObj->GetCollisionEntity();
 841                 if (pent)
 842                 {
 843                         pe_action_awake pa;
 844                         pa.bAwake = true;
 845                         pent->Action(&pa);
 846                 }
 847         }
 848 }
 849
 850 //////////////////////////////////////////////////////////////////////////
 851 bool CObjectMode::CheckVirtualKey(int virtualKey)
 852 {
 853         GetAsyncKeyState(virtualKey);
 854         if (GetAsyncKeyState(virtualKey))
 855                 return true;
 856         return false;
 857 }
 858
 859 //////////////////////////////////////////////////////////////////////////
 860 void CObjectMode::MoveSelectionToPos(CViewport* view, Vec3& pos, bool align, const CPoint& point)
 861 {
 862         view->BeginUndo();
 863         // Find center of selection.
 864         const ISelectionGroup* pSelection = GetIEditor()->GetISelectionGroup();
 865         Vec3 center = pSelection->GetCenter();
 866         pSelection->Move(pos - center, ISelectionGroup::eMS_None, point, true);
 867
 868         if (align)
 869                 GetIEditor()->GetISelectionGroup()->Align();
 870
 871         view->AcceptUndo("Move Selection");
 872 }
 873
 874 //////////////////////////////////////////////////////////////////////////
 875 bool CObjectMode::OnMouseMove(CViewport* view, int nFlags, CPoint point)
 876 {
 877         if (GetIEditor()->IsInGameMode())
 878         {
 879                 // Ignore while in game.
 880                 return true;
 881         }
 882         const bool bAltClick = (nFlags & MK_ALT);
 883         const bool bCtrlClick = (nFlags & MK_CONTROL);
 884         const bool bShiftClick = (nFlags & MK_SHIFT);
 885
 886         bool bSomethingDone = false;
 887
 888         bool bAdding = false;
 889         bool bRemoving = false;
 890
 891         m_openContext = false;
 892
 893         // get current axis constrains.
 894         if (GetCommandMode() == MoveMode)
 895         {
 896                 if (!m_bDragThresholdExceeded)
 897                 {
 898                         int halfLength = gViewportPreferences.dragSquareSize / 2;
 899                         CRect rcDrag(m_cMouseDownPos.x, m_cMouseDownPos.y, m_cMouseDownPos.x, m_cMouseDownPos.y);
 900                         InflateRect(rcDrag, halfLength, halfLength);
 901
 902                         if (!PtInRect(rcDrag, point))
 903                         {
 904                                 // Save the current positions, move tool relies on them - change from relying on undo system.
 905                                 GetIEditor()->GetISelectionGroup()->FilterParents();
 906                                 GetIEditor()->GetISelectionGroup()->SaveFilteredTransform();
 907                         }
 908                         else
 909                         {
 910                                 return true;
 911                         }
 912                 }
 913
 914                 Vec3 v;
 915                 Vec3 p1 = m_mouseDownWorldPos;
 916                 if (gSnappingPreferences.IsSnapToTerrainEnabled() && GetIEditor()->GetLevelEditorSharedState()->GetAxisConstraint() != CLevelEditorSharedState::Axis::Z)
 917                 {
 918                         Vec3 p2 = view->SnapToGrid(view->ViewToWorld(point));
 919                         v = view->GetCPVector(p1, p2);
 920                         v.z = 0;
 921                 }
 922                 else
 923                 {
 924                         Vec3 p2 = view->MapViewToCP(point);
 925                         if (p1.IsZero() || p2.IsZero())
 926                                 return true;
 927
 928                         v = view->GetCPVector(p1, p2);
 929                 }
 930
 931                 int selectionFlags = ISelectionGroup::eMS_None;
 932                 if (gSnappingPreferences.IsSnapToTerrainEnabled() && GetIEditor()->GetLevelEditorSharedState()->GetAxisConstraint() != CLevelEditorSharedState::Axis::Z)
 933                         selectionFlags = ISelectionGroup::eMS_FollowTerrain;
 934
 935                 if (gSnappingPreferences.IsSnapToGeometryEnabled())
 936                         selectionFlags |= ISelectionGroup::eMS_FollowGeometry;
 937
 938                 if (gSnappingPreferences.IsSnapToNormalEnabled())
 939                         selectionFlags |= ISelectionGroup::eMS_SnapToNormal;
 940
 941                 if ((nFlags & MK_CONTROL) && !(nFlags & MK_SHIFT))
 942                         selectionFlags = ISelectionGroup::eMS_FollowGeometry | ISelectionGroup::eMS_SnapToNormal;
 943
 944                 if (!v.IsEquivalent(Vec3(0, 0, 0)))
 945                         m_bTransformChanged = true;
 946
 947 #pragma message("TODO")
 948                 //CTrackViewSequenceNoNotificationContext context(pSequence);
 949
 950                 if (m_bDragThresholdExceeded)
 951                 {
 952                         // All moved objects should have pushed an undo after moving, so suspend here
 953                         // if we don't we'll end up with a huge undo step with duplicate entries for the objects.
 954                         // TODO: improve undo system to only push when really necessary.
 955                         GetIEditor()->GetIUndoManager()->Suspend();
 956                 }
 957
 958                 GetIEditor()->GetISelectionGroup()->Move(v, selectionFlags, point, true);
 959
 960                 if (m_bDragThresholdExceeded)
 961                 {
 962                         GetIEditor()->GetIUndoManager()->Resume();
 963                 }
 964
 965                 m_bDragThresholdExceeded = true;
 966                 bSomethingDone = true;
 967         }
 968         else if (GetCommandMode() == RotateMode)
 969         {
 970                 GetIEditor()->GetIUndoManager()->Restore();
 971
 972                 Ang3 ang(0, 0, 0);
 973                 float ax = point.x - m_cMouseDownPos.x;
 974                 float ay = point.y - m_cMouseDownPos.y;
 975                 switch (GetIEditor()->GetLevelEditorSharedState()->GetAxisConstraint())
 976                 {
 977                 case CLevelEditorSharedState::Axis::X:
 978                         ang.x = ay;
 979                         break;
 980                 case CLevelEditorSharedState::Axis::Y:
 981                         ang.y = ay;
 982                         break;
 983                 case CLevelEditorSharedState::Axis::Z:
 984                         ang.z = ay;
 985                         break;
 986                 case CLevelEditorSharedState::Axis::XY:
 987                         ang(ax, ay, 0);
 988                         break;
 989                 case CLevelEditorSharedState::Axis::XZ:
 990                         ang(ax, 0, ay);
 991                         break;
 992                 case CLevelEditorSharedState::Axis::YZ:
 993                         ang(0, ay, ax);
 994                         break;
 995                 }
 996                 ;
 997
 998                 ang = gSnappingPreferences.SnapAngle(ang);
 999
1000                 if (!ang.IsEquivalent(Ang3(0, 0, 0)))
1001                         m_bTransformChanged = true;
1002
1003                 //m_cMouseDownPos = point;
1004                 GetIEditor()->GetISelectionGroup()->Rotate(ang);
1005                 bSomethingDone = true;
1006         }
1007         else if (GetCommandMode() == ScaleMode)
1008         {
1009                 Vec3 scale;
1010
1011                 GetScale(view, point, scale);
1012
1013                 if (!m_bTransformChanged)
1014                 {
1015                         if (!scale.IsEquivalent(Vec3(0, 0, 0)))
1016                         {
1017                                 // Save the current positions, scale tool relies on them - change from relying on undo system.
1018                                 GetIEditor()->GetISelectionGroup()->FilterParents();
1019                                 GetIEditor()->GetISelectionGroup()->SaveFilteredTransform();
1020                         }
1021                         else
1022                         {
1023                                 return true;
1024                         }
1025                 }
1026
1027                 if (m_bTransformChanged)
1028                 {
1029                         GetIEditor()->GetIUndoManager()->Suspend();
1030                 }
1031                 GetIEditor()->GetISelectionGroup()->Scale(scale);
1032                 if (m_bTransformChanged)
1033                 {
1034                         GetIEditor()->GetIUndoManager()->Resume();
1035                 }
1036                 m_bTransformChanged = true;
1037                 bSomethingDone = true;
1038         }
1039         else if (GetCommandMode() == SelectMode)
1040         {
1041                 // Ignore select when selection locked.
1042                 if (GetIEditor()->IsSelectionLocked())
1043                         return true;
1044
1045                 if (bShiftClick)
1046                 {
1047                         bAdding = true;
1048                 }
1049                 else if (bAltClick)
1050                 {
1051                         bRemoving = true;
1052                 }
1053
1054                 CRect rc(m_cMouseDownPos, point);
1055                 if (GetIEditor()->GetLevelEditorSharedState()->GetEditMode() == CLevelEditorSharedState::EditMode::SelectArea)
1056                 {
1057                         view->OnDragSelectRectangle(CPoint(rc.left, rc.top), CPoint(rc.right, rc.bottom), false);
1058                 }
1059                 else
1060                 {
1061                         view->SetSelectionRectangle(rc.TopLeft(), rc.BottomRight());
1062                 }
1063                 //else
1064                 //OnDragSelectRectangle( CPoint(rc.left,rc.top),CPoint(rc.right,rc.bottom),true );
1065
1066                 bSomethingDone = true;
1067         }
1068
1069         if (!(nFlags & MK_RBUTTON || nFlags & MK_MBUTTON))
1070         {
1071                 const IObjectManager::ESelectOp selectOp = bAdding ? IObjectManager::ESelectOp::eSelect :
1072                                                            (bRemoving ? IObjectManager::ESelectOp::eUnselect : IObjectManager::ESelectOp::eNone);
1073
1074                 // Track mouse movements.
1075                 CGizmo* highlightedGizmo = GetIEditor()->GetGizmoManager()->GetHighlightedGizmo();
1076
1077                 HitContext hitInfo;
1078                 if (!highlightedGizmo && view->HitTest(point, hitInfo))
1079                 {
1080                         SetObjectCursor(view, hitInfo.object, selectOp);
1081                 }
1082                 else
1083                 {
1084                         SetObjectCursor(view, nullptr, selectOp);
1085                 }
1086
1087                 HandleMoveByFaceNormal(hitInfo);
1088         }
1089         else
1090         {
1091                 // pan/rotate case
1092                 SetObjectCursor(view, nullptr, IObjectManager::ESelectOp::eNone);
1093         }
1094
1095         if ((nFlags & MK_MBUTTON) && GetIEditor()->GetGameEngine()->GetSimulationMode())
1096         {
1097                 // Get control key status.
1098                 if (bCtrlClick)
1099                 {
1100                         // In simulation mode awake objects under the cursor when Ctrl+MButton pressed.
1101                         AwakeObjectAtPoint(view, point);
1102                 }
1103         }
1104
1105         return bSomethingDone;
1106 }
1107
1108 //////////////////////////////////////////////////////////////////////////
1109 void CObjectMode::SetObjectCursor(CViewport* view, CBaseObject* hitObj, IObjectManager::ESelectOp selectMode)
1110 {
1111         EStdCursor cursor = STD_CURSOR_DEFAULT;
1112         string m_cursorStr;
1113
1114         CBaseObject* pMouseOverObject = NULL;
1115         if (m_MouseOverObject != CryGUID::Null() && !m_suspendHighlightChange)
1116         {
1117                 pMouseOverObject = GetIEditor()->GetObjectManager()->FindObject(m_MouseOverObject);
1118         }
1119
1120         //HCURSOR hPrevCursor = m_hCurrCursor;
1121         if (pMouseOverObject)
1122         {
1123                 pMouseOverObject->SetHighlight(false);
1124         }
1125
1126         if (!m_suspendHighlightChange)
1127         {
1128                 if (hitObj)
1129                         m_MouseOverObject = hitObj->GetId();
1130                 else
1131                         m_MouseOverObject = CryGUID::Null();
1132                 pMouseOverObject = hitObj;
1133         }
1134
1135         bool bHitSelectedObject = false;
1136         if (pMouseOverObject)
1137         {
1138                 if (GetCommandMode() != SelectMode && !GetIEditor()->IsSelectionLocked())
1139                 {
1140                         if (pMouseOverObject->CanBeHightlighted() && GetIEditor()->IsHelpersDisplayed())
1141                                 pMouseOverObject->SetHighlight(true);
1142
1143                         m_cursorStr = pMouseOverObject->GetName();
1144
1145                         string comment(pMouseOverObject->GetComment());
1146                         if (!comment.IsEmpty())
1147                         {
1148                                 m_cursorStr += "\n";
1149                                 m_cursorStr += comment;
1150                         }
1151
1152                         if (gViewportDebugPreferences.showMeshStatsOnMouseOver)
1153                         {
1154                                 const string triangleCountText = pMouseOverObject->GetMouseOverStatisticsText();
1155
1156                                 if (!triangleCountText.IsEmpty())
1157                                 {
1158                                         m_cursorStr += triangleCountText;
1159                                 }
1160                         }
1161
1162                         string warnings(pMouseOverObject->GetWarningsText());
1163                         if (!warnings.IsEmpty())
1164                         {
1165                                 m_cursorStr += warnings;
1166                         }
1167
1168                         cursor = STD_CURSOR_HIT;
1169                         if (pMouseOverObject->IsSelected())
1170                                 bHitSelectedObject = true;
1171                 }
1172         }
1173         else
1174         {
1175                 m_cursorStr = "";
1176                 cursor = STD_CURSOR_DEFAULT;
1177         }
1178
1179         const bool bAddSelect = (selectMode == IObjectManager::ESelectOp::eSelect);
1180         const bool bUnselect = (selectMode == IObjectManager::ESelectOp::eUnselect);
1181         const bool bNoRemoveSelection = bAddSelect || bUnselect;
1182
1183         bool bLockSelection = GetIEditor()->IsSelectionLocked();
1184
1185         if (GetCommandMode() == SelectMode || GetCommandMode() == NothingMode)
1186         {
1187                 if (bAddSelect)
1188                         cursor = STD_CURSOR_SEL_PLUS;
1189                 if (bUnselect)
1190                         cursor = STD_CURSOR_SEL_MINUS;
1191
1192                 if ((bHitSelectedObject && !bNoRemoveSelection) || bLockSelection)
1193                 {
1194                         CLevelEditorSharedState::EditMode editMode = GetIEditor()->GetLevelEditorSharedState()->GetEditMode();
1195                         if (editMode == CLevelEditorSharedState::EditMode::Move)
1196                         {
1197                                 cursor = STD_CURSOR_MOVE;
1198                         }
1199                         else if (editMode == CLevelEditorSharedState::EditMode::Rotate)
1200                         {
1201                                 cursor = STD_CURSOR_ROTATE;
1202                         }
1203                         else if (editMode == CLevelEditorSharedState::EditMode::Scale)
1204                         {
1205                                 cursor = STD_CURSOR_SCALE;
1206                         }
1207                 }
1208         }
1209         else if (GetCommandMode() == MoveMode)
1210         {
1211                 cursor = STD_CURSOR_MOVE;
1212         }
1213         else if (GetCommandMode() == RotateMode)
1214         {
1215                 cursor = STD_CURSOR_ROTATE;
1216         }
1217         else if (GetCommandMode() == ScaleMode)
1218         {
1219                 cursor = STD_CURSOR_SCALE;
1220         }
1221
1222         view->SetCurrentCursor(cursor, m_cursorStr);
1223 }
1224
1225 //////////////////////////////////////////////////////////////////////////
1226 // Class description.
1227 //////////////////////////////////////////////////////////////////////////
1228 class CObjectMode_ClassDesc : public IClassDesc
1229 {
1230         //! This method returns an Editor defined GUID describing the class this plugin class is associated with.
1231         virtual ESystemClassID SystemClassID() { return ESYSTEM_CLASS_EDITTOOL; }
1232
1233         //! This method returns the human readable name of the class.
1234         virtual const char* ClassName() { return "EditTool.ObjectMode"; };
1235
1236         //! This method returns Category of this class, Category is specifing where this plugin class fits best in
1237         //! create panel.
1238         virtual const char*    Category()        { return "Select"; };
1239         virtual CRuntimeClass* GetRuntimeClass() { return RUNTIME_CLASS(CObjectMode); }
1240         //////////////////////////////////////////////////////////////////////////
1241 };
1242
1243 REGISTER_CLASS_DESC(CObjectMode_ClassDesc);
1244
1245 //////////////////////////////////////////////////////////////////////////
1246 void CObjectMode::CheckDeepSelection(HitContext& hitContext, CViewport* pWnd)
1247 {
1248         if (hitContext.pDeepSelection)
1249         {
1250                 m_pDeepSelection->CollectCandidate(hitContext.dist, gDeepSelectionPreferences.deepSelectionRange);
1251         }
1252
1253         if (m_pDeepSelection->GetCandidateObjectCount() > 1)
1254         {
1255                 // Deep Selection Pop Mode
1256                 if (m_pDeepSelection->GetMode() == CDeepSelection::DSM_POP)
1257                 {
1258                         CMenu popUpDeepSelect;
1259                         popUpDeepSelect.CreatePopupMenu();
1260
1261                         for (int i = 0; i < m_pDeepSelection->GetCandidateObjectCount(); ++i)
1262                         {
1263                                 popUpDeepSelect.AppendMenu(MF_STRING, i + 1, m_pDeepSelection->GetCandidateObject(i)->GetName());
1264                         }
1265
1266                         CPoint p;
1267                         ::GetCursorPos(&p);
1268                         int nSelect = popUpDeepSelect.TrackPopupMenu(TPM_NONOTIFY | TPM_RETURNCMD | TPM_CENTERALIGN, p.x, p.y, CWnd::FromHandle((HWND)pWnd->GetSafeHwnd()), NULL);
1269
1270                         if (nSelect > 0)
1271                         {
1272                                 // Update HitContext hitInfo.
1273                                 hitContext.object = m_pDeepSelection->GetCandidateObject(nSelect - 1);
1274                                 m_pDeepSelection->ExcludeHitTest(nSelect - 1);
1275                         }
1276                 }
1277                 else if (m_pDeepSelection->GetMode() == CDeepSelection::DSM_CYCLE)
1278                 {
1279                         int selPos = m_pDeepSelection->GetCurrentSelectPos();
1280                         hitContext.object = m_pDeepSelection->GetCandidateObject(selPos + 1);
1281                         m_pDeepSelection->ExcludeHitTest(selPos + 1);
1282                 }
1283         }
1284 }
1285
1286 Vec3& CObjectMode::GetScale(const CViewport* view, const CPoint& point, Vec3& OutScale)
1287 {
1288         float ay = 1.0f - 0.01f * (point.y - m_cMouseDownPos.y);
1289
1290         if (ay < 0.01f) ay = 0.01f;
1291
1292         Vec3 scl(ay, ay, ay);
1293
1294         CLevelEditorSharedState::Axis axisConstraint = GetIEditor()->GetLevelEditorSharedState()->GetAxisConstraint();
1295
1296         switch (axisConstraint)
1297         {
1298         case CLevelEditorSharedState::Axis::X:
1299                 scl(ay, 1, 1);
1300                 break;
1301         case CLevelEditorSharedState::Axis::Y:
1302                 scl(1, ay, 1);
1303                 break;
1304         case CLevelEditorSharedState::Axis::Z:
1305                 scl(1, 1, ay);
1306                 break;
1307         case CLevelEditorSharedState::Axis::XY:
1308                 scl(ay, ay, ay);
1309                 break;
1310         case CLevelEditorSharedState::Axis::XZ:
1311                 scl(ay, ay, ay);
1312                 break;
1313         case CLevelEditorSharedState::Axis::YZ:
1314                 scl(ay, ay, ay);
1315                 break;
1316         case CLevelEditorSharedState::Axis::XYZ:
1317                 scl(ay, ay, ay);
1318                 break;
1319         }
1320         ;
1321
1322         if (gSnappingPreferences.IsSnapToTerrainEnabled())
1323                 scl(ay, ay, ay);
1324
1325         OutScale = scl;
1326
1327         return OutScale;
1328 }
1329
1330 void CObjectMode::OnManipulatorBeginDrag(IDisplayViewport* view, ITransformManipulator* pManipulator, const Vec2i& point, int flags)
1331 {
1332         m_cMouseDownPos = CPoint(point.x, point.y);
1333         m_bGizmoDrag = true;
1334         CLevelEditorSharedState::EditMode editMode = GetIEditor()->GetLevelEditorSharedState()->GetEditMode();
1335
1336         if (editMode == CLevelEditorSharedState::EditMode::Scale || editMode == CLevelEditorSharedState::EditMode::Move)
1337         {
1338                 const ISelectionGroup* pSelection = GetIEditor()->GetISelectionGroup();
1339                 pSelection->FilterParents();
1340                 pSelection->SaveFilteredTransform();
1341
1342                 // Hack: Only for move mode, set the command mode to move, so that grid shows up in the viewport
1343                 if (editMode == CLevelEditorSharedState::EditMode::Move)
1344                 {
1345                         m_bDragThresholdExceeded = false;
1346                 }
1347         }
1348
1349         if (editMode == CLevelEditorSharedState::EditMode::Move)
1350         {
1351                 m_commandMode = MoveMode;
1352         }
1353         else if (editMode == CLevelEditorSharedState::EditMode::Scale)
1354         {
1355                 m_commandMode = ScaleMode;
1356         }
1357         else if (editMode == CLevelEditorSharedState::EditMode::Rotate)
1358         {
1359                 m_commandMode = RotateMode;
1360         }
1361
1362         ((CViewport*)view)->DegradateQuality(true);
1363 }
1364
1365 void CObjectMode::OnManipulatorEndDrag(IDisplayViewport* view, ITransformManipulator* pManipulator)
1366 {
1367         if (m_commandMode == ScaleMode || m_commandMode == MoveMode)
1368         {
1369                 if (m_bDragThresholdExceeded)
1370                 {
1371                         const ISelectionGroup* pSelection = GetIEditor()->GetISelectionGroup();
1372                         pSelection->FinishChanges();
1373                         m_bDragThresholdExceeded = false;
1374                 }
1375         }
1376         m_commandMode = NothingMode;
1377         m_bGizmoDrag = false;
1378
1379         ((CViewport*)view)->DegradateQuality(false);
1380         GetIEditor()->UpdateViews(eUpdateObjects);
1381 }
1382
1383 //////////////////////////////////////////////////////////////////////////
1384 // This callback is currently called only to handle the case of the 'move by the face normal'.
1385 // Other movements of the object are handled in the 'CObjectMode::OnMouseMove()' method.
1386 void CObjectMode::OnManipulatorDrag(IDisplayViewport* view, ITransformManipulator* pManipulator, const Vec2i& point, const Vec3& value, int flags)
1387 {
1388         CPoint p(point.x, point.y);
1389
1390         if (m_commandMode == MoveMode)
1391         {
1392                 int halfLength = gViewportPreferences.dragSquareSize / 2;
1393                 CRect rcDrag(m_cMouseDownPos.x, m_cMouseDownPos.y, m_cMouseDownPos.x, m_cMouseDownPos.y);
1394                 InflateRect(rcDrag, halfLength, halfLength);
1395
1396                 if (PtInRect(rcDrag, p))
1397                 {
1398                         return;
1399                 }
1400
1401                 const ISelectionGroup* pSelection = GetIEditor()->GetISelectionGroup();
1402
1403                 if (m_bDragThresholdExceeded)
1404                 {
1405                         // All moved objects should have pushed an undo after moving, so suspend here
1406                         // if we don't we'll end up with a huge undo step with duplicate entries for the objects.
1407                         // TODO: improve undo system to only push when really necessary.
1408                         GetIEditor()->GetIUndoManager()->Suspend();
1409                 }
1410
1411                 int selectionFlags = ISelectionGroup::eMS_None;
1412                 if (gSnappingPreferences.IsSnapToTerrainEnabled())
1413                         selectionFlags = ISelectionGroup::eMS_FollowTerrain;
1414
1415                 if (gSnappingPreferences.IsSnapToNormalEnabled())
1416                         selectionFlags |= ISelectionGroup::eMS_SnapToNormal;
1417
1418                 pSelection->Move(value, selectionFlags, p, true);
1419
1420                 if (m_pHitObject)
1421                         UpdateMoveByFaceNormGizmo(m_pHitObject);
1422
1423                 if (m_bDragThresholdExceeded)
1424                 {
1425                         GetIEditor()->GetIUndoManager()->Resume();
1426                 }
1427                 m_bDragThresholdExceeded = true;
1428         }
1429         else if (m_commandMode == RotateMode)
1430         {
1431                 GetIEditor()->GetIUndoManager()->Restore();
1432                 const ISelectionGroup* pSelection = GetIEditor()->GetISelectionGroup();
1433
1434                 // unfortunately more conversion to fit selectiongroup format
1435                 Ang3 angles = RAD2DEG(-value);
1436                 pSelection->Rotate(angles);
1437         }
1438         else if (m_commandMode == ScaleMode)
1439         {
1440                 const ISelectionGroup* pSelection = GetIEditor()->GetISelectionGroup();
1441                 pSelection->Scale(value);
1442                 m_bDragThresholdExceeded = true;
1443         }
1444 }
1445
1446 void CObjectMode::HandleMoveByFaceNormal(HitContext& hitInfo)
1447 {
1448         CBaseObject* pHitObject = hitInfo.object;
1449         bool bFaceNormalMovePossible = pHitObject && GetIEditor()->GetLevelEditorSharedState()->GetEditMode() == CLevelEditorSharedState::EditMode::Move
1450                                        && (pHitObject->GetType() == OBJTYPE_SOLID || pHitObject->GetType() == OBJTYPE_BRUSH)
1451                                        && pHitObject->IsSelected();
1452         bool bNKeyPressed = CheckVirtualKey('N');
1453         if (bFaceNormalMovePossible && bNKeyPressed)
1454         {
1455                 // Test a hit for its faces.
1456                 hitInfo.nSubObjFlags = SO_HIT_POINT | SO_HIT_SELECT | SO_HIT_NO_EDIT | SO_HIT_ELEM_FACE;
1457                 pHitObject->SetFlags(OBJFLAG_SUBOBJ_EDITING);
1458                 pHitObject->HitTest(hitInfo);
1459                 pHitObject->ClearFlags(OBJFLAG_SUBOBJ_EDITING);
1460
1461                 UpdateMoveByFaceNormGizmo(pHitObject);
1462         }
1463         else if (m_bMoveByFaceNormManipShown && !bNKeyPressed)
1464         {
1465                 HideMoveByFaceNormGizmo();
1466         }
1467 }
1468
1469 void CObjectMode::UpdateMoveByFaceNormGizmo(CBaseObject* pHitObject)
1470 {
1471         Matrix34 refFrame;
1472         refFrame.SetIdentity();
1473         SubObjectSelectionReferenceFrameCalculator calculator(SO_ELEM_FACE);
1474         pHitObject->CalculateSubObjectSelectionReferenceFrame(&calculator);
1475         if (calculator.GetFrame(refFrame) == false)
1476         {
1477                 HideMoveByFaceNormGizmo();
1478         }
1479         else
1480         {
1481                 if (!m_normalMoveGizmo)
1482                 {
1483                         m_normalMoveGizmo = GetIEditor()->GetGizmoManager()->AddManipulator(&m_normalGizmoOwner);
1484                 }
1485                 m_bMoveByFaceNormManipShown = true;
1486                 m_pHitObject = pHitObject;
1487                 m_normalMoveGizmo->SetCustomTransform(true, refFrame);
1488         }
1489 }
1490
1491 void CObjectMode::HideMoveByFaceNormGizmo()
1492 {
1493         if (m_normalMoveGizmo)
1494         {
1495                 m_normalMoveGizmo->signalBeginDrag.DisconnectAll();
1496                 m_normalMoveGizmo->signalDragging.DisconnectAll();
1497                 m_normalMoveGizmo->signalEndDrag.DisconnectAll();
1498                 GetIEditor()->GetGizmoManager()->RemoveManipulator(m_normalMoveGizmo);
1499                 m_normalMoveGizmo = nullptr;
1500         }
1501         m_bMoveByFaceNormManipShown = false;
1502         m_pHitObject = NULL;
1503 }
1504
1505 // only display the grid when we actually transform something
1506 bool CObjectMode::IsDisplayGrid()
1507 {
1508         return
1509           (!m_bGizmoDrag && m_commandMode != NothingMode)
1510           || (m_commandMode == MoveMode);
1511 }