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