Merge branch 'master' into refactor-mesh-selection-generic

1 files changed, 50 insertions, 42 deletions

diff --git a/source/blender/editors/sculpt_paint/paint_vertex.cc b/source/blender/editors/sculpt_paint/paint_vertex.cc
index 5f25cdebe78..fa714563fac 100644
--- a/source/blender/editors/sculpt_paint/paint_vertex.cc
+++ b/source/blender/editors/sculpt_paint/paint_vertex.cc
@@ -774,6 +774,8 @@ struct WeightPaintGroupData {
  * paint stroke update - campbell */
 struct WeightPaintInfo {
 
+  MutableSpan<MDeformVert> dvert;
+
   int defbase_tot;
 
   /* both must add up to 'defbase_tot' */
@@ -816,7 +818,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;
@@ -876,7 +878,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);
 
@@ -916,9 +918,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);
@@ -1029,7 +1031,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 */
@@ -1045,7 +1047,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;
@@ -1072,9 +1074,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(
@@ -1236,6 +1238,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;
@@ -1244,15 +1248,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);
@@ -1901,7 +1905,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);
 }
@@ -1966,8 +1970,7 @@ 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;
       /* If the vertex is selected */
       if (!(use_face_sel || use_vert_sel) || selection_vert[v_index]) {
@@ -1976,12 +1979,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];
           }
         }
@@ -2065,10 +2068,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) || selection_vert[v_index]) {
@@ -2090,12 +2092,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];
@@ -2176,8 +2178,7 @@ 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;
 
       /* If the vertex is selected */
@@ -2524,7 +2525,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;
@@ -2546,7 +2551,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);
@@ -2559,9 +2564,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);
 
@@ -2999,7 +3004,7 @@ 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;
 
@@ -3144,7 +3149,7 @@ 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;
 
@@ -3174,7 +3179,7 @@ static void do_vpaint_brush_blur_verts(bContext *C,
                   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;
 
@@ -3205,7 +3210,7 @@ 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);
 
                   if (!use_face_sel || selection_poly[p_index]) {
                     Color color_orig(0, 0, 0, 0); /* unused when array is nullptr */
@@ -3298,10 +3303,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 || selection_vert[v_index]) {
@@ -3330,7 +3335,7 @@ 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];
                   if (!use_face_sel || selection_poly[p_index]) {
@@ -3338,7 +3343,7 @@ static void do_vpaint_brush_smear(bContext *C,
                     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. */
@@ -3384,7 +3389,7 @@ 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);
                     }
 
                     if (!use_face_sel || selection_poly[p_index]) {
@@ -3462,7 +3467,7 @@ 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. */
@@ -3586,7 +3591,7 @@ 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;
 
@@ -4118,6 +4123,9 @@ 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++) {
@@ -4127,18 +4135,18 @@ static bool vertex_color_set(Object *ob, ColorPaint4f paintcol_in, CustomDataLay
 
       int j = 0;
       do {
-        uint vidx = me->mloop[mp->loopstart + j].v;
+        uint vidx = loops[poly.loopstart + j].v;
 
         if (!(use_vert_sel && !(selection_vert[vidx]))) {
           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 */