intern/bsp/intern/BSP_CSGMesh.h

   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 /** \file bsp/intern/BSP_CSGMesh.h
  30  *  \ingroup bsp
  31  */
  32
  33
  34 #ifndef NAN_INCLUDED_BSP_CSGMesh_h
  35 #define NAN_INCLUDED_BSP_CSGMesh_h
  36
  37 #include "BSP_MeshPrimitives.h"
  38 #include "MEM_SmartPtr.h"
  39 #include "MEM_RefCountPtr.h"
  40 #include "MEM_NonCopyable.h"
  41 #include "../extern/CSG_BooleanOps.h"
  42
  43
  44 class MT_Plane3;
  45
  46 class BSP_CSGMesh :
  47         public MEM_NonCopyable,
  48         public MEM_RefCountable
  49 {
  50
  51 public :
  52
  53         static
  54                 BSP_CSGMesh *
  55         New(
  56         );
  57
  58                 bool
  59         SetVertices(
  60                 std::vector<BSP_MVertex> *verts
  61         );
  62
  63                 void
  64         AddPolygon(
  65                 const int * verts,
  66                 int num_verts
  67         );
  68
  69         // assumes that the face already has a plane equation
  70                 void
  71         AddPolygon(
  72                 const BSP_MFace &face
  73         );
  74
  75
  76         // Allocate and build the mesh edges.
  77         ////////////////////////////////////
  78
  79                 bool
  80         BuildEdges(
  81         );
  82
  83         // Clean the mesh of edges. and edge pointers
  84         // This removes the circular connectivity information
  85         /////////////////////////////////////////////
  86
  87                 void
  88         DestroyEdges(
  89         );
  90
  91         // return a new separate copy of the
  92         // mesh allocated on the heap.
  93
  94                 BSP_CSGMesh *
  95         NewCopy(
  96         ) const;
  97
  98
  99         // Reverse the winding order of every polygon
 100         // in the mesh and swap the planes around.
 101
 102                 void
 103         Invert(
 104         );
 105
 106
 107         // geometry access
 108         //////////////////
 109
 110                 std::vector<BSP_MVertex> &
 111         VertexSet(
 112         ) const ;
 113
 114                 std::vector<BSP_MFace> &
 115         FaceSet(
 116         ) const ;
 117
 118                 std::vector<BSP_MEdge> &
 119         EdgeSet(
 120         ) const;
 121
 122         ~BSP_CSGMesh(
 123         );
 124
 125         // local geometry queries.
 126         /////////////////////////
 127
 128         // face queries
 129         ///////////////
 130
 131                 void
 132         FaceVertices(
 133                 const BSP_FaceInd & f,
 134                 std::vector<BSP_VertexInd> &output
 135         );
 136
 137                 void
 138         FaceEdges(
 139                 const BSP_FaceInd & f,
 140                 std::vector<BSP_EdgeInd> &output
 141         );
 142
 143         // edge queries
 144         ///////////////
 145
 146                 void
 147         EdgeVertices(
 148                 const BSP_EdgeInd & e,
 149                 std::vector<BSP_VertexInd> &output
 150         );
 151
 152                 void
 153         EdgeFaces(
 154                 const BSP_EdgeInd & e,
 155                 std::vector<BSP_FaceInd> &output
 156         );
 157
 158         // vertex queries
 159         /////////////////
 160
 161                 void
 162         VertexEdges(
 163                 const BSP_VertexInd & v,
 164                 std::vector<BSP_EdgeInd> &output
 165         );
 166
 167                 void
 168         VertexFaces(
 169                 const BSP_VertexInd & v,
 170                 std::vector<BSP_FaceInd> &output
 171         );
 172
 173         // Returns the edge index of the edge from v1 to v2.
 174         // Does this by searching the edge sets of v1 - but not v2.
 175         // If you are paranoid you should check both and make sure the
 176         // indices are the same. If the edge doe not exist edgeInd is empty.
 177
 178                 BSP_EdgeInd
 179         FindEdge(
 180                 const BSP_VertexInd &v1,
 181                 const BSP_VertexInd &v2
 182         ) const;
 183
 184
 185         /**
 186          * Sanity checkers
 187          */
 188
 189         // make sure the edge faces have a pointer to f
 190
 191                 bool
 192         SC_Face(
 193                 BSP_FaceInd f
 194         );
 195
 196         /**
 197          * Return the face plane equation
 198          */
 199
 200                 MT_Plane3
 201         FacePlane(
 202                 const BSP_FaceInd &fi
 203         )const;
 204
 205
 206         /**
 207          * Recompute Face plane equations.
 208          * essential if you have been messing with the object.
 209          */
 210
 211                 void
 212         ComputeFacePlanes(
 213         );
 214
 215         /**
 216          * Count the number of trinagles in the mesh.
 217          * This is not the same as the number of polygons.
 218          */
 219
 220                 int
 221         CountTriangles(
 222         ) const;
 223
 224 private :
 225
 226                 void
 227         InsertEdge(
 228                 const BSP_VertexInd &v1,
 229                 const BSP_VertexInd &v2,
 230                 const BSP_FaceInd &f,
 231                 std::vector<BSP_EdgeInd> &new_edges
 232         );
 233
 234
 235         // Private to insure heap instantiation.
 236
 237         BSP_CSGMesh(
 238         );
 239
 240         std::vector<BSP_MVertex> *m_verts;
 241         std::vector<BSP_MFace>   *m_faces;
 242         std::vector<BSP_MEdge>   *m_edges;
 243
 244         MT_Vector3 m_bbox_min;
 245         MT_Vector3 m_bbox_max;
 246
 247 };
 248
 249
 250 #endif
 251