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