Try to generate a GP3 stroke using modifier.

none of the features are working yet,
need to implement `GEO_` functions for this.

@@ -0,0 +56,4 @@
+    do_starts[curve]=do_start;
+    do_ends[curve]=do_end;
+  }
+  OffsetIndices<int> dst_point_offsets = offset_indices::accumulate_counts_to_offsets(dst_point_counts.as_mutable_span());

@@ -0,0 +42,4 @@
+  Array<int> dst_point_counts(src_curves_num + 1);
+  
+  /* Count how many points we need. */
+  for(const int curve : do_curves.index_range()){

@@ -0,0 +65,4 @@
+    const int point_count = points_by_curve[curve].size();
+    int local_front = 0;
+    MutableSpan<int> new_points = dst_to_src_point.as_mutable_span().slice(
+      dst_point_counts[curve], dst_point_counts[curve+1]-dst_point_counts[curve]);

@@ -0,0 +86,4 @@
+  Array<int> dst_to_src_curve(src_curves_num);
+  dst_to_src_curve.fill(1);
+  dst_to_src_curve[0] = 0;
+  offset_indices::accumulate_counts_to_offsets(dst_to_src_curve.as_mutable_span());

@@ -0,0 +105,4 @@
+      src_attributes, bke::AttrDomain::Point, {}, {}, dst_to_src_point, dst_attributes);
+
+  dst_curves.update_curve_types();
+  dst_curves.remove_attributes_based_on_types();

@@ -0,0 +187,4 @@
+      selection,
+      use_starts,
+      use_ends,
+      std::move(VArray<float>::ForSingle(mmd.overshoot_fac, cnum)),

@@ -0,0 +170,4 @@
+                                   positions[new_points[curve][index2]],
+                                   fmodf(overshoot_point_param, 1.0f));
+        result -= positions[new_points[curve].last()];
+        if (UNLIKELY(is_zero_v3(result))) {

@@ -0,0 +190,4 @@
+       * strokes. */
+      const float overshoot_parameter = used_percent_length * (orig_totpoints - 2);
+      int overshoot_pointcount = ceil(overshoot_parameter);
+      CLAMP(overshoot_pointcount, 1, orig_totpoints - 2);

@@ -0,0 +193,4 @@
+      CLAMP(overshoot_pointcount, 1, orig_totpoints - 2);
+
+      /* Do for both sides without code duplication. */
+      float3 no, vec1, vec2, total_angle;

@@ -0,0 +200,4 @@
+        }
+
+        const int start_i = k == 0 ? first_old_index :
+                                     last_old_index;  // first_old_index, last_old_index

@@ -0,0 +207,4 @@
+               positions[new_points[curve][start_i]];
+        total_angle = float3({0, 0, 0});
+        float segment_length = normalize_v3(
+            vec1); /* Not using `math::normalize_and_get_length` for simplicity. */

@@ -0,0 +273,4 @@
+        const float prev_length = normalize_v3_length(vec1, step_length);
+
+        /* Build rotation matrix here to get best performance. */
+        float rot[3][3];

