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