Merge branch 'master' into refactor-mesh-remove-pointers

21 files changed, 410 insertions, 148 deletions

diff --git a/source/blender/editors/sculpt_paint/CMakeLists.txt b/source/blender/editors/sculpt_paint/CMakeLists.txt
index b170280ccf3..f4d3002219d 100644
--- a/source/blender/editors/sculpt_paint/CMakeLists.txt
+++ b/source/blender/editors/sculpt_paint/CMakeLists.txt
@@ -21,7 +21,6 @@ set(INC
   ../../../../intern/atomic
   ../../../../intern/clog
   ../../../../intern/eigen
-  ../../../../intern/glew-mx
   ../../../../intern/guardedalloc
   # RNA_prototypes.h
   ${CMAKE_BINARY_DIR}/source/blender/makesrna
diff --git a/source/blender/editors/sculpt_paint/paint_hide.c b/source/blender/editors/sculpt_paint/paint_hide.c
index c904d533db8..a7aa29853e6 100644
--- a/source/blender/editors/sculpt_paint/paint_hide.c
+++ b/source/blender/editors/sculpt_paint/paint_hide.c
@@ -351,10 +351,10 @@ static int hide_show_exec(bContext *C, wmOperator *op)
   /* Start undo. */
   switch (action) {
     case PARTIALVIS_HIDE:
-      SCULPT_undo_push_begin(ob, "Hide area");
+      SCULPT_undo_push_begin_ex(ob, "Hide area");
       break;
     case PARTIALVIS_SHOW:
-      SCULPT_undo_push_begin(ob, "Show area");
+      SCULPT_undo_push_begin_ex(ob, "Show area");
       break;
   }
 
diff --git a/source/blender/editors/sculpt_paint/paint_image.cc b/source/blender/editors/sculpt_paint/paint_image.cc
index 24290fed323..5a6ac9463e2 100644
--- a/source/blender/editors/sculpt_paint/paint_image.cc
+++ b/source/blender/editors/sculpt_paint/paint_image.cc
@@ -158,6 +158,16 @@ void imapaint_image_update(
                                             imapaintpartial.dirty_region.xmax,
                                             imapaintpartial.dirty_region.ymax);
 
+  /* When buffer is partial updated the planes should be set to a larger value than 8. This will
+   * make sure that partial updating is working but uses more GPU memory as the gpu texture will
+   * have 4 channels. When so the whole texture needs to be reuploaded to the GPU using the new
+   * texture format.*/
+  if (ibuf != nullptr && ibuf->planes == 8) {
+    ibuf->planes = 32;
+    BKE_image_partial_update_mark_full_update(image);
+    return;
+  }
+
   /* TODO: should set_tpage create ->rect? */
   if (texpaint || (sima && sima->lock)) {
     const int w = BLI_rcti_size_x(&imapaintpartial.dirty_region);
diff --git a/source/blender/editors/sculpt_paint/paint_mask.c b/source/blender/editors/sculpt_paint/paint_mask.c
index 246481feb0b..de86597e223 100644
--- a/source/blender/editors/sculpt_paint/paint_mask.c
+++ b/source/blender/editors/sculpt_paint/paint_mask.c
@@ -152,7 +152,7 @@ static int mask_flood_fill_exec(bContext *C, wmOperator *op)
 
   BKE_pbvh_search_gather(pbvh, NULL, NULL, &nodes, &totnode);
 
-  SCULPT_undo_push_begin(ob, "Mask flood fill");
+  SCULPT_undo_push_begin(ob, op);
 
   MaskTaskData data = {
       .ob = ob,
@@ -687,10 +687,10 @@ static bool sculpt_gesture_is_vertex_effected(SculptGestureContext *sgcontext, P
   return false;
 }
 
-static void sculpt_gesture_apply(bContext *C, SculptGestureContext *sgcontext)
+static void sculpt_gesture_apply(bContext *C, SculptGestureContext *sgcontext, wmOperator *op)
 {
   SculptGestureOperation *operation = sgcontext->operation;
-  SCULPT_undo_push_begin(CTX_data_active_object(C), "Sculpt Gesture Apply");
+  SCULPT_undo_push_begin(CTX_data_active_object(C), op);
 
   operation->sculpt_gesture_begin(C, sgcontext);
 
@@ -1506,7 +1506,7 @@ static int paint_mask_gesture_box_exec(bContext *C, wmOperator *op)
     return OPERATOR_CANCELLED;
   }
   sculpt_gesture_init_mask_properties(sgcontext, op);
-  sculpt_gesture_apply(C, sgcontext);
+  sculpt_gesture_apply(C, sgcontext, op);
   sculpt_gesture_context_free(sgcontext);
   return OPERATOR_FINISHED;
 }
@@ -1518,7 +1518,7 @@ static int paint_mask_gesture_lasso_exec(bContext *C, wmOperator *op)
     return OPERATOR_CANCELLED;
   }
   sculpt_gesture_init_mask_properties(sgcontext, op);
-  sculpt_gesture_apply(C, sgcontext);
+  sculpt_gesture_apply(C, sgcontext, op);
   sculpt_gesture_context_free(sgcontext);
   return OPERATOR_FINISHED;
 }
@@ -1530,7 +1530,7 @@ static int paint_mask_gesture_line_exec(bContext *C, wmOperator *op)
     return OPERATOR_CANCELLED;
   }
   sculpt_gesture_init_mask_properties(sgcontext, op);
-  sculpt_gesture_apply(C, sgcontext);
+  sculpt_gesture_apply(C, sgcontext, op);
   sculpt_gesture_context_free(sgcontext);
   return OPERATOR_FINISHED;
 }
@@ -1542,7 +1542,7 @@ static int face_set_gesture_box_exec(bContext *C, wmOperator *op)
     return OPERATOR_CANCELLED;
   }
   sculpt_gesture_init_face_set_properties(sgcontext, op);
-  sculpt_gesture_apply(C, sgcontext);
+  sculpt_gesture_apply(C, sgcontext, op);
   sculpt_gesture_context_free(sgcontext);
   return OPERATOR_FINISHED;
 }
@@ -1554,7 +1554,7 @@ static int face_set_gesture_lasso_exec(bContext *C, wmOperator *op)
     return OPERATOR_CANCELLED;
   }
   sculpt_gesture_init_face_set_properties(sgcontext, op);
-  sculpt_gesture_apply(C, sgcontext);
+  sculpt_gesture_apply(C, sgcontext, op);
   sculpt_gesture_context_free(sgcontext);
   return OPERATOR_FINISHED;
 }
@@ -1579,7 +1579,7 @@ static int sculpt_trim_gesture_box_exec(bContext *C, wmOperator *op)
   }
 
   sculpt_gesture_init_trim_properties(sgcontext, op);
-  sculpt_gesture_apply(C, sgcontext);
+  sculpt_gesture_apply(C, sgcontext, op);
   sculpt_gesture_context_free(sgcontext);
   return OPERATOR_FINISHED;
 }
@@ -1620,7 +1620,7 @@ static int sculpt_trim_gesture_lasso_exec(bContext *C, wmOperator *op)
     return OPERATOR_CANCELLED;
   }
   sculpt_gesture_init_trim_properties(sgcontext, op);
-  sculpt_gesture_apply(C, sgcontext);
+  sculpt_gesture_apply(C, sgcontext, op);
   sculpt_gesture_context_free(sgcontext);
   return OPERATOR_FINISHED;
 }
@@ -1649,7 +1649,7 @@ static int project_gesture_line_exec(bContext *C, wmOperator *op)
     return OPERATOR_CANCELLED;
   }
   sculpt_gesture_init_project_properties(sgcontext, op);
-  sculpt_gesture_apply(C, sgcontext);
+  sculpt_gesture_apply(C, sgcontext, op);
   sculpt_gesture_context_free(sgcontext);
   return OPERATOR_FINISHED;
 }
diff --git a/source/blender/editors/sculpt_paint/paint_vertex.cc b/source/blender/editors/sculpt_paint/paint_vertex.cc
index f373bb2f763..c08857bff58 100644
--- a/source/blender/editors/sculpt_paint/paint_vertex.cc
+++ b/source/blender/editors/sculpt_paint/paint_vertex.cc
@@ -3961,7 +3961,7 @@ static int vpaint_invoke(bContext *C, wmOperator *op, const wmEvent *event)
     BKE_pbvh_ensure_node_loops(ob->sculpt->pbvh);
   }
 
