fac86f79e23a3ac38d1bb1b1f4b3ffb1394e9e5f
[blender-staging.git] / source / blender / bmesh / bmesh.h
1 /**
2  *  bmesh.h    jan 2007
3  *
4  *      BMesh API.
5  *
6  * $Id: BKE_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  * The Original Code is Copyright (C) 2004 Blender Foundation.
28  * All rights reserved.
29  *
30  * The Original Code is: all of this file.
31  *
32  * Contributor(s): Geoffrey Bantle, Levi Schooley.
33  *
34  * ***** END GPL LICENSE BLOCK *****
35  */
36
37 #ifndef BMESH_H
38 #define BMESH_H
39
40 #include "DNA_listBase.h"
41 #include "DNA_scene_types.h"
42 #include "DNA_customdata_types.h"
43
44 #include "BKE_customdata.h"
45
46 #include "BLI_mempool.h"
47
48 /*
49 short introduction:
50
51 the bmesh structure is a boundary representation, supporting non-manifold 
52 locally modifiable topology. the API is designed to allow clean, maintainable
53 code, that never (or almost never) directly inspects the underlying structure.
54
55 The API includes iterators, including many useful topological iterators;
56 walkers, which walk over a mesh, without the risk of hitting the recursion
57 limit; operators, which are logical, reusable mesh modules; topological
58 modification functions (like split face, join faces, etc), which are used for 
59 topological manipulations; and some (not yet finished) geometric utility 
60 functions.
61
62 some definitions:
63
64 tool flags: private flags for tools.  each operator has it's own private
65             tool flag "layer", which it can use to flag elements.
66             tool flags are also used by various other parts of the api.
67 header flags: stores persistent flags, such as selection state, hide state,
68               etc.  be careful of touching these.
69 */
70
71 /*forward declarations*/
72 struct BMesh;
73 struct BMVert;
74 struct BMEdge;
75 struct BMFace;
76 struct BMLoop;
77 struct BMOperator;
78 struct Mesh;
79 struct EditMesh;
80
81 /*
82  * BMHeader
83  *
84  * All mesh elements begin with a BMHeader. This structure 
85  * hold several types of data
86  *
87  * 1: The type of the element (vert, edge, loop or face)
88  * 2: Persistant "header" flags/markings (sharp, seam, select, hidden, ect)
89       note that this is different from the "tool" flags.
90  * 3: Unique ID in the bmesh.
91  * 4: some elements for internal record keeping.
92  *
93 */
94
95 /*BMHeader->type*/
96 #define BM_VERT         1
97 #define BM_EDGE         2
98 #define BM_LOOP         4
99 #define BM_FACE         8
100 #define BM_ALL          (BM_VERT | BM_EDGE | BM_LOOP | BM_FACE)
101
102 /*BMHeader->flag*/
103 #define BM_SELECT       (1<<0)
104
105 #define BM_SEAM         (1<<1)
106 #define BM_FGON         (1<<2)
107 #define BM_HIDDEN       (1<<3)
108 #define BM_SHARP        (1<<4)
109 #define BM_SMOOTH       (1<<5)
110 #define BM_ACTIVE       (1<<6)
111 #define BM_NONORMCALC   (1<<7)
112 #define BM_PINNED       (1<<8)
113
114 typedef struct BMHeader {
115         struct BMHeader *next, *prev;
116         int             EID;  /*Consider removing this/making it ifdeffed for debugging*/
117         
118         /*don't confuse this with tool flags.  this flag
119           member is what "header flag" means.*/
120         int             flag;
121         int             type; /*the element type, can be BM_VERT, BM_EDGE, BM_LOOP, or BM_FACE*/
122         int             eflag1, eflag2; /*Flags used by eulers. Try and get rid of/minimize some of these*/
123         
124         /*this is only used to store temporary integers.  
125           don't use it for anything else.
126           use the BMINDEX_GET and BMINDEX_SET macros to access it*/
127         int index;
128         struct BMFlagLayer *flags; /*Dynamically allocated block of flag layers for operators to use*/
129         void *data; /*customdata block*/
130 } BMHeader;
131
132 typedef struct BMFlagLayer {
133         int f1;
134         short mask, pflag;
135 } BMFlagLayer;
136
137 #define BM_OVERLAP      (1<<14)                 /*used by bmesh_verts_in_face*/
138 #define BM_EDGEVERT     (1<<15)                 /*used by bmesh_make_ngon*/
139
140 /*
141  * BMNode
142  *
143  * Used for circular/linked list functions that form basis of
144  * adjacency system in BMesh. This should probably be hidden 
145  * somewhere since tool authors never need to know about it.
146  *
147 */
148
149 typedef struct BMNode {
150         struct BMNode *next, *prev;
151         void *data;
152 } BMNode;
153
154 typedef struct BMesh {
155         ListBase verts, edges, polys;
156         struct BLI_mempool *vpool;
157         struct BLI_mempool *epool;
158         struct BLI_mempool *lpool;
159         struct BLI_mempool *ppool;
160         struct BMVert **vtar;
161         struct BMEdge **edar;
162         struct BMLoop **lpar;
163         struct BMFace **plar;
164         int vtarlen, edarlen, lparlen, plarlen;
165         int totvert, totedge, totface, totloop; 
166         int totvertsel, totedgesel, totfacesel;
167         int nextv, nexte, nextp, nextl;
168         struct CustomData vdata, edata, pdata, ldata;
169         int selectmode; /*now uses defines in DNA_scene_types.h*/
170         struct BLI_mempool *flagpool;                                   /*memory pool for dynamically allocated flag layers*/
171         int stackdepth;                                                                 /*current depth of operator stack*/
172         int totflags, walkers;                                                  /*total number of tool flag layers*/
173         ListBase errorstack;
174
175         /*selection order list*/
176         ListBase selected;
177
178         /*active face pointer*/
179         struct BMFace *act_face;
180 } BMesh;
181
182 typedef struct BMVert { 
183         struct BMHeader head;
184         float co[3];                                                                    
185         float no[3];                                                                    
186         struct BMEdge *edge;
187         float bweight;                  /*please, someone just get rid of me...*/
188 } BMVert;
189
190 typedef struct BMEdge {
191         struct BMHeader head;
192         struct BMVert *v1, *v2;
193         struct BMNode d1, d2;
194         struct BMLoop *loop;
195         float crease, bweight; /*make these custom data.... no really, please....*/
196 } BMEdge;
197
198 typedef struct BMLoop  {
199         struct BMHeader head;
200         struct BMNode radial;
201         struct BMVert *v;
202         struct BMEdge *e;
203         struct BMFace *f;       
204 } BMLoop;
205
206 typedef struct BMFace {
207         struct BMHeader head;
208         struct BMLoop *loopbase;
209         int len;
210         float no[3];
211
212         /*custom data again*/
213         short mat_nr; 
214 } BMFace;
215
216 /*stub */
217 void bmesh_error(void);
218
219 /*Mesh Level Ops */
220 struct BMesh *BM_Make_Mesh(int allocsize[4]);
221 BMesh *BM_Copy_Mesh(BMesh *bmold);
222 void BM_Free_Mesh(struct BMesh *bm);
223
224 /*frees mesh, but not actual BMesh struct*/
225 void BM_Free_Mesh_Data(BMesh *bm);
226 void BM_Compute_Normals(struct BMesh *bm);
227
228 /*Construction*/
229 struct BMVert *BM_Make_Vert(struct BMesh *bm, float co[3], struct BMVert *example);
230 struct BMEdge *BM_Make_Edge(struct BMesh *bm, struct BMVert *v1, struct BMVert *v2, struct BMEdge *example, int nodouble);
231 struct BMFace *BM_Make_Quadtriangle(struct BMesh *bm, struct BMVert **verts, BMEdge **edges, int len, struct BMFace *example, int nodouble);
232
233 /*more easier to use version of BM_Make_Quadtriangle.
234   creates edges if necassary.*/
235 BMFace *BM_Make_QuadTri(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v3, 
236                         BMVert *v4, BMFace *example, int nodouble);
237
238 /*makes an ngon from an unordered list of edges.  v1 and v2 must be the verts
239 defining edges[0], and define the winding of the new face.*/
240 struct BMFace *BM_Make_Ngon(struct BMesh *bm, struct BMVert *v1, struct BMVert *v2, struct BMEdge **edges, int len, int nodouble);
241
242 /*stuff for dealing with header flags*/
243 #define BM_TestHFlag(ele, f) (((BMHeader*)ele)->flag & (f))
244 #define BM_SetHFlag(ele, f) (((BMHeader*)ele)->flag = ((BMHeader*)ele)->flag | (f))
245 #define BM_ClearHFlag(ele, f) (((BMHeader*)ele)->flag = ((BMHeader*)ele)->flag & ~(f))
246
247 /*stuff for setting indices in elements.*/
248 #define BMINDEX_SET(ele, i) (((BMHeader*)(ele))->index = i)
249 #define BMINDEX_GET(ele) (((BMHeader*)(ele))->index)
250
251 /*copies loop data from adjacent faces*/
252 void BM_Face_CopyShared(BMesh *bm, BMFace *f);
253
254 /*copies attributes, e.g. customdata, header flags, etc, from one element
255   to another of the same type.*/
256 void BM_Copy_Attributes(struct BMesh *source_mesh, struct BMesh *target_mesh, void *source, void *target);
257
258 /*Modification*/
259 /*join two adjacent faces together along an edge.  note that
260   the faces must only be joined by on edge.  e is the edge you
261   wish to dissolve.*/
262 struct BMFace *BM_Join_Faces(struct BMesh *bm, struct BMFace *f1, 
263                              struct BMFace *f2, struct BMEdge *e);
264
265 /*split a face along two vertices.  returns the newly made face, and sets
266   the nl member to a loop in the newly created edge.*/
267 struct BMFace *BM_Split_Face(struct BMesh *bm, struct BMFace *f,  
268                              struct BMVert *v1, struct BMVert *v2, 
269                              struct BMLoop **nl, struct BMEdge *example);
270
271 /*dissolves a vert shared only by two edges*/
272 void BM_Collapse_Vert(struct BMesh *bm, struct BMEdge *ke, struct BMVert *kv, 
273                       float fac);
274
275 /*splits an edge.  ne is set to the new edge created.*/
276 struct BMVert *BM_Split_Edge(struct BMesh *bm, struct BMVert *v, 
277                              struct BMEdge *e, struct BMEdge **ne,
278                              float percent);
279
280 /*split an edge multiple times evenly*/
281 struct BMVert  *BM_Split_Edge_Multi(struct BMesh *bm, struct BMEdge *e, 
282                                     int numcuts);
283
284 /*connect two verts together, through a face they share.  this function may
285   be removed in the future.*/
286 BMEdge *BM_Connect_Verts(BMesh *bm, BMVert *v1, BMVert *v2, BMFace **nf);
287
288 /*rotates an edge topologically, either clockwise (if ccw=0) or counterclockwise
289   (if ccw is 1).*/
290 BMEdge *BM_Rotate_Edge(BMesh *bm, BMEdge *e, int ccw);
291
292 /*updates a face normal*/
293 void BM_Face_UpdateNormal(BMesh *bm, BMFace *f);
294
295 /*updates face and vertex normals incident on an edge*/
296 void BM_Edge_UpdateNormals(BMesh *bm, BMEdge *e);
297
298 /*update a vert normal (but not the faces incident on it)*/
299 void BM_Vert_UpdateNormal(BMesh *bm, BMVert *v);
300
301 void BM_flip_normal(BMesh *bm, BMFace *f);
302
303 /*dissolves all faces around a vert, and removes it.*/
304 int BM_Dissolve_Disk(BMesh *bm, BMVert *v);
305
306 /*dissolves vert, in more situations then BM_Dissolve_Disk
307   (e.g. if the vert is part of a wire edge, etc).*/
308 int BM_Dissolve_Vert(BMesh *bm, BMVert *v);
309
310
311 /*Interpolation*/
312 void BM_Data_Interp_From_Verts(struct BMesh *bm, struct BMVert *v1, struct BMVert *v2, struct BMVert *v, float fac);
313 void BM_Data_Facevert_Edgeinterp(struct BMesh *bm, struct BMVert *v1, struct BMVert *v2, struct BMVert *v, struct BMEdge *e1, float fac);
314 //void bmesh_data_interp_from_face(struct BMesh *bm, struct BMFace *source, struct BMFace *target);
315 void BM_add_data_layer(BMesh *em, CustomData *data, int type);
316 void BM_free_data_layer(BMesh *em, CustomData *data, int type);
317
318
319 /*computes the centroid of a face, using the center of the bounding box*/
320 int BM_Compute_Face_Center(BMesh *bm, BMFace *f, float center[3]);
321
322 void BM_SelectMode_Flush(BMesh *bm);
323
324 /*convert an editmesh to a bmesh*/
325 BMesh *editmesh_to_bmesh(struct EditMesh *em);
326
327 /*initializes editmesh to bmesh operator, but doesn't execute.
328   this is used in situations where you need to get access to the
329   conversion operator's editmesh->bmesh mapping slot (e.g. if you
330   need to find the bmesh edge that corrusponds to a specific editmesh
331   edge).*/
332 BMesh *init_editmesh_to_bmesh(struct EditMesh *em, struct BMOperator *op);
333
334 /*converts a bmesh to an editmesh*/
335 struct EditMesh *bmesh_to_editmesh(BMesh *bm);
336
337 /*convert between bmesh and Mesh flags*/
338 int BMFlags_To_MEFlags(void *element);
339
340 /*convert between Mesh and bmesh flags
341   type must be BM_VERT/BM_EDGE/BM_FACE,
342   and represents the type of the element
343   parameter (the three defines map to
344   MVert, MEdge, and MPoly, respectively).*/
345 int MEFlags_To_BMFlags(int flag, int type);
346
347 /*convert MLoop*** in a bmface to mtface and mcol in
348   an MFace*/
349 void BM_loops_to_corners(BMesh *bm, struct Mesh *me, int findex,
350                          BMFace *f, int numTex, int numCol);
351
352 /*include the rest of the API*/
353 #include "bmesh_filters.h"
354 #include "bmesh_iterators.h"
355 #include "bmesh_marking.h"
356 #include "bmesh_operator_api.h"
357 #include "bmesh_operators.h"
358 #include "bmesh_error.h"
359 #include "bmesh_queries.h"
360 #include "bmesh_walkers.h"
361
362 #endif /* BMESH_H */