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