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