commit before doing some hefty shapekey change, will break compilation
[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
181         /*active shape key number, should really be in BMEditMesh, not here*/
182         int shapenr;
183 } BMesh;
184
185 typedef struct BMVert { 
186         struct BMHeader head;
187         float co[3];                                                                    
188         float no[3];                                                                    
189         struct BMEdge *edge;
190         float bweight;                  /*please, someone just get rid of me...*/
191 } BMVert;
192
193 typedef struct BMEdge {
194         struct BMHeader head;
195         struct BMVert *v1, *v2;
196         struct BMNode d1, d2;
197         struct BMLoop *loop;
198         float crease, bweight; /*make these custom data.... no really, please....*/
199 } BMEdge;
200
201 typedef struct BMLoop  {
202         struct BMHeader head;
203         struct BMNode radial;
204         struct BMVert *v;
205         struct BMEdge *e;
206         struct BMFace *f;       
207 } BMLoop;
208
209 typedef struct BMFace {
210         struct BMHeader head;
211         struct BMLoop *loopbase;
212         int len;
213         float no[3];
214
215         /*custom data again*/
216         short mat_nr; 
217 } BMFace;
218
219 /*stub */
220 void bmesh_error(void);
221
222 /*Mesh Level Ops */
223 struct BMesh *BM_Make_Mesh(int allocsize[4]);
224 BMesh *BM_Copy_Mesh(BMesh *bmold);
225 void BM_Free_Mesh(struct BMesh *bm);
226
227 /*frees mesh, but not actual BMesh struct*/
228 void BM_Free_Mesh_Data(BMesh *bm);
229 void BM_Compute_Normals(struct BMesh *bm);
230
231 /*Construction*/
232 struct BMVert *BM_Make_Vert(struct BMesh *bm, float co[3], struct BMVert *example);
233 struct BMEdge *BM_Make_Edge(struct BMesh *bm, struct BMVert *v1, struct BMVert *v2, struct BMEdge *example, int nodouble);
234 struct BMFace *BM_Make_Quadtriangle(struct BMesh *bm, struct BMVert **verts, BMEdge **edges, int len, struct BMFace *example, int nodouble);
235
236 /*more easier to use version of BM_Make_Quadtriangle.
237   creates edges if necassary.*/
238 BMFace *BM_Make_QuadTri(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v3, 
239                         BMVert *v4, BMFace *example, int nodouble);
240
241 /*makes an ngon from an unordered list of edges.  v1 and v2 must be the verts
242 defining edges[0], and define the winding of the new face.*/
243 struct BMFace *BM_Make_Ngon(struct BMesh *bm, struct BMVert *v1, struct BMVert *v2, struct BMEdge **edges, int len, int nodouble);
244
245 /*stuff for dealing with header flags*/
246 #define BM_TestHFlag(ele, f) (((BMHeader*)ele)->flag & (f))
247 #define BM_SetHFlag(ele, f) (((BMHeader*)ele)->flag = ((BMHeader*)ele)->flag | (f))
248 #define BM_ClearHFlag(ele, f) (((BMHeader*)ele)->flag = ((BMHeader*)ele)->flag & ~(f))
249
250 /*stuff for setting indices in elements.*/
251 #define BMINDEX_SET(ele, i) (((BMHeader*)(ele))->index = i)
252 #define BMINDEX_GET(ele) (((BMHeader*)(ele))->index)
253
254 /*copies loop data from adjacent faces*/
255 void BM_Face_CopyShared(BMesh *bm, BMFace *f);
256
257 /*copies attributes, e.g. customdata, header flags, etc, from one element
258   to another of the same type.*/
259 void BM_Copy_Attributes(struct BMesh *source_mesh, struct BMesh *target_mesh, void *source, void *target);
260
261 /*Modification*/
262 /*join two adjacent faces together along an edge.  note that
263   the faces must only be joined by on edge.  e is the edge you
264   wish to dissolve.*/
265 struct BMFace *BM_Join_Faces(struct BMesh *bm, struct BMFace *f1, 
266                              struct BMFace *f2, struct BMEdge *e);
267
268 /*split a face along two vertices.  returns the newly made face, and sets
269   the nl member to a loop in the newly created edge.*/
270 struct BMFace *BM_Split_Face(struct BMesh *bm, struct BMFace *f,  
271                              struct BMVert *v1, struct BMVert *v2, 
272                              struct BMLoop **nl, struct BMEdge *example);
273
274 /*dissolves a vert shared only by two edges*/
275 void BM_Collapse_Vert(struct BMesh *bm, struct BMEdge *ke, struct BMVert *kv, 
276                       float fac);
277
278 /*splits an edge.  ne is set to the new edge created.*/
279 struct BMVert *BM_Split_Edge(struct BMesh *bm, struct BMVert *v, 
280                              struct BMEdge *e, struct BMEdge **ne,
281                              float percent);
282
283 /*split an edge multiple times evenly*/
284 struct BMVert  *BM_Split_Edge_Multi(struct BMesh *bm, struct BMEdge *e, 
285                                     int numcuts);
286
287 /*connect two verts together, through a face they share.  this function may
288   be removed in the future.*/
289 BMEdge *BM_Connect_Verts(BMesh *bm, BMVert *v1, BMVert *v2, BMFace **nf);
290
291 /*rotates an edge topologically, either clockwise (if ccw=0) or counterclockwise
292   (if ccw is 1).*/
293 BMEdge *BM_Rotate_Edge(BMesh *bm, BMEdge *e, int ccw);
294
295 /*updates a face normal*/
296 void BM_Face_UpdateNormal(BMesh *bm, BMFace *f);
297
298 /*updates face and vertex normals incident on an edge*/
299 void BM_Edge_UpdateNormals(BMesh *bm, BMEdge *e);
300
301 /*update a vert normal (but not the faces incident on it)*/
302 void BM_Vert_UpdateNormal(BMesh *bm, BMVert *v);
303
304 void BM_flip_normal(BMesh *bm, BMFace *f);
305
306 /*dissolves all faces around a vert, and removes it.*/
307 int BM_Dissolve_Disk(BMesh *bm, BMVert *v);
308
309 /*dissolves vert, in more situations then BM_Dissolve_Disk
310   (e.g. if the vert is part of a wire edge, etc).*/
311 int BM_Dissolve_Vert(BMesh *bm, BMVert *v);
312
313
314 /*Interpolation*/
315 void BM_Data_Interp_From_Verts(struct BMesh *bm, struct BMVert *v1, struct BMVert *v2, struct BMVert *v, float fac);
316 void BM_Data_Facevert_Edgeinterp(struct BMesh *bm, struct BMVert *v1, struct BMVert *v2, struct BMVert *v, struct BMEdge *e1, float fac);
317 //void bmesh_data_interp_from_face(struct BMesh *bm, struct BMFace *source, struct BMFace *target);
318 void BM_add_data_layer(BMesh *em, CustomData *data, int type);
319 void BM_free_data_layer(BMesh *em, CustomData *data, int type);
320
321
322 /*computes the centroid of a face, using the center of the bounding box*/
323 int BM_Compute_Face_Center(BMesh *bm, BMFace *f, float center[3]);
324
325 void BM_SelectMode_Flush(BMesh *bm);
326
327 /*convert an editmesh to a bmesh*/
328 BMesh *editmesh_to_bmesh(struct EditMesh *em);
329
330 /*initializes editmesh to bmesh operator, but doesn't execute.
331   this is used in situations where you need to get access to the
332   conversion operator's editmesh->bmesh mapping slot (e.g. if you
333   need to find the bmesh edge that corrusponds to a specific editmesh
334   edge).*/
335 BMesh *init_editmesh_to_bmesh(struct EditMesh *em, struct BMOperator *op);
336
337 /*converts a bmesh to an editmesh*/
338 struct EditMesh *bmesh_to_editmesh(BMesh *bm);
339
340 /*convert between bmesh and Mesh flags*/
341 int BMFlags_To_MEFlags(void *element);
342
343 /*convert between Mesh and bmesh flags
344   type must be BM_VERT/BM_EDGE/BM_FACE,
345   and represents the type of the element
346   parameter (the three defines map to
347   MVert, MEdge, and MPoly, respectively).*/
348 int MEFlags_To_BMFlags(int flag, int type);
349
350 /*convert MLoop*** in a bmface to mtface and mcol in
351   an MFace*/
352 void BM_loops_to_corners(BMesh *bm, struct Mesh *me, int findex,
353                          BMFace *f, int numTex, int numCol);
354
355 /*include the rest of the API*/
356 #include "bmesh_filters.h"
357 #include "bmesh_iterators.h"
358 #include "bmesh_marking.h"
359 #include "bmesh_operator_api.h"
360 #include "bmesh_operators.h"
361 #include "bmesh_error.h"
362 #include "bmesh_queries.h"
363 #include "bmesh_walkers.h"
364
365 #endif /* BMESH_H */