Code/Sandbox/Plugins/CryDesigner/Tools/Shape/BoxTool.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "BoxTool.h"
   5 #include "DesignerEditor.h"
   6 #include "Tools/Select/SelectTool.h"
   7 #include "Viewport.h"
   8 #include "Util/HeightManipulator.h"
   9 #include "Util/ExtrusionSnappingHelper.h"
  10 #include "ToolFactory.h"
  11 #include "Core/Helper.h"
  12 #include "DesignerSession.h"
  13
  14 namespace Designer
  15 {
  16 void BoxTool::Serialize(Serialization::IArchive& ar)
  17 {
  18         __super::Serialize(ar);
  19         m_BoxParameter.Serialize(ar);
  20 }
  21
  22 void BoxTool::OnLButtonDownAboutPlaceStartingPointPhase(CViewport* view, UINT nFlags, CPoint point)
  23 {
  24         __super::OnLButtonDownAboutPlaceStartingPointPhase(view, nFlags, point);
  25
  26         StoreSeparateStatus();
  27         m_BoxParameter.m_Height = 0;
  28         s_SnappingHelper.Init(GetModel());
  29 }
  30
  31 bool BoxTool::OnLButtonDown(CViewport* view, UINT nFlags, CPoint point)
  32 {
  33         __super::OnLButtonDown(view, nFlags, point);
  34
  35         if (m_Phase == eBoxPhase_RaiseHeight)
  36                 m_Phase = eBoxPhase_Done;
  37
  38         return true;
  39 }
  40
  41 bool BoxTool::OnLButtonUp(CViewport* view, UINT nFlags, CPoint point)
  42 {
  43         if (m_Phase == eBoxPhase_DrawRectangle)
  44         {
  45                 if (std::abs(GetCurrentSpotPos().x - GetStartSpotPos().x) > (BrushFloat)0.01 ||
  46                     std::abs(GetCurrentSpotPos().y - GetStartSpotPos().y) > (BrushFloat)0.01 ||
  47                     std::abs(GetCurrentSpotPos().z - GetStartSpotPos().z) > (BrushFloat)0.01)
  48                 {
  49                         m_Phase = eBoxPhase_RaiseHeight;
  50                         s_SnappingHelper.SearchForOppositePolygons(m_pCapPolygon);
  51                         m_pCapPolygon = NULL;
  52                         m_bIsOverOpposite = false;
  53                         s_HeightManipulator.Init(GetPlane(), GetCurrentSpotPos());
  54                 }
  55         }
  56
  57         return true;
  58 }
  59
  60 bool BoxTool::OnMouseMove(CViewport* view, UINT nFlags, CPoint point)
  61 {
  62         __super::OnMouseMove(view, nFlags, point);
  63
  64         if (m_Phase == eBoxPhase_RaiseHeight)
  65         {
  66                 m_BoxParameter.m_Height = (float)s_HeightManipulator.Update(GetWorldTM(), view, GetDesigner()->GetRay());
  67
  68                 if (m_BoxParameter.m_Height < (float)kInitialPrimitiveHeight)
  69                         m_BoxParameter.m_Height = 0;
  70
  71                 if (m_BoxParameter.m_bAlignment)
  72                 {
  73                         PolygonPtr pAlignedPolygon = s_SnappingHelper.FindAlignedPolygon(m_pCapPolygon, GetWorldTM(), view, point);
  74                         if (pAlignedPolygon)
  75                                 m_BoxParameter.m_Height = (float)(GetPlane().Distance() - pAlignedPolygon->GetPlane().Distance());
  76                 }
  77
  78                 UpdateShapeWithBoundaryCheck();
  79         }
  80
  81         return true;
  82 }
  83
  84 void BoxTool::UpdateShapeWithBoundaryCheck(bool bUpdateUIs)
  85 {
  86         UpdateShape(bUpdateUIs);
  87         m_bIsOverOpposite = m_pCapPolygon && s_SnappingHelper.IsOverOppositePolygon(m_pCapPolygon, ePP_Pull);
  88         if (m_bIsOverOpposite)
  89         {
  90                 m_BoxParameter.m_Height = (float)s_SnappingHelper.GetNearestDistanceToOpposite(ePP_Pull);
  91                 UpdateShape(bUpdateUIs);
  92         }
  93 }
  94
  95 void BoxTool::UpdateShape(bool bUpdateUIs)
  96 {
  97         std::vector<PolygonPtr> polygonList;
  98
  99         m_v[0] = GetStartSpotPos();
 100         m_v[1] = GetCurrentSpotPos();
 101
 102         BrushVec2 p0 = GetPlane().W2P(m_v[0]);
 103         BrushVec2 p1 = GetPlane().W2P(m_v[1]);
 104
 105         std::vector<BrushVec3> vList(4);
 106         vList[0] = m_v[0];
 107         vList[1] = GetPlane().P2W(BrushVec2(p1.x, p0.y));
 108         vList[2] = m_v[1];
 109         vList[3] = GetPlane().P2W(BrushVec2(p0.x, p1.y));
 110
 111         polygonList.push_back(new Polygon(vList));
 112         if (polygonList[0]->IsOpen())
 113                 return;
 114         if (polygonList[0]->GetPlane().IsSameFacing(GetPlane()))
 115                 polygonList[0]->Flip();
 116
 117         for (int i = 0; i < 4; ++i)
 118                 vList[i] += GetPlane().Normal() * (BrushFloat)m_BoxParameter.m_Height;
 119         polygonList.push_back(new Polygon(vList));
 120         if (!polygonList[1]->GetPlane().IsSameFacing(GetPlane()))
 121                 polygonList[1]->Flip();
 122
 123         for (int i = 0; i < 4; ++i)
 124         {
 125                 BrushEdge3D e = polygonList[0]->GetEdge(i);
 126
 127                 vList[0] = e.m_v[1];
 128                 vList[1] = e.m_v[0];
 129                 vList[2] = e.m_v[0] + GetPlane().Normal() * (BrushFloat)m_BoxParameter.m_Height;
 130                 vList[3] = e.m_v[1] + GetPlane().Normal() * (BrushFloat)m_BoxParameter.m_Height;
 131
 132                 polygonList.push_back(new Polygon(vList));
 133         }
 134
 135         MODEL_SHELF_RECONSTRUCTOR(GetModel());
 136
 137         GetModel()->SetShelf(eShelf_Construction);
 138         GetModel()->Clear();
 139
 140         for (int i = 0, iCount(polygonList.size()); i < iCount; ++i)
 141         {
 142                 if (polygonList[i]->IsOpen())
 143                         continue;
 144
 145                 if (GetStartSpot().m_pPolygon)
 146                 {
 147                         polygonList[i]->SetTexInfo(GetStartSpot().m_pPolygon->GetTexInfo());
 148                         polygonList[i]->SetSubMatID(GetStartSpot().m_pPolygon->GetSubMatID());
 149                 }
 150
 151                 AddPolygonWithSubMatID(polygonList[i]);
 152
 153                 if (Comparison::IsEquivalent(polygonList[i]->GetPlane().Normal(), GetPlane().Normal()))
 154                         m_pCapPolygon = polygonList[i];
 155         }
 156
 157         if (bUpdateUIs)
 158         {
 159                 m_RectangleParameter.m_Width = std::abs(p0.x - p1.x);
 160                 m_RectangleParameter.m_Depth = std::abs(p0.y - p1.y);
 161                 DesignerSession::GetInstance()->signalDesignerEvent(eDesignerNotify_SubtoolOptionChanged, nullptr);
 162         }
 163
 164         ApplyPostProcess(ePostProcess_Mesh | ePostProcess_Mirror | ePostProcess_SmoothingGroup);
 165 }
 166
 167 void BoxTool::Display(SDisplayContext& dc)
 168 {
 169         DisplayCurrentSpot(dc);
 170         DisplayDimensionHelper(dc, eShelf_Construction);
 171         if (GetStartSpot().m_pPolygon)
 172                 DisplayDimensionHelper(dc);
 173         s_HeightManipulator.Display(dc);
 174 }
 175
 176 void BoxTool::Register()
 177 {
 178         RegisterShape(GetStartSpot().m_pPolygon);
 179 }
 180
 181 void BoxTool::RegisterShape(PolygonPtr pFloorPolygon)
 182 {
 183         if (!GetModel() || GetModel()->IsEmpty(eShelf_Construction))
 184                 return;
 185
 186         MODEL_SHELF_RECONSTRUCTOR(GetModel());
 187
 188         if (m_pCapPolygon)
 189         {
 190                 GetModel()->SetShelf(eShelf_Construction);
 191                 if (m_bIsOverOpposite)
 192                 {
 193                         s_SnappingHelper.ApplyOppositePolygons(m_pCapPolygon, ePP_Pull, true);
 194                         GetModel()->RemovePolygon(GetModel()->QueryEquivalentPolygon(m_pCapPolygon));
 195                 }
 196
 197                 if (!IsSeparateStatus())
 198                 {
 199                         std::vector<PolygonPtr> sidePolygons;
 200
 201                         BrushPlane invertedCapPolygonPlane = m_pCapPolygon->GetPlane().GetInverted();
 202                         for (int i = 0, iPolygonCount(GetModel()->GetPolygonCount()); i < iPolygonCount; ++i)
 203                         {
 204                                 PolygonPtr pPolygon = GetModel()->GetPolygon(i);
 205                                 if (pPolygon != m_pCapPolygon && !Comparison::IsEquivalent(invertedCapPolygonPlane.Normal(), pPolygon->GetPlane().Normal()))
 206                                         sidePolygons.push_back(pPolygon);
 207                         }
 208
 209                         std::vector<PolygonPtr> intersectedSidePolygons;
 210                         for (int i = 0, iSidePolygonCount(sidePolygons.size()); i < iSidePolygonCount; ++i)
 211                         {
 212                                 for (int k = 0; k < 2; ++k)
 213                                 {
 214                                         PolygonPtr pSidePolygon = k == 0 ? sidePolygons[i]->Clone()->Flip() : sidePolygons[i];
 215
 216                                         GetModel()->SetShelf(eShelf_Base);
 217                                         bool bHasIntersected = GetModel()->HasIntersection(pSidePolygon, true);
 218                                         bool bTouched = GetModel()->HasTouched(pSidePolygon);
 219                                         if ((!bHasIntersected && !bTouched) || (bTouched && k == 0))
 220                                                 continue;
 221
 222                                         GetModel()->SetShelf(eShelf_Construction);
 223                                         GetModel()->RemovePolygon(sidePolygons[i]);
 224
 225                                         GetModel()->SetShelf(eShelf_Base);
 226                                         if (bHasIntersected)
 227                                         {
 228                                                 GetModel()->AddXORPolygon(pSidePolygon);
 229                                                 intersectedSidePolygons.push_back(pSidePolygon);
 230                                         }
 231                                         else if (bTouched)
 232                                         {
 233                                                 GetModel()->AddUnionPolygon(pSidePolygon);
 234                                         }
 235                                         break;
 236                                 }
 237                         }
 238
 239                         for (int i = 0, iCount(intersectedSidePolygons.size()); i < iCount; ++i)
 240                         {
 241                                 GetModel()->SetShelf(eShelf_Base);
 242                         }
 243                 }
 244         }
 245
 246         __super::RegisterShape(pFloorPolygon);
 247 }
 248
 249 }
 250
 251 REGISTER_DESIGNER_TOOL_WITH_PROPERTYTREE_PANEL_AND_COMMAND(eDesigner_Box, eToolGroup_Shape, "Box", BoxTool,
 252                                                            box, "runs box tool", "designer.box");