Fix eraser UI after rebase

Removes the `StrokeCache` and all it's depending code.
The drawing operator now draws directly into the `CurvesGeometry`
on the drawing.

@@ -476,0 +475,4 @@
+            [positions, radii](int64_t first_index, int64_t last_index, int64_t index) {
+              const float dist_position = dist_to_line_v3(
+                  positions[index], positions[first_index], positions[last_index]);
+              /* We devide the distance by 2000.0f to convert from "pixels" to an actual distance.

@@ -0,0 +28,4 @@
+    if (align_flag & GP_PROJECT_CURSOR) {
+      return float3(scene->cursor.location);
+    }
+    else {

@@ -0,0 +62,4 @@
+
+  /* Use an (arbitrary) screen space offset in the x direction to measure the size. */
+  const int x_offest = 64;
+  const float brush_size = static_cast<float>(BKE_brush_size_get(scene, brush));

@@ -128,0 +146,4 @@
+      BKE_report(op->reports, RPT_ERROR, "No Grease Pencil frame to draw on");
+      return OPERATOR_CANCELLED;
+    }
+    else {

@@ -22,0 +30,4 @@
+
+static constexpr int64_t STOKE_CACHE_ALLOCATION_CHUNK_SIZE = 1024;
+
+/** Forward differencing of a bezier curve segment (q0,q1,q2,q3). Steps are written to \a r_p.

@@ -22,0 +76,4 @@
+  }
+  return points;
+}
+

@@ -58,0 +255,4 @@
+    const float max_radius_px = 30.0f;
+    const int64_t max_samples = 64;
+    const float angle_threshold = 0.6f;
+    IndexMask corner_mask = blender::ed::greasepencil::polyline_detect_corners(

@@ -22,0 +42,4 @@
+  const Span<float2> curve_segments = curve_points.drop_front(1).drop_back(1);
+  for (const int64_t segment_i : IndexRange(num_segments)) {
+    IndexRange segment_range(segment_i * resolution, resolution);
+    bke::curves::bezier::evaluate_segment(curve_segments[segment_i * 3 + 0],

@@ -22,0 +52,4 @@
+}
+
+/** Interpolate \a dst such that the points in \a dst lie evenly distributed on \a src. */
+static void interp_polyline_to_polyline(Span<float2> src, MutableSpan<float2> dst)

@@ -58,0 +191,4 @@
+    return proj_point;
+  }
+
+  ScreenSpacePoint point_from_input_sample(const InputSample &sample)

