archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Modifier: move edit-mesh calculation from DerivedMesh to Mesh

Browse Source
This commit is contained in:
Campbell Barton
2018-10-09 15:04:51 +11:00
parent 75ac83610b
commit 20fbe6bca8
3 changed files with 146 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/blenkernel/BKE_DerivedMesh.h
View File

@@ -554,7 +554,7 @@ DerivedMesh *editbmesh_get_derived_cage_and_final(
DerivedMesh *object_get_derived_final(struct Object *ob, const bool for_render); DerivedMesh *object_get_derived_final(struct Object *ob, const bool for_render);
float (*editbmesh_get_vertex_cos(struct BMEditMesh *em, int *r_numVerts))[3]; float (*editbmesh_get_vertex_cos(struct BMEditMesh *em, int *r_numVerts))[3];
bool editbmesh_modifier_is_enabled(struct Scene *scene, struct ModifierData *md, DerivedMesh *dm); bool editbmesh_modifier_is_enabled(struct Scene *scene, struct ModifierData *md, bool has_prev_mesh);
void makeDerivedMesh( void makeDerivedMesh(
struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob, struct BMEditMesh *em, struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob, struct BMEditMesh *em,
CustomDataMask dataMask, const bool build_shapekey_layers); CustomDataMask dataMask, const bool build_shapekey_layers);

323
source/blender/blenkernel/intern/DerivedMesh.c
View File

@@ -463,12 +463,6 @@ void DM_ensure_normals(DerivedMesh *dm)
BLI_assert((dm->dirty & DM_DIRTY_NORMALS) == 0); BLI_assert((dm->dirty & DM_DIRTY_NORMALS) == 0);
} }
static void DM_calc_loop_normals(DerivedMesh *dm, const bool use_split_normals, float split_angle)
{
dm->calcLoopNormals(dm, use_split_normals, split_angle);
dm->dirty |= DM_DIRTY_TESS_CDLAYERS;
}
/* note: until all modifiers can take MPoly's as input, /* note: until all modifiers can take MPoly's as input,
* use this at the start of modifiers */ * use this at the start of modifiers */
void DM_ensure_tessface(DerivedMesh *dm) void DM_ensure_tessface(DerivedMesh *dm)
@@ -1169,7 +1163,7 @@ static float (*get_editbmesh_orco_verts(BMEditMesh *em))[3]
} }
/* orco custom data layer */ /* orco custom data layer */
static float (*get_orco_coords_dm(Object *ob, BMEditMesh *em, int layer, int *free))[3] static float (*get_orco_coords(Object *ob, BMEditMesh *em, int layer, int *free))[3]
{ {
*free = 0; *free = 0;
@@ -1200,29 +1194,6 @@ static float (*get_orco_coords_dm(Object *ob, BMEditMesh *em, int layer, int *fr
return NULL; return NULL;
} }
static DerivedMesh *create_orco_dm(Object *ob, Mesh *me, BMEditMesh *em, int layer)
{
DerivedMesh *dm;
float (*orco)[3];
int free;
if (em) {
dm = CDDM_from_editbmesh(em, false, false);
}
else {
dm = CDDM_from_mesh(me);
}
orco = get_orco_coords_dm(ob, em, layer, &free);
if (orco) {
CDDM_apply_vert_coords(dm, orco);
if (free) MEM_freeN(orco);
}
return dm;
}
static Mesh *create_orco_mesh(Object *ob, Mesh *me, BMEditMesh *em, int layer) static Mesh *create_orco_mesh(Object *ob, Mesh *me, BMEditMesh *em, int layer)
{ {
Mesh *mesh; Mesh *mesh;
@@ -1236,7 +1207,7 @@ static Mesh *create_orco_mesh(Object *ob, Mesh *me, BMEditMesh *em, int layer)
mesh = BKE_mesh_copy_for_eval(me, true); mesh = BKE_mesh_copy_for_eval(me, true);
} }
orco = get_orco_coords_dm(ob, em, layer, &free); orco = get_orco_coords(ob, em, layer, &free);
if (orco) { if (orco) {
BKE_mesh_apply_vert_coords(mesh, orco); BKE_mesh_apply_vert_coords(mesh, orco);
@@ -1246,44 +1217,6 @@ static Mesh *create_orco_mesh(Object *ob, Mesh *me, BMEditMesh *em, int layer)
return mesh; return mesh;
} }
static void add_orco_dm(
Object *ob, BMEditMesh *em, DerivedMesh *dm,
DerivedMesh *orcodm, int layer)
{
float (*orco)[3], (*layerorco)[3];
int totvert, free;
totvert = dm->getNumVerts(dm);
if (orcodm) {
orco = MEM_calloc_arrayN(totvert, sizeof(float[3]), "dm orco");
free = 1;
if (orcodm->getNumVerts(orcodm) == totvert)
orcodm->getVertCos(orcodm, orco);
else
dm->getVertCos(dm, orco);
}
else {
/* TODO(sybren): totvert should potentially change here, as ob->data
* or em may have a different number of vertices than dm. */
orco = get_orco_coords_dm(ob, em, layer, &free);
}
if (orco) {
if (layer == CD_ORCO)
BKE_mesh_orco_verts_transform(ob->data, orco, totvert, 0);
if (!(layerorco = DM_get_vert_data_layer(dm, layer))) {
DM_add_vert_layer(dm, layer, CD_CALLOC, NULL);
layerorco = DM_get_vert_data_layer(dm, layer);
}
memcpy(layerorco, orco, sizeof(float) * 3 * totvert);
if (free) MEM_freeN(orco);
}
}
static void add_orco_mesh( static void add_orco_mesh(
Object *ob, BMEditMesh *em, Mesh *mesh, Object *ob, BMEditMesh *em, Mesh *mesh,
Mesh *orco_mesh, int layer) Mesh *orco_mesh, int layer)
@@ -1306,7 +1239,7 @@ static void add_orco_mesh(
else { else {
/* TODO(sybren): totvert should potentially change here, as ob->data /* TODO(sybren): totvert should potentially change here, as ob->data
* or em may have a different number of vertices than dm. */ * or em may have a different number of vertices than dm. */
orco = get_orco_coords_dm(ob, em, layer, &free); orco = get_orco_coords(ob, em, layer, &free);
} }
if (orco) { if (orco) {
@@ -1326,7 +1259,7 @@ static void add_orco_mesh(
} }
} }
static void DM_update_statvis_color(const Scene *scene, Object *ob, DerivedMesh *dm) static void UNUSED_FUNCTION(DM_update_statvis_color)(const Scene *scene, Object *ob, DerivedMesh *dm)
{ {
BMEditMesh *em = BKE_editmesh_from_object(ob); BMEditMesh *em = BKE_editmesh_from_object(ob);
@@ -1433,21 +1366,6 @@ static void UNUSED_FUNCTION(add_shapekey_layers)(DerivedMesh *dm, Mesh *me, Obje
* *
* \note tessfaces should already be calculated. * \note tessfaces should already be calculated.
*/ */
static void dm_ensure_display_normals(DerivedMesh *dm)
{
/* Note: dm *may* have a poly CD_NORMAL layer (generated by a modifier needing poly normals e.g.).
* We do not use it here, though. And it should be tagged as temp!
*/
/* BLI_assert((CustomData_has_layer(&dm->polyData, CD_NORMAL) == false)); */
if ((dm->type == DM_TYPE_CDDM) &&
((dm->dirty & DM_DIRTY_NORMALS) || CustomData_has_layer(&dm->polyData, CD_NORMAL) == false))
{
/* if normals are dirty we want to calculate vertex normals too */
CDDM_calc_normals_mapping_ex(dm, (dm->dirty & DM_DIRTY_NORMALS) ? false : true);
}
}
static void mesh_ensure_display_normals(Mesh *mesh) static void mesh_ensure_display_normals(Mesh *mesh)
{ {
/* Note: mesh *may* have a poly CD_NORMAL layer (generated by a modifier needing poly normals e.g.). /* Note: mesh *may* have a poly CD_NORMAL layer (generated by a modifier needing poly normals e.g.).
@@ -1979,7 +1897,7 @@ float (*editbmesh_get_vertex_cos(BMEditMesh *em, int *r_numVerts))[3]
return cos; return cos;
} }
bool editbmesh_modifier_is_enabled(Scene *scene, ModifierData *md, DerivedMesh *dm) bool editbmesh_modifier_is_enabled(Scene *scene, ModifierData *md, bool has_prev_mesh)
{ {
const ModifierTypeInfo *mti = modifierType_getInfo(md->type); const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode; const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
@@ -1988,7 +1906,7 @@ bool editbmesh_modifier_is_enabled(Scene *scene, ModifierData *md, DerivedMesh *
return false; return false;
} }
if ((mti->flags & eModifierTypeFlag_RequiresOriginalData) && dm) { if ((mti->flags & eModifierTypeFlag_RequiresOriginalData) && has_prev_mesh) {
modifier_setError(md, "Modifier requires original data, bad stack position"); modifier_setError(md, "Modifier requires original data, bad stack position");
return false; return false;
} }
@@ -1996,21 +1914,42 @@ bool editbmesh_modifier_is_enabled(Scene *scene, ModifierData *md, DerivedMesh *
return true; return true;
} }
/* TODO(campbell): support mesh with only an edit-mesh which is lazy initialized. */
static Mesh *mesh_from_editmesh_with_coords(
BMEditMesh *em, CustomDataMask data_mask, float (*vertexCos)[3])
{
Mesh *me = BKE_bmesh_to_mesh_nomain(
em->bm,
&(struct BMeshToMeshParams){
.cd_mask_extra = data_mask,
});
if (vertexCos) {
/* We will own this array in the future. */
BKE_mesh_apply_vert_coords(me, vertexCos);
MEM_freeN(vertexCos);
}
return me;
}
static void editbmesh_calc_modifiers( static void editbmesh_calc_modifiers(
struct Depsgraph *depsgraph, Scene *scene, Object *ob, struct Depsgraph *depsgraph, Scene *scene, Object *ob,
BMEditMesh *em, CustomDataMask dataMask, BMEditMesh *em, CustomDataMask dataMask,
/* return args */ /* return args */
DerivedMesh **r_cage, DerivedMesh **r_final) Mesh **r_cage, Mesh **r_final)
{ {
ModifierData *md; ModifierData *md;
float (*deformedVerts)[3] = NULL; float (*deformedVerts)[3] = NULL;
CustomDataMask mask = 0, append_mask = 0; CustomDataMask mask = 0, append_mask = 0;
DerivedMesh *dm = NULL, *orcodm = NULL; Mesh *me = NULL;
Mesh *me_orco = NULL;
int i, numVerts = 0, cageIndex = modifiers_getCageIndex(scene, ob, NULL, 1); int i, numVerts = 0, cageIndex = modifiers_getCageIndex(scene, ob, NULL, 1);
CDMaskLink *datamasks, *curr; CDMaskLink *datamasks, *curr;
const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode; const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
#if 0
const bool do_init_statvis = false; const bool do_init_statvis = false;
#endif
VirtualModifierData virtualModifierData; VirtualModifierData virtualModifierData;
/* TODO(sybren): do we really need multiple objects, or shall we change the flags where needed? */ /* TODO(sybren): do we really need multiple objects, or shall we change the flags where needed? */
@@ -2019,12 +1958,11 @@ static void editbmesh_calc_modifiers(
const ModifierEvalContext mectx_cache = {depsgraph, ob, MOD_APPLY_USECACHE}; const ModifierEvalContext mectx_cache = {depsgraph, ob, MOD_APPLY_USECACHE};
const bool do_loop_normals = (((Mesh *)(ob->data))->flag & ME_AUTOSMOOTH) != 0; const bool do_loop_normals = (((Mesh *)(ob->data))->flag & ME_AUTOSMOOTH) != 0;
const float loop_normals_split_angle = ((Mesh *)(ob->data))->smoothresh;
modifiers_clearErrors(ob); modifiers_clearErrors(ob);
if (r_cage && cageIndex == -1) { if (r_cage && cageIndex == -1) {
*r_cage = getEditDerivedBMesh(em, ob, dataMask, NULL); *r_cage = mesh_from_editmesh_with_coords(em, dataMask, NULL);
} }
md = modifiers_getVirtualModifierList(ob, &virtualModifierData); md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
@@ -2036,15 +1974,16 @@ static void editbmesh_calc_modifiers(
for (i = 0; md; i++, md = md->next, curr = curr->next) { for (i = 0; md; i++, md = md->next, curr = curr->next) {
const ModifierTypeInfo *mti = modifierType_getInfo(md->type); const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
if (!editbmesh_modifier_is_enabled(scene, md, dm)) { if (!editbmesh_modifier_is_enabled(scene, md, me != NULL)) {
continue; continue;
} }
/* add an orco layer if needed by this modifier */ /* add an orco layer if needed by this modifier */
if (dm && mti->requiredDataMask) { if (me && mti->requiredDataMask) {
mask = mti->requiredDataMask(ob, md); mask = mti->requiredDataMask(ob, md);
if (mask & CD_MASK_ORCO) if (mask & CD_MASK_ORCO) {
add_orco_dm(ob, em, dm, orcodm, CD_ORCO); add_orco_mesh(ob, em, me, me_orco, CD_ORCO);
}
} }
/* How to apply modifier depends on (a) what we already have as /* How to apply modifier depends on (a) what we already have as
@@ -2055,15 +1994,12 @@ static void editbmesh_calc_modifiers(
if (mti->type == eModifierTypeType_OnlyDeform) { if (mti->type == eModifierTypeType_OnlyDeform) {
/* No existing verts to deform, need to build them. */ /* No existing verts to deform, need to build them. */
if (!deformedVerts) { if (!deformedVerts) {
if (dm) { if (me) {
/* Deforming a derived mesh, read the vertex locations /* Deforming a derived mesh, read the vertex locations
* out of the mesh and deform them. Once done with this * out of the mesh and deform them. Once done with this
* run of deformers verts will be written back. * run of deformers verts will be written back.
*/ */
numVerts = dm->getNumVerts(dm); deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
deformedVerts =
MEM_malloc_arrayN(numVerts, sizeof(*deformedVerts), "dfmv");
dm->getVertCos(dm, deformedVerts);
} }
else { else {
deformedVerts = editbmesh_get_vertex_cos(em, &numVerts); deformedVerts = editbmesh_get_vertex_cos(em, &numVerts);
@@ -2071,60 +2007,63 @@ static void editbmesh_calc_modifiers(
} }
if (mti->deformVertsEM) if (mti->deformVertsEM)
modwrap_deformVertsEM_DM_deprecated(md, &mectx, em, dm, deformedVerts, numVerts); modwrap_deformVertsEM(md, &mectx, em, me, deformedVerts, numVerts);
else else
modwrap_deformVerts_DM_deprecated(md, &mectx, dm, deformedVerts, numVerts); modwrap_deformVerts(md, &mectx, me, deformedVerts, numVerts);
} }
else { else {
DerivedMesh *ndm; Mesh *me_next;
/* apply vertex coordinates or build a DerivedMesh as necessary */ /* apply vertex coordinates or build a DerivedMesh as necessary */
if (dm) { if (me) {
if (deformedVerts) { if (deformedVerts) {
DerivedMesh *tdm = CDDM_copy(dm); Mesh *me_temp = BKE_mesh_copy_for_eval(me, false);
if (!(r_cage && dm == *r_cage)) {
dm->release(dm);
}
dm = tdm;
CDDM_apply_vert_coords(dm, deformedVerts); if (!(r_cage && me == *r_cage)) {
BKE_id_free(NULL, me);
}
me = me_temp;
BKE_mesh_apply_vert_coords(me, deformedVerts);
} }
else if (r_cage && dm == *r_cage) { else if (r_cage && me == *r_cage) {
/* dm may be changed by this modifier, so we need to copy it */ /* 'me' may be changed by this modifier, so we need to copy it. */
dm = CDDM_copy(dm); me = BKE_mesh_copy_for_eval(me, false);
} }
} }
else { else {
dm = CDDM_from_editbmesh(em, false, false); me = BKE_bmesh_to_mesh_nomain(em->bm, &(struct BMeshToMeshParams){0});
ASSERT_IS_VALID_DM(dm); ASSERT_IS_VALID_MESH(me);
if (deformedVerts) { if (deformedVerts) {
CDDM_apply_vert_coords(dm, deformedVerts); BKE_mesh_apply_vert_coords(me, deformedVerts);
} }
} }
/* create an orco derivedmesh in parallel */ /* create an orco derivedmesh in parallel */
mask = curr->mask; mask = curr->mask;
if (mask & CD_MASK_ORCO) { if (mask & CD_MASK_ORCO) {
if (!orcodm) if (!me_orco) {
orcodm = create_orco_dm(ob, ob->data, em, CD_ORCO); me_orco = create_orco_mesh(ob, ob->data, em, CD_ORCO);
}
mask &= ~CD_MASK_ORCO; mask &= ~CD_MASK_ORCO;
DM_set_only_copy(orcodm, mask | CD_MASK_ORIGINDEX); mesh_set_only_copy(me_orco, mask | CD_MASK_ORIGINDEX);
if (mti->applyModifierEM) { if (mti->applyModifierEM) {
ndm = modwrap_applyModifierEM_DM_deprecated(md, &mectx_orco, em, orcodm); me_next = modwrap_applyModifierEM(md, &mectx_orco, em, me_orco);
} }
else { else {
ndm = modwrap_applyModifier_DM_deprecated(md, &mectx_orco, orcodm); me_next = modwrap_applyModifier(md, &mectx_orco, me_orco);
} }
ASSERT_IS_VALID_DM(ndm); ASSERT_IS_VALID_MESH(me_next);
if (ndm) { if (me_next) {
/* if the modifier returned a new dm, release the old one */ /* if the modifier returned a new dm, release the old one */
if (orcodm && orcodm != ndm) orcodm->release(orcodm); if (me_orco && me_orco != me_next) {
orcodm = ndm; BKE_id_free(NULL, me_orco);
}
me_orco = me_next;
} }
} }
@@ -2132,52 +2071,53 @@ static void editbmesh_calc_modifiers(
mask |= append_mask; mask |= append_mask;
mask = curr->mask; /* CD_MASK_ORCO may have been cleared above */ mask = curr->mask; /* CD_MASK_ORCO may have been cleared above */
DM_set_only_copy(dm, mask | CD_MASK_ORIGINDEX); mesh_set_only_copy(me, mask | CD_MASK_ORIGINDEX);
if (mask & CD_MASK_ORIGSPACE_MLOOP) { if (mask & CD_MASK_ORIGSPACE_MLOOP) {
if (!CustomData_has_layer(&dm->loopData, CD_ORIGSPACE_MLOOP)) { if (!CustomData_has_layer(&me->ldata, CD_ORIGSPACE_MLOOP)) {
DM_add_loop_layer(dm, CD_ORIGSPACE_MLOOP, CD_CALLOC, NULL); CustomData_add_layer(&me->ldata, CD_ORIGSPACE_MLOOP, CD_CALLOC, NULL, me->totloop);
DM_init_origspace(dm); mesh_init_origspace(me);
} }
} }
if (mti->applyModifierEM) if (mti->applyModifierEM) {
ndm = modwrap_applyModifierEM_DM_deprecated(md, &mectx_cache, em, dm); me_next = modwrap_applyModifierEM(md, &mectx_cache, em, me);
else }
ndm = modwrap_applyModifier_DM_deprecated(md, &mectx_cache, dm); else {
ASSERT_IS_VALID_DM(ndm); me_next = modwrap_applyModifier(md, &mectx_cache, me);
}
ASSERT_IS_VALID_MESH(me_next);
if (ndm) { if (me_next) {
if (dm && dm != ndm) if (me && me != me_next) {
dm->release(dm); BKE_id_free(NULL, me);
}
dm = ndm; me = me_next;
if (deformedVerts) { if (deformedVerts) {
MEM_freeN(deformedVerts); MEM_freeN(deformedVerts);
deformedVerts = NULL; deformedVerts = NULL;
} }
} }
me->runtime.deformed_only = false;
dm->deformedOnly = false;
} }
if (r_cage && i == cageIndex) { if (r_cage && i == cageIndex) {
if (dm && deformedVerts) { if (me && deformedVerts) {
*r_cage = CDDM_copy(dm); *r_cage = BKE_mesh_copy_for_eval(me, false);
CDDM_apply_vert_coords(*r_cage, deformedVerts); BKE_mesh_apply_vert_coords(*r_cage, deformedVerts);
} }
else if (dm) { else if (me) {
*r_cage = dm; *r_cage = me;
} }
else { else {
struct Mesh *mesh = ob->data; struct Mesh *me_orig = ob->data;
if (mesh->id.tag & LIB_TAG_COPIED_ON_WRITE) { if (me_orig->id.tag & LIB_TAG_COPIED_ON_WRITE) {
BKE_mesh_runtime_ensure_edit_data(mesh); BKE_mesh_runtime_ensure_edit_data(me_orig);
mesh->runtime.edit_data->vertexCos = MEM_dupallocN(deformedVerts); me_orig->runtime.edit_data->vertexCos = MEM_dupallocN(deformedVerts);
} }
*r_cage = getEditDerivedBMesh( *r_cage = mesh_from_editmesh_with_coords(
em, ob, mask, em, mask,
deformedVerts ? MEM_dupallocN(deformedVerts) : NULL); deformedVerts ? MEM_dupallocN(deformedVerts) : NULL);
} }
} }
@@ -2189,25 +2129,27 @@ static void editbmesh_calc_modifiers(
* to apply these back onto the DerivedMesh. If we have no DerivedMesh * to apply these back onto the DerivedMesh. If we have no DerivedMesh
* then we need to build one. * then we need to build one.
*/ */
if (dm && deformedVerts) { if (me && deformedVerts) {
*r_final = CDDM_copy(dm); *r_final = BKE_mesh_copy_for_eval(me, false);
if (!(r_cage && dm == *r_cage)) { if (!(r_cage && me == *r_cage)) {
dm->release(dm); BKE_id_free(NULL, me);
} }
BKE_mesh_apply_vert_coords(*r_final, deformedVerts);
CDDM_apply_vert_coords(*r_final, deformedVerts);
} }
else if (dm) { else if (me) {
*r_final = dm; *r_final = me;
} }
else if (!deformedVerts && r_cage && *r_cage) { else if (!deformedVerts && r_cage && *r_cage) {
/* cage should already have up to date normals */ /* cage should already have up to date normals */
*r_final = *r_cage; *r_final = *r_cage;
#if 0
/* In this case, we should never have weight-modifying modifiers in stack... */ /* In this case, we should never have weight-modifying modifiers in stack... */
if (do_init_statvis) if (do_init_statvis) {
DM_update_statvis_color(scene, ob, *r_final); DM_update_statvis_color(scene, ob, *r_final);
}
#endif
} }
else { else {
/* this is just a copy of the editmesh, no need to calc normals */ /* this is just a copy of the editmesh, no need to calc normals */
@@ -2218,19 +2160,24 @@ static void editbmesh_calc_modifiers(
MEM_freeN((void *)mesh->runtime.edit_data->vertexCos); MEM_freeN((void *)mesh->runtime.edit_data->vertexCos);
mesh->runtime.edit_data->vertexCos = MEM_dupallocN(deformedVerts); mesh->runtime.edit_data->vertexCos = MEM_dupallocN(deformedVerts);
} }
*r_final = getEditDerivedBMesh(em, ob, dataMask, deformedVerts); *r_final = mesh_from_editmesh_with_coords(em, dataMask, deformedVerts);
deformedVerts = NULL; deformedVerts = NULL;
#if 0
/* In this case, we should never have weight-modifying modifiers in stack... */ /* In this case, we should never have weight-modifying modifiers in stack... */
if (do_init_statvis) if (do_init_statvis) {
DM_update_statvis_color(scene, ob, *r_final); DM_update_statvis_color(scene, ob, *r_final);
}
#endif
} }
if (do_loop_normals) { if (do_loop_normals) {
/* Compute loop normals */ /* Compute loop normals */
DM_calc_loop_normals(*r_final, do_loop_normals, loop_normals_split_angle); BKE_mesh_calc_normals_split(*r_final);
BKE_mesh_tessface_clear(*r_final);
if (r_cage && *r_cage && (*r_cage != *r_final)) { if (r_cage && *r_cage && (*r_cage != *r_final)) {
DM_calc_loop_normals(*r_cage, do_loop_normals, loop_normals_split_angle); BKE_mesh_calc_normals_split(*r_cage);
BKE_mesh_tessface_clear(*r_cage);
} }
} }
@@ -2239,13 +2186,13 @@ static void editbmesh_calc_modifiers(
* check if the derived meshes are DM_TYPE_EDITBMESH before calling, this isn't essential * check if the derived meshes are DM_TYPE_EDITBMESH before calling, this isn't essential
* but quiets annoying error messages since tessfaces wont be created. */ * but quiets annoying error messages since tessfaces wont be created. */
if (dataMask & CD_MASK_MFACE) { if (dataMask & CD_MASK_MFACE) {
if ((*r_final)->type != DM_TYPE_EDITBMESH) { if ((*r_final)->edit_btmesh == NULL) {
DM_ensure_tessface(*r_final); BKE_mesh_tessface_ensure(*r_final);
} }
if (r_cage && *r_cage) { if (r_cage && *r_cage) {
if ((*r_cage)->type != DM_TYPE_EDITBMESH) { if ((*r_cage)->edit_btmesh == NULL) {
if (*r_cage != *r_final) { if (*r_cage != *r_final) {
DM_ensure_tessface(*r_cage); BKE_mesh_tessface_ensure(*r_cage);
} }
} }
} }
@@ -2254,27 +2201,29 @@ static void editbmesh_calc_modifiers(
/* same as mesh_calc_modifiers (if using loop normals, poly nors have already been computed). */ /* same as mesh_calc_modifiers (if using loop normals, poly nors have already been computed). */
if (!do_loop_normals) { if (!do_loop_normals) {
dm_ensure_display_normals(*r_final); mesh_ensure_display_normals(*r_final);
/* Some modifiers, like datatransfer, may generate those data, we do not want to keep them, /* Some modifiers, like datatransfer, may generate those data, we do not want to keep them,
* as they are used by display code when available (i.e. even if autosmooth is disabled). */ * as they are used by display code when available (i.e. even if autosmooth is disabled). */
if (CustomData_has_layer(&(*r_final)->loopData, CD_NORMAL)) { if (CustomData_has_layer(&(*r_final)->ldata, CD_NORMAL)) {
CustomData_free_layers(&(*r_final)->loopData, CD_NORMAL, (*r_final)->numLoopData); CustomData_free_layers(&(*r_final)->ldata, CD_NORMAL, (*r_final)->totloop);
} }
if (r_cage && CustomData_has_layer(&(*r_cage)->loopData, CD_NORMAL)) { if (r_cage && CustomData_has_layer(&(*r_cage)->ldata, CD_NORMAL)) {
CustomData_free_layers(&(*r_cage)->loopData, CD_NORMAL, (*r_cage)->numLoopData); CustomData_free_layers(&(*r_cage)->ldata, CD_NORMAL, (*r_cage)->totloop);
} }
} }
/* add an orco layer if needed */ /* add an orco layer if needed */
if (dataMask & CD_MASK_ORCO) if (dataMask & CD_MASK_ORCO)
add_orco_dm(ob, em, *r_final, orcodm, CD_ORCO); add_orco_mesh(ob, em, *r_final, me_orco, CD_ORCO);
if (orcodm) if (me_orco) {
orcodm->release(orcodm); BKE_id_free(NULL, me_orco);
}
if (deformedVerts) if (deformedVerts) {
MEM_freeN(deformedVerts); MEM_freeN(deformedVerts);
}
} }
static void mesh_finalize_eval(Object *object) static void mesh_finalize_eval(Object *object)
@@ -2368,9 +2317,23 @@ static void editbmesh_build_data(
BKE_editmesh_free_derivedmesh(em); BKE_editmesh_free_derivedmesh(em);
Mesh *me_cage;
Mesh *me_final;
editbmesh_calc_modifiers( editbmesh_calc_modifiers(
depsgraph, scene, obedit, em, dataMask, depsgraph, scene, obedit, em, dataMask,
&em->derivedCage, &em->derivedFinal); &me_cage, &me_final);
/* TODO(campbell): remove derived mesh conversion. */
em->derivedFinal = CDDM_from_mesh_ex(me_final, CD_DUPLICATE, CD_MASK_MESH);
BKE_id_free(NULL, me_final);
if (me_cage != me_final) {
em->derivedCage = CDDM_from_mesh_ex(me_cage, CD_DUPLICATE, CD_MASK_MESH);
BKE_id_free(NULL, me_cage);
}
else {
em->derivedCage = em->derivedFinal;
}
DM_set_object_boundbox(obedit, em->derivedFinal); DM_set_object_boundbox(obedit, em->derivedFinal);

4
source/blender/blenkernel/intern/crazyspace.c
View File

@@ -274,7 +274,7 @@ int BKE_crazyspace_get_first_deform_matrices_editbmesh(
for (i = 0; md && i <= cageIndex; i++, md = md->next) { for (i = 0; md && i <= cageIndex; i++, md = md->next) {
const ModifierTypeInfo *mti = modifierType_getInfo(md->type); const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
if (!editbmesh_modifier_is_enabled(scene, md, dm)) if (!editbmesh_modifier_is_enabled(scene, md, dm != NULL))
continue; continue;
if (mti->type == eModifierTypeType_OnlyDeform && mti->deformMatricesEM) { if (mti->type == eModifierTypeType_OnlyDeform && mti->deformMatricesEM) {
@@ -300,7 +300,7 @@ int BKE_crazyspace_get_first_deform_matrices_editbmesh(
} }
for (; md && i <= cageIndex; md = md->next, i++) for (; md && i <= cageIndex; md = md->next, i++)
if (editbmesh_modifier_is_enabled(scene, md, dm) && modifier_isCorrectableDeformed(md)) if (editbmesh_modifier_is_enabled(scene, md, dm != NULL) && modifier_isCorrectableDeformed(md))
numleft++; numleft++;
if (dm) if (dm)