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