Merge branch 'blender2.7'
[blender.git] / source / blender / bmesh / bmesh_class.h
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 #ifndef __BMESH_CLASS_H__
18 #define __BMESH_CLASS_H__
19
20 /** \file
21  * \ingroup bmesh
22  */
23
24 /* bmesh data structures */
25
26 /* dissable holes for now, these are ifdef'd because they use more memory and cant be saved in DNA currently */
27 // #define USE_BMESH_HOLES
28
29 struct BMEdge;
30 struct BMFace;
31 struct BMLoop;
32 struct BMVert;
33 struct BMesh;
34
35 struct MLoopNorSpaceArray;
36
37 struct BLI_mempool;
38
39 /* note: it is very important for BMHeader to start with two
40  * pointers. this is a requirement of mempool's method of
41  * iteration.
42  *
43  * hrm. it doesn't but still works ok, remove the comment above? - campbell.
44  */
45
46 // #pragma GCC diagnostic error "-Wpadded"
47
48 /**
49  * BMHeader
50  *
51  * All mesh elements begin with a BMHeader. This structure
52  * hold several types of data
53  *
54  * 1: The type of the element (vert, edge, loop or face)
55  * 2: Persistent "header" flags/markings (smooth, seam, select, hidden, etc)
56  *     note that this is different from the "tool" flags.
57  * 3: Unique ID in the bmesh.
58  * 4: some elements for internal record keeping.
59  */
60 typedef struct BMHeader {
61   /** Customdata layers. */
62   void *data;
63
64   /**
65    * \note
66    * - Use BM_elem_index_get/set macros for index
67    * - Uninitialized to -1 so we can easily tell its not set.
68    * - Used for edge/vert/face/loop, check BMesh.elem_index_dirty for valid index values,
69    *   this is abused by various tools which set it dirty.
70    * - For loops this is used for sorting during tessellation.
71    */
72   int index;
73
74   /** Element geometric type (verts/edges/loops/faces). */
75   char htype;
76   /** This would be a CD layer, see below. */
77   char hflag;
78
79   /**
80    * Internal use only!
81    * \note We are very picky about not bloating this struct
82    * but in this case its padded up to 16 bytes anyway,
83    * so adding a flag here gives no increase in size.
84    */
85   char api_flag;
86   // char _pad;
87 } BMHeader;
88
89 BLI_STATIC_ASSERT((sizeof(BMHeader) <= 16), "BMHeader size has grown!");
90
91 /* note: need some way to specify custom locations for custom data layers.  so we can
92  * make them point directly into structs.  and some way to make it only happen to the
93  * active layer, and properly update when switching active layers.*/
94
95 typedef struct BMVert {
96   BMHeader head;
97
98   float co[3]; /* vertex coordinates */
99   float no[3]; /* vertex normal */
100
101   /* pointer to (any) edge using this vertex (for disk cycles)
102    *
103    * note: some higher level functions set this to different edges that use this vertex,
104    *       which is a bit of an abuse of internal bmesh data but also works OK for now (use with care!).
105    */
106   struct BMEdge *e;
107 } BMVert;
108
109 typedef struct BMVert_OFlag {
110   BMVert base;
111   struct BMFlagLayer *oflags;
112 } BMVert_OFlag;
113
114 /* disk link structure, only used by edges */
115 typedef struct BMDiskLink {
116   struct BMEdge *next, *prev;
117 } BMDiskLink;
118
119 typedef struct BMEdge {
120   BMHeader head;
121
122   struct BMVert *v1, *v2; /* vertices (unordered) */
123
124   /* the list of loops around the edge (use l->radial_prev/next)
125    * to access the other loops using the edge */
126   struct BMLoop *l;
127
128   /* disk cycle pointers
129    * relative data: d1 indicates indicates the next/prev edge around vertex v1 and d2 does the same for v2 */
130   BMDiskLink v1_disk_link, v2_disk_link;
131 } BMEdge;
132
133 typedef struct BMEdge_OFlag {
134   BMEdge base;
135   struct BMFlagLayer *oflags;
136 } BMEdge_OFlag;
137
138 typedef struct BMLoop {
139   BMHeader head;
140   /* notice no flags layer */
141
142   struct BMVert *v;
143   struct BMEdge *e; /* edge, using verts (v, next->v) */
144   struct BMFace *f;
145
146   /* circular linked list of loops which all use the same edge as this one '->e',
147    * but not necessarily the same vertex (can be either v1 or v2 of our own '->e') */
148   struct BMLoop *radial_next, *radial_prev;
149
150   /* these were originally commented as private but are used all over the code */
151   /* can't use ListBase API, due to head */
152   struct BMLoop *next, *prev; /* next/prev verts around the face */
153 } BMLoop;
154
155 /* can cast BMFace/BMEdge/BMVert, but NOT BMLoop, since these don't have a flag layer */
156 typedef struct BMElemF {
157   BMHeader head;
158 } BMElemF;
159
160 /* can cast anything to this, including BMLoop */
161 typedef struct BMElem {
162   BMHeader head;
163 } BMElem;
164
165 #ifdef USE_BMESH_HOLES
166 /* eventually, this structure will be used for supporting holes in faces */
167 typedef struct BMLoopList {
168   struct BMLoopList *next, *prev;
169   struct BMLoop *first, *last;
170 } BMLoopList;
171 #endif
172
173 typedef struct BMFace {
174   BMHeader head;
175
176 #ifdef USE_BMESH_HOLES
177   int totbounds; /*total boundaries, is one plus the number of holes in the face*/
178   ListBase loops;
179 #else
180   BMLoop *l_first;
181 #endif
182   int len;      /* number of vertices in the face */
183   float no[3];  /* face normal */
184   short mat_nr; /* material index */
185   //  short _pad[3];
186 } BMFace;
187
188 typedef struct BMFace_OFlag {
189   BMFace base;
190   struct BMFlagLayer *oflags;
191 } BMFace_OFlag;
192
193 typedef struct BMFlagLayer {
194   short f; /* flags */
195 } BMFlagLayer;
196
197 // #pragma GCC diagnostic ignored "-Wpadded"
198
199 typedef struct BMesh {
200   int totvert, totedge, totloop, totface;
201   int totvertsel, totedgesel, totfacesel;
202
203   /* flag index arrays as being dirty so we can check if they are clean and
204    * avoid looping over the entire vert/edge/face/loop array in those cases.
205    * valid flags are - BM_VERT | BM_EDGE | BM_FACE | BM_LOOP. */
206   char elem_index_dirty;
207
208   /* flag array table as being dirty so we know when its safe to use it,
209    * or when it needs to be re-created */
210   char elem_table_dirty;
211
212   /* element pools */
213   struct BLI_mempool *vpool, *epool, *lpool, *fpool;
214
215   /* mempool lookup tables (optional)
216    * index tables, to map indices to elements via
217    * BM_mesh_elem_table_ensure and associated functions.  don't
218    * touch this or read it directly.\
219    * Use BM_mesh_elem_table_ensure(), BM_vert/edge/face_at_index() */
220   BMVert **vtable;
221   BMEdge **etable;
222   BMFace **ftable;
223
224   /* size of allocated tables */
225   int vtable_tot;
226   int etable_tot;
227   int ftable_tot;
228
229   /* operator api stuff (must be all NULL or all alloc'd) */
230   struct BLI_mempool *vtoolflagpool, *etoolflagpool, *ftoolflagpool;
231
232   uint use_toolflags : 1;
233
234   int toolflag_index;
235   struct BMOperator *currentop;
236
237   CustomData vdata, edata, ldata, pdata;
238
239 #ifdef USE_BMESH_HOLES
240   struct BLI_mempool *looplistpool;
241 #endif
242
243   struct MLoopNorSpaceArray *lnor_spacearr;
244   char spacearr_dirty;
245
246   /* should be copy of scene select mode */
247   /* stored in BMEditMesh too, this is a bit confusing,
248    * make sure they're in sync!
249    * Only use when the edit mesh cant be accessed - campbell */
250   short selectmode;
251
252   /* ID of the shape key this bmesh came from */
253   int shapenr;
254
255   int totflags;
256   ListBase selected;
257
258   BMFace *act_face;
259
260   ListBase errorstack;
261
262   void *py_handle;
263 } BMesh;
264
265 /* BMHeader->htype (char) */
266 enum {
267   BM_VERT = 1,
268   BM_EDGE = 2,
269   BM_LOOP = 4,
270   BM_FACE = 8,
271 };
272
273 typedef struct BMLoopNorEditData {
274   int loop_index;
275   BMLoop *loop;
276   float niloc[3];
277   float nloc[3];
278   float *loc;
279   short *clnors_data;
280 } BMLoopNorEditData;
281
282 typedef struct BMLoopNorEditDataArray {
283   BMLoopNorEditData *lnor_editdata;
284   /* This one has full amount of loops, used to map loop index to actual BMLoopNorEditData struct. */
285   BMLoopNorEditData **lidx_to_lnor_editdata;
286
287   int cd_custom_normal_offset;
288   int totloop;
289 } BMLoopNorEditDataArray;
290
291 #define BM_ALL (BM_VERT | BM_EDGE | BM_LOOP | BM_FACE)
292 #define BM_ALL_NOLOOP (BM_VERT | BM_EDGE | BM_FACE)
293
294 enum {
295   BM_SPACEARR_DIRTY = 1 << 0,
296   BM_SPACEARR_DIRTY_ALL = 1 << 1,
297   BM_SPACEARR_BMO_SET = 1 << 2,
298 };
299
300 /* args for _Generic */
301 #define _BM_GENERIC_TYPE_ELEM_NONCONST \
302   void *, BMVert *, BMEdge *, BMLoop *, BMFace *, BMVert_OFlag *, BMEdge_OFlag *, BMFace_OFlag *, \
303       BMElem *, BMElemF *, BMHeader *
304
305 #define _BM_GENERIC_TYPE_ELEM_CONST \
306   const void *, const BMVert *, const BMEdge *, const BMLoop *, const BMFace *, \
307       const BMVert_OFlag *, const BMEdge_OFlag *, const BMFace_OFlag *, const BMElem *, \
308       const BMElemF *, const BMHeader *, void *const, BMVert *const, BMEdge *const, \
309       BMLoop *const, BMFace *const, BMElem *const, BMElemF *const, BMHeader *const
310
311 #define BM_CHECK_TYPE_ELEM_CONST(ele) CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPES_CONST)
312
313 #define BM_CHECK_TYPE_ELEM_NONCONST(ele) CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_ELEM_NONCONST)
314
315 #define BM_CHECK_TYPE_ELEM(ele) \
316   CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_ELEM_NONCONST, _BM_GENERIC_TYPE_ELEM_CONST)
317
318 /* vert */
319 #define _BM_GENERIC_TYPE_VERT_NONCONST BMVert *, BMVert_OFlag *
320 #define _BM_GENERIC_TYPE_VERT_CONST const BMVert *, const BMVert_OFlag *
321 #define BM_CHECK_TYPE_VERT_CONST(ele) CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_VERT_CONST)
322 #define BM_CHECK_TYPE_VERT_NONCONST(ele) CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_ELEM_NONCONST)
323 #define BM_CHECK_TYPE_VERT(ele) \
324   CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_VERT_NONCONST, _BM_GENERIC_TYPE_VERT_CONST)
325 /* edge */
326 #define _BM_GENERIC_TYPE_EDGE_NONCONST BMEdge *, BMEdge_OFlag *
327 #define _BM_GENERIC_TYPE_EDGE_CONST const BMEdge *, const BMEdge_OFlag *
328 #define BM_CHECK_TYPE_EDGE_CONST(ele) CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_EDGE_CONST)
329 #define BM_CHECK_TYPE_EDGE_NONCONST(ele) CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_ELEM_NONCONST)
330 #define BM_CHECK_TYPE_EDGE(ele) \
331   CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_EDGE_NONCONST, _BM_GENERIC_TYPE_EDGE_CONST)
332 /* face */
333 #define _BM_GENERIC_TYPE_FACE_NONCONST BMFace *, BMFace_OFlag *
334 #define _BM_GENERIC_TYPE_FACE_CONST const BMFace *, const BMFace_OFlag *
335 #define BM_CHECK_TYPE_FACE_CONST(ele) CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_FACE_CONST)
336 #define BM_CHECK_TYPE_FACE_NONCONST(ele) CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_ELEM_NONCONST)
337 #define BM_CHECK_TYPE_FACE(ele) \
338   CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_FACE_NONCONST, _BM_GENERIC_TYPE_FACE_CONST)
339
340 /* Assignment from a void* to a typed pointer is not allowed in C++,
341  * casting the LHS to void works fine though.
342  */
343 #ifdef __cplusplus
344 #  define BM_CHECK_TYPE_ELEM_ASSIGN(ele) (BM_CHECK_TYPE_ELEM(ele)), *((void **)&ele)
345 #else
346 #  define BM_CHECK_TYPE_ELEM_ASSIGN(ele) (BM_CHECK_TYPE_ELEM(ele)), ele
347 #endif
348
349 /* BMHeader->hflag (char) */
350 enum {
351   BM_ELEM_SELECT = (1 << 0),
352   BM_ELEM_HIDDEN = (1 << 1),
353   BM_ELEM_SEAM = (1 << 2),
354   /**
355    * used for faces and edges, note from the user POV,
356    * this is a sharp edge when disabled */
357   BM_ELEM_SMOOTH = (1 << 3),
358   /**
359    * internal flag, used for ensuring correct normals
360    * during multires interpolation, and any other time
361    * when temp tagging is handy.
362    * always assume dirty & clear before use. */
363   BM_ELEM_TAG = (1 << 4),
364
365   BM_ELEM_DRAW = (1 << 5), /* edge display */
366
367   /* spare tag, assumed dirty, use define in each function to name based on use */
368   // _BM_ELEM_TAG_ALT = (1 << 6),  // UNUSED
369   /**
370    * For low level internal API tagging,
371    * since tools may want to tag verts and not have functions clobber them.
372    * Leave cleared! */
373   BM_ELEM_INTERNAL_TAG = (1 << 7),
374 };
375
376 struct BPy_BMGeneric;
377 extern void bpy_bm_generic_invalidate(struct BPy_BMGeneric *self);
378
379 typedef bool (*BMElemFilterFunc)(const BMElem *, void *user_data);
380 typedef bool (*BMVertFilterFunc)(const BMVert *, void *user_data);
381 typedef bool (*BMEdgeFilterFunc)(const BMEdge *, void *user_data);
382 typedef bool (*BMFaceFilterFunc)(const BMFace *, void *user_data);
383 typedef bool (*BMLoopFilterFunc)(const BMLoop *, void *user_data);
384
385 /* defines */
386 #define BM_ELEM_CD_SET_INT(ele, offset, f) \
387   { \
388     CHECK_TYPE_NONCONST(ele); \
389     assert(offset != -1); \
390     *((int *)((char *)(ele)->head.data + (offset))) = (f); \
391   } \
392   (void)0
393
394 #define BM_ELEM_CD_GET_INT(ele, offset) \
395   (assert(offset != -1), *((int *)((char *)(ele)->head.data + (offset))))
396
397 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
398 #  define BM_ELEM_CD_GET_VOID_P(ele, offset) \
399     (assert(offset != -1), \
400      _Generic(ele, \
401               GENERIC_TYPE_ANY(POINTER_OFFSET((ele)->head.data, offset), \
402                                _BM_GENERIC_TYPE_ELEM_NONCONST), \
403               GENERIC_TYPE_ANY((const void *)POINTER_OFFSET((ele)->head.data, offset), \
404                                _BM_GENERIC_TYPE_ELEM_CONST)))
405 #else
406 #  define BM_ELEM_CD_GET_VOID_P(ele, offset) \
407     (assert(offset != -1), (void *)((char *)(ele)->head.data + (offset)))
408 #endif
409
410 #define BM_ELEM_CD_SET_FLOAT(ele, offset, f) \
411   { \
412     CHECK_TYPE_NONCONST(ele); \
413     assert(offset != -1); \
414     *((float *)((char *)(ele)->head.data + (offset))) = (f); \
415   } \
416   (void)0
417
418 #define BM_ELEM_CD_GET_FLOAT(ele, offset) \
419   (assert(offset != -1), *((float *)((char *)(ele)->head.data + (offset))))
420
421 #define BM_ELEM_CD_GET_FLOAT_AS_UCHAR(ele, offset) \
422   (assert(offset != -1), (uchar)(BM_ELEM_CD_GET_FLOAT(ele, offset) * 255.0f))
423
424 /*forward declarations*/
425
426 #ifdef USE_BMESH_HOLES
427 #  define BM_FACE_FIRST_LOOP(p) (((BMLoopList *)((p)->loops.first))->first)
428 #else
429 #  define BM_FACE_FIRST_LOOP(p) ((p)->l_first)
430 #endif
431
432 #define BM_DISK_EDGE_NEXT(e, v) \
433   (CHECK_TYPE_INLINE(e, BMEdge *), \
434    CHECK_TYPE_INLINE(v, BMVert *), \
435    BLI_assert(BM_vert_in_edge(e, v)), \
436    (((&e->v1_disk_link)[v == e->v2]).next))
437 #define BM_DISK_EDGE_PREV(e, v) \
438   (CHECK_TYPE_INLINE(e, BMEdge *), \
439    CHECK_TYPE_INLINE(v, BMVert *), \
440    BLI_assert(BM_vert_in_edge(e, v)), \
441    (((&e->v1_disk_link)[v == e->v2]).prev))
442
443 /**
444  * size to use for stack arrays when dealing with NGons,
445  * alloc after this limit is reached.
446  * this value is rather arbitrary */
447 #define BM_DEFAULT_NGON_STACK_SIZE 32
448 /**
449  * size to use for stack arrays dealing with connected mesh data
450  * verts of faces, edges of vert - etc.
451  * often used with #BM_iter_as_arrayN() */
452 #define BM_DEFAULT_ITER_STACK_SIZE 16
453
454 /* avoid inf loop, this value is arbitrary
455  * but should not error on valid cases */
456 #define BM_LOOP_RADIAL_MAX 10000
457 #define BM_NGON_MAX 100000
458
459 /* setting zero so we can catch bugs in OpenMP/BMesh */
460 #ifdef DEBUG
461 #  define BM_OMP_LIMIT 0
462 #else
463 #  define BM_OMP_LIMIT 10000
464 #endif
465
466 #endif /* __BMESH_CLASS_H__ */