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