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