Merge branch 'master' into refactor-mesh-uv-map-generic

1 files changed, 83 insertions, 80 deletions

diff --git a/source/blender/blenkernel/intern/mesh_evaluate.cc b/source/blender/blenkernel/intern/mesh_evaluate.cc
index e644bfbb52c..60365860583 100644
--- a/source/blender/blenkernel/intern/mesh_evaluate.cc
+++ b/source/blender/blenkernel/intern/mesh_evaluate.cc
@@ -150,7 +150,7 @@ static void mesh_calc_ngon_center(const MPoly *mpoly,
                                   const MVert *mvert,
                                   float cent[3])
 {
-  const float w = 1.0f / (float)mpoly->totloop;
+  const float w = 1.0f / float(mpoly->totloop);
 
   zero_v3(cent);
 
@@ -190,7 +190,7 @@ float BKE_mesh_calc_poly_area(const MPoly *mpoly, const MLoop *loopstart, const
   }
 
   const MLoop *l_iter = loopstart;
-  float(*vertexcos)[3] = (float(*)[3])BLI_array_alloca(vertexcos, (size_t)mpoly->totloop);
+  float(*vertexcos)[3] = (float(*)[3])BLI_array_alloca(vertexcos, size_t(mpoly->totloop));
 
   /* pack vertex cos into an array for area_poly_v3 */
   for (int i = 0; i < mpoly->totloop; i++, l_iter++) {
@@ -198,7 +198,7 @@ float BKE_mesh_calc_poly_area(const MPoly *mpoly, const MLoop *loopstart, const
   }
 
   /* finally calculate the area */
-  float area = area_poly_v3((const float(*)[3])vertexcos, (uint)mpoly->totloop);
+  float area = area_poly_v3((const float(*)[3])vertexcos, uint(mpoly->totloop));
 
   return area;
 }
@@ -216,6 +216,24 @@ float BKE_mesh_calc_area(const Mesh *me)
   return total_area;
 }
 
+float BKE_mesh_calc_poly_uv_area(const MPoly *mpoly, const float (*uv_array)[2] )
+{
+
+  int i, l_iter = mpoly->loopstart;
+  float area;
+  float(*vertexcos)[2] = (float(*)[2])BLI_array_alloca(vertexcos, size_t(mpoly->totloop));
+
+  /* pack vertex cos into an array for area_poly_v2 */
+  for (i = 0; i < mpoly->totloop; i++, l_iter++) {
+    copy_v2_v2(vertexcos[i], uv_array[l_iter]);
+  }
+
+  /* finally calculate the area */
+  area = area_poly_v2(vertexcos, uint(mpoly->totloop));
+
+  return area;
+}
+
 static float UNUSED_FUNCTION(mesh_calc_poly_volume_centroid)(const MPoly *mpoly,
                                                              const MLoop *loopstart,
                                                              const MVert *mvarray,
@@ -389,7 +407,7 @@ bool BKE_mesh_center_median(const Mesh *me, float r_cent[3])
   }
   /* otherwise we get NAN for 0 verts */
   if (me->totvert) {
-    mul_v3_fl(r_cent, 1.0f / (float)me->totvert);
+    mul_v3_fl(r_cent, 1.0f / float(me->totvert));
   }
   return (me->totvert != 0);
 }
@@ -410,7 +428,7 @@ bool BKE_mesh_center_median_from_polys(const Mesh *me, float r_cent[3])
   }
   /* otherwise we get NAN for 0 verts */
   if (me->totpoly) {
-    mul_v3_fl(r_cent, 1.0f / (float)tot);
+    mul_v3_fl(r_cent, 1.0f / float(tot));
   }
   return (me->totpoly != 0);
 }
@@ -620,7 +638,7 @@ void BKE_mesh_mdisp_flip(MDisps *md, const bool use_loop_mdisp_flip)
     return;
   }
 
