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