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