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