skip assigning vars for inline bmesh flag funcs, just cast.
[blender.git] / source / blender / bmesh / bmesh.h
1 /**
2  *  bmesh.h    jan 2007
3  *
4  *      BMesh API.
5  *
6  * $Id: bmesh.h,v 1.00 2007/01/17 17:42:01 Briggs Exp $
7  *
8  * ***** BEGIN GPL LICENSE BLOCK *****
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version. The Blender
14  * Foundation also sells licenses for use in proprietary software under
15  * the Blender License.  See http://www.blender.org/BL/ for information
16  * about this.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software Foundation,
25  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
26  *
27  * Contributor(s): Geoffrey Bantle, Levi Schooley.
28  *
29  * ***** END GPL LICENSE BLOCK *****
30  */
31
32 #ifndef BMESH_H
33 #define BMESH_H
34
35 #ifdef __cplusplus
36 extern "C" {
37 #endif
38
39 #include "DNA_listBase.h"
40 #include "DNA_scene_types.h"
41 #include "DNA_customdata_types.h"
42
43 #include "BKE_customdata.h"
44
45 #include "BLI_utildefines.h"
46         
47 /*
48 short introduction:
49
50 the bmesh structure is a boundary representation, supporting non-manifold
51 locally modifiable topology. the API is designed to allow clean, maintainable
52 code, that never (or almost never) directly inspects the underlying structure.
53
54 The API includes iterators, including many useful topological iterators;
55 walkers, which walk over a mesh, without the risk of hitting the recursion
56 limit; operators, which are logical, reusable mesh modules; topological
57 modification functions (like split face, join faces, etc), which are used for
58 topological manipulations; and some (not yet finished) geometric utility
59 functions.
60
61 some definitions:
62
63 tool flags: private flags for tools.  each operator has it's own private
64             tool flag "layer", which it can use to flag elements.
65             tool flags are also used by various other parts of the api.
66 header flags: stores persistent flags, such as selection state, hide state,
67               etc.  be careful of touching these.
68 */
69
70 /*forward declarations*/
71 struct BMesh;
72 struct BMVert;
73 struct BMEdge;
74 struct BMFace;
75 struct BMLoop;
76 struct BMOperator;
77 struct Mesh;
78 struct EditMesh;
79
80 /*
81  * BMHeader
82  *
83  * All mesh elements begin with a BMHeader. This structure
84  * hold several types of data
85  *
86  * 1: The type of the element (vert, edge, loop or face)
87  * 2: Persistant "header" flags/markings (sharp, seam, select, hidden, ect)
88       note that this is different from the "tool" flags.
89  * 3: Unique ID in the bmesh.
90  * 4: some elements for internal record keeping.
91  *
92 */
93
94 /*BMHeader->type*/
95 #define BM_VERT         1
96 #define BM_EDGE         2
97 #define BM_LOOP         4
98 #define BM_FACE         8
99 #define BM_ALL          (BM_VERT | BM_EDGE | BM_LOOP | BM_FACE)
100
101 /*BMHeader->flag*/
102 #define BM_SELECT       (1<<0)
103
104 #define BM_SEAM         (1<<1)
105 #define BM_FGON         (1<<2)
106 #define BM_HIDDEN       (1<<3)
107 #define BM_SHARP        (1<<4)
108 #define BM_SMOOTH       (1<<5)
109 #define BM_ACTIVE       (1<<6)
110 #define BM_NONORMCALC   (1<<7)
111 #define BM_FLIPPED      (1<<8) /*internal flag, used for ensuring correct normals during multires interpolation*/
112
113 #include "bmesh_class.h"
114
115 /*stub */
116 void bmesh_error ( void );
117
118 /*Mesh Level Ops */
119
120 /*ob is needed by multires*/
121 struct BMesh *BM_Make_Mesh (struct Object *ob, int allocsize[4] );
122 BMesh *BM_Copy_Mesh ( BMesh *bmold );
123 void BM_Free_Mesh ( struct BMesh *bm );
124
125 /*frees mesh, but not actual BMesh struct*/
126 void BM_Free_Mesh_Data ( BMesh *bm );
127 void BM_Compute_Normals ( struct BMesh *bm );
128
129 /*Construction*/
130 struct BMVert *BM_Make_Vert ( struct BMesh *bm, float co[3], struct BMVert *example );
131 struct BMEdge *BM_Make_Edge ( struct BMesh *bm, struct BMVert *v1, struct BMVert *v2, struct BMEdge *example, int nodouble );
132 struct BMFace *BM_Make_Quadtriangle ( struct BMesh *bm, struct BMVert **verts, BMEdge **edges, int len, struct BMFace *example, int nodouble );
133
134 BMFace *BM_Make_Face(BMesh *bm, BMVert **verts, BMEdge **edges, int len);
135
136 /*more easier to use version of BM_Make_Quadtriangle.
137   creates edges if necassary.*/
138 BMFace *BM_Make_QuadTri ( BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v3,
139                           BMVert *v4, BMFace *example, int nodouble );
140
141 /*makes an ngon from an unordered list of edges.  v1 and v2 must be the verts
142 defining edges[0], and define the winding of the new face.*/
143 struct BMFace *BM_Make_Ngon ( struct BMesh *bm, struct BMVert *v1, struct BMVert *v2, struct BMEdge **edges, int len, int nodouble );
144
145 /*stuff for dealing with header flags*/
146 BM_INLINE int BM_TestHFlag(void *element, const int flag);
147
148 /*stuff for dealing with header flags*/
149 BM_INLINE void BM_SetHFlag(void *element, const int flag);
150
151 /*stuff for dealing with header flags*/
152 BM_INLINE void BM_ClearHFlag(void *element, const int flag);
153
154 /*stuff for dealing BM_ToggleHFlag header flags*/
155 BM_INLINE void BM_ToggleHFlag(void *element, const int flag);
156 BM_INLINE void BM_SetIndex(void *element, const int index);
157 BM_INLINE int BM_GetIndex(const void *element);
158
159 /*copies loop data from adjacent faces*/
160 void BM_Face_CopyShared ( BMesh *bm, BMFace *f );
161
162 /*copies attributes, e.g. customdata, header flags, etc, from one element
163   to another of the same type.*/
164 void BM_Copy_Attributes ( struct BMesh *source_mesh, struct BMesh *target_mesh, void *source, void *target );
165
166 /*Modification*/
167 /*join two adjacent faces together along an edge.  note that
168   the faces must only be joined by on edge.  e is the edge you
169   wish to dissolve.*/
170 BMFace *BM_Join_TwoFaces(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e);
171
172 /*generic, flexible join faces function; note that most everything uses
173   this, including BM_Join_TwoFaces*/
174 BMFace *BM_Join_Faces(BMesh *bm, BMFace **faces, int totface);
175
176 /*split a face along two vertices.  returns the newly made face, and sets
177   the nl member to a loop in the newly created edge.*/
178 struct BMFace *BM_Split_Face ( struct BMesh *bm, struct BMFace *f,
179                                            struct BMVert *v1, struct BMVert *v2,
180                                            struct BMLoop **nl, struct BMEdge *example );
181
182 /*dissolves a vert shared only by two edges*/
183 void BM_Collapse_Vert ( struct BMesh *bm, struct BMEdge *ke, struct BMVert *kv,
184                         float fac );
185
186 /*splits an edge.  ne is set to the new edge created.*/
187 struct BMVert *BM_Split_Edge ( struct BMesh *bm, struct BMVert *v,
188                                            struct BMEdge *e, struct BMEdge **ne,
189                                            float percent );
190
191 /*split an edge multiple times evenly*/
192 struct BMVert  *BM_Split_Edge_Multi ( struct BMesh *bm, struct BMEdge *e,
193                                                   int numcuts );
194
195 /*connect two verts together, through a face they share.  this function may
196   be removed in the future.*/
197 BMEdge *BM_Connect_Verts ( BMesh *bm, BMVert *v1, BMVert *v2, BMFace **nf );
198
199 /*rotates an edge topologically, either clockwise (if ccw=0) or counterclockwise
200   (if ccw is 1).*/
201 BMEdge *BM_Rotate_Edge ( BMesh *bm, BMEdge *e, int ccw );
202
203 /*updates a face normal*/
204 void BM_Face_UpdateNormal ( BMesh *bm, BMFace *f );
205
206 /*updates face and vertex normals incident on an edge*/
207 void BM_Edge_UpdateNormals ( BMesh *bm, BMEdge *e );
208
209 /*update a vert normal (but not the faces incident on it)*/
210 void BM_Vert_UpdateNormal ( BMesh *bm, BMVert *v );
211 void BM_Vert_UpdateAllNormals ( BMesh *bm, BMVert *v );
212
213 void BM_flip_normal ( BMesh *bm, BMFace *f );
214
215 /*dissolves all faces around a vert, and removes it.*/
216 int BM_Dissolve_Disk ( BMesh *bm, BMVert *v );
217
218 /*dissolves vert, in more situations then BM_Dissolve_Disk
219   (e.g. if the vert is part of a wire edge, etc).*/
220 int BM_Dissolve_Vert ( BMesh *bm, BMVert *v );
221
222 /*Projects co onto face f, and returns true if it is inside
223   the face bounds.  Note that this uses a best-axis projection
224   test, instead of projecting co directly into f's orientation
225   space, so there might be accuracy issues.*/
226 int BM_Point_In_Face(BMesh *bm, BMFace *f, float co[3]);
227
228 /*Interpolation*/
229
230 /*projects target onto source for customdata interpolation.  note: only
231   does loop customdata.  multires is handled.  */
232 void BM_face_interp_from_face(BMesh *bm, BMFace *target, BMFace *source);
233
234 /*projects a single loop, target, onto source for customdata interpolation. multires is handled.  
235   if do_vertex is true, target's vert data will also get interpolated.*/
236 void BM_loop_interp_from_face(BMesh *bm, BMLoop *target, BMFace *source, 
237                               int do_vertex, int do_multires);
238
239 /*smoothes boundaries between multires grids, including some borders in adjacent faces*/
240 void BM_multires_smooth_bounds(BMesh *bm, BMFace *f);
241
242 /*project the multires grid in target onto source's set of multires grids*/
243 void BM_loop_interp_multires(BMesh *bm, BMLoop *target, BMFace *source);
244 void BM_vert_interp_from_face(BMesh *bm, BMVert *v, BMFace *source);
245
246 void BM_Data_Interp_From_Verts (struct BMesh *bm, struct BMVert *v1, struct BMVert *v2, struct BMVert *v, float fac );
247 void BM_Data_Facevert_Edgeinterp (struct BMesh *bm, struct BMVert *v1, struct BMVert *v2, struct BMVert *v, struct BMEdge *e1, float fac );
248 void BM_add_data_layer (BMesh *em, CustomData *data, int type );
249 void BM_add_data_layer_named (BMesh *bm, CustomData *data, int type, char *name );
250 void BM_free_data_layer (BMesh *em, CustomData *data, int type );
251 void BM_free_data_layer_n(BMesh *bm, CustomData *data, int type, int n);
252 float BM_GetCDf(struct CustomData *cd, void *element, int type);
253 void BM_SetCDf(struct CustomData *cd, void *element, int type, float val);
254
255 /*computes the centroid of a face, using the center of the bounding box*/
256 int BM_Compute_Face_Center ( BMesh *bm, BMFace *f, float center[3] );
257
258 void BM_SelectMode_Flush ( BMesh *bm );
259
260 /*convert an editmesh to a bmesh*/
261 BMesh *editmesh_to_bmesh ( struct EditMesh *em );
262
263 /*initializes editmesh to bmesh operator, but doesn't execute.
264   this is used in situations where you need to get access to the
265   conversion operator's editmesh->bmesh mapping slot (e.g. if you
266   need to find the bmesh edge that corrusponds to a specific editmesh
267   edge).*/
268 BMesh *init_editmesh_to_bmesh ( struct EditMesh *em, struct BMOperator *op );
269
270 /*converts a bmesh to an editmesh*/
271 struct EditMesh *bmesh_to_editmesh ( BMesh *bm );
272
273 /*convert between bmesh and Mesh flags*/
274 int BMFlags_To_MEFlags ( void *element );
275
276 /*convert between Mesh and bmesh flags
277   type must be BM_VERT/BM_EDGE/BM_FACE,
278   and represents the type of the element
279   parameter (the three defines map to
280   MVert, MEdge, and MPoly, respectively).*/
281 int MEFlags_To_BMFlags ( int flag, int type );
282
283 /*convert MLoop*** in a bmface to mtface and mcol in
284   an MFace*/
285 void BM_loops_to_corners ( BMesh *bm, struct Mesh *me, int findex,
286                            BMFace *f, int numTex, int numCol );
287
288 void BM_Kill_Loop(BMesh *bm, BMLoop *l);
289 void BM_Kill_Face(BMesh *bm, BMFace *f);
290 void BM_Kill_Edge(BMesh *bm, BMEdge *e);
291 void BM_Kill_Vert(BMesh *bm, BMVert *v);
292
293 /*kills all edges associated with f, along with any other faces containing
294   those edges*/
295 void BM_Kill_Face_Edges(BMesh *bm, BMFace *f);
296
297 /*kills all verts associated with f, along with any other faces containing
298   those vertices*/
299 void BM_Kill_Face_Verts(BMesh *bm, BMFace *f) ;
300
301 /*start/stop edit*/
302 void bmesh_begin_edit(struct BMesh *bm, int flag);
303 void bmesh_end_edit(struct BMesh *bm, int flag);
304
305
306 #define bm_firstfaceloop(p) ((BMLoopList*)(p->loops.first))->first
307
308 /*include the rest of the API*/
309 #include "bmesh_filters.h"
310 #include "bmesh_iterators.h"
311 #include "bmesh_marking.h"
312 #include "bmesh_operator_api.h"
313 #include "bmesh_operators.h"
314 #include "bmesh_error.h"
315 #include "bmesh_queries.h"
316 #include "bmesh_walkers.h"
317 #include "intern/bmesh_inline.c"
318
319 #ifdef __cplusplus
320 }
321 #endif
322
323 #endif /* BMESH_H */