allow building without xinput again
[blender.git] / intern / bsp / intern / BSP_CSGMesh_CFIterator.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 /** \file bsp/intern/BSP_CSGMesh_CFIterator.h
29  *  \ingroup bsp
30  */
31
32
33 #ifndef BSP_CSGMesh_CFIterator_h
34
35 #define BSP_CSGMesh_CFIterator_h
36
37 #include "BSP_CSGMesh.h"
38 #include "../extern/CSG_BooleanOps.h"
39 /**
40  * This class defines 2 C style iterators over a CSG mesh, one for
41  * vertices and 1 for faces. They conform to the iterator interface
42  * defined in CSG_BooleanOps.h
43  */
44
45 struct BSP_CSGMesh_VertexIt {
46         BSP_CSGMesh *mesh;
47         BSP_MVertex * pos;
48 };
49
50
51 inline
52         void
53 BSP_CSGMesh_VertexIt_Destruct(
54         CSG_VertexIteratorDescriptor * iterator
55 ) {
56         delete ((BSP_CSGMesh_VertexIt *)(iterator->it));
57         iterator->it = NULL;
58         iterator->Done = NULL;
59         iterator->Fill = NULL;
60         iterator->Reset = NULL;
61         iterator->Step = NULL;
62         iterator->num_elements = 0;
63 };
64
65
66 inline
67         int
68 BSP_CSGMesh_VertexIt_Done(
69         CSG_IteratorPtr it
70 ) {
71         // assume CSG_IteratorPtr is of the correct type.
72         BSP_CSGMesh_VertexIt * vertex_it = (BSP_CSGMesh_VertexIt *)it;
73
74         /* dereferencing iterator::end() is illegal, so we dereference 1 before it */
75         /* also check that vector is not empty */
76         if (vertex_it->mesh->VertexSet().size() && 
77                         vertex_it->pos <= &(*(vertex_it->mesh->VertexSet().end() -1) )) return 0;
78         return 1;
79 };
80
81 inline
82         void
83 BSP_CSGMesh_VertexIt_Fill(
84         CSG_IteratorPtr it,
85         CSG_IVertex *vert
86 ) {
87         // assume CSG_IteratorPtr is of the correct type.
88         BSP_CSGMesh_VertexIt * vertex_it = (BSP_CSGMesh_VertexIt *)it;
89                         
90         vertex_it->pos->m_pos.getValue(vert->position);
91 };
92
93 inline
94         void
95 BSP_CSGMesh_VertexIt_Step(
96         CSG_IteratorPtr it
97 ) {
98         // assume CSG_IteratorPtr is of the correct type.
99         BSP_CSGMesh_VertexIt * vertex_it = (BSP_CSGMesh_VertexIt *)it;
100
101         ++(vertex_it->pos);
102 };
103
104 inline
105         void
106 BSP_CSGMesh_VertexIt_Reset(
107         CSG_IteratorPtr it
108 ) {
109         // assume CSG_IteratorPtr is of the correct type.
110         BSP_CSGMesh_VertexIt * vertex_it = (BSP_CSGMesh_VertexIt *)it;
111         vertex_it->pos = &vertex_it->mesh->VertexSet()[0];
112 };      
113
114 inline
115         void
116 BSP_CSGMeshVertexIt_Construct(
117         BSP_CSGMesh *mesh,
118         CSG_VertexIteratorDescriptor *output
119 ){
120         // user should have insured mesh is not equal to NULL.
121         
122         output->Done = BSP_CSGMesh_VertexIt_Done;
123         output->Fill = BSP_CSGMesh_VertexIt_Fill;
124         output->Step = BSP_CSGMesh_VertexIt_Step;
125         output->Reset = BSP_CSGMesh_VertexIt_Reset;
126         output->num_elements = mesh->VertexSet().size();
127         
128         BSP_CSGMesh_VertexIt * v_it = new BSP_CSGMesh_VertexIt;
129         v_it->mesh = mesh;
130         if( output->num_elements > 0 )
131                 v_it->pos = &mesh->VertexSet()[0];
132         output->it = v_it;
133 };                      
134
135
136 /**
137  * Face iterator.
138  */
139
140 struct BSP_CSGMesh_FaceIt {
141         BSP_CSGMesh *mesh;
142         BSP_MFace *pos;
143         int face_triangle;
144 };
145
146
147 inline
148         void
149 BSP_CSGMesh_FaceIt_Destruct(
150         CSG_FaceIteratorDescriptor *iterator
151 ) {
152         delete ((BSP_CSGMesh_FaceIt *)(iterator->it));
153         iterator->it = NULL;
154         iterator->Done = NULL;
155         iterator->Fill = NULL;
156         iterator->Reset = NULL;
157         iterator->Step = NULL;
158         iterator->num_elements = 0;
159 };
160
161
162 inline
163         int
164 BSP_CSGMesh_FaceIt_Done(
165         CSG_IteratorPtr it
166 ) {
167         // assume CSG_IteratorPtr is of the correct type.
168         BSP_CSGMesh_FaceIt * face_it = (BSP_CSGMesh_FaceIt *)it;
169
170         /* dereferencing iterator::end() is illegal, so we dereference 1 before it */
171         /* also check that vector is not empty */
172         if (face_it->mesh->FaceSet().size() && 
173                         face_it->pos <= &(*(face_it->mesh->FaceSet().end() -1))) {
174                 if (face_it->face_triangle + 3 <= (int)face_it->pos->m_verts.size()) {
175                         return 0;
176                 }
177         }
178         return 1;
179 };
180
181 inline
182         void
183 BSP_CSGMesh_FaceIt_Fill(
184         CSG_IteratorPtr it,
185         CSG_IFace *face
186 ){
187         // assume CSG_IteratorPtr is of the correct type.
188         BSP_CSGMesh_FaceIt * face_it = (BSP_CSGMesh_FaceIt *)it;                
189         // essentially iterating through a triangle fan here.
190
191         if (face_it->pos->m_verts.size()>3) {
192                 // QUAD
193                 face->vertex_index[0] = int(face_it->pos->m_verts[0]);
194                 face->vertex_index[1] = int(face_it->pos->m_verts[1]);
195                 face->vertex_index[2] = int(face_it->pos->m_verts[2]);
196                 face->vertex_index[3] = int(face_it->pos->m_verts[3]);
197
198                 face->orig_face = face_it->pos->m_orig_face;
199
200                 face->vertex_number = 4;
201         }
202         else {
203                 // TRIANGLE
204                 face->vertex_index[0] = int(face_it->pos->m_verts[0]);
205                 face->vertex_index[1] = int(face_it->pos->m_verts[1]);
206                 face->vertex_index[2] = int(face_it->pos->m_verts[2]);
207
208                 face->orig_face = face_it->pos->m_orig_face;
209
210                 face->vertex_number = 3;
211         }
212 };
213
214 inline
215         void
216 BSP_CSGMesh_FaceIt_Step(
217         CSG_IteratorPtr it
218 ) {
219         // assume CSG_IteratorPtr is of the correct type.
220         BSP_CSGMesh_FaceIt * face_it = (BSP_CSGMesh_FaceIt *)it;                
221
222         /* dereferencing iterator::end() is illegal, so we dereference 1 before it */
223         /* also check that vector is not empty */
224         if (face_it->mesh->FaceSet().size() && 
225                         face_it->pos <= &(*(face_it->mesh->FaceSet().end() -1))) {
226
227                 //if (face_it->face_triangle + 3 < face_it->pos->m_verts.size()) {
228                 //      (face_it->face_triangle)++;
229                 //} else {
230                         face_it->face_triangle = 0;
231                         (face_it->pos) ++;
232                 //}
233         }
234 };
235
236 inline
237         void
238 BSP_CSGMesh_FaceIt_Reset(
239         CSG_IteratorPtr it
240 ) {
241         // assume CSG_IteratorPtr is of the correct type.
242         BSP_CSGMesh_FaceIt * f_it = (BSP_CSGMesh_FaceIt *)it;           
243         f_it->pos = &f_it->mesh->FaceSet()[0];
244         f_it->face_triangle = 0;
245 };
246
247 inline
248         void
249 BSP_CSGMesh_FaceIt_Construct(
250         BSP_CSGMesh * mesh,
251         CSG_FaceIteratorDescriptor *output
252 ) {
253
254         output->Done = BSP_CSGMesh_FaceIt_Done;
255         output->Fill = BSP_CSGMesh_FaceIt_Fill;
256         output->Step = BSP_CSGMesh_FaceIt_Step;
257         output->Reset = BSP_CSGMesh_FaceIt_Reset;
258
259         output->num_elements = mesh->FaceSet().size();
260         
261         BSP_CSGMesh_FaceIt * f_it = new BSP_CSGMesh_FaceIt;
262         f_it->mesh = mesh;
263         if( output->num_elements > 0 )
264                 f_it->pos = &mesh->FaceSet()[0];
265         f_it->face_triangle = 0;
266
267         output->it = f_it;
268 };
269
270
271 #endif
272