1 /*
2  Copyright (C) 2010-2014 Kristian Duske
3 
4  This file is part of TrenchBroom.
5 
6  TrenchBroom is free software: you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation, either version 3 of the License, or
9  (at your option) any later version.
10 
11  TrenchBroom is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  GNU General Public License for more details.
15 
16  You should have received a copy of the GNU General Public License
17  along with TrenchBroom. If not, see <http://www.gnu.org/licenses/>.
18  */
19 
20 #ifndef TrenchBroom_VertexHandleManager
21 #define TrenchBroom_VertexHandleManager
22 
23 #include "TrenchBroom.h"
24 #include "VecMath.h"
25 #include "Model/BrushGeometry.h"
26 #include "Model/Hit.h"
27 #include "Model/ModelTypes.h"
28 #include "Renderer/EdgeRenderer.h"
29 #include "Renderer/PointGuideRenderer.h"
30 #include "View/ViewTypes.h"
31 
32 #include <map>
33 
34 namespace TrenchBroom {
35     namespace Model {
36         class PickResult;
37     }
38 
39     namespace Renderer {
40         class Camera;
41         class RenderBatch;
42         class RenderContext;
43     }
44 
45     namespace View {
46         class VertexHandleManager {
47         public:
48             static const Model::Hit::HitType VertexHandleHit;
49             static const Model::Hit::HitType EdgeHandleHit;
50             static const Model::Hit::HitType FaceHandleHit;
51         private:
52             Model::VertexToBrushesMap m_unselectedVertexHandles;
53             Model::VertexToBrushesMap m_selectedVertexHandles;
54             Model::VertexToEdgesMap m_unselectedEdgeHandles;
55             Model::VertexToEdgesMap m_selectedEdgeHandles;
56             Model::VertexToFacesMap m_unselectedFaceHandles;
57             Model::VertexToFacesMap m_selectedFaceHandles;
58 
59             size_t m_totalVertexCount;
60             size_t m_selectedVertexCount;
61             size_t m_totalEdgeCount;
62             size_t m_selectedEdgeCount;
63             size_t m_totalFaceCount;
64             size_t m_selectedFaceCount;
65 
66             Vec3::List m_unselectedVertexHandlePositions;
67             Vec3::List m_unselectedEdgeHandlePositions;
68             Vec3::List m_unselectedFaceHandlePositions;
69             Vec3::List m_selectedHandlePositions;
70 
71             Vec3f::List m_edgeVertices;
72             Renderer::PointGuideRenderer m_guideRenderer;
73 
74             bool m_renderStateValid;
75         public:
76             VertexHandleManager(View::MapDocumentWPtr document);
77 
78             const Model::VertexToBrushesMap& unselectedVertexHandles() const;
79             const Model::VertexToBrushesMap& selectedVertexHandles() const;
80             const Model::VertexToEdgesMap& unselectedEdgeHandles() const;
81             const Model::VertexToEdgesMap& selectedEdgeHandles() const;
82             const Model::VertexToFacesMap& unselectedFaceHandles() const;
83             const Model::VertexToFacesMap& selectedFaceHandles() const;
84 
85             Vec3::List vertexHandlePositions() const;
86             Vec3::List edgeHandlePositions() const;
87             Vec3::List faceHandlePositions() const;
88 
89             Vec3::List unselectedVertexHandlePositions() const;
90             Vec3::List unselectedEdgeHandlePositions() const;
91             Vec3::List unselectedFaceHandlePositions() const;
92 
93             Vec3::List selectedVertexHandlePositions() const;
94             Vec3::List selectedEdgeHandlePositions() const;
95             Vec3::List selectedFaceHandlePositions() const;
96 
97             bool isHandleSelected(const Vec3& position) const;
98             bool isVertexHandleSelected(const Vec3& position) const;
99             bool isEdgeHandleSelected(const Vec3& position) const;
100             bool isFaceHandleSelected(const Vec3& position) const;
101 
102             size_t selectedVertexCount() const;
103             size_t totalVertexCount() const;
104             size_t selectedEdgeCount() const;
105             size_t totalEdgeCount() const;
106             size_t selectedFaceCount() const;
107             size_t totalSelectedFaceCount() const;
108 
109             Model::BrushSet selectedBrushes() const;
110             const Model::BrushSet& brushes(const Vec3& handlePosition) const;
111             const Model::BrushEdgeSet& edges(const Vec3& handlePosition) const;
112             const Model::BrushFaceSet& faces(const Vec3& handlePosition) const;
113 
114             void addBrush(Model::Brush* brush);
115             void removeBrush(Model::Brush* brush);
116 
117             template <typename I>
addBrushes(I cur,I end)118             void addBrushes(I cur, I end) {
119                 while (cur != end)
120                     addBrush(*cur++);
121             }
122 
123             template <typename I>
removeBrushes(I cur,I end)124             void removeBrushes(I cur, I end) {
125                 while (cur != end)
126                     removeBrush(*cur++);
127             }
128 
129             void clear();
130 
131             void selectVertexHandle(const Vec3& position);
132             void deselectVertexHandle(const Vec3& position);
133             void toggleVertexHandle(const Vec3& position);
134             void selectVertexHandles(const Vec3::List& positions);
135             void deselectAllVertexHandles();
136             void toggleVertexHandles(const Vec3::List& positions);
137 
138             void selectEdgeHandle(const Vec3& position);
139             void deselectEdgeHandle(const Vec3& position);
140             void toggleEdgeHandle(const Vec3& position);
141             void selectEdgeHandles(const Edge3::List& edges);
142             void deselectAllEdgeHandles();
143             void toggleEdgeHandles(const Vec3::List& positions);
144 
145             void selectFaceHandle(const Vec3& position);
146             void deselectFaceHandle(const Vec3& position);
147             void toggleFaceHandle(const Vec3& position);
148             void selectFaceHandles(const Polygon3::List& faces);
149             void deselectAllFaceHandles();
150             void toggleFaceHandles(const Vec3::List& positions);
151 
152             bool hasSelectedHandles() const;
153             void deselectAllHandles();
154 
155             void reselectVertexHandles(const Model::BrushSet& brushes, const Vec3::List& positions, FloatType maxDistance);
156             void reselectEdgeHandles(const Model::BrushSet& brushes, const Vec3::List& positions, FloatType maxDistance);
157             void reselectFaceHandles(const Model::BrushSet& brushes, const Vec3::List& positions, FloatType maxDistance);
158 
159             void pick(const Ray3& ray, const Renderer::Camera& camera, Model::PickResult& pickResult, bool splitMode) const;
160             void render(Renderer::RenderContext& renderContext, Renderer::RenderBatch& renderBatch, bool splitMode);
161             void renderHighlight(Renderer::RenderContext& renderContext, Renderer::RenderBatch& renderBatch, const Vec3& position);
162             void renderEdgeHighlight(Renderer::RenderContext& renderContext, Renderer::RenderBatch& renderBatch, const Vec3& handlePosition);
163             void renderFaceHighlight(Renderer::RenderContext& renderContext, Renderer::RenderBatch& renderBatch, const Vec3& handlePosition);
164             void renderGuide(Renderer::RenderContext& renderContext, Renderer::RenderBatch& renderBatch, const Vec3& position);
165         private:
166             template <typename Element>
removeHandle(const Vec3 & position,Element * element,std::map<Vec3,std::set<Element * >,Vec3::LexicographicOrder> & map)167             inline bool removeHandle(const Vec3& position, Element* element, std::map<Vec3, std::set<Element*>, Vec3::LexicographicOrder >& map) {
168                 typedef std::set<Element*> Set;
169                 typedef std::map<Vec3, Set, Vec3::LexicographicOrder> Map;
170 
171                 typename Map::iterator mapIt = map.find(position);
172                 if (mapIt == map.end())
173                     return false;
174 
175                 Set& elements = mapIt->second;
176                 typename Set::iterator setIt = elements.find(element);
177                 if (setIt == elements.end())
178                     return false;
179 
180                 elements.erase(setIt);
181                 if (elements.empty())
182                     map.erase(mapIt);
183                 return true;
184             }
185 
186             template <typename Element>
moveHandle(const Vec3 & position,std::map<Vec3,std::set<Element * >,Vec3::LexicographicOrder> & from,std::map<Vec3,std::set<Element * >,Vec3::LexicographicOrder> & to)187             inline size_t moveHandle(const Vec3& position, std::map<Vec3, std::set<Element*>, Vec3::LexicographicOrder >& from, std::map<Vec3, std::set<Element*>, Vec3::LexicographicOrder >& to) {
188                 typedef std::set<Element*> Set;
189                 typedef std::map<Vec3, Set, Vec3::LexicographicOrder> Map;
190 
191                 typename Map::iterator mapIt = from.find(position);
192                 if (mapIt == from.end())
193                     return 0;
194 
195                 Set& fromElements = mapIt->second;
196                 Set& toElements = to[position];
197                 const size_t elementCount = fromElements.size();
198                 toElements.insert(fromElements.begin(), fromElements.end());
199 
200                 from.erase(mapIt);
201                 return elementCount;
202             }
203 
204             template <typename T, typename O>
handlePositions(const std::map<Vec3,T,O> & handles,Vec3::List & result)205             void handlePositions(const std::map<Vec3, T, O>& handles, Vec3::List& result) const {
206                 result.reserve(result.size() + handles.size());
207 
208                 typename std::map<Vec3, T, O>::const_iterator it, end;
209                 for (it = handles.begin(), end = handles.end(); it != end; ++it) {
210                     const Vec3& position = it->first;
211                     result.push_back(position);
212                 }
213             }
214 
215             Vec3::List findVertexHandlePositions(const Model::BrushSet& brushes, const Vec3& query, FloatType maxDistance);
216             Vec3::List findEdgeHandlePositions(const Model::BrushSet& brushes, const Vec3& query, FloatType maxDistance);
217             Vec3::List findFaceHandlePositions(const Model::BrushSet& brushes, const Vec3& query, FloatType maxDistance);
218 
219             Model::Hit pickHandle(const Ray3& ray, const Renderer::Camera& camera, const Vec3& position, Model::Hit::HitType type) const;
220             void validateRenderState(bool splitMode);
221         };
222     }
223 }
224 
225 #endif /* defined(TrenchBroom_VertexHandleManager) */
226