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