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