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