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

Cleanup: naming

Browse Source 
- mesh_calc_modifiers & editbmesh_calc_modifiers
  now follow similar naming.
- me and mesh were too easily confused in mesh_calc_modifiers
  (remove 'me', access ob->data).
This commit is contained in:
Campbell Barton
2018-10-10 15:00:37 +11:00
parent 58a41df51e
commit 62020eddec
1 changed files with 99 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1220,18 +1220,18 @@ static Mesh *create_orco_mesh(Object *ob, Mesh *me, BMEditMesh *em, int layer)
static void add_orco_mesh(
Object *ob, BMEditMesh *em, Mesh *mesh,
Mesh *orco_mesh, int layer)
Mesh *me_orco, int layer)
{
float (*orco)[3], (*layerorco)[3];
int totvert, free;
totvert = mesh->totvert;
if (orco_mesh) {
if (me_orco) {
free = 1;
if (orco_mesh->totvert == totvert) {
orco = BKE_mesh_vertexCos_get(orco_mesh, NULL);
if (me_orco->totvert == totvert) {
orco = BKE_mesh_vertexCos_get(me_orco, NULL);
}
else {
orco = BKE_mesh_vertexCos_get(mesh, NULL);
@@ -1400,15 +1400,14 @@ static void mesh_calc_modifiers(
const bool need_mapping, CustomDataMask dataMask,
const int index, const bool useCache, const bool build_shapekey_layers,
/* return args */
Mesh **r_deform_mesh, Mesh **r_final_mesh)
Mesh **r_deform, Mesh **r_final)
{
Mesh *me = ob->data;
ModifierData *firstmd, *md, *previewmd = NULL;
CDMaskLink *datamasks, *curr;
/* XXX Always copying POLYINDEX, else tessellated data are no more valid! */
CustomDataMask mask, nextmask, previewmask = 0, append_mask = CD_MASK_ORIGINDEX;
float (*deformedVerts)[3] = NULL;
int numVerts = me->totvert;
int numVerts = ((Mesh *)ob->data)->totvert;
const bool useRenderParams = (DEG_get_mode(depsgraph) == DAG_EVAL_RENDER);
const int required_mode = useRenderParams ? eModifierMode_Render : eModifierMode_Realtime;
bool isPrevDeform = false;
@@ -1420,14 +1419,14 @@ static void mesh_calc_modifiers(
/* Generic preview only in object mode! */
const bool do_mod_mcol = (ob->mode == OB_MODE_OBJECT);
const bool do_loop_normals = (me->flag & ME_AUTOSMOOTH) != 0;
const bool do_loop_normals = (((Mesh *)ob->data)->flag & ME_AUTOSMOOTH) != 0;
VirtualModifierData virtualModifierData;
ModifierApplyFlag app_flags = useRenderParams ? MOD_APPLY_RENDER : 0;
ModifierApplyFlag deform_app_flags = app_flags;
BLI_assert((me->id.tag & LIB_TAG_COPIED_ON_WRITE_EVAL_RESULT) == 0);
BLI_assert((((Mesh *)ob->data)->id.tag & LIB_TAG_COPIED_ON_WRITE_EVAL_RESULT) == 0);
if (useCache)
app_flags |= MOD_APPLY_USECACHE;
@@ -1455,10 +1454,10 @@ static void mesh_calc_modifiers(
datamasks = modifiers_calcDataMasks(scene, ob, md, dataMask, required_mode, previewmd, previewmask);
curr = datamasks;
if (r_deform_mesh) {
*r_deform_mesh = NULL;
if (r_deform) {
*r_deform = NULL;
}
*r_final_mesh = NULL;
*r_final = NULL;
if (useDeform) {
if (inputVertexCos)
@@ -1478,7 +1477,7 @@ static void mesh_calc_modifiers(
if (mti->type == eModifierTypeType_OnlyDeform && !sculpt_dyntopo) {
if (!deformedVerts)
deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
deformedVerts = BKE_mesh_vertexCos_get(ob->data, &numVerts);
modwrap_deformVerts(md, &mectx_deform, NULL, deformedVerts, numVerts);
}
@@ -1495,17 +1494,17 @@ static void mesh_calc_modifiers(
* places that wish to use the original mesh but with deformed
* coordinates (vpaint, etc.)
*/
if (r_deform_mesh) {
*r_deform_mesh = BKE_mesh_copy_for_eval(me, true);
if (r_deform) {
*r_deform = BKE_mesh_copy_for_eval(ob->data, true);
/* XXX: Is build_shapekey_layers ever even true? This should have crashed long ago... */
BLI_assert(!build_shapekey_layers);
if (build_shapekey_layers) {
add_shapekey_layers(*r_deform_mesh, me, ob);
add_shapekey_layers(*r_deform, ob->data, ob);
}
if (deformedVerts) {
BKE_mesh_apply_vert_coords(*r_deform_mesh, deformedVerts);
BKE_mesh_apply_vert_coords(*r_deform, deformedVerts);
}
}
}
@@ -1514,16 +1513,16 @@ static void mesh_calc_modifiers(
if (inputVertexCos)
deformedVerts = inputVertexCos;
else
deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
deformedVerts = BKE_mesh_vertexCos_get(ob->data, &numVerts);
}
/* Now apply all remaining modifiers. If useDeform is off then skip
* OnlyDeform ones.
*/
Mesh *mesh = NULL;
Mesh *orco_mesh = NULL;
Mesh *cloth_orco_mesh = NULL;
Mesh *me = NULL;
Mesh *me_orco = NULL;
Mesh *me_orco_cloth = NULL;
for (; md; md = md->next, curr = curr->next) {
const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
@@ -1536,7 +1535,7 @@ static void mesh_calc_modifiers(
continue;
}
if ((mti->flags & eModifierTypeFlag_RequiresOriginalData) && mesh) {
if ((mti->flags & eModifierTypeFlag_RequiresOriginalData) && me) {
modifier_setError(md, "Modifier requires original data, bad stack position");
continue;
}
@@ -1587,8 +1586,8 @@ static void mesh_calc_modifiers(
else
mask = 0;
if (mesh && (mask & CD_MASK_ORCO)) {
add_orco_mesh(ob, NULL, mesh, orco_mesh, CD_ORCO);
if (me && (mask & CD_MASK_ORCO)) {
add_orco_mesh(ob, NULL, me, me_orco, CD_ORCO);
}
/* How to apply modifier depends on (a) what we already have as
@@ -1599,15 +1598,15 @@ static void mesh_calc_modifiers(
if (mti->type == eModifierTypeType_OnlyDeform) {
/* No existing verts to deform, need to build them. */
if (!deformedVerts) {
if (mesh) {
if (me) {
/* Deforming a mesh, read the vertex locations
* out of the mesh and deform them. Once done with this
* run of deformers verts will be written back.
*/
deformedVerts = BKE_mesh_vertexCos_get(mesh, &numVerts);
deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
}
else {
deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
deformedVerts = BKE_mesh_vertexCos_get(ob->data, &numVerts);
}
}
@@ -1615,12 +1614,12 @@ static void mesh_calc_modifiers(
* to avoid giving bogus normals to the next modifier see: [#23673] */
if (isPrevDeform && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
/* XXX, this covers bug #23673, but we may need normal calc for other types */
if (mesh) {
BKE_mesh_apply_vert_coords(mesh, deformedVerts);
if (me) {
BKE_mesh_apply_vert_coords(me, deformedVerts);
}
}
modwrap_deformVerts(md, &mectx_deform, mesh, deformedVerts, numVerts);
modwrap_deformVerts(md, &mectx_deform, me, deformedVerts, numVerts);
}
else {
/* determine which data layers are needed by following modifiers */
@@ -1630,21 +1629,21 @@ static void mesh_calc_modifiers(
nextmask = dataMask;
/* apply vertex coordinates or build a Mesh as necessary */
if (mesh) {
if (me) {
if (deformedVerts) {
BKE_mesh_apply_vert_coords(mesh, deformedVerts);
BKE_mesh_apply_vert_coords(me, deformedVerts);
}
}
else {
mesh = BKE_mesh_copy_for_eval(me, true);
ASSERT_IS_VALID_MESH(mesh);
me = BKE_mesh_copy_for_eval(ob->data, true);
ASSERT_IS_VALID_MESH(me);
if (build_shapekey_layers) {
add_shapekey_layers(mesh, me, ob);
add_shapekey_layers(me, ob->data, ob);
}
if (deformedVerts) {
BKE_mesh_apply_vert_coords(mesh, deformedVerts);
BKE_mesh_apply_vert_coords(me, deformedVerts);
}
/* Constructive modifiers need to have an origindex
@@ -1656,14 +1655,14 @@ static void mesh_calc_modifiers(
*/
if (need_mapping || (nextmask & CD_MASK_ORIGINDEX)) {
/* calc */
CustomData_add_layer(&mesh->vdata, CD_ORIGINDEX, CD_CALLOC, NULL, mesh->totvert);
CustomData_add_layer(&mesh->edata, CD_ORIGINDEX, CD_CALLOC, NULL, mesh->totedge);
CustomData_add_layer(&mesh->pdata, CD_ORIGINDEX, CD_CALLOC, NULL, mesh->totpoly);
CustomData_add_layer(&me->vdata, CD_ORIGINDEX, CD_CALLOC, NULL, me->totvert);
CustomData_add_layer(&me->edata, CD_ORIGINDEX, CD_CALLOC, NULL, me->totedge);
CustomData_add_layer(&me->pdata, CD_ORIGINDEX, CD_CALLOC, NULL, me->totpoly);
/* Not worth parallelizing this, gives less than 0.1% overall speedup in best of best cases... */
range_vn_i(CustomData_get_layer(&mesh->vdata, CD_ORIGINDEX), mesh->totvert, 0);
range_vn_i(CustomData_get_layer(&mesh->edata, CD_ORIGINDEX), mesh->totedge, 0);
range_vn_i(CustomData_get_layer(&mesh->pdata, CD_ORIGINDEX), mesh->totpoly, 0);
range_vn_i(CustomData_get_layer(&me->vdata, CD_ORIGINDEX), me->totvert, 0);
range_vn_i(CustomData_get_layer(&me->edata, CD_ORIGINDEX), me->totedge, 0);
range_vn_i(CustomData_get_layer(&me->pdata, CD_ORIGINDEX), me->totpoly, 0);
}
}
@@ -1673,85 +1672,84 @@ static void mesh_calc_modifiers(
/* needMapping check here fixes bug [#28112], otherwise it's
* possible that it won't be copied */
mask |= append_mask;
mesh_set_only_copy(mesh, mask | (need_mapping ? CD_MASK_ORIGINDEX : 0));
mesh_set_only_copy(me, mask | (need_mapping ? CD_MASK_ORIGINDEX : 0));
/* add cloth rest shape key if needed */
if (mask & CD_MASK_CLOTH_ORCO)
add_orco_mesh(ob, NULL, mesh, orco_mesh, CD_CLOTH_ORCO);
add_orco_mesh(ob, NULL, me, me_orco, CD_CLOTH_ORCO);
/* add an origspace layer if needed */
if ((curr->mask) & CD_MASK_ORIGSPACE_MLOOP) {
if (!CustomData_has_layer(&mesh->ldata, CD_ORIGSPACE_MLOOP)) {
CustomData_add_layer(&mesh->ldata, CD_ORIGSPACE_MLOOP, CD_CALLOC, NULL, mesh->totloop);
mesh_init_origspace(mesh);
if (!CustomData_has_layer(&me->ldata, CD_ORIGSPACE_MLOOP)) {
CustomData_add_layer(&me->ldata, CD_ORIGSPACE_MLOOP, CD_CALLOC, NULL, me->totloop);
mesh_init_origspace(me);
}
}
Mesh *new_mesh = modwrap_applyModifier(md, &mectx_apply, mesh);
ASSERT_IS_VALID_MESH(new_mesh);
Mesh *me_next = modwrap_applyModifier(md, &mectx_apply, me);
ASSERT_IS_VALID_MESH(me_next);
if (new_mesh) {
if (me_next) {
/* if the modifier returned a new mesh, release the old one */
if (mesh && mesh != new_mesh) {
BLI_assert(mesh != me);
BKE_id_free(NULL, mesh);
if (me && me != me_next) {
BLI_assert(me != ob->data);
BKE_id_free(NULL, me);
}
mesh = new_mesh;
me = me_next;
if (deformedVerts) {
if (deformedVerts != inputVertexCos)
if (deformedVerts != inputVertexCos) {
MEM_freeN(deformedVerts);
}
deformedVerts = NULL;
}
}
/* create an orco mesh in parallel */
if (nextmask & CD_MASK_ORCO) {
if (!orco_mesh) {
orco_mesh = create_orco_mesh(ob, me, NULL, CD_ORCO);
if (!me_orco) {
me_orco = create_orco_mesh(ob, ob->data, NULL, CD_ORCO);
}
nextmask &= ~CD_MASK_ORCO;
mesh_set_only_copy(orco_mesh, nextmask | CD_MASK_ORIGINDEX |
mesh_set_only_copy(me_orco, nextmask | CD_MASK_ORIGINDEX |
(mti->requiredDataMask ?
mti->requiredDataMask(ob, md) : 0));
new_mesh = modwrap_applyModifier(md, &mectx_orco, orco_mesh);
ASSERT_IS_VALID_MESH(new_mesh);
me_next = modwrap_applyModifier(md, &mectx_orco, me_orco);
ASSERT_IS_VALID_MESH(me_next);
if (new_mesh) {
if (me_next) {
/* if the modifier returned a new mesh, release the old one */
if (orco_mesh && orco_mesh != new_mesh) {
BLI_assert(orco_mesh != me);
BKE_id_free(NULL, orco_mesh);
if (me_orco && me_orco != me_next) {
BLI_assert(me_orco != ob->data);
BKE_id_free(NULL, me_orco);
}
orco_mesh = new_mesh;
me_orco = me_next;
}
}
/* create cloth orco mesh in parallel */
if (nextmask & CD_MASK_CLOTH_ORCO) {
if (!cloth_orco_mesh) {
cloth_orco_mesh = create_orco_mesh(ob, me, NULL, CD_CLOTH_ORCO);
if (!me_orco_cloth) {
me_orco_cloth = create_orco_mesh(ob, ob->data, NULL, CD_CLOTH_ORCO);
}
nextmask &= ~CD_MASK_CLOTH_ORCO;
mesh_set_only_copy(cloth_orco_mesh, nextmask | CD_MASK_ORIGINDEX);
mesh_set_only_copy(me_orco_cloth, nextmask | CD_MASK_ORIGINDEX);
new_mesh = modwrap_applyModifier(md, &mectx_orco, cloth_orco_mesh);
ASSERT_IS_VALID_DM(new_mesh);
me_next = modwrap_applyModifier(md, &mectx_orco, me_orco_cloth);
ASSERT_IS_VALID_DM(me_next);
if (new_mesh) {
if (me_next) {
/* if the modifier returned a new mesh, release the old one */
if (cloth_orco_mesh && cloth_orco_mesh != new_mesh) {
BLI_assert(orco_mesh != me);
BKE_id_free(NULL, cloth_orco_mesh);
if (me_orco_cloth && me_orco_cloth != me_next) {
BLI_assert(me_orco != ob->data);
BKE_id_free(NULL, me_orco_cloth);
}
cloth_orco_mesh = new_mesh;
me_orco_cloth = me_next;
}
}
@@ -1760,7 +1758,7 @@ static void mesh_calc_modifiers(
if (md->type == eModifierType_DynamicPaint)
append_mask |= CD_MASK_PREVIEW_MLOOPCOL;
mesh->runtime.deformed_only = false;
me->runtime.deformed_only = false;
}
isPrevDeform = (mti->type == eModifierTypeType_OnlyDeform);
@@ -1781,45 +1779,43 @@ static void mesh_calc_modifiers(
* need to apply these back onto the Mesh. If we have no
* Mesh then we need to build one.
*/
Mesh *final_mesh;
if (mesh) {
final_mesh = mesh;
if (me) {
*r_final = me;
if (deformedVerts) {
BKE_mesh_apply_vert_coords(final_mesh, deformedVerts);
BKE_mesh_apply_vert_coords(*r_final, deformedVerts);
}
}
else {
final_mesh = BKE_mesh_copy_for_eval(me, true);
*r_final = BKE_mesh_copy_for_eval(ob->data, true);
if (build_shapekey_layers) {
add_shapekey_layers(final_mesh, me, ob);
add_shapekey_layers(*r_final, ob->data, ob);
}
if (deformedVerts) {
BKE_mesh_apply_vert_coords(final_mesh, deformedVerts);
BKE_mesh_apply_vert_coords(*r_final, deformedVerts);
}
}
/* add an orco layer if needed */
if (dataMask & CD_MASK_ORCO) {
add_orco_mesh(ob, NULL, final_mesh, orco_mesh, CD_ORCO);
add_orco_mesh(ob, NULL, *r_final, me_orco, CD_ORCO);
if (r_deform_mesh && *r_deform_mesh)
add_orco_mesh(ob, NULL, *r_deform_mesh, NULL, CD_ORCO);
if (r_deform && *r_deform)
add_orco_mesh(ob, NULL, *r_deform, NULL, CD_ORCO);
}
if (do_loop_normals) {
/* Compute loop normals (note: will compute poly and vert normals as well, if needed!) */
BKE_mesh_calc_normals_split(final_mesh);
BKE_mesh_tessface_clear(final_mesh);
BKE_mesh_calc_normals_split(*r_final);
BKE_mesh_tessface_clear(*r_final);
}
if (sculpt_dyntopo == false) {
/* watch this! after 2.75a we move to from tessface to looptri (by default) */
if (dataMask & CD_MASK_MFACE) {
BKE_mesh_tessface_ensure(final_mesh);
BKE_mesh_tessface_ensure(*r_final);
}
/* without this, drawing ngon tri's faces will show ugly tessellated face
@@ -1832,23 +1828,21 @@ static void mesh_calc_modifiers(
* If using loop normals, poly nors have already been computed.
*/
if (!do_loop_normals) {
mesh_ensure_display_normals(final_mesh);
mesh_ensure_display_normals(*r_final);
}
}
/* Some modifiers, like datatransfer, may generate those data as temp layer, we do not want to keep them,
* as they are used by display code when available (i.e. even if autosmooth is disabled). */
if (!do_loop_normals && CustomData_has_layer(&final_mesh->ldata, CD_NORMAL)) {
CustomData_free_layers(&final_mesh->ldata, CD_NORMAL, final_mesh->totloop);
if (!do_loop_normals && CustomData_has_layer(&(*r_final)->ldata, CD_NORMAL)) {
CustomData_free_layers(&(*r_final)->ldata, CD_NORMAL, (*r_final)->totloop);
}
*r_final_mesh = final_mesh;
if (orco_mesh) {
BKE_id_free(NULL, orco_mesh);
if (me_orco) {
BKE_id_free(NULL, me_orco);
}
if (cloth_orco_mesh) {
BKE_id_free(NULL, cloth_orco_mesh);
if (me_orco_cloth) {
BKE_id_free(NULL, me_orco_cloth);
}
if (deformedVerts && deformedVerts != inputVertexCos)
@@ -1925,8 +1919,6 @@ static void editbmesh_calc_modifiers(
ModifierData *md;
float (*deformedVerts)[3] = NULL;
CustomDataMask mask = 0, append_mask = 0;
Mesh *me = NULL;
Mesh *me_orco = NULL;
int i, numVerts = 0, cageIndex = modifiers_getCageIndex(scene, ob, NULL, 1);
CDMaskLink *datamasks, *curr;
const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
@@ -1952,6 +1944,10 @@ static void editbmesh_calc_modifiers(
datamasks = modifiers_calcDataMasks(scene, ob, md, dataMask, required_mode, NULL, 0);
curr = datamasks;
Mesh *me = NULL;
Mesh *me_orco = NULL;
for (i = 0; md; i++, md = md->next, curr = curr->next) {
const ModifierTypeInfo *mti = modifierType_getInfo(md->type);