merge with/from trunk at r35190
[blender.git] / source / blender / editors / mesh / mesh_data.c
index eb6927cec657b47f44f60bdadfdddbd824c7d615..0ae3076170c6be4ad55bea18fe59b877b452051d 100644 (file)
@@ -1,4 +1,4 @@
-/**
+/*
  * $Id$
  *
  * ***** BEGIN GPL LICENSE BLOCK *****
@@ -15,7 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
  * The Original Code is Copyright (C) 2009 Blender Foundation.
  * All rights reserved.
 
 #include "MEM_guardedalloc.h"
 
-#include "DNA_customdata_types.h"
 #include "DNA_material_types.h"
-#include "DNA_mesh_types.h"
 #include "DNA_meshdata_types.h"
 #include "DNA_object_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_view3d_types.h"
-#include "DNA_windowmanager_types.h"
+
+#include "BLI_math.h"
+#include "BLI_editVert.h"
+#include "BLI_edgehash.h"
+#include "BLI_utildefines.h"
 
 #include "BKE_context.h"
-#include "BKE_customdata.h"
 #include "BKE_depsgraph.h"
 #include "BKE_displist.h"
-#include "BKE_global.h"
+#include "BKE_image.h"
+#include "BKE_library.h"
 #include "BKE_material.h"
 #include "BKE_mesh.h"
 #include "BKE_report.h"
-
-#include "BLI_math.h"
-#include "BLI_editVert.h"
-#include "BLI_edgehash.h"
+#include "BKE_tessmesh.h"
 
 #include "RNA_access.h"
 #include "RNA_define.h"
 
 #include "ED_mesh.h"
 #include "ED_object.h"
+#include "ED_uvedit.h"
 #include "ED_view3d.h"
 
 #include "RE_render_ext.h"
 
 #include "mesh_intern.h"
 
+#define GET_CD_DATA(me, data) (me->edit_btmesh ? &me->edit_btmesh->bm->data : &me->data)
+
 static void delete_customdata_layer(bContext *C, Object *ob, CustomDataLayer *layer)
 {
        Mesh *me = ob->data;
-       CustomData *data= (me->edit_mesh)? &me->edit_mesh->fdata: &me->fdata;
-       void *actlayerdata, *rndlayerdata, *clonelayerdata, *masklayerdata, *layerdata=layer->data;
+       CustomData *data;
+       void *actlayerdata, *rndlayerdata, *clonelayerdata, *stencillayerdata, *layerdata=layer->data;
        int type= layer->type;
-       int index= CustomData_get_layer_index(data, type);
-       int i, actindex, rndindex, cloneindex, maskindex;
+       int index;
+       int i, actindex, rndindex, cloneindex, stencilindex, tot;
        
+       if (layer->type == CD_MLOOPCOL || layer->type == CD_MLOOPUV) {
+               data = (me->edit_btmesh)? &me->edit_btmesh->bm->ldata: &me->ldata;
+               tot = me->totloop;
+       } else {
+               data = (me->edit_btmesh)? &me->edit_btmesh->bm->pdata: &me->pdata;
+               tot = me->totpoly;
+       }
+       
+       index = CustomData_get_layer_index(data, type);
+
        /* ok, deleting a non-active layer needs to preserve the active layer indices.
          to do this, we store a pointer to the .data member of both layer and the active layer,
          (to detect if we're deleting the active layer or not), then use the active
@@ -87,18 +99,18 @@ static void delete_customdata_layer(bContext *C, Object *ob, CustomDataLayer *la
        actlayerdata = data->layers[CustomData_get_active_layer_index(data, type)].data;
        rndlayerdata = data->layers[CustomData_get_render_layer_index(data, type)].data;
        clonelayerdata = data->layers[CustomData_get_clone_layer_index(data, type)].data;
-       masklayerdata = data->layers[CustomData_get_mask_layer_index(data, type)].data;
+       stencillayerdata = data->layers[CustomData_get_stencil_layer_index(data, type)].data;
        CustomData_set_layer_active(data, type, layer - &data->layers[index]);
 
-       if(me->edit_mesh) {
-               EM_free_data_layer(me->edit_mesh, data, type);
+       if(me->edit_btmesh) {
+               BM_free_data_layer(me->edit_btmesh->bm, data, type);
        }
        else {
-               CustomData_free_layer_active(data, type, me->totface);
+               CustomData_free_layer_active(data, type, tot);
                mesh_update_customdata_pointers(me);
        }
 
-       if(!CustomData_has_layer(data, type) && (type == CD_MCOL && (ob->mode & OB_MODE_VERTEX_PAINT)))
+       if(!CustomData_has_layer(data, type) && (type == CD_MLOOPCOL && (ob->mode & OB_MODE_VERTEX_PAINT)))
                ED_object_toggle_modes(C, OB_MODE_VERTEX_PAINT);
 
        /* reconstruct active layer */
