4322fedbed47bf93ca9f6259b3c1169dd9e5355e
[blender.git] / intern / bsp / test / BSP_GhostTest / BSP_TMesh.h
1 /**
2  * $Id$
3  * ***** BEGIN GPL/BL DUAL 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. The Blender
9  * Foundation also sells licenses for use in proprietary software under
10  * the Blender License.  See http://www.blender.org/BL/ for information
11  * about this.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
30  */
31
32 #ifndef BSP_TMesh_h
33 #define BSP_TMesh_h
34
35 #include "MT_Point3.h"
36 #include "MT_Vector3.h"
37 #include "MT_Transform.h"
38
39 #include "MEM_SmartPtr.h"
40
41 #include <vector>
42
43 #include "CSG_BooleanOps.h"
44
45 /**
46  * A very basic test mesh.
47  */
48
49 struct BSP_TVertex {
50         MT_Point3 m_pos;
51 };
52
53 struct BSP_TFace {
54         int m_verts[3];
55         MT_Vector3 m_normal;
56 };
57
58
59 class BSP_TMesh {
60 public :
61
62         std::vector<BSP_TVertex> m_verts;
63         std::vector<BSP_TFace> m_faces;
64         
65         MT_Vector3 m_min,m_max;
66
67                 std::vector<BSP_TVertex> &
68         VertexSet(
69         ){
70                 return m_verts;
71         }
72
73                 std::vector<BSP_TFace> &
74         FaceSet(
75         ) {
76                 return m_faces;
77         }
78
79                 void
80         AddFace(
81                 int *verts,
82                 int num_verts
83         );
84
85                 void
86         BuildNormal(
87                 BSP_TFace & f
88         ) const ;
89                 
90 };
91
92
93
94 /**
95  *  some iterator functions to describe the mesh to the BSP module.
96  */
97
98 /**
99  * This class defines 2 C style iterators over a CSG mesh, one for
100  * vertices and 1 for faces. They conform to the iterator interface
101  * defined in CSG_BooleanOps.h
102  */
103
104 struct VertexIt {
105         BSP_TMesh * mesh;
106         BSP_TVertex * pos;
107         MT_Transform trans;
108 };
109
110
111 static
112         void
113 VertexIt_Destruct(
114         CSG_VertexIteratorDescriptor * iterator
115 ) {
116         delete ((VertexIt *)(iterator->it));
117         iterator->it = NULL;
118         delete(iterator);
119 };
120
121
122 static
123         int
124 VertexIt_Done(
125         CSG_IteratorPtr it
126 ) {
127         // assume CSG_IteratorPtr is of the correct type.
128         VertexIt * vertex_it = (VertexIt *)it;
129
130         if (vertex_it->pos < vertex_it->mesh->VertexSet().end()) return 0;
131         return 1;
132 };
133
134 static
135         void
136 VertexIt_Fill(
137         CSG_IteratorPtr it,
138         CSG_IVertex *vert
139 ) {
140         // assume CSG_IteratorPtr is of the correct type.
141         VertexIt * vertex_it = (VertexIt *)it;
142                         
143         MT_Point3 p = vertex_it->pos->m_pos;
144         p = vertex_it->trans * p;
145
146         p.getValue(vert->position);
147 };
148
149 static
150         void
151 VertexIt_Step(
152         CSG_IteratorPtr it
153 ) {
154         // assume CSG_IteratorPtr is of the correct type.
155         VertexIt * vertex_it = (VertexIt *)it;
156
157         ++(vertex_it->pos);
158 };
159
160 static
161         CSG_VertexIteratorDescriptor * 
162 VertexIt_Construct(
163         BSP_TMesh *mesh,
164         MT_Transform trans
165 ){
166         // user should have insured mesh is not equal to NULL.
167         
168         CSG_VertexIteratorDescriptor * output = new CSG_VertexIteratorDescriptor;
169         if (output == NULL) return NULL;
170         output->Done = VertexIt_Done;
171         output->Fill = VertexIt_Fill;
172         output->Step = VertexIt_Step;
173         output->num_elements = mesh->VertexSet().size();
174         
175         VertexIt * v_it = new VertexIt;
176         v_it->mesh = mesh;
177         v_it->pos = mesh->VertexSet().begin();
178         v_it->trans = trans;
179         output->it = v_it;
180         return output;
181 };                      
182
183
184 /**
185  * Face iterator.
186  */
187
188 struct FaceIt {
189         BSP_TMesh * mesh;
190         BSP_TFace *pos;
191 };
192
193
194 static
195         void
196 FaceIt_Destruct(
197         CSG_FaceIteratorDescriptor * iterator
198 ) {
199         delete ((FaceIt *)(iterator->it));
200         iterator->it = NULL;
201         delete(iterator);
202 };
203
204
205 static
206         int
207 FaceIt_Done(
208         CSG_IteratorPtr it
209 ) {
210         // assume CSG_IteratorPtr is of the correct type.
211         FaceIt * face_it = (FaceIt *)it;
212
213         if (face_it->pos < face_it->mesh->FaceSet().end()) {
214                 return 0;
215         }
216         return 1;
217 };
218
219 static
220         void
221 FaceIt_Fill(
222         CSG_IteratorPtr it,
223         CSG_IFace *face
224 ){
225         // assume CSG_IteratorPtr is of the correct type.
226         FaceIt * face_it = (FaceIt *)it;                
227         // essentially iterating through a triangle fan here.
228
229         face->vertex_index[0] = int(face_it->pos->m_verts[0]);
230         face->vertex_index[1] = int(face_it->pos->m_verts[1]);
231         face->vertex_index[2] = int(face_it->pos->m_verts[2]);
232
233         face->vertex_number = 3;
234 };
235
236 static
237         void
238 FaceIt_Step(
239         CSG_IteratorPtr it
240 ) {
241         // assume CSG_IteratorPtr is of the correct type.
242         FaceIt * face_it = (FaceIt *)it;                
243
244         face_it->pos ++;
245 };
246
247 static
248         CSG_FaceIteratorDescriptor * 
249 FaceIt_Construct(
250         BSP_TMesh * mesh
251 ) {
252         CSG_FaceIteratorDescriptor * output = new CSG_FaceIteratorDescriptor;
253         if (output == NULL) return NULL;
254
255         output->Done = FaceIt_Done;
256         output->Fill = FaceIt_Fill;
257         output->Step = FaceIt_Step;
258
259         output->num_elements = mesh->FaceSet().size();
260         
261         FaceIt * f_it = new FaceIt;
262         f_it->mesh = mesh;
263         f_it->pos = mesh->FaceSet().begin();
264
265         output->it = f_it;
266
267         return output;
268 };
269
270 /**
271  * Some Build functions.
272  */
273
274 static
275         MEM_SmartPtr<BSP_TMesh>
276 BuildMesh(
277         CSG_MeshPropertyDescriptor &props,
278         CSG_FaceIteratorDescriptor &face_it,
279         CSG_VertexIteratorDescriptor &vertex_it
280 ) {
281         MEM_SmartPtr<BSP_TMesh> mesh = new BSP_TMesh();
282
283         CSG_IVertex vert;
284
285         while (!vertex_it.Done(vertex_it.it)) {
286
287                 vertex_it.Fill(vertex_it.it,&vert);
288         
289                 BSP_TVertex v;
290                 v.m_pos = MT_Point3(vert.position);
291                 mesh->VertexSet().push_back(v);
292
293                 vertex_it.Step(vertex_it.it);
294         }
295
296         
297         CSG_IFace face;
298
299         while (!face_it.Done(face_it.it)) {
300                 face_it.Fill(face_it.it,&face);
301
302                 BSP_TFace f;
303
304                 f.m_verts[0] = face.vertex_index[0],
305                 f.m_verts[1] = face.vertex_index[1],
306                 f.m_verts[2] = face.vertex_index[2],
307
308                 mesh->BuildNormal(f);
309
310                 mesh->FaceSet().push_back(f);
311
312                 face_it.Step(face_it.it);
313         }
314
315         return mesh;
316 };
317
318
319
320         
321
322         
323
324
325
326
327
328
329         
330
331
332
333         
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353 #endif
354