@@ -2610,0 +2612,4 @@
+typedef struct GreasePencilLengthModifierData {
+  ModifierData modifier;
+  GreasePencilModifierInfluenceData influence;
+  /** Flags. */

@@ -2610,0 +2624,4 @@
+  int seed;
+  /** How many frames before recalculate randoms. */
+  int step;
+  /** Modifier mode. */

@@ -0,0 +95,4 @@
+static Array<float> noise_table(int len, int offset, int seed)
+{
+  Array<float> table(len);
+  for (int i = 0; i < len; i++) {

@@ -0,0 +103,4 @@
+
+static float table_sample(Array<float> &table, float x)
+{
+  return math::interpolate(table[int(ceilf(x))], table[int(floor(x))], fractf(x));

@@ -0,0 +107,4 @@
+}
+
+static void deform_drawing(ModifierData &md,
+                           Depsgraph *depsgraph,

@@ -0,0 +122,4 @@
+  const IndexMask selection = modifier::greasepencil::get_filtered_stroke_mask(
+      &ob, curves, mmd.influence, memory);
+
+  const int cnum = curves.curves_num();

@@ -0,0 +127,4 @@
+  /* Variable for tagging shrinking when values are adjusted after random. */
+  bool needs_additional_shrinking = false;
+
+  VArray<float> use_starts = VArray<float>::ForSingle(mmd.start_fac, cnum);

@@ -1129,12 +1129,12 @@ static int add_material_from_template(Main &bmain, Object &ob, const ColorTempla
   return index;
 }
 
-static bke::CurvesGeometry create_drawing_data(const Span<float3> positions,

@@ -1135,3 +1132,1 @@
-                                               const Span<int> offsets,
-                                               const Span<int> materials,
-                                               const float4x4 &matrix)
+bke::CurvesGeometry create_drawing_data(const Span<float3> positions,

@@ -198,6 +198,13 @@ IndexMask retrieve_editable_and_selected_elements(Object &object,
                                                   bke::AttrDomain selection_domain,
                                                   IndexMaskMemory &memory);
 
+bke::CurvesGeometry create_drawing_data(const Span<float3> positions,

@@ -0,0 +17,4 @@
+ * Create a new Curves instance by trimming the input curves. Copying the selected splines
+ * between the start and end points.
+ */
+bke::CurvesGeometry stretch_curves(const bke::CurvesGeometry &src_curves,

@@ -151,6 +151,7 @@ class OBJECT_MT_modifier_add_generate(ModifierAddMenu, Menu):
             self.operator_modifier_add(layout, 'WIREFRAME')
         if ob_type == 'GREASEPENCIL':
             self.operator_modifier_add(layout, 'GREASE_PENCIL_SUBDIV')
+            self.operator_modifier_add(layout, 'GREASE_PENCIL_LENGTH')

@@ -40,12 +40,14 @@ set(SRC
   intern/set_curve_type.cc
   intern/smooth_curves.cc
   intern/subdivide_curves.cc
+  intern/extend_curves.cc

@@ -0,0 +14,4 @@
+namespace blender::geometry {
+
+/*
+ * Create a new Curves instance by trimming the input curves. Copying the selected splines

@@ -0,0 +11,4 @@
+#include "BLI_math_axis_angle.hh"
+#include "BLI_math_matrix.h"
+#include "BLI_math_quaternion.hh"
+#include "BLI_math_rotation.h"

@@ -0,0 +37,4 @@
+    const VArray<float> &max_angle,
+    const VArray<bool> &invert_curvature,
+    const GeometryNodeCurveSampleMode sample_mode,
+    const bke::AnonymousAttributePropagationInfo & /*propagation_info*/)

@@ -0,0 +50,4 @@
+  Array<float> use_end_lengths(src_curves_num);
+
+  const OffsetIndices<int> points_by_curve = src_curves.points_by_curve();
+  Array<int> dst_point_counts(src_curves_num + 1);

@@ -0,0 +103,4 @@
+      local_front = start_points[curve];
+    }
+    if (end_points[curve]) {
+      MutableSpan<int> ends = new_points.slice(new_points.size() - end_points[curve],

@@ -0,0 +124,4 @@
+  bke::MutableAttributeAccessor dst_attributes = dst_curves.attributes_for_write();
+
+  /* Transfer point attributes. */
+  gather_attributes(

@@ -0,0 +127,4 @@
+  gather_attributes(
+      src_attributes, bke::AttrDomain::Point, {}, {}, dst_to_src_point, dst_attributes);
+
+  dst_curves.tag_topology_changed();

@@ -0,0 +131,4 @@
+
+  MutableSpan<float3> positions = dst_curves.positions_for_write();
+
+  const OffsetIndices<int> new_points = dst_curves.points_by_curve();

@@ -0,0 +132,4 @@
+  MutableSpan<float3> positions = dst_curves.positions_for_write();
+
+  const OffsetIndices<int> new_points = dst_curves.points_by_curve();
+  for (const int curve : dst_curves.curves_range()) {

@@ -0,0 +157,4 @@
+        // I think It should always be endpoint to overshoot point?
+        int index1 = math::floor(overshoot_point_param);
+        int index2 = math::ceil(overshoot_point_param);
+        result = math::interpolate(positions[new_points[curve][index1]],

@@ -0,0 +164,4 @@
+        if (UNLIKELY(math::is_zero(result))) {
+          result = positions[new_points[curve][1]] - positions[new_points[curve][0]];
+        }
+        madd_v3_v3fl(

@@ -0,0 +205,4 @@
+        }
+
+        const int start_i = k == 0 ? first_old_index :
+                                     last_old_index; /* first_old_index, last_old_index */

@@ -0,0 +305,4 @@
+    }
+  }
+
+  dst_curves.tag_positions_changed();

@@ -0,0 +191,4 @@
+      VArray<bool>::ForSingle(mmd.flag & GP_LENGTH_USE_CURVATURE, curves_num),
+      VArray<int>::ForSingle(mmd.point_density, curves_num),
+      VArray<float>::ForSingle(mmd.segment_influence, curves_num),
+      VArray<float>::ForSingle(mmd.max_angle, curves_num),

@@ -0,0 +137,4 @@
+      }
+      const IndexRange new_curve = new_points_by_curve[curve];
+      int new_size = new_curve.size();
+      float used_percent_length = overshoot_fac;

@@ -0,0 +139,4 @@
+      int new_size = new_curve.size();
+      float used_percent_length = overshoot_fac;
+      used_percent_length = std::clamp(used_percent_length, 1e-4f, 1.0f);
+      if (!isfinite(used_percent_length)) {

@@ -0,0 +149,4 @@
+        used_percent_length = 0.1f;
+      }
+      /* Handle simple case first, straight stretching. */
+      if (!follow_curvature) {

@@ -0,0 +130,4 @@
+
+  /* Use random to modify start/end factors. Put the modified values outside the
+   * branch so it could be accessed in later stretching/shrinking stages. */
+  Array<float> modified_starts;

@@ -0,0 +136,4 @@
+  if (mmd.rand_start_fac != 0.0 || mmd.rand_end_fac != 0.0) {
+    modified_starts = Array<float>(curves.curves_num());
+    modified_ends = Array<float>(curves.curves_num());
+    modified_starts.fill(mmd.start_fac);

@@ -0,0 +156,4 @@
+    Array<float> noise_table_length = noise_table(
+        4 + curves_num, int(math::floor(mmd.rand_offset)), seed + 2);
+
+    for (int i = 0; i < curves_num; i++) {

@@ -0,0 +210,4 @@
+    needs_removal.fill(false);
+
+    curves.ensure_evaluated_lengths();
+    for (const int curve : curves.curves_range()) {

@@ -0,0 +234,4 @@
+    /* #trim_curves() will leave the last segment there when trimmed length is greater than
+     * curve original length, thus we need to remove those curves afterwards. */
+    IndexMaskMemory memory_remove;
+    IndexMask to_remove = IndexMask::from_bools(needs_removal.as_span(), memory_remove);

@@ -0,0 +24,4 @@
+                                  const float overshoot_fac,
+                                  const bool follow_curvature,
+                                  const int point_density,
+                                  const float segment_influence,

@@ -0,0 +24,4 @@
+
+namespace blender::geometry {
+
+static auto extend_curves_straight(const float used_percent_length,

@@ -0,0 +30,4 @@
+                                   const Array<int> &end_points,
+                                   const int curve,
+                                   const IndexRange new_curve,
+                                   const Array<float> &use_start_lengths,

@@ -0,0 +38,4 @@
+  float3 result;
+  if (start_points[curve]) {
+    // TODO: I don't think the algorithm here is correct?
+    // I think It should always be endpoint to overshoot point?

@@ -0,0 +78,4 @@
+                                 const bool invert_curvature,
+                                 MutableSpan<float3> positions)
+{
+

@@ -0,0 +230,4 @@
+    int point_count = points_by_curve[curve].size();
+    dst_point_offsets[curve] = point_count;
+    /* Curve not suitable for stretching... */
+    if (point_count <= 2 || (!selection.contains(curve))) {

@@ -0,0 +234,4 @@
+      continue;
+    }
+    float density = point_density;
+    if (density < 1e-4f) {

@@ -0,0 +292,4 @@
+  gather_attributes(src_attributes,
+                    bke::AttrDomain::Point,
+                    propagation_info,
+                    {},  //{"position"},

@@ -0,0 +309,4 @@
+      int new_size = new_curve.size();
+
+      /* #used_percent_length must always be finite, otherwise a segfault occurs.
+       * Since this function should never segfault, set #used_percent_length to a safe fallback.

@@ -0,0 +312,4 @@
+       * Since this function should never segfault, set #used_percent_length to a safe fallback.
+       */
+      /* NOTE: This fallback is used if `gps->totpoints == 2`, see
+       * `MOD_gpencil_legacy_length.cc`.

@@ -0,0 +48,4 @@
+    if (index2 == 0) {
+      index2 = 1;
+    }
+    result = math::interpolate(positions[new_curve[index1]],

@@ -0,0 +55,4 @@
+    if (UNLIKELY(math::is_zero(result))) {
+      result = positions[new_curve[1]] - positions[new_curve[0]];
+    }
+    positions[new_curve[0]] += result * (-use_start_lengths[curve] / len_v3(result));

@@ -0,0 +75,4 @@
+static void extend_curves_curved(const float used_percent_length,
+                                 const Span<int> start_points,
+                                 const Span<int> end_points,
+                                 const OffsetIndices<int> &points_by_curve,

@@ -0,0 +268,4 @@
+      end_points[curve] = count_end;
+    });
+
+    OffsetIndices dst_indicies = offset_indices::accumulate_counts_to_offsets(dst_point_offsets);