accident when merge. revert to r37405
[blender.git] / 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