tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity

Cleanup: Rename mesh face deformed edit position variables 

Use standard naming similar to their `Mesh` counterparts.
This commit is contained in:
Hans Goudey 2024-03-28 18:25:24 -04:00
parent 72347f11fe
commit 931206d3dc
10 changed files with 61 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
source/blender/blenkernel/BKE_editmesh_cache.hh
View File

@ -18,13 +18,13 @@ namespace blender::bke {
struct EditMeshData {
/** when set, \a vertexNos, faceNos are lazy initialized */
Array<float3> vertexCos;
Array<float3> vert_positions;
/** lazy initialize (when \a vertexCos is set) */
Array<float3> vertexNos;
Array<float3> faceNos;
/** also lazy init but don't depend on \a vertexCos */
Array<float3> faceCos;
/** lazy initialize (when \a vert_positions is set) */
Array<float3> vert_normals;
Array<float3> face_normals;
/** also lazy init but don't depend on \a vert_positions */
Array<float3> face_centers;
};
} // namespace blender::bke

4
source/blender/blenkernel/BKE_modifier.hh
View File

@ -200,8 +200,8 @@ struct ModifierTypeInfo {
/********************* Deform modifier functions *********************/
/**
* Apply a deformation to the positions in the \a vertexCos array. If the \a mesh argument is
* non-null, if will contain proper (not wrapped) mesh data. The \a vertexCos array may or may
* Apply a deformation to the positions in the \a positions array. If the \a mesh argument is
* non-null, if will contain proper (not wrapped) mesh data. The \a positions array may or may
* not be the same as the mesh's position attribute.
*/
void (*deform_verts)(ModifierData *md,

8
source/blender/blenkernel/intern/DerivedMesh.cc
View File

@ -1022,7 +1022,7 @@ static void editbmesh_calc_modifier_final_normals(Mesh *mesh_final)
case ME_WRAPPER_TYPE_BMESH: {
BMEditMesh &em = *mesh_final->runtime->edit_mesh;
blender::bke::EditMeshData &emd = *mesh_final->runtime->edit_data;
if (!emd.vertexCos.is_empty()) {
if (!emd.vert_positions.is_empty()) {
BKE_editmesh_cache_ensure_vert_normals(em, emd);
BKE_editmesh_cache_ensure_face_normals(em, emd);
}
@ -1047,11 +1047,11 @@ static MutableSpan<float3> mesh_wrapper_vert_coords_ensure_for_write(Mesh *mesh)
{
switch (mesh->runtime->wrapper_type) {
case ME_WRAPPER_TYPE_BMESH:
if (mesh->runtime->edit_data->vertexCos.is_empty()) {
mesh->runtime->edit_data->vertexCos = editbmesh_vert_coords_alloc(
if (mesh->runtime->edit_data->vert_positions.is_empty()) {
mesh->runtime->edit_data->vert_positions = editbmesh_vert_coords_alloc(
mesh->runtime->edit_mesh);
}
return mesh->runtime->edit_data->vertexCos;
return mesh->runtime->edit_data->vert_positions;
case ME_WRAPPER_TYPE_MDATA:
case ME_WRAPPER_TYPE_SUBD:
return mesh->vert_positions_for_write();

34
source/blender/blenkernel/intern/editmesh_cache.cc
View File

@ -23,12 +23,12 @@
void BKE_editmesh_cache_ensure_face_normals(BMEditMesh &em, blender::bke::EditMeshData &emd)
{
if (emd.vertexCos.is_empty() || !emd.faceNos.is_empty()) {
if (emd.vert_positions.is_empty() || !emd.face_normals.is_empty()) {
return;
}
BMesh *bm = em.bm;
emd.faceNos.reinitialize(bm->totface);
emd.face_normals.reinitialize(bm->totface);
BM_mesh_elem_index_ensure(bm, BM_VERT);
BMFace *efa;
@ -36,15 +36,17 @@ void BKE_editmesh_cache_ensure_face_normals(BMEditMesh &em, blender::bke::EditMe
int i;
BM_ITER_MESH_INDEX (efa, &fiter, bm, BM_FACES_OF_MESH, i) {
BM_elem_index_set(efa, i); /* set_inline */
BM_face_calc_normal_vcos(
bm, efa, emd.faceNos[i], reinterpret_cast<const float(*)[3]>(emd.vertexCos.data()));
BM_face_calc_normal_vcos(bm,
efa,
emd.face_normals[i],
reinterpret_cast<const float(*)[3]>(emd.vert_positions.data()));
}
bm->elem_index_dirty &= ~BM_FACE;
}
void BKE_editmesh_cache_ensure_vert_normals(BMEditMesh &em, blender::bke::EditMeshData &emd)
{
if (emd.vertexCos.is_empty() || !emd.vertexNos.is_empty()) {
if (emd.vert_positions.is_empty() || !emd.vert_normals.is_empty()) {
return;
}
BMesh *bm = em.bm;
@ -52,36 +54,36 @@ void BKE_editmesh_cache_ensure_vert_normals(BMEditMesh &em, blender::bke::EditMe
/* Calculate vertex normals from face normals. */
BKE_editmesh_cache_ensure_face_normals(em, emd);
emd.vertexNos.reinitialize(bm->totvert);
emd.vert_normals.reinitialize(bm->totvert);
BM_mesh_elem_index_ensure(bm, BM_FACE);
BM_verts_calc_normal_vcos(bm,
reinterpret_cast<const float(*)[3]>(emd.faceNos.data()),
reinterpret_cast<const float(*)[3]>(emd.vertexCos.data()),
reinterpret_cast<float(*)[3]>(emd.vertexNos.data()));
reinterpret_cast<const float(*)[3]>(emd.face_normals.data()),
reinterpret_cast<const float(*)[3]>(emd.vert_positions.data()),
reinterpret_cast<float(*)[3]>(emd.vert_normals.data()));
}
void BKE_editmesh_cache_ensure_face_centers(BMEditMesh &em, blender::bke::EditMeshData &emd)
{
if (!emd.faceCos.is_empty()) {
if (!emd.face_centers.is_empty()) {
return;
}
BMesh *bm = em.bm;
emd.faceCos.reinitialize(bm->totface);
emd.face_centers.reinitialize(bm->totface);
BMFace *efa;
BMIter fiter;
int i;
if (emd.vertexCos.is_empty()) {
if (emd.vert_positions.is_empty()) {
BM_ITER_MESH_INDEX (efa, &fiter, bm, BM_FACES_OF_MESH, i) {
BM_face_calc_center_median(efa, emd.faceCos[i]);
BM_face_calc_center_median(efa, emd.face_centers[i]);
}
}
else {
BM_mesh_elem_index_ensure(bm, BM_VERT);
BM_ITER_MESH_INDEX (efa, &fiter, bm, BM_FACES_OF_MESH, i) {
BM_face_calc_center_median_vcos(bm, efa, emd.faceCos[i], emd.vertexCos);
BM_face_calc_center_median_vcos(bm, efa, emd.face_centers[i], emd.vert_positions);
}
}
}
@ -101,7 +103,7 @@ std::optional<blender::Bounds<blender::float3>> BKE_editmesh_cache_calc_minmax(
return std::nullopt;
}
if (emd.vertexCos.is_empty()) {
if (emd.vert_positions.is_empty()) {
BMVert *eve;
BMIter iter;
float3 min(std::numeric_limits<float>::max());
@ -112,7 +114,7 @@ std::optional<blender::Bounds<blender::float3>> BKE_editmesh_cache_calc_minmax(
return Bounds<float3>{min, max};
}
return bounds::min_max(emd.vertexCos.as_span());
return bounds::min_max(emd.vert_positions.as_span());
}
/** \} */

16
source/blender/blenkernel/intern/mesh_iterators.cc
View File

@ -41,12 +41,12 @@ void BKE_mesh_foreach_mapped_vert(
BMIter iter;
BMVert *eve;
int i;
if (!mesh->runtime->edit_data->vertexCos.is_empty()) {
const blender::Span<blender::float3> positions = mesh->runtime->edit_data->vertexCos;
if (!mesh->runtime->edit_data->vert_positions.is_empty()) {
const blender::Span<blender::float3> positions = mesh->runtime->edit_data->vert_positions;
blender::Span<blender::float3> vert_normals;
if (flag & MESH_FOREACH_USE_NORMAL) {
BKE_editmesh_cache_ensure_vert_normals(*em, *mesh->runtime->edit_data);
vert_normals = mesh->runtime->edit_data->vertexNos;
vert_normals = mesh->runtime->edit_data->vert_normals;
}
BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
const float *no = (flag & MESH_FOREACH_USE_NORMAL) ? &vert_normals[i].x : nullptr;
@ -100,8 +100,8 @@ void BKE_mesh_foreach_mapped_edge(
BMIter iter;
BMEdge *eed;
int i;
if (!mesh->runtime->edit_data->vertexCos.is_empty()) {
const blender::Span<blender::float3> positions = mesh->runtime->edit_data->vertexCos;
if (!mesh->runtime->edit_data->vert_positions.is_empty()) {
const blender::Span<blender::float3> positions = mesh->runtime->edit_data->vert_positions;
BM_mesh_elem_index_ensure(bm, BM_VERT);
BM_ITER_MESH_INDEX (eed, &iter, bm, BM_EDGES_OF_MESH, i) {
func(user_data,
@ -159,7 +159,7 @@ void BKE_mesh_foreach_mapped_loop(Mesh *mesh,
BMIter iter;
BMFace *efa;
const blender::Span<blender::float3> positions = mesh->runtime->edit_data->vertexCos;
const blender::Span<blender::float3> positions = mesh->runtime->edit_data->vert_positions;
/* XXX: investigate using EditMesh data. */
blender::Span<blender::float3> corner_normals;
@ -243,11 +243,11 @@ void BKE_mesh_foreach_mapped_face_center(
int i;
BKE_editmesh_cache_ensure_face_centers(*em, *mesh->runtime->edit_data);
face_centers = mesh->runtime->edit_data->faceCos; /* always set */
face_centers = mesh->runtime->edit_data->face_centers; /* always set */
if (flag & MESH_FOREACH_USE_NORMAL) {
BKE_editmesh_cache_ensure_face_normals(*em, *mesh->runtime->edit_data);
face_normals = mesh->runtime->edit_data->faceNos; /* maybe nullptr */
face_normals = mesh->runtime->edit_data->face_normals; /* maybe nullptr */
}
if (!face_normals.is_empty()) {

22
source/blender/blenkernel/intern/mesh_wrapper.cc
View File

@ -124,8 +124,8 @@ void BKE_mesh_wrapper_ensure_mdata(Mesh *mesh)
BKE_mesh_ensure_default_orig_index_customdata_no_check(mesh);
blender::bke::EditMeshData &edit_data = *mesh->runtime->edit_data;
if (!edit_data.vertexCos.is_empty()) {
mesh->vert_positions_for_write().copy_from(edit_data.vertexCos);
if (!edit_data.vert_positions.is_empty()) {
mesh->vert_positions_for_write().copy_from(edit_data.vert_positions);
mesh->runtime->is_original_bmesh = false;
}
@ -152,7 +152,7 @@ Span<float3> BKE_mesh_wrapper_vert_coords(const Mesh *mesh)
{
switch (mesh->runtime->wrapper_type) {
case ME_WRAPPER_TYPE_BMESH:
return mesh->runtime->edit_data->vertexCos;
return mesh->runtime->edit_data->vert_positions;
case ME_WRAPPER_TYPE_MDATA:
case ME_WRAPPER_TYPE_SUBD:
return mesh->vert_positions();
@ -166,7 +166,7 @@ Span<float3> BKE_mesh_wrapper_face_normals(Mesh *mesh)
switch (mesh->runtime->wrapper_type) {
case ME_WRAPPER_TYPE_BMESH:
BKE_editmesh_cache_ensure_face_normals(*mesh->runtime->edit_mesh, *mesh->runtime->edit_data);
return mesh->runtime->edit_data->faceNos;
return mesh->runtime->edit_data->face_normals;
case ME_WRAPPER_TYPE_MDATA:
case ME_WRAPPER_TYPE_SUBD:
return mesh->face_normals();
@ -180,9 +180,9 @@ void BKE_mesh_wrapper_tag_positions_changed(Mesh *mesh)
switch (mesh->runtime->wrapper_type) {
case ME_WRAPPER_TYPE_BMESH:
if (mesh->runtime->edit_data) {
mesh->runtime->edit_data->vertexNos = {};
mesh->runtime->edit_data->faceCos = {};
mesh->runtime->edit_data->faceNos = {};
mesh->runtime->edit_data->vert_normals = {};
mesh->runtime->edit_data->face_centers = {};
mesh->runtime->edit_data->face_normals = {};
}
break;
case ME_WRAPPER_TYPE_MDATA:
@ -198,8 +198,8 @@ void BKE_mesh_wrapper_vert_coords_copy(const Mesh *mesh, blender::MutableSpan<fl
case ME_WRAPPER_TYPE_BMESH: {
BMesh *bm = mesh->runtime->edit_mesh->bm;
const blender::bke::EditMeshData &edit_data = *mesh->runtime->edit_data;
if (!edit_data.vertexCos.is_empty()) {
positions.copy_from(edit_data.vertexCos);
if (!edit_data.vert_positions.is_empty()) {
positions.copy_from(edit_data.vert_positions);
}
else {
BMIter iter;
@ -230,9 +230,9 @@ void BKE_mesh_wrapper_vert_coords_copy_with_mat4(const Mesh *mesh,
BMesh *bm = mesh->runtime->edit_mesh->bm;
BLI_assert(vert_coords_len == bm->totvert);
const blender::bke::EditMeshData &edit_data = *mesh->runtime->edit_data;
if (!edit_data.vertexCos.is_empty()) {
if (!edit_data.vert_positions.is_empty()) {
for (int i = 0; i < vert_coords_len; i++) {
mul_v3_m4v3(vert_coords[i], mat, edit_data.vertexCos[i]);
mul_v3_m4v3(vert_coords[i], mat, edit_data.vert_positions[i]);
}
}
else {

2
source/blender/blenkernel/intern/modifier.cc
View File

@ -879,7 +879,7 @@ static void modwrap_dependsOnNormals(Mesh *mesh)
switch (mesh->runtime->wrapper_type) {
case ME_WRAPPER_TYPE_BMESH: {
blender::bke::EditMeshData &edit_data = *mesh->runtime->edit_data;
if (!edit_data.vertexCos.is_empty()) {
if (!edit_data.vert_positions.is_empty()) {
/* Note that 'ensure' is acceptable here since these values aren't modified in-place.
* If that changes we'll need to recalculate. */
BKE_editmesh_cache_ensure_vert_normals(*mesh->runtime->edit_mesh, edit_data);

4
source/blender/blenkernel/intern/object.cc
View File

@ -3111,9 +3111,9 @@ static void give_parvert(Object *par, int nr, float vec[3])
}
if (nr < numVerts) {
if (mesh_eval && mesh_eval->runtime->edit_data &&
!mesh_eval->runtime->edit_data->vertexCos.is_empty())
!mesh_eval->runtime->edit_data->vert_positions.is_empty())
{
add_v3_v3(vec, mesh_eval->runtime->edit_data->vertexCos[nr]);
add_v3_v3(vec, mesh_eval->runtime->edit_data->vert_positions[nr]);
}
else {
const BMVert *v = BM_vert_at_index(em->bm, nr);

6
source/blender/blenkernel/intern/object_dupli.cc
View File

@ -472,11 +472,11 @@ static const Mesh *mesh_data_from_duplicator_object(Object *ob,
*r_em = em;
mesh_eval = nullptr;
if ((emd != nullptr) && !emd->vertexCos.is_empty()) {
*r_vert_coords = reinterpret_cast<const float(*)[3]>(emd->vertexCos.data());
if ((emd != nullptr) && !emd->vert_positions.is_empty()) {
*r_vert_coords = reinterpret_cast<const float(*)[3]>(emd->vert_positions.data());
if (r_vert_normals != nullptr) {
BKE_editmesh_cache_ensure_vert_normals(*em, *emd);
*r_vert_normals = reinterpret_cast<const float(*)[3]>(emd->vertexNos.data());
*r_vert_normals = reinterpret_cast<const float(*)[3]>(emd->vert_normals.data());
}
}
}

12
source/blender/draw/intern/draw_cache_extract_mesh_render_data.cc
View File

@ -507,7 +507,7 @@ void mesh_render_data_update_normals(MeshRenderData &mr, const eMRDataType data_
const float(*vert_normals)[3] = nullptr;
const float(*face_normals)[3] = nullptr;
if (mr.edit_data && !mr.edit_data->vertexCos.is_empty()) {
if (mr.edit_data && !mr.edit_data->vert_positions.is_empty()) {
vert_coords = reinterpret_cast<const float(*)[3]>(mr.bm_vert_coords.data());
vert_normals = reinterpret_cast<const float(*)[3]>(mr.bm_vert_normals.data());
face_normals = reinterpret_cast<const float(*)[3]>(mr.bm_face_normals.data());
@ -573,15 +573,15 @@ MeshRenderData *mesh_render_data_create(Object *object,
if (mr->edit_data) {
bke::EditMeshData *emd = mr->edit_data;
if (!emd->vertexCos.is_empty()) {
if (!emd->vert_positions.is_empty()) {
BKE_editmesh_cache_ensure_vert_normals(*mr->edit_bmesh, *emd);
BKE_editmesh_cache_ensure_face_normals(*mr->edit_bmesh, *emd);
}
mr->bm_vert_coords = mr->edit_data->vertexCos;
mr->bm_vert_normals = mr->edit_data->vertexNos;
mr->bm_face_normals = mr->edit_data->faceNos;
mr->bm_face_centers = mr->edit_data->faceCos;
mr->bm_vert_coords = mr->edit_data->vert_positions;
mr->bm_vert_normals = mr->edit_data->vert_normals;
mr->bm_face_normals = mr->edit_data->face_normals;
mr->bm_face_centers = mr->edit_data->face_centers;
}
int bm_ensure_types = BM_VERT | BM_EDGE | BM_LOOP | BM_FACE;