source/blender/blenkernel/BKE_mesh_iterators.hh

@@ -17,6 +17,7 @@ enum MeshForeachFlag {
 
 void BKE_mesh_foreach_mapped_vert(
     const Mesh *mesh,
+    const bool use_orig_index,
     void (*func)(void *user_data, int index, const float co[3], const float no[3]),
     void *user_data,
     MeshForeachFlag flag);
@@ -28,9 +29,11 @@ void BKE_mesh_foreach_mapped_vert(
 void BKE_mesh_foreach_mapped_edge(
     Mesh *mesh,
     int tot_edges,
+    const bool use_orig_index,
     void (*func)(void *user_data, int index, const float v0co[3], const float v1co[3]),
     void *user_data);
 void BKE_mesh_foreach_mapped_loop(Mesh *mesh,
+                                  const bool use_orig_index,
                                   void (*func)(void *user_data,
                                                int vertex_index,
                                                int face_index,
@@ -40,11 +43,13 @@ void BKE_mesh_foreach_mapped_loop(Mesh *mesh,
                                   MeshForeachFlag flag);
 void BKE_mesh_foreach_mapped_face_center(
     Mesh *mesh,
+    const bool use_orig_index,
     void (*func)(void *user_data, int index, const float cent[3], const float no[3]),
     void *user_data,
     MeshForeachFlag flag);
 void BKE_mesh_foreach_mapped_subdiv_face_center(
     Mesh *mesh,
+    const bool use_orig_index,
     void (*func)(void *user_data, int index, const float cent[3], const float no[3]),
     void *user_data,
     MeshForeachFlag flag);

source/blender/blenkernel/intern/DerivedMesh.cc

@@ -1620,7 +1620,8 @@ void mesh_get_mapped_verts_coords(Mesh *mesh_eval, blender::MutableSpan<blender:
     r_cos.fill(float3(0));
     user_data.vertexcos = reinterpret_cast<float(*)[3]>(r_cos.data());
     user_data.vertex_visit = BLI_BITMAP_NEW(r_cos.size(), "vertexcos flags");
-    BKE_mesh_foreach_mapped_vert(mesh_eval, make_vertexcos__mapFunc, &user_data, MESH_FOREACH_NOP);
+    BKE_mesh_foreach_mapped_vert(
+        mesh_eval, true, make_vertexcos__mapFunc, &user_data, MESH_FOREACH_NOP);
     MEM_freeN(user_data.vertex_visit);
   }
   else {

source/blender/blenkernel/intern/editmesh.cc

@@ -157,7 +157,7 @@ float (*BKE_editmesh_vert_coords_alloc(
   data.cos_cage = cos_cage;
   data.visit_bitmap = visit_bitmap;
 
-  BKE_mesh_foreach_mapped_vert(cage, cage_mapped_verts_callback, &data, MESH_FOREACH_NOP);
+  BKE_mesh_foreach_mapped_vert(cage, true, cage_mapped_verts_callback, &data, MESH_FOREACH_NOP);
 
   MEM_freeN(visit_bitmap);
 

source/blender/blenkernel/intern/mesh_iterators.cc

@@ -31,6 +31,7 @@
 
 void BKE_mesh_foreach_mapped_vert(
     const Mesh *mesh,
+    const bool use_orig_index,
     void (*func)(void *user_data, int index, const float co[3], const float no[3]),
     void *user_data,
     MeshForeachFlag flag)
@@ -62,8 +63,9 @@ void BKE_mesh_foreach_mapped_vert(
   }
   else {
     const blender::Span<blender::float3> positions = mesh->vert_positions();
-    const int *index = static_cast<const int *>(
-        CustomData_get_layer(&mesh->vert_data, CD_ORIGINDEX));
+    const int *index = use_orig_index ? static_cast<const int *>(
+                                            CustomData_get_layer(&mesh->vert_data, CD_ORIGINDEX)) :
+                                        nullptr;
     blender::Span<blender::float3> vert_normals;
     if (flag & MESH_FOREACH_USE_NORMAL) {
       vert_normals = mesh->vert_normals();
@@ -91,6 +93,7 @@ void BKE_mesh_foreach_mapped_vert(
 void BKE_mesh_foreach_mapped_edge(
     Mesh *mesh,
     const int tot_edges,
+    const bool use_orig_index,
     void (*func)(void *user_data, int index, const float v0co[3], const float v1co[3]),
     void *user_data)
 {
@@ -119,8 +122,9 @@ void BKE_mesh_foreach_mapped_edge(
   else {
     const blender::Span<blender::float3> positions = mesh->vert_positions();
     const blender::Span<blender::int2> edges = mesh->edges();
-    const int *index = static_cast<const int *>(
-        CustomData_get_layer(&mesh->edge_data, CD_ORIGINDEX));
+    const int *index = use_orig_index ? static_cast<const int *>(
+                                            CustomData_get_layer(&mesh->edge_data, CD_ORIGINDEX)) :
+                                        nullptr;
 
     if (index) {
       for (const int i : edges.index_range()) {
@@ -141,6 +145,7 @@ void BKE_mesh_foreach_mapped_edge(
 }
 
 void BKE_mesh_foreach_mapped_loop(Mesh *mesh,
+                                  const bool use_orig_index,
                                   void (*func)(void *user_data,
                                                int vertex_index,
                                                int face_index,
@@ -195,10 +200,12 @@ void BKE_mesh_foreach_mapped_loop(Mesh *mesh,
     const blender::Span<blender::float3> positions = mesh->vert_positions();
     const blender::OffsetIndices faces = mesh->faces();
     const blender::Span<int> corner_verts = mesh->corner_verts();
-    const int *v_index = static_cast<const int *>(
-        CustomData_get_layer(&mesh->vert_data, CD_ORIGINDEX));
-    const int *f_index = static_cast<const int *>(
-        CustomData_get_layer(&mesh->face_data, CD_ORIGINDEX));
+    const int *v_index = use_orig_index ? static_cast<const int *>(CustomData_get_layer(
+                                              &mesh->vert_data, CD_ORIGINDEX)) :
+                                          nullptr;
+    const int *f_index = use_orig_index ? static_cast<const int *>(CustomData_get_layer(
+                                              &mesh->face_data, CD_ORIGINDEX)) :
+                                          nullptr;
 
     if (v_index || f_index) {
       for (const int face_i : faces.index_range()) {
@@ -228,6 +235,7 @@ void BKE_mesh_foreach_mapped_loop(Mesh *mesh,
 
 void BKE_mesh_foreach_mapped_face_center(
     Mesh *mesh,
+    const bool use_orig_index,
     void (*func)(void *user_data, int index, const float cent[3], const float no[3]),
     void *user_data,
     MeshForeachFlag flag)
@@ -267,8 +275,9 @@ void BKE_mesh_foreach_mapped_face_center(
     const blender::Span<float3> positions = mesh->vert_positions();
     const blender::OffsetIndices faces = mesh->faces();
     const blender::Span<int> corner_verts = mesh->corner_verts();
-    const int *index = static_cast<const int *>(
-        CustomData_get_layer(&mesh->face_data, CD_ORIGINDEX));
+    const int *index = use_orig_index ? static_cast<const int *>(
+                                            CustomData_get_layer(&mesh->face_data, CD_ORIGINDEX)) :
+                                        nullptr;
 
     if (index) {
       for (const int i : faces.index_range()) {
@@ -305,6 +314,7 @@ void BKE_mesh_foreach_mapped_face_center(
 
 void BKE_mesh_foreach_mapped_subdiv_face_center(
     Mesh *mesh,
+    const bool use_orig_index,
     void (*func)(void *user_data, int index, const float cent[3], const float no[3]),
     void *user_data,
     MeshForeachFlag flag)
@@ -316,8 +326,9 @@ void BKE_mesh_foreach_mapped_subdiv_face_center(
   if (flag & MESH_FOREACH_USE_NORMAL) {
     vert_normals = mesh->vert_normals();
   }
-  const int *index = static_cast<const int *>(
-      CustomData_get_layer(&mesh->face_data, CD_ORIGINDEX));
+  const int *index = use_orig_index ? static_cast<const int *>(
+                                          CustomData_get_layer(&mesh->face_data, CD_ORIGINDEX)) :
+                                      nullptr;
   const blender::BitSpan facedot_tags = mesh->runtime->subsurf_face_dot_tags;
 
   if (index) {
@@ -381,6 +392,7 @@ void BKE_mesh_foreach_mapped_vert_coords_get(const Mesh *mesh_eval,
   memset(r_cos, 0, sizeof(*r_cos) * totcos);
   user_data.vertexcos = r_cos;
   user_data.vertex_visit = BLI_BITMAP_NEW(totcos, __func__);
-  BKE_mesh_foreach_mapped_vert(mesh_eval, get_vertexcos__mapFunc, &user_data, MESH_FOREACH_NOP);
+  BKE_mesh_foreach_mapped_vert(
+      mesh_eval, true, get_vertexcos__mapFunc, &user_data, MESH_FOREACH_NOP);
   MEM_freeN(user_data.vertex_visit);
 }

source/blender/draw/DRW_select_buffer.hh

@@ -68,7 +68,8 @@ struct SELECTID_Context {
 
 /* `draw_select_buffer.cc` */
 
-bool DRW_select_buffer_elem_get(uint sel_id, uint *r_elem, uint *r_base_index, char *r_elem_type);
+bool DRW_select_buffer_elem_get(
+    uint sel_id, uint *r_elem, uint *r_base_index, char *r_elem_type, const bool use_orig_index);
 uint DRW_select_buffer_context_offset_for_object_elem(Depsgraph *depsgraph,
                                                       Object *object,
                                                       char elem_type);

source/blender/draw/engines/select/select_draw_utils.cc

@@ -93,7 +93,7 @@ static void draw_select_id_edit_mesh(SELECTID_StorageList *stl,
       blender::gpu::Batch *geom_facedots = DRW_mesh_batch_cache_get_facedots_with_select_id(mesh);
       DRW_shgroup_call_no_cull(face_shgrp, geom_facedots, ob);
     }
-    *r_face_offset = initial_offset + em->bm->totface;
+    *r_face_offset = initial_offset + mesh->faces_num;
   }
   else {
     if (ob->dt >= OB_SOLID) {
@@ -114,7 +114,7 @@ static void draw_select_id_edit_mesh(SELECTID_StorageList *stl,
     DRWShadingGroup *edge_shgrp = DRW_shgroup_create_sub(stl->g_data->shgrp_edge);
     DRW_shgroup_uniform_int_copy(edge_shgrp, "offset", *(int *)r_face_offset);
     DRW_shgroup_call_no_cull(edge_shgrp, geom_edges, ob);
-    *r_edge_offset = *r_face_offset + em->bm->totedge;
+    *r_edge_offset = *r_face_offset + mesh->edges_num;
   }
   else {
     /* Note that `r_vert_offset` is calculated from `r_edge_offset`.
@@ -128,7 +128,7 @@ static void draw_select_id_edit_mesh(SELECTID_StorageList *stl,
     DRWShadingGroup *vert_shgrp = DRW_shgroup_create_sub(stl->g_data->shgrp_vert);
     DRW_shgroup_uniform_int_copy(vert_shgrp, "offset", *(int *)r_edge_offset);
     DRW_shgroup_call_no_cull(vert_shgrp, geom_verts, ob);
-    *r_vert_offset = *r_edge_offset + em->bm->totvert;
+    *r_vert_offset = *r_edge_offset + mesh->verts_num;
   }
   else {
     *r_vert_offset = *r_edge_offset;

source/blender/draw/intern/draw_select_buffer.cc

@@ -17,6 +17,10 @@
 
 #include "DNA_screen_types.h"
 
+#include "BKE_customdata.hh"
+#include "BKE_mesh.hh"
+#include "BKE_object.hh"
+
 #include "GPU_select.hh"
 
 #include "DEG_depsgraph.hh"
@@ -392,7 +396,8 @@ uint DRW_select_buffer_find_nearest_to_point(Depsgraph *depsgraph,
 bool DRW_select_buffer_elem_get(const uint sel_id,
                                 uint *r_elem,
                                 uint *r_base_index,
-                                char *r_elem_type)
+                                char *r_elem_type,
+                                const bool use_orig_index)
 {
   SELECTID_Context *select_ctx = DRW_select_engine_context_get();
 
@@ -424,8 +429,6 @@ bool DRW_select_buffer_elem_get(const uint sel_id,
     return false;
   }
 
-  *r_elem = elem_id;
-
   if (r_base_index) {
     *r_base_index = base_index;
   }
@@ -434,6 +437,22 @@ bool DRW_select_buffer_elem_get(const uint sel_id,
     *r_elem_type = elem_type;
   }
 
+  if (use_orig_index) {
+    Object *object = select_ctx->objects[base_index];
+    Mesh *mesh_eval = BKE_object_get_evaluated_mesh(object);
+    const int *orig_index = reinterpret_cast<const int *>(
+        CustomData_get_layer(elem_type == SCE_SELECT_FACE ? &mesh_eval->face_data :
+                             elem_type == SCE_SELECT_EDGE ? &mesh_eval->edge_data :
+                                                            &mesh_eval->vert_data,
+                             CD_ORIGINDEX));
+
+    if (orig_index) {
+      elem_id = orig_index[elem_id];
+    }
+  }
+
+  *r_elem = elem_id;
+
   return true;
 }
 

source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_select_idx.cc

@@ -38,11 +38,6 @@ static void extract_select_idx_init(const MeshRenderData &mr,
   extract_select_idx_init_impl(mr, mr.corners_num + mr.loose_indices_num, buf, tls_data);
 }
 
-/* TODO: Use #glVertexID to get loop index and use the data structure on the CPU to retrieve the
- * select element associated with this loop ID. This would remove the need for this separate
- * index VBO's. We could upload the p/e/v_origindex as a buffer texture and sample it inside the
- * shader to output original index. */
-
 static void extract_face_idx_iter_face_bm(const MeshRenderData & /*mr*/,
                                           const BMFace *f,
                                           const int f_index,
@@ -115,7 +110,7 @@ static void extract_face_idx_iter_face_mesh(const MeshRenderData &mr,
                                             void *data)
 {
   for (const int corner : mr.faces[face_index]) {
-    (*(int32_t **)data)[corner] = (mr.p_origindex) ? mr.p_origindex[face_index] : face_index;
+    (*(int32_t **)data)[corner] = face_index;
   }
 }
 
@@ -125,7 +120,7 @@ static void extract_edge_idx_iter_face_mesh(const MeshRenderData &mr,
 {
   for (const int corner : mr.faces[face_index]) {
     const int edge = mr.corner_edges[corner];
-    (*(int32_t **)data)[corner] = (mr.e_origindex) ? mr.e_origindex[edge] : edge;
+    (*(int32_t **)data)[corner] = edge;
   }
 }
 
@@ -135,7 +130,7 @@ static void extract_vert_idx_iter_face_mesh(const MeshRenderData &mr,
 {
   for (const int corner : mr.faces[face_index]) {
     const int vert = mr.corner_verts[corner];
-    (*(int32_t **)data)[corner] = (mr.v_origindex) ? mr.v_origindex[vert] : vert;
+    (*(int32_t **)data)[corner] = vert;
   }
 }
 
@@ -145,9 +140,8 @@ static void extract_edge_idx_iter_loose_edge_mesh(const MeshRenderData &mr,
                                                   void *data)
 {
   const int e_index = mr.loose_edges[loose_edge_i];
-  const int e_orig = (mr.e_origindex) ? mr.e_origindex[e_index] : e_index;
-  (*(int32_t **)data)[mr.corners_num + loose_edge_i * 2 + 0] = e_orig;
-  (*(int32_t **)data)[mr.corners_num + loose_edge_i * 2 + 1] = e_orig;
+  (*(int32_t **)data)[mr.corners_num + loose_edge_i * 2 + 0] = e_index;
+  (*(int32_t **)data)[mr.corners_num + loose_edge_i * 2 + 1] = e_index;
 }
 
 static void extract_vert_idx_iter_loose_edge_mesh(const MeshRenderData &mr,
@@ -155,8 +149,8 @@ static void extract_vert_idx_iter_loose_edge_mesh(const MeshRenderData &mr,
                                                   const int loose_edge_i,
                                                   void *data)
 {
-  int v1_orig = (mr.v_origindex) ? mr.v_origindex[edge[0]] : edge[0];
-  int v2_orig = (mr.v_origindex) ? mr.v_origindex[edge[1]] : edge[1];
+  int v1_orig = edge[0];
+  int v2_orig = edge[1];
   (*(int32_t **)data)[mr.corners_num + loose_edge_i * 2 + 0] = v1_orig;
   (*(int32_t **)data)[mr.corners_num + loose_edge_i * 2 + 1] = v2_orig;
 }
@@ -168,8 +162,7 @@ static void extract_vert_idx_iter_loose_vert_mesh(const MeshRenderData &mr,
   const int offset = mr.corners_num + (mr.loose_edges_num * 2);
 
   const int v_index = mr.loose_verts[loose_vert_i];
-  const int v_orig = (mr.v_origindex) ? mr.v_origindex[v_index] : v_index;
-  (*(int32_t **)data)[offset + loose_vert_i] = v_orig;
+  (*(int32_t **)data)[offset + loose_vert_i] = v_index;
 }
 
 static void extract_vert_idx_init_subdiv(const DRWSubdivCache &subdiv_cache,
@@ -185,20 +178,6 @@ static void extract_vert_idx_init_subdiv(const DRWSubdivCache &subdiv_cache,
                                     (int32_t *)GPU_vertbuf_get_data(subdiv_cache.verts_orig_index),
                                     subdiv_cache.num_subdiv_loops,
                                     loose_geom.loop_len);
-  if (!mr.v_origindex) {
-    return;
-  }
-
-  /* Remap the vertex indices to those pointed by the origin indices layer. At this point, the
-   * VBO data is a copy of #verts_orig_index which contains the coarse vertices indices, so
-   * the memory can both be accessed for lookup and immediately overwritten. */
-  int32_t *vbo_data = static_cast<int32_t *>(GPU_vertbuf_get_data(vbo));
-  for (int i = 0; i < subdiv_cache.num_subdiv_loops; i++) {
-    if (vbo_data[i] == -1) {
-      continue;
-    }
-    vbo_data[i] = mr.v_origindex[vbo_data[i]];
-  }
 }
 
 static void extract_vert_idx_loose_geom_subdiv(const DRWSubdivCache &subdiv_cache,
@@ -222,13 +201,11 @@ static void extract_vert_idx_loose_geom_subdiv(const DRWSubdivCache &subdiv_cach
     const DRWSubdivLooseVertex &v2 = loose_geom.verts[loose_edge.loose_subdiv_v2_index];
 
     if (v1.coarse_vertex_index != -1u) {
-      vert_idx_data[offset] = mr.v_origindex ? mr.v_origindex[v1.coarse_vertex_index] :
-                                               v1.coarse_vertex_index;
+      vert_idx_data[offset] = v1.coarse_vertex_index;
     }
 
     if (v2.coarse_vertex_index != -1u) {
-      vert_idx_data[offset + 1] = mr.v_origindex ? mr.v_origindex[v2.coarse_vertex_index] :
-                                                   v2.coarse_vertex_index;
+      vert_idx_data[offset + 1] = v2.coarse_vertex_index;
     }
 
     offset += 2;
@@ -237,8 +214,7 @@ static void extract_vert_idx_loose_geom_subdiv(const DRWSubdivCache &subdiv_cach
   Span<DRWSubdivLooseVertex> loose_verts = draw_subdiv_cache_get_loose_verts(subdiv_cache);
 
   for (const DRWSubdivLooseVertex &loose_vert : loose_verts) {
-    vert_idx_data[offset] = mr.v_origindex ? mr.v_origindex[loose_vert.coarse_vertex_index] :
-                                             loose_vert.coarse_vertex_index;
+    vert_idx_data[offset] = loose_vert.coarse_vertex_index;
     offset += 1;
   }
 }
@@ -274,8 +250,7 @@ static void extract_edge_idx_loose_geom_subdiv(const DRWSubdivCache &subdiv_cach
 
   Span<DRWSubdivLooseEdge> loose_edges = draw_subdiv_cache_get_loose_edges(subdiv_cache);
   for (const DRWSubdivLooseEdge &loose_edge : loose_edges) {
-    const int coarse_edge_index = mr.e_origindex ? mr.e_origindex[loose_edge.coarse_edge_index] :
-                                                   loose_edge.coarse_edge_index;
+    const int coarse_edge_index = loose_edge.coarse_edge_index;
     vert_idx_data[offset] = coarse_edge_index;
     vert_idx_data[offset + 1] = coarse_edge_index;
     offset += 2;
@@ -291,18 +266,6 @@ static void extract_face_idx_init_subdiv(const DRWSubdivCache &subdiv_cache,
   gpu::VertBuf *vbo = static_cast<gpu::VertBuf *>(buf);
   draw_subdiv_init_origindex_buffer(
       vbo, subdiv_cache.subdiv_loop_face_index, subdiv_cache.num_subdiv_loops, 0);
-
-  if (!mr.p_origindex) {
-    return;
-  }
-
-  /* Remap the face indices to those pointed by the origin indices layer. At this point, the
-   * VBO data is a copy of #subdiv_loop_face_index which contains the coarse face indices, so
-   * the memory can both be accessed for lookup and immediately overwritten. */
-  int32_t *vbo_data = static_cast<int32_t *>(GPU_vertbuf_get_data(vbo));
-  for (int i = 0; i < subdiv_cache.num_subdiv_loops; i++) {
-    vbo_data[i] = mr.p_origindex[vbo_data[i]];
-  }
 }
 
 constexpr MeshExtract create_extractor_face_idx()
@@ -375,12 +338,7 @@ static void extract_fdot_idx_iter_face_mesh(const MeshRenderData &mr,
                                             const int face_index,
                                             void *data)
 {
-  if (mr.p_origindex != nullptr) {
-    (*(int32_t **)data)[face_index] = mr.p_origindex[face_index];
-  }
-  else {
-    (*(int32_t **)data)[face_index] = face_index;
-  }
+  (*(int32_t **)data)[face_index] = face_index;
 }
 
 constexpr MeshExtract create_extractor_fdot_idx()

source/blender/editors/mesh/editmesh_select.cc

@@ -181,7 +181,7 @@ static BMElem *edbm_select_id_bm_elem_get(const Span<Base *> bases,
 {
   uint elem_id;
   char elem_type = 0;
-  bool success = DRW_select_buffer_elem_get(sel_id, &elem_id, r_base_index, &elem_type);
+  bool success = DRW_select_buffer_elem_get(sel_id, &elem_id, r_base_index, &elem_type, true);
 
   if (success) {
     Object *obedit = bases[*r_base_index]->object;

source/blender/editors/mesh/meshtools.cc

@@ -1391,7 +1391,8 @@ bool ED_mesh_pick_vert(
     data.v_idx_best = -1;
     data.hide_vert = *attributes.lookup<bool>(".hide_vert", bke::AttrDomain::Point);
 
-    BKE_mesh_foreach_mapped_vert(mesh_eval, ed_mesh_pick_vert__mapFunc, &data, MESH_FOREACH_NOP);
+    BKE_mesh_foreach_mapped_vert(
+        mesh_eval, true, ed_mesh_pick_vert__mapFunc, &data, MESH_FOREACH_NOP);
 
     if (data.v_idx_best == -1) {
       return false;

source/blender/editors/sculpt_paint/paint_vertex_proj.cc

@@ -83,7 +83,7 @@ static void vpaint_proj_dm_map_cosnos_init(Depsgraph *depsgraph,
 
   memset(vp_handle->vcosnos, 0, sizeof(*vp_handle->vcosnos) * mesh->verts_num);
   BKE_mesh_foreach_mapped_vert(
-      mesh_eval, vpaint_proj_dm_map_cosnos_init__map_cb, vp_handle, MESH_FOREACH_USE_NORMAL);
+      mesh_eval, true, vpaint_proj_dm_map_cosnos_init__map_cb, vp_handle, MESH_FOREACH_USE_NORMAL);
 }
 
 /* -------------------------------------------------------------------- */
@@ -146,8 +146,11 @@ static void vpaint_proj_dm_map_cosnos_update(Depsgraph *depsgraph,
   BLI_assert(BLI_listbase_is_empty(&ob->modifiers) == false);
 
   copy_vn_fl(vp_handle->dists_sq, mesh->verts_num, FLT_MAX);
-  BKE_mesh_foreach_mapped_vert(
-      mesh_eval, vpaint_proj_dm_map_cosnos_update__map_cb, &vp_update, MESH_FOREACH_USE_NORMAL);
+  BKE_mesh_foreach_mapped_vert(mesh_eval,
+                               true,
+                               vpaint_proj_dm_map_cosnos_update__map_cb,
+                               &vp_update,
+                               MESH_FOREACH_USE_NORMAL);
 }
 
 /* -------------------------------------------------------------------- */

source/blender/editors/sculpt_paint/paint_vertex_weight_ops.cc

@@ -830,13 +830,15 @@ static int paint_weight_gradient_exec(bContext *C, wmOperator *op)
   if (data.is_init) {
     data.vert_visit = BLI_BITMAP_NEW(mesh->verts_num, __func__);
 
-    BKE_mesh_foreach_mapped_vert(mesh_eval, gradientVertInit__mapFunc, &data, MESH_FOREACH_NOP);
+    BKE_mesh_foreach_mapped_vert(
+        mesh_eval, true, gradientVertInit__mapFunc, &data, MESH_FOREACH_NOP);
 
     MEM_freeN(data.vert_visit);
     data.vert_visit = nullptr;
   }
   else {
-    BKE_mesh_foreach_mapped_vert(mesh_eval, gradientVertUpdate__mapFunc, &data, MESH_FOREACH_NOP);
+    BKE_mesh_foreach_mapped_vert(
+        mesh_eval, true, gradientVertUpdate__mapFunc, &data, MESH_FOREACH_NOP);
   }
 
   DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);

source/blender/editors/space_view3d/view3d_iterators.cc

@@ -312,7 +312,7 @@ void meshobject_foreachScreenVert(const ViewContext *vc,
   }
 
   BKE_mesh_foreach_mapped_vert(
-      mesh, meshobject_foreachScreenVert__mapFunc, &data, MESH_FOREACH_NOP);
+      mesh, true, meshobject_foreachScreenVert__mapFunc, &data, MESH_FOREACH_NOP);
 }
 
 static void mesh_foreachScreenVert__mapFunc(void *user_data,
@@ -361,7 +361,8 @@ void mesh_foreachScreenVert(
   }
 
   BM_mesh_elem_table_ensure(vc->em->bm, BM_VERT);
-  BKE_mesh_foreach_mapped_vert(mesh, mesh_foreachScreenVert__mapFunc, &data, MESH_FOREACH_NOP);
+  BKE_mesh_foreach_mapped_vert(
+      mesh, true, mesh_foreachScreenVert__mapFunc, &data, MESH_FOREACH_NOP);
 }
 
 /** \} */
@@ -440,7 +441,8 @@ void mesh_foreachScreenEdge(const ViewContext *vc,
   }
 
   BM_mesh_elem_table_ensure(vc->em->bm, BM_EDGE);
-  BKE_mesh_foreach_mapped_edge(mesh, vc->em->bm->totedge, mesh_foreachScreenEdge__mapFunc, &data);
+  BKE_mesh_foreach_mapped_edge(
+      mesh, true, vc->em->bm->totedge, mesh_foreachScreenEdge__mapFunc, &data);
 }
 
 /** \} */
@@ -530,11 +532,11 @@ void mesh_foreachScreenEdge_clip_bb_segment(const ViewContext *vc,
     ED_view3d_clipping_local(
         vc->rv3d, vc->obedit->object_to_world().ptr()); /* for local clipping lookups. */
     BKE_mesh_foreach_mapped_edge(
-        mesh, vc->em->bm->totedge, mesh_foreachScreenEdge_clip_bb_segment__mapFunc, &data);
+        mesh, true, vc->em->bm->totedge, mesh_foreachScreenEdge_clip_bb_segment__mapFunc, &data);
   }
   else {
     BKE_mesh_foreach_mapped_edge(
-        mesh, vc->em->bm->totedge, mesh_foreachScreenEdge__mapFunc, &data);
+        mesh, true, vc->em->bm->totedge, mesh_foreachScreenEdge__mapFunc, &data);
   }
 }
 
@@ -589,11 +591,11 @@ void mesh_foreachScreenFace(
   const int face_dot_tags_num = mesh->runtime->subsurf_face_dot_tags.size();
   if (face_dot_tags_num && (face_dot_tags_num != mesh->verts_num)) {
     BKE_mesh_foreach_mapped_subdiv_face_center(
-        mesh, mesh_foreachScreenFace__mapFunc, &data, MESH_FOREACH_NOP);
+        mesh, true, mesh_foreachScreenFace__mapFunc, &data, MESH_FOREACH_NOP);
   }
   else {
     BKE_mesh_foreach_mapped_face_center(
-        mesh, mesh_foreachScreenFace__mapFunc, &data, MESH_FOREACH_NOP);
+        mesh, true, mesh_foreachScreenFace__mapFunc, &data, MESH_FOREACH_NOP);
   }
 }
 

source/blender/editors/util/ed_transverts.cc

@@ -310,7 +310,7 @@ void ED_transverts_create_from_obedit(TransVertStore *tvs, const Object *obedit,
       if (tvs->transverts && editmesh_eval_cage) {
         BM_mesh_elem_table_ensure(bm, BM_VERT);
         BKE_mesh_foreach_mapped_vert(
-            editmesh_eval_cage, set_mapped_co, userdata, MESH_FOREACH_NOP);
+            editmesh_eval_cage, true, set_mapped_co, userdata, MESH_FOREACH_NOP);
       }
     }
   }