Mesh: Remove redundant custom data pointers

For copy-on-write, we want to share attribute arrays between meshes
where possible. Mutable pointers like `Mesh.mvert` make that difficult
by making ownership vague. They also make code more complex by adding
redundancy.

The simplest solution is just removing them and retrieving layers from
`CustomData` as needed. Similar changes have already been applied to
curves and point clouds (e9f82d3dc7ee, 410a6efb747f). Removing use of
the pointers generally makes code more obvious and more reusable.

Mesh data is now accessed with a C++ API (`Mesh::edges()` or
`Mesh::edges_for_write()`), and a C API (`BKE_mesh_edges(mesh)`).

The CoW changes this commit makes possible are described in T95845
and T95842, and started in D14139 and D14140. The change also simplifies
the ongoing mesh struct-of-array refactors from T95965.

**RNA/Python Access Performance**
Theoretically, accessing mesh elements with the RNA API may become
slower, since the layer needs to be found on every random access.
However, overhead is already high enough that this doesn't make a
noticible differenc, and performance is actually improved in some
cases. Random access can be up to 10% faster, but other situations
might be a bit slower. Generally using `foreach_get/set` are the best
way to improve performance. See the differential revision for more
discussion about Python performance.

Cycles has been updated to use raw pointers and the internal Blender
mesh types, mostly because there is no sense in having this overhead
when it's already compiled with Blender. In my tests this roughly
halves the Cycles mesh creation time (0.19s to 0.10s for a 1 million
face grid).

Differential Revision: https://developer.blender.org/D15488

1 files changed, 73 insertions, 66 deletions

