Hello,
[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                 int i;
85                 for (i= 2; i <num_verts; i++) {
86                         BSP_TFace f;
87                         f.m_verts[0] = verts[0];
88                         f.m_verts[1] = verts[i-1];
89                         f.m_verts[2] = verts[i];
90
91                         m_faces.push_back(f);
92
93                         BuildNormal(m_faces.back());            
94                 }
95         }
96
97                 void
98         BuildNormal(
99                 BSP_TFace & f
100         ) const {
101                 MT_Vector3 l1 = 
102                         m_verts[f.m_verts[1]].m_pos - 
103                         m_verts[f.m_verts[0]].m_pos;
104                 MT_Vector3 l2 = 
105                         m_verts[f.m_verts[2]].m_pos - 
106                         m_verts[f.m_verts[1]].m_pos;
107
108                 MT_Vector3 normal = l1.cross(l2);
109                 
110                 f.m_normal = normal.safe_normalized();
111         }
112                 
113 };
114
115
116
117 /**
118  *  some iterator functions to describe the mesh to the BSP module.
119  */
120
121 /**
122  * This class defines 2 C style iterators over a CSG mesh, one for
123  * vertices and 1 for faces. They conform to the iterator interface
124  * defined in CSG_BooleanOps.h
125  */
126
127 struct VertexIt {
128         BSP_TMesh * mesh;
129         BSP_TVertex * pos;
130         MT_Transform trans;
131 };
132
133
134 static
135         void
136 VertexIt_Destruct(
137         CSG_VertexIteratorDescriptor * iterator
138 ) {
139         delete ((VertexIt *)(iterator->it));
140         iterator->it = NULL;
141         delete(iterator);
142 };
143
144
145 static
146         int
147 VertexIt_Done(
148         CSG_IteratorPtr it
149 ) {
150         // assume CSG_IteratorPtr is of the correct type.
151         VertexIt * vertex_it = (VertexIt *)it;
152
153         if (vertex_it->pos < vertex_it->mesh->VertexSet().end()) return 0;
154         return 1;
155 };
156
157 static
158         void
159 VertexIt_Fill(
160         CSG_IteratorPtr it,
161         CSG_IVertex *vert
162 ) {
163         // assume CSG_IteratorPtr is of the correct type.
164         VertexIt * vertex_it = (VertexIt *)it;
165                         
166         MT_Point3 p = vertex_it->pos->m_pos;
167         p = vertex_it->trans * p;
168
169         p.getValue(vert->position);
170 };
171
172 static
173         void
174 VertexIt_Step(
175         CSG_IteratorPtr it
176 ) {
177         // assume CSG_IteratorPtr is of the correct type.
178         VertexIt * vertex_it = (VertexIt *)it;
179
180         ++(vertex_it->pos);
181 };
182
183 static
184         void
185 VertexIt_Reset(
186         CSG_IteratorPtr it
187 ) {
188         // assume CSG_IteratorPtr is of the correct type.
189         VertexIt * vertex_it = (VertexIt *)it;
190
191         vertex_it->pos = vertex_it->mesh->VertexSet().begin();
192 };
193
194 static
195         CSG_VertexIteratorDescriptor * 
196 VertexIt_Construct(
197         BSP_TMesh *mesh,
198         MT_Transform trans
199 ){
200         // user should have insured mesh is not equal to NULL.
201         
202         CSG_VertexIteratorDescriptor * output = new CSG_VertexIteratorDescriptor;
203         if (output == NULL) return NULL;
204         output->Done = VertexIt_Done;
205         output->Fill = VertexIt_Fill;
206         output->Step = VertexIt_Step;
207         output->Reset = VertexIt_Reset;
208         output->num_elements = mesh->VertexSet().size();
209         
210         VertexIt * v_it = new VertexIt;
211         v_it->mesh = mesh;
212         v_it->pos = mesh->VertexSet().begin();
213         v_it->trans = trans;
214         output->it = v_it;
215         return output;
216 };                      
217
218
219 /**
220  * Face iterator.
221  */
222
223 struct FaceIt {
224         BSP_TMesh * mesh;
225         BSP_TFace *pos;
226 };
227
228
229 static
230         void
231 FaceIt_Destruct(
232         CSG_FaceIteratorDescriptor * iterator
233 ) {
234         delete ((FaceIt *)(iterator->it));
235         iterator->it = NULL;
236         delete(iterator);
237 };
238
239
240 static
241         int
242 FaceIt_Done(
243         CSG_IteratorPtr it
244 ) {
245         // assume CSG_IteratorPtr is of the correct type.
246         FaceIt * face_it = (FaceIt *)it;
247
248         if (face_it->pos < face_it->mesh->FaceSet().end()) {
249                 return 0;
250         }
251         return 1;
252 };
253
254 static
255         void
256 FaceIt_Fill(
257         CSG_IteratorPtr it,
258         CSG_IFace *face
259 ){
260         // assume CSG_IteratorPtr is of the correct type.
261         FaceIt * face_it = (FaceIt *)it;                
262         // essentially iterating through a triangle fan here.
263
264         face->vertex_index[0] = int(face_it->pos->m_verts[0]);
265         face->vertex_index[1] = int(face_it->pos->m_verts[1]);
266         face->vertex_index[2] = int(face_it->pos->m_verts[2]);
267
268         face->vertex_number = 3;
269 };
270
271 static
272         void
273 FaceIt_Step(
274         CSG_IteratorPtr it
275 ) {
276         // assume CSG_IteratorPtr is of the correct type.
277         FaceIt * face_it = (FaceIt *)it;                
278
279         face_it->pos ++;
280 };
281
282 static
283         void
284 FaceIt_Reset(
285         CSG_IteratorPtr it
286 ) {
287         // assume CSG_IteratorPtr is of the correct type.
288         FaceIt * face_it = (FaceIt *)it;                
289
290         face_it->pos = face_it->mesh->FaceSet().begin();
291 };
292
293 static
294         CSG_FaceIteratorDescriptor * 
295 FaceIt_Construct(
296         BSP_TMesh * mesh
297 ) {
298         CSG_FaceIteratorDescriptor * output = new CSG_FaceIteratorDescriptor;
299         if (output == NULL) return NULL;
300
301         output->Done = FaceIt_Done;
302         output->Fill = FaceIt_Fill;
303         output->Step = FaceIt_Step;
304         output->Reset = FaceIt_Reset;
305
306         output->num_elements = mesh->FaceSet().size();
307         
308         FaceIt * f_it = new FaceIt;
309         f_it->mesh = mesh;
310         f_it->pos = mesh->FaceSet().begin();
311
312         output->it = f_it;
313
314         return output;
315 };
316
317 /**
318  * Some Build functions.
319  */
320
321 static
322         MEM_SmartPtr<BSP_TMesh>
323 BuildMesh(
324         CSG_MeshPropertyDescriptor &props,
325         CSG_FaceIteratorDescriptor &face_it,
326         CSG_VertexIteratorDescriptor &vertex_it
327 ) {
328         MEM_SmartPtr<BSP_TMesh> mesh = new BSP_TMesh();
329
330         CSG_IVertex vert;
331
332         while (!vertex_it.Done(vertex_it.it)) {
333
334                 vertex_it.Fill(vertex_it.it,&vert);
335         
336                 BSP_TVertex v;
337                 v.m_pos = MT_Point3(vert.position);
338                 mesh->VertexSet().push_back(v);
339
340                 vertex_it.Step(vertex_it.it);
341         }
342
343         
344         CSG_IFace face;
345
346         while (!face_it.Done(face_it.it)) {
347                 face_it.Fill(face_it.it,&face);
348
349                 BSP_TFace f;
350
351                 f.m_verts[0] = face.vertex_index[0],
352                 f.m_verts[1] = face.vertex_index[1],
353                 f.m_verts[2] = face.vertex_index[2],
354
355                 mesh->BuildNormal(f);
356
357                 mesh->FaceSet().push_back(f);
358
359                 face_it.Step(face_it.it);
360         }
361
362         return mesh;
363 };
364
365
366
367         
368
369         
370
371
372
373
374
375
376         
377
378
379
380         
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400 #endif
401