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         Main *bmain = CTX_data_main(C);
542         Scene *scene = CTX_data_scene(C);
543         View3D *v3d = CTX_wm_view3d(C);
544         BaseLegacy *base;
545         Image *ima = NULL;
546         Mesh *me;
547         Object *obedit;
548         int exitmode = 0;
549         
550         if (v3d == NULL) {
551                 BKE_report(op->reports, RPT_ERROR, "No 3D View Available");
552                 return OPERATOR_CANCELLED;
553         }
554
555         base = ED_view3d_give_base_under_cursor(C, event->mval);
556
557         /* Check context */
558         if (base == NULL || base->object->type != OB_MESH) {
559                 BKE_report(op->reports, RPT_ERROR, "Not an object or mesh");
560                 return OPERATOR_CANCELLED;
561         }
562         
563         ima = (Image *)WM_operator_drop_load_path(C, op, ID_IM);
564         if (!ima) {
565                 return OPERATOR_CANCELLED;
566         }
567         /* handled below */
568         id_us_min((ID *)ima);
569
570         /* put mesh in editmode */
571
572         obedit = base->object;
573         me = obedit->data;
574         if (me->edit_btmesh == NULL) {
575                 EDBM_mesh_make(scene->toolsettings, obedit, false);
576                 exitmode = 1;
577         }
578         if (me->edit_btmesh == NULL)
579                 return OPERATOR_CANCELLED;
580         
581         ED_uvedit_assign_image(bmain, scene, obedit, ima, NULL);
582
583         if (exitmode) {
584                 EDBM_mesh_load(obedit);
585                 EDBM_mesh_free(me->edit_btmesh);
586                 MEM_freeN(me->edit_btmesh);
587                 me->edit_btmesh = NULL;
588
589                 /* load_editMesh free's pointers used by CustomData layers which might be used by DerivedMesh too,
590                  * so signal to re-create DerivedMesh here (sergey) */
591                 DEG_id_tag_update(&me->id, 0);
592         }
593
594         /* dummie drop support; ensure view shows a result :) */
595         if (v3d)
596                 v3d->flag2 |= V3D_SOLID_TEX;
597         
598         WM_event_add_notifier(C, NC_GEOM | ND_DATA, obedit->data);
599         
600         return OPERATOR_FINISHED;
601 }
602
603 void MESH_OT_drop_named_image(wmOperatorType *ot)
604 {
605         /* identifiers */
606         ot->name = "Drop Image to Mesh UV Map";
607         ot->description = "Assign Image to active UV Map, or create an UV Map";
608         ot->idname = "MESH_OT_drop_named_image";
609         
610         /* api callbacks */
611         ot->poll = layers_poll;
612         ot->invoke = drop_named_image_invoke;
613         
614         /* flags */
615         ot->flag = OPTYPE_UNDO | OPTYPE_INTERNAL;
616         
617         /* properties */
618         RNA_def_string(ot->srna, "name", "Image", MAX_ID_NAME - 2, "Name", "Image name to assign");
619         RNA_def_string(ot->srna, "filepath", "Path", FILE_MAX, "Filepath", "Path to image file");
620         RNA_def_boolean(ot->srna, "relative_path", true, "Relative Path", "Select the file relative to the blend file");
621 }
622
623 static int mesh_uv_texture_remove_exec(bContext *C, wmOperator *UNUSED(op))
624 {
625         Object *ob = ED_object_context(C);
626         Mesh *me = ob->data;
627
628         if (!ED_mesh_uv_texture_remove_active(me))
629                 return OPERATOR_CANCELLED;
630
631         if (ob->mode & OB_MODE_TEXTURE_PAINT) {
632                 Scene *scene = CTX_data_scene(C);
633                 BKE_paint_proj_mesh_data_check(scene, ob, NULL, NULL, NULL, NULL);
634                 WM_event_add_notifier(C, NC_SCENE | ND_TOOLSETTINGS, NULL);
635         }
636         
637         return OPERATOR_FINISHED;
638 }
639
640 void MESH_OT_uv_texture_remove(wmOperatorType *ot)
641 {
642         /* identifiers */
643         ot->name = "Remove UV Map";
644         ot->description = "Remove UV Map";
645         ot->idname = "MESH_OT_uv_texture_remove";
646         
647         /* api callbacks */
648         ot->poll = layers_poll;
649         ot->exec = mesh_uv_texture_remove_exec;
650
651         /* flags */
652         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
653 }
654
655 /*********************** vertex color operators ************************/
656
657 static int mesh_vertex_color_add_exec(bContext *C, wmOperator *UNUSED(op))
658 {
659         Object *ob = ED_object_context(C);
660         Mesh *me = ob->data;
661
662         if (ED_mesh_color_add(me, NULL, true) == -1)
663                 return OPERATOR_CANCELLED;
664
665         return OPERATOR_FINISHED;
666 }
667
668 void MESH_OT_vertex_color_add(wmOperatorType *ot)
669 {
670         /* identifiers */
671         ot->name = "Add Vertex Color";
672         ot->description = "Add vertex color layer";
673         ot->idname = "MESH_OT_vertex_color_add";
674         
675         /* api callbacks */
676         ot->poll = layers_poll;
677         ot->exec = mesh_vertex_color_add_exec;
678
679         /* flags */
680         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
681 }
682
683 static int mesh_vertex_color_remove_exec(bContext *C, wmOperator *UNUSED(op))
684 {
685         Object *ob = ED_object_context(C);
686         Mesh *me = ob->data;
687
688         if (!ED_mesh_color_remove_active(me))
689                 return OPERATOR_CANCELLED;
690
691         return OPERATOR_FINISHED;
692 }
693
694 void MESH_OT_vertex_color_remove(wmOperatorType *ot)
695 {
696         /* identifiers */
697         ot->name = "Remove Vertex Color";
698         ot->description = "Remove vertex color layer";
699         ot->idname = "MESH_OT_vertex_color_remove";
700         
701         /* api callbacks */
702         ot->exec = mesh_vertex_color_remove_exec;
703         ot->poll = layers_poll;
704
705         /* flags */
706         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
707 }
708
709 /* *** CustomData clear functions, we need an operator for each *** */
710
711 static int mesh_customdata_clear_exec__internal(bContext *C,
712                                                 char htype, int type)
713 {
714         Object *obedit = ED_object_context(C);
715         Mesh       *me = obedit->data;
716
717         int tot;
718         CustomData *data = mesh_customdata_get_type(me, htype, &tot);
719
720         BLI_assert(CustomData_layertype_is_singleton(type) == true);
721
722         if (CustomData_has_layer(data, type)) {
723                 if (me->edit_btmesh) {
724                         BM_data_layer_free(me->edit_btmesh->bm, data, type);
725                 }
726                 else {
727                         CustomData_free_layers(data, type, tot);
728                 }
729
730                 DEG_id_tag_update(&me->id, 0);
731                 WM_event_add_notifier(C, NC_GEOM | ND_DATA, me);
732
733                 return OPERATOR_FINISHED;
734         }
735         else {
736                 return OPERATOR_CANCELLED;
737         }
738 }
739
740 /* Clear Mask */
741 static int mesh_customdata_mask_clear_poll(bContext *C)
742 {
743         Object *ob = ED_object_context(C);
744         if (ob && ob->type == OB_MESH) {
745                 Mesh *me = ob->data;
746
747                 /* special case - can't run this if we're in sculpt mode */
748                 if (ob->mode & OB_MODE_SCULPT) {
749                         return false;
750                 }
751
752                 if (!ID_IS_LINKED(me)) {
753                         CustomData *data = GET_CD_DATA(me, vdata);
754                         if (CustomData_has_layer(data, CD_PAINT_MASK)) {
755                                 return true;
756                         }
757                         data = GET_CD_DATA(me, ldata);
758                         if (CustomData_has_layer(data, CD_GRID_PAINT_MASK)) {
759                                 return true;
760                         }
761                 }
762         }
763         return false;
764 }
765 static int mesh_customdata_mask_clear_exec(bContext *C, wmOperator *UNUSED(op))
766 {
767         int ret_a = mesh_customdata_clear_exec__internal(C, BM_VERT, CD_PAINT_MASK);
768         int ret_b = mesh_customdata_clear_exec__internal(C, BM_LOOP, CD_GRID_PAINT_MASK);
769
770         if (ret_a == OPERATOR_FINISHED ||
771             ret_b == OPERATOR_FINISHED)
772         {
773                 return OPERATOR_FINISHED;
774         }
775         else {
776                 return OPERATOR_CANCELLED;
777         }
778 }
779
780 void MESH_OT_customdata_mask_clear(wmOperatorType *ot)
781 {
782
783         /* identifiers */
784         ot->name = "Clear Sculpt-Mask Data";
785         ot->idname = "MESH_OT_customdata_mask_clear";
786         ot->description = "Clear vertex sculpt masking data from the mesh";
787
788         /* api callbacks */
789         ot->exec = mesh_customdata_mask_clear_exec;
790         ot->poll = mesh_customdata_mask_clear_poll;
791
792         /* flags */
793         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
794 }
795
796 /**
797  * Clear Skin
798  * \return -1 invalid state, 0 no skin, 1 has skin.
799  */
800 static int mesh_customdata_skin_state(bContext *C)
801 {
802         Object *ob = ED_object_context(C);
803
804         if (ob && ob->type == OB_MESH) {
805                 Mesh *me = ob->data;
806                 if (!ID_IS_LINKED(me)) {
807                         CustomData *data = GET_CD_DATA(me, vdata);
808                         return CustomData_has_layer(data, CD_MVERT_SKIN);
809                 }
810         }
811         return -1;
812 }
813
814 static int mesh_customdata_skin_add_poll(bContext *C)
815 {
816         return (mesh_customdata_skin_state(C) == 0);
817 }
818
819 static int mesh_customdata_skin_add_exec(bContext *C, wmOperator *UNUSED(op))
820 {
821         Object *ob = ED_object_context(C);
822         Mesh *me = ob->data;
823
824         BKE_mesh_ensure_skin_customdata(me);
825
826         DEG_id_tag_update(&me->id, 0);
827         WM_event_add_notifier(C, NC_GEOM | ND_DATA, me);
828
829         return OPERATOR_FINISHED;
830 }
831
832 void MESH_OT_customdata_skin_add(wmOperatorType *ot)
833 {
834         /* identifiers */
835         ot->name = "Add Skin Data";
836         ot->idname = "MESH_OT_customdata_skin_add";
837         ot->description = "Add a vertex skin layer";
838
839         /* api callbacks */
840         ot->exec = mesh_customdata_skin_add_exec;
841         ot->poll = mesh_customdata_skin_add_poll;
842
843         /* flags */
844         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
845 }
846
847 static int mesh_customdata_skin_clear_poll(bContext *C)
848 {
849         return (mesh_customdata_skin_state(C) == 1);
850 }
851
852 static int mesh_customdata_skin_clear_exec(bContext *C, wmOperator *UNUSED(op))
853 {
854         return mesh_customdata_clear_exec__internal(C, BM_VERT, CD_MVERT_SKIN);
855 }
856
857 void MESH_OT_customdata_skin_clear(wmOperatorType *ot)
858 {
859         /* identifiers */
860         ot->name = "Clear Skin Data";
861         ot->idname = "MESH_OT_customdata_skin_clear";
862         ot->description = "Clear vertex skin layer";
863
864         /* api callbacks */
865         ot->exec = mesh_customdata_skin_clear_exec;
866         ot->poll = mesh_customdata_skin_clear_poll;
867
868         /* flags */
869         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
870 }
871
872 /* Clear custom loop normals */
873 static int mesh_customdata_custom_splitnormals_add_exec(bContext *C, wmOperator *UNUSED(op))
874 {
875         Object *ob = ED_object_context(C);
876         Mesh *me = ob->data;
877
878         if (!BKE_mesh_has_custom_loop_normals(me)) {
879                 CustomData *data = GET_CD_DATA(me, ldata);
880
881                 if (me->edit_btmesh) {
882                         BM_data_layer_add(me->edit_btmesh->bm, data, CD_CUSTOMLOOPNORMAL);
883                 }
884                 else {
885                         CustomData_add_layer(data, CD_CUSTOMLOOPNORMAL, CD_DEFAULT, NULL, me->totloop);
886                 }
887
888                 DEG_id_tag_update(&me->id, 0);
889                 WM_event_add_notifier(C, NC_GEOM | ND_DATA, me);
890
891                 return OPERATOR_FINISHED;
892         }
893         return OPERATOR_CANCELLED;
894 }
895
896 void MESH_OT_customdata_custom_splitnormals_add(wmOperatorType *ot)
897 {
898         /* identifiers */
899         ot->name = "Add Custom Split Normals Data";
900         ot->idname = "MESH_OT_customdata_custom_splitnormals_add";
901         ot->description = "Add a custom split normals layer, if none exists yet";
902
903         /* api callbacks */
904         ot->exec = mesh_customdata_custom_splitnormals_add_exec;
905         ot->poll = ED_operator_object_active_editable_mesh;
906
907         /* flags */
908         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
909 }
910
911 static int mesh_customdata_custom_splitnormals_clear_exec(bContext *C, wmOperator *UNUSED(op))
912 {
913         Object *ob = ED_object_context(C);
914         Mesh *me = ob->data;
915
916         if (BKE_mesh_has_custom_loop_normals(me)) {
917                 return mesh_customdata_clear_exec__internal(C, BM_LOOP, CD_CUSTOMLOOPNORMAL);
918         }
919         return OPERATOR_CANCELLED;
920 }
921
922 void MESH_OT_customdata_custom_splitnormals_clear(wmOperatorType *ot)
923 {
924         /* identifiers */
925         ot->name = "Clear Custom Split Normals Data";
926         ot->idname = "MESH_OT_customdata_custom_splitnormals_clear";
927         ot->description = "Remove the custom split normals layer, if it exists";
928
929         /* api callbacks */
930         ot->exec = mesh_customdata_custom_splitnormals_clear_exec;
931         ot->poll = ED_operator_object_active_editable_mesh;
932
933         /* flags */
934         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
935 }
936
937 /************************** Add Geometry Layers *************************/
938
939 void ED_mesh_update(Mesh *mesh, bContext *C, int calc_edges, int calc_tessface)
940 {
941         bool tessface_input = false;
942
943         if (mesh->totface > 0 && mesh->totpoly == 0) {
944                 BKE_mesh_convert_mfaces_to_mpolys(mesh);
945
946                 /* would only be converting back again, don't bother */
947                 tessface_input = true;
948         }
949
950         if (calc_edges || ((mesh->totpoly || mesh->totface) && mesh->totedge == 0))
951                 BKE_mesh_calc_edges(mesh, calc_edges, true);
952
953         if (calc_tessface) {
954                 if (tessface_input == false) {
955                         BKE_mesh_tessface_calc(mesh);
956                 }
957         }
958         else {
959                 /* default state is not to have tessface's so make sure this is the case */
960                 BKE_mesh_tessface_clear(mesh);
961         }
962
963         BKE_mesh_calc_normals(mesh);
964
965         DEG_id_tag_update(&mesh->id, 0);
966         WM_event_add_notifier(C, NC_GEOM | ND_DATA, mesh);
967 }
968
969 static void mesh_add_verts(Mesh *mesh, int len)
970 {
971         CustomData vdata;
972         MVert *mvert;
973         int i, totvert;
974
975         if (len == 0)
976                 return;
977
978         totvert = mesh->totvert + len;
979         CustomData_copy(&mesh->vdata, &vdata, CD_MASK_MESH, CD_DEFAULT, totvert);
980         CustomData_copy_data(&mesh->vdata, &vdata, 0, 0, mesh->totvert);
981
982         if (!CustomData_has_layer(&vdata, CD_MVERT))
983                 CustomData_add_layer(&vdata, CD_MVERT, CD_CALLOC, NULL, totvert);
984
985         CustomData_free(&mesh->vdata, mesh->totvert);
986         mesh->vdata = vdata;
987         BKE_mesh_update_customdata_pointers(mesh, false);
988
989         /* scan the input list and insert the new vertices */
990
991         /* set default flags */
992         mvert = &mesh->mvert[mesh->totvert];
993         for (i = 0; i < len; i++, mvert++)
994                 mvert->flag |= SELECT;
995
996         /* set final vertex list size */
997         mesh->totvert = totvert;
998 }
999
1000 static void mesh_add_edges(Mesh *mesh, int len)
1001 {
1002         CustomData edata;
1003         MEdge *medge;
1004         int i, totedge;
1005
1006         if (len == 0)
1007                 return;
1008
1009         totedge = mesh->totedge + len;
1010
1011         /* update customdata  */
1012         CustomData_copy(&mesh->edata, &edata, CD_MASK_MESH, CD_DEFAULT, totedge);
1013         CustomData_copy_data(&mesh->edata, &edata, 0, 0, mesh->totedge);
1014
1015         if (!CustomData_has_layer(&edata, CD_MEDGE))
1016                 CustomData_add_layer(&edata, CD_MEDGE, CD_CALLOC, NULL, totedge);
1017
1018         CustomData_free(&mesh->edata, mesh->totedge);
1019         mesh->edata = edata;
1020         BKE_mesh_update_customdata_pointers(mesh, false); /* new edges don't change tessellation */
1021
1022         /* set default flags */
1023         medge = &mesh->medge[mesh->totedge];
1024         for (i = 0; i < len; i++, medge++)
1025                 medge->flag = ME_EDGEDRAW | ME_EDGERENDER | SELECT;
1026
1027         mesh->totedge = totedge;
1028 }
1029
1030 static void mesh_add_tessfaces(Mesh *mesh, int len)
1031 {
1032         CustomData fdata;
1033         MFace *mface;
1034         int i, totface;
1035
1036         if (len == 0)
1037                 return;
1038
1039         totface = mesh->totface + len;   /* new face count */
1040
1041         /* update customdata */
1042         CustomData_copy(&mesh->fdata, &fdata, CD_MASK_MESH, CD_DEFAULT, totface);
1043         CustomData_copy_data(&mesh->fdata, &fdata, 0, 0, mesh->totface);
1044
1045         if (!CustomData_has_layer(&fdata, CD_MFACE))
1046                 CustomData_add_layer(&fdata, CD_MFACE, CD_CALLOC, NULL, totface);
1047
1048         CustomData_free(&mesh->fdata, mesh->totface);
1049         mesh->fdata = fdata;
1050         BKE_mesh_update_customdata_pointers(mesh, true);
1051
1052         /* set default flags */
1053         mface = &mesh->mface[mesh->totface];
1054         for (i = 0; i < len; i++, mface++)
1055                 mface->flag = ME_FACE_SEL;
1056
1057         mesh->totface = totface;
1058 }
1059
1060 static void mesh_add_loops(Mesh *mesh, int len)
1061 {
1062         CustomData ldata;
1063         int totloop;
1064
1065         if (len == 0)
1066                 return;
1067
1068         totloop = mesh->totloop + len;   /* new face count */
1069
1070         /* update customdata */
1071         CustomData_copy(&mesh->ldata, &ldata, CD_MASK_MESH, CD_DEFAULT, totloop);
1072         CustomData_copy_data(&mesh->ldata, &ldata, 0, 0, mesh->totloop);
1073
1074         if (!CustomData_has_layer(&ldata, CD_MLOOP))
1075                 CustomData_add_layer(&ldata, CD_MLOOP, CD_CALLOC, NULL, totloop);
1076
1077         CustomData_free(&mesh->ldata, mesh->totloop);
1078         mesh->ldata = ldata;
1079         BKE_mesh_update_customdata_pointers(mesh, true);
1080
1081         mesh->totloop = totloop;
1082 }
1083
1084 static void mesh_add_polys(Mesh *mesh, int len)
1085 {
1086         CustomData pdata;
1087         MPoly *mpoly;
1088         int i, totpoly;
1089
1090         if (len == 0)
1091                 return;
1092
1093         totpoly = mesh->totpoly + len;   /* new face count */
1094
1095         /* update customdata */
1096         CustomData_copy(&mesh->pdata, &pdata, CD_MASK_MESH, CD_DEFAULT, totpoly);
1097         CustomData_copy_data(&mesh->pdata, &pdata, 0, 0, mesh->totpoly);
1098
1099         if (!CustomData_has_layer(&pdata, CD_MPOLY))
1100                 CustomData_add_layer(&pdata, CD_MPOLY, CD_CALLOC, NULL, totpoly);
1101
1102         CustomData_free(&mesh->pdata, mesh->totpoly);
1103         mesh->pdata = pdata;
1104         BKE_mesh_update_customdata_pointers(mesh, true);
1105
1106         /* set default flags */
1107         mpoly = &mesh->mpoly[mesh->totpoly];
1108         for (i = 0; i < len; i++, mpoly++)
1109                 mpoly->flag = ME_FACE_SEL;
1110
1111         mesh->totpoly = totpoly;
1112 }
1113
1114 static void mesh_remove_verts(Mesh *mesh, int len)
1115 {
1116         int totvert;
1117
1118         if (len == 0)
1119                 return;
1120
1121         totvert = mesh->totvert - len;
1122         CustomData_free_elem(&mesh->vdata, totvert, len);
1123
1124         /* set final vertex list size */
1125         mesh->totvert = totvert;
1126 }
1127
1128 static void mesh_remove_edges(Mesh *mesh, int len)
1129 {
1130         int totedge;
1131
1132         if (len == 0)
1133                 return;
1134
1135         totedge = mesh->totedge - len;
1136         CustomData_free_elem(&mesh->edata, totedge, len);
1137
1138         mesh->totedge = totedge;
1139 }
1140
1141 static void mesh_remove_faces(Mesh *mesh, int len)
1142 {
1143         int totface;
1144
1145         if (len == 0)
1146                 return;
1147
1148         totface = mesh->totface - len;   /* new face count */
1149         CustomData_free_elem(&mesh->fdata, totface, len);
1150
1151         mesh->totface = totface;
1152 }
1153
1154 #if 0
1155 void ED_mesh_geometry_add(Mesh *mesh, ReportList *reports, int verts, int edges, int faces)
1156 {
1157         if (mesh->edit_btmesh) {
1158                 BKE_report(reports, RPT_ERROR, "Cannot add geometry in edit mode");
1159                 return;
1160         }
1161
1162         if (verts)
1163                 mesh_add_verts(mesh, verts);
1164         if (edges)
1165                 mesh_add_edges(mesh, edges);
1166         if (faces)
1167                 mesh_add_faces(mesh, faces);
1168 }
1169 #endif
1170
1171 void ED_mesh_tessfaces_add(Mesh *mesh, ReportList *reports, int count)
1172 {
1173         if (mesh->edit_btmesh) {
1174                 BKE_report(reports, RPT_ERROR, "Cannot add tessfaces in edit mode");
1175                 return;
1176         }
1177
1178         if (mesh->mpoly) {
1179                 BKE_report(reports, RPT_ERROR, "Cannot add tessfaces to a mesh that already has polygons");
1180                 return;
1181         }
1182
1183         mesh_add_tessfaces(mesh, count);
1184 }
1185
1186 void ED_mesh_edges_add(Mesh *mesh, ReportList *reports, int count)
1187 {
1188         if (mesh->edit_btmesh) {
1189                 BKE_report(reports, RPT_ERROR, "Cannot add edges in edit mode");
1190                 return;
1191         }
1192
1193         mesh_add_edges(mesh, count);
1194 }
1195
1196 void ED_mesh_vertices_add(Mesh *mesh, ReportList *reports, int count)
1197 {
1198         if (mesh->edit_btmesh) {
1199                 BKE_report(reports, RPT_ERROR, "Cannot add vertices in edit mode");
1200                 return;
1201         }
1202
1203         mesh_add_verts(mesh, count);
1204 }
1205
1206 void ED_mesh_faces_remove(Mesh *mesh, ReportList *reports, int count)
1207 {
1208         if (mesh->edit_btmesh) {
1209                 BKE_report(reports, RPT_ERROR, "Cannot remove faces in edit mode");
1210                 return;
1211         }
1212         else if (count > mesh->totface) {
1213                 BKE_report(reports, RPT_ERROR, "Cannot remove more faces than the mesh contains");
1214                 return;
1215         }
1216
1217         mesh_remove_faces(mesh, count);
1218 }
1219
1220 void ED_mesh_edges_remove(Mesh *mesh, ReportList *reports, int count)
1221 {
1222         if (mesh->edit_btmesh) {
1223                 BKE_report(reports, RPT_ERROR, "Cannot remove edges in edit mode");
1224                 return;
1225         }
1226         else if (count > mesh->totedge) {
1227                 BKE_report(reports, RPT_ERROR, "Cannot remove more edges than the mesh contains");
1228                 return;
1229         }
1230
1231         mesh_remove_edges(mesh, count);
1232 }
1233
1234 void ED_mesh_vertices_remove(Mesh *mesh, ReportList *reports, int count)
1235 {
1236         if (mesh->edit_btmesh) {
1237                 BKE_report(reports, RPT_ERROR, "Cannot remove vertices in edit mode");
1238                 return;
1239         }
1240         else if (count > mesh->totvert) {
1241                 BKE_report(reports, RPT_ERROR, "Cannot remove more vertices than the mesh contains");
1242                 return;
1243         }
1244
1245         mesh_remove_verts(mesh, count);
1246 }
1247
1248 void ED_mesh_loops_add(Mesh *mesh, ReportList *reports, int count)
1249 {
1250         if (mesh->edit_btmesh) {
1251                 BKE_report(reports, RPT_ERROR, "Cannot add loops in edit mode");
1252                 return;
1253         }
1254
1255         mesh_add_loops(mesh, count);
1256 }
1257
1258 void ED_mesh_polys_add(Mesh *mesh, ReportList *reports, int count)
1259 {
1260         if (mesh->edit_btmesh) {
1261                 BKE_report(reports, RPT_ERROR, "Cannot add polygons in edit mode");
1262                 return;
1263         }
1264
1265         mesh_add_polys(mesh, count);
1266 }
1267
1268 void ED_mesh_calc_tessface(Mesh *mesh, bool free_mpoly)
1269 {
1270         if (mesh->edit_btmesh) {
1271                 BKE_editmesh_tessface_calc(mesh->edit_btmesh);
1272         }
1273         else {
1274                 BKE_mesh_tessface_calc(mesh);
1275         }
1276         if (free_mpoly) {
1277                 CustomData_free(&mesh->ldata, mesh->totloop);
1278                 CustomData_free(&mesh->pdata, mesh->totpoly);
1279                 mesh->totloop = 0;
1280                 mesh->totpoly = 0;
1281                 mesh->mloop = NULL;
1282                 mesh->mloopcol = NULL;
1283                 mesh->mloopuv = NULL;
1284                 mesh->mpoly = NULL;
1285         }
1286 }
1287
1288 void ED_mesh_report_mirror_ex(wmOperator *op, int totmirr, int totfail,
1289                               char selectmode)
1290 {
1291         const char *elem_type;
1292
1293         if (selectmode & SCE_SELECT_VERTEX) {
1294                 elem_type = "vertices";
1295         }
1296         else if (selectmode & SCE_SELECT_EDGE) {
1297                 elem_type = "edges";
1298         }
1299         else {
1300                 elem_type = "faces";
1301         }
1302
1303         if (totfail) {
1304                 BKE_reportf(op->reports, RPT_WARNING, "%d %s mirrored, %d failed", totmirr, elem_type, totfail);
1305         }
1306         else {
1307                 BKE_reportf(op->reports, RPT_INFO, "%d %s mirrored", totmirr, elem_type);
1308         }
1309 }
1310
1311 void ED_mesh_report_mirror(wmOperator *op, int totmirr, int totfail)
1312 {
1313         ED_mesh_report_mirror_ex(op, totmirr, totfail, SCE_SELECT_VERTEX);
1314 }