-  const int sides = (int)sqrt(md->totdisp);
+  const int sides = int(sqrt(md->totdisp));
   float(*co)[3] = md->disps;
 
   for (int x = 0; x < sides; x++) {
@@ -800,103 +818,88 @@ void BKE_mesh_flush_hidden_from_polys(Mesh *me)
   hide_edge.finish();
 }
 
-void BKE_mesh_flush_select_from_polys_ex(MVert *mvert,
-                                         const int totvert,
-                                         const MLoop *mloop,
-                                         MEdge *medge,
-                                         const int totedge,
-                                         const MPoly *mpoly,
-                                         const int totpoly)
+void BKE_mesh_flush_select_from_polys(Mesh *me)
 {
-  MVert *mv;
-  MEdge *med;
-  const MPoly *mp;
-
-  int i = totvert;
-  for (mv = mvert; i--; mv++) {
-    mv->flag &= (char)~SELECT;
+  using namespace blender::bke;
+  MutableAttributeAccessor attributes = me->attributes_for_write();
+  const VArray<bool> select_poly = attributes.lookup_or_default<bool>(
+      ".select_poly", ATTR_DOMAIN_FACE, false);
+  if (select_poly.is_single() && !select_poly.get_internal_single()) {
+    attributes.remove(".select_vert");
+    attributes.remove(".select_edge");
+    return;
   }
+  SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_only_span<bool>(
+      ".select_vert", ATTR_DOMAIN_POINT);
+  SpanAttributeWriter<bool> select_edge = attributes.lookup_or_add_for_write_only_span<bool>(
+      ".select_edge", ATTR_DOMAIN_EDGE);
 
-  i = totedge;
-  for (med = medge; i--; med++) {
-    med->flag &= ~SELECT;
-  }
+  /* Use generic domain interpolation to read the polygon attribute on the other domains.
+   * Assume selected faces are not hidden and none of their vertices/edges are hidden. */
+  attributes.lookup_or_default<bool>(".select_poly", ATTR_DOMAIN_POINT, false)
+      .materialize(select_vert.span);
+  attributes.lookup_or_default<bool>(".select_poly", ATTR_DOMAIN_EDGE, false)
+      .materialize(select_edge.span);
 
-  i = totpoly;
-  for (mp = mpoly; i--; mp++) {
-    /* Assume if its selected its not hidden and none of its verts/edges are hidden
-     * (a common assumption). */
-    if (mp->flag & ME_FACE_SEL) {
-      const MLoop *ml;
-      int j;
-      j = mp->totloop;
-      for (ml = &mloop[mp->loopstart]; j--; ml++) {
-        mvert[ml->v].flag |= SELECT;
-        medge[ml->e].flag |= SELECT;
-      }
-    }
-  }
-}
-void BKE_mesh_flush_select_from_polys(Mesh *me)
-{
-  BKE_mesh_flush_select_from_polys_ex(me->verts_for_write().data(),
-                                      me->totvert,
-                                      me->loops().data(),
-                                      me->edges_for_write().data(),
-                                      me->totedge,
-                                      me->polys().data(),
-                                      me->totpoly);
+  select_vert.finish();
+  select_edge.finish();
 }
 
-static void mesh_flush_select_from_verts(const Span<MVert> verts,
+static void mesh_flush_select_from_verts(const Span<MEdge> edges,
+                                         const Span<MPoly> polys,
                                          const Span<MLoop> loops,
                                          const VArray<bool> &hide_edge,
                                          const VArray<bool> &hide_poly,
-                                         MutableSpan<MEdge> edges,
-                                         MutableSpan<MPoly> polys)
+                                         const VArray<bool> &select_vert,
+                                         MutableSpan<bool> select_edge,
+                                         MutableSpan<bool> select_poly)
 {
+  /* Select visible edges that have both of their vertices selected. */
   for (const int i : edges.index_range()) {
     if (!hide_edge[i]) {
-      MEdge &edge = edges[i];
-      if ((verts[edge.v1].flag & SELECT) && (verts[edge.v2].flag & SELECT)) {
-        edge.flag |= SELECT;
-      }
-      else {
-        edge.flag &= ~SELECT;
-      }
+      const MEdge &edge = edges[i];
+      select_edge[i] = select_vert[edge.v1] && select_vert[edge.v2];
     }
   }
 
+  /* Select visible faces that have all of their vertices selected. */
   for (const int i : polys.index_range()) {
-    if (hide_poly[i]) {
-      continue;
-    }
-    MPoly &poly = polys[i];
-    bool all_verts_selected = true;
-    for (const MLoop &loop : loops.slice(poly.loopstart, poly.totloop)) {
-      if (!(verts[loop.v].flag & SELECT)) {
-        all_verts_selected = false;
-      }
-    }
-    if (all_verts_selected) {
-      poly.flag |= ME_FACE_SEL;
-    }
-    else {
-      poly.flag &= (char)~ME_FACE_SEL;
+    if (!hide_poly[i]) {
+      const MPoly &poly = polys[i];
+      const Span<MLoop> poly_loops = loops.slice(poly.loopstart, poly.totloop);
+      select_poly[i] = std::all_of(poly_loops.begin(), poly_loops.end(), [&](const MLoop &loop) {
+        return select_vert[loop.v];
+      });
     }
   }
 }
 
 void BKE_mesh_flush_select_from_verts(Mesh *me)
 {
-  const blender::bke::AttributeAccessor attributes = me->attributes();
+  using namespace blender::bke;
+  MutableAttributeAccessor attributes = me->attributes_for_write();
+  const VArray<bool> select_vert = attributes.lookup_or_default<bool>(
+      ".select_vert", ATTR_DOMAIN_POINT, false);
+  if (select_vert.is_single() && !select_vert.get_internal_single()) {
+    attributes.remove(".select_edge");
+    attributes.remove(".select_poly");
+    return;
+  }
+  SpanAttributeWriter<bool> select_edge = attributes.lookup_or_add_for_write_only_span<bool>(
+      ".select_edge", ATTR_DOMAIN_EDGE);
+  SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_only_span<bool>(
+      ".select_poly", ATTR_DOMAIN_FACE);
   mesh_flush_select_from_verts(
-      me->verts(),
+      me->edges(),
+      me->polys(),
       me->loops(),
       attributes.lookup_or_default<bool>(".hide_edge", ATTR_DOMAIN_EDGE, false),
       attributes.lookup_or_default<bool>(".hide_poly", ATTR_DOMAIN_FACE, false),
-      me->edges_for_write(),
-      me->polys_for_write());
+      select_vert,
+      select_edge.span,
+      select_poly.span);
+  select_edge.finish();
+  select_poly.finish();
 }
 
 /** \} */
@@ -919,9 +922,9 @@ void BKE_mesh_calc_relative_deform(const MPoly *mpoly,
   const MPoly *mp;
   int i;
 
-  int *vert_accum = (int *)MEM_calloc_arrayN((size_t)totvert, sizeof(*vert_accum), __func__);
+  int *vert_accum = (int *)MEM_calloc_arrayN(size_t(totvert), sizeof(*vert_accum), __func__);
 
-  memset(vert_cos_new, '\0', sizeof(*vert_cos_new) * (size_t)totvert);
+  memset(vert_cos_new, '\0', sizeof(*vert_cos_new) * size_t(totvert));
 
   for (i = 0, mp = mpoly; i < totpoly; i++, mp++) {
     const MLoop *loopstart = mloop + mp->loopstart;
@@ -949,7 +952,7 @@ void BKE_mesh_calc_relative_deform(const MPoly *mpoly,
 
   for (i = 0; i < totvert; i++) {
     if (vert_accum[i]) {
-      mul_v3_fl(vert_cos_new[i], 1.0f / (float)vert_accum[i]);
+      mul_v3_fl(vert_cos_new[i], 1.0f / float(vert_accum[i]));
     }
     else {
       copy_v3_v3(vert_cos_new[i], vert_cos_org[i]);