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