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