Overlay for vertex weights in GPv3 (initial commit)

@@ -320,0 +331,4 @@
+  start_sample.mouse_position = float2(mouse);
+  start_sample.pressure = 0.0f;
+
+  GreasePencilStrokeOperation *operation = greasepencil::new_weight_paint_operation().release();

@@ -22,2 +22,4 @@
   virtual void on_stroke_extended(const bContext &C, const InputSample &extension_sample) = 0;
   virtual void on_stroke_done(const bContext &C) = 0;
+
+  BrushStrokeMode brush_mode;

@@ -0,0 +529,4 @@
+                    DrawingWeightData &drawing_weight = drawing_weights[drawing_index];
+
+                    for (const BrushPoint &point : drawing_weight.points_in_brush) {
+                      switch (this->brush->weightpaint_tool) {

@@ -321,0 +380,4 @@
+    }
+
+    if (!editable_drawings.is_empty()) {
+      drawings_per_frame.append(editable_drawings);

@@ -545,0 +627,4 @@
+  const bke::AttributeAccessor attributes = curves.attributes();
+
+  /* Propagate the material index to the points. */
+  const VArray<int> materials = *attributes.lookup<int>("material_index", bke::AttrDomain::Point);

@@ -0,0 +47,4 @@
+          BKE_object_defgroup_add_name(ob, pchan->name);
+          return (BKE_object_defgroup_active_index_get(ob) - 1);
+        }
+        else {

@@ -0,0 +108,4 @@
+ * Returns false when the normalization failed due to too many locked vertex groups. In that case a
+ * second pass can be done with the active vertex group unlocked.
+ */
+static bool normalize_vertex_weights_try(const MDeformVert &dvert,

@@ -0,0 +111,4 @@
+static bool normalize_vertex_weights_try(const MDeformVert &dvert,
+                                         const int vertex_groups_num,
+                                         const int locked_active_vertex_group,
+                                         const Vector<bool> &vertex_group_is_locked,

@@ -0,0 +252,4 @@
+  const Object *ob_eval = DEG_get_evaluated_object(vc.depsgraph, const_cast<Object *>(vc.obact));
+  GreasePencil &grease_pencil = *static_cast<GreasePencil *>(vc.obact->data);
+  const Vector<ed::greasepencil::DrawingInfo> drawings =
+      ed::greasepencil::retrieve_visible_drawings(*vc.scene, grease_pencil);

@@ -0,0 +315,4 @@
+
+  /* From the closest point found, get the vertex weight in the active vertex group. */
+  const float new_weight = math::clamp(
+      bke::varray_for_deform_verts(closest.drawing->strokes().deform_verts(),

@@ -236,2 +244,4 @@
                                   IndexMaskMemory &memory);
 
+/** Create a vertex group in a GP object with a general name or the name of an active bone. */
+int create_vertex_group_in_object(Object *ob);

@@ -238,0 +252,4 @@
+/** For a point in a stroke, normalize the weights of vertex groups deformed by bones so that the
+ * sum is 1.0f. */
+void normalize_vertex_weights(const MDeformVert &dvert,
+                              const int active_vertex_group,

@@ -0,0 +91,4 @@
+
+  /* The number of points stored in the stroke point buffers. Per frame group.
+   * Note: we can't use Array or Vector here, because it doesn't support atomic types. */
+  std::vector<std::atomic<int>> points_in_stroke_num;

@@ -0,0 +106,4 @@
+ * Returns false when the normalization failed due to too many locked vertex groups. In that case a
+ * second pass can be done with the active vertex group unlocked.
+ */
+static bool normalize_vertex_weights_try(const MDeformVert &dvert,

@@ -0,0 +118,4 @@
+  }
+
+  /* Get the sum of weights of bone-deformed vertex groups. */
+  float sum_weights_total = 0.0f, sum_weights_locked = 0.0f, sum_weights_unlocked = 0.0f;

@@ -0,0 +120,4 @@
+  /* Get the sum of weights of bone-deformed vertex groups. */
+  float sum_weights_total = 0.0f, sum_weights_locked = 0.0f, sum_weights_unlocked = 0.0f;
+  int locked_num = 0, unlocked_num = 0;
+  for (int i = 0; i < dvert.totweight; i++) {

@@ -0,0 +150,4 @@
+  /* Any unlocked vertex group to normalize? */
+  if (unlocked_num == 0) {
+    /* We don't need a second pass when there is only one locked group (the active group). */
+    return (locked_num == 1);

@@ -0,0 +206,4 @@
+
+void normalize_vertex_weights(const MDeformVert &dvert,
+                              const int active_vertex_group,
+                              const Span<bool> &vertex_group_is_locked,

@@ -0,0 +217,4 @@
+                                                    vertex_group_is_locked,
+                                                    vertex_group_is_bone_deformed);
+
+  if (!success) {

@@ -0,0 +38,4 @@
+  /* Look for an active bone in armature to name the vertex group after. */
+  Object *ob_armature = BKE_modifiers_is_deformed_by_armature(&ob);
+  if (ob_armature != nullptr) {
+    Bone *actbone = ((bArmature *)ob_armature->data)->act_bone;

@@ -0,0 +191,4 @@
+  const float weight_remainder = math::clamp(
+      (1.0f - sum_weights_locked) / unlocked_num, 0.0f, 1.0f);
+
+  for (int i = 0; i < dvert.totweight; i++) {

@@ -0,0 +69,4 @@
+
+            /* Collect all stroke points under the brush in a buffer. */
+            threading::parallel_for(
+                drawing_weights.index_range(), 1, [&](const IndexRange drawing_range) {

@@ -0,0 +29,4 @@
+     * point weights, based on the distance of the neighbour point to A. So points closer to A
+     * contribute more to the average than points farther away from A. */
+    float distance_sum = 0.0f;
+    for (int i = 0; i < point_num; i++) {

@@ -0,0 +36,4 @@
+      return;
+    }
+    float blur_weight_sum = 0.0f;
+    for (int i = 0; i < point_num; i++) {

@@ -0,0 +94,4 @@
+            std::atomic<bool> balance_kdtree = false;
+
+            /* Collect all stroke points under the brush in a buffer. */
+            threading::parallel_for(

@@ -0,0 +76,4 @@
+    const float distance_normalizer = (min_distance == max_distance) ?
+                                          1.0f :
+                                          (0.95f / (max_distance - min_distance));
+    for (int i = 0; i < point_num; i++) {

@@ -0,0 +33,4 @@
+
+namespace blender::ed::greasepencil {
+
+int create_vertex_group_in_object(Object &ob)

@@ -0,0 +58,4 @@
+  return 0;
+}
+
+Set<std::string> get_bone_deformed_vertex_groups(Object &object)

@@ -0,0 +70,4 @@
+  /* Lambda function for finding deforming bones with a name matching a vertex group. */
+  Set<std::string> bone_deformed_vgroups;
+  const auto find_pose_channels = [&](ModifierData *md) {
+    for (; md; md = md->next) {

@@ -0,0 +94,4 @@
+  };
+
+  /* Inspect all armature modifiers in the object. */
+  VirtualModifierData virtual_modifier_data;

@@ -0,0 +106,4 @@
+ * Returns false when the normalization failed due to too many locked vertex groups. In that case a
+ * second pass can be done with the active vertex group unlocked.
+ */
+static bool normalize_vertex_weights_try(MDeformVert &dvert,

@@ -0,0 +238,4 @@
+  ed::curves::FindClosestData elem = {};
+};
+
+static int sample_weight(bContext *C, wmOperator * /*op*/, const wmEvent *event)

@@ -238,0 +253,4 @@
+ * sum is 1.0f. */
+void normalize_vertex_weights(MDeformVert &dvert,
+                              int active_vertex_group,
+                              const Span<bool> vertex_group_is_locked,

@@ -145,3 +153,3 @@
             _row, sub = row_for_mirror()
             sub.prop(context.object.pose, "use_mirror_x", text="X", toggle=True)
-        elif mode_string in {'EDIT_MESH', 'PAINT_WEIGHT', 'SCULPT', 'PAINT_VERTEX', 'PAINT_TEXTURE'}:
+        elif ((not is_greasepencil) and 

@@ -716,6 +716,12 @@ bool BKE_object_defgroup_check_lock_relative_multi(int defbase_tot,
 
 bool BKE_object_defgroup_active_is_locked(const Object *ob)
 {
+  if (ob->type == OB_GREASE_PENCIL) {

@@ -555,0 +649,4 @@
+  }
+
+  const bke::CurvesGeometry &curves = drawing.strokes();
+  const IndexRange points_range = drawing.strokes().points_range();

@@ -245,2 +253,4 @@
                                   IndexMaskMemory &memory);
 
+/** Returns a set of vertex group names that are deformed by a bone in an armature. */
+Set<std::string> get_bone_deformed_vertex_group_names(Object &object);

@@ -296,0 +301,4 @@
+
+static bool weight_stroke_test_start(bContext *C, wmOperator *op, const float mouse[2])
+{
+

@@ -296,0 +309,4 @@
+  GreasePencilStrokeOperation *operation = nullptr;
+  Paint *paint = BKE_paint_get_active_from_context(C);
+  Brush *brush = BKE_paint_brush(paint);
+  BrushStrokeMode brush_mode = static_cast<BrushStrokeMode>(RNA_enum_get(op->ptr, "mode"));

@@ -296,0 +311,4 @@
+  Brush *brush = BKE_paint_brush(paint);
+  BrushStrokeMode brush_mode = static_cast<BrushStrokeMode>(RNA_enum_get(op->ptr, "mode"));
+
+  switch (brush->weightpaint_tool) {

@@ -296,0 +328,4 @@
+      break;
+  }
+
+  if (operation) {

@@ -0,0 +7,4 @@
+namespace blender::ed::sculpt_paint::greasepencil {
+
+class AverageWeightPaintOperation : public WeightPaintOperation {
+ private:

@@ -0,0 +209,4 @@
+        bke::crazyspace::GeometryDeformation deformation =
+            bke::crazyspace::get_evaluated_grease_pencil_drawing_deformation(
+                ob_eval, *this->object, drawing_info.layer_index, drawing_info.frame_number);
+        drawing_weight_data.point_positions = Array<float2>(deformation.positions.size());

@@ -0,0 +280,4 @@
+  }
+
+  /* Create KDTree for all stroke points touched by the brush during a weight paint operation. */
+  PointsTouchedByBrush create_kdtree_of_points_touched_by_the_brush(

@@ -0,0 +26,4 @@
+  }
+
+ public:
+  void on_stroke_begin(const bContext &C, const InputSample &start_sample)

@@ -52,6 +52,7 @@
 #include "WM_toolsystem.hh"
 #include "WM_types.hh"
 
+#include "ED_grease_pencil.hh"

@@ -1031,6 +1031,8 @@ static const EnumPropertyItem *rna_Brush_direction_itemf(bContext *C,
         default:
           return rna_enum_dummy_DEFAULT_items;
       }
+    case PaintMode::Weight: