accident when merge. revert to r37405
[blender.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 /** \file bsp/intern/BSP_MeshPrimitives.cpp
30  *  \ingroup bsp
31  */
32
33
34 #include "BSP_MeshPrimitives.h"
35
36 #include "MT_assert.h"
37 #include "BSP_CSGException.h"
38 #include <algorithm>
39
40 using namespace std;
41
42 BSP_MVertex::
43 BSP_MVertex(
44 ) :
45         m_pos (MT_Point3()),
46         m_select_tag (false),
47         m_open_tag (0)
48 {
49 };
50
51 BSP_MVertex::
52 BSP_MVertex(
53         const MT_Point3 & pos
54 ) :
55         m_pos(pos),
56         m_select_tag (false),
57         m_open_tag (0)
58 {
59 };
60
61
62         bool
63 BSP_MVertex::
64 RemoveEdge(
65         BSP_EdgeInd e
66 ){
67         vector<BSP_EdgeInd>::iterator result = find(m_edges.begin(),m_edges.end(),e);
68         if (result == m_edges.end()) {
69                 return false;
70         }
71         BSP_EdgeInd last = m_edges.back();
72         m_edges.pop_back();
73         if (m_edges.empty()) return true;
74
75         *result = last;
76         return true;    
77 }       
78
79         void
80 BSP_MVertex::
81 AddEdge(
82         BSP_EdgeInd e
83 ){
84         m_edges.push_back(e);
85 }
86
87         void
88 BSP_MVertex::
89 SwapEdge(
90         BSP_EdgeInd e_old,
91         BSP_EdgeInd e_new
92 ){
93         vector<BSP_EdgeInd>::iterator result = 
94                 find(m_edges.begin(),m_edges.end(),e_old);
95         if (result == m_edges.end()) {
96                 BSP_CSGException e(e_mesh_error);
97                 throw(e);
98                 MT_assert(false);
99         }
100         
101         *result = e_new;
102 }
103
104         bool
105 BSP_MVertex::
106 SelectTag(
107 ) const{
108         return m_select_tag;
109 }
110
111         void
112 BSP_MVertex::
113 SetSelectTag(
114         bool tag        
115 ){
116         m_select_tag = tag;
117 }
118
119         int
120 BSP_MVertex::
121 OpenTag(
122 ) const {
123         return m_open_tag;
124 }
125
126         void
127 BSP_MVertex::
128 SetOpenTag(
129         int tag
130 ){
131         m_open_tag = tag;
132 }
133
134
135 /**
136  * Edge Primitive Methods.
137  */
138
139 BSP_MEdge::
140 BSP_MEdge(
141 ){
142         m_verts[0] = m_verts[1] = BSP_VertexInd::Empty();
143 }
144         
145         bool 
146 BSP_MEdge::
147 operator == (
148         BSP_MEdge & rhs
149 ){
150         // edges are the same if their vertex indices are the 
151         // same!!! Other properties are not checked 
152
153         int matches = 0;
154
155         if (this->m_verts[0] == rhs.m_verts[0]) {
156                 ++matches;
157         }
158         if (this->m_verts[1] == rhs.m_verts[0]) {
159                 ++matches;
160         }
161         if (this->m_verts[0] == rhs.m_verts[1]) {
162                 ++matches;
163         }
164         if (this->m_verts[1] == rhs.m_verts[1]) {
165                 ++matches;
166         }
167         
168         if (matches >= 2) {
169                 return true;
170         }
171         return false;
172 }
173
174         void
175 BSP_MEdge::
176 SwapFace(
177         BSP_FaceInd old_f,
178         BSP_FaceInd new_f
179 ){
180         vector<BSP_FaceInd>::iterator result = 
181                 find(m_faces.begin(),m_faces.end(),old_f);
182         if (result == m_faces.end()) {
183                 BSP_CSGException e(e_mesh_error);
184                 throw(e);
185                 MT_assert(false);
186         }
187         
188         *result = new_f;
189 }
190
191     BSP_VertexInd
192 BSP_MEdge::
193 OpVertex(
194         BSP_VertexInd vi
195 ) const {
196         if (vi == m_verts[0]) return m_verts[1];
197         if (vi == m_verts[1]) return m_verts[0];
198         MT_assert(false);
199         BSP_CSGException e(e_mesh_error);
200         throw(e);
201
202         return BSP_VertexInd::Empty();
203 }
204
205         bool
206 BSP_MEdge::
207 SelectTag(
208 ) const {
209         return bool(m_verts[1].Tag() & 0x1);
210 }
211         void
212 BSP_MEdge::
213 SetSelectTag(
214         bool tag        
215 ){
216         m_verts[1].SetTag(int(tag));
217 }
218
219         int
220 BSP_MEdge::
221 OpenTag(
222 ) const {
223         return m_verts[0].Tag();
224 }
225
226         void
227 BSP_MEdge::
228 SetOpenTag(
229         int tag
230 ) {
231         // Note conversion from int to unsigned int!!!!!
232         m_verts[0].SetTag(tag);
233 }
234         
235
236 /**
237  * Face primitive methods
238  */
239
240
241 BSP_MFace::
242 BSP_MFace(
243 ):
244         m_open_tag(-1),
245         m_orig_face(0)
246 {
247         // nothing to do
248 }
249
250         void
251 BSP_MFace::
252 Invert(
253 ){
254
255         // TODO replace reverse as I think some compilers
256         // do not support the STL routines employed.
257
258         reverse(
259                 m_verts.begin(),
260                 m_verts.end()
261         );
262
263         // invert the normal
264         m_plane.Invert();
265 }
266
267         bool
268 BSP_MFace::
269 SelectTag(
270 ) const {
271         return bool(m_verts[1].Tag() & 0x1);
272 }       
273
274         void
275 BSP_MFace::
276 SetSelectTag(
277         bool tag        
278 ){
279         m_verts[1].SetTag(int(tag));
280 };      
281
282         int
283 BSP_MFace::
284 OpenTag(
285 ) const {
286         return m_open_tag;
287 }
288
289         void
290 BSP_MFace::
291 SetOpenTag(
292         int tag
293 ){
294         // Note conversion from int to unsigned int!!!!!
295         m_open_tag = tag;
296 }
297
298
299