1 files changed, 34 insertions, 30 deletions

diff --git a/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc b/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc
index 0af6c76feaf..afc492c40e4 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc
@@ -10,6 +10,7 @@
 
 #include "BKE_attribute_math.hh"
 #include "BKE_bvhutils.h"
+#include "BKE_mesh.h"
 #include "BKE_mesh_runtime.h"
 #include "BKE_mesh_sample.hh"
 
@@ -234,12 +235,12 @@ static void get_closest_mesh_looptris(const Mesh &mesh,
   free_bvhtree_from_mesh(&tree_data);
 }
 
-static void get_closest_mesh_polygons(const Mesh &mesh,
-                                      const VArray<float3> &positions,
-                                      const IndexMask mask,
-                                      const MutableSpan<int> r_poly_indices,
-                                      const MutableSpan<float> r_distances_sq,
-                                      const MutableSpan<float3> r_positions)
+static void get_closest_mesh_polys(const Mesh &mesh,
+                                   const VArray<float3> &positions,
+                                   const IndexMask mask,
+                                   const MutableSpan<int> r_poly_indices,
+                                   const MutableSpan<float> r_distances_sq,
+                                   const MutableSpan<float3> r_positions)
 {
   BLI_assert(mesh.totpoly > 0);
 
@@ -263,23 +264,27 @@ static void get_closest_mesh_corners(const Mesh &mesh,
                                      const MutableSpan<float> r_distances_sq,
                                      const MutableSpan<float3> r_positions)
 {
+  const Span<MVert> verts = mesh.verts();
+  const Span<MPoly> polys = mesh.polys();
+  const Span<MLoop> loops = mesh.loops();
+
   BLI_assert(mesh.totloop > 0);
   Array<int> poly_indices(positions.size());
-  get_closest_mesh_polygons(mesh, positions, mask, poly_indices, {}, {});
+  get_closest_mesh_polys(mesh, positions, mask, poly_indices, {}, {});
 
   for (const int i : mask) {
     const float3 position = positions[i];
     const int poly_index = poly_indices[i];
-    const MPoly &poly = mesh.mpoly[poly_index];
+    const MPoly &poly = polys[poly_index];
 
     /* Find the closest vertex in the polygon. */
     float min_distance_sq = FLT_MAX;
     const MVert *closest_mvert;
     int closest_loop_index = 0;
     for (const int loop_index : IndexRange(poly.loopstart, poly.totloop)) {
-      const MLoop &loop = mesh.mloop[loop_index];
+      const MLoop &loop = loops[loop_index];
       const int vertex_index = loop.v;
-      const MVert &mvert = mesh.mvert[vertex_index];
+      const MVert &mvert = verts[vertex_index];
       const float distance_sq = math::distance_squared(position, float3(mvert.co));
       if (distance_sq < min_distance_sq) {
         min_distance_sq = distance_sq;
@@ -365,7 +370,7 @@ static bool component_is_available(const GeometrySet &geometry,
   if (component.is_empty()) {
     return false;
   }
-  return component.attribute_domain_num(domain) != 0;
+  return component.attribute_domain_size(domain) != 0;
 }
 
 /**
@@ -387,7 +392,7 @@ class NearestInterpolatedTransferFunction : public fn::MultiFunction {
 
   fn::MFSignature signature_;
 
-  std::optional<GeometryComponentFieldContext> source_context_;
+  std::optional<bke::MeshFieldContext> source_context_;
   std::unique_ptr<FieldEvaluator> source_evaluator_;
   const GVArray *source_data_;
 
@@ -431,10 +436,10 @@ class NearestInterpolatedTransferFunction : public fn::MultiFunction {
  private:
   void evaluate_source_field()
   {
-    const MeshComponent &mesh_component = *source_.get_component_for_read<MeshComponent>();
-    source_context_.emplace(GeometryComponentFieldContext{mesh_component, domain_});
-    const int domain_num = mesh_component.attribute_domain_num(domain_);
-    source_evaluator_ = std::make_unique<FieldEvaluator>(*source_context_, domain_num);
+    const Mesh &mesh = *source_.get_mesh_for_read();
+    source_context_.emplace(bke::MeshFieldContext{mesh, domain_});
+    const int domain_size = mesh.attributes().domain_size(domain_);
+    source_evaluator_ = std::make_unique<FieldEvaluator>(*source_context_, domain_size);
     source_evaluator_->add(src_field_);
     source_evaluator_->evaluate();
     source_data_ = &source_evaluator_->get_evaluated(0);
@@ -457,11 +462,11 @@ class NearestTransferFunction : public fn::MultiFunction {
   bool use_points_;
 
   /* Store data from the source as a virtual array, since we may only access a few indices. */
-  std::optional<GeometryComponentFieldContext> mesh_context_;
+  std::optional<bke::MeshFieldContext> mesh_context_;
   std::unique_ptr<FieldEvaluator> mesh_evaluator_;
   const GVArray *mesh_data_;
 
-  std::optional<GeometryComponentFieldContext> point_context_;
+  std::optional<bke::PointCloudFieldContext> point_context_;
   std::unique_ptr<FieldEvaluator> point_evaluator_;
   const GVArray *point_data_;
 
@@ -535,7 +540,7 @@ class NearestTransferFunction : public fn::MultiFunction {
           break;
         }
         case ATTR_DOMAIN_FACE: {
-          get_closest_mesh_polygons(*mesh, positions, mask, mesh_indices, mesh_distances, {});
+          get_closest_mesh_polys(*mesh, positions, mask, mesh_indices, mesh_distances, {});
           break;
         }
         case ATTR_DOMAIN_CORNER: {
@@ -577,20 +582,19 @@ class NearestTransferFunction : public fn::MultiFunction {
   void evaluate_source_field()
   {
     if (use_mesh_) {
-      const MeshComponent &mesh = *source_.get_component_for_read<MeshComponent>();
-      const int domain_num = mesh.attribute_domain_num(domain_);
-      mesh_context_.emplace(GeometryComponentFieldContext(mesh, domain_));
-      mesh_evaluator_ = std::make_unique<FieldEvaluator>(*mesh_context_, domain_num);
+      const Mesh &mesh = *source_.get_mesh_for_read();
+      const int domain_size = mesh.attributes().domain_size(domain_);
+      mesh_context_.emplace(bke::MeshFieldContext(mesh, domain_));
+      mesh_evaluator_ = std::make_unique<FieldEvaluator>(*mesh_context_, domain_size);
       mesh_evaluator_->add(src_field_);
       mesh_evaluator_->evaluate();
       mesh_data_ = &mesh_evaluator_->get_evaluated(0);
     }
 
     if (use_points_) {
-      const PointCloudComponent &points = *source_.get_component_for_read<PointCloudComponent>();
-      const int domain_num = points.attribute_domain_num(domain_);
-      point_context_.emplace(GeometryComponentFieldContext(points, domain_));
-      point_evaluator_ = std::make_unique<FieldEvaluator>(*point_context_, domain_num);
+      const PointCloud &points = *source_.get_pointcloud_for_read();
+      point_context_.emplace(bke::PointCloudFieldContext(points));
+      point_evaluator_ = std::make_unique<FieldEvaluator>(*point_context_, points.totpoint);
       point_evaluator_->add(src_field_);
       point_evaluator_->evaluate();
       point_data_ = &point_evaluator_->get_evaluated(0);
@@ -628,7 +632,7 @@ class IndexTransferFunction : public fn::MultiFunction {
 
   fn::MFSignature signature_;
 
-  std::optional<GeometryComponentFieldContext> geometry_context_;
+  std::optional<bke::GeometryFieldContext> geometry_context_;
   std::unique_ptr<FieldEvaluator> evaluator_;
   const GVArray *src_data_ = nullptr;
 
@@ -658,8 +662,8 @@ class IndexTransferFunction : public fn::MultiFunction {
     if (component == nullptr) {
       return;
     }
-    const int domain_num = component->attribute_domain_num(domain_);
-    geometry_context_.emplace(GeometryComponentFieldContext(*component, domain_));
+    const int domain_num = component->attribute_domain_size(domain_);
+    geometry_context_.emplace(bke::GeometryFieldContext(*component, domain_));
     evaluator_ = std::make_unique<FieldEvaluator>(*geometry_context_, domain_num);
     evaluator_->add(src_field_);
     evaluator_->evaluate();