/* makes Mesh out of editmesh */
void load_editMesh(Scene *scene, Object *obedit)
{
Mesh *me= obedit->data;
MVert *mvert, *oldverts;
MEdge *medge;
MFace *mface;
MSelect *mselect;
EditMesh *em= me->edit_mesh;
EditVert *eve;
EditFace *efa, *efa_act;
EditEdge *eed;
EditSelection *ese;
float *fp, *newkey, *oldkey;
int i, a, ototvert;
/* this one also tests of edges are not in faces: */
/* eed->f2==0: not in face, f2==1: draw it */
/* eed->f1 : flag for dynaface (cylindertest, old engine) */
/* eve->f1 : flag for dynaface (sphere test, old engine) */
/* eve->f2 : being used in vertexnormals */
edge_drawflags(me, em);
EM_stats_update(em);
/* new Vertex block */
if(em->totvert==0) mvert= NULL;
else mvert= MEM_callocN(em->totvert*sizeof(MVert), "loadeditMesh vert");
/* new Edge block */
if(em->totedge==0) medge= NULL;
else medge= MEM_callocN(em->totedge*sizeof(MEdge), "loadeditMesh edge");
/* new Face block */
if(em->totface==0) mface= NULL;
else mface= MEM_callocN(em->totface*sizeof(MFace), "loadeditMesh face");
/* lets save the old verts just in case we are actually working on
* a key ... we now do processing of the keys at the end */
oldverts= me->mvert;
ototvert= me->totvert;
/* don't free this yet */
CustomData_set_layer(&me->vdata, CD_MVERT, NULL);
/* free custom data */
CustomData_free(&me->vdata, me->totvert);
CustomData_free(&me->edata, me->totedge);
CustomData_free(&me->fdata, me->totface);
/* add new custom data */
me->totvert= em->totvert;
me->totedge= em->totedge;
me->totface= em->totface;
CustomData_copy(&em->vdata, &me->vdata, CD_MASK_MESH, CD_CALLOC, me->totvert);
CustomData_copy(&em->edata, &me->edata, CD_MASK_MESH, CD_CALLOC, me->totedge);
CustomData_copy(&em->fdata, &me->fdata, CD_MASK_MESH, CD_CALLOC, me->totface);
CustomData_add_layer(&me->vdata, CD_MVERT, CD_ASSIGN, mvert, me->totvert);
CustomData_add_layer(&me->edata, CD_MEDGE, CD_ASSIGN, medge, me->totedge);
CustomData_add_layer(&me->fdata, CD_MFACE, CD_ASSIGN, mface, me->totface);
mesh_update_customdata_pointers(me);
/* the vertices, use ->tmp.l as counter */
eve= em->verts.first;
a= 0;
while(eve) {
VECCOPY(mvert->co, eve->co);
/* vertex normal */
normal_float_to_short_v3(mvert->no, eve->no);
/* note: it used to remove me->dvert when it was not in use, cancelled
that... annoying when you have a fresh vgroup */
CustomData_from_em_block(&em->vdata, &me->vdata, eve->data, a);
eve->tmp.l = a++; /* counter */
mvert->flag= 0;
mvert->flag |= (eve->f & SELECT);
if (eve->h) mvert->flag |= ME_HIDE;
mvert->bweight= (char)(255.0f*eve->bweight);
eve= eve->next;
mvert++;
}
/* the edges */
a= 0;
eed= em->edges.first;
while(eed) {
medge->v1= (unsigned int) eed->v1->tmp.l;
medge->v2= (unsigned int) eed->v2->tmp.l;
medge->flag= (eed->f & SELECT) | ME_EDGERENDER;
if(eed->f2<2) medge->flag |= ME_EDGEDRAW;
if(eed->f2==0) medge->flag |= ME_LOOSEEDGE;
if(eed->sharp) medge->flag |= ME_SHARP;
if(eed->seam) medge->flag |= ME_SEAM;
if(eed->h & EM_FGON) medge->flag |= ME_FGON; // different defines yes
if(eed->h & 1) medge->flag |= ME_HIDE;
medge->crease= (char)(255.0f*eed->crease);
medge->bweight= (char)(255.0f*eed->bweight);
CustomData_from_em_block(&em->edata, &me->edata, eed->data, a);
eed->tmp.l = a++;
medge++;
eed= eed->next;
}
/* the faces */
a = 0;
efa= em->faces.first;
efa_act= EM_get_actFace(em, 0);
i = 0;
me->act_face = -1;
while(efa) {
mface= &((MFace *) me->mface)[i];
mface->v1= (unsigned int) efa->v1->tmp.l;
mface->v2= (unsigned int) efa->v2->tmp.l;
mface->v3= (unsigned int) efa->v3->tmp.l;
if (efa->v4) mface->v4 = (unsigned int) efa->v4->tmp.l;
mface->mat_nr= efa->mat_nr;
mface->flag= efa->flag;
/* bit 0 of flag is already taken for smooth... */
if(efa->h) {
mface->flag |= ME_HIDE;
mface->flag &= ~ME_FACE_SEL;
} else {
if(efa->f & 1) mface->flag |= ME_FACE_SEL;
else mface->flag &= ~ME_FACE_SEL;
}
/* watch: efa->e1->f2==0 means loose edge */
if(efa->e1->f2==1) {
efa->e1->f2= 2;
}
if(efa->e2->f2==1) {
efa->e2->f2= 2;
}
if(efa->e3->f2==1) {
efa->e3->f2= 2;
}
if(efa->e4 && efa->e4->f2==1) {
efa->e4->f2= 2;
}
CustomData_from_em_block(&em->fdata, &me->fdata, efa->data, i);
/* no index '0' at location 3 or 4 */
test_index_face(mface, &me->fdata, i, efa->v4?4:3);
if (efa_act == efa)
me->act_face = a;
efa->tmp.l = a++;
i++;
efa= efa->next;
}
/* patch hook indices and vertex parents */
{
Object *ob;
ModifierData *md;
EditVert **vertMap = NULL;
int j;
for (ob=G.main->object.first; ob; ob=ob->id.next) {
if (ob->parent==obedit && ELEM(ob->partype, PARVERT1,PARVERT3)) {
/* duplicate code from below, make it function later...? */
if (!vertMap) {
vertMap = MEM_callocN(sizeof(*vertMap)*ototvert, "vertMap");
for (eve=em->verts.first; eve; eve=eve->next) {
if (eve->keyindex!=-1)
vertMap[eve->keyindex] = eve;
}
}
if(ob->par1 < ototvert) {
eve = vertMap[ob->par1];
if(eve) ob->par1= eve->tmp.l;
}
if(ob->par2 < ototvert) {
eve = vertMap[ob->par2];
if(eve) ob->par2= eve->tmp.l;
}
if(ob->par3 < ototvert) {
eve = vertMap[ob->par3];
if(eve) ob->par3= eve->tmp.l;
}
}
if (ob->data==me) {
for (md=ob->modifiers.first; md; md=md->next) {
if (md->type==eModifierType_Hook) {
HookModifierData *hmd = (HookModifierData*) md;
if (!vertMap) {
vertMap = MEM_callocN(sizeof(*vertMap)*ototvert, "vertMap");
for (eve=em->verts.first; eve; eve=eve->next) {
if (eve->keyindex!=-1)
vertMap[eve->keyindex] = eve;
}
}
for (i=j=0; i<hmd->totindex; i++) {
if(hmd->indexar[i] < ototvert) {
eve = vertMap[hmd->indexar[i]];
if (eve) {
hmd->indexar[j++] = eve->tmp.l;
}
}
else j++;
}
hmd->totindex = j;
}
}
}
}
if (vertMap) MEM_freeN(vertMap);
}
/* are there keys? */
if(me->key) {
KeyBlock *currkey;
KeyBlock *actkey= BLI_findlink(&me->key->block, em->shapenr-1);
float (*ofs)[3] = NULL;
/* editing the base key should update others */
if(me->key->type==KEY_RELATIVE && oldverts) {
int act_is_basis = 0;
/* find if this key is a basis for any others */
for(currkey = me->key->block.first; currkey; currkey= currkey->next) {
if(em->shapenr-1 == currkey->relative) {
act_is_basis = 1;
break;
}
}
if(act_is_basis) { /* active key is a base */
float (*fp)[3]= actkey->data;
i=0;
ofs= MEM_callocN(sizeof(float) * 3 * em->totvert, "currkey->data");
eve= em->verts.first;
mvert = me->mvert;
while(eve) {
if(eve->keyindex>=0) {
sub_v3_v3v3(ofs[i], mvert->co, fp[eve->keyindex]);
}
eve= eve->next;
i++;
mvert++;
}
}
}
/* Lets reorder the key data so that things line up roughly
* with the way things were before editmode */
currkey = me->key->block.first;
while(currkey) {
int apply_offset = (ofs && (currkey != actkey) && (em->shapenr-1 == currkey->relative));
fp= newkey= MEM_callocN(me->key->elemsize*em->totvert, "currkey->data");
oldkey = currkey->data;
eve= em->verts.first;
i = 0;
mvert = me->mvert;
while(eve) {
if (eve->keyindex >= 0 && eve->keyindex < currkey->totelem) { // valid old vertex
if(currkey == actkey) {
if(actkey == me->key->refkey) {
VECCOPY(fp, mvert->co);
}
else {
VECCOPY(fp, mvert->co);
if(oldverts) {
VECCOPY(mvert->co, oldverts[eve->keyindex].co);
}
}
}
else {
if(oldkey) {
VECCOPY(fp, oldkey + 3 * eve->keyindex);
}
}
}
else {
VECCOPY(fp, mvert->co);
}
/* propagate edited basis offsets to other shapes */
if(apply_offset) {
VECADD(fp, fp, ofs[i]);
}
fp+= 3;
++i;
++mvert;
eve= eve->next;
}
currkey->totelem= em->totvert;
if(currkey->data) MEM_freeN(currkey->data);
currkey->data = newkey;
currkey= currkey->next;
}
if(ofs) MEM_freeN(ofs);
}
if(oldverts) MEM_freeN(oldverts);
i = 0;
for(ese=em->selected.first; ese; ese=ese->next) i++;
me->totselect = i;
if(i==0) mselect= NULL;
else mselect= MEM_callocN(i*sizeof(MSelect), "loadeditMesh selections");
if(me->mselect) MEM_freeN(me->mselect);
me->mselect= mselect;
for(ese=em->selected.first; ese; ese=ese->next){
mselect->type = ese->type;
if(ese->type == EDITVERT) mselect->index = ((EditVert*)ese->data)->tmp.l;
else if(ese->type == EDITEDGE) mselect->index = ((EditEdge*)ese->data)->tmp.l;
else if(ese->type == EDITFACE) mselect->index = ((EditFace*)ese->data)->tmp.l;
mselect++;
}
/* to be sure: clear ->tmp.l pointers */
eve= em->verts.first;
while(eve) {
eve->tmp.l = 0;
eve= eve->next;
}
eed= em->edges.first;
while(eed) {
eed->tmp.l = 0;
eed= eed->next;
}
efa= em->faces.first;
while(efa) {
efa->tmp.l = 0;
efa= efa->next;
}
/* remake softbody of all users */
if(me->id.us>1) {
Base *base;
for(base= scene->base.first; base; base= base->next)
if(base->object->data==me)
base->object->recalc |= OB_RECALC_DATA;
}
mesh_calc_normals(me->mvert, me->totvert, me->mface, me->totface, NULL);
/* topology could be changed, ensure mdisps are ok */
multires_topology_changed(scene, obedit);
}
static void make_prim(Object *obedit, int type, float mat[4][4], int tot, int seg,
int subdiv, float dia, float depth, int ext, int fill)
{
/*
* type - for the type of shape
* dia - the radius for cone,sphere cylinder etc.
* depth -
* ext - extrude
* fill - end capping, and option to fill in circle
* cent[3] - center of the data.
* */
EditMesh *em= BKE_mesh_get_editmesh(((Mesh *)obedit->data));
EditVert *eve, *v1=NULL, *v2, *v3, *v4=NULL, *vtop, *vdown;
float phi, phid, vec[3];
float q[4], cmat[3][3], nor[3]= {0.0, 0.0, 0.0};
short a, b;
EM_clear_flag_all(em, SELECT);
phid= 2.0f*(float)M_PI/tot;
phi= .25f*(float)M_PI;
switch(type) {
case PRIM_GRID: /* grid */
/* clear flags */
eve= em->verts.first;
while(eve) {
eve->f= 0;
eve= eve->next;
}
/* one segment first: the X axis */
phi = (2*dia)/(float)(tot-1);
phid = (2*dia)/(float)(seg-1);
for(a=tot-1;a>=0;a--) {
vec[0] = (phi*a) - dia;
vec[1]= - dia;
vec[2]= 0.0f;
eve= addvertlist(em, vec, NULL);
eve->f= 1+2+4;
if(a < tot -1) addedgelist(em, eve->prev, eve, NULL);
}
/* extrude and translate */
vec[0]= vec[2]= 0.0;
vec[1]= phid;
for(a=0;a<seg-1;a++) {
extrudeflag_vert(obedit, em, 2, nor, 0); // nor unused
translateflag(em, 2, vec);
}
/* and now do imat */
eve= em->verts.first;
while(eve) {
if(eve->f & SELECT) {
mul_m4_v3(mat,eve->co);
}
eve= eve->next;
}
recalc_editnormals(em);
break;
case PRIM_UVSPHERE: /* UVsphere */
/* clear all flags */
eve= em->verts.first;
while(eve) {
eve->f= 0;
eve= eve->next;
}
/* one segment first */
phi= 0;
phid/=2;
for(a=0; a<=tot; a++) {
vec[0]= dia*sinf(phi);
vec[1]= 0.0;
vec[2]= dia*cosf(phi);
eve= addvertlist(em, vec, NULL);
eve->f= 1+2+4;
if(a==0) v1= eve;
else addedgelist(em, eve, eve->prev, NULL);
phi+= phid;
}
/* extrude and rotate */
phi= M_PI/seg;
q[0]= cos(phi);
q[3]= sin(phi);
q[1]=q[2]= 0;
quat_to_mat3( cmat,q);
for(a=0; a<seg; a++) {
extrudeflag_vert(obedit, em, 2, nor, 0); // nor unused
rotateflag(em, 2, v1->co, cmat);
}
removedoublesflag(em, 4, 0, 0.0001);
/* and now do imat */
eve= em->verts.first;
while(eve) {
if(eve->f & SELECT) {
mul_m4_v3(mat,eve->co);
}
eve= eve->next;
}
recalc_editnormals(em);
break;
case PRIM_ICOSPHERE: /* Icosphere */
{
EditVert *eva[12];
EditEdge *eed;
/* clear all flags */
eve= em->verts.first;
while(eve) {
eve->f= 0;
eve= eve->next;
}
dia/=200;
for(a=0;a<12;a++) {
vec[0]= dia*icovert[a][0];
vec[1]= dia*icovert[a][1];
vec[2]= dia*icovert[a][2];
eva[a]= addvertlist(em, vec, NULL);
eva[a]->f= 1+2;
}
for(a=0;a<20;a++) {
EditFace *evtemp;
v1= eva[ icoface[a][0] ];
v2= eva[ icoface[a][1] ];
v3= eva[ icoface[a][2] ];
evtemp = addfacelist(em, v1, v2, v3, 0, NULL, NULL);
evtemp->e1->f = 1+2;
evtemp->e2->f = 1+2;
evtemp->e3->f = 1+2;
}
dia*=200;
for(a=1; a<subdiv; a++) esubdivideflag(obedit, em, 2, dia, 0, B_SPHERE,1, SUBDIV_CORNER_PATH, 0);
/* and now do imat */
eve= em->verts.first;
while(eve) {
if(eve->f & 2) {
mul_m4_v3(mat,eve->co);
}
eve= eve->next;
}
// Clear the flag 2 from the edges
for(eed=em->edges.first;eed;eed=eed->next){
if(eed->f & 2){
eed->f &= !2;
}
}
}
break;
case PRIM_MONKEY: /* Monkey */
{
//extern int monkeyo, monkeynv, monkeynf;
//extern signed char monkeyf[][4];
//extern signed char monkeyv[][3];
EditVert **tv= MEM_mallocN(sizeof(*tv)*monkeynv*2, "tv");
int i;
for (i=0; i<monkeynv; i++) {
float v[3];
v[0]= (monkeyv[i][0]+127)/128.0, v[1]= monkeyv[i][1]/128.0, v[2]= monkeyv[i][2]/128.0;
tv[i]= addvertlist(em, v, NULL);
tv[i]->f |= SELECT;
tv[monkeynv+i]= (fabs(v[0]= -v[0])<0.001)?tv[i]:addvertlist(em, v, NULL);
tv[monkeynv+i]->f |= SELECT;
}
for (i=0; i<monkeynf; i++) {
addfacelist(em, tv[monkeyf[i][0]+i-monkeyo], tv[monkeyf[i][1]+i-monkeyo], tv[monkeyf[i][2]+i-monkeyo], (monkeyf[i][3]!=monkeyf[i][2])?tv[monkeyf[i][3]+i-monkeyo]:NULL, NULL, NULL);
addfacelist(em, tv[monkeynv+monkeyf[i][2]+i-monkeyo], tv[monkeynv+monkeyf[i][1]+i-monkeyo], tv[monkeynv+monkeyf[i][0]+i-monkeyo], (monkeyf[i][3]!=monkeyf[i][2])?tv[monkeynv+monkeyf[i][3]+i-monkeyo]:NULL, NULL, NULL);
}
MEM_freeN(tv);
/* and now do imat */
for(eve= em->verts.first; eve; eve= eve->next) {
if(eve->f & SELECT) {
mul_m4_v3(mat,eve->co);
}
}
recalc_editnormals(em);
}
break;
default: /* all types except grid, sphere... */
if(type==PRIM_CONE);
else if(ext==0)
depth= 0.0f;
/* first vertex at 0° for circular objects */
if( ELEM3(type, PRIM_CIRCLE,PRIM_CYLINDER,PRIM_CONE) )
phi = 0.0f;
vtop= vdown= v1= v2= 0;
for(b=0; b<=ext; b++) {
for(a=0; a<tot; a++) {
vec[0]= dia*sinf(phi);
vec[1]= dia*cosf(phi);
vec[2]= b?depth:-depth;
mul_m4_v3(mat, vec);
eve= addvertlist(em, vec, NULL);
eve->f= SELECT;
if(a==0) {
if(b==0) v1= eve;
else v2= eve;
}
phi+=phid;
}
}
/* center vertices */
/* type PRIM_CONE can only have 1 one side filled
* if the cone has no capping, dont add vtop */
if(type == PRIM_CONE || (fill && !ELEM(type, PRIM_PLANE, PRIM_CUBE))) {
vec[0]= vec[1]= 0.0f;
vec[2]= type==PRIM_CONE ? depth : -depth;
mul_m4_v3(mat, vec);
vdown= addvertlist(em, vec, NULL);
if((ext || type==PRIM_CONE) && fill) {
vec[0]= vec[1]= 0.0f;
vec[2]= type==PRIM_CONE ? -depth : depth;
mul_m4_v3(mat,vec);
vtop= addvertlist(em, vec, NULL);
}
} else {
vdown= v1;
vtop= v2;
}
if(vtop) vtop->f= SELECT;
if(vdown) vdown->f= SELECT;
/* top and bottom face */
if(fill || type==PRIM_CONE) {
if(tot==4 && ELEM(type, PRIM_PLANE, PRIM_CUBE)) {
v3= v1->next->next;
if(ext) v4= v2->next->next;
addfacelist(em, v3, v1->next, v1, v3->next, NULL, NULL);
if(ext) addfacelist(em, v2, v2->next, v4, v4->next, NULL, NULL);
}
else {
v3= v1;
v4= v2;
for(a=1; a<tot; a++) {
addfacelist(em, vdown, v3, v3->next, 0, NULL, NULL);
v3= v3->next;
if(ext && fill) {
addfacelist(em, vtop, v4, v4->next, 0, NULL, NULL);
v4= v4->next;
}
}
if(!ELEM(type, PRIM_PLANE, PRIM_CUBE)) {
addfacelist(em, vdown, v3, v1, 0, NULL, NULL);
if(ext) addfacelist(em, vtop, v4, v2, 0, NULL, NULL);
}
}
}
else if(type==PRIM_CIRCLE) { /* we need edges for a circle */
v3= v1;
for(a=1;a<tot;a++) {
addedgelist(em, v3, v3->next, NULL);
v3= v3->next;
}
addedgelist(em, v3, v1, NULL);
}
/* side faces */
if(ext) {
v3= v1;
v4= v2;
for(a=1; a<tot; a++) {
addfacelist(em, v3, v3->next, v4->next, v4, NULL, NULL);
v3= v3->next;
v4= v4->next;
}
addfacelist(em, v3, v1, v2, v4, NULL, NULL);
}
else if(fill && type==PRIM_CONE) {
/* add the bottom flat area of the cone
* if capping is disabled dont bother */
v3= v1;
for(a=1; a<tot; a++) {
addfacelist(em, vtop, v3->next, v3, 0, NULL, NULL);
v3= v3->next;
}
addfacelist(em, vtop, v1, v3, 0, NULL, NULL);
}
}
EM_stats_update(em);
/* simple selection flush OK, based on fact it's a single model */
EM_select_flush(em); /* flushes vertex -> edge -> face selection */
if(!ELEM5(type, PRIM_GRID, PRIM_PLANE, PRIM_ICOSPHERE, PRIM_UVSPHERE, PRIM_MONKEY))
EM_recalc_normal_direction(em, FALSE, TRUE); /* otherwise monkey has eyes in wrong direction */
BKE_mesh_end_editmesh(obedit->data, em);
}
/* return 1: success */
static int mesh_separate_selected(wmOperator *op, Main *bmain, Scene *scene, Base *editbase)
{
EditMesh *em, *emnew;
EditVert *eve, *v1;
EditEdge *eed, *e1;
EditFace *efa, *f1;
Object *obedit;
Mesh *me, *menew;
Base *basenew;
if(editbase==NULL) return 0;
obedit= editbase->object;
me= obedit->data;
em= BKE_mesh_get_editmesh(me);
if(me->key) {
BKE_report(op->reports, RPT_WARNING, "Can't separate mesh with shape keys");
BKE_mesh_end_editmesh(me, em);
return 0;
}
if(em->selected.first)
BLI_freelistN(&(em->selected)); /* clear the selection order */
EM_selectmode_set(em); // enforce full consistent selection flags
EM_stats_update(em);
if(em->totvertsel==0) {
BKE_mesh_end_editmesh(me, em);
return 0;
}
/* we are going to work as follows:
* 1. add a linked duplicate object: this will be the new one, we remember old pointer
* 2. give new object empty mesh and put in editmode
* 3: do a split if needed on current editmesh.
* 4. copy over: all NOT selected verts, edges, faces
* 5. call load_editMesh() on the new object
*/
/* 1 */
basenew= ED_object_add_duplicate(bmain, scene, editbase, 0); /* 0 = fully linked */
ED_base_object_select(basenew, BA_DESELECT);
/* 2 */
basenew->object->data= menew= add_mesh(me->id.name+2); /* empty */
assign_matarar(basenew->object, give_matarar(obedit), *give_totcolp(obedit)); /* new in 2.5 */
me->id.us--;
make_editMesh(scene, basenew->object);
emnew= menew->edit_mesh;
CustomData_copy(&em->vdata, &emnew->vdata, CD_MASK_EDITMESH, CD_DEFAULT, 0);
CustomData_copy(&em->edata, &emnew->edata, CD_MASK_EDITMESH, CD_DEFAULT, 0);
CustomData_copy(&em->fdata, &emnew->fdata, CD_MASK_EDITMESH, CD_DEFAULT, 0);
/* 3 */
/* SPLIT: first make duplicate */
adduplicateflag(em, SELECT);
/* SPLIT: old faces have 3x flag 128 set, delete these ones */
delfaceflag(em, 128);
/* since we do tricky things with verts/edges/faces, this makes sure all is selected coherent */
EM_selectmode_set(em);
/* 4 */
/* move over: everything that is selected */
for(eve= em->verts.first; eve; eve= v1) {
v1= eve->next;
if(eve->f & SELECT) {
BLI_remlink(&em->verts, eve);
BLI_addtail(&emnew->verts, eve);
}
}
for(eed= em->edges.first; eed; eed= e1) {
e1= eed->next;
if(eed->f & SELECT) {
BLI_remlink(&em->edges, eed);
BLI_addtail(&emnew->edges, eed);
}
}
for(efa= em->faces.first; efa; efa= f1) {
f1= efa->next;
if (efa == em->act_face && (efa->f & SELECT)) {
EM_set_actFace(em, NULL);
}
if(efa->f & SELECT) {
BLI_remlink(&em->faces, efa);
BLI_addtail(&emnew->faces, efa);
}
}
/* 5 */
load_editMesh(scene, basenew->object);
free_editMesh(emnew);
MEM_freeN(menew->edit_mesh);
menew->edit_mesh= NULL;
/* copy settings */
menew->texflag= me->texflag;
menew->drawflag= me->drawflag;
menew->flag= me->flag;
menew->editflag= me->editflag;
menew->smoothresh= me->smoothresh;
/* hashedges are invalid now, make new! */
editMesh_set_hash(em);
DAG_id_tag_update(&obedit->id, OB_RECALC_DATA);
DAG_id_tag_update(&basenew->object->id, OB_RECALC_DATA);
BKE_mesh_end_editmesh(me, em);
return 1;
}
