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