BMesh Merge
[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_meshdata_types.h"
40 #include "DNA_object_types.h"
41 #include "DNA_scene_types.h"
42 #include "DNA_view3d_types.h"
43
44 #include "BLI_utildefines.h"
45 #include "BLI_array.h"
46 #include "BLI_math.h"
47 #include "BLI_editVert.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         } else {
91                 data = (me->edit_btmesh)? &me->edit_btmesh->bm->pdata: &me->pdata;
92                 tot = me->totpoly;
93         }
94         
95         index = CustomData_get_layer_index(data, type);
96
97         /* ok, deleting a non-active layer needs to preserve the active layer indices.
98           to do this, we store a pointer to the .data member of both layer and the active layer,
99           (to detect if we're deleting the active layer or not), then use the active
100           layer data pointer to find where the active layer has ended up.
101
102           
103           this is necassary 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                 } else if (len == 4) {
264                         fuvs[0][0] = 0.0;
265                         fuvs[0][1] = 0.0;
266                         
267                         fuvs[1][0] = 1.0;
268                         fuvs[1][1] = 0.0;
269
270                         fuvs[2][0] = 1.0;
271                         fuvs[2][1] = 1.0;
272
273                         fuvs[3][0] = 0.0;
274                         fuvs[3][1] = 1.0;
275                   /*make sure we ignore 2-sided faces*/
276                 } else if (len > 2) {
277                         float fac = 0.0f, dfac = 1.0f / (float)len;
278
279                         dfac *= M_PI*2;
280
281                         for (i = 0; i < len; i++) {
282                                 fuvs[i][0] = 0.5f * sin(fac) + 0.5f;
283                                 fuvs[i][1] = 0.5f * cos(fac) + 0.5f;
284
285                                 fac += dfac;
286                         }
287                 }
288
289                 fuvs += len;
290         }
291
292         /* BMESH_TODO: Copy poly UVs onto CD_MTFACE layer for tesselated faces */
293
294         BLI_array_free(uvs);
295         BLI_array_free(polylengths);
296
297         DAG_id_tag_update(&me->id, 0);
298         WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);
299
300         return 1;
301 }
302
303 int ED_mesh_uv_texture_add(bContext *C, Mesh *me, const char *name, int active_set)
304 {
305         BMEditMesh *em;
306         int layernum;
307
308         if (me->edit_btmesh) {
309                 em= me->edit_btmesh;
310
311                 layernum = CustomData_number_of_layers(&em->bm->pdata, CD_MTEXPOLY);
312                 if (layernum >= MAX_MTFACE)
313                         return -1;
314
315                 BM_data_layer_add(em->bm, &em->bm->pdata, CD_MTEXPOLY);
316                 CustomData_set_layer_active(&em->bm->pdata, CD_MTEXPOLY, layernum);
317                 CustomData_set_layer_name(&em->bm->pdata, CD_MTEXPOLY, layernum, name);
318
319                 /* copy data from active UV */
320                 if (layernum)
321                         copy_editface_active_customdata(em, CD_MTFACE, layernum);
322
323                 if (active_set || layernum == 0) {
324                         CustomData_set_layer_active(&em->bm->pdata, CD_MTEXPOLY, layernum);
325                 }
326
327                 BM_data_layer_add(em->bm, &em->bm->ldata, CD_MLOOPUV);
328                 CustomData_set_layer_name(&em->bm->ldata, CD_MLOOPUV, layernum, name);
329                 
330                 CustomData_set_layer_active(&em->bm->ldata, CD_MLOOPUV, layernum);
331                 if(active_set || layernum == 0) {
332                         CustomData_set_layer_active(&em->bm->ldata, CD_MLOOPUV, layernum);
333                 }
334         }
335         else {
336                 layernum = CustomData_number_of_layers(&me->pdata, CD_MTEXPOLY);
337                 if (layernum >= MAX_MTFACE)
338                         return -1;
339
340                 if (me->mtpoly) {
341                         CustomData_add_layer_named(&me->pdata, CD_MTEXPOLY, CD_DUPLICATE, me->mtpoly, me->totpoly, name);
342                         CustomData_add_layer_named(&me->ldata, CD_MLOOPUV, CD_DUPLICATE, me->mloopuv, me->totloop, name);
343                         CustomData_add_layer_named(&me->fdata, CD_MTFACE, CD_DUPLICATE, me->mtface, me->totface, name);
344                 } else {
345                         CustomData_add_layer_named(&me->pdata, CD_MTEXPOLY, CD_DEFAULT, NULL, me->totpoly, name);
346                         CustomData_add_layer_named(&me->ldata, CD_MLOOPUV, CD_DEFAULT, NULL, me->totloop, name);
347                         CustomData_add_layer_named(&me->fdata, CD_MTFACE, CD_DEFAULT, NULL, me->totface, name);
348                 }
349                 
350                 if (active_set || layernum == 0) {
351                         CustomData_set_layer_active(&me->pdata, CD_MTEXPOLY, layernum);
352                         CustomData_set_layer_active(&me->ldata, CD_MLOOPUV, layernum);
353
354                         CustomData_set_layer_active(&me->fdata, CD_MTFACE, layernum);
355                 }
356
357                 mesh_update_customdata_pointers(me, TRUE);
358         }
359
360         ED_mesh_uv_loop_reset(C, me);
361
362         DAG_id_tag_update(&me->id, 0);
363         WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);
364
365         return layernum;
366 }
367
368 int ED_mesh_uv_texture_remove(bContext *C, Object *ob, Mesh *me)
369 {
370         CustomData *pdata = GET_CD_DATA(me, pdata), *ldata = GET_CD_DATA(me, ldata);
371         CustomDataLayer *cdlp, *cdlu;
372         int index;
373
374         index= CustomData_get_active_layer_index(pdata, CD_MTEXPOLY);
375         cdlp= (index == -1)? NULL: &pdata->layers[index];
376
377         index= CustomData_get_active_layer_index(ldata, CD_MLOOPUV);
378         cdlu= (index == -1)? NULL: &ldata->layers[index];
379         
380         if (!cdlp || !cdlu)
381                 return 0;
382
383         delete_customdata_layer(C, ob, cdlp);
384         delete_customdata_layer(C, ob, cdlu);
385         
386         DAG_id_tag_update(&me->id, 0);
387         WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);
388
389         return 1;
390 }
391
392 int ED_mesh_color_add(bContext *C, Scene *UNUSED(scene), Object *UNUSED(ob), Mesh *me, const char *name, int active_set)
393 {
394         BMEditMesh *em;
395         int layernum;
396
397         if (me->edit_btmesh) {
398                 em= me->edit_btmesh;
399
400                 layernum= CustomData_number_of_layers(&em->bm->ldata, CD_MLOOPCOL);
401                 if (layernum >= MAX_MCOL) {
402                         return -1;
403                 }
404
405                 BM_data_layer_add(em->bm, &em->bm->pdata, CD_MLOOPCOL);
406                 CustomData_set_layer_active(&em->bm->ldata, CD_MLOOPCOL, layernum);
407
408                 /* copy data from active vertex color layer */
409                 if (layernum) {
410                         copy_editface_active_customdata(em, CD_MCOL, layernum);
411                 }
412
413                 if (active_set || layernum == 0) {
414                         CustomData_set_layer_active(&em->bm->ldata, CD_MLOOPCOL, layernum);
415                 }
416         }
417         else {
418                 layernum= CustomData_number_of_layers(&me->ldata, CD_MLOOPCOL);
419                 if (layernum >= CD_MLOOPCOL) {
420                         return -1;
421                 }
422
423                 if(me->mloopcol) {
424                         CustomData_add_layer_named(&me->ldata, CD_MLOOPCOL, CD_DUPLICATE, me->mloopcol, me->totloop, name);
425                         CustomData_add_layer_named(&me->fdata, CD_MCOL, CD_DUPLICATE, me->mloopcol, me->totface, name);
426                 }
427                 else {
428                         CustomData_add_layer_named(&me->ldata, CD_MLOOPCOL, CD_DEFAULT, NULL, me->totloop, name);
429                         CustomData_add_layer_named(&me->fdata, CD_MCOL, CD_DEFAULT, NULL, me->totface, name);
430                 }
431
432                 if(active_set || layernum==0) {
433                         CustomData_set_layer_active(&me->ldata, CD_MLOOPCOL, layernum);
434                         CustomData_set_layer_active(&me->fdata, CD_MCOL, layernum);
435                 }
436
437                 mesh_update_customdata_pointers(me, TRUE);
438         }
439
440         DAG_id_tag_update(&me->id, 0);
441         WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);
442
443         return layernum;
444 }
445
446 int ED_mesh_color_remove(bContext *C, Object *ob, Mesh *me)
447 {
448         CustomDataLayer *cdl;
449         int index;
450
451         index= CustomData_get_active_layer_index(&me->ldata, CD_MLOOPCOL);
452         cdl= (index == -1)? NULL: &me->ldata.layers[index];
453
454         if(!cdl)
455                 return 0;
456
457         delete_customdata_layer(C, ob, cdl);
458         DAG_id_tag_update(&me->id, 0);
459         WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);
460
461         return 1;
462 }
463
464 int ED_mesh_color_remove_named(bContext *C, Object *ob, Mesh *me, const char *name)
465 {
466         CustomDataLayer *cdl;
467         int index;
468
469         index= CustomData_get_named_layer_index(&me->ldata, CD_MLOOPCOL, name);
470         cdl= (index == -1)? NULL: &me->ldata.layers[index];
471
472         if(!cdl)
473                 return 0;
474
475         delete_customdata_layer(C, ob, cdl);
476         DAG_id_tag_update(&me->id, 0);
477         WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);
478
479         return 1;
480 }
481
482 /*********************** UV texture operators ************************/
483
484 static int layers_poll(bContext *C)
485 {
486         Object *ob= ED_object_context(C);
487         ID *data= (ob)? ob->data: NULL;
488         return (ob && !ob->id.lib && ob->type==OB_MESH && data && !data->lib);
489 }
490
491 static int uv_texture_add_exec(bContext *C, wmOperator *UNUSED(op))
492 {
493         Object *ob= ED_object_context(C);
494         Mesh *me= ob->data;
495
496         if(ED_mesh_uv_texture_add(C, me, NULL, TRUE) == -1)
497                 return OPERATOR_CANCELLED;
498
499         return OPERATOR_FINISHED;
500 }
501
502 void MESH_OT_uv_texture_add(wmOperatorType *ot)
503 {
504         /* identifiers */
505         ot->name= "Add UV Map";
506         ot->description= "Add UV Map";
507         ot->idname= "MESH_OT_uv_texture_add";
508         
509         /* api callbacks */
510         ot->poll= layers_poll;
511         ot->exec= uv_texture_add_exec;
512
513         /* flags */
514         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
515 }
516
517 static int drop_named_image_invoke(bContext *C, wmOperator *op, wmEvent *event)
518 {
519         Main *bmain= CTX_data_main(C);
520         Scene *scene= CTX_data_scene(C);
521         View3D *v3d= CTX_wm_view3d(C);
522         Base *base= ED_view3d_give_base_under_cursor(C, event->mval);
523         Image *ima= NULL;
524         Mesh *me;
525         Object *obedit;
526         int exitmode= 0;
527         char name[MAX_ID_NAME-2];
528         
529         /* Check context */
530         if(base==NULL || base->object->type!=OB_MESH) {
531                 BKE_report(op->reports, RPT_ERROR, "Not an Object or Mesh");
532                 return OPERATOR_CANCELLED;
533         }
534         
535         /* check input variables */
536         if(RNA_struct_property_is_set(op->ptr, "filepath")) {
537                 char path[FILE_MAX];
538                 
539                 RNA_string_get(op->ptr, "filepath", path);
540                 ima= BKE_add_image_file(path);
541         }
542         else {
543                 RNA_string_get(op->ptr, "name", name);
544                 ima= (Image *)find_id("IM", name);
545         }
546         
547         if(!ima) {
548                 BKE_report(op->reports, RPT_ERROR, "Not an Image");
549                 return OPERATOR_CANCELLED;
550         }
551         
552         /* put mesh in editmode */
553
554         obedit= base->object;
555         me= obedit->data;
556         if(me->edit_btmesh==NULL) {
557                 EDBM_MakeEditBMesh(scene->toolsettings, scene, obedit);
558                 exitmode= 1;
559         }
560         if(me->edit_btmesh==NULL)
561                 return OPERATOR_CANCELLED;
562         
563         ED_uvedit_assign_image(bmain, scene, obedit, ima, NULL);
564
565         if(exitmode) {
566                 EDBM_LoadEditBMesh(scene, obedit);
567                 EDBM_FreeEditBMesh(me->edit_btmesh);
568                 MEM_freeN(me->edit_btmesh);
569                 me->edit_btmesh= NULL;
570
571                 /* load_editMesh free's pointers used by CustomData layers which might be used by DerivedMesh too,
572                  * so signal to re-create DerivedMesh here (sergey) */
573                 DAG_id_tag_update(&me->id, 0);
574         }
575
576         /* dummie drop support; ensure view shows a result :) */
577         if(v3d)
578                 v3d->flag2 |= V3D_SOLID_TEX;
579         
580         WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data);
581         
582         return OPERATOR_FINISHED;
583 }
584
585 void MESH_OT_drop_named_image(wmOperatorType *ot)
586 {
587         /* identifiers */
588         ot->name= "Assign Image to UV Map";
589         ot->description= "Assign Image to active UV Map, or create an UV Map";
590         ot->idname= "MESH_OT_drop_named_image";
591         
592         /* api callbacks */
593         ot->poll= layers_poll;
594         ot->invoke= drop_named_image_invoke;
595         
596         /* flags */
597         ot->flag= OPTYPE_UNDO;
598         
599         /* properties */
600         RNA_def_string(ot->srna, "name", "Image", MAX_ID_NAME-2, "Name", "Image name to assign");
601         RNA_def_string(ot->srna, "filepath", "Path", FILE_MAX, "Filepath", "Path to image file");
602 }
603
604 static int uv_texture_remove_exec(bContext *C, wmOperator *UNUSED(op))
605 {
606         Object *ob= ED_object_context(C);
607         Mesh *me= ob->data;
608
609         if(!ED_mesh_uv_texture_remove(C, ob, me))
610                 return OPERATOR_CANCELLED;
611
612         return OPERATOR_FINISHED;
613 }
614
615 void MESH_OT_uv_texture_remove(wmOperatorType *ot)
616 {
617         /* identifiers */
618         ot->name= "Remove UV Map";
619         ot->description= "Remove UV Map";
620         ot->idname= "MESH_OT_uv_texture_remove";
621         
622         /* api callbacks */
623         ot->poll= layers_poll;
624         ot->exec= uv_texture_remove_exec;
625
626         /* flags */
627         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
628 }
629
630 /*********************** vertex color operators ************************/
631
632 static int vertex_color_add_exec(bContext *C, wmOperator *UNUSED(op))
633 {
634         Scene *scene= CTX_data_scene(C);
635         Object *ob= ED_object_context(C);
636         Mesh *me= ob->data;
637
638         if(ED_mesh_color_add(C, scene, ob, me, NULL, TRUE) == -1)
639                 return OPERATOR_CANCELLED;
640
641         return OPERATOR_FINISHED;
642 }
643
644 void MESH_OT_vertex_color_add(wmOperatorType *ot)
645 {
646         /* identifiers */
647         ot->name= "Add Vertex Color";
648         ot->description= "Add vertex color layer";
649         ot->idname= "MESH_OT_vertex_color_add";
650         
651         /* api callbacks */
652         ot->poll= layers_poll;
653         ot->exec= vertex_color_add_exec;
654
655         /* flags */
656         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
657 }
658
659 static int vertex_color_remove_exec(bContext *C, wmOperator *UNUSED(op))
660 {
661         Object *ob= ED_object_context(C);
662         Mesh *me= ob->data;
663
664         if(!ED_mesh_color_remove(C, ob, me))
665                 return OPERATOR_CANCELLED;
666
667         return OPERATOR_FINISHED;
668 }
669
670 void MESH_OT_vertex_color_remove(wmOperatorType *ot)
671 {
672         /* identifiers */
673         ot->name= "Remove Vertex Color";
674         ot->description= "Remove vertex color layer";
675         ot->idname= "MESH_OT_vertex_color_remove";
676         
677         /* api callbacks */
678         ot->exec= vertex_color_remove_exec;
679         ot->poll= layers_poll;
680
681         /* flags */
682         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
683 }
684
685 /*********************** sticky operators ************************/
686
687 static int sticky_add_exec(bContext *C, wmOperator *UNUSED(op))
688 {
689         Scene *scene= CTX_data_scene(C);
690         View3D *v3d= CTX_wm_view3d(C);
691         Object *ob= ED_object_context(C);
692         Mesh *me= ob->data;
693
694         /*if(me->msticky)
695                 return OPERATOR_CANCELLED;*/
696
697         RE_make_sticky(scene, v3d);
698
699         DAG_id_tag_update(&me->id, 0);
700         WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);
701
702         return OPERATOR_FINISHED;
703 }
704
705 void MESH_OT_sticky_add(wmOperatorType *ot)
706 {
707         /* identifiers */
708         ot->name= "Add Sticky";
709         ot->description= "Add sticky UV texture layer";
710         ot->idname= "MESH_OT_sticky_add";
711         
712         /* api callbacks */
713         ot->poll= layers_poll;
714         ot->exec= sticky_add_exec;
715
716         /* flags */
717         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
718 }
719
720 static int sticky_remove_exec(bContext *C, wmOperator *UNUSED(op))
721 {
722         Object *ob= ED_object_context(C);
723         Mesh *me= ob->data;
724
725         if(!me->msticky)
726                 return OPERATOR_CANCELLED;
727
728         CustomData_free_layer_active(&me->vdata, CD_MSTICKY, me->totvert);
729         me->msticky= NULL;
730
731         DAG_id_tag_update(&me->id, 0);
732         WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);
733
734         return OPERATOR_FINISHED;
735 }
736
737 void MESH_OT_sticky_remove(wmOperatorType *ot)
738 {
739         /* identifiers */
740         ot->name= "Remove Sticky";
741         ot->description= "Remove sticky UV texture layer";
742         ot->idname= "MESH_OT_sticky_remove";
743         
744         /* api callbacks */
745         ot->poll= layers_poll;
746         ot->exec= sticky_remove_exec;
747
748         /* flags */
749         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
750 }
751
752 /************************** Add Geometry Layers *************************/
753
754 void ED_mesh_update(Mesh *mesh, bContext *C, int calc_edges)
755 {
756         int *polyindex = NULL;
757         float (*face_nors)[3];
758
759         if(mesh->totface > 0 && mesh->totpoly == 0)
760                 convert_mfaces_to_mpolys(mesh);
761
762         if(calc_edges || (mesh->totpoly && mesh->totedge == 0))
763                 BKE_mesh_calc_edges(mesh, calc_edges);
764
765         /* TODO, make this optional, we dont always want this! */
766         BKE_mesh_tessface_calc(mesh);
767
768         polyindex = CustomData_get_layer(&mesh->fdata, CD_POLYINDEX);
769         /* add a normals layer for tesselated faces, a tessface normal will
770            contain the normal of the poly the face was tesselated from. */
771         face_nors = CustomData_add_layer(&mesh->fdata, CD_NORMAL, CD_CALLOC, NULL, mesh->totface);
772
773         mesh_calc_normals_mapping(
774                 mesh->mvert,
775                 mesh->totvert,
776                 mesh->mloop,
777                 mesh->mpoly,
778                 mesh->totloop,
779                 mesh->totpoly,
780                 NULL /* polyNors_r */,
781                 mesh->mface,
782                 mesh->totface,
783                 polyindex,
784                 face_nors);
785
786         DAG_id_tag_update(&mesh->id, 0);
787         WM_event_add_notifier(C, NC_GEOM|ND_DATA, mesh);
788 }
789
790 static void mesh_add_verts(Mesh *mesh, int len)
791 {
792         CustomData vdata;
793         MVert *mvert;
794         int i, totvert;
795
796         if(len == 0)
797                 return;
798
799         totvert= mesh->totvert + len;
800         CustomData_copy(&mesh->vdata, &vdata, CD_MASK_MESH, CD_DEFAULT, totvert);
801         CustomData_copy_data(&mesh->vdata, &vdata, 0, 0, mesh->totvert);
802
803         if(!CustomData_has_layer(&vdata, CD_MVERT))
804                 CustomData_add_layer(&vdata, CD_MVERT, CD_CALLOC, NULL, totvert);
805
806         CustomData_free(&mesh->vdata, mesh->totvert);
807         mesh->vdata= vdata;
808         mesh_update_customdata_pointers(mesh, FALSE);
809
810         /* scan the input list and insert the new vertices */
811
812         mvert= &mesh->mvert[mesh->totvert];
813         for(i=0; i<len; i++, mvert++)
814                 mvert->flag |= SELECT;
815
816         /* set final vertex list size */
817         mesh->totvert= totvert;
818 }
819
820 void ED_mesh_transform(Mesh *me, float *mat)
821 {
822         int i;
823         MVert *mvert= me->mvert;
824
825         for(i= 0; i < me->totvert; i++, mvert++)
826                 mul_m4_v3((float (*)[4])mat, mvert->co);
827
828         mesh_calc_normals_mapping(me->mvert, me->totvert, me->mloop, me->mpoly, me->totloop, me->totpoly, NULL, NULL, 0, NULL, NULL);
829 }
830
831 static void mesh_add_edges(Mesh *mesh, int len)
832 {
833         CustomData edata;
834         MEdge *medge;
835         int i, totedge;
836
837         if(len == 0)
838                 return;
839
840         totedge= mesh->totedge+len;
841
842         /* update customdata  */
843         CustomData_copy(&mesh->edata, &edata, CD_MASK_MESH, CD_DEFAULT, totedge);
844         CustomData_copy_data(&mesh->edata, &edata, 0, 0, mesh->totedge);
845
846         if(!CustomData_has_layer(&edata, CD_MEDGE))
847                 CustomData_add_layer(&edata, CD_MEDGE, CD_CALLOC, NULL, totedge);
848
849         CustomData_free(&mesh->edata, mesh->totedge);
850         mesh->edata= edata;
851         mesh_update_customdata_pointers(mesh, FALSE); /* new edges dont change tessellation */
852
853         /* set default flags */
854         medge= &mesh->medge[mesh->totedge];
855         for(i=0; i<len; i++, medge++)
856                 medge->flag= ME_EDGEDRAW|ME_EDGERENDER|SELECT;
857
858         mesh->totedge= totedge;
859 }
860
861 static void mesh_add_faces(Mesh *mesh, int len)
862 {
863         CustomData fdata;
864         MFace *mface;
865         int i, totface;
866
867         if(len == 0)
868                 return;
869
870         totface= mesh->totface + len;   /* new face count */
871
872         /* update customdata */
873         CustomData_copy(&mesh->fdata, &fdata, CD_MASK_MESH, CD_DEFAULT, totface);
874         CustomData_copy_data(&mesh->fdata, &fdata, 0, 0, mesh->totface);
875
876         if(!CustomData_has_layer(&fdata, CD_MFACE))
877                 CustomData_add_layer(&fdata, CD_MFACE, CD_CALLOC, NULL, totface);
878
879         CustomData_free(&mesh->fdata, mesh->totface);
880         mesh->fdata= fdata;
881         mesh_update_customdata_pointers(mesh, TRUE);
882
883         /* set default flags */
884         mface= &mesh->mface[mesh->totface];
885         for(i=0; i<len; i++, mface++)
886                 mface->flag= ME_FACE_SEL;
887
888         mesh->totface= totface;
889 }
890
891 static void mesh_add_loops(Mesh *mesh, int len)
892 {
893         CustomData ldata;
894         int totloop;
895
896         if(len == 0)
897                 return;
898
899         totloop= mesh->totloop + len;   /* new face count */
900
901         /* update customdata */
902         CustomData_copy(&mesh->ldata, &ldata, CD_MASK_MESH, CD_DEFAULT, totloop);
903         CustomData_copy_data(&mesh->ldata, &ldata, 0, 0, mesh->totloop);
904
905         if(!CustomData_has_layer(&ldata, CD_MLOOP))
906                 CustomData_add_layer(&ldata, CD_MLOOP, CD_CALLOC, NULL, totloop);
907
908         CustomData_free(&mesh->ldata, mesh->totloop);
909         mesh->ldata= ldata;
910         mesh_update_customdata_pointers(mesh, TRUE);
911
912         mesh->totloop= totloop;
913 }
914
915 static void mesh_add_polys(Mesh *mesh, int len)
916 {
917         CustomData pdata;
918         MPoly *mpoly;
919         int i, totpoly;
920
921         if(len == 0)
922                 return;
923
924         totpoly= mesh->totpoly + len;   /* new face count */
925
926         /* update customdata */
927         CustomData_copy(&mesh->pdata, &pdata, CD_MASK_MESH, CD_DEFAULT, totpoly);
928         CustomData_copy_data(&mesh->pdata, &pdata, 0, 0, mesh->totpoly);
929
930         if(!CustomData_has_layer(&pdata, CD_MPOLY))
931                 CustomData_add_layer(&pdata, CD_MPOLY, CD_CALLOC, NULL, totpoly);
932
933         CustomData_free(&mesh->pdata, mesh->totpoly);
934         mesh->pdata= pdata;
935         mesh_update_customdata_pointers(mesh, TRUE);
936
937         /* set default flags */
938         mpoly= &mesh->mpoly[mesh->totpoly];
939         for(i=0; i<len; i++, mpoly++)
940                 mpoly->flag= ME_FACE_SEL;
941
942         mesh->totpoly= totpoly;
943 }
944
945 static void mesh_remove_verts(Mesh *mesh, int len)
946 {
947         int totvert;
948
949         if(len == 0)
950                 return;
951
952         totvert= mesh->totvert - len;
953         CustomData_free_elem(&mesh->vdata, totvert, len);
954
955         /* set final vertex list size */
956         mesh->totvert= totvert;
957 }
958
959 static void mesh_remove_edges(Mesh *mesh, int len)
960 {
961         int totedge;
962
963         if(len == 0)
964                 return;
965
966         totedge= mesh->totedge - len;
967         CustomData_free_elem(&mesh->edata, totedge, len);
968
969         mesh->totedge= totedge;
970 }
971
972 static void mesh_remove_faces(Mesh *mesh, int len)
973 {
974         int totface;
975
976         if(len == 0)
977                 return;
978
979         totface= mesh->totface - len;   /* new face count */
980         CustomData_free_elem(&mesh->fdata, totface, len);
981
982         mesh->totface= totface;
983 }
984
985 /*
986 void ED_mesh_geometry_add(Mesh *mesh, ReportList *reports, int verts, int edges, int faces)
987 {
988         if(mesh->edit_btmesh) {
989                 BKE_report(reports, RPT_ERROR, "Can't add geometry in edit mode");
990                 return;
991         }
992
993         if(verts)
994                 mesh_add_verts(mesh, verts);
995         if(edges)
996                 mesh_add_edges(mesh, edges);
997         if(faces)
998                 mesh_add_faces(mesh, faces);
999 }
1000 */
1001
1002 void ED_mesh_faces_add(Mesh *mesh, ReportList *reports, int count)
1003 {
1004         if(mesh->edit_btmesh) {
1005                 BKE_report(reports, RPT_ERROR, "Can't add faces in edit mode");
1006                 return;
1007         }
1008
1009         mesh_add_faces(mesh, count);
1010 }
1011
1012 void ED_mesh_edges_add(Mesh *mesh, ReportList *reports, int count)
1013 {
1014         if(mesh->edit_btmesh) {
1015                 BKE_report(reports, RPT_ERROR, "Can't add edges in edit mode");
1016                         return;
1017         }
1018
1019         mesh_add_edges(mesh, count);
1020 }
1021
1022 void ED_mesh_vertices_add(Mesh *mesh, ReportList *reports, int count)
1023 {
1024         if(mesh->edit_btmesh) {
1025                 BKE_report(reports, RPT_ERROR, "Can't add vertices in edit mode");
1026                 return;
1027         }
1028
1029         mesh_add_verts(mesh, count);
1030 }
1031
1032 void ED_mesh_faces_remove(Mesh *mesh, ReportList *reports, int count)
1033 {
1034         if(mesh->edit_btmesh) {
1035                 BKE_report(reports, RPT_ERROR, "Can't remove faces in edit mode");
1036                 return;
1037         }
1038         else if(count > mesh->totface) {
1039                 BKE_report(reports, RPT_ERROR, "Can't remove more faces than the mesh contains");
1040                 return;
1041         }
1042
1043         mesh_remove_faces(mesh, count);
1044 }
1045
1046 void ED_mesh_edges_remove(Mesh *mesh, ReportList *reports, int count)
1047 {
1048         if(mesh->edit_btmesh) {
1049                 BKE_report(reports, RPT_ERROR, "Can't remove edges in edit mode");
1050                 return;
1051         }
1052         else if(count > mesh->totedge) {
1053                 BKE_report(reports, RPT_ERROR, "Can't remove more edges than the mesh contains");
1054                 return;
1055         }
1056
1057         mesh_remove_edges(mesh, count);
1058 }
1059
1060 void ED_mesh_vertices_remove(Mesh *mesh, ReportList *reports, int count)
1061 {
1062         if(mesh->edit_btmesh) {
1063                 BKE_report(reports, RPT_ERROR, "Can't remove vertices in edit mode");
1064                 return;
1065         }
1066         else if(count > mesh->totvert) {
1067                 BKE_report(reports, RPT_ERROR, "Can't remove more vertices than the mesh contains");
1068                 return;
1069         }
1070
1071         mesh_remove_verts(mesh, count);
1072 }
1073
1074 void ED_mesh_loops_add(Mesh *mesh, ReportList *reports, int count)
1075 {
1076         if(mesh->edit_btmesh) {
1077                 BKE_report(reports, RPT_ERROR, "Can't add loops in edit mode.");
1078                         return;
1079         }
1080
1081         mesh_add_loops(mesh, count);
1082 }
1083
1084 void ED_mesh_polys_add(Mesh *mesh, ReportList *reports, int count)
1085 {
1086         if(mesh->edit_btmesh) {
1087                 BKE_report(reports, RPT_ERROR, "Can't add polys in edit mode.");
1088                 return;
1089         }
1090
1091         mesh_add_polys(mesh, count);
1092 }
1093
1094 void ED_mesh_calc_normals(Mesh *mesh)
1095 {
1096         mesh_calc_normals_mapping(mesh->mvert, mesh->totvert, mesh->mloop, mesh->mpoly, mesh->totloop, mesh->totpoly, NULL, NULL, 0, NULL, NULL);
1097 }