r34526 removed a line which had an unused return value but still needed to run.
[blender-staging.git] / intern / bsp / intern / BSP_MeshPrimitives.cpp
1 /**
2  * $Id$
3  * ***** BEGIN GPL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software Foundation,
17  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18  *
19  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
20  * All rights reserved.
21  *
22  * The Original Code is: all of this file.
23  *
24  * Contributor(s): none yet.
25  *
26  * ***** END GPL LICENSE BLOCK *****
27  */
28
29 #include "BSP_MeshPrimitives.h"
30
31 #include "MT_assert.h"
32 #include "BSP_CSGException.h"
33 #include <algorithm>
34
35 using namespace std;
36
37 BSP_MVertex::
38 BSP_MVertex(
39 ) :
40         m_pos (MT_Point3()),
41         m_select_tag (false),
42         m_open_tag (0)
43 {
44 };
45
46 BSP_MVertex::
47 BSP_MVertex(
48         const MT_Point3 & pos
49 ) :
50         m_pos(pos),
51         m_select_tag (false),
52         m_open_tag (0)
53 {
54 };
55
56
57         bool
58 BSP_MVertex::
59 RemoveEdge(
60         BSP_EdgeInd e
61 ){
62         vector<BSP_EdgeInd>::iterator result = find(m_edges.begin(),m_edges.end(),e);
63         if (result == m_edges.end()) {
64                 return false;
65         }
66         BSP_EdgeInd last = m_edges.back();
67         m_edges.pop_back();
68         if (m_edges.empty()) return true;
69
70         *result = last;
71         return true;    
72 }       
73
74         void
75 BSP_MVertex::
76 AddEdge(
77         BSP_EdgeInd e
78 ){
79         m_edges.push_back(e);
80 }
81
82         void
83 BSP_MVertex::
84 SwapEdge(
85         BSP_EdgeInd e_old,
86         BSP_EdgeInd e_new
87 ){
88         vector<BSP_EdgeInd>::iterator result = 
89                 find(m_edges.begin(),m_edges.end(),e_old);
90         if (result == m_edges.end()) {
91                 BSP_CSGException e(e_mesh_error);
92                 throw(e);
93                 MT_assert(false);
94         }
95         
96         *result = e_new;
97 }
98
99         bool
100 BSP_MVertex::
101 SelectTag(
102 ) const{
103         return m_select_tag;
104 }
105
106         void
107 BSP_MVertex::
108 SetSelectTag(
109         bool tag        
110 ){
111         m_select_tag = tag;
112 }
113
114         int
115 BSP_MVertex::
116 OpenTag(
117 ) const {
118         return m_open_tag;
119 }
120
121         void
122 BSP_MVertex::
123 SetOpenTag(
124         int tag
125 ){
126         m_open_tag = tag;
127 }
128
129
130 /**
131  * Edge Primitive Methods.
132  */
133
134 BSP_MEdge::
135 BSP_MEdge(
136 ){
137         m_verts[0] = m_verts[1] = BSP_VertexInd::Empty();
138 }
139         
140         bool 
141 BSP_MEdge::
142 operator == (
143         BSP_MEdge & rhs
144 ){
145         // edges are the same if their vertex indices are the 
146         // same!!! Other properties are not checked 
147
148         int matches = 0;
149
150         if (this->m_verts[0] == rhs.m_verts[0]) {
151                 ++matches;
152         }
153         if (this->m_verts[1] == rhs.m_verts[0]) {
154                 ++matches;
155         }
156         if (this->m_verts[0] == rhs.m_verts[1]) {
157                 ++matches;
158         }
159         if (this->m_verts[1] == rhs.m_verts[1]) {
160                 ++matches;
161         }
162         
163         if (matches >= 2) {
164                 return true;
165         }
166         return false;
167 }
168
169         void
170 BSP_MEdge::
171 SwapFace(
172         BSP_FaceInd old_f,
173         BSP_FaceInd new_f
174 ){
175         vector<BSP_FaceInd>::iterator result = 
176                 find(m_faces.begin(),m_faces.end(),old_f);
177         if (result == m_faces.end()) {
178                 BSP_CSGException e(e_mesh_error);
179                 throw(e);
180                 MT_assert(false);
181         }
182         
183         *result = new_f;
184 }
185
186     BSP_VertexInd
187 BSP_MEdge::
188 OpVertex(
189         BSP_VertexInd vi
190 ) const {
191         if (vi == m_verts[0]) return m_verts[1];
192         if (vi == m_verts[1]) return m_verts[0];
193         MT_assert(false);
194         BSP_CSGException e(e_mesh_error);
195         throw(e);
196
197         return BSP_VertexInd::Empty();
198 }
199
200         bool
201 BSP_MEdge::
202 SelectTag(
203 ) const {
204         return bool(m_verts[1].Tag() & 0x1);
205 }
206         void
207 BSP_MEdge::
208 SetSelectTag(
209         bool tag        
210 ){
211         m_verts[1].SetTag(int(tag));
212 }
213
214         int
215 BSP_MEdge::
216 OpenTag(
217 ) const {
218         return m_verts[0].Tag();
219 }
220
221         void
222 BSP_MEdge::
223 SetOpenTag(
224         int tag
225 ) {
226         // Note conversion from int to unsigned int!!!!!
227         m_verts[0].SetTag(tag);
228 }
229         
230
231 /**
232  * Face primitive methods
233  */
234
235
236 BSP_MFace::
237 BSP_MFace(
238 ):
239         m_open_tag(-1),
240         m_orig_face(0)
241 {
242         // nothing to do
243 }
244
245         void
246 BSP_MFace::
247 Invert(
248 ){
249
250         // TODO replace reverse as I think some compilers
251         // do not support the STL routines employed.
252
253         reverse(
254                 m_verts.begin(),
255                 m_verts.end()
256         );
257
258         // invert the normal
259         m_plane.Invert();
260 }
261
262         bool
263 BSP_MFace::
264 SelectTag(
265 ) const {
266         return bool(m_verts[1].Tag() & 0x1);
267 }       
268
269         void
270 BSP_MFace::
271 SetSelectTag(
272         bool tag        
273 ){
274         m_verts[1].SetTag(int(tag));
275 };      
276
277         int
278 BSP_MFace::
279 OpenTag(
280 ) const {
281         return m_open_tag;
282 }
283
284         void
285 BSP_MFace::
286 SetOpenTag(
287         int tag
288 ){
289         // Note conversion from int to unsigned int!!!!!
290         m_open_tag = tag;
291 }
292
293
294