-  SCULPT_undo_push_begin(ob, "Vertex Paint");
+  SCULPT_undo_push_begin_ex(ob, "Vertex Paint");
 
   if ((retval = op->type->modal(C, op, event)) == OPERATOR_FINISHED) {
     paint_stroke_free(C, op, (PaintStroke *)op->customdata);
diff --git a/source/blender/editors/sculpt_paint/sculpt.c b/source/blender/editors/sculpt_paint/sculpt.c
index 02cb8e1b6c7..c3ba29295c7 100644
--- a/source/blender/editors/sculpt_paint/sculpt.c
+++ b/source/blender/editors/sculpt_paint/sculpt.c
@@ -1406,16 +1406,13 @@ static void paint_mesh_restore_co_task_cb(void *__restrict userdata,
   switch (data->brush->sculpt_tool) {
     case SCULPT_TOOL_MASK:
       type = SCULPT_UNDO_MASK;
-      BKE_pbvh_node_mark_update_mask(data->nodes[n]);
       break;
     case SCULPT_TOOL_PAINT:
     case SCULPT_TOOL_SMEAR:
       type = SCULPT_UNDO_COLOR;
-      BKE_pbvh_node_mark_update_color(data->nodes[n]);
       break;
     default:
       type = SCULPT_UNDO_COORDS;
-      BKE_pbvh_node_mark_update(data->nodes[n]);
       break;
   }
 
@@ -1430,6 +1427,20 @@ static void paint_mesh_restore_co_task_cb(void *__restrict userdata,
     return;
   }
 
+  switch (type) {
+    case SCULPT_UNDO_MASK:
+      BKE_pbvh_node_mark_update_mask(data->nodes[n]);
+      break;
+    case SCULPT_UNDO_COLOR:
+      BKE_pbvh_node_mark_update_color(data->nodes[n]);
+      break;
+    case SCULPT_UNDO_COORDS:
+      BKE_pbvh_node_mark_update(data->nodes[n]);
+      break;
+    default:
+      break;
+  }
+
   PBVHVertexIter vd;
   SculptOrigVertData orig_data;
 
@@ -5383,7 +5394,7 @@ static bool sculpt_stroke_test_start(bContext *C, struct wmOperator *op, const f
       ED_image_undo_push_begin(op->type->name, PAINT_MODE_SCULPT);
     }
     else {
-      SCULPT_undo_push_begin(ob, sculpt_tool_name(sd));
+      SCULPT_undo_push_begin_ex(ob, sculpt_tool_name(sd));
     }
 
     return true;
@@ -5646,6 +5657,10 @@ static int sculpt_brush_stroke_modal(bContext *C, wmOperator *op, const wmEvent
   return paint_stroke_modal(C, op, event, (struct PaintStroke **)&op->customdata);
 }
 
+static void sculpt_redo_empty_ui(bContext *UNUSED(C), wmOperator *UNUSED(op))
+{
+}
+
 void SCULPT_OT_brush_stroke(wmOperatorType *ot)
 {
   /* Identifiers. */
@@ -5659,9 +5674,10 @@ void SCULPT_OT_brush_stroke(wmOperatorType *ot)
   ot->exec = sculpt_brush_stroke_exec;
   ot->poll = SCULPT_poll;
   ot->cancel = sculpt_brush_stroke_cancel;
+  ot->ui = sculpt_redo_empty_ui;
 
   /* Flags (sculpt does own undo? (ton)). */
-  ot->flag = OPTYPE_BLOCKING;
+  ot->flag = OPTYPE_BLOCKING | OPTYPE_REGISTER | OPTYPE_UNDO;
 
   /* Properties. */
 
diff --git a/source/blender/editors/sculpt_paint/sculpt_cloth.c b/source/blender/editors/sculpt_paint/sculpt_cloth.c
index b4b2c4e48c8..691dfa21851 100644
--- a/source/blender/editors/sculpt_paint/sculpt_cloth.c
+++ b/source/blender/editors/sculpt_paint/sculpt_cloth.c
@@ -1579,7 +1579,7 @@ static int sculpt_cloth_filter_invoke(bContext *C, wmOperator *op, const wmEvent
   /* Needs mask data to be available as it is used when solving the constraints. */
   BKE_sculpt_update_object_for_edit(depsgraph, ob, true, true, false);
 
-  SCULPT_undo_push_begin(ob, "Cloth filter");
+  SCULPT_undo_push_begin(ob, op);
   SCULPT_filter_cache_init(C, ob, sd, SCULPT_UNDO_COORDS);
 
   ss->filter_cache->automasking = SCULPT_automasking_cache_init(sd, NULL, ob);
diff --git a/source/blender/editors/sculpt_paint/sculpt_detail.c b/source/blender/editors/sculpt_paint/sculpt_detail.c
index ebbb0fa429e..8f87cd1b6ed 100644
--- a/source/blender/editors/sculpt_paint/sculpt_detail.c
+++ b/source/blender/editors/sculpt_paint/sculpt_detail.c
@@ -76,7 +76,7 @@ static bool sculpt_and_dynamic_topology_poll(bContext *C)
 /** \name Detail Flood Fill
  * \{ */
 
-static int sculpt_detail_flood_fill_exec(bContext *C, wmOperator *UNUSED(op))
+static int sculpt_detail_flood_fill_exec(bContext *C, wmOperator *op)
 {
   Sculpt *sd = CTX_data_tool_settings(C)->sculpt;
   Object *ob = CTX_data_active_object(C);
@@ -106,7 +106,7 @@ static int sculpt_detail_flood_fill_exec(bContext *C, wmOperator *UNUSED(op))
   float object_space_constant_detail = 1.0f / (sd->constant_detail * mat4_to_scale(ob->obmat));
   BKE_pbvh_bmesh_detail_size_set(ss->pbvh, object_space_constant_detail);
 
-  SCULPT_undo_push_begin(ob, "Dynamic topology flood fill");
+  SCULPT_undo_push_begin(ob, op);
   SCULPT_undo_push_node(ob, NULL, SCULPT_UNDO_COORDS);
 
   while (BKE_pbvh_bmesh_update_topology(
diff --git a/source/blender/editors/sculpt_paint/sculpt_dyntopo.c b/source/blender/editors/sculpt_paint/sculpt_dyntopo.c
index e19ce74d947..99617ecaed6 100644
--- a/source/blender/editors/sculpt_paint/sculpt_dyntopo.c
+++ b/source/blender/editors/sculpt_paint/sculpt_dyntopo.c
@@ -272,7 +272,7 @@ void sculpt_dynamic_topology_disable_with_undo(Main *bmain,
     /* May be false in background mode. */
     const bool use_undo = G.background ? (ED_undo_stack_get() != NULL) : true;
     if (use_undo) {
-      SCULPT_undo_push_begin(ob, "Dynamic topology disable");
+      SCULPT_undo_push_begin_ex(ob, "Dynamic topology disable");
       SCULPT_undo_push_node(ob, NULL, SCULPT_UNDO_DYNTOPO_END);
     }
     SCULPT_dynamic_topology_disable_ex(bmain, depsgraph, scene, ob, NULL);
@@ -292,7 +292,7 @@ static void sculpt_dynamic_topology_enable_with_undo(Main *bmain,
     /* May be false in background mode. */
     const bool use_undo = G.background ? (ED_undo_stack_get() != NULL) : true;
     if (use_undo) {
-      SCULPT_undo_push_begin(ob, "Dynamic topology enable");
+      SCULPT_undo_push_begin_ex(ob, "Dynamic topology enable");
     }
     SCULPT_dynamic_topology_enable_ex(bmain, depsgraph, scene, ob);
     if (use_undo) {
diff --git a/source/blender/editors/sculpt_paint/sculpt_expand.c b/source/blender/editors/sculpt_paint/sculpt_expand.c
index b3614e1f277..d4b2b884905 100644
--- a/source/blender/editors/sculpt_paint/sculpt_expand.c
+++ b/source/blender/editors/sculpt_paint/sculpt_expand.c
@@ -2128,7 +2128,7 @@ static int sculpt_expand_invoke(bContext *C, wmOperator *op, const wmEvent *even
   sculpt_expand_ensure_sculptsession_data(ob);
 
   /* Initialize undo. */
-  SCULPT_undo_push_begin(ob, "expand");
+  SCULPT_undo_push_begin(ob, op);
   sculpt_expand_undo_push(ob, ss->expand_cache);
 
   /* Set the initial element for expand from the event position. */
diff --git a/source/blender/editors/sculpt_paint/sculpt_face_set.c b/source/blender/editors/sculpt_paint/sculpt_face_set.c
index 6ea932d6f67..684cebd0d3a 100644
--- a/source/blender/editors/sculpt_paint/sculpt_face_set.c
+++ b/source/blender/editors/sculpt_paint/sculpt_face_set.c
@@ -317,7 +317,7 @@ static int sculpt_face_set_create_exec(bContext *C, wmOperator *op)
     return OPERATOR_CANCELLED;
   }
 
-  SCULPT_undo_push_begin(ob, "face set change");
+  SCULPT_undo_push_begin(ob, op);
   SCULPT_undo_push_node(ob, nodes[0], SCULPT_UNDO_FACE_SETS);
 
   const int next_face_set = SCULPT_face_set_next_available_get(ss);
@@ -707,7 +707,7 @@ static int sculpt_face_set_init_exec(bContext *C, wmOperator *op)
     return OPERATOR_CANCELLED;
   }
 
-  SCULPT_undo_push_begin(ob, "face set change");
+  SCULPT_undo_push_begin(ob, op);
   SCULPT_undo_push_node(ob, nodes[0], SCULPT_UNDO_FACE_SETS);
 
   const float threshold = RNA_float_get(op->ptr, "threshold");
@@ -856,7 +856,7 @@ static int sculpt_face_sets_change_visibility_exec(bContext *C, wmOperator *op)
   const int mode = RNA_enum_get(op->ptr, "mode");
   const int active_face_set = SCULPT_active_face_set_get(ss);
 
-  SCULPT_undo_push_begin(ob, "Hide area");
+  SCULPT_undo_push_begin(ob, op);
 
   PBVH *pbvh = ob->sculpt->pbvh;
   PBVHNode **nodes;
@@ -1322,9 +1322,10 @@ static void sculpt_face_set_edit_modify_geometry(bContext *C,
                                                  Object *ob,
                                                  const int active_face_set,
                                                  const eSculptFaceSetEditMode mode,
-                                                 const bool modify_hidden)
+                                                 const bool modify_hidden,
+                                                 wmOperator *op)
 {
-  ED_sculpt_undo_geometry_begin(ob, "edit face set delete geometry");
+  ED_sculpt_undo_geometry_begin(ob, op);
   sculpt_face_set_apply_edit(ob, abs(active_face_set), mode, modify_hidden);
   ED_sculpt_undo_geometry_end(ob);
   BKE_mesh_batch_cache_dirty_tag(ob->data, BKE_MESH_BATCH_DIRTY_ALL);
@@ -1354,7 +1355,8 @@ static void face_set_edit_do_post_visibility_updates(Object *ob, PBVHNode **node
 static void sculpt_face_set_edit_modify_face_sets(Object *ob,
                                                   const int active_face_set,
                                                   const eSculptFaceSetEditMode mode,
-                                                  const bool modify_hidden)
+                                                  const bool modify_hidden,
+                                                  wmOperator *op)
 {
   PBVH *pbvh = ob->sculpt->pbvh;
   PBVHNode **nodes;
@@ -1364,7 +1366,7 @@ static void sculpt_face_set_edit_modify_face_sets(Object *ob,
   if (!nodes) {
     return;
   }
-  SCULPT_undo_push_begin(ob, "face set edit");
+  SCULPT_undo_push_begin(ob, op);
   SCULPT_undo_push_node(ob, nodes[0], SCULPT_UNDO_FACE_SETS);
   sculpt_face_set_apply_edit(ob, abs(active_face_set), mode, modify_hidden);
   SCULPT_undo_push_end(ob);
@@ -1375,7 +1377,8 @@ static void sculpt_face_set_edit_modify_face_sets(Object *ob,
 static void sculpt_face_set_edit_modify_coordinates(bContext *C,
                                                     Object *ob,
                                                     const int active_face_set,
-                                                    const eSculptFaceSetEditMode mode)
+                                                    const eSculptFaceSetEditMode mode,
+                                                    wmOperator *op)
 {
   Sculpt *sd = CTX_data_tool_settings(C)->sculpt;
   SculptSession *ss = ob->sculpt;
@@ -1383,7 +1386,7 @@ static void sculpt_face_set_edit_modify_coordinates(bContext *C,
   PBVHNode **nodes;
   int totnode;
   BKE_pbvh_search_gather(pbvh, NULL, NULL, &nodes, &totnode);
-  SCULPT_undo_push_begin(ob, "face set edit");
+  SCULPT_undo_push_begin(ob, op);
   for (int i = 0; i < totnode; i++) {
     BKE_pbvh_node_mark_update(nodes[i]);
     SCULPT_undo_push_node(ob, nodes[i], SCULPT_UNDO_COORDS);
@@ -1426,15 +1429,15 @@ static int sculpt_face_set_edit_invoke(bContext *C, wmOperator *op, const wmEven
 
   switch (mode) {
     case SCULPT_FACE_SET_EDIT_DELETE_GEOMETRY:
-      sculpt_face_set_edit_modify_geometry(C, ob, active_face_set, mode, modify_hidden);
+      sculpt_face_set_edit_modify_geometry(C, ob, active_face_set, mode, modify_hidden, op);
       break;
     case SCULPT_FACE_SET_EDIT_GROW:
     case SCULPT_FACE_SET_EDIT_SHRINK:
-      sculpt_face_set_edit_modify_face_sets(ob, active_face_set, mode, modify_hidden);
+      sculpt_face_set_edit_modify_face_sets(ob, active_face_set, mode, modify_hidden, op);
       break;
     case SCULPT_FACE_SET_EDIT_FAIR_POSITIONS:
     case SCULPT_FACE_SET_EDIT_FAIR_TANGENCY:
-      sculpt_face_set_edit_modify_coordinates(C, ob, active_face_set, mode);
+      sculpt_face_set_edit_modify_coordinates(C, ob, active_face_set, mode, op);
       break;
   }
 
diff --git a/source/blender/editors/sculpt_paint/sculpt_filter_color.c b/source/blender/editors/sculpt_paint/sculpt_filter_color.c
index 7a1e08ea713..161fc563950 100644
--- a/source/blender/editors/sculpt_paint/sculpt_filter_color.c
+++ b/source/blender/editors/sculpt_paint/sculpt_filter_color.c
@@ -346,7 +346,7 @@ static int sculpt_color_filter_invoke(bContext *C, wmOperator *op, const wmEvent
     return OPERATOR_CANCELLED;
   }
 
-  SCULPT_undo_push_begin(ob, "color filter");
+  SCULPT_undo_push_begin(ob, op);
   BKE_sculpt_color_layer_create_if_needed(ob);
 
   /* CTX_data_ensure_evaluated_depsgraph should be used at the end to include the updates of
diff --git a/source/blender/editors/sculpt_paint/sculpt_filter_mask.c b/source/blender/editors/sculpt_paint/sculpt_filter_mask.c
index fa4fe191273..cba1d3dcdc1 100644
--- a/source/blender/editors/sculpt_paint/sculpt_filter_mask.c
+++ b/source/blender/editors/sculpt_paint/sculpt_filter_mask.c
@@ -193,7 +193,7 @@ static int sculpt_mask_filter_exec(bContext *C, wmOperator *op)
   int num_verts = SCULPT_vertex_count_get(ss);
 
   BKE_pbvh_search_gather(pbvh, NULL, NULL, &nodes, &totnode);
-  SCULPT_undo_push_begin(ob, "Mask Filter");
+  SCULPT_undo_push_begin(ob, op);
 
   for (int i = 0; i < totnode; i++) {
     SCULPT_undo_push_node(ob, nodes[i], SCULPT_UNDO_MASK);
@@ -409,7 +409,7 @@ static int sculpt_dirty_mask_exec(bContext *C, wmOperator *op)
   }
 
   BKE_pbvh_search_gather(pbvh, NULL, NULL, &nodes, &totnode);
-  SCULPT_undo_push_begin(ob, "Dirty Mask");
+  SCULPT_undo_push_begin(ob, op);
 
   for (int i = 0; i < totnode; i++) {
     SCULPT_undo_push_node(ob, nodes[i], SCULPT_UNDO_MASK);
diff --git a/source/blender/editors/sculpt_paint/sculpt_filter_mesh.c b/source/blender/editors/sculpt_paint/sculpt_filter_mesh.c
index 4f45b7917ec..e576cfda3af 100644
--- a/source/blender/editors/sculpt_paint/sculpt_filter_mesh.c
+++ b/source/blender/editors/sculpt_paint/sculpt_filter_mesh.c
@@ -694,7 +694,7 @@ static int sculpt_mesh_filter_invoke(bContext *C, wmOperator *op, const wmEvent
     SCULPT_boundary_info_ensure(ob);
   }
 
-  SCULPT_undo_push_begin(ob, "Mesh Filter");
+  SCULPT_undo_push_begin(ob, op);
 
   SCULPT_filter_cache_init(C, ob, sd, SCULPT_UNDO_COORDS);
 
diff --git a/source/blender/editors/sculpt_paint/sculpt_intern.h b/source/blender/editors/sculpt_paint/sculpt_intern.h
index 6a10f7cad18..e4bba135518 100644
--- a/source/blender/editors/sculpt_paint/sculpt_intern.h
+++ b/source/blender/editors/sculpt_paint/sculpt_intern.h
@@ -1494,10 +1494,17 @@ SculptUndoNode *SCULPT_undo_get_node(PBVHNode *node, SculptUndoType type);
 SculptUndoNode *SCULPT_undo_get_first_node(void);
 
 /**
- * NOTE: `name` must match operator name for
- * redo panels to work.
+ * Pushes an undo step using the operator name. This is necessary for
+ * redo panels to work; operators that do not support that may use
+ * #SCULPT_undo_push_begin_ex instead if so desired.
  */
-void SCULPT_undo_push_begin(struct Object *ob, const char *name);
+void SCULPT_undo_push_begin(struct Object *ob, const struct wmOperator *op);
+
+/**
+ * NOTE: #SCULPT_undo_push_begin is preferred since `name`
+ * must match operator name for redo panels to work.
+ */
+void SCULPT_undo_push_begin_ex(struct Object *ob, const char *name);
 void SCULPT_undo_push_end(struct Object *ob);
 void SCULPT_undo_push_end_ex(struct Object *ob, const bool use_nested_undo);
 
diff --git a/source/blender/editors/sculpt_paint/sculpt_mask_expand.c b/source/blender/editors/sculpt_paint/sculpt_mask_expand.c
index 2e661711172..9556d24f12c 100644
--- a/source/blender/editors/sculpt_paint/sculpt_mask_expand.c
+++ b/source/blender/editors/sculpt_paint/sculpt_mask_expand.c
@@ -361,7 +361,7 @@ static int sculpt_mask_expand_invoke(bContext *C, wmOperator *op, const wmEvent
 
   BKE_pbvh_search_gather(pbvh, NULL, NULL, &ss->filter_cache->nodes, &ss->filter_cache->totnode);
 
-  SCULPT_undo_push_begin(ob, "Mask Expand");
+  SCULPT_undo_push_begin(ob, op);
 
   if (create_face_set) {
     SCULPT_undo_push_node(ob, ss->filter_cache->nodes[0], SCULPT_UNDO_FACE_SETS);
diff --git a/source/blender/editors/sculpt_paint/sculpt_mask_init.c b/source/blender/editors/sculpt_paint/sculpt_mask_init.c
index cc27623adb0..b9b889ab2ce 100644
--- a/source/blender/editors/sculpt_paint/sculpt_mask_init.c
+++ b/source/blender/editors/sculpt_paint/sculpt_mask_init.c
@@ -131,7 +131,7 @@ static int sculpt_mask_init_exec(bContext *C, wmOperator *op)
     return OPERATOR_CANCELLED;
   }
 
-  SCULPT_undo_push_begin(ob, "init mask");
+  SCULPT_undo_push_begin(ob, op);
 
   if (mode == SCULPT_MASK_INIT_RANDOM_PER_LOOSE_PART) {
     SCULPT_connected_components_ensure(ob);
diff --git a/source/blender/editors/sculpt_paint/sculpt_ops.c b/source/blender/editors/sculpt_paint/sculpt_ops.c
index 151eb7744ea..b7b3b32aaf7 100644
--- a/source/blender/editors/sculpt_paint/sculpt_ops.c
+++ b/source/blender/editors/sculpt_paint/sculpt_ops.c
@@ -215,7 +215,7 @@ static int sculpt_symmetrize_exec(bContext *C, wmOperator *op)
        * as deleted, then after symmetrize operation all BMesh elements
        * are logged as added (as opposed to attempting to store just the
        * parts that symmetrize modifies). */
-      SCULPT_undo_push_begin(ob, "Dynamic topology symmetrize");
+      SCULPT_undo_push_begin(ob, op);
       SCULPT_undo_push_node(ob, NULL, SCULPT_UNDO_DYNTOPO_SYMMETRIZE);
       BM_log_before_all_removed(ss->bm, ss->bm_log);
 
@@ -242,7 +242,7 @@ static int sculpt_symmetrize_exec(bContext *C, wmOperator *op)
       break;
     case PBVH_FACES:
       /* Mesh Symmetrize. */
-      ED_sculpt_undo_geometry_begin(ob, "mesh symmetrize");
+      ED_sculpt_undo_geometry_begin(ob, op);
       Mesh *mesh = ob->data;
 
       BKE_mesh_mirror_apply_mirror_on_axis(bmain, mesh, sd->symmetrize_direction, dist);
@@ -394,7 +394,7 @@ void ED_object_sculptmode_enter_ex(Main *bmain,
       bool has_undo = wm->undo_stack != NULL;
       /* Undo push is needed to prevent memory leak. */
       if (has_undo) {
-        SCULPT_undo_push_begin(ob, "Dynamic topology enable");
+        SCULPT_undo_push_begin_ex(ob, "Dynamic topology enable");
       }
       SCULPT_dynamic_topology_enable_ex(bmain, depsgraph, scene, ob);
       if (has_undo) {
@@ -510,7 +510,7 @@ static int sculpt_mode_toggle_exec(bContext *C, wmOperator *op)
          * while it works it causes lag when undoing the first undo step, see T71564. */
         wmWindowManager *wm = CTX_wm_manager(C);
         if (wm->op_undo_depth <= 1) {
-          SCULPT_undo_push_begin(ob, op->type->name);
+          SCULPT_undo_push_begin(ob, op);
           SCULPT_undo_push_end(ob);
         }
       }
@@ -921,7 +921,7 @@ static int sculpt_mask_by_color_invoke(bContext *C, wmOperator *op, const wmEven
   const float mval_fl[2] = {UNPACK2(event->mval)};
   SCULPT_cursor_geometry_info_update(C, &sgi, mval_fl, false);
 
-  SCULPT_undo_push_begin(ob, "Mask by color");
+  SCULPT_undo_push_begin(ob, op);
   BKE_sculpt_color_layer_create_if_needed(ob);
 
   const PBVHVertRef active_vertex = SCULPT_active_vertex_get(ss);
diff --git a/source/blender/editors/sculpt_paint/sculpt_transform.c b/source/blender/editors/sculpt_paint/sculpt_transform.c
index 7207e6c35d4..dfaa0bd4daa 100644
--- a/source/blender/editors/sculpt_paint/sculpt_transform.c
+++ b/source/blender/editors/sculpt_paint/sculpt_transform.c
@@ -46,7 +46,7 @@
 #include <math.h>
 #include <stdlib.h>
 
-void ED_sculpt_init_transform(struct bContext *C, Object *ob)
+void ED_sculpt_init_transform(struct bContext *C, Object *ob, const char *undo_name)
 {
   Sculpt *sd = CTX_data_tool_settings(C)->sculpt;
   SculptSession *ss = ob->sculpt;
@@ -60,7 +60,7 @@ void ED_sculpt_init_transform(struct bContext *C, Object *ob)
   copy_v4_v4(ss->prev_pivot_rot, ss->pivot_rot);
   copy_v3_v3(ss->prev_pivot_scale, ss->pivot_scale);
 
-  SCULPT_undo_push_begin(ob, "Transform");
+  SCULPT_undo_push_begin_ex(ob, undo_name);
   BKE_sculpt_update_object_for_edit(depsgraph, ob, false, false, false);
 
   ss->pivot_rot[3] = 1.0f;
@@ -351,11 +351,6 @@ void ED_sculpt_end_transform(struct bContext *C, Object *ob)
   if (ss->filter_cache) {
     SCULPT_filter_cache_free(ss);
   }
-  /* Force undo push to happen even inside transform operator, since the sculpt
-   * undo system works separate from regular undo and this is require to properly
-   * finish an undo step also when canceling. */
-  const bool use_nested_undo = true;
-  SCULPT_undo_push_end_ex(ob, use_nested_undo);
   SCULPT_flush_update_done(C, ob, SCULPT_UPDATE_COORDS);
 }
 
diff --git a/source/blender/editors/sculpt_paint/sculpt_undo.c b/source/blender/editors/sculpt_paint/sculpt_undo.c
index a12f377c90d..fdda81baccd 100644
--- a/source/blender/editors/sculpt_paint/sculpt_undo.c
+++ b/source/blender/editors/sculpt_paint/sculpt_undo.c
@@ -4,6 +4,29 @@
 /** \file
  * \ingroup edsculpt
  * Implements the Sculpt Mode tools.
+ *
+ * Usage Guide
+ * ===========
+ *
+ * The sculpt undo system is a delta-based system. Each undo step stores
+ * the difference with the prior one.
+ *
+ * To use the sculpt undo system, you must call SCULPT_undo_push_begin
+ * inside an operator exec or invoke callback (ED_sculpt_undo_geometry_begin
+ * may be called if you wish to save a non-delta copy of the entire mesh).
+ * This will initialize the sculpt undo stack and set up an undo step.
+ *
+ * At the end of the operator you should call SCULPT_undo_push_end.
+ *
+ * SCULPT_undo_push_end and ED_sculpt_undo_geometry_begin both take a
+ * wmOperatorType as an argument. There are _ex versions that allow a custom
+ * name; try to avoid using them. These can break the redo panel since it requires
+ * the undo push have the same name as the calling operator.
+ *
+ * Note: Sculpt undo steps are not appended to the global undo stack until
+ * the operator finishes.  We use BKE_undosys_step_push_init_with_type to build
+ * a tentative undo step with is appended later when the operator ends.
+ * Operators must have the OPTYPE_UNDO flag set for this to work properly.
  */
 
 #include <stddef.h>
@@ -350,10 +373,11 @@ static bool sculpt_undo_restore_hidden(bContext *C, SculptUndoNode *unode, bool
 
   if (unode->maxvert) {
     for (int i = 0; i < unode->totvert; i++) {
-      if ((BLI_BITMAP_TEST(unode->vert_hidden, i) != 0) != hide_vert[i]) {
+      const int vert_index = unode->index[i];
+      if ((BLI_BITMAP_TEST(unode->vert_hidden, i) != 0) != hide_vert[vert_index]) {
         BLI_BITMAP_FLIP(unode->vert_hidden, i);
-        hide_vert[unode->index[i]] = !hide_vert[i];
-        modified_vertices[unode->index[i]] = true;
+        hide_vert[vert_index] = !hide_vert[vert_index];
+        modified_vertices[vert_index] = true;
       }
     }
   }
@@ -877,7 +901,6 @@ static void sculpt_undo_restore_list(bContext *C, Depsgraph *depsgraph, ListBase
         .modified_hidden_vertices = modified_hidden_vertices,
         .modified_mask_vertices = modified_mask_vertices,
         .modified_color_vertices = modified_color_vertices,
-
     };
     BKE_pbvh_search_callback(ss->pbvh, NULL, NULL, update_cb_partial, &data);
     BKE_pbvh_update_bounds(ss->pbvh, PBVH_UpdateBB | PBVH_UpdateOriginalBB | PBVH_UpdateRedraw);
@@ -1140,8 +1163,7 @@ static SculptUndoNode *sculpt_undo_alloc_node(Object *ob, PBVHNode *node, Sculpt
       unode->co = MEM_callocN(alloc_size, "SculptUndoNode.co");
       usculpt->undo_size += alloc_size;
 
-      /* FIXME: Should explain why this is allocated here, to be freed in
-       * `SCULPT_undo_push_end_ex()`? */
+      /* Needed for original data lookup. */
       alloc_size = sizeof(*unode->no) * (size_t)allvert;
       unode->no = MEM_callocN(alloc_size, "SculptUndoNode.no");
       usculpt->undo_size += alloc_size;
@@ -1544,7 +1566,12 @@ static void sculpt_save_active_attribute(Object *ob, SculptAttrRef *attr)
   attr->was_set = true;
 }
 
-void SCULPT_undo_push_begin(Object *ob, const char *name)
+void SCULPT_undo_push_begin(Object *ob, const wmOperator *op)
+{
+  SCULPT_undo_push_begin_ex(ob, op->type->name);
+}
+
+void SCULPT_undo_push_begin_ex(Object *ob, const char *name)
 {
   UndoStack *ustack = ED_undo_stack_get();
 
@@ -1640,11 +1667,12 @@ static void sculpt_undo_set_active_layer(struct bContext *C, SculptAttrRef *attr
    */
   if (!layer) {
     layer = BKE_id_attribute_search(&me->id, attr->name, CD_MASK_PROP_ALL, ATTR_DOMAIN_MASK_ALL);
-    eAttrDomain domain = layer ? BKE_id_attribute_domain(&me->id, layer) : ATTR_DOMAIN_NUM;
-
-    if (layer && ED_geometry_attribute_convert(
-                     me, attr->name, layer->type, domain, attr->type, attr->domain)) {
-      layer = BKE_id_attribute_find(&me->id, attr->name, attr->type, attr->domain);
+    if (layer) {
+      const eAttrDomain domain = BKE_id_attribute_domain(&me->id, layer);
+      if (ED_geometry_attribute_convert(
+              me, attr->name, layer->type, domain, attr->type, attr->domain)) {
+        layer = BKE_id_attribute_find(&me->id, attr->name, attr->type, attr->domain);
+      }
     }
   }
 
@@ -1832,9 +1860,15 @@ static void sculpt_undosys_step_free(UndoStep *us_p)
   sculpt_undo_free_list(&us->data.nodes);
 }
 
-void ED_sculpt_undo_geometry_begin(struct Object *ob, const char *name)
+void ED_sculpt_undo_geometry_begin(struct Object *ob, const wmOperator *op)
+{
+  SCULPT_undo_push_begin(ob, op);
+  SCULPT_undo_push_node(ob, NULL, SCULPT_UNDO_GEOMETRY);
+}
+
+void ED_sculpt_undo_geometry_begin_ex(struct Object *ob, const char *name)
 {
-  SCULPT_undo_push_begin(ob, name);
+  SCULPT_undo_push_begin_ex(ob, name);
   SCULPT_undo_push_node(ob, NULL, SCULPT_UNDO_GEOMETRY);
 }
 
@@ -1947,7 +1981,7 @@ void ED_sculpt_undo_push_multires_mesh_begin(bContext *C, const char *str)
 
   Object *object = CTX_data_active_object(C);
 
-  SCULPT_undo_push_begin(object, str);
+  SCULPT_undo_push_begin_ex(object, str);
 
   SculptUndoNode *geometry_unode = SCULPT_undo_push_node(object, NULL, SCULPT_UNDO_GEOMETRY);
   geometry_unode->geometry_clear_pbvh = false;
diff --git a/source/blender/editors/sculpt_paint/sculpt_uv.c b/source/blender/editors/sculpt_paint/sculpt_uv.c
index 2e2abd30ea2..8b9776cf94d 100644
--- a/source/blender/editors/sculpt_paint/sculpt_uv.c
+++ b/source/blender/editors/sculpt_paint/sculpt_uv.c
@@ -9,7 +9,7 @@
 #include "MEM_guardedalloc.h"
 
 #include "BLI_ghash.h"
-#include "BLI_math.h"
+#include "BLI_math_base_safe.h"
 #include "BLI_utildefines.h"
 
 #include "DNA_brush_types.h"
@@ -22,6 +22,7 @@
 #include "BKE_context.h"
 #include "BKE_customdata.h"
 #include "BKE_editmesh.h"
+#include "BKE_image.h"
 #include "BKE_mesh_mapping.h"
 #include "BKE_paint.h"
 
@@ -30,6 +31,7 @@
 #include "ED_image.h"
 #include "ED_mesh.h"
 #include "ED_screen.h"
+#include "ED_uvedit.h"
 
 #include "WM_api.h"
 #include "WM_types.h"
@@ -42,6 +44,9 @@
 
 #include "UI_view2d.h"
 
+/* When set, the UV element is on the boundary of the graph.
+ * i.e. Instead of a 2-dimensional laplace operator, use a 1-dimensional version.
+ * Visually, UV elements on the graph boundary appear as borders of the UV Island. */
 #define MARK_BOUNDARY 1
 
 typedef struct UvAdjacencyElement {
@@ -49,16 +54,17 @@ typedef struct UvAdjacencyElement {
   UvElement *element;
   /* uv pointer for convenience. Caution, this points to the original UVs! */
   float *uv;
-  /* general use flag (Used to check if Element is boundary here) */
-  char flag;
+  /* Are we on locked in place? */
+  bool is_locked;
+  /* Are we on the boundary? */
+  bool is_boundary;
 } UvAdjacencyElement;
 
 typedef struct UvEdge {
   uint uv1;
   uint uv2;
-  /* general use flag
-   * (Used to check if edge is boundary here, and propagates to adjacency elements) */
-  char flag;
+  /* Are we in the interior? */
+  bool is_interior;
 } UvEdge;
 
 typedef struct UVInitialStrokeElement {
@@ -90,13 +96,13 @@ typedef struct UvSculptData {
    * to their coincident UV's */
   UvAdjacencyElement *uv;
 
-  /* ...Is what it says */
+  /* Total number of unique UVs. */
   int totalUniqueUvs;
 
   /* Edges used for adjacency info, used with laplacian smoothing */
   UvEdge *uvedges;
 
-  /* need I say more? */
+  /* Total number of #UvEdge. */
   int totalUvEdges;
 
   /* data for initial stroke, used by tools like grab */
@@ -116,8 +122,25 @@ typedef struct UvSculptData {
 
   /* store invert flag here */
   char invert;
+
+  /* Is constrain to image bounds active? */
+  bool constrain_to_bounds;
+
+  /* Base for constrain_to_bounds. */
+  float uv_base_offset[2];
 } UvSculptData;
 
+static void apply_sculpt_data_constraints(UvSculptData *sculptdata, float uv[2])
+{
+  if (!sculptdata->constrain_to_bounds) {
+    return;
+  }
+  float u = sculptdata->uv_base_offset[0];
+  float v = sculptdata->uv_base_offset[1];
+  uv[0] = clamp_f(uv[0], u, u + 1.0f);
+  uv[1] = clamp_f(uv[1], v, v + 1.0f);
+}
+
 /*********** Improved Laplacian Relaxation Operator ************************/
 /* original code by Raul Fernandez Hernandez "farsthary"                   *
  * adapted to uv smoothing by Antony Riakiatakis                           *
@@ -170,17 +193,14 @@ static void HC_relaxation_iteration_uv(BMEditMesh *em,
   }
 
   for (i = 0; i < sculptdata->totalUniqueUvs; i++) {
-    float dist;
-    /* This is supposed to happen only if "Pin Edges" is on,
-     * since we have initialization on stroke start.
-     * If ever uv brushes get their own mode we should check for toolsettings option too. */
-    if (sculptdata->uv[i].flag & MARK_BOUNDARY) {
+    if (sculptdata->uv[i].is_locked) {
       continue;
     }
 
     sub_v2_v2v2(diff, sculptdata->uv[i].uv, mouse_coord);
     diff[1] /= aspectRatio;
-    if ((dist = dot_v2v2(diff, diff)) <= radius) {
+    float dist = dot_v2v2(diff, diff);
+    if (dist <= radius) {
       UvElement *element;
       float strength;
       strength = alpha * BKE_brush_curve_strength_clamped(brush, sqrtf(dist), radius_root);
@@ -196,6 +216,8 @@ static void HC_relaxation_iteration_uv(BMEditMesh *em,
                                      0.5f * (tmp_uvdata[i].b[1] +
                                              tmp_uvdata[i].sum_b[1] / tmp_uvdata[i].ncounter));
 
+      apply_sculpt_data_constraints(sculptdata, sculptdata->uv[i].uv);
+
       for (element = sculptdata->uv[i].element; element; element = element->next) {
         MLoopUV *luv;
         BMLoop *l;
@@ -214,6 +236,13 @@ static void HC_relaxation_iteration_uv(BMEditMesh *em,
   MEM_SAFE_FREE(tmp_uvdata);
 }
 
+/* Legacy version which only does laplacian relaxation.
+ * Probably a little faster as it caches UvEdges.
+ * Mostly preserved for comparison with `HC_relaxation_iteration_uv`.
+ * Once the HC method has been merged into `relaxation_iteration_uv`,
+ * all the `HC_*` and `laplacian_*` specific functions can probably be removed.
+ */
+
 static void laplacian_relaxation_iteration_uv(BMEditMesh *em,
                                               UvSculptData *sculptdata,
                                               const float mouse_coord[2],
@@ -233,11 +262,16 @@ static void laplacian_relaxation_iteration_uv(BMEditMesh *em,
   /* counting neighbors */
   for (i = 0; i < sculptdata->totalUvEdges; i++) {
     UvEdge *tmpedge = sculptdata->uvedges + i;
-    tmp_uvdata[tmpedge->uv1].ncounter++;
-    tmp_uvdata[tmpedge->uv2].ncounter++;
-
-    add_v2_v2(tmp_uvdata[tmpedge->uv2].sum_co, sculptdata->uv[tmpedge->uv1].uv);
-    add_v2_v2(tmp_uvdata[tmpedge->uv1].sum_co, sculptdata->uv[tmpedge->uv2].uv);
+    bool code1 = sculptdata->uv[sculptdata->uvedges[i].uv1].is_boundary;
+    bool code2 = sculptdata->uv[sculptdata->uvedges[i].uv2].is_boundary;
+    if (code1 || (code1 == code2)) {
+      tmp_uvdata[tmpedge->uv2].ncounter++;
+      add_v2_v2(tmp_uvdata[tmpedge->uv2].sum_co, sculptdata->uv[tmpedge->uv1].uv);
+    }
+    if (code2 || (code1 == code2)) {
+      tmp_uvdata[tmpedge->uv1].ncounter++;
+      add_v2_v2(tmp_uvdata[tmpedge->uv1].sum_co, sculptdata->uv[tmpedge->uv2].uv);
+    }
   }
 
   /* Original Laplacian algorithm included removal of normal component of translation.
@@ -248,17 +282,14 @@ static void laplacian_relaxation_iteration_uv(BMEditMesh *em,
   }
 
   for (i = 0; i < sculptdata->totalUniqueUvs; i++) {
-    float dist;
-    /* This is supposed to happen only if "Pin Edges" is on,
-     * since we have initialization on stroke start.
-     * If ever uv brushes get their own mode we should check for toolsettings option too. */
-    if (sculptdata->uv[i].flag & MARK_BOUNDARY) {
+    if (sculptdata->uv[i].is_locked) {
       continue;
     }
 
     sub_v2_v2v2(diff, sculptdata->uv[i].uv, mouse_coord);
     diff[1] /= aspectRatio;
-    if ((dist = dot_v2v2(diff, diff)) <= radius) {
+    float dist = dot_v2v2(diff, diff);
+    if (dist <= radius) {
       UvElement *element;
       float strength;
       strength = alpha * BKE_brush_curve_strength_clamped(brush, sqrtf(dist), radius_root);
@@ -268,6 +299,8 @@ static void laplacian_relaxation_iteration_uv(BMEditMesh *em,
       sculptdata->uv[i].uv[1] = (1.0f - strength) * sculptdata->uv[i].uv[1] +
                                 strength * tmp_uvdata[i].p[1];
 
+      apply_sculpt_data_constraints(sculptdata, sculptdata->uv[i].uv);
+
       for (element = sculptdata->uv[i].element; element; element = element->next) {
         MLoopUV *luv;
         BMLoop *l;
@@ -286,6 +319,153 @@ static void laplacian_relaxation_iteration_uv(BMEditMesh *em,
   MEM_SAFE_FREE(tmp_uvdata);
 }
 
+static void add_weighted_edge(float (*delta_buf)[3],
+                              const UvElement *storage,
+                              const UvElement *ele_next,
+                              const UvElement *ele_prev,
+                              const MLoopUV *luv_next,
+                              const MLoopUV *luv_prev,
+                              const float weight)
+{
+  float delta[2];
+  sub_v2_v2v2(delta, luv_next->uv, luv_prev->uv);
+
+  bool code1 = (ele_prev->flag & MARK_BOUNDARY);
+  bool code2 = (ele_next->flag & MARK_BOUNDARY);
+  if (code1 || (code1 == code2)) {
+    int index_next = ele_next - storage;
+    delta_buf[index_next][0] -= delta[0] * weight;
+    delta_buf[index_next][1] -= delta[1] * weight;
+    delta_buf[index_next][2] += fabsf(weight);
+  }
+  if (code2 || (code1 == code2)) {
+    int index_prev = ele_prev - storage;
+    delta_buf[index_prev][0] += delta[0] * weight;
+    delta_buf[index_prev][1] += delta[1] * weight;
+    delta_buf[index_prev][2] += fabsf(weight);
+  }
+}
+
+static float tri_weight_v3(int method, const float *v1, const float *v2, const float *v3)
+{
+  switch (method) {
+    case UV_SCULPT_TOOL_RELAX_LAPLACIAN:
+    case UV_SCULPT_TOOL_RELAX_HC:
+      return 1.0f;
+    case UV_SCULPT_TOOL_RELAX_COTAN:
+      return cotangent_tri_weight_v3(v1, v2, v3);
+    default:
+      BLI_assert_unreachable();
+  }
+  return 0.0f;
+}
+
+static void relaxation_iteration_uv(BMEditMesh *em,
+                                    UvSculptData *sculptdata,
+                                    const float mouse_coord[2],
+                                    const float alpha,
+                                    const float radius_squared,
+                                    const float aspect_ratio,
+                                    const int method)
+{
+  if (method == UV_SCULPT_TOOL_RELAX_HC) {
+    HC_relaxation_iteration_uv(em, sculptdata, mouse_coord, alpha, radius_squared, aspect_ratio);
+    return;
+  }
+  if (method == UV_SCULPT_TOOL_RELAX_LAPLACIAN) {
+    laplacian_relaxation_iteration_uv(
+        em, sculptdata, mouse_coord, alpha, radius_squared, aspect_ratio);
+    return;
+  }
+
+  struct UvElement **head_table = BM_uv_element_map_ensure_head_table(sculptdata->elementMap);
+
+  const int cd_loop_uv_offset = CustomData_get_offset(&em->bm->ldata, CD_MLOOPUV);
+  BLI_assert(cd_loop_uv_offset >= 0);
+
+  const int total_uvs = sculptdata->elementMap->total_uvs;
+  float(*delta_buf)[3] = (float(*)[3])MEM_callocN(total_uvs * sizeof(float[3]), __func__);
+
+  const UvElement *storage = sculptdata->elementMap->storage;
+  for (int j = 0; j < total_uvs; j++) {
+    const UvElement *ele_curr = storage + j;
+    const BMFace *efa = ele_curr->l->f;
+    const UvElement *ele_next = BM_uv_element_get(sculptdata->elementMap, efa, ele_curr->l->next);
+    const UvElement *ele_prev = BM_uv_element_get(sculptdata->elementMap, efa, ele_curr->l->prev);
+
+    const float *v_curr_co = ele_curr->l->v->co;
+    const float *v_prev_co = ele_prev->l->v->co;
+    const float *v_next_co = ele_next->l->v->co;
+
+    const MLoopUV *luv_curr = BM_ELEM_CD_GET_VOID_P(ele_curr->l, cd_loop_uv_offset);
+    const MLoopUV *luv_next = BM_ELEM_CD_GET_VOID_P(ele_next->l, cd_loop_uv_offset);
+    const MLoopUV *luv_prev = BM_ELEM_CD_GET_VOID_P(ele_prev->l, cd_loop_uv_offset);
+
+    const UvElement *head_curr = head_table[ele_curr - sculptdata->elementMap->storage];
+    const UvElement *head_next = head_table[ele_next - sculptdata->elementMap->storage];
+    const UvElement *head_prev = head_table[ele_prev - sculptdata->elementMap->storage];
+
+    /* If the mesh is triangulated with no boundaries, only one edge is required. */
+    const float weight_curr = tri_weight_v3(method, v_curr_co, v_prev_co, v_next_co);
+    add_weighted_edge(delta_buf, storage, head_next, head_prev, luv_next, luv_prev, weight_curr);
+
+    /* Triangulated with a boundary? We need the incoming edges to solve the boundary. */
+    const float weight_prev = tri_weight_v3(method, v_prev_co, v_curr_co, v_next_co);
+    add_weighted_edge(delta_buf, storage, head_next, head_curr, luv_next, luv_curr, weight_prev);
+
+    if (method == UV_SCULPT_TOOL_RELAX_LAPLACIAN) {
+      /* Laplacian method has zero weights on virtual edges. */
+      continue;
+    }
+
+    /* Meshes with quads (or other n-gons) need "virtual" edges too. */
+    const float weight_next = tri_weight_v3(method, v_next_co, v_curr_co, v_prev_co);
+    add_weighted_edge(delta_buf, storage, head_prev, head_curr, luv_prev, luv_curr, weight_next);
+  }
+
+  Brush *brush = BKE_paint_brush(sculptdata->uvsculpt);
+  for (int i = 0; i < sculptdata->totalUniqueUvs; i++) {
+    UvAdjacencyElement *adj_el = &sculptdata->uv[i];
+    if (adj_el->is_locked) {
+      continue; /* Locked UVs can't move. */
+    }
+
+    /* Is UV within brush's influence? */
+    float diff[2];
+    sub_v2_v2v2(diff, adj_el->uv, mouse_coord);
+    diff[1] /= aspect_ratio;
+    const float dist_squared = len_squared_v2(diff);
+    if (dist_squared > radius_squared) {
+      continue;
+    }
+    const float strength = alpha * BKE_brush_curve_strength_clamped(
+                                       brush, sqrtf(dist_squared), sqrtf(radius_squared));
+
+    const float *delta_sum = delta_buf[adj_el->element - storage];
+
+    {
+      MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(adj_el->element->l, cd_loop_uv_offset);
+      BLI_assert(adj_el->uv == luv->uv); /* Only true for head. */
+      adj_el->uv[0] = luv->uv[0] + strength * safe_divide(delta_sum[0], delta_sum[2]);
+      adj_el->uv[1] = luv->uv[1] + strength * safe_divide(delta_sum[1], delta_sum[2]);
+      apply_sculpt_data_constraints(sculptdata, adj_el->uv);
+    }
+
+    /* Copy UV co-ordinates to all UvElements. */
+    UvElement *tail = adj_el->element;
+    while (tail) {
+      MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(tail->l, cd_loop_uv_offset);
+      copy_v2_v2(luv->uv, adj_el->uv);
+      tail = tail->next;
+      if (tail && tail->separate) {
+        break;
+      }
+    }
+  }
+
+  MEM_SAFE_FREE(delta_buf);
+}
+
 static void uv_sculpt_stroke_apply(bContext *C,
                                    wmOperator *op,
                                    const wmEvent *event,
@@ -327,17 +507,15 @@ static void uv_sculpt_stroke_apply(bContext *C,
     int i;
     alpha *= invert;
     for (i = 0; i < sculptdata->totalUniqueUvs; i++) {
-      float dist, diff[2];
-      /* This is supposed to happen only if "Lock Borders" is on,
-       * since we have initialization on stroke start.
-       * If ever uv brushes get their own mode we should check for toolsettings option too. */
-      if (sculptdata->uv[i].flag & MARK_BOUNDARY) {
+      if (sculptdata->uv[i].is_locked) {
         continue;
       }
 
+      float diff[2];
       sub_v2_v2v2(diff, sculptdata->uv[i].uv, co);
       diff[1] /= aspectRatio;
-      if ((dist = dot_v2v2(diff, diff)) <= radius) {
+      float dist = dot_v2v2(diff, diff);
+      if (dist <= radius) {
         UvElement *element;
         float strength;
         strength = alpha * BKE_brush_curve_strength_clamped(brush, sqrtf(dist), radius_root);
@@ -346,6 +524,8 @@ static void uv_sculpt_stroke_apply(bContext *C,
         sculptdata->uv[i].uv[0] -= strength * diff[0] * 0.001f;
         sculptdata->uv[i].uv[1] -= strength * diff[1] * 0.001f;
 
+        apply_sculpt_data_constraints(sculptdata, sculptdata->uv[i].uv);
+
         for (element = sculptdata->uv[i].element; element; element = element->next) {
           MLoopUV *luv;
           BMLoop *l;
@@ -363,16 +543,11 @@ static void uv_sculpt_stroke_apply(bContext *C,
   }
 
   /*
-   * Smooth Tool
+   * Relax Tool
    */
   else if (tool == UV_SCULPT_TOOL_RELAX) {
-    uint method = toolsettings->uv_relax_method;
-    if (method == UV_SCULPT_TOOL_RELAX_HC) {
-      HC_relaxation_iteration_uv(em, sculptdata, co, alpha, radius, aspectRatio);
-    }
-    else {
-      laplacian_relaxation_iteration_uv(em, sculptdata, co, alpha, radius, aspectRatio);
-    }
+    relaxation_iteration_uv(
+        em, sculptdata, co, alpha, radius, aspectRatio, toolsettings->uv_relax_method);
   }
 
   /*
@@ -392,6 +567,8 @@ static void uv_sculpt_stroke_apply(bContext *C,
       sculptdata->uv[uvindex].uv[1] =
           sculptdata->initial_stroke->initialSelection[i].initial_uv[1] + strength * diff[1];
 
+      apply_sculpt_data_constraints(sculptdata, sculptdata->uv[uvindex].uv);
+
       for (element = sculptdata->uv[uvindex].element; element; element = element->next) {
         MLoopUV *luv;
         BMLoop *l;
@@ -405,11 +582,18 @@ static void uv_sculpt_stroke_apply(bContext *C,
         copy_v2_v2(luv->uv, sculptdata->uv[uvindex].uv);
       }
     }
+    if (sima->flag & SI_LIVE_UNWRAP) {
+      ED_uvedit_live_unwrap_re_solve();
+    }
   }
 }
 
 static void uv_sculpt_stroke_exit(bContext *C, wmOperator *op)
 {
+  SpaceImage *sima = CTX_wm_space_image(C);
+  if (sima->flag & SI_LIVE_UNWRAP) {
+    ED_uvedit_live_unwrap_end(false);
+  }
   UvSculptData *data = op->customdata;
   if (data->timer) {
     WM_event_remove_timer(CTX_wm_manager(C), CTX_wm_window(C), data->timer);
@@ -454,6 +638,17 @@ static bool uv_edge_compare(const void *a, const void *b)
   return true;
 }
 
+static void set_element_flag(UvElement *element, const int flag)
+{
+  while (element) {
+    element->flag |= flag;
+    element = element->next;
+    if (!element || element->separate) {
+      break;
+    }
+  }
+}
+
 static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wmEvent *event)
 {
   Scene *scene = CTX_data_scene(C);
@@ -481,8 +676,6 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
 
     bool do_island_optimization = !(ts->uv_sculpt_settings & UV_SCULPT_ALL_ISLANDS);
     int island_index = 0;
-    /* Holds, for each UvElement in elementMap, an index of its unique UV. */
-    int *uniqueUv;
     data->tool = (RNA_enum_get(op->ptr, "mode") == BRUSH_STROKE_SMOOTH) ?
                      UV_SCULPT_TOOL_RELAX :
                      ts->uvsculpt->paint.brush->uv_sculpt_tool;
@@ -518,22 +711,17 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
     /* Count 'unique' UV's */
     int unique_uvs = data->elementMap->total_unique_uvs;
     if (do_island_optimization) {
-      unique_uvs = 0;
-      for (int i = 0; i < data->elementMap->total_uvs; i++) {
-        if (data->elementMap->storage[i].separate &&
-            (data->elementMap->storage[i].island == island_index)) {
-          unique_uvs++;
-        }
-      }
+      unique_uvs = data->elementMap->island_total_unique_uvs[island_index];
     }
 
     /* Allocate the unique uv buffers */
-    data->uv = MEM_mallocN(sizeof(*data->uv) * unique_uvs, "uv_brush_unique_uvs");
-    uniqueUv = MEM_mallocN(sizeof(*uniqueUv) * data->elementMap->total_uvs,
-                           "uv_brush_unique_uv_map");
+    data->uv = MEM_callocN(sizeof(*data->uv) * unique_uvs, "uv_brush_unique_uvs");
+    /* Holds, for each UvElement in elementMap, an index of its unique UV. */
+    int *uniqueUv = MEM_mallocN(sizeof(*uniqueUv) * data->elementMap->total_uvs,
+                                "uv_brush_unique_uv_map");
     edgeHash = BLI_ghash_new(uv_edge_hash, uv_edge_compare, "uv_brush_edge_hash");
     /* we have at most totalUVs edges */
-    edges = MEM_mallocN(sizeof(*edges) * data->elementMap->total_uvs, "uv_brush_all_edges");
+    edges = MEM_callocN(sizeof(*edges) * data->elementMap->total_uvs, "uv_brush_all_edges");
     if (!data->uv || !uniqueUv || !edgeHash || !edges) {
       MEM_SAFE_FREE(edges);
       MEM_SAFE_FREE(uniqueUv);
@@ -565,13 +753,18 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
 
           counter++;
           data->uv[counter].element = element;
-          data->uv[counter].flag = 0;
           data->uv[counter].uv = luv->uv;
+          if (data->tool != UV_SCULPT_TOOL_GRAB) {
+            if (luv->flag & MLOOPUV_PINNED) {
+              data->uv[counter].is_locked = true;
+            }
+          }
         }
         /* Pointer arithmetic to the rescue, as always :). */
         uniqueUv[element - data->elementMap->storage] = counter;
       }
     }
+    BLI_assert(counter + 1 == unique_uvs);
 
     /* Now, on to generate our uv connectivity data */
     counter = 0;
@@ -581,7 +774,6 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
                          data->elementMap, efa, l, island_index, do_island_optimization);
         int offset2, itmp2 = uv_element_offset_from_face_get(
                          data->elementMap, efa, l->next, island_index, do_island_optimization);
-        char *flag;
 
         /* Skip edge if not found(unlikely) or not on valid island */
         if (itmp1 == -1 || itmp2 == -1) {
@@ -591,7 +783,6 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
         offset1 = uniqueUv[itmp1];
         offset2 = uniqueUv[itmp2];
 
-        edges[counter].flag = 0;
         /* Using an order policy, sort UV's according to address space.
          * This avoids having two different UvEdges with the same UV's on different positions. */
         if (offset1 < offset2) {
@@ -602,15 +793,13 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
           edges[counter].uv1 = offset2;
           edges[counter].uv2 = offset1;
         }
-        /* Hack! Set the value of the key to its flag.
-         * Now we can set the flag when an edge exists twice :) */
-        flag = BLI_ghash_lookup(edgeHash, &edges[counter]);
-        if (flag) {
-          *flag = 1;
+        UvEdge *prev_edge = BLI_ghash_lookup(edgeHash, &edges[counter]);
+        if (prev_edge) {
+          prev_edge->is_interior = true;
+          edges[counter].is_interior = true;
         }
         else {
-          /* Hack mentioned */
-          BLI_ghash_insert(edgeHash, &edges[counter], &edges[counter].flag);
+          BLI_ghash_insert(edgeHash, &edges[counter], &edges[counter]);
         }
         counter++;
       }
@@ -619,7 +808,7 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
     MEM_SAFE_FREE(uniqueUv);
 
     /* Allocate connectivity data, we allocate edges once */
-    data->uvedges = MEM_mallocN(sizeof(*data->uvedges) * BLI_ghash_len(edgeHash),
+    data->uvedges = MEM_callocN(sizeof(*data->uvedges) * BLI_ghash_len(edgeHash),
                                 "uv_brush_edge_connectivity_data");
     if (!data->uvedges) {
       BLI_ghash_free(edgeHash, NULL, NULL);
@@ -642,20 +831,27 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
     MEM_SAFE_FREE(edges);
 
     /* transfer boundary edge property to UV's */
-    if (ts->uv_sculpt_settings & UV_SCULPT_LOCK_BORDERS) {
-      for (int i = 0; i < data->totalUvEdges; i++) {
-        if (!data->uvedges[i].flag) {
-          data->uv[data->uvedges[i].uv1].flag |= MARK_BOUNDARY;
-          data->uv[data->uvedges[i].uv2].flag |= MARK_BOUNDARY;
+    for (int i = 0; i < data->totalUvEdges; i++) {
+      if (!data->uvedges[i].is_interior) {
+        data->uv[data->uvedges[i].uv1].is_boundary = true;
+        data->uv[data->uvedges[i].uv2].is_boundary = true;
+        if (ts->uv_sculpt_settings & UV_SCULPT_LOCK_BORDERS) {
+          data->uv[data->uvedges[i].uv1].is_locked = true;
+          data->uv[data->uvedges[i].uv2].is_locked = true;
         }
+        set_element_flag(data->uv[data->uvedges[i].uv1].element, MARK_BOUNDARY);
+        set_element_flag(data->uv[data->uvedges[i].uv2].element, MARK_BOUNDARY);
       }
     }
 
+    SpaceImage *sima = CTX_wm_space_image(C);
+    data->constrain_to_bounds = (sima->flag & SI_CLIP_UV);
+    BKE_image_find_nearest_tile_with_offset(sima->image, co, data->uv_base_offset);
+
     /* Allocate initial selection for grab tool */
     if (data->tool == UV_SCULPT_TOOL_GRAB) {
       float radius, radius_root;
       UvSculptData *sculptdata = (UvSculptData *)op->customdata;
-      SpaceImage *sima;
       int width, height;
       float aspectRatio;
       float alpha, zoomx, zoomy;
@@ -664,7 +860,6 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
       alpha = BKE_brush_alpha_get(scene, brush);
 
       radius = BKE_brush_size_get(scene, brush);
-      sima = CTX_wm_space_image(C);
       ED_space_image_get_size(sima, &width, &height);
       ED_space_image_get_zoom(sima, region, &zoomx, &zoomy);
 
@@ -689,16 +884,16 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
       copy_v2_v2(data->initial_stroke->init_coord, co);
 
       counter = 0;
-
       for (int i = 0; i < data->totalUniqueUvs; i++) {
-        float dist, diff[2];
-        if (data->uv[i].flag & MARK_BOUNDARY) {
+        if (data->uv[i].is_locked) {
           continue;
         }
 
+        float diff[2];
         sub_v2_v2v2(diff, data->uv[i].uv, co);
         diff[1] /= aspectRatio;
-        if ((dist = dot_v2v2(diff, diff)) <= radius) {
+        float dist = dot_v2v2(diff, diff);
+        if (dist <= radius) {
           float strength;
           strength = alpha * BKE_brush_curve_strength_clamped(brush, sqrtf(dist), radius_root);
 
@@ -710,6 +905,9 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
       }
 
       data->initial_stroke->totalInitialSelected = counter;
+      if (sima->flag & SI_LIVE_UNWRAP) {
+        ED_uvedit_live_unwrap_begin(scene, obedit);
+      }
     }
   }