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