Cleanup: Adjust naming in new curves code

Rename "size" variables and functions to use "num" instead,
based on T85728 (though this doesn't apply to simple C++
containers, it applies here). Rename "range" to "points" in
some functions, so be more specific.

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

5 files changed, 22 insertions, 22 deletions

diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_endpoint_selection.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_endpoint_selection.cc
index 2c72e5f14f5..1ef4705ed75 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_endpoint_selection.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_endpoint_selection.cc
@@ -55,24 +55,24 @@ class EndpointFieldInput final : public GeometryFieldInput {
 
     const Curves &curves_id = *curve_component.get_for_read();
     const bke::CurvesGeometry &curves = bke::CurvesGeometry::wrap(curves_id.geometry);
-    if (curves.points_size() == 0) {
+    if (curves.num_points() == 0) {
       return nullptr;
     }
 
     GeometryComponentFieldContext size_context{curve_component, ATTR_DOMAIN_CURVE};
-    fn::FieldEvaluator evaluator{size_context, curves.curves_size()};
+    fn::FieldEvaluator evaluator{size_context, curves.num_curves()};
     evaluator.add(start_size_);
     evaluator.add(end_size_);
     evaluator.evaluate();
     const VArray<int> &start_size = evaluator.get_evaluated<int>(0);
     const VArray<int> &end_size = evaluator.get_evaluated<int>(1);
 
-    Array<bool> selection(curves.points_size(), false);
+    Array<bool> selection(curves.num_points(), false);
     MutableSpan<bool> selection_span = selection.as_mutable_span();
     devirtualize_varray2(start_size, end_size, [&](const auto &start_size, const auto &end_size) {
       threading::parallel_for(curves.curves_range(), 1024, [&](IndexRange curves_range) {
         for (const int i : curves_range) {
-          const IndexRange range = curves.range_for_curve(i);
+          const IndexRange range = curves.points_for_curve(i);
           const int start = std::max(start_size[i], 0);
           const int end = std::max(end_size[i], 0);
 
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc
index 42c83d7a9e5..5c7c9f22e15 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc
@@ -46,13 +46,13 @@ static meshintersect::CDT_result<double> do_cdt(const bke::CurvesGeometry &curve
   meshintersect::CDT_input<double> input;
   input.need_ids = false;
   input.vert.reinitialize(curves.evaluated_points_size());
-  input.face.reinitialize(curves.curves_size());
+  input.face.reinitialize(curves.num_curves());
 
   VArray<bool> cyclic = curves.cyclic();
   Span<float3> positions = curves.evaluated_positions();
 
   for (const int i_curve : curves.curves_range()) {
-    const IndexRange points = curves.evaluated_range_for_curve(i_curve);
+    const IndexRange points = curves.evaluated_points_for_curve(i_curve);
     const int segment_size = bke::curves::curve_segment_size(points.size(), cyclic[i_curve]);
 
     for (const int i : points) {
@@ -118,7 +118,7 @@ static void curve_fill_calculate(GeometrySet &geometry_set, const GeometryNodeCu
 
   const Curves &curves_id = *geometry_set.get_curves_for_read();
   const bke::CurvesGeometry &curves = bke::CurvesGeometry::wrap(curves_id.geometry);
-  if (curves.curves_size() == 0) {
+  if (curves.num_curves() == 0) {
     geometry_set.replace_curves(nullptr);
     return;
   }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_handle_type_selection.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_handle_type_selection.cc
index 775376d473e..dc2b9d40894 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_handle_type_selection.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_handle_type_selection.cc
@@ -57,7 +57,7 @@ static void select_by_handle_type(const bke::CurvesGeometry &curves,
   VArray<int8_t> right = curves.handle_types_right();
 
   for (const int i_curve : curves.curves_range()) {
-    const IndexRange points = curves.range_for_curve(i_curve);
+    const IndexRange points = curves.points_for_curve(i_curve);
     if (curve_types[i_curve] != CURVE_TYPE_BEZIER) {
       r_selection.slice(points).fill(false);
     }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_duplicate_elements.cc b/source/blender/nodes/geometry/nodes/node_geo_duplicate_elements.cc
index 39e5748daa5..da4e99026c3 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_duplicate_elements.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_duplicate_elements.cc
@@ -273,9 +273,9 @@ static void copy_curve_attributes_without_id(const GeometrySet &geometry_set,
           threading::parallel_for(selection.index_range(), 512, [&](IndexRange range) {
             for (const int i_selection : range) {
               const int i_src_curve = selection[i_selection];
-              const Span<T> curve_src = src.slice(src_curves.range_for_curve(i_src_curve));
+              const Span<T> curve_src = src.slice(src_curves.points_for_curve(i_src_curve));
               for (const int i_dst_curve : range_for_offsets_index(curve_offsets, i_selection)) {
-                dst.slice(dst_curves.range_for_curve(i_dst_curve)).copy_from(curve_src);
+                dst.slice(dst_curves.points_for_curve(i_dst_curve)).copy_from(curve_src);
               }
             }
           });
@@ -317,12 +317,12 @@ static void copy_stable_id_curves(const bke::CurvesGeometry &src_curves,
   threading::parallel_for(selection.index_range(), 512, [&](IndexRange range) {
     for (const int i_selection : range) {
       const int i_src_curve = selection[i_selection];
-      const Span<int> curve_src = src.slice(src_curves.range_for_curve(i_src_curve));
+      const Span<int> curve_src = src.slice(src_curves.points_for_curve(i_src_curve));
       const IndexRange duplicates_range = range_for_offsets_index(curve_offsets, i_selection);
       for (const int i_duplicate : IndexRange(duplicates_range.size()).drop_front(1)) {
         const int i_dst_curve = duplicates_range[i_duplicate];
         copy_hashed_ids(
-            curve_src, i_duplicate, dst.slice(dst_curves.range_for_curve(i_dst_curve)));
+            curve_src, i_duplicate, dst.slice(dst_curves.points_for_curve(i_dst_curve)));
       }
     }
   });
@@ -345,7 +345,7 @@ static void duplicate_curves(GeometrySet &geometry_set,
   const bke::CurvesGeometry &curves = bke::CurvesGeometry::wrap(curves_id.geometry);
 
   GeometryComponentFieldContext field_context{src_component, ATTR_DOMAIN_CURVE};
-  FieldEvaluator evaluator{field_context, curves.curves_size()};
+  FieldEvaluator evaluator{field_context, curves.num_curves()};
   evaluator.add(count_field);
   evaluator.set_selection(selection_field);
   evaluator.evaluate();
@@ -363,7 +363,7 @@ static void duplicate_curves(GeometrySet &geometry_set,
     curve_offsets[i_curve] = dst_curves_size;
     point_offsets[i_curve] = dst_points_size;
     dst_curves_size += count;
-    dst_points_size += count * curves.range_for_curve(selection[i_curve]).size();
+    dst_points_size += count * curves.points_for_curve(selection[i_curve]).size();
   }
   curve_offsets.last() = dst_curves_size;
   point_offsets.last() = dst_points_size;
@@ -375,7 +375,7 @@ static void duplicate_curves(GeometrySet &geometry_set,
   threading::parallel_for(selection.index_range(), 512, [&](IndexRange range) {
     for (const int i_selection : range) {
       const int i_src_curve = selection[i_selection];
-      const IndexRange src_curve_range = curves.range_for_curve(i_src_curve);
+      const IndexRange src_curve_range = curves.points_for_curve(i_src_curve);
       const IndexRange dst_curves_range = range_for_offsets_index(curve_offsets, i_selection);
       MutableSpan<int> dst_offsets = all_dst_offsets.slice(dst_curves_range);
       for (const int i_duplicate : IndexRange(dst_curves_range.size())) {
@@ -800,12 +800,12 @@ static void duplicate_points_curve(GeometrySet &geometry_set,
   const CurveComponent &src_component = *geometry_set.get_component_for_read<CurveComponent>();
   const Curves &src_curves_id = *src_component.get_for_read();
   const bke::CurvesGeometry &src_curves = bke::CurvesGeometry::wrap(src_curves_id.geometry);
-  if (src_curves.points_size() == 0) {
+  if (src_curves.num_points() == 0) {
     return;
   }
 
   GeometryComponentFieldContext field_context{src_component, ATTR_DOMAIN_POINT};
-  FieldEvaluator evaluator{field_context, src_curves.points_size()};
+  FieldEvaluator evaluator{field_context, src_curves.num_points()};
   evaluator.add(count_field);
   evaluator.set_selection(selection_field);
   evaluator.evaluate();
@@ -815,10 +815,10 @@ static void duplicate_points_curve(GeometrySet &geometry_set,
   Array<int> offsets = accumulate_counts_to_offsets(selection, counts);
   const int dst_size = offsets.last();
 
-  Array<int> point_to_curve_map(src_curves.points_size());
+  Array<int> point_to_curve_map(src_curves.num_points());
   threading::parallel_for(src_curves.curves_range(), 1024, [&](const IndexRange range) {
     for (const int i_curve : range) {
-      const IndexRange point_range = src_curves.range_for_curve(i_curve);
+      const IndexRange point_range = src_curves.points_for_curve(i_curve);
       point_to_curve_map.as_mutable_span().slice(point_range).fill(i_curve);
     }
   });
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_spline_length.cc b/source/blender/nodes/geometry/nodes/node_geo_input_spline_length.cc
index 197cb6e6852..3cf5aebda12 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_spline_length.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_spline_length.cc
@@ -86,13 +86,13 @@ static VArray<int> construct_spline_count_gvarray(const CurveComponent &componen
   const Curves &curves_id = *component.get_for_read();
   const bke::CurvesGeometry &curves = bke::CurvesGeometry::wrap(curves_id.geometry);
 
-  auto count_fn = [curves](int64_t i) { return curves.range_for_curve(i).size(); };
+  auto count_fn = [curves](int64_t i) { return curves.points_for_curve(i).size(); };
 
   if (domain == ATTR_DOMAIN_CURVE) {
-    return VArray<int>::ForFunc(curves.curves_size(), count_fn);
+    return VArray<int>::ForFunc(curves.num_curves(), count_fn);
   }
   if (domain == ATTR_DOMAIN_POINT) {
-    VArray<int> count = VArray<int>::ForFunc(curves.curves_size(), count_fn);
+    VArray<int> count = VArray<int>::ForFunc(curves.num_curves(), count_fn);
     return component.attribute_try_adapt_domain<int>(
         std::move(count), ATTR_DOMAIN_CURVE, ATTR_DOMAIN_POINT);
   }