forked from bartvdbraak/blender
bmesh:
- moved mesh conversion functions into their own file. bmesh py api: - can now create a new empty bmesh without first creating mesh data. - added function to copy bmesh data back to a mesh. - bmesh.from_mesh() can now get a mesh which isnt in editmode.
This commit is contained in:
parent
83a5c943af
commit
e09ab8883c
@ -65,6 +65,8 @@ set(SRC
|
||||
intern/bmesh_marking.h
|
||||
intern/bmesh_mesh.c
|
||||
intern/bmesh_mesh.h
|
||||
intern/bmesh_mesh_conv.c
|
||||
intern/bmesh_mesh_conv.h
|
||||
intern/bmesh_mods.c
|
||||
intern/bmesh_mods.h
|
||||
intern/bmesh_opdefines.c
|
||||
|
@ -286,6 +286,7 @@ BM_INLINE void _bm_elem_index_set(BMHeader *ele, const int index);
|
||||
#include "intern/bmesh_iterators.h"
|
||||
#include "intern/bmesh_marking.h"
|
||||
#include "intern/bmesh_mesh.h"
|
||||
#include "intern/bmesh_mesh_conv.h"
|
||||
#include "intern/bmesh_mods.h"
|
||||
#include "intern/bmesh_operators.h"
|
||||
#include "intern/bmesh_polygon.h"
|
||||
|
901
source/blender/bmesh/intern/bmesh_mesh_conv.c
Normal file
901
source/blender/bmesh/intern/bmesh_mesh_conv.c
Normal file
@ -0,0 +1,901 @@
|
||||
/*
|
||||
* ***** BEGIN GPL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* Contributor(s): Geoffrey Bantle.
|
||||
*
|
||||
* ***** END GPL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/** \file blender/bmesh/intern/bmesh_mesh_conv.c
|
||||
* \ingroup bmesh
|
||||
*
|
||||
* BM mesh conversion functions.
|
||||
*/
|
||||
|
||||
|
||||
#include "bmesh.h"
|
||||
#include "intern/bmesh_private.h" /* for element checking */
|
||||
|
||||
#include "DNA_mesh_types.h"
|
||||
#include "DNA_meshdata_types.h"
|
||||
#include "DNA_object_types.h"
|
||||
#include "DNA_modifier_types.h"
|
||||
#include "DNA_key_types.h"
|
||||
|
||||
#include "BLI_listbase.h"
|
||||
#include "BLI_array.h"
|
||||
#include "BLI_math_vector.h"
|
||||
|
||||
#include "BKE_mesh.h"
|
||||
#include "BKE_customdata.h"
|
||||
|
||||
#include "BKE_global.h" /* ugh - for looping over all objects */
|
||||
#include "BKE_main.h"
|
||||
|
||||
#include "MEM_guardedalloc.h"
|
||||
|
||||
/* Mesh -> BMesh */
|
||||
void BM_mesh_to_bmesh(BMesh *bm, Mesh *me, int set_key, int act_key_nr)
|
||||
{
|
||||
MVert *mvert;
|
||||
BLI_array_declare(verts);
|
||||
MEdge *medge;
|
||||
MLoop *ml;
|
||||
MPoly *mpoly;
|
||||
KeyBlock *actkey, *block;
|
||||
BMVert *v, **vt = NULL, **verts = NULL;
|
||||
BMEdge *e, **fedges = NULL, **et = NULL;
|
||||
BMFace *f;
|
||||
BMLoop *l;
|
||||
BLI_array_declare(fedges);
|
||||
float (*keyco)[3] = NULL;
|
||||
int *keyi;
|
||||
int totuv, i, j;
|
||||
|
||||
if (!me || !me->totvert) {
|
||||
return; /* sanity check */
|
||||
}
|
||||
|
||||
vt = MEM_mallocN(sizeof(void **) * me->totvert, "mesh to bmesh vtable");
|
||||
|
||||
CustomData_copy(&me->vdata, &bm->vdata, CD_MASK_BMESH, CD_CALLOC, 0);
|
||||
CustomData_copy(&me->edata, &bm->edata, CD_MASK_BMESH, CD_CALLOC, 0);
|
||||
CustomData_copy(&me->ldata, &bm->ldata, CD_MASK_BMESH, CD_CALLOC, 0);
|
||||
CustomData_copy(&me->pdata, &bm->pdata, CD_MASK_BMESH, CD_CALLOC, 0);
|
||||
|
||||
/* make sure uv layer names are consisten */
|
||||
totuv = CustomData_number_of_layers(&bm->pdata, CD_MTEXPOLY);
|
||||
for (i = 0; i < totuv; i++) {
|
||||
int li = CustomData_get_layer_index_n(&bm->pdata, CD_MTEXPOLY, i);
|
||||
CustomData_set_layer_name(&bm->ldata, CD_MLOOPUV, i, bm->pdata.layers[li].name);
|
||||
}
|
||||
|
||||
if (!CustomData_has_layer(&bm->edata, CD_CREASE))
|
||||
CustomData_add_layer(&bm->edata, CD_CREASE, CD_ASSIGN, NULL, 0);
|
||||
|
||||
if (!CustomData_has_layer(&bm->edata, CD_BWEIGHT))
|
||||
CustomData_add_layer(&bm->edata, CD_BWEIGHT, CD_ASSIGN, NULL, 0);
|
||||
|
||||
if (!CustomData_has_layer(&bm->vdata, CD_BWEIGHT))
|
||||
CustomData_add_layer(&bm->vdata, CD_BWEIGHT, CD_ASSIGN, NULL, 0);
|
||||
|
||||
if ((act_key_nr != 0) && (me->key != NULL)) {
|
||||
actkey = BLI_findlink(&me->key->block, act_key_nr - 1);
|
||||
}
|
||||
else {
|
||||
actkey = NULL;
|
||||
}
|
||||
|
||||
if (actkey && actkey->totelem == me->totvert) {
|
||||
CustomData_add_layer(&bm->vdata, CD_SHAPE_KEYINDEX, CD_ASSIGN, NULL, 0);
|
||||
|
||||
/* check if we need to generate unique ids for the shapekeys.
|
||||
* this also exists in the file reading code, but is here for
|
||||
* a sanity check */
|
||||
if (!me->key->uidgen) {
|
||||
fprintf(stderr,
|
||||
"%s had to generate shape key uid's in a situation we shouldn't need to! "
|
||||
"(bmesh internal error)\n",
|
||||
__func__);
|
||||
|
||||
me->key->uidgen = 1;
|
||||
for (block = me->key->block.first; block; block = block->next) {
|
||||
block->uid = me->key->uidgen++;
|
||||
}
|
||||
}
|
||||
|
||||
keyco = actkey->data;
|
||||
bm->shapenr = act_key_nr;
|
||||
for (i = 0, block = me->key->block.first; block; block = block->next, i++) {
|
||||
CustomData_add_layer_named(&bm->vdata, CD_SHAPEKEY,
|
||||
CD_ASSIGN, NULL, 0, block->name);
|
||||
|
||||
j = CustomData_get_layer_index_n(&bm->vdata, CD_SHAPEKEY, i);
|
||||
bm->vdata.layers[j].uid = block->uid;
|
||||
}
|
||||
}
|
||||
else if (actkey) {
|
||||
printf("shapekey <-> mesh mismatch!\n");
|
||||
}
|
||||
|
||||
CustomData_bmesh_init_pool(&bm->vdata, me->totvert, BM_VERT);
|
||||
CustomData_bmesh_init_pool(&bm->edata, me->totedge, BM_EDGE);
|
||||
CustomData_bmesh_init_pool(&bm->ldata, me->totloop, BM_LOOP);
|
||||
CustomData_bmesh_init_pool(&bm->pdata, me->totpoly, BM_FACE);
|
||||
|
||||
for (i = 0, mvert = me->mvert; i < me->totvert; i++, mvert++) {
|
||||
v = BM_vert_create(bm, keyco && set_key ? keyco[i] : mvert->co, NULL);
|
||||
BM_elem_index_set(v, i); /* set_ok */
|
||||
vt[i] = v;
|
||||
|
||||
/* transfer flag */
|
||||
v->head.hflag = BM_vert_flag_from_mflag(mvert->flag);
|
||||
|
||||
/* this is necessary for selection counts to work properly */
|
||||
if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
|
||||
BM_vert_select_set(bm, v, TRUE);
|
||||
}
|
||||
|
||||
normal_short_to_float_v3(v->no, mvert->no);
|
||||
|
||||
BM_elem_float_data_set(&bm->vdata, v, CD_BWEIGHT, (float)mvert->bweight / 255.0f);
|
||||
|
||||
/* Copy Custom Dat */
|
||||
CustomData_to_bmesh_block(&me->vdata, &bm->vdata, i, &v->head.data);
|
||||
|
||||
/* set shapekey data */
|
||||
if (me->key) {
|
||||
/* set shape key original index */
|
||||
keyi = CustomData_bmesh_get(&bm->vdata, v->head.data, CD_SHAPE_KEYINDEX);
|
||||
if (keyi) {
|
||||
*keyi = i;
|
||||
}
|
||||
|
||||
for (block = me->key->block.first, j = 0; block; block = block->next, j++) {
|
||||
float *co = CustomData_bmesh_get_n(&bm->vdata, v->head.data, CD_SHAPEKEY, j);
|
||||
|
||||
if (co) {
|
||||
copy_v3_v3(co, ((float *)block->data) + 3 * i);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bm->elem_index_dirty &= ~BM_VERT; /* added in order, clear dirty flag */
|
||||
|
||||
if (!me->totedge) {
|
||||
MEM_freeN(vt);
|
||||
return;
|
||||
}
|
||||
|
||||
et = MEM_mallocN(sizeof(void **) * me->totedge, "mesh to bmesh etable");
|
||||
|
||||
medge = me->medge;
|
||||
for (i = 0; i < me->totedge; i++, medge++) {
|
||||
e = BM_edge_create(bm, vt[medge->v1], vt[medge->v2], NULL, FALSE);
|
||||
BM_elem_index_set(e, i); /* set_ok */
|
||||
et[i] = e;
|
||||
|
||||
/* transfer flags */
|
||||
e->head.hflag = BM_edge_flag_from_mflag(medge->flag);
|
||||
|
||||
/* this is necessary for selection counts to work properly */
|
||||
if (BM_elem_flag_test(e, BM_ELEM_SELECT)) BM_elem_select_set(bm, e, TRUE);
|
||||
|
||||
/* Copy Custom Data */
|
||||
CustomData_to_bmesh_block(&me->edata, &bm->edata, i, &e->head.data);
|
||||
|
||||
BM_elem_float_data_set(&bm->edata, e, CD_CREASE, (float)medge->crease / 255.0f);
|
||||
BM_elem_float_data_set(&bm->edata, e, CD_BWEIGHT, (float)medge->bweight / 255.0f);
|
||||
}
|
||||
|
||||
bm->elem_index_dirty &= ~BM_EDGE; /* added in order, clear dirty flag */
|
||||
|
||||
mpoly = me->mpoly;
|
||||
for (i = 0; i < me->totpoly; i++, mpoly++) {
|
||||
BMIter iter;
|
||||
|
||||
BLI_array_empty(fedges);
|
||||
BLI_array_empty(verts);
|
||||
|
||||
BLI_array_growitems(fedges, mpoly->totloop);
|
||||
BLI_array_growitems(verts, mpoly->totloop);
|
||||
|
||||
for (j = 0; j < mpoly->totloop; j++) {
|
||||
ml = &me->mloop[mpoly->loopstart + j];
|
||||
v = vt[ml->v];
|
||||
e = et[ml->e];
|
||||
|
||||
fedges[j] = e;
|
||||
verts[j] = v;
|
||||
}
|
||||
|
||||
/* not sure what this block is supposed to do,
|
||||
* but its unused. so commenting - campbell */
|
||||
#if 0
|
||||
{
|
||||
BMVert *v1, *v2;
|
||||
v1 = vt[me->mloop[mpoly->loopstart].v];
|
||||
v2 = vt[me->mloop[mpoly->loopstart + 1].v];
|
||||
|
||||
if (v1 == fedges[0]->v1) {
|
||||
v2 = fedges[0]->v2;
|
||||
}
|
||||
else {
|
||||
v1 = fedges[0]->v2;
|
||||
v2 = fedges[0]->v1;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
f = BM_face_create(bm, verts, fedges, mpoly->totloop, FALSE);
|
||||
|
||||
if (!f) {
|
||||
printf("%s: Warning! Bad face in mesh"
|
||||
" \"%s\" at index %d!, skipping\n",
|
||||
__func__, me->id.name + 2, i);
|
||||
continue;
|
||||
}
|
||||
|
||||
/* dont use 'i' since we may have skipped the face */
|
||||
BM_elem_index_set(f, bm->totface - 1); /* set_ok */
|
||||
|
||||
/* transfer flag */
|
||||
f->head.hflag = BM_face_flag_from_mflag(mpoly->flag);
|
||||
|
||||
/* this is necessary for selection counts to work properly */
|
||||
if (BM_elem_flag_test(f, BM_ELEM_SELECT)) BM_elem_select_set(bm, f, TRUE);
|
||||
|
||||
f->mat_nr = mpoly->mat_nr;
|
||||
if (i == me->act_face) bm->act_face = f;
|
||||
|
||||
j = 0;
|
||||
BM_ITER_INDEX(l, &iter, bm, BM_LOOPS_OF_FACE, f, j) {
|
||||
/* Save index of correspsonding MLoop */
|
||||
BM_elem_index_set(l, mpoly->loopstart + j); /* set_loop */
|
||||
}
|
||||
|
||||
/* Copy Custom Data */
|
||||
CustomData_to_bmesh_block(&me->pdata, &bm->pdata, i, &f->head.data);
|
||||
}
|
||||
|
||||
bm->elem_index_dirty &= ~BM_FACE; /* added in order, clear dirty flag */
|
||||
|
||||
{
|
||||
BMIter fiter;
|
||||
BMIter liter;
|
||||
|
||||
/* Copy over loop CustomData. Doing this in a separate loop isn't necessary
|
||||
* but is an optimization, to avoid copying a bunch of interpolated customdata
|
||||
* for each BMLoop (from previous BMLoops using the same edge), always followed
|
||||
* by freeing the interpolated data and overwriting it with data from the Mesh. */
|
||||
BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
|
||||
BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) {
|
||||
int li = BM_elem_index_get(l);
|
||||
CustomData_to_bmesh_block(&me->ldata, &bm->ldata, li, &l->head.data);
|
||||
BM_elem_index_set(l, 0); /* set_loop */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (me->mselect && me->totselect != 0) {
|
||||
BMIter iter;
|
||||
BMVert *vertex;
|
||||
BMEdge *edge;
|
||||
BMFace *face;
|
||||
BMVert **vertex_array = MEM_callocN(sizeof(BMVert *) * bm->totvert,
|
||||
"Selection Conversion Vertex Pointer Array");
|
||||
BMEdge **edge_array = MEM_callocN(sizeof(BMEdge *) * bm->totedge,
|
||||
"Selection Conversion Edge Pointer Array");
|
||||
BMFace **face_array = MEM_callocN(sizeof(BMFace *) * bm->totface,
|
||||
"Selection Conversion Face Pointer Array");
|
||||
|
||||
for (i = 0, vertex = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL);
|
||||
vertex;
|
||||
i++, vertex = BM_iter_step(&iter))
|
||||
{
|
||||
vertex_array[i] = vertex;
|
||||
}
|
||||
|
||||
for (i = 0, edge = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, NULL);
|
||||
edge;
|
||||
i++, edge = BM_iter_step(&iter))
|
||||
{
|
||||
edge_array[i] = edge;
|
||||
}
|
||||
|
||||
for (i = 0, face = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, NULL);
|
||||
face;
|
||||
i++, face = BM_iter_step(&iter))
|
||||
{
|
||||
face_array[i] = face;
|
||||
}
|
||||
|
||||
if (me->mselect) {
|
||||
for (i = 0; i < me->totselect; i++) {
|
||||
if (me->mselect[i].type == ME_VSEL) {
|
||||
BM_select_history_store(bm, (BMElem *)vertex_array[me->mselect[i].index]);
|
||||
}
|
||||
else if (me->mselect[i].type == ME_ESEL) {
|
||||
BM_select_history_store(bm, (BMElem *)edge_array[me->mselect[i].index]);
|
||||
}
|
||||
else if (me->mselect[i].type == ME_FSEL) {
|
||||
BM_select_history_store(bm, (BMElem *)face_array[me->mselect[i].index]);
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
me->totselect = 0;
|
||||
}
|
||||
|
||||
MEM_freeN(vertex_array);
|
||||
MEM_freeN(edge_array);
|
||||
MEM_freeN(face_array);
|
||||
}
|
||||
else {
|
||||
me->totselect = 0;
|
||||
if (me->mselect) {
|
||||
MEM_freeN(me->mselect);
|
||||
me->mselect = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
BLI_array_free(fedges);
|
||||
BLI_array_free(verts);
|
||||
|
||||
MEM_freeN(vt);
|
||||
MEM_freeN(et);
|
||||
}
|
||||
|
||||
|
||||
/* BMesh -> Mesh */
|
||||
static BMVert **bm_to_mesh_vertex_map(BMesh *bm, int ototvert)
|
||||
{
|
||||
BMVert **vertMap = NULL;
|
||||
BMVert *eve;
|
||||
int index;
|
||||
int i = 0;
|
||||
BMIter iter;
|
||||
|
||||
/* caller needs to ensure this */
|
||||
BLI_assert(ototvert > 0);
|
||||
|
||||
vertMap = MEM_callocN(sizeof(*vertMap)*ototvert, "vertMap");
|
||||
if (CustomData_has_layer(&bm->vdata, CD_SHAPE_KEYINDEX)) {
|
||||
int *keyi;
|
||||
BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
|
||||
keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
|
||||
if (keyi) {
|
||||
if (((index = *keyi) != ORIGINDEX_NONE) && (index < ototvert)) {
|
||||
vertMap[index] = eve;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (i < ototvert) {
|
||||
vertMap[i] = eve;
|
||||
}
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
else {
|
||||
BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
|
||||
if (i < ototvert) {
|
||||
vertMap[i] = eve;
|
||||
}
|
||||
else {
|
||||
break;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
return vertMap;
|
||||
}
|
||||
|
||||
BM_INLINE void bmesh_quick_edgedraw_flag(MEdge *med, BMEdge *e)
|
||||
{
|
||||
/* this is a cheap way to set the edge draw, its not precise and will
|
||||
* pick the first 2 faces an edge uses */
|
||||
|
||||
|
||||
if ( /* (med->flag & ME_EDGEDRAW) && */ /* assume to be true */
|
||||
(e->l && (e->l != e->l->radial_next)) &&
|
||||
(dot_v3v3(e->l->f->no, e->l->radial_next->f->no) > 0.998f))
|
||||
{
|
||||
med->flag &= ~ME_EDGEDRAW;
|
||||
}
|
||||
}
|
||||
|
||||
void BM_mesh_from_bmesh(BMesh *bm, Mesh *me, int dotess)
|
||||
{
|
||||
MLoop *mloop;
|
||||
MPoly *mpoly;
|
||||
MVert *mvert, *oldverts;
|
||||
MEdge *med, *medge;
|
||||
BMVert *v, *eve;
|
||||
BMEdge *e;
|
||||
BMLoop *l;
|
||||
BMFace *f;
|
||||
BMIter iter, liter;
|
||||
int i, j, *keyi, ototvert, totloop;
|
||||
|
||||
ototvert = me->totvert;
|
||||
|
||||
/* new Vertex block */
|
||||
if (bm->totvert == 0) mvert = NULL;
|
||||
else mvert = MEM_callocN(bm->totvert * sizeof(MVert), "loadeditbMesh vert");
|
||||
|
||||
/* new Edge block */
|
||||
if (bm->totedge == 0) medge = NULL;
|
||||
else medge = MEM_callocN(bm->totedge * sizeof(MEdge), "loadeditbMesh edge");
|
||||
|
||||
/* build ngon data */
|
||||
/* new Ngon Face block */
|
||||
if (bm->totface == 0) mpoly = NULL;
|
||||
else mpoly = MEM_callocN(bm->totface * sizeof(MPoly), "loadeditbMesh poly");
|
||||
|
||||
/* find number of loops to allocate */
|
||||
totloop = 0;
|
||||
BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
|
||||
totloop += f->len;
|
||||
}
|
||||
|
||||
if (totloop == 0) mloop = NULL;
|
||||
else mloop = MEM_callocN(totloop * sizeof(MLoop), "loadeditbMesh loop");
|
||||
|
||||
/* 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;
|
||||
|
||||
/* 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);
|
||||
CustomData_free(&me->ldata, me->totloop);
|
||||
CustomData_free(&me->pdata, me->totpoly);
|
||||
|
||||
/* add new custom data */
|
||||
me->totvert = bm->totvert;
|
||||
me->totedge = bm->totedge;
|
||||
me->totloop = totloop;
|
||||
me->totpoly = bm->totface;
|
||||
/* will be overwritten with a valid value if 'dotess' is set, otherwise we
|
||||
* end up with 'me->totface' and me->mface == NULL which can crash [#28625]
|
||||
*/
|
||||
me->totface = 0;
|
||||
|
||||
CustomData_copy(&bm->vdata, &me->vdata, CD_MASK_MESH, CD_CALLOC, me->totvert);
|
||||
CustomData_copy(&bm->edata, &me->edata, CD_MASK_MESH, CD_CALLOC, me->totedge);
|
||||
CustomData_copy(&bm->ldata, &me->ldata, CD_MASK_MESH, CD_CALLOC, me->totloop);
|
||||
CustomData_copy(&bm->pdata, &me->pdata, CD_MASK_MESH, CD_CALLOC, me->totpoly);
|
||||
|
||||
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->ldata, CD_MLOOP, CD_ASSIGN, mloop, me->totloop);
|
||||
CustomData_add_layer(&me->pdata, CD_MPOLY, CD_ASSIGN, mpoly, me->totpoly);
|
||||
|
||||
/* this is called again, 'dotess' arg is used there */
|
||||
mesh_update_customdata_pointers(me, 0);
|
||||
|
||||
i = 0;
|
||||
BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
|
||||
float *bweight = CustomData_bmesh_get(&bm->vdata, v->head.data, CD_BWEIGHT);
|
||||
|
||||
mvert->bweight = bweight ? (char)((*bweight) * 255) : 0;
|
||||
|
||||
copy_v3_v3(mvert->co, v->co);
|
||||
normal_float_to_short_v3(mvert->no, v->no);
|
||||
|
||||
mvert->flag = BM_vert_flag_to_mflag(v);
|
||||
|
||||
BM_elem_index_set(v, i); /* set_inline */
|
||||
|
||||
/* copy over customdat */
|
||||
CustomData_from_bmesh_block(&bm->vdata, &me->vdata, v->head.data, i);
|
||||
|
||||
i++;
|
||||
mvert++;
|
||||
|
||||
BM_CHECK_ELEMENT(bm, v);
|
||||
}
|
||||
bm->elem_index_dirty &= ~BM_VERT;
|
||||
|
||||
med = medge;
|
||||
i = 0;
|
||||
BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
|
||||
float *crease = CustomData_bmesh_get(&bm->edata, e->head.data, CD_CREASE);
|
||||
float *bweight = CustomData_bmesh_get(&bm->edata, e->head.data, CD_BWEIGHT);
|
||||
|
||||
med->v1 = BM_elem_index_get(e->v1);
|
||||
med->v2 = BM_elem_index_get(e->v2);
|
||||
med->crease = crease ? (char)((*crease) * 255) : 0;
|
||||
med->bweight = bweight ? (char)((*bweight) * 255) : 0;
|
||||
|
||||
med->flag = BM_edge_flag_to_mflag(e);
|
||||
|
||||
BM_elem_index_set(e, i); /* set_inline */
|
||||
|
||||
/* copy over customdata */
|
||||
CustomData_from_bmesh_block(&bm->edata, &me->edata, e->head.data, i);
|
||||
|
||||
bmesh_quick_edgedraw_flag(med, e);
|
||||
|
||||
i++;
|
||||
med++;
|
||||
BM_CHECK_ELEMENT(bm, e);
|
||||
}
|
||||
bm->elem_index_dirty &= ~BM_EDGE;
|
||||
|
||||
i = 0;
|
||||
j = 0;
|
||||
BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
|
||||
mpoly->loopstart = j;
|
||||
mpoly->totloop = f->len;
|
||||
mpoly->mat_nr = f->mat_nr;
|
||||
mpoly->flag = BM_face_flag_to_mflag(f);
|
||||
|
||||
l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, f);
|
||||
for ( ; l; l = BM_iter_step(&liter), j++, mloop++) {
|
||||
mloop->e = BM_elem_index_get(l->e);
|
||||
mloop->v = BM_elem_index_get(l->v);
|
||||
|
||||
/* copy over customdat */
|
||||
CustomData_from_bmesh_block(&bm->ldata, &me->ldata, l->head.data, j);
|
||||
BM_CHECK_ELEMENT(bm, l);
|
||||
BM_CHECK_ELEMENT(bm, l->e);
|
||||
BM_CHECK_ELEMENT(bm, l->v);
|
||||
}
|
||||
|
||||
if (f == bm->act_face) me->act_face = i;
|
||||
|
||||
/* copy over customdata */
|
||||
CustomData_from_bmesh_block(&bm->pdata, &me->pdata, f->head.data, i);
|
||||
|
||||
i++;
|
||||
mpoly++;
|
||||
BM_CHECK_ELEMENT(bm, f);
|
||||
}
|
||||
|
||||
/* patch hook indices and vertex parents */
|
||||
if (ototvert > 0) {
|
||||
Object *ob;
|
||||
ModifierData *md;
|
||||
BMVert **vertMap = NULL;
|
||||
int i, j;
|
||||
|
||||
for (ob = G.main->object.first; ob; ob = ob->id.next) {
|
||||
if (ob->parent == bm->ob && ELEM(ob->partype, PARVERT1, PARVERT3)) {
|
||||
|
||||
if (vertMap == NULL) {
|
||||
vertMap = bm_to_mesh_vertex_map(bm, ototvert);
|
||||
}
|
||||
|
||||
if (ob->par1 < ototvert) {
|
||||
eve = vertMap[ob->par1];
|
||||
if (eve) ob->par1 = BM_elem_index_get(eve);
|
||||
}
|
||||
if (ob->par2 < ototvert) {
|
||||
eve = vertMap[ob->par2];
|
||||
if (eve) ob->par2 = BM_elem_index_get(eve);
|
||||
}
|
||||
if (ob->par3 < ototvert) {
|
||||
eve = vertMap[ob->par3];
|
||||
if (eve) ob->par3 = BM_elem_index_get(eve);
|
||||
}
|
||||
|
||||
}
|
||||
if (ob->data == me) {
|
||||
for (md = ob->modifiers.first; md; md = md->next) {
|
||||
if (md->type == eModifierType_Hook) {
|
||||
HookModifierData *hmd = (HookModifierData *) md;
|
||||
|
||||
if (vertMap == NULL) {
|
||||
vertMap = bm_to_mesh_vertex_map(bm, ototvert);
|
||||
}
|
||||
|
||||
for (i = j = 0; i < hmd->totindex; i++) {
|
||||
if (hmd->indexar[i] < ototvert) {
|
||||
eve = vertMap[hmd->indexar[i]];
|
||||
|
||||
if (eve) {
|
||||
hmd->indexar[j++] = BM_elem_index_get(eve);
|
||||
}
|
||||
}
|
||||
else j++;
|
||||
}
|
||||
|
||||
hmd->totindex = j;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (vertMap) MEM_freeN(vertMap);
|
||||
}
|
||||
|
||||
if (dotess) {
|
||||
BKE_mesh_tessface_calc(me);
|
||||
}
|
||||
|
||||
mesh_update_customdata_pointers(me, dotess);
|
||||
|
||||
{
|
||||
BMEditSelection *selected;
|
||||
me->totselect = BLI_countlist(&(bm->selected));
|
||||
|
||||
if (me->mselect) MEM_freeN(me->mselect);
|
||||
|
||||
me->mselect = MEM_callocN(sizeof(MSelect) * me->totselect, "Mesh selection history");
|
||||
|
||||
|
||||
for (i = 0, selected = bm->selected.first; selected; i++, selected = selected->next) {
|
||||
if (selected->htype == BM_VERT) {
|
||||
me->mselect[i].type = ME_VSEL;
|
||||
|
||||
}
|
||||
else if (selected->htype == BM_EDGE) {
|
||||
me->mselect[i].type = ME_ESEL;
|
||||
|
||||
}
|
||||
else if (selected->htype == BM_FACE) {
|
||||
me->mselect[i].type = ME_FSEL;
|
||||
}
|
||||
|
||||
me->mselect[i].index = BM_elem_index_get(selected->ele);
|
||||
}
|
||||
}
|
||||
|
||||
/* see comment below, this logic is in twice */
|
||||
|
||||
if (me->key) {
|
||||
KeyBlock *currkey;
|
||||
KeyBlock *actkey = BLI_findlink(&me->key->block, bm->shapenr - 1);
|
||||
|
||||
float (*ofs)[3] = NULL;
|
||||
|
||||
/* go through and find any shapekey customdata layers
|
||||
* that might not have corresponding KeyBlocks, and add them if
|
||||
* necessary */
|
||||
j = 0;
|
||||
for (i = 0; i < bm->vdata.totlayer; i++) {
|
||||
if (bm->vdata.layers[i].type != CD_SHAPEKEY)
|
||||
continue;
|
||||
|
||||
for (currkey = me->key->block.first; currkey; currkey = currkey->next) {
|
||||
if (currkey->uid == bm->vdata.layers[i].uid)
|
||||
break;
|
||||
}
|
||||
|
||||
if (!currkey) {
|
||||
currkey = MEM_callocN(sizeof(KeyBlock), "KeyBlock mesh_conv.c");
|
||||
currkey->type = KEY_LINEAR;
|
||||
currkey->slidermin = 0.0f;
|
||||
currkey->slidermax = 1.0f;
|
||||
|
||||
BLI_addtail(&me->key->block, currkey);
|
||||
me->key->totkey++;
|
||||
}
|
||||
|
||||
j++;
|
||||
}
|
||||
|
||||
|
||||
/* 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 (bm->shapenr - 1 == currkey->relative) {
|
||||
act_is_basis = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (act_is_basis) { /* active key is a base */
|
||||
float (*fp)[3] = actkey->data;
|
||||
int *keyi;
|
||||
i = 0;
|
||||
ofs = MEM_callocN(sizeof(float) * 3 * bm->totvert, "currkey->data");
|
||||
mvert = me->mvert;
|
||||
BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
|
||||
keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
|
||||
if (keyi && *keyi != ORIGINDEX_NONE) {
|
||||
sub_v3_v3v3(ofs[i], mvert->co, fp[*keyi]);
|
||||
}
|
||||
i++;
|
||||
mvert++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
for (currkey = me->key->block.first; currkey; currkey = currkey->next) {
|
||||
j = 0;
|
||||
|
||||
for (i = 0; i < bm->vdata.totlayer; i++) {
|
||||
if (bm->vdata.layers[i].type != CD_SHAPEKEY)
|
||||
continue;
|
||||
|
||||
if (currkey->uid == bm->vdata.layers[i].uid) {
|
||||
int apply_offset = (ofs && (currkey != actkey) && (bm->shapenr - 1 == currkey->relative));
|
||||
float *fp, *co;
|
||||
float (*ofs_pt)[3] = ofs;
|
||||
|
||||
if (currkey->data)
|
||||
MEM_freeN(currkey->data);
|
||||
currkey->data = fp = MEM_mallocN(sizeof(float) * 3 * bm->totvert, "shape key data");
|
||||
currkey->totelem = bm->totvert;
|
||||
|
||||
mvert = me->mvert;
|
||||
BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
|
||||
co = (currkey == actkey) ?
|
||||
eve->co :
|
||||
CustomData_bmesh_get_n(&bm->vdata, eve->head.data, CD_SHAPEKEY, j);
|
||||
|
||||
copy_v3_v3(fp, co);
|
||||
|
||||
/* propagate edited basis offsets to other shapes */
|
||||
if (apply_offset) {
|
||||
add_v3_v3(fp, *ofs_pt++);
|
||||
}
|
||||
|
||||
if (currkey == actkey && oldverts) {
|
||||
keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
|
||||
|
||||
if (*keyi >= 0 && *keyi < currkey->totelem) // valid old vertex
|
||||
copy_v3_v3(mvert->co, oldverts[*keyi].co);
|
||||
|
||||
mvert++;
|
||||
}
|
||||
|
||||
fp += 3;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
j++;
|
||||
}
|
||||
|
||||
/* if we didn't find a shapekey, tag the block to be reconstructed
|
||||
* via the old method below */
|
||||
if (j == CustomData_number_of_layers(&bm->vdata, CD_SHAPEKEY)) {
|
||||
currkey->flag |= KEYBLOCK_MISSING;
|
||||
}
|
||||
}
|
||||
|
||||
if (ofs) MEM_freeN(ofs);
|
||||
}
|
||||
|
||||
/* XXX, code below is from trunk and a duplicate functionality
|
||||
* to the block above.
|
||||
* We should use one or the other, having both means we have to maintain
|
||||
* both and keep them working the same way which is a hassle - campbell */
|
||||
|
||||
/* old method of reconstructing keys via vertice's original key indices,
|
||||
* currently used if the new method above fails (which is theoretically
|
||||
* possible in certain cases of undo) */
|
||||
if (me->key) {
|
||||
float *fp, *newkey, *oldkey;
|
||||
KeyBlock *currkey;
|
||||
KeyBlock *actkey = BLI_findlink(&me->key->block, bm->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 (bm->shapenr - 1 == currkey->relative) {
|
||||
act_is_basis = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (act_is_basis) { /* active key is a base */
|
||||
float (*fp)[3] = actkey->data;
|
||||
int *keyi;
|
||||
i = 0;
|
||||
ofs = MEM_callocN(sizeof(float) * 3 * bm->totvert, "currkey->data");
|
||||
mvert = me->mvert;
|
||||
BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
|
||||
keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
|
||||
if (keyi && *keyi != ORIGINDEX_NONE) {
|
||||
sub_v3_v3v3(ofs[i], mvert->co, fp[*keyi]);
|
||||
}
|
||||
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) && (bm->shapenr - 1 == currkey->relative));
|
||||
|
||||
if (!(currkey->flag & KEYBLOCK_MISSING)) {
|
||||
currkey = currkey->next;
|
||||
continue;
|
||||
}
|
||||
|
||||
printf("warning: had to hackishly reconstruct shape key \"%s\","
|
||||
" it may not be correct anymore.\n", currkey->name);
|
||||
|
||||
currkey->flag &= ~KEYBLOCK_MISSING;
|
||||
|
||||
fp = newkey = MEM_callocN(me->key->elemsize * bm->totvert, "currkey->data");
|
||||
oldkey = currkey->data;
|
||||
|
||||
eve = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL);
|
||||
|
||||
i = 0;
|
||||
mvert = me->mvert;
|
||||
while (eve) {
|
||||
keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
|
||||
if (!keyi) {
|
||||
break;
|
||||
}
|
||||
if (*keyi >= 0 && *keyi < currkey->totelem) { // valid old vertex
|
||||
if (currkey == actkey) {
|
||||
if (actkey == me->key->refkey) {
|
||||
copy_v3_v3(fp, mvert->co);
|
||||
}
|
||||
else {
|
||||
copy_v3_v3(fp, mvert->co);
|
||||
if (oldverts) {
|
||||
copy_v3_v3(mvert->co, oldverts[*keyi].co);
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (oldkey) {
|
||||
copy_v3_v3(fp, oldkey + 3 * *keyi);
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
copy_v3_v3(fp, mvert->co);
|
||||
}
|
||||
|
||||
/* propagate edited basis offsets to other shapes */
|
||||
if (apply_offset) {
|
||||
add_v3_v3(fp, ofs[i]);
|
||||
}
|
||||
|
||||
fp += 3;
|
||||
i++;
|
||||
mvert++;
|
||||
eve = BM_iter_step(&iter);
|
||||
}
|
||||
currkey->totelem = bm->totvert;
|
||||
if (currkey->data) MEM_freeN(currkey->data);
|
||||
currkey->data = newkey;
|
||||
|
||||
currkey = currkey->next;
|
||||
}
|
||||
|
||||
if (ofs) MEM_freeN(ofs);
|
||||
}
|
||||
|
||||
if (oldverts) MEM_freeN(oldverts);
|
||||
}
|
40
source/blender/bmesh/intern/bmesh_mesh_conv.h
Normal file
40
source/blender/bmesh/intern/bmesh_mesh_conv.h
Normal file
@ -0,0 +1,40 @@
|
||||
/*
|
||||
* ***** BEGIN GPL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2004 Blender Foundation.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): Geoffrey Bantle.
|
||||
*
|
||||
* ***** END GPL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#ifndef __BMESH_MESH_CONV_H__
|
||||
#define __BMESH_MESH_CONV_H__
|
||||
|
||||
/** \file blender/bmesh/intern/bmesh_mesh_conv.h
|
||||
* \ingroup bmesh
|
||||
*/
|
||||
|
||||
struct Mesh;
|
||||
|
||||
void BM_mesh_to_bmesh(BMesh *bm, struct Mesh *me, int set_key, int act_key_nr);
|
||||
void BM_mesh_from_bmesh(BMesh *bm, struct Mesh *me, int dotess);
|
||||
|
||||
#endif /* __BMESH_MESH_CONV_H__ */
|
@ -55,314 +55,13 @@ void bmo_mesh_to_bmesh_exec(BMesh *bm, BMOperator *op)
|
||||
{
|
||||
Object *ob = BMO_slot_ptr_get(op, "object");
|
||||
Mesh *me = BMO_slot_ptr_get(op, "mesh");
|
||||
MVert *mvert;
|
||||
BLI_array_declare(verts);
|
||||
MEdge *medge;
|
||||
MLoop *ml;
|
||||
MPoly *mpoly;
|
||||
KeyBlock *actkey, *block;
|
||||
BMVert *v, **vt = NULL, **verts = NULL;
|
||||
BMEdge *e, **fedges = NULL, **et = NULL;
|
||||
BMFace *f;
|
||||
BMLoop *l;
|
||||
BLI_array_declare(fedges);
|
||||
float (*keyco)[3] = NULL;
|
||||
int *keyi;
|
||||
int set_key = BMO_slot_bool_get(op, "set_shapekey");
|
||||
int totuv, i, j;
|
||||
|
||||
if (!me || !me->totvert) {
|
||||
return; /* sanity check */
|
||||
}
|
||||
|
||||
vt = MEM_mallocN(sizeof(void **) * me->totvert, "mesh to bmesh vtable");
|
||||
|
||||
CustomData_copy(&me->vdata, &bm->vdata, CD_MASK_BMESH, CD_CALLOC, 0);
|
||||
CustomData_copy(&me->edata, &bm->edata, CD_MASK_BMESH, CD_CALLOC, 0);
|
||||
CustomData_copy(&me->ldata, &bm->ldata, CD_MASK_BMESH, CD_CALLOC, 0);
|
||||
CustomData_copy(&me->pdata, &bm->pdata, CD_MASK_BMESH, CD_CALLOC, 0);
|
||||
|
||||
/* make sure uv layer names are consisten */
|
||||
totuv = CustomData_number_of_layers(&bm->pdata, CD_MTEXPOLY);
|
||||
for (i = 0; i < totuv; i++) {
|
||||
int li = CustomData_get_layer_index_n(&bm->pdata, CD_MTEXPOLY, i);
|
||||
CustomData_set_layer_name(&bm->ldata, CD_MLOOPUV, i, bm->pdata.layers[li].name);
|
||||
}
|
||||
|
||||
if (!CustomData_has_layer(&bm->edata, CD_CREASE))
|
||||
CustomData_add_layer(&bm->edata, CD_CREASE, CD_ASSIGN, NULL, 0);
|
||||
|
||||
if (!CustomData_has_layer(&bm->edata, CD_BWEIGHT))
|
||||
CustomData_add_layer(&bm->edata, CD_BWEIGHT, CD_ASSIGN, NULL, 0);
|
||||
|
||||
if (!CustomData_has_layer(&bm->vdata, CD_BWEIGHT))
|
||||
CustomData_add_layer(&bm->vdata, CD_BWEIGHT, CD_ASSIGN, NULL, 0);
|
||||
|
||||
BM_mesh_to_bmesh(bm, me, set_key, ob->shapenr - 1);
|
||||
|
||||
if (me->key && ob->shapenr > me->key->totkey) {
|
||||
ob->shapenr = me->key->totkey - 1;
|
||||
}
|
||||
|
||||
actkey = ob_get_keyblock(ob);
|
||||
if (actkey && actkey->totelem == me->totvert) {
|
||||
CustomData_add_layer(&bm->vdata, CD_SHAPE_KEYINDEX, CD_ASSIGN, NULL, 0);
|
||||
|
||||
/* check if we need to generate unique ids for the shapekeys.
|
||||
* this also exists in the file reading code, but is here for
|
||||
* a sanity chec */
|
||||
if (!me->key->uidgen) {
|
||||
fprintf(stderr,
|
||||
"%s had to generate shape key uid's in a situation we shouldn't need to! "
|
||||
"(bmesh internal error)\n",
|
||||
__func__);
|
||||
|
||||
me->key->uidgen = 1;
|
||||
for (block = me->key->block.first; block; block = block->next) {
|
||||
block->uid = me->key->uidgen++;
|
||||
}
|
||||
}
|
||||
|
||||
keyco = actkey->data;
|
||||
bm->shapenr = ob->shapenr;
|
||||
for (i = 0, block = me->key->block.first; block; block = block->next, i++) {
|
||||
CustomData_add_layer_named(&bm->vdata, CD_SHAPEKEY,
|
||||
CD_ASSIGN, NULL, 0, block->name);
|
||||
|
||||
j = CustomData_get_layer_index_n(&bm->vdata, CD_SHAPEKEY, i);
|
||||
bm->vdata.layers[j].uid = block->uid;
|
||||
}
|
||||
}
|
||||
else if (actkey) {
|
||||
printf("shapekey <-> mesh mismatch!\n");
|
||||
}
|
||||
|
||||
CustomData_bmesh_init_pool(&bm->vdata, me->totvert, BM_VERT);
|
||||
CustomData_bmesh_init_pool(&bm->edata, me->totedge, BM_EDGE);
|
||||
CustomData_bmesh_init_pool(&bm->ldata, me->totloop, BM_LOOP);
|
||||
CustomData_bmesh_init_pool(&bm->pdata, me->totpoly, BM_FACE);
|
||||
|
||||
for (i = 0, mvert = me->mvert; i < me->totvert; i++, mvert++) {
|
||||
v = BM_vert_create(bm, keyco && set_key ? keyco[i] : mvert->co, NULL);
|
||||
BM_elem_index_set(v, i); /* set_ok */
|
||||
vt[i] = v;
|
||||
|
||||
/* transfer flag */
|
||||
v->head.hflag = BM_vert_flag_from_mflag(mvert->flag);
|
||||
|
||||
/* this is necessary for selection counts to work properl */
|
||||
if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
|
||||
BM_vert_select_set(bm, v, TRUE);
|
||||
}
|
||||
|
||||
normal_short_to_float_v3(v->no, mvert->no);
|
||||
|
||||
BM_elem_float_data_set(&bm->vdata, v, CD_BWEIGHT, (float)mvert->bweight / 255.0f);
|
||||
|
||||
/* Copy Custom Dat */
|
||||
CustomData_to_bmesh_block(&me->vdata, &bm->vdata, i, &v->head.data);
|
||||
|
||||
/* set shapekey dat */
|
||||
if (me->key) {
|
||||
/* set shape key original inde */
|
||||
keyi = CustomData_bmesh_get(&bm->vdata, v->head.data, CD_SHAPE_KEYINDEX);
|
||||
if (keyi) {
|
||||
*keyi = i;
|
||||
}
|
||||
|
||||
for (block = me->key->block.first, j = 0; block; block = block->next, j++) {
|
||||
float *co = CustomData_bmesh_get_n(&bm->vdata, v->head.data, CD_SHAPEKEY, j);
|
||||
|
||||
if (co) {
|
||||
copy_v3_v3(co, ((float *)block->data) + 3 * i);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bm->elem_index_dirty &= ~BM_VERT; /* added in order, clear dirty flag */
|
||||
|
||||
if (!me->totedge) {
|
||||
MEM_freeN(vt);
|
||||
return;
|
||||
}
|
||||
|
||||
et = MEM_mallocN(sizeof(void **) * me->totedge, "mesh to bmesh etable");
|
||||
|
||||
medge = me->medge;
|
||||
for (i = 0; i < me->totedge; i++, medge++) {
|
||||
e = BM_edge_create(bm, vt[medge->v1], vt[medge->v2], NULL, FALSE);
|
||||
BM_elem_index_set(e, i); /* set_ok */
|
||||
et[i] = e;
|
||||
|
||||
/* transfer flags */
|
||||
e->head.hflag = BM_edge_flag_from_mflag(medge->flag);
|
||||
|
||||
/* this is necessary for selection counts to work properly */
|
||||
if (BM_elem_flag_test(e, BM_ELEM_SELECT)) BM_elem_select_set(bm, e, TRUE);
|
||||
|
||||
/* Copy Custom Dat */
|
||||
CustomData_to_bmesh_block(&me->edata, &bm->edata, i, &e->head.data);
|
||||
|
||||
BM_elem_float_data_set(&bm->edata, e, CD_CREASE, (float)medge->crease / 255.0f);
|
||||
BM_elem_float_data_set(&bm->edata, e, CD_BWEIGHT, (float)medge->bweight / 255.0f);
|
||||
}
|
||||
|
||||
bm->elem_index_dirty &= ~BM_EDGE; /* added in order, clear dirty flag */
|
||||
|
||||
mpoly = me->mpoly;
|
||||
for (i = 0; i < me->totpoly; i++, mpoly++) {
|
||||
BMIter iter;
|
||||
|
||||
BLI_array_empty(fedges);
|
||||
BLI_array_empty(verts);
|
||||
|
||||
BLI_array_growitems(fedges, mpoly->totloop);
|
||||
BLI_array_growitems(verts, mpoly->totloop);
|
||||
|
||||
for (j = 0; j < mpoly->totloop; j++) {
|
||||
ml = &me->mloop[mpoly->loopstart + j];
|
||||
v = vt[ml->v];
|
||||
e = et[ml->e];
|
||||
|
||||
fedges[j] = e;
|
||||
verts[j] = v;
|
||||
}
|
||||
|
||||
/* not sure what this block is supposed to do,
|
||||
* but its unused. so commenting - campbell */
|
||||
#if 0
|
||||
{
|
||||
BMVert *v1, *v2;
|
||||
v1 = vt[me->mloop[mpoly->loopstart].v];
|
||||
v2 = vt[me->mloop[mpoly->loopstart + 1].v];
|
||||
|
||||
if (v1 == fedges[0]->v1) {
|
||||
v2 = fedges[0]->v2;
|
||||
}
|
||||
else {
|
||||
v1 = fedges[0]->v2;
|
||||
v2 = fedges[0]->v1;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
f = BM_face_create(bm, verts, fedges, mpoly->totloop, FALSE);
|
||||
|
||||
if (!f) {
|
||||
printf("%s: Warning! Bad face in mesh"
|
||||
" \"%s\" at index %d!, skipping\n",
|
||||
__func__, me->id.name + 2, i);
|
||||
continue;
|
||||
}
|
||||
|
||||
/* dont use 'i' since we may have skipped the face */
|
||||
BM_elem_index_set(f, bm->totface - 1); /* set_ok */
|
||||
|
||||
/* transfer flag */
|
||||
f->head.hflag = BM_face_flag_from_mflag(mpoly->flag);
|
||||
|
||||
/* this is necessary for selection counts to work properl */
|
||||
if (BM_elem_flag_test(f, BM_ELEM_SELECT)) BM_elem_select_set(bm, f, TRUE);
|
||||
|
||||
f->mat_nr = mpoly->mat_nr;
|
||||
if (i == me->act_face) bm->act_face = f;
|
||||
|
||||
j = 0;
|
||||
BM_ITER_INDEX(l, &iter, bm, BM_LOOPS_OF_FACE, f, j) {
|
||||
/* Save index of correspsonding MLoop */
|
||||
BM_elem_index_set(l, mpoly->loopstart + j); /* set_loop */
|
||||
}
|
||||
|
||||
/* Copy Custom Data */
|
||||
CustomData_to_bmesh_block(&me->pdata, &bm->pdata, i, &f->head.data);
|
||||
}
|
||||
|
||||
bm->elem_index_dirty &= ~BM_FACE; /* added in order, clear dirty flag */
|
||||
|
||||
{
|
||||
BMIter fiter;
|
||||
BMIter liter;
|
||||
|
||||
/* Copy over loop CustomData. Doing this in a separate loop isn't necessary
|
||||
* but is an optimization, to avoid copying a bunch of interpolated customdata
|
||||
* for each BMLoop (from previous BMLoops using the same edge), always followed
|
||||
* by freeing the interpolated data and overwriting it with data from the Mesh. */
|
||||
BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
|
||||
BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) {
|
||||
int li = BM_elem_index_get(l);
|
||||
CustomData_to_bmesh_block(&me->ldata, &bm->ldata, li, &l->head.data);
|
||||
BM_elem_index_set(l, 0); /* set_loop */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (me->mselect && me->totselect != 0) {
|
||||
BMIter iter;
|
||||
BMVert *vertex;
|
||||
BMEdge *edge;
|
||||
BMFace *face;
|
||||
BMVert **vertex_array = MEM_callocN(sizeof(BMVert *) * bm->totvert,
|
||||
"Selection Conversion Vertex Pointer Array");
|
||||
BMEdge **edge_array = MEM_callocN(sizeof(BMEdge *) * bm->totedge,
|
||||
"Selection Conversion Edge Pointer Array");
|
||||
BMFace **face_array = MEM_callocN(sizeof(BMFace *) * bm->totface,
|
||||
"Selection Conversion Face Pointer Array");
|
||||
|
||||
for (i = 0, vertex = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL);
|
||||
vertex;
|
||||
i++, vertex = BM_iter_step(&iter))
|
||||
{
|
||||
vertex_array[i] = vertex;
|
||||
}
|
||||
|
||||
for (i = 0, edge = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, NULL);
|
||||
edge;
|
||||
i++, edge = BM_iter_step(&iter))
|
||||
{
|
||||
edge_array[i] = edge;
|
||||
}
|
||||
|
||||
for (i = 0, face = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, NULL);
|
||||
face;
|
||||
i++, face = BM_iter_step(&iter))
|
||||
{
|
||||
face_array[i] = face;
|
||||
}
|
||||
|
||||
if (me->mselect) {
|
||||
for (i = 0; i < me->totselect; i++) {
|
||||
if (me->mselect[i].type == ME_VSEL) {
|
||||
BM_select_history_store(bm, (BMElem *)vertex_array[me->mselect[i].index]);
|
||||
}
|
||||
else if (me->mselect[i].type == ME_ESEL) {
|
||||
BM_select_history_store(bm, (BMElem *)edge_array[me->mselect[i].index]);
|
||||
}
|
||||
else if (me->mselect[i].type == ME_FSEL) {
|
||||
BM_select_history_store(bm, (BMElem *)face_array[me->mselect[i].index]);
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
me->totselect = 0;
|
||||
}
|
||||
|
||||
MEM_freeN(vertex_array);
|
||||
MEM_freeN(edge_array);
|
||||
MEM_freeN(face_array);
|
||||
}
|
||||
else {
|
||||
me->totselect = 0;
|
||||
if (me->mselect) {
|
||||
MEM_freeN(me->mselect);
|
||||
me->mselect = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
BLI_array_free(fedges);
|
||||
BLI_array_free(verts);
|
||||
|
||||
MEM_freeN(vt);
|
||||
MEM_freeN(et);
|
||||
}
|
||||
|
||||
void bmo_object_load_bmesh_exec(BMesh *bm, BMOperator *op)
|
||||
@ -374,544 +73,11 @@ void bmo_object_load_bmesh_exec(BMesh *bm, BMOperator *op)
|
||||
BMO_op_callf(bm, "bmesh_to_mesh mesh=%p object=%p notessellation=%b", me, ob, TRUE);
|
||||
}
|
||||
|
||||
|
||||
static BMVert **bm_to_mesh_vertex_map(BMesh *bm, int ototvert)
|
||||
{
|
||||
BMVert **vertMap = NULL;
|
||||
BMVert *eve;
|
||||
int index;
|
||||
int i = 0;
|
||||
BMIter iter;
|
||||
|
||||
/* caller needs to ensure this */
|
||||
BLI_assert(ototvert > 0);
|
||||
|
||||
vertMap = MEM_callocN(sizeof(*vertMap)*ototvert, "vertMap");
|
||||
if (CustomData_has_layer(&bm->vdata, CD_SHAPE_KEYINDEX)) {
|
||||
int *keyi;
|
||||
BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
|
||||
keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
|
||||
if (keyi) {
|
||||
if (((index = *keyi) != ORIGINDEX_NONE) && (index < ototvert)) {
|
||||
vertMap[index] = eve;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (i < ototvert) {
|
||||
vertMap[i] = eve;
|
||||
}
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
else {
|
||||
BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
|
||||
if (i < ototvert) {
|
||||
vertMap[i] = eve;
|
||||
}
|
||||
else {
|
||||
break;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
return vertMap;
|
||||
}
|
||||
|
||||
BM_INLINE void bmesh_quick_edgedraw_flag(MEdge *med, BMEdge *e)
|
||||
{
|
||||
/* this is a cheap way to set the edge draw, its not precise and will
|
||||
* pick the first 2 faces an edge uses */
|
||||
|
||||
|
||||
if ( /* (med->flag & ME_EDGEDRAW) && */ /* assume to be true */
|
||||
(e->l && (e->l != e->l->radial_next)) &&
|
||||
(dot_v3v3(e->l->f->no, e->l->radial_next->f->no) > 0.998f))
|
||||
{
|
||||
med->flag &= ~ME_EDGEDRAW;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void bmo_bmesh_to_mesh_exec(BMesh *bm, BMOperator *op)
|
||||
{
|
||||
Mesh *me = BMO_slot_ptr_get(op, "mesh");
|
||||
/* Object *ob = BMO_slot_ptr_get(op, "object"); */
|
||||
MLoop *mloop;
|
||||
MPoly *mpoly;
|
||||
MVert *mvert, *oldverts;
|
||||
MEdge *med, *medge;
|
||||
BMVert *v, *eve;
|
||||
BMEdge *e;
|
||||
BMLoop *l;
|
||||
BMFace *f;
|
||||
BMIter iter, liter;
|
||||
int i, j, *keyi, ototvert, totloop;
|
||||
int dotess = !BMO_slot_bool_get(op, "notessellation");
|
||||
|
||||
ototvert = me->totvert;
|
||||
|
||||
/* new Vertex block */
|
||||
if (bm->totvert == 0) mvert = NULL;
|
||||
else mvert = MEM_callocN(bm->totvert * sizeof(MVert), "loadeditbMesh vert");
|
||||
|
||||
/* new Edge block */
|
||||
if (bm->totedge == 0) medge = NULL;
|
||||
else medge = MEM_callocN(bm->totedge * sizeof(MEdge), "loadeditbMesh edge");
|
||||
|
||||
/* build ngon dat */
|
||||
/* new Ngon Face block */
|
||||
if (bm->totface == 0) mpoly = NULL;
|
||||
else mpoly = MEM_callocN(bm->totface * sizeof(MPoly), "loadeditbMesh poly");
|
||||
|
||||
/* find number of loops to allocat */
|
||||
totloop = 0;
|
||||
BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
|
||||
totloop += f->len;
|
||||
}
|
||||
|
||||
if (totloop == 0) mloop = NULL;
|
||||
else mloop = MEM_callocN(totloop * sizeof(MLoop), "loadeditbMesh loop");
|
||||
|
||||
/* 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;
|
||||
|
||||
/* 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);
|
||||
CustomData_free(&me->ldata, me->totloop);
|
||||
CustomData_free(&me->pdata, me->totpoly);
|
||||
|
||||
/* add new custom data */
|
||||
me->totvert = bm->totvert;
|
||||
me->totedge = bm->totedge;
|
||||
me->totloop = totloop;
|
||||
me->totpoly = bm->totface;
|
||||
/* will be overwritten with a valid value if 'dotess' is set, otherwise we
|
||||
* end up with 'me->totface' and me->mface == NULL which can crash [#28625]
|
||||
*/
|
||||
me->totface = 0;
|
||||
|
||||
CustomData_copy(&bm->vdata, &me->vdata, CD_MASK_MESH, CD_CALLOC, me->totvert);
|
||||
CustomData_copy(&bm->edata, &me->edata, CD_MASK_MESH, CD_CALLOC, me->totedge);
|
||||
CustomData_copy(&bm->ldata, &me->ldata, CD_MASK_MESH, CD_CALLOC, me->totloop);
|
||||
CustomData_copy(&bm->pdata, &me->pdata, CD_MASK_MESH, CD_CALLOC, me->totpoly);
|
||||
|
||||
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->ldata, CD_MLOOP, CD_ASSIGN, mloop, me->totloop);
|
||||
CustomData_add_layer(&me->pdata, CD_MPOLY, CD_ASSIGN, mpoly, me->totpoly);
|
||||
|
||||
/* this is called again, 'dotess' arg is used there */
|
||||
mesh_update_customdata_pointers(me, 0);
|
||||
|
||||
i = 0;
|
||||
BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
|
||||
float *bweight = CustomData_bmesh_get(&bm->vdata, v->head.data, CD_BWEIGHT);
|
||||
|
||||
mvert->bweight = bweight ? (char)((*bweight) * 255) : 0;
|
||||
|
||||
copy_v3_v3(mvert->co, v->co);
|
||||
normal_float_to_short_v3(mvert->no, v->no);
|
||||
|
||||
mvert->flag = BM_vert_flag_to_mflag(v);
|
||||
|
||||
BM_elem_index_set(v, i); /* set_inline */
|
||||
|
||||
/* copy over customdat */
|
||||
CustomData_from_bmesh_block(&bm->vdata, &me->vdata, v->head.data, i);
|
||||
|
||||
i++;
|
||||
mvert++;
|
||||
|
||||
BM_CHECK_ELEMENT(bm, v);
|
||||
}
|
||||
bm->elem_index_dirty &= ~BM_VERT;
|
||||
|
||||
med = medge;
|
||||
i = 0;
|
||||
BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
|
||||
float *crease = CustomData_bmesh_get(&bm->edata, e->head.data, CD_CREASE);
|
||||
float *bweight = CustomData_bmesh_get(&bm->edata, e->head.data, CD_BWEIGHT);
|
||||
|
||||
med->v1 = BM_elem_index_get(e->v1);
|
||||
med->v2 = BM_elem_index_get(e->v2);
|
||||
med->crease = crease ? (char)((*crease) * 255) : 0;
|
||||
med->bweight = bweight ? (char)((*bweight) * 255) : 0;
|
||||
|
||||
med->flag = BM_edge_flag_to_mflag(e);
|
||||
|
||||
BM_elem_index_set(e, i); /* set_inline */
|
||||
|
||||
/* copy over customdat */
|
||||
CustomData_from_bmesh_block(&bm->edata, &me->edata, e->head.data, i);
|
||||
|
||||
bmesh_quick_edgedraw_flag(med, e);
|
||||
|
||||
i++;
|
||||
med++;
|
||||
BM_CHECK_ELEMENT(bm, e);
|
||||
}
|
||||
bm->elem_index_dirty &= ~BM_EDGE;
|
||||
|
||||
i = 0;
|
||||
j = 0;
|
||||
BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
|
||||
mpoly->loopstart = j;
|
||||
mpoly->totloop = f->len;
|
||||
mpoly->mat_nr = f->mat_nr;
|
||||
mpoly->flag = BM_face_flag_to_mflag(f);
|
||||
|
||||
l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, f);
|
||||
for ( ; l; l = BM_iter_step(&liter), j++, mloop++) {
|
||||
mloop->e = BM_elem_index_get(l->e);
|
||||
mloop->v = BM_elem_index_get(l->v);
|
||||
|
||||
/* copy over customdat */
|
||||
CustomData_from_bmesh_block(&bm->ldata, &me->ldata, l->head.data, j);
|
||||
BM_CHECK_ELEMENT(bm, l);
|
||||
BM_CHECK_ELEMENT(bm, l->e);
|
||||
BM_CHECK_ELEMENT(bm, l->v);
|
||||
}
|
||||
|
||||
if (f == bm->act_face) me->act_face = i;
|
||||
|
||||
/* copy over customdat */
|
||||
CustomData_from_bmesh_block(&bm->pdata, &me->pdata, f->head.data, i);
|
||||
|
||||
i++;
|
||||
mpoly++;
|
||||
BM_CHECK_ELEMENT(bm, f);
|
||||
}
|
||||
|
||||
/* patch hook indices and vertex parents */
|
||||
if (ototvert > 0) {
|
||||
Object *ob;
|
||||
ModifierData *md;
|
||||
BMVert **vertMap = NULL;
|
||||
int i, j;
|
||||
|
||||
for (ob = G.main->object.first; ob; ob = ob->id.next) {
|
||||
if (ob->parent == bm->ob && ELEM(ob->partype, PARVERT1, PARVERT3)) {
|
||||
|
||||
if (vertMap == NULL) {
|
||||
vertMap = bm_to_mesh_vertex_map(bm, ototvert);
|
||||
}
|
||||
|
||||
if (ob->par1 < ototvert) {
|
||||
eve = vertMap[ob->par1];
|
||||
if (eve) ob->par1 = BM_elem_index_get(eve);
|
||||
}
|
||||
if (ob->par2 < ototvert) {
|
||||
eve = vertMap[ob->par2];
|
||||
if (eve) ob->par2 = BM_elem_index_get(eve);
|
||||
}
|
||||
if (ob->par3 < ototvert) {
|
||||
eve = vertMap[ob->par3];
|
||||
if (eve) ob->par3 = BM_elem_index_get(eve);
|
||||
}
|
||||
|
||||
}
|
||||
if (ob->data == me) {
|
||||
for (md = ob->modifiers.first; md; md = md->next) {
|
||||
if (md->type == eModifierType_Hook) {
|
||||
HookModifierData *hmd = (HookModifierData *) md;
|
||||
|
||||
if (vertMap == NULL) {
|
||||
vertMap = bm_to_mesh_vertex_map(bm, ototvert);
|
||||
}
|
||||
|
||||
for (i = j = 0; i < hmd->totindex; i++) {
|
||||
if (hmd->indexar[i] < ototvert) {
|
||||
eve = vertMap[hmd->indexar[i]];
|
||||
|
||||
if (eve) {
|
||||
hmd->indexar[j++] = BM_elem_index_get(eve);
|
||||
}
|
||||
}
|
||||
else j++;
|
||||
}
|
||||
|
||||
hmd->totindex = j;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (vertMap) MEM_freeN(vertMap);
|
||||
}
|
||||
|
||||
if (dotess) {
|
||||
BKE_mesh_tessface_calc(me);
|
||||
}
|
||||
|
||||
mesh_update_customdata_pointers(me, dotess);
|
||||
|
||||
{
|
||||
BMEditSelection *selected;
|
||||
me->totselect = BLI_countlist(&(bm->selected));
|
||||
|
||||
if (me->mselect) MEM_freeN(me->mselect);
|
||||
|
||||
me->mselect = MEM_callocN(sizeof(MSelect) * me->totselect, "Mesh selection history");
|
||||
|
||||
|
||||
for (i = 0, selected = bm->selected.first; selected; i++, selected = selected->next) {
|
||||
if (selected->htype == BM_VERT) {
|
||||
me->mselect[i].type = ME_VSEL;
|
||||
|
||||
}
|
||||
else if (selected->htype == BM_EDGE) {
|
||||
me->mselect[i].type = ME_ESEL;
|
||||
|
||||
}
|
||||
else if (selected->htype == BM_FACE) {
|
||||
me->mselect[i].type = ME_FSEL;
|
||||
}
|
||||
|
||||
me->mselect[i].index = BM_elem_index_get(selected->ele);
|
||||
}
|
||||
}
|
||||
|
||||
/* see comment below, this logic is in twice */
|
||||
|
||||
if (me->key) {
|
||||
KeyBlock *currkey;
|
||||
KeyBlock *actkey = BLI_findlink(&me->key->block, bm->shapenr - 1);
|
||||
|
||||
float (*ofs)[3] = NULL;
|
||||
|
||||
/* go through and find any shapekey customdata layers
|
||||
* that might not have corresponding KeyBlocks, and add them if
|
||||
* necessary */
|
||||
j = 0;
|
||||
for (i = 0; i < bm->vdata.totlayer; i++) {
|
||||
if (bm->vdata.layers[i].type != CD_SHAPEKEY)
|
||||
continue;
|
||||
|
||||
for (currkey = me->key->block.first; currkey; currkey = currkey->next) {
|
||||
if (currkey->uid == bm->vdata.layers[i].uid)
|
||||
break;
|
||||
}
|
||||
|
||||
if (!currkey) {
|
||||
currkey = MEM_callocN(sizeof(KeyBlock), "KeyBlock mesh_conv.c");
|
||||
currkey->type = KEY_LINEAR;
|
||||
currkey->slidermin = 0.0f;
|
||||
currkey->slidermax = 1.0f;
|
||||
|
||||
BLI_addtail(&me->key->block, currkey);
|
||||
me->key->totkey++;
|
||||
}
|
||||
|
||||
j++;
|
||||
}
|
||||
|
||||
|
||||
/* 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 (bm->shapenr - 1 == currkey->relative) {
|
||||
act_is_basis = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (act_is_basis) { /* active key is a base */
|
||||
float (*fp)[3] = actkey->data;
|
||||
int *keyi;
|
||||
i = 0;
|
||||
ofs = MEM_callocN(sizeof(float) * 3 * bm->totvert, "currkey->data");
|
||||
mvert = me->mvert;
|
||||
BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
|
||||
keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
|
||||
if (keyi && *keyi != ORIGINDEX_NONE) {
|
||||
sub_v3_v3v3(ofs[i], mvert->co, fp[*keyi]);
|
||||
}
|
||||
i++;
|
||||
mvert++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
for (currkey = me->key->block.first; currkey; currkey = currkey->next) {
|
||||
j = 0;
|
||||
|
||||
for (i = 0; i < bm->vdata.totlayer; i++) {
|
||||
if (bm->vdata.layers[i].type != CD_SHAPEKEY)
|
||||
continue;
|
||||
|
||||
if (currkey->uid == bm->vdata.layers[i].uid) {
|
||||
int apply_offset = (ofs && (currkey != actkey) && (bm->shapenr - 1 == currkey->relative));
|
||||
float *fp, *co;
|
||||
float (*ofs_pt)[3] = ofs;
|
||||
|
||||
if (currkey->data)
|
||||
MEM_freeN(currkey->data);
|
||||
currkey->data = fp = MEM_mallocN(sizeof(float) * 3 * bm->totvert, "shape key data");
|
||||
currkey->totelem = bm->totvert;
|
||||
|
||||
mvert = me->mvert;
|
||||
BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
|
||||
co = (currkey == actkey) ?
|
||||
eve->co :
|
||||
CustomData_bmesh_get_n(&bm->vdata, eve->head.data, CD_SHAPEKEY, j);
|
||||
|
||||
copy_v3_v3(fp, co);
|
||||
|
||||
/* propagate edited basis offsets to other shapes */
|
||||
if (apply_offset) {
|
||||
add_v3_v3(fp, *ofs_pt++);
|
||||
}
|
||||
|
||||
if (currkey == actkey && oldverts) {
|
||||
keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
|
||||
|
||||
if (*keyi >= 0 && *keyi < currkey->totelem) // valid old vertex
|
||||
copy_v3_v3(mvert->co, oldverts[*keyi].co);
|
||||
|
||||
mvert++;
|
||||
}
|
||||
|
||||
fp += 3;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
j++;
|
||||
}
|
||||
|
||||
/* if we didn't find a shapekey, tag the block to be reconstructed
|
||||
* via the old method below */
|
||||
if (j == CustomData_number_of_layers(&bm->vdata, CD_SHAPEKEY)) {
|
||||
currkey->flag |= KEYBLOCK_MISSING;
|
||||
}
|
||||
}
|
||||
|
||||
if (ofs) MEM_freeN(ofs);
|
||||
}
|
||||
|
||||
/* XXX, code below is from trunk and a duplicate functionality
|
||||
* to the block above.
|
||||
* We should use one or the other, having both means we have to maintain
|
||||
* both and keep them working the same way which is a hassle - campbell */
|
||||
|
||||
/* old method of reconstructing keys via vertice's original key indices,
|
||||
* currently used if the new method above fails (which is theoretically
|
||||
* possible in certain cases of undo) */
|
||||
if (me->key) {
|
||||
float *fp, *newkey, *oldkey;
|
||||
KeyBlock *currkey;
|
||||
KeyBlock *actkey = BLI_findlink(&me->key->block, bm->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 (bm->shapenr - 1 == currkey->relative) {
|
||||
act_is_basis = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (act_is_basis) { /* active key is a base */
|
||||
float (*fp)[3] = actkey->data;
|
||||
int *keyi;
|
||||
i = 0;
|
||||
ofs = MEM_callocN(sizeof(float) * 3 * bm->totvert, "currkey->data");
|
||||
mvert = me->mvert;
|
||||
BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
|
||||
keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
|
||||
if (keyi && *keyi != ORIGINDEX_NONE) {
|
||||
sub_v3_v3v3(ofs[i], mvert->co, fp[*keyi]);
|
||||
}
|
||||
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) && (bm->shapenr - 1 == currkey->relative));
|
||||
|
||||
if (!(currkey->flag & KEYBLOCK_MISSING)) {
|
||||
currkey = currkey->next;
|
||||
continue;
|
||||
}
|
||||
|
||||
printf("warning: had to hackishly reconstruct shape key \"%s\","
|
||||
" it may not be correct anymore.\n", currkey->name);
|
||||
|
||||
currkey->flag &= ~KEYBLOCK_MISSING;
|
||||
|
||||
fp = newkey = MEM_callocN(me->key->elemsize * bm->totvert, "currkey->data");
|
||||
oldkey = currkey->data;
|
||||
|
||||
eve = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL);
|
||||
|
||||
i = 0;
|
||||
mvert = me->mvert;
|
||||
while (eve) {
|
||||
keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
|
||||
if (!keyi) {
|
||||
break;
|
||||
}
|
||||
if (*keyi >= 0 && *keyi < currkey->totelem) { // valid old vertex
|
||||
if (currkey == actkey) {
|
||||
if (actkey == me->key->refkey) {
|
||||
copy_v3_v3(fp, mvert->co);
|
||||
}
|
||||
else {
|
||||
copy_v3_v3(fp, mvert->co);
|
||||
if (oldverts) {
|
||||
copy_v3_v3(mvert->co, oldverts[*keyi].co);
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (oldkey) {
|
||||
copy_v3_v3(fp, oldkey + 3 * *keyi);
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
copy_v3_v3(fp, mvert->co);
|
||||
}
|
||||
|
||||
/* propagate edited basis offsets to other shapes */
|
||||
if (apply_offset) {
|
||||
add_v3_v3(fp, ofs[i]);
|
||||
}
|
||||
|
||||
fp += 3;
|
||||
i++;
|
||||
mvert++;
|
||||
eve = BM_iter_step(&iter);
|
||||
}
|
||||
currkey->totelem = bm->totvert;
|
||||
if (currkey->data) MEM_freeN(currkey->data);
|
||||
currkey->data = newkey;
|
||||
|
||||
currkey = currkey->next;
|
||||
}
|
||||
|
||||
if (ofs) MEM_freeN(ofs);
|
||||
}
|
||||
|
||||
if (oldverts) MEM_freeN(oldverts);
|
||||
BM_mesh_from_bmesh(bm, me, dotess);
|
||||
}
|
||||
|
@ -40,13 +40,36 @@
|
||||
#include "BLI_utildefines.h"
|
||||
|
||||
#include "BKE_tessmesh.h"
|
||||
#include "BKE_depsgraph.h"
|
||||
|
||||
#include "DNA_mesh_types.h"
|
||||
#include "DNA_object_types.h"
|
||||
|
||||
#include "../generic/py_capi_utils.h"
|
||||
|
||||
#include "bmesh_py_api.h" /* own include */
|
||||
|
||||
|
||||
|
||||
PyDoc_STRVAR(bpy_bm_new_doc,
|
||||
".. method:: new()\n"
|
||||
"\n"
|
||||
" :return: Retyrn a new, empty mesh.\n"
|
||||
" :rtype: :class:`BMesh`\n"
|
||||
);
|
||||
|
||||
static PyObject *bpy_bm_new(PyObject *UNUSED(self))
|
||||
{
|
||||
BPy_BMesh *py_bmesh;
|
||||
BMesh *bm;
|
||||
|
||||
bm = BM_mesh_create(NULL, &bm_mesh_allocsize_default);
|
||||
|
||||
py_bmesh = (BPy_BMesh *)BPy_BMesh_CreatePyObject(bm);
|
||||
py_bmesh->py_owns = TRUE;
|
||||
return (PyObject *)py_bmesh;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(bpy_bm_from_mesh_doc,
|
||||
".. method:: from_mesh(mesh)\n"
|
||||
"\n"
|
||||
@ -58,25 +81,77 @@ PyDoc_STRVAR(bpy_bm_from_mesh_doc,
|
||||
|
||||
static PyObject *bpy_bm_from_mesh(PyObject *UNUSED(self), PyObject *value)
|
||||
{
|
||||
BPy_BMesh *py_bmesh;
|
||||
BMesh *bm;
|
||||
Mesh *me = PyC_RNA_AsPointer(value, "Mesh");
|
||||
int py_owns;
|
||||
|
||||
if (me == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (me) {
|
||||
/* temp! */
|
||||
if (!me->edit_btmesh) {
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"Mesh is not in editmode");
|
||||
bm = BM_mesh_create(NULL, &bm_mesh_allocsize_default);
|
||||
BM_mesh_to_bmesh(bm, me, 0, 0); /* BMESH_TODO add args */
|
||||
py_owns = TRUE;
|
||||
}
|
||||
else {
|
||||
bm = me->edit_btmesh->bm;
|
||||
py_owns = FALSE;
|
||||
}
|
||||
|
||||
py_bmesh = (BPy_BMesh *)BPy_BMesh_CreatePyObject(bm);
|
||||
py_bmesh->py_owns = py_owns;
|
||||
return (PyObject *)py_bmesh;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(bpy_bm_to_mesh_doc,
|
||||
".. method:: to_mesh(mesh, bmesh)\n"
|
||||
"\n"
|
||||
" Return a BMesh from this mesh, currently the mesh must already be in editmode.\n"
|
||||
"\n"
|
||||
" :return: the BMesh assosiated with this mesh.\n"
|
||||
" :rtype: :class:`bmesh.types.BMesh`\n"
|
||||
);
|
||||
|
||||
static PyObject *bpy_bm_to_mesh(PyObject *UNUSED(self), PyObject *args)
|
||||
{
|
||||
PyObject *py_mesh;
|
||||
BPy_BMesh *py_bmesh;
|
||||
Mesh *me;
|
||||
BMesh *bm;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "OO!:to_mesh", &py_mesh, &BPy_BMesh_Type, &py_bmesh) ||
|
||||
!(me = PyC_RNA_AsPointer(py_mesh, "Mesh")))
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return BPy_BMesh_CreatePyObject(me->edit_btmesh->bm);
|
||||
}
|
||||
else {
|
||||
BPY_BM_CHECK_OBJ(py_bmesh);
|
||||
|
||||
if (me->edit_btmesh) {
|
||||
PyErr_Format(PyExc_ValueError,
|
||||
"to_mesh(): Mesh '%s' is in editmode", me->id.name + 2);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
bm = py_bmesh->bm;
|
||||
|
||||
BM_mesh_from_bmesh(bm, me, FALSE);
|
||||
|
||||
/* we could have the user do this but if they forget blender can easy crash
|
||||
* since the references arrays for the objects derived meshes are now invalid */
|
||||
DAG_id_tag_update(&me->id, OB_RECALC_DATA);
|
||||
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
|
||||
static struct PyMethodDef BPy_BM_methods[] = {
|
||||
/* THESE NAMES MAY CHANGE! */
|
||||
{"new", (PyCFunction)bpy_bm_new, METH_NOARGS, bpy_bm_new_doc},
|
||||
{"from_mesh", (PyCFunction)bpy_bm_from_mesh, METH_O, bpy_bm_from_mesh_doc},
|
||||
{"to_mesh", (PyCFunction)bpy_bm_to_mesh, METH_VARARGS, bpy_bm_to_mesh_doc},
|
||||
{NULL, NULL, 0, NULL}
|
||||
};
|
||||
|
||||
|
@ -2062,6 +2062,10 @@ static void bpy_bmesh_dealloc(BPy_BMesh *self)
|
||||
bm->py_handle = NULL;
|
||||
}
|
||||
|
||||
if (self->py_owns) {
|
||||
BM_mesh_free(bm);
|
||||
}
|
||||
|
||||
PyObject_DEL(self);
|
||||
}
|
||||
|
||||
|
@ -62,6 +62,7 @@ typedef struct BPy_BMElem {
|
||||
typedef struct BPy_BMesh {
|
||||
PyObject_VAR_HEAD
|
||||
struct BMesh *bm; /* keep first */
|
||||
char py_owns;
|
||||
} BPy_BMesh;
|
||||
|
||||
/* element types */
|
||||
|
Loading…
Reference in New Issue
Block a user