@@ -144,51 +156,65 @@ static void delete_customdata_layer(bContext *C, Object *ob, CustomDataLayer *la
                CustomData_set_layer_clone(data, type, cloneindex);
        }
        
-       if (masklayerdata != layerdata) {
+       if (stencillayerdata != layerdata) {
                /* find index */
-               maskindex = CustomData_get_layer_index(data, type);
-               for (i=maskindex; i<data->totlayer; i++) {
-                       if (data->layers[i].data == masklayerdata) {
-                               maskindex = i - maskindex;
+               stencilindex = CustomData_get_layer_index(data, type);
+               for (i=stencilindex; i<data->totlayer; i++) {
+                       if (data->layers[i].data == stencillayerdata) {
+                               stencilindex = i - stencilindex;
                                break;
                        }
                }
                
                /* set index */
-               CustomData_set_layer_mask(data, type, maskindex);
+               CustomData_set_layer_stencil(data, type, stencilindex);
        }
 }
 
-int ED_mesh_uv_texture_add(bContext *C, Scene *scene, Object *ob, Mesh *me)
+int ED_mesh_uv_texture_add(bContext *C, Mesh *me, const char *name, int active_set)
 {
-       EditMesh *em;
+       BMEditMesh *em;
        int layernum;
 
-       if(me->edit_mesh) {
-               em= me->edit_mesh;
+       if(me->edit_btmesh) {
+               em= me->edit_btmesh;
 
-               layernum= CustomData_number_of_layers(&em->fdata, CD_MTFACE);
+               layernum= CustomData_number_of_layers(&em->bm->pdata, CD_MTEXPOLY);
                if(layernum >= MAX_MTFACE)
-                       return OPERATOR_CANCELLED;
+                       return 0;
 
-               EM_add_data_layer(em, &em->fdata, CD_MTFACE);
-               CustomData_set_layer_active(&em->fdata, CD_MTFACE, layernum);
+               BM_add_data_layer(em->bm, &em->bm->pdata, CD_MTEXPOLY);
+               CustomData_set_layer_active(&em->bm->pdata, CD_MTEXPOLY, layernum);
+               if(active_set || layernum==0)
+                       CustomData_set_layer_active(&em->bm->pdata, CD_MTEXPOLY, layernum);
+
+               BM_add_data_layer(em->bm, &em->bm->ldata, CD_MLOOPUV);
+               CustomData_set_layer_active(&em->bm->ldata, CD_MLOOPUV, layernum);
+               if(active_set || layernum==0)
+                       CustomData_set_layer_active(&em->bm->ldata, CD_MLOOPUV, layernum);
        }
        else {
-               layernum= CustomData_number_of_layers(&me->fdata, CD_MTFACE);
+               layernum= CustomData_number_of_layers(&me->pdata, CD_MTEXPOLY);
                if(layernum >= MAX_MTFACE)
-                       return OPERATOR_CANCELLED;
-
-               if(me->mtface)
-                       CustomData_add_layer(&me->fdata, CD_MTFACE, CD_DUPLICATE, me->mtface, me->totface);
-               else
-                       CustomData_add_layer(&me->fdata, CD_MTFACE, CD_DEFAULT, NULL, me->totface);
+                       return 0;
 
-               CustomData_set_layer_active(&me->fdata, CD_MTFACE, layernum);
+               if(me->mtpoly) {
+                       CustomData_add_layer_named(&me->pdata, CD_MTEXPOLY, CD_DUPLICATE, me->mtpoly, me->totpoly, name);
+                       CustomData_add_layer_named(&me->ldata, CD_MLOOPUV, CD_DUPLICATE, me->mloopuv, me->totloop, name);
+               } else {
+                       CustomData_add_layer_named(&me->pdata, CD_MTEXPOLY, CD_DEFAULT, NULL, me->totpoly, name);
+                       CustomData_add_layer_named(&me->ldata, CD_MLOOPUV, CD_DEFAULT, NULL, me->totloop, name);
+               }
+               
+               if(active_set || layernum==0) {
+                       CustomData_set_layer_active(&me->pdata, CD_MTEXPOLY, layernum);
+                       CustomData_set_layer_active(&me->ldata, CD_MLOOPUV, layernum);
+               }
+               
                mesh_update_customdata_pointers(me);
        }
 
-       DAG_id_flush_update(&me->id, OB_RECALC_DATA);
+       DAG_id_tag_update(&me->id, 0);
        WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);
 
        return 1;
@@ -196,58 +222,72 @@ int ED_mesh_uv_texture_add(bContext *C, Scene *scene, Object *ob, Mesh *me)
 
 int ED_mesh_uv_texture_remove(bContext *C, Object *ob, Mesh *me)
 {
-       CustomDataLayer *cdl;
+       CustomData *pdata = GET_CD_DATA(me, pdata), *ldata = GET_CD_DATA(me, ldata);
+       CustomDataLayer *cdlp, *cdlu;
        int index;
 
-       index= CustomData_get_active_layer_index(&me->fdata, CD_MTFACE);
-       cdl= (index == -1)? NULL: &me->fdata.layers[index];
+       index= CustomData_get_active_layer_index(pdata, CD_MTEXPOLY);
+       cdlp= (index == -1)? NULL: &pdata->layers[index];
 
-       if(!cdl)
+       index= CustomData_get_active_layer_index(ldata, CD_MLOOPUV);
+       cdlu= (index == -1)? NULL: &ldata->layers[index];
+       
+       if (!cdlp || !cdlu)
                return 0;
 
-       delete_customdata_layer(C, ob, cdl);
-       DAG_id_flush_update(&me->id, OB_RECALC_DATA);
+       delete_customdata_layer(C, ob, cdlp);
+       delete_customdata_layer(C, ob, cdlu);
+       
+       DAG_id_tag_update(&me->id, 0);
        WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);
 
        return 1;
 }
 
-int ED_mesh_color_add(bContext *C, Scene *scene, Object *ob, Mesh *me)
+int ED_mesh_color_add(bContext *C, Scene *scene, Object *ob, Mesh *me, const char *name, int active_set)
 {
-       EditMesh *em;
-       MCol *mcol;
+       BMEditMesh *em;
+       MLoopCol *mcol;
        int layernum;
 
-       if(me->edit_mesh) {
-               em= me->edit_mesh;
+       if(me->edit_btmesh) {
+               em= me->edit_btmesh;
 
-               layernum= CustomData_number_of_layers(&em->fdata, CD_MCOL);
+               layernum= CustomData_number_of_layers(&em->bm->ldata, CD_MLOOPCOL);
                if(layernum >= MAX_MCOL)
                        return 0;
 
-               EM_add_data_layer(em, &em->fdata, CD_MCOL);
-               CustomData_set_layer_active(&em->fdata, CD_MCOL, layernum);
+               BM_add_data_layer(em->bm, &em->bm->pdata, CD_MLOOPCOL);
+               CustomData_set_layer_active(&em->bm->ldata, CD_MLOOPCOL, layernum);
+
+               if(active_set || layernum==0)
+                       CustomData_set_layer_active(&em->bm->ldata, CD_MLOOPCOL, layernum);
+
        }
        else {
-               layernum= CustomData_number_of_layers(&me->fdata, CD_MCOL);
-               if(layernum >= MAX_MCOL)
+               layernum= CustomData_number_of_layers(&me->ldata, CD_MLOOPCOL);
+               if(layernum >= CD_MLOOPCOL)
                        return 0;
 
-               mcol= me->mcol;
+               mcol= me->mloopcol;
 
-               if(me->mcol)
-                       CustomData_add_layer(&me->fdata, CD_MCOL, CD_DUPLICATE, me->mcol, me->totface);
+               if(me->mloopcol)
+                       CustomData_add_layer_named(&me->ldata, CD_MLOOPCOL, CD_DUPLICATE, me->mloopcol, me->totloop, name);
                else
-                       CustomData_add_layer(&me->fdata, CD_MCOL, CD_DEFAULT, NULL, me->totface);
+                       CustomData_add_layer_named(&me->ldata, CD_MLOOPCOL, CD_DEFAULT, NULL, me->totloop, name);
+
+               if(active_set || layernum==0)
+                       CustomData_set_layer_active(&me->ldata, CD_MLOOPCOL, layernum);
 
-               CustomData_set_layer_active(&me->fdata, CD_MCOL, layernum);
                mesh_update_customdata_pointers(me);
 
+               /*BMESH_TODO
                if(!mcol)
                        shadeMeshMCol(scene, ob, me);
+               */
        }
 
-       DAG_id_flush_update(&me->id, OB_RECALC_DATA);
+       DAG_id_tag_update(&me->id, 0);
        WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);
 
        return 1;
@@ -258,14 +298,14 @@ int ED_mesh_color_remove(bContext *C, Object *ob, Mesh *me)
        CustomDataLayer *cdl;
        int index;
 
-       index= CustomData_get_active_layer_index(&me->fdata, CD_MCOL);
-       cdl= (index == -1)? NULL: &me->fdata.layers[index];
+       index= CustomData_get_active_layer_index(&me->ldata, CD_MLOOPCOL);
+       cdl= (index == -1)? NULL: &me->ldata.layers[index];
 
        if(!cdl)
                return 0;
 
        delete_customdata_layer(C, ob, cdl);
-       DAG_id_flush_update(&me->id, OB_RECALC_DATA);
+       DAG_id_tag_update(&me->id, 0);
        WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);
 
        return 1;
@@ -280,13 +320,12 @@ static int layers_poll(bContext *C)
        return (ob && !ob->id.lib && ob->type==OB_MESH && data && !data->lib);
 }
 
-static int uv_texture_add_exec(bContext *C, wmOperator *op)
+static int uv_texture_add_exec(bContext *C, wmOperator *UNUSED(op))
 {
-       Scene *scene= CTX_data_scene(C);
        Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
        Mesh *me= ob->data;
 
-       if(!ED_mesh_uv_texture_add(C, scene, ob, me))
+       if(!ED_mesh_uv_texture_add(C, me, NULL, TRUE))
                return OPERATOR_CANCELLED;
 
        return OPERATOR_FINISHED;
@@ -296,7 +335,7 @@ void MESH_OT_uv_texture_add(wmOperatorType *ot)
 {
        /* identifiers */
        ot->name= "Add UV Texture";
-       ot->description= "Add UV texture layer.";
+       ot->description= "Add UV texture layer";
        ot->idname= "MESH_OT_uv_texture_add";
        
        /* api callbacks */
@@ -307,7 +346,90 @@ void MESH_OT_uv_texture_add(wmOperatorType *ot)
        ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 }
 
-static int uv_texture_remove_exec(bContext *C, wmOperator *op)
+static int drop_named_image_invoke(bContext *C, wmOperator *op, wmEvent *event)
+{
+       Scene *scene= CTX_data_scene(C);
+       View3D *v3d= CTX_wm_view3d(C);
+       Base *base= ED_view3d_give_base_under_cursor(C, event->mval);
+       Image *ima= NULL;
+       Mesh *me;
+       Object *obedit;
+       int exitmode= 0;
+       char name[32];
+       
+       /* Check context */
+       if(base==NULL || base->object->type!=OB_MESH) {
+               BKE_report(op->reports, RPT_ERROR, "Not an Object or Mesh");
+               return OPERATOR_CANCELLED;
+       }
+       
+       /* check input variables */
+       if(RNA_property_is_set(op->ptr, "filepath")) {
+               char path[FILE_MAX];
+               
+               RNA_string_get(op->ptr, "filepath", path);
+               ima= BKE_add_image_file(path);
+       }
+       else {
+               RNA_string_get(op->ptr, "name", name);
+               ima= (Image *)find_id("IM", name);
+       }
+       
+       if(!ima) {
+               BKE_report(op->reports, RPT_ERROR, "Not an Image.");
+               return OPERATOR_CANCELLED;
+       }
+       
+       /* put mesh in editmode */
+
+       obedit= base->object;
+       me= obedit->data;
+       if(me->edit_btmesh==NULL) {
+               EDBM_MakeEditBMesh(scene->toolsettings, scene, obedit);
+               exitmode= 1;
+       }
+
+       if(me->edit_btmesh==NULL)
+               return OPERATOR_CANCELLED;
+       
+       ED_uvedit_assign_image(scene, obedit, ima, NULL);
+
+       if(exitmode) {
+               EDBM_LoadEditBMesh(scene, obedit);
+               EDBM_FreeEditBMesh(me->edit_btmesh);
+               MEM_freeN(me->edit_btmesh);
+               me->edit_btmesh= NULL;
+       }
+
+       /* dummie drop support; ensure view shows a result :) */
+       if(v3d)
+               v3d->flag2 |= V3D_SOLID_TEX;
+       
+       WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data);
+       
+       return OPERATOR_FINISHED;
+}
+
+void MESH_OT_drop_named_image(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name= "Assign Image to UV Texture";
+       ot->description= "Assigns Image to active UV layer, or creates a UV layer";
+       ot->idname= "MESH_OT_drop_named_image";
+       
+       /* api callbacks */
+       ot->poll= layers_poll;
+       ot->invoke= drop_named_image_invoke;
+       
+       /* flags */
+       ot->flag= OPTYPE_UNDO;
+       
+       /* properties */
+       RNA_def_string(ot->srna, "name", "Image", 24, "Name", "Image name to assign.");
+       RNA_def_string(ot->srna, "filepath", "Path", FILE_MAX, "Filepath", "Path to image file");
+}
+
+static int uv_texture_remove_exec(bContext *C, wmOperator *UNUSED(op))
 {
        Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
        Mesh *me= ob->data;
@@ -322,7 +444,7 @@ void MESH_OT_uv_texture_remove(wmOperatorType *ot)
 {
        /* identifiers */
        ot->name= "Remove UV Texture";
-       ot->description= "Remove UV texture layer.";
+       ot->description= "Remove UV texture layer";
        ot->idname= "MESH_OT_uv_texture_remove";
        
        /* api callbacks */
@@ -335,13 +457,13 @@ void MESH_OT_uv_texture_remove(wmOperatorType *ot)
 
 /*********************** vertex color operators ************************/
 
-static int vertex_color_add_exec(bContext *C, wmOperator *op)
+static int vertex_color_add_exec(bContext *C, wmOperator *UNUSED(op))
 {
        Scene *scene= CTX_data_scene(C);
        Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
        Mesh *me= ob->data;
 
-       if(!ED_mesh_color_add(C, scene, ob, me))
+       if(!ED_mesh_color_add(C, scene, ob, me, NULL, TRUE))
                return OPERATOR_CANCELLED;
 
        return OPERATOR_FINISHED;
@@ -351,7 +473,7 @@ void MESH_OT_vertex_color_add(wmOperatorType *ot)
 {
        /* identifiers */
        ot->name= "Add Vertex Color";
-       ot->description= "Add vertex color layer.";
+       ot->description= "Add vertex color layer";
        ot->idname= "MESH_OT_vertex_color_add";
        
        /* api callbacks */
@@ -362,7 +484,7 @@ void MESH_OT_vertex_color_add(wmOperatorType *ot)
        ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 }
 
-static int vertex_color_remove_exec(bContext *C, wmOperator *op)
+static int vertex_color_remove_exec(bContext *C, wmOperator *UNUSED(op))
 {
        Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
        Mesh *me= ob->data;
@@ -377,7 +499,7 @@ void MESH_OT_vertex_color_remove(wmOperatorType *ot)
 {
        /* identifiers */
        ot->name= "Remove Vertex Color";
-       ot->description= "Remove vertex color layer.";
+       ot->description= "Remove vertex color layer";
        ot->idname= "MESH_OT_vertex_color_remove";
        
        /* api callbacks */
@@ -390,7 +512,7 @@ void MESH_OT_vertex_color_remove(wmOperatorType *ot)
 
 /*********************** sticky operators ************************/
 
-static int sticky_add_exec(bContext *C, wmOperator *op)
+static int sticky_add_exec(bContext *C, wmOperator *UNUSED(op))
 {
        Scene *scene= CTX_data_scene(C);
        View3D *v3d= CTX_wm_view3d(C);
@@ -402,7 +524,7 @@ static int sticky_add_exec(bContext *C, wmOperator *op)
 
        RE_make_sticky(scene, v3d);
 
-       DAG_id_flush_update(&me->id, OB_RECALC_DATA);
+       DAG_id_tag_update(&me->id, 0);
        WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);
 
        return OPERATOR_FINISHED;
@@ -412,7 +534,7 @@ void MESH_OT_sticky_add(wmOperatorType *ot)
 {
        /* identifiers */
        ot->name= "Add Sticky";
-       ot->description= "Add sticky UV texture layer.";
+       ot->description= "Add sticky UV texture layer";
        ot->idname= "MESH_OT_sticky_add";
        
        /* api callbacks */
@@ -423,7 +545,7 @@ void MESH_OT_sticky_add(wmOperatorType *ot)
        ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 }
 
-static int sticky_remove_exec(bContext *C, wmOperator *op)
+static int sticky_remove_exec(bContext *C, wmOperator *UNUSED(op))
 {
        Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
        Mesh *me= ob->data;
@@ -434,7 +556,7 @@ static int sticky_remove_exec(bContext *C, wmOperator *op)
        CustomData_free_layer_active(&me->vdata, CD_MSTICKY, me->totvert);
        me->msticky= NULL;
 
-       DAG_id_flush_update(&me->id, OB_RECALC_DATA);
+       DAG_id_tag_update(&me->id, 0);
        WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);
 
        return OPERATOR_FINISHED;
@@ -444,7 +566,7 @@ void MESH_OT_sticky_remove(wmOperatorType *ot)
 {
        /* identifiers */
        ot->name= "Remove Sticky";
-       ot->description= "Remove sticky UV texture layer.";
+       ot->description= "Remove sticky UV texture layer";
        ot->idname= "MESH_OT_sticky_remove";
        
        /* api callbacks */
@@ -457,81 +579,14 @@ void MESH_OT_sticky_remove(wmOperatorType *ot)
 
 /************************** Add Geometry Layers *************************/
 
-static void mesh_calc_edges(Mesh *mesh, int update)
-{
-       CustomData edata;
-       EdgeHashIterator *ehi;
-       MFace *mf = mesh->mface;
-       MEdge *med, *med_orig;
-       EdgeHash *eh = BLI_edgehash_new();
-       int i, *index, totedge, totface = mesh->totface;
-
-       if(mesh->totedge==0)
-               update= 0;
-
-       if(update) {
-               /* assume existing edges are valid
-                * useful when adding more faces and generating edges from them */
-               med= mesh->medge;
-               for(i= 0; i<mesh->totedge; i++, med++)
-                       BLI_edgehash_insert(eh, med->v1, med->v2, med);
-       }
-
-       for (i = 0; i < totface; i++, mf++) {
-               if (!BLI_edgehash_haskey(eh, mf->v1, mf->v2))
-                       BLI_edgehash_insert(eh, mf->v1, mf->v2, NULL);
-               if (!BLI_edgehash_haskey(eh, mf->v2, mf->v3))
-                       BLI_edgehash_insert(eh, mf->v2, mf->v3, NULL);
-               
-               if (mf->v4) {
-                       if (!BLI_edgehash_haskey(eh, mf->v3, mf->v4))
-                               BLI_edgehash_insert(eh, mf->v3, mf->v4, NULL);
-                       if (!BLI_edgehash_haskey(eh, mf->v4, mf->v1))
-                               BLI_edgehash_insert(eh, mf->v4, mf->v1, NULL);
-               } else {
-                       if (!BLI_edgehash_haskey(eh, mf->v3, mf->v1))
-                               BLI_edgehash_insert(eh, mf->v3, mf->v1, NULL);
-               }
-       }
-
-       totedge = BLI_edgehash_size(eh);
-
-       /* write new edges into a temporary CustomData */
-       memset(&edata, 0, sizeof(edata));
-       CustomData_add_layer(&edata, CD_MEDGE, CD_CALLOC, NULL, totedge);
-
-       ehi = BLI_edgehashIterator_new(eh);
-       med = CustomData_get_layer(&edata, CD_MEDGE);
-       for(i = 0; !BLI_edgehashIterator_isDone(ehi);
-           BLI_edgehashIterator_step(ehi), ++i, ++med, ++index) {
-
-               if(update && (med_orig=BLI_edgehashIterator_getValue(ehi))) {
-                       *med= *med_orig; /* copy from the original */
-               } else {
-                       BLI_edgehashIterator_getKey(ehi, (int*)&med->v1, (int*)&med->v2);
-                       med->flag = ME_EDGEDRAW|ME_EDGERENDER;
-               }
-       }
-       BLI_edgehashIterator_free(ehi);
-
-       /* free old CustomData and assign new one */
-       CustomData_free(&mesh->edata, mesh->totedge);
-       mesh->edata = edata;
-       mesh->totedge = totedge;
-
-       mesh->medge = CustomData_get_layer(&mesh->edata, CD_MEDGE);
-
-       BLI_edgehash_free(eh, NULL);
-}
-
 void ED_mesh_update(Mesh *mesh, bContext *C, int calc_edges)
 {
        if(calc_edges || (mesh->totface && mesh->totedge == 0))
-               mesh_calc_edges(mesh, calc_edges);
+               BKE_mesh_calc_edges(mesh, calc_edges);
 
        mesh_calc_normals(mesh->mvert, mesh->totvert, mesh->mface, mesh->totface, NULL);
 
-       DAG_id_flush_update(&mesh->id, OB_RECALC_DATA);
+       DAG_id_tag_update(&mesh->id, 0);
        WM_event_add_notifier(C, NC_GEOM|ND_DATA, mesh);
 }
 
@@ -631,14 +686,15 @@ static void mesh_add_faces(Mesh *mesh, int len)
        /* set default flags */
        mface= &mesh->mface[mesh->totface];
        for(i=0; i<len; i++, mface++)
-               mface->flag= SELECT;
+               mface->flag= ME_FACE_SEL;
 
        mesh->totface= totface;
 }
 
+/*
 void ED_mesh_geometry_add(Mesh *mesh, ReportList *reports, int verts, int edges, int faces)
 {
-       if(mesh->edit_mesh) {
+       if(mesh->edit_btmesh) {
                BKE_report(reports, RPT_ERROR, "Can't add geometry in edit mode.");
                return;
        }
@@ -650,32 +706,39 @@ void ED_mesh_geometry_add(Mesh *mesh, ReportList *reports, int verts, int edges,
        if(faces)
                mesh_add_faces(mesh, faces);
 }
+*/
 
-void ED_mesh_calc_normals(Mesh *me)
+void ED_mesh_faces_add(Mesh *mesh, ReportList *reports, int count)
 {
-       mesh_calc_normals(me->mvert, me->totvert, me->mface, me->totface, NULL);
+       if(mesh->edit_btmesh) {
+               BKE_report(reports, RPT_ERROR, "Can't add faces in edit mode.");
+               return;
+       }
+       mesh_add_faces(mesh, count);
 }
 
-void ED_mesh_material_add(Mesh *me, Material *ma)
+void ED_mesh_edges_add(Mesh *mesh, ReportList *reports, int count)
 {
-       int i;
-       int totcol = me->totcol + 1;
-       Material **mat;
-
-       /* don't add if mesh already has it */
-       for(i = 0; i < me->totcol; i++)
-               if(me->mat[i] == ma)
+       if(mesh->edit_btmesh) {
+               BKE_report(reports, RPT_ERROR, "Can't add edges in edit mode.");
                        return;
+       }
 
-       mat= MEM_callocN(sizeof(void*)*totcol, "newmatar");
+       mesh_add_edges(mesh, count);
+}
 
-       if(me->totcol) memcpy(mat, me->mat, sizeof(void*) * me->totcol);
-       if(me->mat) MEM_freeN(me->mat);
+void ED_mesh_vertices_add(Mesh *mesh, ReportList *reports, int count)
+{
+       if(mesh->edit_btmesh) {
+               BKE_report(reports, RPT_ERROR, "Can't add vertices in edit mode.");
+               return;
+       }
 
-       me->mat = mat;
-       me->mat[me->totcol++] = ma;
-       ma->id.us++;
+       mesh_add_verts(mesh, count);
+}
 
-       test_object_materials((ID*)me);
+void ED_mesh_calc_normals(Mesh *me)
+{
+       mesh_calc_normals(me->mvert, me->totvert, me->mface, me->totface, NULL);
 }