Code Cleanup:
[blender.git] / source / blender / bmesh / intern / bmesh_construct.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  * about this.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software Foundation,
17  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18  *
19  * The Original Code is Copyright (C) 2007 Blender Foundation.
20  * All rights reserved.
21  *
22  * The Original Code is: all of this file.
23  *
24  * Contributor(s): Geoffrey Bantle.
25  *
26  * ***** END GPL LICENSE BLOCK *****
27  */
28
29 /** \file blender/bmesh/intern/bmesh_construct.c
30  *  \ingroup bmesh
31  *
32  * BM construction functions.
33  */
34
35 #include "MEM_guardedalloc.h"
36
37 #include "BKE_customdata.h"
38 #include "BKE_utildefines.h"
39
40 #include "BLI_array.h"
41 #include "BLI_utildefines.h"
42
43 #include "DNA_meshdata_types.h"
44 #include "DNA_mesh_types.h"
45
46 #include "BLI_math.h"
47 #include "BLI_utildefines.h"
48
49 #include "bmesh.h"
50 #include "bmesh_private.h"
51
52 #include <math.h>
53 #include <stdio.h>
54 #include <string.h>
55
56 #define SELECT 1
57
58 /* prototypes */
59 static void bm_copy_loop_attributes(BMesh *source_mesh, BMesh *target_mesh,
60                                     const BMLoop *source_loop, BMLoop *target_loop);
61 #if 0
62
63 /*
64  * BM_CONSTRUCT.C
65  *
66  * This file contains functions for making and destroying
67  * individual elements like verts, edges and faces.
68  *
69  */
70
71 /*
72  * BMESH MAKE VERT
73  *
74  * Creates a new vertex and returns a pointer
75  * to it. If a pointer to an example vertex is
76  * passed in, it's custom data and properties
77  * will be copied to the new vertex.
78  *
79  */
80
81 BMVert *BM_Make_Vert(BMesh *bm, float co[3], BMVert *example)
82 {
83         BMVert *v = NULL;
84         v = bmesh_mv(bm, co);
85         if (example)
86                 CustomData_bmesh_copy_data(&bm->vdata, &bm->vdata, example->head.data, &v->head.data);
87         return v;
88 }
89
90 /*
91  * BMESH MAKE EDGE
92  *
93  * Creates a new edge betweeen two vertices and returns a
94  * pointer to it. If 'nodouble' equals 1, then a check is
95  * is done to make sure that an edge between those two vertices
96  * does not already exist. If it does, that edge is returned instead
97  * of creating a new one.
98  *
99  * If a new edge is created, and a pointer to an example edge is
100  * provided, it's custom data and properties will be copied to the
101  * new edge.
102  *
103  */
104
105 BMEdge *BM_Make_Edge(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge *example, int nodouble)
106 {
107         BMEdge *e = NULL;
108         
109         if (nodouble) /* test if edge already exists. */
110                 e = BM_Edge_Exist(v1, v2);
111
112         if (!e) {
113                 e = bmesh_me(bm, v1, v2);
114
115                 if (example)
116                         CustomData_bmesh_copy_data(&bm->edata, &bm->edata, example->head.data, &e->head.data);
117         }
118         
119         return e;
120         
121 }
122 #endif
123
124 /*
125  * BMESH MAKE QUADTRIANGLE
126  *
127  * Creates a new quad or triangle from
128  * a list of 3 or 4 vertices. If nodouble
129  * equals 1, then a check is done to see
130  * if a face with these vertices already
131  * exists and returns it instead. If a pointer
132  * to an example face is provided, it's custom
133  * data and properties will be copied to the new
134  * face.
135  *
136  * Note that the winding of the face is determined
137  * by the order of the vertices in the vertex array
138  */
139
140 BMFace *BM_Make_Face_QuadTri(BMesh *bm,
141                              BMVert *v1, BMVert *v2, BMVert *v3, BMVert *v4,
142                              const BMFace *example, const int nodouble)
143 {
144         BMVert *vtar[4] = {v1, v2, v3, v4};
145         return BM_Make_Face_QuadTri_v(bm, vtar, v4 ? 4 : 3, example, nodouble);
146 }
147
148 /* remove the edge array bits from this. Its not really needed? */
149 BMFace *BM_Make_Face_QuadTri_v(BMesh *bm, BMVert **verts, int len, const BMFace *example, const int nodouble)
150 {
151         BMEdge *edar[4] = {NULL};
152         BMFace *f = NULL;
153         int overlap = 0;
154
155         edar[0] = BM_Edge_Exist(verts[0], verts[1]);
156         edar[1] = BM_Edge_Exist(verts[1], verts[2]);
157         if (len == 4) {
158                 edar[2] = BM_Edge_Exist(verts[2], verts[3]);
159                 edar[3] = BM_Edge_Exist(verts[3], verts[0]);
160         }
161         else {
162                 edar[2] = BM_Edge_Exist(verts[2], verts[0]);
163         }
164
165         if (nodouble) {
166                 /* check if face exists or overlaps */
167                 if (len == 4) {
168                         overlap = BM_Exist_Face_Overlaps(bm, verts, len, &f);
169                 }
170                 else {
171                         overlap = BM_Exist_Face_Overlaps(bm, verts, len, &f);
172                 }
173         }
174
175         /* make new face */
176         if ((!f) && (!overlap)) {
177                 if (!edar[0]) edar[0] = BM_Make_Edge(bm, verts[0], verts[1], NULL, 0);
178                 if (!edar[1]) edar[1] = BM_Make_Edge(bm, verts[1], verts[2], NULL, 0);
179                 if (len == 4) {
180                         if (!edar[2]) edar[2] = BM_Make_Edge(bm, verts[2], verts[3], NULL, 0);
181                         if (!edar[3]) edar[3] = BM_Make_Edge(bm, verts[3], verts[0], NULL, 0);
182                 }
183                 else {
184                         if (!edar[2]) edar[2] = BM_Make_Edge(bm, verts[2], verts[0], NULL, 0);
185                 }
186         
187                 f = BM_Make_Face(bm, verts, edar, len, 0);
188         
189                 if (example && f) {
190                         BM_Copy_Attributes(bm, bm, example, f);
191                 }
192         }
193
194         return f;
195 }
196
197
198 /* copies face data from shared adjacent faces */
199 void BM_Face_CopyShared(BMesh *bm, BMFace *f)
200 {
201         BMIter iter;
202         BMLoop *l, *l2;
203
204         if (!f) return;
205
206         l = BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, f);
207         for ( ; l; l = BMIter_Step(&iter)) {
208                 l2 = l->radial_next;
209                 
210                 if (l2 && l2 != l) {
211                         if (l2->v == l->v) {
212                                 bm_copy_loop_attributes(bm, bm, l2, l);
213                         }
214                         else {
215                                 l2 = l2->next;
216                                 bm_copy_loop_attributes(bm, bm, l2, l);
217                         }
218                 }
219         }
220 }
221
222 /*
223  * BMESH MAKE NGON
224  *
225  * Attempts to make a new Ngon from a list of edges.
226  * If nodouble equals one, a check for overlaps or existing
227  *
228  * The edges are not required to be ordered, simply to to form
229  * a single closed loop as a whole
230  *
231  * Note that while this function will work fine when the edges
232  * are already sorted, if the edges are always going to be sorted,
233  * BM_Make_Face should be considered over this function as it
234  * avoids some unnecessary work.
235  */
236 BMFace *BM_Make_Ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, int len, int nodouble)
237 {
238         BMEdge **edges2 = NULL;
239         BLI_array_staticdeclare(edges2, BM_NGON_STACK_SIZE);
240         BMVert **verts = NULL, *v;
241         BLI_array_staticdeclare(verts, BM_NGON_STACK_SIZE);
242         BMFace *f = NULL;
243         BMEdge *e;
244         BMVert *ev1, *ev2;
245         int i, /* j, */ v1found, reverse;
246
247         /* this code is hideous, yeek.  I'll have to think about ways of
248          *  cleaning it up.  basically, it now combines the old BM_Make_Ngon
249          *  _and_ the old bmesh_mf functions, so its kindof smashed together
250          * - joeedh */
251
252         if (!len || !v1 || !v2 || !edges || !bm)
253                 return NULL;
254
255         /* put edges in correct order */
256         for (i = 0; i < len; i++) {
257                 bmesh_api_setflag(edges[i], _FLAG_MF);
258         }
259
260         ev1 = edges[0]->v1;
261         ev2 = edges[0]->v2;
262
263         if (v1 == ev2) {
264                 /* Swapping here improves performance and consistency of face
265                  * structure in the special case that the edges are already in
266                  * the correct order and winding */
267                 SWAP(BMVert *, ev1, ev2);
268         }
269
270         BLI_array_append(verts, ev1);
271         v = ev2;
272         e = edges[0];
273         do {
274                 BMEdge *e2 = e;
275
276                 BLI_array_append(verts, v);
277                 BLI_array_append(edges2, e);
278
279                 do {
280                         e2 = bmesh_disk_nextedge(e2, v);
281                         if (e2 != e && bmesh_api_getflag(e2, _FLAG_MF)) {
282                                 v = BM_OtherEdgeVert(e2, v);
283                                 break;
284                         }
285                 } while (e2 != e);
286
287                 if (e2 == e)
288                         goto err; /* the edges do not form a closed loop */
289
290                 e = e2;
291         } while (e != edges[0]);
292
293         if (BLI_array_count(edges2) != len) {
294                 goto err; /* we didn't use all edges in forming the boundary loop */
295         }
296
297         /* ok, edges are in correct order, now ensure they are going
298          * in the correct direction */
299         v1found = reverse = 0;
300         for (i = 0; i < len; i++) {
301                 if (BM_Vert_In_Edge(edges2[i], v1)) {
302                         /* see if v1 and v2 are in the same edge */
303                         if (BM_Vert_In_Edge(edges2[i], v2)) {
304                                 /* if v1 is shared by the *next* edge, then the winding
305                                  * is incorrect */
306                                 if (BM_Vert_In_Edge(edges2[(i + 1) % len], v1)) {
307                                         reverse = 1;
308                                         break;
309                                 }
310                         }
311
312                         v1found = 1;
313                 }
314
315                 if (!v1found && BM_Vert_In_Edge(edges2[i], v2)) {
316                         reverse = 1;
317                         break;
318                 }
319         }
320
321         if (reverse) {
322                 for (i = 0; i < len / 2; i++) {
323                         v = verts[i];
324                         verts[i] = verts[len - i - 1];
325                         verts[len - i - 1] = v;
326                 }
327         }
328
329         for (i = 0; i < len; i++) {
330                 edges2[i] = BM_Edge_Exist(verts[i], verts[(i + 1) % len]);
331                 if (!edges2[i]) {
332                         goto err;
333                 }
334         }
335
336         f = BM_Make_Face(bm, verts, edges2, len, nodouble);
337
338         /* clean up flags */
339         for (i = 0; i < len; i++) {
340                 bmesh_api_clearflag(edges2[i], _FLAG_MF);
341         }
342
343         BLI_array_free(verts);
344         BLI_array_free(edges2);
345
346         return f;
347
348 err:
349         for (i = 0; i < len; i++) {
350                 bmesh_api_clearflag(edges[i], _FLAG_MF);
351         }
352
353         BLI_array_free(verts);
354         BLI_array_free(edges2);
355
356         return NULL;
357 }
358
359
360 /* bmesh_make_face_from_face(BMesh *bm, BMFace *source, BMFace *target) */
361
362
363 /*
364  * REMOVE TAGGED XXX
365  *
366  * Called by operators to remove elements that they have marked for
367  * removal.
368  *
369  */
370
371 void BM_remove_tagged_faces(BMesh *bm, const int oflag)
372 {
373         BMFace *f;
374         BMIter iter;
375
376         BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
377                 if (BMO_TestFlag(bm, f, oflag)) {
378                         BM_Kill_Face(bm, f);
379                 }
380         }
381 }
382
383 void BM_remove_tagged_edges(BMesh *bm, const int oflag)
384 {
385         BMEdge *e;
386         BMIter iter;
387
388         BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
389                 if (BMO_TestFlag(bm, e, oflag)) {
390                         BM_Kill_Edge(bm, e);
391                 }
392         }
393 }
394
395 void BM_remove_tagged_verts(BMesh *bm, const int oflag)
396 {
397         BMVert *v;
398         BMIter iter;
399
400         BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
401                 if (BMO_TestFlag(bm, v, oflag)) {
402                         BM_Kill_Vert(bm, v);
403                 }
404         }
405 }
406
407 static void bm_copy_vert_attributes(BMesh *source_mesh, BMesh *target_mesh,
408                                     const BMVert *source_vertex, BMVert *target_vertex)
409 {
410         if ((source_mesh == target_mesh) && (source_vertex == target_vertex)) {
411                 return;
412         }
413         copy_v3_v3(target_vertex->no, source_vertex->no);
414         CustomData_bmesh_free_block(&target_mesh->vdata, &target_vertex->head.data);
415         CustomData_bmesh_copy_data(&source_mesh->vdata, &target_mesh->vdata,
416                                    source_vertex->head.data, &target_vertex->head.data);
417 }
418
419 static void bm_copy_edge_attributes(BMesh *source_mesh, BMesh *target_mesh,
420                                     const BMEdge *source_edge, BMEdge *target_edge)
421 {
422         if ((source_mesh == target_mesh) && (source_edge == target_edge)) {
423                 return;
424         }
425         CustomData_bmesh_free_block(&target_mesh->edata, &target_edge->head.data);
426         CustomData_bmesh_copy_data(&source_mesh->edata, &target_mesh->edata,
427                                    source_edge->head.data, &target_edge->head.data);
428 }
429
430 static void bm_copy_loop_attributes(BMesh *source_mesh, BMesh *target_mesh,
431                                     const BMLoop *source_loop, BMLoop *target_loop)
432 {
433         if ((source_mesh == target_mesh) && (source_loop == target_loop)) {
434                 return;
435         }
436         CustomData_bmesh_free_block(&target_mesh->ldata, &target_loop->head.data);
437         CustomData_bmesh_copy_data(&source_mesh->ldata, &target_mesh->ldata,
438                                    source_loop->head.data, &target_loop->head.data);
439 }
440
441 static void bm_copy_face_attributes(BMesh *source_mesh, BMesh *target_mesh,
442                                     const BMFace *source_face, BMFace *target_face)
443 {
444         if ((source_mesh == target_mesh) && (source_face == target_face)) {
445                 return;
446         }
447         copy_v3_v3(target_face->no, source_face->no);
448         CustomData_bmesh_free_block(&target_mesh->pdata, &target_face->head.data);
449         CustomData_bmesh_copy_data(&source_mesh->pdata, &target_mesh->pdata,
450                                    source_face->head.data, &target_face->head.data);
451         target_face->mat_nr = source_face->mat_nr;
452 }
453
454 /* BMESH_TODO: Special handling for hide flags? */
455
456 void BM_Copy_Attributes(BMesh *source_mesh, BMesh *target_mesh, const void *source, void *target)
457 {
458         const BMHeader *sheader = source;
459         BMHeader *theader = target;
460         
461         if (sheader->htype != theader->htype)
462                 return;
463
464         /* First we copy select */
465         if (BM_Selected(source_mesh, source)) BM_Select(target_mesh, target, TRUE);
466         
467         /* Now we copy flags */
468         theader->hflag = sheader->hflag;
469         
470         /* Copy specific attributes */
471         if (theader->htype == BM_VERT)
472                 bm_copy_vert_attributes(source_mesh, target_mesh, (const BMVert *)source, (BMVert *)target);
473         else if (theader->htype == BM_EDGE)
474                 bm_copy_edge_attributes(source_mesh, target_mesh, (const BMEdge *)source, (BMEdge *)target);
475         else if (theader->htype == BM_LOOP)
476                 bm_copy_loop_attributes(source_mesh, target_mesh, (const BMLoop *)source, (BMLoop *)target);
477         else if (theader->htype == BM_FACE)
478                 bm_copy_face_attributes(source_mesh, target_mesh, (const BMFace *)source, (BMFace *)target);
479 }
480
481 BMesh *BM_Copy_Mesh(BMesh *bmold)
482 {
483         BMesh *bm;
484         BMVert *v, *v2, **vtable = NULL;
485         BMEdge *e, *e2, **edges = NULL, **etable = NULL;
486         BLI_array_declare(edges);
487         BMLoop *l, /* *l2, */ **loops = NULL;
488         BLI_array_declare(loops);
489         BMFace *f, *f2, **ftable = NULL;
490         BMEditSelection *ese;
491         BMIter iter, liter;
492         int allocsize[4] = {512, 512, 2048, 512};
493         int i, j;
494
495         /* allocate a bmesh */
496         bm = BM_Make_Mesh(bmold->ob, allocsize);
497
498         CustomData_copy(&bmold->vdata, &bm->vdata, CD_MASK_BMESH, CD_CALLOC, 0);
499         CustomData_copy(&bmold->edata, &bm->edata, CD_MASK_BMESH, CD_CALLOC, 0);
500         CustomData_copy(&bmold->ldata, &bm->ldata, CD_MASK_BMESH, CD_CALLOC, 0);
501         CustomData_copy(&bmold->pdata, &bm->pdata, CD_MASK_BMESH, CD_CALLOC, 0);
502
503         CustomData_bmesh_init_pool(&bm->vdata, allocsize[0]);
504         CustomData_bmesh_init_pool(&bm->edata, allocsize[1]);
505         CustomData_bmesh_init_pool(&bm->ldata, allocsize[2]);
506         CustomData_bmesh_init_pool(&bm->pdata, allocsize[3]);
507
508         vtable = MEM_mallocN(sizeof(BMVert *) * bmold->totvert, "BM_Copy_Mesh vtable");
509         etable = MEM_mallocN(sizeof(BMEdge *) * bmold->totedge, "BM_Copy_Mesh etable");
510         ftable = MEM_mallocN(sizeof(BMFace *) * bmold->totface, "BM_Copy_Mesh ftable");
511
512         v = BMIter_New(&iter, bmold, BM_VERTS_OF_MESH, NULL);
513         for (i = 0; v; v = BMIter_Step(&iter), i++) {
514                 v2 = BM_Make_Vert(bm, v->co, NULL); /* copy between meshes so cant use 'example' argument */
515                 BM_Copy_Attributes(bmold, bm, v, v2);
516                 vtable[i] = v2;
517                 BM_SetIndex(v, i); /* set_inline */
518                 BM_SetIndex(v2, i); /* set_inline */
519         }
520         bmold->elem_index_dirty &= ~BM_VERT;
521         bm->elem_index_dirty &= ~BM_VERT;
522
523         /* safety check */
524         BLI_assert(i == bmold->totvert);
525         
526         e = BMIter_New(&iter, bmold, BM_EDGES_OF_MESH, NULL);
527         for (i = 0; e; e = BMIter_Step(&iter), i++) {
528                 e2 = BM_Make_Edge(bm, vtable[BM_GetIndex(e->v1)],
529                                   vtable[BM_GetIndex(e->v2)], e, 0);
530
531                 BM_Copy_Attributes(bmold, bm, e, e2);
532                 etable[i] = e2;
533                 BM_SetIndex(e, i); /* set_inline */
534                 BM_SetIndex(e2, i); /* set_inline */
535         }
536         bmold->elem_index_dirty &= ~BM_EDGE;
537         bm->elem_index_dirty &= ~BM_EDGE;
538
539         /* safety check */
540         BLI_assert(i == bmold->totedge);
541         
542         f = BMIter_New(&iter, bmold, BM_FACES_OF_MESH, NULL);
543         for (i = 0; f; f = BMIter_Step(&iter), i++) {
544                 BM_SetIndex(f, i); /* set_inline */
545
546                 BLI_array_empty(loops);
547                 BLI_array_empty(edges);
548                 BLI_array_growitems(loops, f->len);
549                 BLI_array_growitems(edges, f->len);
550
551                 l = BMIter_New(&liter, bmold, BM_LOOPS_OF_FACE, f);
552                 for (j = 0; j < f->len; j++, l = BMIter_Step(&liter)) {
553                         loops[j] = l;
554                         edges[j] = etable[BM_GetIndex(l->e)];
555                 }
556
557                 v = vtable[BM_GetIndex(loops[0]->v)];
558                 v2 = vtable[BM_GetIndex(loops[1]->v)];
559
560                 if (!bmesh_verts_in_edge(v, v2, edges[0])) {
561                         v = vtable[BM_GetIndex(loops[BLI_array_count(loops) - 1]->v)];
562                         v2 = vtable[BM_GetIndex(loops[0]->v)];
563                 }
564
565                 f2 = BM_Make_Ngon(bm, v, v2, edges, f->len, 0);
566                 if (!f2)
567                         continue;
568                 /* use totface incase adding some faces fails */
569                 BM_SetIndex(f2, (bm->totface - 1)); /* set_inline */
570
571                 ftable[i] = f2;
572
573                 BM_Copy_Attributes(bmold, bm, f, f2);
574                 copy_v3_v3(f2->no, f->no);
575
576                 l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f2);
577                 for (j = 0; j < f->len; j++, l = BMIter_Step(&liter)) {
578                         BM_Copy_Attributes(bmold, bm, loops[j], l);
579                 }
580
581                 if (f == bmold->act_face) bm->act_face = f2;
582         }
583         bmold->elem_index_dirty &= ~BM_FACE;
584         bm->elem_index_dirty &= ~BM_FACE;
585
586         /* safety check */
587         BLI_assert(i == bmold->totface);
588
589         /* copy over edit selection history */
590         for (ese = bmold->selected.first; ese; ese = ese->next) {
591                 void *ele = NULL;
592
593                 if (ese->htype == BM_VERT)
594                         ele = vtable[BM_GetIndex(ese->data)];
595                 else if (ese->htype == BM_EDGE)
596                         ele = etable[BM_GetIndex(ese->data)];
597                 else if (ese->htype == BM_FACE) {
598                         ele = ftable[BM_GetIndex(ese->data)];
599                 }
600                 else {
601                         BLI_assert(0);
602                 }
603                 
604                 if (ele)
605                         BM_store_selection(bm, ele);
606         }
607
608         MEM_freeN(etable);
609         MEM_freeN(vtable);
610         MEM_freeN(ftable);
611
612         BLI_array_free(loops);
613         BLI_array_free(edges);
614
615         return bm;
616 }
617
618 /* ME -> BM */
619 char BM_Vert_Flag_From_MEFlag(const char  meflag)
620 {
621     return ( ((meflag & SELECT)       ? BM_SELECT : 0) |
622              ((meflag & ME_HIDE)      ? BM_HIDDEN : 0)
623              );
624 }
625 char BM_Edge_Flag_From_MEFlag(const short meflag)
626 {
627         return ( ((meflag & SELECT)       ? BM_SELECT : 0) |
628                  ((meflag & ME_SEAM)      ? BM_SEAM   : 0) |
629                  ((meflag & ME_SHARP)     ? BM_SHARP  : 0) |
630                  ((meflag & ME_HIDE)      ? BM_HIDDEN : 0)
631                  );
632 }
633 char BM_Face_Flag_From_MEFlag(const char  meflag)
634 {
635     return ( ((meflag & ME_FACE_SEL)  ? BM_SELECT : 0) |
636              ((meflag & ME_SMOOTH)    ? BM_SMOOTH : 0) |
637              ((meflag & ME_HIDE)      ? BM_HIDDEN : 0)
638              );
639 }
640
641 /* BM -> ME */
642 char  BM_Vert_Flag_To_MEFlag(BMVert *eve)
643 {
644     const char hflag = eve->head.hflag;
645
646     return ( ((hflag & BM_SELECT)  ? SELECT  : 0) |
647              ((hflag & BM_HIDDEN)  ? ME_HIDE : 0)
648              );
649 }
650 short BM_Edge_Flag_To_MEFlag(BMEdge *eed)
651 {
652         const char hflag = eed->head.hflag;
653
654         return ( ((hflag & BM_SELECT)       ? SELECT    : 0) |
655                  ((hflag & BM_SEAM)         ? ME_SEAM   : 0) |
656                  ((hflag & BM_SHARP)        ? ME_SHARP  : 0) |
657                  ((hflag & BM_HIDDEN)       ? ME_HIDE   : 0) |
658                  ((BM_Wire_Edge(NULL, eed)) ? ME_LOOSEEDGE : 0) | /* not typical */
659                  (ME_EDGEDRAW | ME_EDGERENDER)
660                  );
661 }
662 char  BM_Face_Flag_To_MEFlag(BMFace *efa)
663 {
664     const char hflag = efa->head.hflag;
665
666     return ( ((hflag & BM_SELECT) ? ME_FACE_SEL : 0) |
667              ((hflag & BM_SMOOTH) ? ME_SMOOTH   : 0) |
668              ((hflag & BM_HIDDEN) ? ME_HIDE     : 0)
669              );
670 }
671
672 /* unused, type spesific functions below */
673 #if 0
674 /*
675   BM FLAGS TO ME FLAGS
676
677   Returns the flags stored in element,
678   which much be either a BMVert, BMEdge,
679   or BMFace, converted to mesh flags.
680  */
681 short BMFlags_To_MEFlags(void *element)
682 {
683         const char src_htype = ((BMHeader *)element)->htype;
684
685         if (src_htype == BM_FACE) {
686                 return BM_Face_Flag_To_MEFlag(element);
687         }
688         else if (src_htype == BM_EDGE) {
689                 return BM_Edge_Flag_To_MEFlag(element);
690         }
691         else if (src_htype == BM_VERT) {
692                 return BM_Vert_Flag_To_MEFlag(element);
693         }
694         else {
695                 return 0;
696         }
697 }
698
699 /*
700   BM FLAGS TO ME FLAGS
701
702   Returns the flags stored in element,
703   which much be either a MVert, MEdge,
704   or MPoly, converted to mesh flags.
705   type must be either BM_VERT, BM_EDGE,
706   or BM_FACE.
707  */
708 char MEFlags_To_BMFlags(const short hflag, const char htype)
709 {
710         if (htype == BM_FACE) {
711                 return BM_Face_Flag_From_MEFlag(hflag);
712         }
713         else if (htype == BM_EDGE) {
714                 return BM_Edge_Flag_From_MEFlag(hflag);
715         }
716         else if (htype == BM_VERT) {
717                 return BM_Vert_Flag_From_MEFlag(hflag);
718         }
719         else {
720                 return 0;
721         }
722 }
723 #endif