Texture painting:
[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_depsgraph.h"
46 #include "BKE_image.h"
47 #include "BKE_library.h"
48 #include "BKE_main.h"
49 #include "BKE_mesh.h"
50 #include "BKE_paint.h"
51 #include "BKE_report.h"
52 #include "BKE_editmesh.h"
53
54 #include "RNA_access.h"
55 #include "RNA_define.h"
56
57 #include "WM_api.h"
58 #include "WM_types.h"
59
60 #include "ED_mesh.h"
61 #include "ED_object.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         DAG_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 *pdata = GET_CD_DATA(me, pdata);
256         const int layernum = CustomData_get_active_layer_index(pdata, CD_MTEXPOLY);
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->pdata, CD_MTEXPOLY);
274                 if (layernum_dst >= MAX_MTFACE)
275                         return -1;
276
277                 /* CD_MTEXPOLY */
278                 BM_data_layer_add_named(em->bm, &em->bm->pdata, CD_MTEXPOLY, name);
279                 /* copy data from active UV */
280                 if (layernum_dst) {
281                         const int layernum_src = CustomData_get_active_layer(&em->bm->pdata, CD_MTEXPOLY);
282                         BM_data_layer_copy(em->bm, &em->bm->pdata, CD_MTEXPOLY, layernum_src, layernum_dst);
283                 }
284                 if (active_set || layernum_dst == 0) {
285                         CustomData_set_layer_active(&em->bm->pdata, CD_MTEXPOLY, layernum_dst);
286                 }
287
288                 /* CD_MLOOPUV */
289                 BM_data_layer_add_named(em->bm, &em->bm->ldata, CD_MLOOPUV, name);
290                 /* copy data from active UV */
291                 if (layernum_dst) {
292                         const int layernum_src = CustomData_get_active_layer(&em->bm->ldata, CD_MLOOPUV);
293                         BM_data_layer_copy(em->bm, &em->bm->ldata, CD_MLOOPUV, layernum_src, layernum_dst);
294
295                         is_init = true;
296                 }
297                 if (active_set || layernum_dst == 0) {
298                         CustomData_set_layer_active(&em->bm->ldata, CD_MLOOPUV, layernum_dst);
299                 }
300         }
301         else {
302                 layernum_dst = CustomData_number_of_layers(&me->pdata, CD_MTEXPOLY);
303                 if (layernum_dst >= MAX_MTFACE)
304                         return -1;
305
306                 if (me->mtpoly) {
307                         CustomData_add_layer_named(&me->pdata, CD_MTEXPOLY, CD_DUPLICATE, me->mtpoly, me->totpoly, name);
308                         CustomData_add_layer_named(&me->ldata, CD_MLOOPUV, CD_DUPLICATE, me->mloopuv, me->totloop, name);
309                         CustomData_add_layer_named(&me->fdata, CD_MTFACE, CD_DUPLICATE, me->mtface, me->totface, name);
310                         is_init = true;
311                 }
312                 else {
313                         CustomData_add_layer_named(&me->pdata, CD_MTEXPOLY, CD_DEFAULT, NULL, me->totpoly, name);
314                         CustomData_add_layer_named(&me->ldata, CD_MLOOPUV, CD_DEFAULT, NULL, me->totloop, name);
315                         CustomData_add_layer_named(&me->fdata, CD_MTFACE, CD_DEFAULT, NULL, me->totface, name);
316                 }
317                 
318                 if (active_set || layernum_dst == 0) {
319                         CustomData_set_layer_active(&me->pdata, CD_MTEXPOLY, layernum_dst);
320                         CustomData_set_layer_active(&me->ldata, CD_MLOOPUV, layernum_dst);
321
322                         CustomData_set_layer_active(&me->fdata, CD_MTFACE, layernum_dst);
323                 }
324
325                 BKE_mesh_update_customdata_pointers(me, true);
326         }
327
328         /* don't overwrite our copied coords */
329         if (is_init == false) {
330                 ED_mesh_uv_loop_reset_ex(me, layernum_dst);
331         }
332
333         DAG_id_tag_update(&me->id, 0);
334         WM_main_add_notifier(NC_GEOM | ND_DATA, me);
335
336         return layernum_dst;
337 }
338
339 bool ED_mesh_uv_texture_remove_index(Mesh *me, const int n)
340 {
341         CustomData *pdata = GET_CD_DATA(me, pdata), *ldata = GET_CD_DATA(me, ldata);
342         CustomDataLayer *cdlp, *cdlu;
343         int index;
344
345         index = CustomData_get_layer_index_n(pdata, CD_MTEXPOLY, n);
346         cdlp = (index == -1) ? NULL : &pdata->layers[index];
347
348         index = CustomData_get_layer_index_n(ldata, CD_MLOOPUV, n);
349         cdlu = (index == -1) ? NULL : &ldata->layers[index];
350
351         if (!cdlp || !cdlu)
352                 return false;
353
354         delete_customdata_layer(me, cdlp);
355         delete_customdata_layer(me, cdlu);
356
357         DAG_id_tag_update(&me->id, 0);
358         WM_main_add_notifier(NC_GEOM | ND_DATA, me);
359
360         return true;
361 }
362 bool ED_mesh_uv_texture_remove_active(Mesh *me)
363 {
364         /* texpoly/uv are assumed to be in sync */
365         CustomData *pdata = GET_CD_DATA(me, pdata);
366         const int n = CustomData_get_active_layer(pdata, CD_MTEXPOLY);
367
368         /* double check active layers align! */
369 #ifdef DEBUG
370         CustomData *ldata = GET_CD_DATA(me, ldata);
371         BLI_assert(CustomData_get_active_layer(ldata, CD_MLOOPUV) == n);
372 #endif
373
374         if (n != -1) {
375                 return ED_mesh_uv_texture_remove_index(me, n);
376         }
377         else {
378                 return false;
379         }
380 }
381 bool ED_mesh_uv_texture_remove_named(Mesh *me, const char *name)
382 {
383         /* texpoly/uv are assumed to be in sync */
384         CustomData *pdata = GET_CD_DATA(me, pdata);
385         const int n = CustomData_get_named_layer(pdata, CD_MTEXPOLY, name);
386         if (n != -1) {
387                 return ED_mesh_uv_texture_remove_index(me, n);
388         }
389         else {
390                 return false;
391         }
392 }
393
394 /* note: keep in sync with ED_mesh_uv_texture_add */
395 int ED_mesh_color_add(Mesh *me, const char *name, const bool active_set)
396 {
397         BMEditMesh *em;
398         int layernum;
399
400         if (me->edit_btmesh) {
401                 em = me->edit_btmesh;
402
403                 layernum = CustomData_number_of_layers(&em->bm->ldata, CD_MLOOPCOL);
404                 if (layernum >= MAX_MCOL) {
405                         return -1;
406                 }
407
408                 /* CD_MLOOPCOL */
409                 BM_data_layer_add_named(em->bm, &em->bm->ldata, CD_MLOOPCOL, name);
410                 /* copy data from active vertex color layer */
411                 if (layernum) {
412                         const int layernum_dst = CustomData_get_active_layer(&em->bm->ldata, CD_MLOOPCOL);
413                         BM_data_layer_copy(em->bm, &em->bm->ldata, CD_MLOOPCOL, layernum, layernum_dst);
414                 }
415                 if (active_set || layernum == 0) {
416                         CustomData_set_layer_active(&em->bm->ldata, CD_MLOOPCOL, layernum);
417                 }
418         }
419         else {
420                 layernum = CustomData_number_of_layers(&me->ldata, CD_MLOOPCOL);
421                 if (layernum >= MAX_MCOL) {
422                         return -1;
423                 }
424
425                 if (me->mloopcol) {
426                         CustomData_add_layer_named(&me->ldata, CD_MLOOPCOL, CD_DUPLICATE, me->mloopcol, me->totloop, name);
427                         CustomData_add_layer_named(&me->fdata, CD_MCOL, CD_DUPLICATE, me->mcol, me->totface, name);
428                 }
429                 else {
430                         CustomData_add_layer_named(&me->ldata, CD_MLOOPCOL, CD_DEFAULT, NULL, me->totloop, name);
431                         CustomData_add_layer_named(&me->fdata, CD_MCOL, CD_DEFAULT, NULL, me->totface, name);
432                 }
433
434                 if (active_set || layernum == 0) {
435                         CustomData_set_layer_active(&me->ldata, CD_MLOOPCOL, layernum);
436                         CustomData_set_layer_active(&me->fdata, CD_MCOL, layernum);
437                 }
438
439                 BKE_mesh_update_customdata_pointers(me, true);
440         }
441
442         DAG_id_tag_update(&me->id, 0);
443         WM_main_add_notifier(NC_GEOM | ND_DATA, me);
444
445         return layernum;
446 }
447
448 bool ED_mesh_color_remove_index(Mesh *me, const int n)
449 {
450         CustomData *ldata = GET_CD_DATA(me, ldata);
451         CustomDataLayer *cdl;
452         int index;
453
454         index = CustomData_get_layer_index_n(ldata, CD_MLOOPCOL, n);
455         cdl = (index == -1) ? NULL : &ldata->layers[index];
456
457         if (!cdl)
458                 return false;
459
460         delete_customdata_layer(me, cdl);
461         DAG_id_tag_update(&me->id, 0);
462         WM_main_add_notifier(NC_GEOM | ND_DATA, me);
463
464         return true;
465 }
466 bool ED_mesh_color_remove_active(Mesh *me)
467 {
468         CustomData *ldata = GET_CD_DATA(me, ldata);
469         const int n = CustomData_get_active_layer(ldata, CD_MLOOPCOL);
470         if (n != -1) {
471                 return ED_mesh_color_remove_index(me, n);
472         }
473         else {
474                 return false;
475         }
476 }
477 bool ED_mesh_color_remove_named(Mesh *me, const char *name)
478 {
479         CustomData *ldata = GET_CD_DATA(me, ldata);
480         const int n = CustomData_get_named_layer(ldata, CD_MLOOPCOL, name);
481         if (n != -1) {
482                 return ED_mesh_color_remove_index(me, n);
483         }
484         else {
485                 return false;
486         }
487 }
488
489 /*********************** UV texture operators ************************/
490
491 static int layers_poll(bContext *C)
492 {
493         Object *ob = ED_object_context(C);
494         ID *data = (ob) ? ob->data : NULL;
495         return (ob && !ob->id.lib && ob->type == OB_MESH && data && !data->lib);
496 }
497
498 static int mesh_uv_texture_add_exec(bContext *C, wmOperator *UNUSED(op))
499 {
500         Object *ob = ED_object_context(C);
501         Mesh *me = ob->data;
502
503         if (ED_mesh_uv_texture_add(me, NULL, true) == -1)
504                 return OPERATOR_CANCELLED;
505
506         if (ob->mode & OB_MODE_TEXTURE_PAINT) {
507                 Scene *scene = CTX_data_scene(C);
508                 BKE_paint_proj_mesh_data_check(scene, ob, NULL, NULL, NULL, NULL);
509                 WM_event_add_notifier(C, NC_SCENE | ND_TOOLSETTINGS, NULL);
510         }
511         
512         return OPERATOR_FINISHED;
513 }
514
515 void MESH_OT_uv_texture_add(wmOperatorType *ot)
516 {
517         /* identifiers */
518         ot->name = "Add UV Map";
519         ot->description = "Add UV Map";
520         ot->idname = "MESH_OT_uv_texture_add";
521         
522         /* api callbacks */
523         ot->poll = layers_poll;
524         ot->exec = mesh_uv_texture_add_exec;
525
526         /* flags */
527         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
528 }
529
530 static int drop_named_image_invoke(bContext *C, wmOperator *op, const wmEvent *event)
531 {
532         Main *bmain = CTX_data_main(C);
533         Scene *scene = CTX_data_scene(C);
534         View3D *v3d = CTX_wm_view3d(C);
535         Base *base;
536         Image *ima = NULL;
537         Mesh *me;
538         Object *obedit;
539         int exitmode = 0;
540         
541         if (v3d == NULL) {
542                 BKE_report(op->reports, RPT_ERROR, "No 3D View Available");
543                 return OPERATOR_CANCELLED;
544         }
545
546         base = ED_view3d_give_base_under_cursor(C, event->mval);
547
548         /* Check context */
549         if (base == NULL || base->object->type != OB_MESH) {
550                 BKE_report(op->reports, RPT_ERROR, "Not an object or mesh");
551                 return OPERATOR_CANCELLED;
552         }
553         
554         /* check input variables */
555         if (RNA_struct_property_is_set(op->ptr, "filepath")) {
556                 char path[FILE_MAX];
557                 
558                 RNA_string_get(op->ptr, "filepath", path);
559                 ima = BKE_image_load_exists(path);
560         }
561         else {
562                 char name[MAX_ID_NAME - 2];
563                 RNA_string_get(op->ptr, "name", name);
564                 ima = (Image *)BKE_libblock_find_name(ID_IM, name);
565         }
566         
567         if (!ima) {
568                 BKE_report(op->reports, RPT_ERROR, "Not an image");
569                 return OPERATOR_CANCELLED;
570         }
571         
572         /* put mesh in editmode */
573
574         obedit = base->object;
575         me = obedit->data;
576         if (me->edit_btmesh == NULL) {
577                 EDBM_mesh_make(scene->toolsettings, obedit);
578                 exitmode = 1;
579         }
580         if (me->edit_btmesh == NULL)
581                 return OPERATOR_CANCELLED;
582         
583         ED_uvedit_assign_image(bmain, scene, obedit, ima, NULL);
584
585         if (exitmode) {
586                 EDBM_mesh_load(obedit);
587                 EDBM_mesh_free(me->edit_btmesh);
588                 MEM_freeN(me->edit_btmesh);
589                 me->edit_btmesh = NULL;
590
591                 /* load_editMesh free's pointers used by CustomData layers which might be used by DerivedMesh too,
592                  * so signal to re-create DerivedMesh here (sergey) */
593                 DAG_id_tag_update(&me->id, 0);
594         }
595
596         /* dummie drop support; ensure view shows a result :) */
597         if (v3d)
598                 v3d->flag2 |= V3D_SOLID_TEX;
599         
600         WM_event_add_notifier(C, NC_GEOM | ND_DATA, obedit->data);
601         
602         return OPERATOR_FINISHED;
603 }
604
605 void MESH_OT_drop_named_image(wmOperatorType *ot)
606 {
607         /* identifiers */
608         ot->name = "Drop Image to Mesh UV Map";
609         ot->description = "Assign Image to active UV Map, or create an UV Map";
610         ot->idname = "MESH_OT_drop_named_image";
611         
612         /* api callbacks */
613         ot->poll = layers_poll;
614         ot->invoke = drop_named_image_invoke;
615         
616         /* flags */
617         ot->flag = OPTYPE_UNDO | OPTYPE_INTERNAL;
618         
619         /* properties */
620         RNA_def_string(ot->srna, "name", "Image", MAX_ID_NAME - 2, "Name", "Image name to assign");
621         RNA_def_string(ot->srna, "filepath", "Path", FILE_MAX, "Filepath", "Path to image file");
622 }
623
624 static int mesh_uv_texture_remove_exec(bContext *C, wmOperator *UNUSED(op))
625 {
626         Object *ob = ED_object_context(C);
627         Mesh *me = ob->data;
628
629         if (!ED_mesh_uv_texture_remove_active(me))
630                 return OPERATOR_CANCELLED;
631
632         if (ob->mode & OB_MODE_TEXTURE_PAINT) {
633                 Scene *scene = CTX_data_scene(C);
634                 BKE_paint_proj_mesh_data_check(scene, ob, NULL, NULL, NULL, NULL);
635                 WM_event_add_notifier(C, NC_SCENE | ND_TOOLSETTINGS, NULL);
636         }
637         
638         return OPERATOR_FINISHED;
639 }
640
641 void MESH_OT_uv_texture_remove(wmOperatorType *ot)
642 {
643         /* identifiers */
644         ot->name = "Remove UV Map";
645         ot->description = "Remove UV Map";
646         ot->idname = "MESH_OT_uv_texture_remove";
647         
648         /* api callbacks */
649         ot->poll = layers_poll;
650         ot->exec = mesh_uv_texture_remove_exec;
651
652         /* flags */
653         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
654 }
655
656 /*********************** vertex color operators ************************/
657
658 static int mesh_vertex_color_add_exec(bContext *C, wmOperator *UNUSED(op))
659 {
660         Object *ob = ED_object_context(C);
661         Mesh *me = ob->data;
662
663         if (ED_mesh_color_add(me, NULL, true) == -1)
664                 return OPERATOR_CANCELLED;
665
666         return OPERATOR_FINISHED;
667 }
668
669 void MESH_OT_vertex_color_add(wmOperatorType *ot)
670 {
671         /* identifiers */
672         ot->name = "Add Vertex Color";
673         ot->description = "Add vertex color layer";
674         ot->idname = "MESH_OT_vertex_color_add";
675         
676         /* api callbacks */
677         ot->poll = layers_poll;
678         ot->exec = mesh_vertex_color_add_exec;
679
680         /* flags */
681         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
682 }
683
684 static int mesh_vertex_color_remove_exec(bContext *C, wmOperator *UNUSED(op))
685 {
686         Object *ob = ED_object_context(C);
687         Mesh *me = ob->data;
688
689         if (!ED_mesh_color_remove_active(me))
690                 return OPERATOR_CANCELLED;
691
692         return OPERATOR_FINISHED;
693 }
694
695 void MESH_OT_vertex_color_remove(wmOperatorType *ot)
696 {
697         /* identifiers */
698         ot->name = "Remove Vertex Color";
699         ot->description = "Remove vertex color layer";
700         ot->idname = "MESH_OT_vertex_color_remove";
701         
702         /* api callbacks */
703         ot->exec = mesh_vertex_color_remove_exec;
704         ot->poll = layers_poll;
705
706         /* flags */
707         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
708 }
709
710 /* *** CustomData clear functions, we need an operator for each *** */
711
712 static int mesh_customdata_clear_exec__internal(bContext *C,
713                                                 char htype, int type)
714 {
715         Object *obedit = ED_object_context(C);
716         Mesh       *me = obedit->data;
717
718         int tot;
719         CustomData *data = mesh_customdata_get_type(me, htype, &tot);
720
721         BLI_assert(CustomData_layertype_is_singleton(type) == true);
722
723         if (CustomData_has_layer(data, type)) {
724                 if (me->edit_btmesh) {
725                         BM_data_layer_free(me->edit_btmesh->bm, data, type);
726                 }
727                 else {
728                         CustomData_free_layers(data, type, tot);
729                 }
730
731                 DAG_id_tag_update(&me->id, 0);
732                 WM_event_add_notifier(C, NC_GEOM | ND_DATA, me);
733
734                 return OPERATOR_FINISHED;
735         }
736         else {
737                 return OPERATOR_CANCELLED;
738         }
739 }
740
741 /* Clear Mask */
742 static int mesh_customdata_clear_mask_poll(bContext *C)
743 {
744         Object *ob = ED_object_context(C);
745         if (ob && ob->type == OB_MESH) {
746                 Mesh *me = ob->data;
747
748                 /* special case - can't run this if we're in sculpt mode */
749                 if (ob->mode & OB_MODE_SCULPT) {
750                         return false;
751                 }
752
753                 if (me->id.lib == NULL) {
754                         CustomData *data = GET_CD_DATA(me, vdata);
755                         if (CustomData_has_layer(data, CD_PAINT_MASK)) {
756                                 return true;
757                         }
758                         data = GET_CD_DATA(me, ldata);
759                         if (CustomData_has_layer(data, CD_GRID_PAINT_MASK)) {
760                                 return true;
761                         }
762                 }
763         }
764         return false;
765 }
766 static int mesh_customdata_clear_mask_exec(bContext *C, wmOperator *UNUSED(op))
767 {
768         int ret_a = mesh_customdata_clear_exec__internal(C, BM_VERT, CD_PAINT_MASK);
769         int ret_b = mesh_customdata_clear_exec__internal(C, BM_LOOP, CD_GRID_PAINT_MASK);
770
771         if (ret_a == OPERATOR_FINISHED ||
772             ret_b == OPERATOR_FINISHED)
773         {
774                 return OPERATOR_FINISHED;
775         }
776         else {
777                 return OPERATOR_CANCELLED;
778         }
779 }
780
781 void MESH_OT_customdata_clear_mask(wmOperatorType *ot)
782 {
783
784         /* identifiers */
785         ot->name = "Clear Sculpt-Mask Data";
786         ot->idname = "MESH_OT_customdata_clear_mask";
787         ot->description = "Clear vertex sculpt masking data from the mesh";
788
789         /* api callbacks */
790         ot->exec = mesh_customdata_clear_mask_exec;
791         ot->poll = mesh_customdata_clear_mask_poll;
792
793         /* flags */
794         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
795 }
796
797 /* Clear Skin */
798 static int mesh_customdata_clear_skin_poll(bContext *C)
799 {
800         Object *ob = ED_object_context(C);
801
802         if (ob && ob->type == OB_MESH) {
803                 Mesh *me = ob->data;
804                 if (me->id.lib == NULL) {
805                         CustomData *data = GET_CD_DATA(me, vdata);
806                         if (CustomData_has_layer(data, CD_MVERT_SKIN)) {
807                                 return true;
808                         }
809                 }
810         }
811         return false;
812 }
813 static int mesh_customdata_clear_skin_exec(bContext *C, wmOperator *UNUSED(op))
814 {
815         return mesh_customdata_clear_exec__internal(C, BM_VERT, CD_MVERT_SKIN);
816 }
817
818 void MESH_OT_customdata_clear_skin(wmOperatorType *ot)
819 {
820         /* identifiers */
821         ot->name = "Clear Skin Data";
822         ot->idname = "MESH_OT_customdata_clear_skin";
823         ot->description = "Clear vertex skin layer";
824
825         /* api callbacks */
826         ot->exec = mesh_customdata_clear_skin_exec;
827         ot->poll = mesh_customdata_clear_skin_poll;
828
829         /* flags */
830         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
831 }
832
833 /************************** Add Geometry Layers *************************/
834
835 void ED_mesh_update(Mesh *mesh, bContext *C, int calc_edges, int calc_tessface)
836 {
837         bool tessface_input = false;
838
839         if (mesh->totface > 0 && mesh->totpoly == 0) {
840                 BKE_mesh_convert_mfaces_to_mpolys(mesh);
841
842                 /* would only be converting back again, don't bother */
843                 tessface_input = true;
844         }
845
846         if (calc_edges || ((mesh->totpoly || mesh->totface) && mesh->totedge == 0))
847                 BKE_mesh_calc_edges(mesh, calc_edges, true);
848
849         if (calc_tessface) {
850                 if (tessface_input == false) {
851                         BKE_mesh_tessface_calc(mesh);
852                 }
853         }
854         else {
855                 /* default state is not to have tessface's so make sure this is the case */
856                 BKE_mesh_tessface_clear(mesh);
857         }
858
859         BKE_mesh_calc_normals(mesh);
860
861         DAG_id_tag_update(&mesh->id, 0);
862         WM_event_add_notifier(C, NC_GEOM | ND_DATA, mesh);
863 }
864
865 static void mesh_add_verts(Mesh *mesh, int len)
866 {
867         CustomData vdata;
868         MVert *mvert;
869         int i, totvert;
870
871         if (len == 0)
872                 return;
873
874         totvert = mesh->totvert + len;
875         CustomData_copy(&mesh->vdata, &vdata, CD_MASK_MESH, CD_DEFAULT, totvert);
876         CustomData_copy_data(&mesh->vdata, &vdata, 0, 0, mesh->totvert);
877
878         if (!CustomData_has_layer(&vdata, CD_MVERT))
879                 CustomData_add_layer(&vdata, CD_MVERT, CD_CALLOC, NULL, totvert);
880
881         CustomData_free(&mesh->vdata, mesh->totvert);
882         mesh->vdata = vdata;
883         BKE_mesh_update_customdata_pointers(mesh, false);
884
885         /* scan the input list and insert the new vertices */
886
887         /* set default flags */
888         mvert = &mesh->mvert[mesh->totvert];
889         for (i = 0; i < len; i++, mvert++)
890                 mvert->flag |= SELECT;
891
892         /* set final vertex list size */
893         mesh->totvert = totvert;
894 }
895
896 static void mesh_add_edges(Mesh *mesh, int len)
897 {
898         CustomData edata;
899         MEdge *medge;
900         int i, totedge;
901
902         if (len == 0)
903                 return;
904
905         totedge = mesh->totedge + len;
906
907         /* update customdata  */
908         CustomData_copy(&mesh->edata, &edata, CD_MASK_MESH, CD_DEFAULT, totedge);
909         CustomData_copy_data(&mesh->edata, &edata, 0, 0, mesh->totedge);
910
911         if (!CustomData_has_layer(&edata, CD_MEDGE))
912                 CustomData_add_layer(&edata, CD_MEDGE, CD_CALLOC, NULL, totedge);
913
914         CustomData_free(&mesh->edata, mesh->totedge);
915         mesh->edata = edata;
916         BKE_mesh_update_customdata_pointers(mesh, false); /* new edges don't change tessellation */
917
918         /* set default flags */
919         medge = &mesh->medge[mesh->totedge];
920         for (i = 0; i < len; i++, medge++)
921                 medge->flag = ME_EDGEDRAW | ME_EDGERENDER | SELECT;
922
923         mesh->totedge = totedge;
924 }
925
926 static void mesh_add_tessfaces(Mesh *mesh, int len)
927 {
928         CustomData fdata;
929         MFace *mface;
930         int i, totface;
931
932         if (len == 0)
933                 return;
934
935         totface = mesh->totface + len;   /* new face count */
936
937         /* update customdata */
938         CustomData_copy(&mesh->fdata, &fdata, CD_MASK_MESH, CD_DEFAULT, totface);
939         CustomData_copy_data(&mesh->fdata, &fdata, 0, 0, mesh->totface);
940
941         if (!CustomData_has_layer(&fdata, CD_MFACE))
942                 CustomData_add_layer(&fdata, CD_MFACE, CD_CALLOC, NULL, totface);
943
944         CustomData_free(&mesh->fdata, mesh->totface);
945         mesh->fdata = fdata;
946         BKE_mesh_update_customdata_pointers(mesh, true);
947
948         /* set default flags */
949         mface = &mesh->mface[mesh->totface];
950         for (i = 0; i < len; i++, mface++)
951                 mface->flag = ME_FACE_SEL;
952
953         mesh->totface = totface;
954 }
955
956 static void mesh_add_loops(Mesh *mesh, int len)
957 {
958         CustomData ldata;
959         int totloop;
960
961         if (len == 0)
962                 return;
963
964         totloop = mesh->totloop + len;   /* new face count */
965
966         /* update customdata */
967         CustomData_copy(&mesh->ldata, &ldata, CD_MASK_MESH, CD_DEFAULT, totloop);
968         CustomData_copy_data(&mesh->ldata, &ldata, 0, 0, mesh->totloop);
969
970         if (!CustomData_has_layer(&ldata, CD_MLOOP))
971                 CustomData_add_layer(&ldata, CD_MLOOP, CD_CALLOC, NULL, totloop);
972
973         CustomData_free(&mesh->ldata, mesh->totloop);
974         mesh->ldata = ldata;
975         BKE_mesh_update_customdata_pointers(mesh, true);
976
977         mesh->totloop = totloop;
978 }
979
980 static void mesh_add_polys(Mesh *mesh, int len)
981 {
982         CustomData pdata;
983         MPoly *mpoly;
984         int i, totpoly;
985
986         if (len == 0)
987                 return;
988
989         totpoly = mesh->totpoly + len;   /* new face count */
990
991         /* update customdata */
992         CustomData_copy(&mesh->pdata, &pdata, CD_MASK_MESH, CD_DEFAULT, totpoly);
993         CustomData_copy_data(&mesh->pdata, &pdata, 0, 0, mesh->totpoly);
994
995         if (!CustomData_has_layer(&pdata, CD_MPOLY))
996                 CustomData_add_layer(&pdata, CD_MPOLY, CD_CALLOC, NULL, totpoly);
997
998         CustomData_free(&mesh->pdata, mesh->totpoly);
999         mesh->pdata = pdata;
1000         BKE_mesh_update_customdata_pointers(mesh, true);
1001
1002         /* set default flags */
1003         mpoly = &mesh->mpoly[mesh->totpoly];
1004         for (i = 0; i < len; i++, mpoly++)
1005                 mpoly->flag = ME_FACE_SEL;
1006
1007         mesh->totpoly = totpoly;
1008 }
1009
1010 static void mesh_remove_verts(Mesh *mesh, int len)
1011 {
1012         int totvert;
1013
1014         if (len == 0)
1015                 return;
1016
1017         totvert = mesh->totvert - len;
1018         CustomData_free_elem(&mesh->vdata, totvert, len);
1019
1020         /* set final vertex list size */
1021         mesh->totvert = totvert;
1022 }
1023
1024 static void mesh_remove_edges(Mesh *mesh, int len)
1025 {
1026         int totedge;
1027
1028         if (len == 0)
1029                 return;
1030
1031         totedge = mesh->totedge - len;
1032         CustomData_free_elem(&mesh->edata, totedge, len);
1033
1034         mesh->totedge = totedge;
1035 }
1036
1037 static void mesh_remove_faces(Mesh *mesh, int len)
1038 {
1039         int totface;
1040
1041         if (len == 0)
1042                 return;
1043
1044         totface = mesh->totface - len;   /* new face count */
1045         CustomData_free_elem(&mesh->fdata, totface, len);
1046
1047         mesh->totface = totface;
1048 }
1049
1050 #if 0
1051 void ED_mesh_geometry_add(Mesh *mesh, ReportList *reports, int verts, int edges, int faces)
1052 {
1053         if (mesh->edit_btmesh) {
1054                 BKE_report(reports, RPT_ERROR, "Cannot add geometry in edit mode");
1055                 return;
1056         }
1057
1058         if (verts)
1059                 mesh_add_verts(mesh, verts);
1060         if (edges)
1061                 mesh_add_edges(mesh, edges);
1062         if (faces)
1063                 mesh_add_faces(mesh, faces);
1064 }
1065 #endif
1066
1067 void ED_mesh_tessfaces_add(Mesh *mesh, ReportList *reports, int count)
1068 {
1069         if (mesh->edit_btmesh) {
1070                 BKE_report(reports, RPT_ERROR, "Cannot add tessfaces in edit mode");
1071                 return;
1072         }
1073
1074         if (mesh->mpoly) {
1075                 BKE_report(reports, RPT_ERROR, "Cannot add tessfaces to a mesh that already has polygons");
1076                 return;
1077         }
1078
1079         mesh_add_tessfaces(mesh, count);
1080 }
1081
1082 void ED_mesh_edges_add(Mesh *mesh, ReportList *reports, int count)
1083 {
1084         if (mesh->edit_btmesh) {
1085                 BKE_report(reports, RPT_ERROR, "Cannot add edges in edit mode");
1086                 return;
1087         }
1088
1089         mesh_add_edges(mesh, count);
1090 }
1091
1092 void ED_mesh_vertices_add(Mesh *mesh, ReportList *reports, int count)
1093 {
1094         if (mesh->edit_btmesh) {
1095                 BKE_report(reports, RPT_ERROR, "Cannot add vertices in edit mode");
1096                 return;
1097         }
1098
1099         mesh_add_verts(mesh, count);
1100 }
1101
1102 void ED_mesh_faces_remove(Mesh *mesh, ReportList *reports, int count)
1103 {
1104         if (mesh->edit_btmesh) {
1105                 BKE_report(reports, RPT_ERROR, "Cannot remove faces in edit mode");
1106                 return;
1107         }
1108         else if (count > mesh->totface) {
1109                 BKE_report(reports, RPT_ERROR, "Cannot remove more faces than the mesh contains");
1110                 return;
1111         }
1112
1113         mesh_remove_faces(mesh, count);
1114 }
1115
1116 void ED_mesh_edges_remove(Mesh *mesh, ReportList *reports, int count)
1117 {
1118         if (mesh->edit_btmesh) {
1119                 BKE_report(reports, RPT_ERROR, "Cannot remove edges in edit mode");
1120                 return;
1121         }
1122         else if (count > mesh->totedge) {
1123                 BKE_report(reports, RPT_ERROR, "Cannot remove more edges than the mesh contains");
1124                 return;
1125         }
1126
1127         mesh_remove_edges(mesh, count);
1128 }
1129
1130 void ED_mesh_vertices_remove(Mesh *mesh, ReportList *reports, int count)
1131 {
1132         if (mesh->edit_btmesh) {
1133                 BKE_report(reports, RPT_ERROR, "Cannot remove vertices in edit mode");
1134                 return;
1135         }
1136         else if (count > mesh->totvert) {
1137                 BKE_report(reports, RPT_ERROR, "Cannot remove more vertices than the mesh contains");
1138                 return;
1139         }
1140
1141         mesh_remove_verts(mesh, count);
1142 }
1143
1144 void ED_mesh_loops_add(Mesh *mesh, ReportList *reports, int count)
1145 {
1146         if (mesh->edit_btmesh) {
1147                 BKE_report(reports, RPT_ERROR, "Cannot add loops in edit mode");
1148                 return;
1149         }
1150
1151         mesh_add_loops(mesh, count);
1152 }
1153
1154 void ED_mesh_polys_add(Mesh *mesh, ReportList *reports, int count)
1155 {
1156         if (mesh->edit_btmesh) {
1157                 BKE_report(reports, RPT_ERROR, "Cannot add polygons in edit mode");
1158                 return;
1159         }
1160
1161         mesh_add_polys(mesh, count);
1162 }
1163
1164 void ED_mesh_calc_tessface(Mesh *mesh)
1165 {
1166         if (mesh->edit_btmesh) {
1167                 BKE_editmesh_tessface_calc(mesh->edit_btmesh);
1168         }
1169         else {
1170                 BKE_mesh_tessface_calc(mesh);
1171         }
1172 }
1173
1174 void ED_mesh_report_mirror_ex(wmOperator *op, int totmirr, int totfail,
1175                               char selectmode)
1176 {
1177         const char *elem_type;
1178
1179         if (selectmode & SCE_SELECT_VERTEX) {
1180                 elem_type = "vertices";
1181         }
1182         else if (selectmode & SCE_SELECT_EDGE) {
1183                 elem_type = "edges";
1184         }
1185         else {
1186                 elem_type = "faces";
1187         }
1188
1189         if (totfail) {
1190                 BKE_reportf(op->reports, RPT_WARNING, "%d %s mirrored, %d failed", totmirr, elem_type, totfail);
1191         }
1192         else {
1193                 BKE_reportf(op->reports, RPT_INFO, "%d %s mirrored", totmirr, elem_type);
1194         }
1195 }
1196
1197 void ED_mesh_report_mirror(wmOperator *op, int totmirr, int totfail)
1198 {
1199         ED_mesh_report_mirror_ex(op, totmirr, totfail, SCE_SELECT_VERTEX);
1200 }