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