Initial revision
[blender.git] / intern / bsp / intern / BSP_CSGMesh.h
1 /**
2  * $Id$
3  * ***** BEGIN GPL/BL DUAL 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. The Blender
9  * Foundation also sells licenses for use in proprietary software under
10  * the Blender License.  See http://www.blender.org/BL/ for information
11  * about this.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
30  */
31
32 #ifndef NAN_INCLUDED_BSP_CSGMesh_h
33
34 #define NAN_INCLUDED_BSP_CSGMesh_h
35
36 #include "BSP_MeshPrimitives.h"
37 #include "MEM_SmartPtr.h"
38 #include "MEM_RefCountPtr.h"
39 #include "MEM_NonCopyable.h"
40 #include "BSP_CSGUserData.h"
41 #include "../extern/CSG_BooleanOps.h"
42
43
44 class MT_Plane3;
45 class BSP_MeshFragment;
46
47 class BSP_CSGMesh : 
48         public MEM_NonCopyable, 
49         public MEM_RefCountable
50 {
51
52 public :
53
54         static
55                 BSP_CSGMesh *
56         New(
57         );
58
59                 bool
60         SetVertices(
61                 MEM_SmartPtr<std::vector<BSP_MVertex> > verts
62         );
63
64                 void
65         SetFaceVertexData(
66                 MEM_SmartPtr<BSP_CSGUserData> fv_data
67         );
68
69                 void
70         SetFaceData(
71                 MEM_SmartPtr<BSP_CSGUserData> f_data
72         );
73
74                 void
75         AddPolygon(
76                 const int * verts,
77                 int num_verts
78         );      
79
80                 void
81         AddPolygon(
82                 const int * verts,
83                 const int * fv_indices,
84                 int num_verts
85         );
86
87                 void
88         AddSubTriangle(
89                 const BSP_MFace &iface,
90                 const int * index_info
91         ); 
92
93         // assumes that the face already has a plane equation
94                 void
95         AddPolygon(
96                 const BSP_MFace &face
97         );
98
99
100         // Allocate and build the mesh edges.
101         ////////////////////////////////////
102
103                 bool
104         BuildEdges(
105         );
106
107         // Clean the mesh of edges. and edge pointers
108         // This removes the circular connectivity information
109         /////////////////////////////////////////////
110
111                 void
112         DestroyEdges(
113         );
114
115         // return a new seperate copy of the 
116         // mesh allocated on the heap.
117
118                 BSP_CSGMesh *
119         NewCopy(
120         ) const;
121         
122
123         // Reverse the winding order of every polygon 
124         // in the mesh and swap the planes around.
125
126                 void
127         Invert(
128         );
129
130
131         // geometry access
132         //////////////////
133
134                 std::vector<BSP_MVertex> &
135         VertexSet(
136         ) const ;               
137
138                 std::vector<BSP_MFace> &
139         FaceSet(
140         ) const ;
141
142                 std::vector<BSP_MEdge> &
143         EdgeSet(
144         ) const;
145
146                 BSP_CSGUserData &
147         FaceVertexData(
148         ) const;
149
150                 BSP_CSGUserData &
151         FaceData(
152         ) const;
153
154         ~BSP_CSGMesh(
155         );
156
157         // local geometry queries.
158         /////////////////////////
159
160         // face queries
161         ///////////////
162
163                 void
164         FaceVertices(
165                 const BSP_FaceInd & f,
166                 std::vector<BSP_VertexInd> &output
167         );
168         
169                 void
170         FaceEdges(
171                 const BSP_FaceInd & f,
172                 std::vector<BSP_EdgeInd> &output
173         );      
174
175         // edge queries
176         ///////////////
177
178                 void
179         EdgeVertices(
180                 const BSP_EdgeInd & e,
181                 std::vector<BSP_VertexInd> &output
182         );
183
184                 void
185         EdgeFaces(
186                 const BSP_EdgeInd & e,
187                 std::vector<BSP_FaceInd> &output
188         );
189
190         // vertex queries
191         /////////////////
192
193                 void
194         VertexEdges(
195                 const BSP_VertexInd & v,
196                 std::vector<BSP_EdgeInd> &output
197         );
198         
199                 void
200         VertexFaces(
201                 const BSP_VertexInd & v,
202                 std::vector<BSP_FaceInd> &output
203         );
204
205         // Returns the edge index of the edge from v1 to v2. 
206         // Does this by searching the edge sets of v1 - but not v2.
207         // If you are paranoid you should check both and make sure the 
208         // indices are the same. If the edge doe not exist edgeInd is empty.
209
210                 BSP_EdgeInd
211         FindEdge(
212                 const BSP_VertexInd &v1,
213                 const BSP_VertexInd &v2
214         ) const;
215
216
217         // Bounding box methods
218         ///////////////////////
219
220                 void
221         SetBBox(
222                 const MT_Vector3 & min,
223                 const MT_Vector3 & max
224         );
225
226                 void
227         BBox(
228                 MT_Vector3 &min,
229                 MT_Vector3 &max
230         ) const ;
231
232         // Update the BBox
233         //////////////////
234
235                 void
236         UpdateBBox(
237         );
238
239         
240         /**
241          * Sanity checkers
242          */
243
244         // make sure the edge faces have a pointer to f
245
246                 bool
247         SC_Face(
248                 BSP_FaceInd f
249         );
250
251         /**
252          * Make sure the polygons vertex classification is correct
253          */
254
255                 void
256         SC_Classification(
257                 BSP_FaceInd f,
258                 const MT_Plane3&plane
259         );
260
261         /**
262          * Return the face plane equation
263          */
264
265                 MT_Plane3
266         FacePlane(
267                 const BSP_FaceInd &fi
268         )const;
269
270
271         /**
272          * Recompute Face plane equations.
273          * essential if you have been messing with the object.
274          */
275
276                 void
277         ComputeFacePlanes(
278         );
279                 
280         /**
281          * Count the number of trinagles in the mesh.
282          * This is not the same as the number of polygons.
283          */
284
285                 int
286         CountTriangles(
287         ) const;
288
289         /** 
290          * Insert a vertex index into a polygon
291          * and call the external splitting function to 
292          * generate a new face vertex property.
293          */
294
295                 void
296         InsertVertexIntoFace(
297                 BSP_MFace & face,
298                 const BSP_VertexInd & v1,
299                 const BSP_VertexInd & v2,
300                 const BSP_VertexInd & vi,
301                 CSG_InterpolateUserFaceVertexDataFunc fv_split_func,
302                 MT_Scalar epsilon
303         );
304
305
306 private :
307         
308                 void
309         InsertEdge(
310                 const BSP_VertexInd &v1,
311                 const BSP_VertexInd &v2,
312                 const BSP_FaceInd &f,
313                 std::vector<BSP_EdgeInd> &new_edges
314         );
315
316                 
317         // Private to insure heap instantiation.
318
319         BSP_CSGMesh(
320         );
321
322
323         MEM_SmartPtr< std::vector<BSP_MVertex> > m_verts;
324         MEM_SmartPtr< std::vector<BSP_MFace> > m_faces;
325         MEM_SmartPtr< std::vector<BSP_MEdge> > m_edges;
326
327         // The face_vertex user data associated with this mesh
328
329         MEM_SmartPtr<BSP_CSGUserData> m_fv_data;
330
331         // The face user data associated with this mesh - 
332         // This is a buffer that maps directly to the face buffer.
333         // An index into the faces is alos an index into m_face_data 
334         // for that face
335
336         MEM_SmartPtr<BSP_CSGUserData> m_face_data;
337
338         
339         MT_Vector3 m_bbox_min;
340         MT_Vector3 m_bbox_max;
341
342 };
343
344
345 #endif