Curves: Interpolate point count in add brush

This commit adds an option to interpolate the number of control points
in new curves based on the count in neighboring existing curves. The
idea is to provide a more automatic default than manually controlling
the number of points in a curve, so users don't have to think about
the resolution quite as much.

Internally, some utilities for creating new curves are extracted to a
new header file. These can be used for the various nodes and operators
that create new curves.

The top-bar UI will be adjusted in a separate patch, probably moving
all of the settings that affect the size and shape of the new curves
into a popover.

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

1 files changed, 60 insertions, 37 deletions

diff --git a/source/blender/editors/sculpt_paint/curves_sculpt_add.cc b/source/blender/editors/sculpt_paint/curves_sculpt_add.cc
index 6edc9194319..18bdbb88d8f 100644
--- a/source/blender/editors/sculpt_paint/curves_sculpt_add.cc
+++ b/source/blender/editors/sculpt_paint/curves_sculpt_add.cc
@@ -18,6 +18,7 @@
 #include "BKE_bvhutils.h"
 #include "BKE_context.h"
 #include "BKE_curves.hh"
+#include "BKE_curves_utils.hh"
 #include "BKE_mesh.h"
 #include "BKE_mesh_runtime.h"
 #include "BKE_paint.h"
@@ -105,10 +106,11 @@ struct AddOperationExecutor {
   bool use_front_face_;
   bool interpolate_length_;
   bool interpolate_shape_;
+  bool interpolate_point_count_;
   bool use_interpolation_;
   float new_curve_length_;
   int add_amount_;
-  int points_per_curve_;
+  int constant_points_per_curve_;
 
   /** Various matrices to convert between coordinate spaces. */
   float4x4 curves_to_world_mat_;
@@ -129,6 +131,15 @@ struct AddOperationExecutor {
     Vector<int> looptri_indices;
   };
 
+  struct NeighborInfo {
+    /* Curve index of the neighbor. */
+    int index;
+    /* The weights of all neighbors of a new curve add up to 1. */
+    float weight;
+  };
+  static constexpr int max_neighbors = 5;
+  using NeighborsVector = Vector<NeighborInfo, max_neighbors>;
+
   void execute(AddOperation &self, bContext *C, const StrokeExtension &stroke_extension)
   {
     self_ = &self;
@@ -172,10 +183,12 @@ struct AddOperationExecutor {
     const eBrushFalloffShape falloff_shape = static_cast<eBrushFalloffShape>(
         brush_->falloff_shape);
     add_amount_ = std::max(0, brush_settings_->add_amount);
-    points_per_curve_ = std::max(2, brush_settings_->points_per_curve);
+    constant_points_per_curve_ = std::max(2, brush_settings_->points_per_curve);
     interpolate_length_ = brush_settings_->flag & BRUSH_CURVES_SCULPT_FLAG_INTERPOLATE_LENGTH;
     interpolate_shape_ = brush_settings_->flag & BRUSH_CURVES_SCULPT_FLAG_INTERPOLATE_SHAPE;
-    use_interpolation_ = interpolate_length_ || interpolate_shape_;
+    interpolate_point_count_ = brush_settings_->flag &
+                               BRUSH_CURVES_SCULPT_FLAG_INTERPOLATE_POINT_COUNT;
+    use_interpolation_ = interpolate_length_ || interpolate_shape_ || interpolate_point_count_;
     new_curve_length_ = brush_settings_->curve_length;
 
     tot_old_curves_ = curves_->curves_num();
@@ -215,18 +228,26 @@ struct AddOperationExecutor {
       return;
     }
 
+    Array<NeighborsVector> neighbors_per_curve;
     if (use_interpolation_) {
       this->ensure_curve_roots_kdtree();
+      neighbors_per_curve = this->find_curve_neighbors(added_points);
     }
 
+    /* Resize to add the new curves, building the offests in the array owned by thge curves. */
     const int tot_added_curves = added_points.bary_coords.size();
-    const int tot_added_points = tot_added_curves * points_per_curve_;
+    curves_->resize(curves_->points_num(), curves_->curves_num() + tot_added_curves);
+    if (interpolate_point_count_) {
+      this->initialize_curve_offsets_with_interpolation(neighbors_per_curve);
+    }
+    else {
+      this->initialize_curve_offsets_without_interpolation(constant_points_per_curve_);
+    }
 
-    curves_->resize(curves_->points_num() + tot_added_points,
-                    curves_->curves_num() + tot_added_curves);
+    /* Resize to add the correct point count calculated as part of building the offsets. */
+    curves_->resize(curves_->offsets().last(), curves_->curves_num());
 
-    threading::parallel_invoke([&]() { this->initialize_curve_offsets(tot_added_curves); },
-                               [&]() { this->initialize_attributes(added_points); });
+    this->initialize_attributes(added_points, neighbors_per_curve);
 
     curves_->update_curve_types();
 
@@ -580,33 +601,37 @@ struct AddOperationExecutor {
     }
   }
 
-  void initialize_curve_offsets(const int tot_added_curves)
+  void initialize_curve_offsets_with_interpolation(const Span<NeighborsVector> neighbors_per_curve)
   {
-    MutableSpan<int> offsets = curves_->offsets_for_write();
-    threading::parallel_for(IndexRange(tot_added_curves), 1024, [&](const IndexRange range) {
-      for (const int i : range) {
-        const int curve_i = tot_old_curves_ + i;
-        offsets[curve_i + 1] = tot_old_points_ + (i + 1) * points_per_curve_;
+    MutableSpan<int> new_offsets = curves_->offsets_for_write().drop_front(tot_old_curves_);
+
+    attribute_math::DefaultMixer<int> mixer{new_offsets};
+    threading::parallel_for(neighbors_per_curve.index_range(), 1024, [&](IndexRange curves_range) {
+      for (const int i : curves_range) {
+        for (const NeighborInfo &neighbor : neighbors_per_curve[i]) {
+          const int neighbor_points_num = curves_->points_for_curve(neighbor.index).size();
+          mixer.mix_in(i, neighbor_points_num, neighbor.weight);
+        }
       }
     });
-  }
+    mixer.finalize();
 
-  struct NeighborInfo {
-    /* Curve index of the neighbor. */
-    int index;
-    /* The weights of all neighbors of a new curve add up to 1. */
-    float weight;
-  };
-  static constexpr int max_neighbors = 5;
-  using NeighborsVector = Vector<NeighborInfo, max_neighbors>;
+    bke::curves::accumulate_counts_to_offsets(new_offsets, tot_old_points_);
+  }
 
-  void initialize_attributes(const AddedPoints &added_points)
+  void initialize_curve_offsets_without_interpolation(const int points_per_curve)
   {
-    Array<NeighborsVector> neighbors_per_curve;
-    if (use_interpolation_) {
-      neighbors_per_curve = this->find_curve_neighbors(added_points);
+    MutableSpan<int> new_offsets = curves_->offsets_for_write().drop_front(tot_old_curves_);
+    int offset = tot_old_points_;
+    for (const int i : new_offsets.index_range()) {
+      new_offsets[i] = offset;
+      offset += points_per_curve;
     }
+  }
 
+  void initialize_attributes(const AddedPoints &added_points,
+                             const Span<NeighborsVector> neighbors_per_curve)
+  {
     Array<float> new_lengths_cu(added_points.bary_coords.size());
     if (interpolate_length_) {
       this->interpolate_lengths(neighbors_per_curve, new_lengths_cu);
@@ -735,15 +760,14 @@ struct AddOperationExecutor {
     threading::parallel_for(
         added_points.bary_coords.index_range(), 256, [&](const IndexRange range) {
           for (const int i : range) {
-            const int first_point_i = tot_old_points_ + i * points_per_curve_;
+            const IndexRange points = curves_->points_for_curve(tot_old_curves_ + i);
             const float3 &root_cu = added_points.positions_cu[i];
             const float length = lengths_cu[i];
             const float3 &normal_su = normals_su[i];
             const float3 normal_cu = math::normalize(surface_to_curves_normal_mat_ * normal_su);
             const float3 tip_cu = root_cu + length * normal_cu;
 
-            initialize_straight_curve_positions(
-                root_cu, tip_cu, positions_cu.slice(first_point_i, points_per_curve_));
+            initialize_straight_curve_positions(root_cu, tip_cu, positions_cu.slice(points));
           }
         });
   }
@@ -764,23 +788,22 @@ struct AddOperationExecutor {
         added_points.bary_coords.index_range(), 256, [&](const IndexRange range) {
           for (const int i : range) {
             const Span<NeighborInfo> neighbors = neighbors_per_curve[i];
+            const IndexRange points = curves_->points_for_curve(tot_old_curves_ + i);
 
             const float length_cu = new_lengths_cu[i];
             const float3 &normal_su = new_normals_su[i];
             const float3 normal_cu = math::normalize(surface_to_curves_normal_mat_ * normal_su);
 
             const float3 &root_cu = added_points.positions_cu[i];
-            const int first_point_i = tot_old_points_ + i * points_per_curve_;
 
             if (neighbors.is_empty()) {
               /* If there are no neighbors, just make a straight line. */
               const float3 tip_cu = root_cu + length_cu * normal_cu;
-              initialize_straight_curve_positions(
-                  root_cu, tip_cu, positions_cu.slice(first_point_i, points_per_curve_));
+              initialize_straight_curve_positions(root_cu, tip_cu, positions_cu.slice(points));
               continue;
             }
 
-            positions_cu.slice(first_point_i, points_per_curve_).fill(root_cu);
+            positions_cu.slice(points).fill(root_cu);
 
             for (const NeighborInfo &neighbor : neighbors) {
               const int neighbor_curve_i = neighbor.index;
@@ -814,8 +837,8 @@ struct AddOperationExecutor {
               const float neighbor_length_cu = neighbor_spline.length();
               const float length_factor = std::min(1.0f, length_cu / neighbor_length_cu);
 
-              const float resample_factor = (1.0f / (points_per_curve_ - 1.0f)) * length_factor;
-              for (const int j : IndexRange(points_per_curve_)) {
+              const float resample_factor = (1.0f / (points.size() - 1.0f)) * length_factor;
+              for (const int j : IndexRange(points.size())) {
                 const Spline::LookupResult lookup = neighbor_spline.lookup_evaluated_factor(
                     j * resample_factor);
                 const float index_factor = lookup.evaluated_index + lookup.factor;
@@ -825,7 +848,7 @@ struct AddOperationExecutor {
                 const float3 relative_coord = p - neighbor_root_cu;
                 float3 rotated_relative_coord = relative_coord;
                 mul_m3_v3(normal_rotation_cu, rotated_relative_coord);
-                positions_cu[first_point_i + j] += neighbor.weight * rotated_relative_coord;
+                positions_cu[points[j]] += neighbor.weight * rotated_relative_coord;
               }
             }
           }