diff --git a/source/blender/editors/sculpt_paint/paint_vertex.cc b/source/blender/editors/sculpt_paint/paint_vertex.cc
index ccaf8b1ba37..c1a2a326d14 100644
--- a/source/blender/editors/sculpt_paint/paint_vertex.cc
+++ b/source/blender/editors/sculpt_paint/paint_vertex.cc
@@ -773,6 +773,8 @@ struct WeightPaintGroupData {
  * paint stroke update - campbell */
 struct WeightPaintInfo {
 
+  MutableSpan<MDeformVert> dvert;
+
   int defbase_tot;
 
   /* both must add up to 'defbase_tot' */
@@ -815,7 +817,7 @@ static void do_weight_paint_vertex_single(
     float paintweight)
 {
   Mesh *me = (Mesh *)ob->data;
-  MDeformVert *dv = &me->dvert[index];
+  MDeformVert *dv = &wpi->dvert[index];
   bool topology = (me->editflag & ME_EDIT_MIRROR_TOPO) != 0;
 
   MDeformWeight *dw;
@@ -875,7 +877,7 @@ static void do_weight_paint_vertex_single(
 
   /* get the mirror def vars */
   if (index_mirr != -1) {
-    dv_mirr = &me->dvert[index_mirr];
+    dv_mirr = &wpi->dvert[index_mirr];
     if (wp->flag & VP_FLAG_VGROUP_RESTRICT) {
       dw_mirr = BKE_defvert_find_index(dv_mirr, vgroup_mirr);
 
@@ -915,9 +917,9 @@ static void do_weight_paint_vertex_single(
 
   if (!brush_use_accumulate(wp)) {
     MDeformVert *dvert_prev = ob->sculpt->mode.wpaint.dvert_prev;
-    MDeformVert *dv_prev = defweight_prev_init(dvert_prev, me->dvert, index);
+    MDeformVert *dv_prev = defweight_prev_init(dvert_prev, wpi->dvert.data(), index);
     if (index_mirr != -1) {
-      defweight_prev_init(dvert_prev, me->dvert, index_mirr);
+      defweight_prev_init(dvert_prev, wpi->dvert.data(), index_mirr);
     }
 
     weight_prev = BKE_defvert_find_weight(dv_prev, wpi->active.index);
@@ -1028,7 +1030,7 @@ static void do_weight_paint_vertex_multi(
     float paintweight)
 {
   Mesh *me = (Mesh *)ob->data;
-  MDeformVert *dv = &me->dvert[index];
+  MDeformVert *dv = &wpi->dvert[index];
   bool topology = (me->editflag & ME_EDIT_MIRROR_TOPO) != 0;
 
   /* mirror vars */
@@ -1044,7 +1046,7 @@ static void do_weight_paint_vertex_multi(
     index_mirr = mesh_get_x_mirror_vert(ob, nullptr, index, topology);
 
     if (!ELEM(index_mirr, -1, index)) {
-      dv_mirr = &me->dvert[index_mirr];
+      dv_mirr = &wpi->dvert[index_mirr];
     }
     else {
       index_mirr = -1;
@@ -1071,9 +1073,9 @@ static void do_weight_paint_vertex_multi(
 
   if (!brush_use_accumulate(wp)) {
     MDeformVert *dvert_prev = ob->sculpt->mode.wpaint.dvert_prev;
-    MDeformVert *dv_prev = defweight_prev_init(dvert_prev, me->dvert, index);
+    MDeformVert *dv_prev = defweight_prev_init(dvert_prev, wpi->dvert.data(), index);
     if (index_mirr != -1) {
-      defweight_prev_init(dvert_prev, me->dvert, index_mirr);
+      defweight_prev_init(dvert_prev, wpi->dvert.data(), index_mirr);
     }
 
     oldw = BKE_defvert_multipaint_collective_weight(
@@ -1235,6 +1237,8 @@ static void vertex_paint_init_session_data(const ToolSettings *ts, Object *ob)
   }
 
   Mesh *me = (Mesh *)ob->data;
+  const Span<MPoly> polys = me->polygons();
+  const Span<MLoop> loops = me->loops();
 
   if (gmap->vert_to_loop == nullptr) {
     gmap->vert_map_mem = nullptr;
@@ -1243,15 +1247,15 @@ static void vertex_paint_init_session_data(const ToolSettings *ts, Object *ob)
     gmap->vert_to_poly = nullptr;
     BKE_mesh_vert_loop_map_create(&gmap->vert_to_loop,
                                   &gmap->vert_map_mem,
-                                  me->mpoly,
-                                  me->mloop,
+                                  polys.data(),
+                                  loops.data(),
                                   me->totvert,
                                   me->totpoly,
                                   me->totloop);
     BKE_mesh_vert_poly_map_create(&gmap->vert_to_poly,
                                   &gmap->poly_map_mem,
-                                  me->mpoly,
-                                  me->mloop,
+                                  polys.data(),
+                                  loops.data(),
                                   me->totvert,
                                   me->totpoly,
                                   me->totloop);
@@ -1900,7 +1904,7 @@ static void do_wpaint_precompute_weight_cb_ex(void *__restrict userdata,
                                               const TaskParallelTLS *__restrict UNUSED(tls))
 {
   SculptThreadedTaskData *data = (SculptThreadedTaskData *)userdata;
-  const MDeformVert *dv = &data->me->dvert[n];
+  const MDeformVert *dv = &data->wpi->dvert[n];
 
   data->wpd->precomputed_weight[n] = wpaint_get_active_weight(dv, data->wpi);
 }
@@ -1961,10 +1965,9 @@ static void do_wpaint_brush_blur_task_cb_ex(void *__restrict userdata,
     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
       /* For grid based pbvh, take the vert whose loop corresponds to the current grid.
        * Otherwise, take the current vert. */
-      const int v_index = has_grids ? data->me->mloop[vd.grid_indices[vd.g]].v :
-                                      vd.vert_indices[vd.i];
+      const int v_index = has_grids ? ss->mloop[vd.grid_indices[vd.g]].v : vd.vert_indices[vd.i];
       const float grid_alpha = has_grids ? 1.0f / vd.gridsize : 1.0f;
-      const char v_flag = data->me->mvert[v_index].flag;
+      const char v_flag = ss->mvert[v_index].flag;
       /* If the vertex is selected */
       if (!(use_face_sel || use_vert_sel) || v_flag & SELECT) {
         /* Get the average poly weight */
@@ -1972,12 +1975,12 @@ static void do_wpaint_brush_blur_task_cb_ex(void *__restrict userdata,
         float weight_final = 0.0f;
         for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
           const int p_index = gmap->vert_to_poly[v_index].indices[j];
-          const MPoly *mp = &data->me->mpoly[p_index];
+          const MPoly *mp = &ss->mpoly[p_index];
 
           total_hit_loops += mp->totloop;
           for (int k = 0; k < mp->totloop; k++) {
             const int l_index = mp->loopstart + k;
-            const MLoop *ml = &data->me->mloop[l_index];
+            const MLoop *ml = &ss->mloop[l_index];
             weight_final += data->wpd->precomputed_weight[ml->v];
           }
         }
@@ -2057,10 +2060,9 @@ static void do_wpaint_brush_smear_task_cb_ex(void *__restrict userdata,
       if (sculpt_brush_test_sq_fn(&test, vd.co)) {
         /* For grid based pbvh, take the vert whose loop corresponds to the current grid.
          * Otherwise, take the current vert. */
-        const int v_index = has_grids ? data->me->mloop[vd.grid_indices[vd.g]].v :
-                                        vd.vert_indices[vd.i];
+        const int v_index = has_grids ? ss->mloop[vd.grid_indices[vd.g]].v : vd.vert_indices[vd.i];
         const float grid_alpha = has_grids ? 1.0f / vd.gridsize : 1.0f;
-        const MVert *mv_curr = &data->me->mvert[v_index];
+        const MVert *mv_curr = &ss->mvert[v_index];
 
         /* If the vertex is selected */
         if (!(use_face_sel || use_vert_sel) || mv_curr->flag & SELECT) {
@@ -2082,12 +2084,12 @@ static void do_wpaint_brush_smear_task_cb_ex(void *__restrict userdata,
             float weight_final = 0.0;
             for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
               const int p_index = gmap->vert_to_poly[v_index].indices[j];
-              const MPoly *mp = &data->me->mpoly[p_index];
-              const MLoop *ml_other = &data->me->mloop[mp->loopstart];
+              const MPoly *mp = &ss->mpoly[p_index];
+              const MLoop *ml_other = &ss->mloop[mp->loopstart];
               for (int k = 0; k < mp->totloop; k++, ml_other++) {
                 const uint v_other_index = ml_other->v;
                 if (v_other_index != v_index) {
-                  const MVert *mv_other = &data->me->mvert[v_other_index];
+                  const MVert *mv_other = &ss->mvert[v_other_index];
 
                   /* Get the direction from the selected vert to the neighbor. */
                   float other_dir[3];
@@ -2164,11 +2166,10 @@ static void do_wpaint_brush_draw_task_cb_ex(void *__restrict userdata,
       /* NOTE: grids are 1:1 with corners (aka loops).
        * For multires, take the vert whose loop corresponds to the current grid.
        * Otherwise, take the current vert. */
-      const int v_index = has_grids ? data->me->mloop[vd.grid_indices[vd.g]].v :
-                                      vd.vert_indices[vd.i];
+      const int v_index = has_grids ? ss->mloop[vd.grid_indices[vd.g]].v : vd.vert_indices[vd.i];
       const float grid_alpha = has_grids ? 1.0f / vd.gridsize : 1.0f;
 
-      const char v_flag = data->me->mvert[v_index].flag;
+      const char v_flag = ss->mvert[v_index].flag;
       /* If the vertex is selected */
       if (!(use_face_sel || use_vert_sel) || v_flag & SELECT) {
         float brush_strength = cache->bstrength;
@@ -2232,13 +2233,12 @@ static void do_wpaint_brush_calc_average_weight_cb_ex(
                                                       1.0f;
       if (angle_cos > 0.0 &&
           BKE_brush_curve_strength(data->brush, sqrtf(test.dist), cache->radius) > 0.0) {
-        const int v_index = has_grids ? data->me->mloop[vd.grid_indices[vd.g]].v :
-                                        vd.vert_indices[vd.i];
-        const char v_flag = data->me->mvert[v_index].flag;
+        const int v_index = has_grids ? ss->mloop[vd.grid_indices[vd.g]].v : vd.vert_indices[vd.i];
+        const char v_flag = ss->mvert[v_index].flag;
 
         /* If the vertex is selected. */
         if (!(use_face_sel || use_vert_sel) || v_flag & SELECT) {
-          const MDeformVert *dv = &data->me->dvert[v_index];
+          const MDeformVert *dv = &data->wpi->dvert[v_index];
           accum->len += 1;
           accum->value += wpaint_get_active_weight(dv, data->wpi);
         }
@@ -2510,7 +2510,11 @@ static void wpaint_stroke_update_step(bContext *C,
   /* load projection matrix */
   mul_m4_m4m4(mat, vc->rv3d->persmat, ob->obmat);
 
+  Mesh *mesh = static_cast<Mesh *>(ob->data);
+
   /* *** setup WeightPaintInfo - pass onto do_weight_paint_vertex *** */
+  wpi.dvert = mesh->deform_verts_for_write();
+
   wpi.defbase_tot = wpd->defbase_tot;
   wpi.defbase_sel = wpd->defbase_sel;
   wpi.defbase_tot_sel = wpd->defbase_tot_sel;
@@ -2532,7 +2536,7 @@ static void wpaint_stroke_update_step(bContext *C,
   /* *** done setting up WeightPaintInfo *** */
 
   if (wpd->precomputed_weight) {
-    precompute_weight_values(C, ob, brush, wpd, &wpi, (Mesh *)ob->data);
+    precompute_weight_values(C, ob, brush, wpd, &wpi, mesh);
   }
 
   wpaint_do_symmetrical_brush_actions(C, ob, wp, sd, wpd, &wpi);
@@ -2545,9 +2549,9 @@ static void wpaint_stroke_update_step(bContext *C,
   mul_v3_m4v3(loc_world, ob->obmat, ss->cache->true_location);
   paint_last_stroke_update(scene, loc_world);
 
-  BKE_mesh_batch_cache_dirty_tag((Mesh *)ob->data, BKE_MESH_BATCH_DIRTY_ALL);
+  BKE_mesh_batch_cache_dirty_tag(mesh, BKE_MESH_BATCH_DIRTY_ALL);
 
-  DEG_id_tag_update((ID *)ob->data, 0);
+  DEG_id_tag_update(&mesh->id, 0);
   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
   swap_m4m4(wpd->vc.rv3d->persmat, mat);
 
@@ -2980,10 +2984,10 @@ static void do_vpaint_brush_blur_loops(bContext *C,
         if (sculpt_brush_test_sq_fn(&test, vd.co)) {
           /* For grid based pbvh, take the vert whose loop corresponds to the current grid.
            * Otherwise, take the current vert. */
-          const int v_index = has_grids ? me->mloop[vd.grid_indices[vd.g]].v :
+          const int v_index = has_grids ? ss->mloop[vd.grid_indices[vd.g]].v :
                                           vd.vert_indices[vd.i];
           const float grid_alpha = has_grids ? 1.0f / vd.gridsize : 1.0f;
-          const MVert *mv = &me->mvert[v_index];
+          const MVert *mv = &ss->mvert[v_index];
 
           /* If the vertex is selected for painting. */
           if (!use_vert_sel || mv->flag & SELECT) {
@@ -3006,7 +3010,7 @@ static void do_vpaint_brush_blur_loops(bContext *C,
 
               for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
                 int p_index = gmap->vert_to_poly[v_index].indices[j];
-                const MPoly *mp = &me->mpoly[p_index];
+                const MPoly *mp = &ss->mpoly[p_index];
                 if (!use_face_sel || mp->flag & ME_FACE_SEL) {
                   total_hit_loops += mp->totloop;
                   for (int k = 0; k < mp->totloop; k++) {
@@ -3040,8 +3044,8 @@ static void do_vpaint_brush_blur_loops(bContext *C,
                 for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
                   const int p_index = gmap->vert_to_poly[v_index].indices[j];
                   const int l_index = gmap->vert_to_loop[v_index].indices[j];
-                  BLI_assert(me->mloop[l_index].v == v_index);
-                  const MPoly *mp = &me->mpoly[p_index];
+                  BLI_assert(ss->mloop[l_index].v == v_index);
+                  const MPoly *mp = &ss->mpoly[p_index];
                   if (!use_face_sel || mp->flag & ME_FACE_SEL) {
                     Color color_orig(0, 0, 0, 0); /* unused when array is nullptr */
 
@@ -3122,10 +3126,10 @@ static void do_vpaint_brush_blur_verts(bContext *C,
         if (sculpt_brush_test_sq_fn(&test, vd.co)) {
           /* For grid based pbvh, take the vert whose loop corresponds to the current grid.
            * Otherwise, take the current vert. */
-          const int v_index = has_grids ? me->mloop[vd.grid_indices[vd.g]].v :
+          const int v_index = has_grids ? ss->mloop[vd.grid_indices[vd.g]].v :
                                           vd.vert_indices[vd.i];
           const float grid_alpha = has_grids ? 1.0f / vd.gridsize : 1.0f;
-          const MVert *mv = &me->mvert[v_index];
+          const MVert *mv = &ss->mvert[v_index];
 
           /* If the vertex is selected for painting. */
           if (!use_vert_sel || mv->flag & SELECT) {
@@ -3148,12 +3152,12 @@ static void do_vpaint_brush_blur_verts(bContext *C,
 
               for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
                 int p_index = gmap->vert_to_poly[v_index].indices[j];
-                const MPoly *mp = &me->mpoly[p_index];
+                const MPoly *mp = &ss->mpoly[p_index];
                 if (!use_face_sel || mp->flag & ME_FACE_SEL) {
                   total_hit_loops += mp->totloop;
                   for (int k = 0; k < mp->totloop; k++) {
                     const uint l_index = mp->loopstart + k;
-                    const uint v_index = me->mloop[l_index].v;
+                    const uint v_index = ss->mloop[l_index].v;
 
                     Color *col = lcol + v_index;
 
@@ -3184,9 +3188,9 @@ static void do_vpaint_brush_blur_verts(bContext *C,
                 for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
                   const int p_index = gmap->vert_to_poly[v_index].indices[j];
 
-                  BLI_assert(me->mloop[gmap->vert_to_loop[v_index].indices[j]].v == v_index);
+                  BLI_assert(ss->mloop[gmap->vert_to_loop[v_index].indices[j]].v == v_index);
 
-                  const MPoly *mp = &me->mpoly[p_index];
+                  const MPoly *mp = &ss->mpoly[p_index];
                   if (!use_face_sel || mp->flag & ME_FACE_SEL) {
                     Color color_orig(0, 0, 0, 0); /* unused when array is nullptr */
 
@@ -3273,10 +3277,10 @@ static void do_vpaint_brush_smear(bContext *C,
           if (sculpt_brush_test_sq_fn(&test, vd.co)) {
             /* For grid based pbvh, take the vert whose loop corresponds to the current grid.
              * Otherwise, take the current vert. */
-            const int v_index = has_grids ? me->mloop[vd.grid_indices[vd.g]].v :
+            const int v_index = has_grids ? ss->mloop[vd.grid_indices[vd.g]].v :
                                             vd.vert_indices[vd.i];
             const float grid_alpha = has_grids ? 1.0f / vd.gridsize : 1.0f;
-            const MVert *mv_curr = &me->mvert[v_index];
+            const MVert *mv_curr = &ss->mvert[v_index];
 
             /* if the vertex is selected for painting. */
             if (!use_vert_sel || mv_curr->flag & SELECT) {
@@ -3305,15 +3309,15 @@ static void do_vpaint_brush_smear(bContext *C,
                 for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
                   const int p_index = gmap->vert_to_poly[v_index].indices[j];
                   const int l_index = gmap->vert_to_loop[v_index].indices[j];
-                  BLI_assert(me->mloop[l_index].v == v_index);
+                  BLI_assert(ss->mloop[l_index].v == v_index);
                   UNUSED_VARS_NDEBUG(l_index);
-                  const MPoly *mp = &me->mpoly[p_index];
+                  const MPoly *mp = &ss->mpoly[p_index];
                   if (!use_face_sel || mp->flag & ME_FACE_SEL) {
-                    const MLoop *ml_other = &me->mloop[mp->loopstart];
+                    const MLoop *ml_other = &ss->mloop[mp->loopstart];
                     for (int k = 0; k < mp->totloop; k++, ml_other++) {
                       const uint v_other_index = ml_other->v;
                       if (v_other_index != v_index) {
-                        const MVert *mv_other = &me->mvert[v_other_index];
+                        const MVert *mv_other = &ss->mvert[v_other_index];
 
                         /* Get the direction from the
                          * selected vert to the neighbor. */
@@ -3359,10 +3363,10 @@ static void do_vpaint_brush_smear(bContext *C,
                     else {
                       const int l_index = gmap->vert_to_loop[v_index].indices[j];
                       elem_index = l_index;
-                      BLI_assert(me->mloop[l_index].v == v_index);
+                      BLI_assert(ss->mloop[l_index].v == v_index);
                     }
 
-                    const MPoly *mp = &me->mpoly[p_index];
+                    const MPoly *mp = &ss->mpoly[p_index];
                     if (!use_face_sel || mp->flag & ME_FACE_SEL) {
                       /* Get the previous element color */
                       Color color_orig(0, 0, 0, 0); /* unused when array is nullptr */
@@ -3435,11 +3439,11 @@ static void calculate_average_color(VPaintData<Color, Traits, domain> *vpd,
       BKE_pbvh_vertex_iter_begin (ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
         /* Test to see if the vertex coordinates are within the spherical brush region. */
         if (sculpt_brush_test_sq_fn(&test, vd.co)) {
-          const int v_index = has_grids ? me->mloop[vd.grid_indices[vd.g]].v :
+          const int v_index = has_grids ? ss->mloop[vd.grid_indices[vd.g]].v :
                                           vd.vert_indices[vd.i];
           if (BKE_brush_curve_strength(brush, 0.0, cache->radius) > 0.0) {
             /* If the vertex is selected for painting. */
-            const MVert *mv = &me->mvert[v_index];
+            const MVert *mv = &ss->mvert[v_index];
             if (!use_vert_sel || mv->flag & SELECT) {
               accum2->len += gmap->vert_to_loop[v_index].count;
               /* if a vertex is within the brush region, then add its color to the blend. */
@@ -3555,10 +3559,10 @@ static void vpaint_do_draw(bContext *C,
           /* NOTE: Grids are 1:1 with corners (aka loops).
            * For grid based pbvh, take the vert whose loop corresponds to the current grid.
            * Otherwise, take the current vert. */
-          const int v_index = has_grids ? me->mloop[vd.grid_indices[vd.g]].v :
+          const int v_index = has_grids ? ss->mloop[vd.grid_indices[vd.g]].v :
                                           vd.vert_indices[vd.i];
           const float grid_alpha = has_grids ? 1.0f / vd.gridsize : 1.0f;
-          const MVert *mv = &me->mvert[v_index];
+          const MVert *mv = &ss->mvert[v_index];
 
           /* If the vertex is selected for painting. */
           if (!use_vert_sel || mv->flag & SELECT) {
@@ -3612,8 +3616,8 @@ static void vpaint_do_draw(bContext *C,
                 for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
                   const int p_index = gmap->vert_to_poly[v_index].indices[j];
                   const int l_index = gmap->vert_to_loop[v_index].indices[j];
-                  BLI_assert(me->mloop[l_index].v == v_index);
-                  const MPoly *mp = &me->mpoly[p_index];
+                  BLI_assert(ss->mloop[l_index].v == v_index);
+                  const MPoly *mp = &ss->mpoly[p_index];
                   if (!use_face_sel || mp->flag & ME_FACE_SEL) {
                     Color color_orig = Color(0, 0, 0, 0); /* unused when array is nullptr */
 
@@ -4084,27 +4088,30 @@ static bool vertex_color_set(Object *ob, ColorPaint4f paintcol_in, CustomDataLay
   }
   else {
     Color *color_layer = static_cast<Color *>(layer->data);
+    const Span<MVert> verts = me->vertices();
+    const Span<MPoly> polys = me->polygons();
+    const Span<MLoop> loops = me->loops();
 
-    const MPoly *mp = me->mpoly;
-    for (int i = 0; i < me->totpoly; i++, mp++) {
-      if (use_face_sel && !(mp->flag & ME_FACE_SEL)) {
+    for (const int i : polys.index_range()) {
+      const MPoly &poly = polys[i];
+      if (use_face_sel && !(poly.flag & ME_FACE_SEL)) {
         continue;
       }
 
       int j = 0;
       do {
-        uint vidx = me->mloop[mp->loopstart + j].v;
+        uint vidx = loops[poly.loopstart + j].v;
 
-        if (!(use_vert_sel && !(me->mvert[vidx].flag & SELECT))) {
+        if (!(use_vert_sel && !(verts[vidx].flag & SELECT))) {
           if constexpr (domain == ATTR_DOMAIN_CORNER) {
-            color_layer[mp->loopstart + j] = paintcol;
+            color_layer[poly.loopstart + j] = paintcol;
           }
           else {
             color_layer[vidx] = paintcol;
           }
         }
         j++;
-      } while (j < mp->totloop);
+      } while (j < poly.totloop);
     }
 
     /* remove stale me->mcol, will be added later */