intern/bsp/intern/BSP_MeshPrimitives.cpp

   1 /**
   2  * $Id$
   3  * ***** BEGIN GPL 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.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  *
  19  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  20  * All rights reserved.
  21  *
  22  * The Original Code is: all of this file.
  23  *
  24  * Contributor(s): none yet.
  25  *
  26  * ***** END GPL LICENSE BLOCK *****
  27  */
  28
  29 #include "BSP_MeshPrimitives.h"
  30
  31 #include "MT_assert.h"
  32 #include "BSP_CSGException.h"
  33 #include <algorithm>
  34
  35 using namespace std;
  36
  37 BSP_MVertex::
  38 BSP_MVertex(
  39 ) :
  40         m_pos (MT_Point3()),
  41         m_select_tag (false),
  42         m_open_tag (0)
  43 {
  44 };
  45
  46 BSP_MVertex::
  47 BSP_MVertex(
  48         const MT_Point3 & pos
  49 ) :
  50         m_pos(pos),
  51         m_select_tag (false),
  52         m_open_tag (0)
  53 {
  54 };
  55
  56
  57         bool
  58 BSP_MVertex::
  59 RemoveEdge(
  60         BSP_EdgeInd e
  61 ){
  62         vector<BSP_EdgeInd>::iterator result = find(m_edges.begin(),m_edges.end(),e);
  63         if (result == m_edges.end()) {
  64                 return false;
  65         }
  66         BSP_EdgeInd last = m_edges.back();
  67         m_edges.pop_back();
  68         if (m_edges.empty()) return true;
  69
  70         *result = last;
  71         return true;
  72 }
  73
  74         void
  75 BSP_MVertex::
  76 AddEdge(
  77         BSP_EdgeInd e
  78 ){
  79         m_edges.push_back(e);
  80 }
  81
  82         void
  83 BSP_MVertex::
  84 SwapEdge(
  85         BSP_EdgeInd e_old,
  86         BSP_EdgeInd e_new
  87 ){
  88         vector<BSP_EdgeInd>::iterator result =
  89                 find(m_edges.begin(),m_edges.end(),e_old);
  90         if (result == m_edges.end()) {
  91                 BSP_CSGException e(e_mesh_error);
  92                 throw(e);
  93                 MT_assert(false);
  94         }
  95
  96         *result = e_new;
  97 }
  98
  99         bool
 100 BSP_MVertex::
 101 SelectTag(
 102 ) const{
 103         return m_select_tag;
 104 }
 105
 106         void
 107 BSP_MVertex::
 108 SetSelectTag(
 109         bool tag
 110 ){
 111         m_select_tag = tag;
 112 }
 113
 114         int
 115 BSP_MVertex::
 116 OpenTag(
 117 ) const {
 118         return m_open_tag;
 119 }
 120
 121         void
 122 BSP_MVertex::
 123 SetOpenTag(
 124         int tag
 125 ){
 126         m_open_tag = tag;
 127 }
 128
 129
 130 /**
 131  * Edge Primitive Methods.
 132  */
 133
 134 BSP_MEdge::
 135 BSP_MEdge(
 136 ){
 137         m_verts[0] = m_verts[1] = BSP_VertexInd::Empty();
 138 }
 139
 140         bool
 141 BSP_MEdge::
 142 operator == (
 143         BSP_MEdge & rhs
 144 ){
 145         // edges are the same if their vertex indices are the
 146         // same!!! Other properties are not checked
 147
 148         int matches = 0;
 149
 150         if (this->m_verts[0] == rhs.m_verts[0]) {
 151                 ++matches;
 152         }
 153         if (this->m_verts[1] == rhs.m_verts[0]) {
 154                 ++matches;
 155         }
 156         if (this->m_verts[0] == rhs.m_verts[1]) {
 157                 ++matches;
 158         }
 159         if (this->m_verts[1] == rhs.m_verts[1]) {
 160                 ++matches;
 161         }
 162
 163         if (matches >= 2) {
 164                 return true;
 165         }
 166         return false;
 167 }
 168
 169         void
 170 BSP_MEdge::
 171 SwapFace(
 172         BSP_FaceInd old_f,
 173         BSP_FaceInd new_f
 174 ){
 175         vector<BSP_FaceInd>::iterator result =
 176                 find(m_faces.begin(),m_faces.end(),old_f);
 177         if (result == m_faces.end()) {
 178                 BSP_CSGException e(e_mesh_error);
 179                 throw(e);
 180                 MT_assert(false);
 181         }
 182
 183         *result = new_f;
 184 }
 185
 186     BSP_VertexInd
 187 BSP_MEdge::
 188 OpVertex(
 189         BSP_VertexInd vi
 190 ) const {
 191         if (vi == m_verts[0]) return m_verts[1];
 192         if (vi == m_verts[1]) return m_verts[0];
 193         MT_assert(false);
 194         BSP_CSGException e(e_mesh_error);
 195         throw(e);
 196
 197         return BSP_VertexInd::Empty();
 198 }
 199
 200         bool
 201 BSP_MEdge::
 202 SelectTag(
 203 ) const {
 204         return bool(m_verts[1].Tag() & 0x1);
 205 }
 206         void
 207 BSP_MEdge::
 208 SetSelectTag(
 209         bool tag
 210 ){
 211         m_verts[1].SetTag(int(tag));
 212 }
 213
 214         int
 215 BSP_MEdge::
 216 OpenTag(
 217 ) const {
 218         return m_verts[0].Tag();
 219 }
 220
 221         void
 222 BSP_MEdge::
 223 SetOpenTag(
 224         int tag
 225 ) {
 226         // Note conversion from int to unsigned int!!!!!
 227         m_verts[0].SetTag(tag);
 228 }
 229
 230
 231 /**
 232  * Face primitive methods
 233  */
 234
 235
 236 BSP_MFace::
 237 BSP_MFace(
 238 ):
 239         m_open_tag(-1),
 240         m_orig_face(0)
 241 {
 242         // nothing to do
 243 }
 244
 245         void
 246 BSP_MFace::
 247 Invert(
 248 ){
 249
 250         // TODO replace reverse as I think some compilers
 251         // do not support the STL routines employed.
 252
 253         reverse(
 254                 m_verts.begin(),
 255                 m_verts.end()
 256         );
 257
 258         // invert the normal
 259         m_plane.Invert();
 260 }
 261
 262         bool
 263 BSP_MFace::
 264 SelectTag(
 265 ) const {
 266         return bool(m_verts[1].Tag() & 0x1);
 267 }
 268
 269         void
 270 BSP_MFace::
 271 SetSelectTag(
 272         bool tag
 273 ){
 274         m_verts[1].SetTag(int(tag));
 275 };
 276
 277         int
 278 BSP_MFace::
 279 OpenTag(
 280 ) const {
 281         return m_open_tag;
 282 }
 283
 284         void
 285 BSP_MFace::
 286 SetOpenTag(
 287         int tag
 288 ){
 289         // Note conversion from int to unsigned int!!!!!
 290         m_open_tag = tag;
 291 }
 292
 293
 294