@@ -65,0 +254,4 @@
+    const int64_t corner_max_samples = 64;
+    const float corner_angle_threshold = 0.6f;
+    IndexMaskMemory memory;
+    IndexMask corner_mask = ed::greasepencil::polyline_detect_corners(

@@ -65,0 +353,4 @@
+
+    bke::CurvesGeometry &curves = drawing_->strokes_for_write();
+
+    float2 prev_co = self.screen_space_coordinates_.last();

@@ -65,0 +388,4 @@
+      new_coordinates[i] = bke::attribute_math::mix2<float2>(factor, prev_co, point.co);
+      new_radii[i] = bke::attribute_math::mix2<float>(factor, prev_radius, point.radius);
+      new_opacities[i] = bke::attribute_math::mix2<float>(factor, prev_opacity, point.opacity);
+      new_vertex_colors[i] = bke::attribute_math::mix2<ColorGeometry4f>(

@@ -76,0 +491,4 @@
+void PaintOperation::simplify_stroke(bke::greasepencil::Drawing &drawing, const float epsilon_px)
+{
+  const int stroke_index = drawing.strokes().curves_range().last();
+  const IndexRange points_range = drawing.strokes().points_by_curve()[stroke_index];

@@ -76,0 +498,4 @@
+  /* Distance function for `ramer_douglas_peucker_simplify`. */
+  const Span<float2> positions_2d = this->screen_space_smoothed_coordinates_.as_span();
+  const auto dist_function =
+      [points_range, positions_2d, radii](int64_t first_index, int64_t last_index, int64_t index) {

@@ -76,0 +514,4 @@
+        return math::max(dist_position_px, dist_radii_px);
+      };
+
+  Array<bool> points_to_delete(curves.points_num(), false);

@@ -76,0 +532,4 @@
+  /* Remove points at the end that have a radius close to 0. */
+  int64_t points_to_remove = 0;
+  for (int64_t index = points_range.last(); index >= points_range.first(); index--) {
+    if (drawing.radii()[index] < 1e-5f) {

@@ -0,0 +82,4 @@
+{
+  Array<int32_t> indices(corner_mask.size());
+  corner_mask.to_indices(indices.as_mutable_span());
+  uint *indicies_ptr = (corner_mask.size() > 0) ? reinterpret_cast<uint *>(indices.data()) :

@@ -0,0 +45,4 @@
+
+float brush_radius_world_space(bContext &C, int x, int y)
+{
+  using namespace blender;

@@ -124,2 +126,4 @@
+                                       FunctionRef<float(int64_t, int64_t, int64_t)> dist_function,
                                        MutableSpan<bool> dst);
 
+Array<float2> fit_curve_polyline_2d(Span<float2> points,

@@ -126,0 +133,4 @@
+IndexMask polyline_detect_corners(Span<float2> points,
+                                  float radius_min,
+                                  float radius_max,
+                                  int64_t samples_max,

@@ -22,0 +29,4 @@
+static constexpr float POINT_OVERRIDE_THRESHOLD_PX = 3.0f;
+static constexpr float POINT_RESAMPLE_MIN_DISTANCE_PX = 10.0f;
+
+static constexpr int64_t STOKE_CACHE_ALLOCATION_CHUNK_SIZE = 1024;

@@ -22,0 +32,4 @@
+static constexpr int64_t STOKE_CACHE_ALLOCATION_CHUNK_SIZE = 1024;
+
+/** Sample a bezier curve at a fixed resolution and return the sampled points in an array. */
+static Array<float2> sample_curve_2d(Span<float2> curve_points, const int64_t resolution)

@@ -22,0 +41,4 @@
+
+  Array<float2> points(num_points);
+  const Span<float2> curve_segments = curve_points.drop_front(1).drop_back(1);
+  threading::parallel_for(IndexRange(num_segments), 512 * resolution, [&](const IndexRange range) {

@@ -65,0 +258,4 @@
+    Array<float2> coords_smoothed(screen_space_coords_smooth_slice.size());
+    morph_points_to_curve(screen_space_coords_smooth_slice, sampled_curve_points, coords_smoothed);
+
+    MutableSpan<float2> smoothed_coordinates_slice =

@@ -65,0 +334,4 @@
+    int new_points_num = 1;
+    const float distance_px = math::distance(position, prev_position);
+    if (distance_px > POINT_RESAMPLE_MIN_DISTANCE_PX) {
+      const int subdivisions = static_cast<int>(

@@ -65,0 +355,4 @@
+    const float step = 1.0f / static_cast<float>(new_points_num);
+    float factor = step;
+    for (const int64_t i : new_range.index_range()) {
+      new_screen_space_coordinates[i] = bke::attribute_math::mix2<float2>(

@@ -65,0 +383,4 @@
+    }
+
+    /* Active smoothing is done in a window at the end of the new stroke. */
+    const IndexRange smooth_window(self.active_smooth_index_,

@@ -125,2 +448,2 @@
-  SpanAttributeWriter<int> materials = attributes.lookup_or_add_for_write_span<int>(
-      "material_index", ATTR_DOMAIN_CURVE);
+  if (dist1 + dist2 > 1e-5f) {
+    const float interpolated_val = interpf(valB, valA, dist1 / (dist1 + dist2));