source/blender/editors/mesh/mesh_data.c

   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  * The Original Code is Copyright (C) 2009 Blender Foundation.
  17  * All rights reserved.
  18  */
  19
  20 /** \file
  21  * \ingroup edmesh
  22  */
  23
  24 #include "MEM_guardedalloc.h"
  25
  26 #include "DNA_mesh_types.h"
  27 #include "DNA_meshdata_types.h"
  28 #include "DNA_object_types.h"
  29 #include "DNA_scene_types.h"
  30 #include "DNA_view3d_types.h"
  31
  32 #include "BLI_alloca.h"
  33 #include "BLI_math.h"
  34 #include "BLI_utildefines.h"
  35
  36 #include "BKE_context.h"
  37 #include "BKE_editmesh.h"
  38 #include "BKE_mesh.h"
  39 #include "BKE_report.h"
  40
  41 #include "DEG_depsgraph.h"
  42
  43 #include "RNA_access.h"
  44 #include "RNA_define.h"
  45
  46 #include "WM_api.h"
  47 #include "WM_types.h"
  48
  49 #include "ED_mesh.h"
  50 #include "ED_object.h"
  51 #include "ED_paint.h"
  52 #include "ED_screen.h"
  53 #include "ED_uvedit.h"
  54 #include "ED_view3d.h"
  55
  56 #include "mesh_intern.h" /* own include */
  57
  58 static CustomData *mesh_customdata_get_type(Mesh *me, const char htype, int *r_tot)
  59 {
  60   CustomData *data;
  61   BMesh *bm = (me->edit_mesh) ? me->edit_mesh->bm : NULL;
  62   int tot;
  63
  64   /* this  */
  65   switch (htype) {
  66     case BM_VERT:
  67       if (bm) {
  68         data = &bm->vdata;
  69         tot = bm->totvert;
  70       }
  71       else {
  72         data = &me->vdata;
  73         tot = me->totvert;
  74       }
  75       break;
  76     case BM_EDGE:
  77       if (bm) {
  78         data = &bm->edata;
  79         tot = bm->totedge;
  80       }
  81       else {
  82         data = &me->edata;
  83         tot = me->totedge;
  84       }
  85       break;
  86     case BM_LOOP:
  87       if (bm) {
  88         data = &bm->ldata;
  89         tot = bm->totloop;
  90       }
  91       else {
  92         data = &me->ldata;
  93         tot = me->totloop;
  94       }
  95       break;
  96     case BM_FACE:
  97       if (bm) {
  98         data = &bm->pdata;
  99         tot = bm->totface;
 100       }
 101       else {
 102         data = &me->pdata;
 103         tot = me->totpoly;
 104       }
 105       break;
 106     default:
 107       BLI_assert(0);
 108       tot = 0;
 109       data = NULL;
 110       break;
 111   }
 112
 113   *r_tot = tot;
 114   return data;
 115 }
 116
 117 #define GET_CD_DATA(me, data) ((me)->edit_mesh ? &(me)->edit_mesh->bm->data : &(me)->data)
 118 static void delete_customdata_layer(Mesh *me, CustomDataLayer *layer)
 119 {
 120   const int type = layer->type;
 121   CustomData *data;
 122   int layer_index, tot, n;
 123
 124   char htype = BM_FACE;
 125   if (ELEM(type, CD_MLOOPCOL, CD_MLOOPUV)) {
 126     htype = BM_LOOP;
 127   }
 128   else if (ELEM(type, CD_PROP_COLOR)) {
 129     htype = BM_VERT;
 130   }
 131
 132   data = mesh_customdata_get_type(me, htype, &tot);
 133   layer_index = CustomData_get_layer_index(data, type);
 134   n = (layer - &data->layers[layer_index]);
 135   BLI_assert(n >= 0 && (n + layer_index) < data->totlayer);
 136
 137   if (me->edit_mesh) {
 138     BM_data_layer_free_n(me->edit_mesh->bm, data, type, n);
 139   }
 140   else {
 141     CustomData_free_layer(data, type, tot, layer_index + n);
 142     BKE_mesh_update_customdata_pointers(me, true);
 143   }
 144 }
 145
 146 static void mesh_uv_reset_array(float **fuv, const int len)
 147 {
 148   if (len == 3) {
 149     fuv[0][0] = 0.0;
 150     fuv[0][1] = 0.0;
 151
 152     fuv[1][0] = 1.0;
 153     fuv[1][1] = 0.0;
 154
 155     fuv[2][0] = 1.0;
 156     fuv[2][1] = 1.0;
 157   }
 158   else if (len == 4) {
 159     fuv[0][0] = 0.0;
 160     fuv[0][1] = 0.0;
 161
 162     fuv[1][0] = 1.0;
 163     fuv[1][1] = 0.0;
 164
 165     fuv[2][0] = 1.0;
 166     fuv[2][1] = 1.0;
 167
 168     fuv[3][0] = 0.0;
 169     fuv[3][1] = 1.0;
 170     /*make sure we ignore 2-sided faces*/
 171   }
 172   else if (len > 2) {
 173     float fac = 0.0f, dfac = 1.0f / (float)len;
 174
 175     dfac *= (float)M_PI * 2.0f;
 176
 177     for (int i = 0; i < len; i++) {
 178       fuv[i][0] = 0.5f * sinf(fac) + 0.5f;
 179       fuv[i][1] = 0.5f * cosf(fac) + 0.5f;
 180
 181       fac += dfac;
 182     }
 183   }
 184 }
 185
 186 static void mesh_uv_reset_bmface(BMFace *f, const int cd_loop_uv_offset)
 187 {
 188   float **fuv = BLI_array_alloca(fuv, f->len);
 189   BMIter liter;
 190   BMLoop *l;
 191   int i;
 192
 193   BM_ITER_ELEM_INDEX (l, &liter, f, BM_LOOPS_OF_FACE, i) {
 194     fuv[i] = ((MLoopUV *)BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset))->uv;
 195   }
 196
 197   mesh_uv_reset_array(fuv, f->len);
 198 }
 199
 200 static void mesh_uv_reset_mface(MPoly *mp, MLoopUV *mloopuv)
 201 {
 202   float **fuv = BLI_array_alloca(fuv, mp->totloop);
 203
 204   for (int i = 0; i < mp->totloop; i++) {
 205     fuv[i] = mloopuv[mp->loopstart + i].uv;
 206   }
 207
 208   mesh_uv_reset_array(fuv, mp->totloop);
 209 }
 210
 211 /* without bContext, called in uvedit */
 212 void ED_mesh_uv_loop_reset_ex(struct Mesh *me, const int layernum)
 213 {
 214   BMEditMesh *em = me->edit_mesh;
 215
 216   if (em) {
 217     /* Collect BMesh UVs */
 218     const int cd_loop_uv_offset = CustomData_get_n_offset(&em->bm->ldata, CD_MLOOPUV, layernum);
 219
 220     BMFace *efa;
 221     BMIter iter;
 222
 223     BLI_assert(cd_loop_uv_offset != -1);
 224
 225     BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
 226       if (!BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
 227         continue;
 228       }
 229
 230       mesh_uv_reset_bmface(efa, cd_loop_uv_offset);
 231     }
 232   }
 233   else {
 234     /* Collect Mesh UVs */
 235     BLI_assert(CustomData_has_layer(&me->ldata, CD_MLOOPUV));
 236     MLoopUV *mloopuv = CustomData_get_layer_n(&me->ldata, CD_MLOOPUV, layernum);
 237
 238     for (int i = 0; i < me->totpoly; i++) {
 239       mesh_uv_reset_mface(&me->mpoly[i], mloopuv);
 240     }
 241   }
 242
 243   DEG_id_tag_update(&me->id, 0);
 244 }
 245
 246 void ED_mesh_uv_loop_reset(struct bContext *C, struct Mesh *me)
 247 {
 248   /* could be ldata or pdata */
 249   CustomData *ldata = GET_CD_DATA(me, ldata);
 250   const int layernum = CustomData_get_active_layer(ldata, CD_MLOOPUV);
 251   ED_mesh_uv_loop_reset_ex(me, layernum);
 252
 253   WM_event_add_notifier(C, NC_GEOM | ND_DATA, me);
 254 }
 255
 256 /* note: keep in sync with ED_mesh_color_add */
 257 int ED_mesh_uv_texture_add(Mesh *me, const char *name, const bool active_set, const bool do_init)
 258 {
 259   BMEditMesh *em;
 260   int layernum_dst;
 261
 262   bool is_init = false;
 263
 264   if (me->edit_mesh) {
 265     em = me->edit_mesh;
 266
 267     layernum_dst = CustomData_number_of_layers(&em->bm->ldata, CD_MLOOPUV);
 268     if (layernum_dst >= MAX_MTFACE) {
 269       return -1;
 270     }
 271
 272     /* CD_MLOOPUV */
 273     BM_data_layer_add_named(em->bm, &em->bm->ldata, CD_MLOOPUV, name);
 274     /* copy data from active UV */
 275     if (layernum_dst && do_init) {
 276       const int layernum_src = CustomData_get_active_layer(&em->bm->ldata, CD_MLOOPUV);
 277       BM_data_layer_copy(em->bm, &em->bm->ldata, CD_MLOOPUV, layernum_src, layernum_dst);
 278
 279       is_init = true;
 280     }
 281     if (active_set || layernum_dst == 0) {
 282       CustomData_set_layer_active(&em->bm->ldata, CD_MLOOPUV, layernum_dst);
 283     }
 284   }
 285   else {
 286     layernum_dst = CustomData_number_of_layers(&me->ldata, CD_MLOOPUV);
 287     if (layernum_dst >= MAX_MTFACE) {
 288       return -1;
 289     }
 290
 291     if (me->mloopuv && do_init) {
 292       CustomData_add_layer_named(
 293           &me->ldata, CD_MLOOPUV, CD_DUPLICATE, me->mloopuv, me->totloop, name);
 294       is_init = true;
 295     }
 296     else {
 297       CustomData_add_layer_named(&me->ldata, CD_MLOOPUV, CD_DEFAULT, NULL, me->totloop, name);
 298     }
 299
 300     if (active_set || layernum_dst == 0) {
 301       CustomData_set_layer_active(&me->ldata, CD_MLOOPUV, layernum_dst);
 302     }
 303
 304     BKE_mesh_update_customdata_pointers(me, true);
 305   }
 306
 307   /* don't overwrite our copied coords */
 308   if (!is_init && do_init) {
 309     ED_mesh_uv_loop_reset_ex(me, layernum_dst);
 310   }
 311
 312   DEG_id_tag_update(&me->id, 0);
 313   WM_main_add_notifier(NC_GEOM | ND_DATA, me);
 314
 315   return layernum_dst;
 316 }
 317
 318 void ED_mesh_uv_texture_ensure(struct Mesh *me, const char *name)
 319 {
 320   BMEditMesh *em;
 321   int layernum_dst;
 322
 323   if (me->edit_mesh) {
 324     em = me->edit_mesh;
 325
 326     layernum_dst = CustomData_number_of_layers(&em->bm->ldata, CD_MLOOPUV);
 327     if (layernum_dst == 0) {
 328       ED_mesh_uv_texture_add(me, name, true, true);
 329     }
 330   }
 331   else {
 332     layernum_dst = CustomData_number_of_layers(&me->ldata, CD_MLOOPUV);
 333     if (layernum_dst == 0) {
 334       ED_mesh_uv_texture_add(me, name, true, true);
 335     }
 336   }
 337 }
 338
 339 bool ED_mesh_uv_texture_remove_index(Mesh *me, const int n)
 340 {
 341   CustomData *ldata = GET_CD_DATA(me, ldata);
 342   CustomDataLayer *cdlu;
 343   int index;
 344
 345   index = CustomData_get_layer_index_n(ldata, CD_MLOOPUV, n);
 346   cdlu = (index == -1) ? NULL : &ldata->layers[index];
 347
 348   if (!cdlu) {
 349     return false;
 350   }
 351
 352   delete_customdata_layer(me, cdlu);
 353
 354   DEG_id_tag_update(&me->id, 0);
 355   WM_main_add_notifier(NC_GEOM | ND_DATA, me);
 356
 357   return true;
 358 }
 359 bool ED_mesh_uv_texture_remove_active(Mesh *me)
 360 {
 361   /* texpoly/uv are assumed to be in sync */
 362   CustomData *ldata = GET_CD_DATA(me, ldata);
 363   const int n = CustomData_get_active_layer(ldata, CD_MLOOPUV);
 364
 365   if (n != -1) {
 366     return ED_mesh_uv_texture_remove_index(me, n);
 367   }
 368   return false;
 369 }
 370 bool ED_mesh_uv_texture_remove_named(Mesh *me, const char *name)
 371 {
 372   /* texpoly/uv are assumed to be in sync */
 373   CustomData *ldata = GET_CD_DATA(me, ldata);
 374   const int n = CustomData_get_named_layer(ldata, CD_MLOOPUV, name);
 375   if (n != -1) {
 376     return ED_mesh_uv_texture_remove_index(me, n);
 377   }
 378   return false;
 379 }
 380
 381 /* note: keep in sync with ED_mesh_uv_texture_add */
 382 int ED_mesh_color_add(Mesh *me, const char *name, const bool active_set, const bool do_init)
 383 {
 384   BMEditMesh *em;
 385   int layernum;
 386
 387   if (me->edit_mesh) {
 388     em = me->edit_mesh;
 389
 390     layernum = CustomData_number_of_layers(&em->bm->ldata, CD_MLOOPCOL);
 391     if (layernum >= MAX_MCOL) {
 392       return -1;
 393     }
 394
 395     /* CD_MLOOPCOL */
 396     BM_data_layer_add_named(em->bm, &em->bm->ldata, CD_MLOOPCOL, name);
 397     /* copy data from active vertex color layer */
 398     if (layernum && do_init) {
 399       const int layernum_dst = CustomData_get_active_layer(&em->bm->ldata, CD_MLOOPCOL);
 400       BM_data_layer_copy(em->bm, &em->bm->ldata, CD_MLOOPCOL, layernum_dst, layernum);
 401     }
 402     if (active_set || layernum == 0) {
 403       CustomData_set_layer_active(&em->bm->ldata, CD_MLOOPCOL, layernum);
 404     }
 405   }
 406   else {
 407     layernum = CustomData_number_of_layers(&me->ldata, CD_MLOOPCOL);
 408     if (layernum >= MAX_MCOL) {
 409       return -1;
 410     }
 411
 412     if (me->mloopcol && do_init) {
 413       CustomData_add_layer_named(
 414           &me->ldata, CD_MLOOPCOL, CD_DUPLICATE, me->mloopcol, me->totloop, name);
 415     }
 416     else {
 417       CustomData_add_layer_named(&me->ldata, CD_MLOOPCOL, CD_DEFAULT, NULL, me->totloop, name);
 418     }
 419
 420     if (active_set || layernum == 0) {
 421       CustomData_set_layer_active(&me->ldata, CD_MLOOPCOL, layernum);
 422     }
 423
 424     BKE_mesh_update_customdata_pointers(me, true);
 425   }
 426
 427   DEG_id_tag_update(&me->id, 0);
 428   WM_main_add_notifier(NC_GEOM | ND_DATA, me);
 429
 430   return layernum;
 431 }
 432
 433 bool ED_mesh_color_ensure(struct Mesh *me, const char *name)
 434 {
 435   BLI_assert(me->edit_mesh == NULL);
 436
 437   if (!me->mloopcol && me->totloop) {
 438     CustomData_add_layer_named(&me->ldata, CD_MLOOPCOL, CD_DEFAULT, NULL, me->totloop, name);
 439     BKE_mesh_update_customdata_pointers(me, true);
 440   }
 441
 442   DEG_id_tag_update(&me->id, 0);
 443
 444   return (me->mloopcol != NULL);
 445 }
 446
 447 bool ED_mesh_color_remove_index(Mesh *me, const int n)
 448 {
 449   CustomData *ldata = GET_CD_DATA(me, ldata);
 450   CustomDataLayer *cdl;
 451   int index;
 452
 453   index = CustomData_get_layer_index_n(ldata, CD_MLOOPCOL, n);
 454   cdl = (index == -1) ? NULL : &ldata->layers[index];
 455
 456   if (!cdl) {
 457     return false;
 458   }
 459
 460   delete_customdata_layer(me, cdl);
 461   DEG_id_tag_update(&me->id, 0);
 462   WM_main_add_notifier(NC_GEOM | ND_DATA, me);
 463
 464   return true;
 465 }
 466 bool ED_mesh_color_remove_active(Mesh *me)
 467 {
 468   CustomData *ldata = GET_CD_DATA(me, ldata);
 469   const int n = CustomData_get_active_layer(ldata, CD_MLOOPCOL);
 470   if (n != -1) {
 471     return ED_mesh_color_remove_index(me, n);
 472   }
 473   return false;
 474 }
 475 bool ED_mesh_color_remove_named(Mesh *me, const char *name)
 476 {
 477   CustomData *ldata = GET_CD_DATA(me, ldata);
 478   const int n = CustomData_get_named_layer(ldata, CD_MLOOPCOL, name);
 479   if (n != -1) {
 480     return ED_mesh_color_remove_index(me, n);
 481   }
 482   return false;
 483 }
 484
 485 /*********************** Sculpt Vertex colors operators ************************/
 486
 487 /* note: keep in sync with ED_mesh_uv_texture_add */
 488 int ED_mesh_sculpt_color_add(Mesh *me, const char *name, const bool active_set, const bool do_init)
 489 {
 490   BMEditMesh *em;
 491   int layernum;
 492
 493   if (me->edit_mesh) {
 494     em = me->edit_mesh;
 495
 496     layernum = CustomData_number_of_layers(&em->bm->vdata, CD_PROP_COLOR);
 497     if (layernum >= MAX_MCOL) {
 498       return -1;
 499     }
 500
 501     /* CD_PROP_COLOR */
 502     BM_data_layer_add_named(em->bm, &em->bm->vdata, CD_PROP_COLOR, name);
 503     /* copy data from active vertex color layer */
 504     if (layernum && do_init) {
 505       const int layernum_dst = CustomData_get_active_layer(&em->bm->vdata, CD_PROP_COLOR);
 506       BM_data_layer_copy(em->bm, &em->bm->vdata, CD_PROP_COLOR, layernum_dst, layernum);
 507     }
 508     if (active_set || layernum == 0) {
 509       CustomData_set_layer_active(&em->bm->vdata, CD_PROP_COLOR, layernum);
 510     }
 511   }
 512   else {
 513     layernum = CustomData_number_of_layers(&me->vdata, CD_PROP_COLOR);
 514     if (layernum >= MAX_MCOL) {
 515       return -1;
 516     }
 517
 518     if (CustomData_has_layer(&me->vdata, CD_PROP_COLOR) && do_init) {
 519       MPropCol *color_data = CustomData_get_layer(&me->vdata, CD_PROP_COLOR);
 520       CustomData_add_layer_named(
 521           &me->vdata, CD_PROP_COLOR, CD_DUPLICATE, color_data, me->totvert, name);
 522     }
 523     else {
 524       CustomData_add_layer_named(&me->vdata, CD_PROP_COLOR, CD_DEFAULT, NULL, me->totvert, name);
 525     }
 526
 527     if (active_set || layernum == 0) {
 528       CustomData_set_layer_active(&me->vdata, CD_PROP_COLOR, layernum);
 529     }
 530
 531     BKE_mesh_update_customdata_pointers(me, true);
 532   }
 533
 534   DEG_id_tag_update(&me->id, 0);
 535   WM_main_add_notifier(NC_GEOM | ND_DATA, me);
 536
 537   return layernum;
 538 }
 539
 540 bool ED_mesh_sculpt_color_ensure(struct Mesh *me, const char *name)
 541 {
 542   BLI_assert(me->edit_mesh == NULL);
 543
 544   if (me->totvert && !CustomData_has_layer(&me->vdata, CD_PROP_COLOR)) {
 545     CustomData_add_layer_named(&me->vdata, CD_PROP_COLOR, CD_DEFAULT, NULL, me->totvert, name);
 546     BKE_mesh_update_customdata_pointers(me, true);
 547   }
 548
 549   DEG_id_tag_update(&me->id, 0);
 550
 551   return (me->mloopcol != NULL);
 552 }
 553
 554 bool ED_mesh_sculpt_color_remove_index(Mesh *me, const int n)
 555 {
 556   CustomData *vdata = GET_CD_DATA(me, vdata);
 557   CustomDataLayer *cdl;
 558   int index;
 559
 560   index = CustomData_get_layer_index_n(vdata, CD_PROP_COLOR, n);
 561   cdl = (index == -1) ? NULL : &vdata->layers[index];
 562
 563   if (!cdl) {
 564     return false;
 565   }
 566
 567   delete_customdata_layer(me, cdl);
 568   DEG_id_tag_update(&me->id, 0);
 569   WM_main_add_notifier(NC_GEOM | ND_DATA, me);
 570
 571   return true;
 572 }
 573 bool ED_mesh_sculpt_color_remove_active(Mesh *me)
 574 {
 575   CustomData *vdata = GET_CD_DATA(me, vdata);
 576   const int n = CustomData_get_active_layer(vdata, CD_PROP_COLOR);
 577   if (n != -1) {
 578     return ED_mesh_sculpt_color_remove_index(me, n);
 579   }
 580   return false;
 581 }
 582 bool ED_mesh_sculpt_color_remove_named(Mesh *me, const char *name)
 583 {
 584   CustomData *vdata = GET_CD_DATA(me, vdata);
 585   const int n = CustomData_get_named_layer(vdata, CD_PROP_COLOR, name);
 586   if (n != -1) {
 587     return ED_mesh_sculpt_color_remove_index(me, n);
 588   }
 589   return false;
 590 }
 591
 592 /*********************** UV texture operators ************************/
 593
 594 static bool layers_poll(bContext *C)
 595 {
 596   Object *ob = ED_object_context(C);
 597   ID *data = (ob) ? ob->data : NULL;
 598   return (ob && !ID_IS_LINKED(ob) && ob->type == OB_MESH && data && !ID_IS_LINKED(data));
 599 }
 600
 601 static int mesh_uv_texture_add_exec(bContext *C, wmOperator *UNUSED(op))
 602 {
 603   Object *ob = ED_object_context(C);
 604   Mesh *me = ob->data;
 605
 606   if (ED_mesh_uv_texture_add(me, NULL, true, true) == -1) {
 607     return OPERATOR_CANCELLED;
 608   }
 609
 610   if (ob->mode & OB_MODE_TEXTURE_PAINT) {
 611     Scene *scene = CTX_data_scene(C);
 612     ED_paint_proj_mesh_data_check(scene, ob, NULL, NULL, NULL, NULL);
 613     WM_event_add_notifier(C, NC_SCENE | ND_TOOLSETTINGS, NULL);
 614   }
 615
 616   return OPERATOR_FINISHED;
 617 }
 618
 619 void MESH_OT_uv_texture_add(wmOperatorType *ot)
 620 {
 621   /* identifiers */
 622   ot->name = "Add UV Map";
 623   ot->description = "Add UV map";
 624   ot->idname = "MESH_OT_uv_texture_add";
 625
 626   /* api callbacks */
 627   ot->poll = layers_poll;
 628   ot->exec = mesh_uv_texture_add_exec;
 629
 630   /* flags */
 631   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 632 }
 633
 634 static int mesh_uv_texture_remove_exec(bContext *C, wmOperator *UNUSED(op))
 635 {
 636   Object *ob = ED_object_context(C);
 637   Mesh *me = ob->data;
 638
 639   if (!ED_mesh_uv_texture_remove_active(me)) {
 640     return OPERATOR_CANCELLED;
 641   }
 642
 643   if (ob->mode & OB_MODE_TEXTURE_PAINT) {
 644     Scene *scene = CTX_data_scene(C);
 645     ED_paint_proj_mesh_data_check(scene, ob, NULL, NULL, NULL, NULL);
 646     WM_event_add_notifier(C, NC_SCENE | ND_TOOLSETTINGS, NULL);
 647   }
 648
 649   return OPERATOR_FINISHED;
 650 }
 651
 652 void MESH_OT_uv_texture_remove(wmOperatorType *ot)
 653 {
 654   /* identifiers */
 655   ot->name = "Remove UV Map";
 656   ot->description = "Remove UV map";
 657   ot->idname = "MESH_OT_uv_texture_remove";
 658
 659   /* api callbacks */
 660   ot->poll = layers_poll;
 661   ot->exec = mesh_uv_texture_remove_exec;
 662
 663   /* flags */
 664   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 665 }
 666
 667 /*********************** vertex color operators ************************/
 668
 669 static int mesh_vertex_color_add_exec(bContext *C, wmOperator *UNUSED(op))
 670 {
 671   Object *ob = ED_object_context(C);
 672   Mesh *me = ob->data;
 673
 674   if (ED_mesh_color_add(me, NULL, true, true) == -1) {
 675     return OPERATOR_CANCELLED;
 676   }
 677
 678   return OPERATOR_FINISHED;
 679 }
 680
 681 void MESH_OT_vertex_color_add(wmOperatorType *ot)
 682 {
 683   /* identifiers */
 684   ot->name = "Add Vertex Color";
 685   ot->description = "Add vertex color layer";
 686   ot->idname = "MESH_OT_vertex_color_add";
 687
 688   /* api callbacks */
 689   ot->poll = layers_poll;
 690   ot->exec = mesh_vertex_color_add_exec;
 691
 692   /* flags */
 693   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 694 }
 695
 696 static int mesh_vertex_color_remove_exec(bContext *C, wmOperator *UNUSED(op))
 697 {
 698   Object *ob = ED_object_context(C);
 699   Mesh *me = ob->data;
 700
 701   if (!ED_mesh_color_remove_active(me)) {
 702     return OPERATOR_CANCELLED;
 703   }
 704
 705   return OPERATOR_FINISHED;
 706 }
 707
 708 void MESH_OT_vertex_color_remove(wmOperatorType *ot)
 709 {
 710   /* identifiers */
 711   ot->name = "Remove Vertex Color";
 712   ot->description = "Remove vertex color layer";
 713   ot->idname = "MESH_OT_vertex_color_remove";
 714
 715   /* api callbacks */
 716   ot->exec = mesh_vertex_color_remove_exec;
 717   ot->poll = layers_poll;
 718
 719   /* flags */
 720   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 721 }
 722
 723 /*********************** Sculpt Vertex Color Operators ************************/
 724
 725 static int mesh_sculpt_vertex_color_add_exec(bContext *C, wmOperator *UNUSED(op))
 726 {
 727   Object *ob = ED_object_context(C);
 728   Mesh *me = ob->data;
 729
 730   if (ED_mesh_sculpt_color_add(me, NULL, true, true) == -1) {
 731     return OPERATOR_CANCELLED;
 732   }
 733
 734   return OPERATOR_FINISHED;
 735 }
 736
 737 void MESH_OT_sculpt_vertex_color_add(wmOperatorType *ot)
 738 {
 739   /* identifiers */
 740   ot->name = "Add Sculpt Vertex Color";
 741   ot->description = "Add vertex color layer";
 742   ot->idname = "MESH_OT_sculpt_vertex_color_add";
 743
 744   /* api callbacks */
 745   ot->poll = layers_poll;
 746   ot->exec = mesh_sculpt_vertex_color_add_exec;
 747
 748   /* flags */
 749   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 750 }
 751
 752 static int mesh_sculpt_vertex_color_remove_exec(bContext *C, wmOperator *UNUSED(op))
 753 {
 754   Object *ob = ED_object_context(C);
 755   Mesh *me = ob->data;
 756
 757   if (!ED_mesh_sculpt_color_remove_active(me)) {
 758     return OPERATOR_CANCELLED;
 759   }
 760
 761   return OPERATOR_FINISHED;
 762 }
 763
 764 void MESH_OT_sculpt_vertex_color_remove(wmOperatorType *ot)
 765 {
 766   /* identifiers */
 767   ot->name = "Remove Sculpt Vertex Color";
 768   ot->description = "Remove vertex color layer";
 769   ot->idname = "MESH_OT_sculpt_vertex_color_remove";
 770
 771   /* api callbacks */
 772   ot->exec = mesh_sculpt_vertex_color_remove_exec;
 773   ot->poll = layers_poll;
 774
 775   /* flags */
 776   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 777 }
 778
 779 /* *** CustomData clear functions, we need an operator for each *** */
 780
 781 static int mesh_customdata_clear_exec__internal(bContext *C, char htype, int type)
 782 {
 783   Mesh *me = ED_mesh_context(C);
 784
 785   int tot;
 786   CustomData *data = mesh_customdata_get_type(me, htype, &tot);
 787
 788   BLI_assert(CustomData_layertype_is_singleton(type) == true);
 789
 790   if (CustomData_has_layer(data, type)) {
 791     if (me->edit_mesh) {
 792       BM_data_layer_free(me->edit_mesh->bm, data, type);
 793     }
 794     else {
 795       CustomData_free_layers(data, type, tot);
 796     }
 797
 798     DEG_id_tag_update(&me->id, 0);
 799     WM_event_add_notifier(C, NC_GEOM | ND_DATA, me);
 800
 801     return OPERATOR_FINISHED;
 802   }
 803   return OPERATOR_CANCELLED;
 804 }
 805
 806 /* Clear Mask */
 807 static bool mesh_customdata_mask_clear_poll(bContext *C)
 808 {
 809   Object *ob = ED_object_context(C);
 810   if (ob && ob->type == OB_MESH) {
 811     Mesh *me = ob->data;
 812
 813     /* special case - can't run this if we're in sculpt mode */
 814     if (ob->mode & OB_MODE_SCULPT) {
 815       return false;
 816     }
 817
 818     if (!ID_IS_LINKED(me)) {
 819       CustomData *data = GET_CD_DATA(me, vdata);
 820       if (CustomData_has_layer(data, CD_PAINT_MASK)) {
 821         return true;
 822       }
 823       data = GET_CD_DATA(me, ldata);
 824       if (CustomData_has_layer(data, CD_GRID_PAINT_MASK)) {
 825         return true;
 826       }
 827     }
 828   }
 829   return false;
 830 }
 831 static int mesh_customdata_mask_clear_exec(bContext *C, wmOperator *UNUSED(op))
 832 {
 833   int ret_a = mesh_customdata_clear_exec__internal(C, BM_VERT, CD_PAINT_MASK);
 834   int ret_b = mesh_customdata_clear_exec__internal(C, BM_LOOP, CD_GRID_PAINT_MASK);
 835
 836   if (ret_a == OPERATOR_FINISHED || ret_b == OPERATOR_FINISHED) {
 837     return OPERATOR_FINISHED;
 838   }
 839   return OPERATOR_CANCELLED;
 840 }
 841
 842 void MESH_OT_customdata_mask_clear(wmOperatorType *ot)
 843 {
 844
 845   /* identifiers */
 846   ot->name = "Clear Sculpt Mask Data";
 847   ot->idname = "MESH_OT_customdata_mask_clear";
 848   ot->description = "Clear vertex sculpt masking data from the mesh";
 849
 850   /* api callbacks */
 851   ot->exec = mesh_customdata_mask_clear_exec;
 852   ot->poll = mesh_customdata_mask_clear_poll;
 853
 854   /* flags */
 855   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 856 }
 857
 858 /**
 859  * Clear Skin
 860  * \return -1 invalid state, 0 no skin, 1 has skin.
 861  */
 862 static int mesh_customdata_skin_state(bContext *C)
 863 {
 864   Object *ob = ED_object_context(C);
 865
 866   if (ob && ob->type == OB_MESH) {
 867     Mesh *me = ob->data;
 868     if (!ID_IS_LINKED(me)) {
 869       CustomData *data = GET_CD_DATA(me, vdata);
 870       return CustomData_has_layer(data, CD_MVERT_SKIN);
 871     }
 872   }
 873   return -1;
 874 }
 875
 876 static bool mesh_customdata_skin_add_poll(bContext *C)
 877 {
 878   return (mesh_customdata_skin_state(C) == 0);
 879 }
 880
 881 static int mesh_customdata_skin_add_exec(bContext *C, wmOperator *UNUSED(op))
 882 {
 883   Object *ob = ED_object_context(C);
 884   Mesh *me = ob->data;
 885
 886   BKE_mesh_ensure_skin_customdata(me);
 887
 888   DEG_id_tag_update(&me->id, 0);
 889   WM_event_add_notifier(C, NC_GEOM | ND_DATA, me);
 890
 891   return OPERATOR_FINISHED;
 892 }
 893
 894 void MESH_OT_customdata_skin_add(wmOperatorType *ot)
 895 {
 896   /* identifiers */
 897   ot->name = "Add Skin Data";
 898   ot->idname = "MESH_OT_customdata_skin_add";
 899   ot->description = "Add a vertex skin layer";
 900
 901   /* api callbacks */
 902   ot->exec = mesh_customdata_skin_add_exec;
 903   ot->poll = mesh_customdata_skin_add_poll;
 904
 905   /* flags */
 906   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 907 }
 908
 909 static bool mesh_customdata_skin_clear_poll(bContext *C)
 910 {
 911   return (mesh_customdata_skin_state(C) == 1);
 912 }
 913
 914 static int mesh_customdata_skin_clear_exec(bContext *C, wmOperator *UNUSED(op))
 915 {
 916   return mesh_customdata_clear_exec__internal(C, BM_VERT, CD_MVERT_SKIN);
 917 }
 918
 919 void MESH_OT_customdata_skin_clear(wmOperatorType *ot)
 920 {
 921   /* identifiers */
 922   ot->name = "Clear Skin Data";
 923   ot->idname = "MESH_OT_customdata_skin_clear";
 924   ot->description = "Clear vertex skin layer";
 925
 926   /* api callbacks */
 927   ot->exec = mesh_customdata_skin_clear_exec;
 928   ot->poll = mesh_customdata_skin_clear_poll;
 929
 930   /* flags */
 931   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 932 }
 933
 934 /* Clear custom loop normals */
 935 static int mesh_customdata_custom_splitnormals_add_exec(bContext *C, wmOperator *UNUSED(op))
 936 {
 937   Mesh *me = ED_mesh_context(C);
 938
 939   if (!BKE_mesh_has_custom_loop_normals(me)) {
 940     CustomData *data = GET_CD_DATA(me, ldata);
 941
 942     if (me->edit_mesh) {
 943       /* Tag edges as sharp according to smooth threshold if needed,
 944        * to preserve autosmooth shading. */
 945       if (me->flag & ME_AUTOSMOOTH) {
 946         BM_edges_sharp_from_angle_set(me->edit_mesh->bm, me->smoothresh);
 947       }
 948
 949       BM_data_layer_add(me->edit_mesh->bm, data, CD_CUSTOMLOOPNORMAL);
 950     }
 951     else {
 952       /* Tag edges as sharp according to smooth threshold if needed,
 953        * to preserve autosmooth shading. */
 954       if (me->flag & ME_AUTOSMOOTH) {
 955         float(*polynors)[3] = MEM_mallocN(sizeof(*polynors) * (size_t)me->totpoly, __func__);
 956
 957         BKE_mesh_calc_normals_poly(me->mvert,
 958                                    NULL,
 959                                    me->totvert,
 960                                    me->mloop,
 961                                    me->mpoly,
 962                                    me->totloop,
 963                                    me->totpoly,
 964                                    polynors,
 965                                    true);
 966
 967         BKE_edges_sharp_from_angle_set(me->mvert,
 968                                        me->totvert,
 969                                        me->medge,
 970                                        me->totedge,
 971                                        me->mloop,
 972                                        me->totloop,
 973                                        me->mpoly,
 974                                        polynors,
 975                                        me->totpoly,
 976                                        me->smoothresh);
 977
 978         MEM_freeN(polynors);
 979       }
 980
 981       CustomData_add_layer(data, CD_CUSTOMLOOPNORMAL, CD_DEFAULT, NULL, me->totloop);
 982     }
 983
 984     DEG_id_tag_update(&me->id, 0);
 985     WM_event_add_notifier(C, NC_GEOM | ND_DATA, me);
 986
 987     return OPERATOR_FINISHED;
 988   }
 989   return OPERATOR_CANCELLED;
 990 }
 991
 992 void MESH_OT_customdata_custom_splitnormals_add(wmOperatorType *ot)
 993 {
 994   /* identifiers */
 995   ot->name = "Add Custom Split Normals Data";
 996   ot->idname = "MESH_OT_customdata_custom_splitnormals_add";
 997   ot->description = "Add a custom split normals layer, if none exists yet";
 998
 999   /* api callbacks */
1000   ot->exec = mesh_customdata_custom_splitnormals_add_exec;
1001   ot->poll = ED_operator_editable_mesh;
1002
1003   /* flags */
1004   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1005 }
1006
1007 static int mesh_customdata_custom_splitnormals_clear_exec(bContext *C, wmOperator *UNUSED(op))
1008 {
1009   Mesh *me = ED_mesh_context(C);
1010
1011   if (BKE_mesh_has_custom_loop_normals(me)) {
1012     BMEditMesh *em = me->edit_mesh;
1013     if (em != NULL && em->bm->lnor_spacearr != NULL) {
1014       BKE_lnor_spacearr_clear(em->bm->lnor_spacearr);
1015     }
1016     return mesh_customdata_clear_exec__internal(C, BM_LOOP, CD_CUSTOMLOOPNORMAL);
1017   }
1018   return OPERATOR_CANCELLED;
1019 }
1020
1021 void MESH_OT_customdata_custom_splitnormals_clear(wmOperatorType *ot)
1022 {
1023   /* identifiers */
1024   ot->name = "Clear Custom Split Normals Data";
1025   ot->idname = "MESH_OT_customdata_custom_splitnormals_clear";
1026   ot->description = "Remove the custom split normals layer, if it exists";
1027
1028   /* api callbacks */
1029   ot->exec = mesh_customdata_custom_splitnormals_clear_exec;
1030   ot->poll = ED_operator_editable_mesh;
1031
1032   /* flags */
1033   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1034 }
1035
1036 /************************** Add Geometry Layers *************************/
1037
1038 void ED_mesh_update(Mesh *mesh, bContext *C, bool calc_edges, bool calc_edges_loose)
1039 {
1040   if (calc_edges || ((mesh->totpoly || mesh->totface) && mesh->totedge == 0)) {
1041     BKE_mesh_calc_edges(mesh, calc_edges, true);
1042   }
1043
1044   if (calc_edges_loose && mesh->totedge) {
1045     BKE_mesh_calc_edges_loose(mesh);
1046   }
1047
1048   /* Default state is not to have tessface's so make sure this is the case. */
1049   BKE_mesh_tessface_clear(mesh);
1050
1051   BKE_mesh_calc_normals(mesh);
1052
1053   DEG_id_tag_update(&mesh->id, 0);
1054   WM_event_add_notifier(C, NC_GEOM | ND_DATA, mesh);
1055 }
1056
1057 static void mesh_add_verts(Mesh *mesh, int len)
1058 {
1059   if (len == 0) {
1060     return;
1061   }
1062
1063   int totvert = mesh->totvert + len;
1064   CustomData vdata;
1065   CustomData_copy(&mesh->vdata, &vdata, CD_MASK_MESH.vmask, CD_DEFAULT, totvert);
1066   CustomData_copy_data(&mesh->vdata, &vdata, 0, 0, mesh->totvert);
1067
1068   if (!CustomData_has_layer(&vdata, CD_MVERT)) {
1069     CustomData_add_layer(&vdata, CD_MVERT, CD_CALLOC, NULL, totvert);
1070   }
1071
1072   CustomData_free(&mesh->vdata, mesh->totvert);
1073   mesh->vdata = vdata;
1074   BKE_mesh_update_customdata_pointers(mesh, false);
1075
1076   /* scan the input list and insert the new vertices */
1077
1078   /* set default flags */
1079   MVert *mvert = &mesh->mvert[mesh->totvert];
1080   for (int i = 0; i < len; i++, mvert++) {
1081     mvert->flag |= SELECT;
1082   }
1083
1084   /* set final vertex list size */
1085   mesh->totvert = totvert;
1086 }
1087
1088 static void mesh_add_edges(Mesh *mesh, int len)
1089 {
1090   CustomData edata;
1091   MEdge *medge;
1092   int i, totedge;
1093
1094   if (len == 0) {
1095     return;
1096   }
1097
1098   totedge = mesh->totedge + len;
1099
1100   /* update customdata  */
1101   CustomData_copy(&mesh->edata, &edata, CD_MASK_MESH.emask, CD_DEFAULT, totedge);
1102   CustomData_copy_data(&mesh->edata, &edata, 0, 0, mesh->totedge);
1103
1104   if (!CustomData_has_layer(&edata, CD_MEDGE)) {
1105     CustomData_add_layer(&edata, CD_MEDGE, CD_CALLOC, NULL, totedge);
1106   }
1107
1108   CustomData_free(&mesh->edata, mesh->totedge);
1109   mesh->edata = edata;
1110   BKE_mesh_update_customdata_pointers(mesh, false); /* new edges don't change tessellation */
1111
1112   /* set default flags */
1113   medge = &mesh->medge[mesh->totedge];
1114   for (i = 0; i < len; i++, medge++) {
1115     medge->flag = ME_EDGEDRAW | ME_EDGERENDER | SELECT;
1116   }
1117
1118   mesh->totedge = totedge;
1119 }
1120
1121 static void mesh_add_loops(Mesh *mesh, int len)
1122 {
1123   CustomData ldata;
1124   int totloop;
1125
1126   if (len == 0) {
1127     return;
1128   }
1129
1130   totloop = mesh->totloop + len; /* new face count */
1131
1132   /* update customdata */
1133   CustomData_copy(&mesh->ldata, &ldata, CD_MASK_MESH.lmask, CD_DEFAULT, totloop);
1134   CustomData_copy_data(&mesh->ldata, &ldata, 0, 0, mesh->totloop);
1135
1136   if (!CustomData_has_layer(&ldata, CD_MLOOP)) {
1137     CustomData_add_layer(&ldata, CD_MLOOP, CD_CALLOC, NULL, totloop);
1138   }
1139
1140   CustomData_free(&mesh->ldata, mesh->totloop);
1141   mesh->ldata = ldata;
1142   BKE_mesh_update_customdata_pointers(mesh, true);
1143
1144   mesh->totloop = totloop;
1145 }
1146
1147 static void mesh_add_polys(Mesh *mesh, int len)
1148 {
1149   CustomData pdata;
1150   MPoly *mpoly;
1151   int i, totpoly;
1152
1153   if (len == 0) {
1154     return;
1155   }
1156
1157   totpoly = mesh->totpoly + len; /* new face count */
1158
1159   /* update customdata */
1160   CustomData_copy(&mesh->pdata, &pdata, CD_MASK_MESH.pmask, CD_DEFAULT, totpoly);
1161   CustomData_copy_data(&mesh->pdata, &pdata, 0, 0, mesh->totpoly);
1162
1163   if (!CustomData_has_layer(&pdata, CD_MPOLY)) {
1164     CustomData_add_layer(&pdata, CD_MPOLY, CD_CALLOC, NULL, totpoly);
1165   }
1166
1167   CustomData_free(&mesh->pdata, mesh->totpoly);
1168   mesh->pdata = pdata;
1169   BKE_mesh_update_customdata_pointers(mesh, true);
1170
1171   /* set default flags */
1172   mpoly = &mesh->mpoly[mesh->totpoly];
1173   for (i = 0; i < len; i++, mpoly++) {
1174     mpoly->flag = ME_FACE_SEL;
1175   }
1176
1177   mesh->totpoly = totpoly;
1178 }
1179
1180 /* -------------------------------------------------------------------- */
1181 /** \name Add Geometry
1182  * \{ */
1183
1184 void ED_mesh_verts_add(Mesh *mesh, ReportList *reports, int count)
1185 {
1186   if (mesh->edit_mesh) {
1187     BKE_report(reports, RPT_ERROR, "Cannot add vertices in edit mode");
1188     return;
1189   }
1190   mesh_add_verts(mesh, count);
1191 }
1192
1193 void ED_mesh_edges_add(Mesh *mesh, ReportList *reports, int count)
1194 {
1195   if (mesh->edit_mesh) {
1196     BKE_report(reports, RPT_ERROR, "Cannot add edges in edit mode");
1197     return;
1198   }
1199   mesh_add_edges(mesh, count);
1200 }
1201
1202 void ED_mesh_loops_add(Mesh *mesh, ReportList *reports, int count)
1203 {
1204   if (mesh->edit_mesh) {
1205     BKE_report(reports, RPT_ERROR, "Cannot add loops in edit mode");
1206     return;
1207   }
1208   mesh_add_loops(mesh, count);
1209 }
1210
1211 void ED_mesh_polys_add(Mesh *mesh, ReportList *reports, int count)
1212 {
1213   if (mesh->edit_mesh) {
1214     BKE_report(reports, RPT_ERROR, "Cannot add polygons in edit mode");
1215     return;
1216   }
1217   mesh_add_polys(mesh, count);
1218 }
1219
1220 /** \} */
1221
1222 /* -------------------------------------------------------------------- */
1223 /** \name Remove Geometry
1224  * \{ */
1225
1226 static void mesh_remove_verts(Mesh *mesh, int len)
1227 {
1228   if (len == 0) {
1229     return;
1230   }
1231   const int totvert = mesh->totvert - len;
1232   CustomData_free_elem(&mesh->vdata, totvert, len);
1233   mesh->totvert = totvert;
1234 }
1235
1236 static void mesh_remove_edges(Mesh *mesh, int len)
1237 {
1238   if (len == 0) {
1239     return;
1240   }
1241   const int totedge = mesh->totedge - len;
1242   CustomData_free_elem(&mesh->edata, totedge, len);
1243   mesh->totedge = totedge;
1244 }
1245
1246 static void mesh_remove_loops(Mesh *mesh, int len)
1247 {
1248   if (len == 0) {
1249     return;
1250   }
1251   const int totloop = mesh->totloop - len;
1252   CustomData_free_elem(&mesh->ldata, totloop, len);
1253   mesh->totloop = totloop;
1254 }
1255
1256 static void mesh_remove_polys(Mesh *mesh, int len)
1257 {
1258   if (len == 0) {
1259     return;
1260   }
1261   const int totpoly = mesh->totpoly - len;
1262   CustomData_free_elem(&mesh->pdata, totpoly, len);
1263   mesh->totpoly = totpoly;
1264 }
1265
1266 void ED_mesh_verts_remove(Mesh *mesh, ReportList *reports, int count)
1267 {
1268   if (mesh->edit_mesh) {
1269     BKE_report(reports, RPT_ERROR, "Cannot remove vertices in edit mode");
1270     return;
1271   }
1272   if (count > mesh->totvert) {
1273     BKE_report(reports, RPT_ERROR, "Cannot remove more vertices than the mesh contains");
1274     return;
1275   }
1276
1277   mesh_remove_verts(mesh, count);
1278 }
1279
1280 void ED_mesh_edges_remove(Mesh *mesh, ReportList *reports, int count)
1281 {
1282   if (mesh->edit_mesh) {
1283     BKE_report(reports, RPT_ERROR, "Cannot remove edges in edit mode");
1284     return;
1285   }
1286   if (count > mesh->totedge) {
1287     BKE_report(reports, RPT_ERROR, "Cannot remove more edges than the mesh contains");
1288     return;
1289   }
1290
1291   mesh_remove_edges(mesh, count);
1292 }
1293
1294 void ED_mesh_loops_remove(Mesh *mesh, ReportList *reports, int count)
1295 {
1296   if (mesh->edit_mesh) {
1297     BKE_report(reports, RPT_ERROR, "Cannot remove loops in edit mode");
1298     return;
1299   }
1300   if (count > mesh->totloop) {
1301     BKE_report(reports, RPT_ERROR, "Cannot remove more loops than the mesh contains");
1302     return;
1303   }
1304
1305   mesh_remove_loops(mesh, count);
1306 }
1307
1308 void ED_mesh_polys_remove(Mesh *mesh, ReportList *reports, int count)
1309 {
1310   if (mesh->edit_mesh) {
1311     BKE_report(reports, RPT_ERROR, "Cannot remove polys in edit mode");
1312     return;
1313   }
1314   if (count > mesh->totpoly) {
1315     BKE_report(reports, RPT_ERROR, "Cannot remove more polys than the mesh contains");
1316     return;
1317   }
1318
1319   mesh_remove_polys(mesh, count);
1320 }
1321
1322 void ED_mesh_geometry_clear(Mesh *mesh)
1323 {
1324   mesh_remove_verts(mesh, mesh->totvert);
1325   mesh_remove_edges(mesh, mesh->totedge);
1326   mesh_remove_loops(mesh, mesh->totloop);
1327   mesh_remove_polys(mesh, mesh->totpoly);
1328 }
1329
1330 /** \} */
1331
1332 void ED_mesh_report_mirror_ex(wmOperator *op, int totmirr, int totfail, char selectmode)
1333 {
1334   const char *elem_type;
1335
1336   if (selectmode & SCE_SELECT_VERTEX) {
1337     elem_type = "vertices";
1338   }
1339   else if (selectmode & SCE_SELECT_EDGE) {
1340     elem_type = "edges";
1341   }
1342   else {
1343     elem_type = "faces";
1344   }
1345
1346   if (totfail) {
1347     BKE_reportf(
1348         op->reports, RPT_WARNING, "%d %s mirrored, %d failed", totmirr, elem_type, totfail);
1349   }
1350   else {
1351     BKE_reportf(op->reports, RPT_INFO, "%d %s mirrored", totmirr, elem_type);
1352   }
1353 }
1354
1355 void ED_mesh_report_mirror(wmOperator *op, int totmirr, int totfail)
1356 {
1357   ED_mesh_report_mirror_ex(op, totmirr, totfail, SCE_SELECT_VERTEX);
1358 }
1359
1360 Mesh *ED_mesh_context(struct bContext *C)
1361 {
1362   Mesh *mesh = CTX_data_pointer_get_type(C, "mesh", &RNA_Mesh).data;
1363   if (mesh != NULL) {
1364     return mesh;
1365   }
1366
1367   Object *ob = ED_object_active_context(C);
1368   if (ob == NULL) {
1369     return NULL;
1370   }
1371
1372   ID *data = (ID *)ob->data;
1373   if (data == NULL || GS(data->name) != ID_ME) {
1374     return NULL;
1375   }
1376
1377   return (Mesh *)data;
1378 }