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