Merge branch 'master' into refactor-mesh-hide-generic

5 files changed, 55 insertions, 30 deletions

diff --git a/source/blender/editors/sculpt_paint/sculpt.c b/source/blender/editors/sculpt_paint/sculpt.c
index 85cc1b526ab..020b0954458 100644
--- a/source/blender/editors/sculpt_paint/sculpt.c
+++ b/source/blender/editors/sculpt_paint/sculpt.c
@@ -5392,7 +5392,7 @@ static bool sculpt_stroke_test_start(bContext *C, struct wmOperator *op, const f
 
 static void sculpt_stroke_update_step(bContext *C,
                                       wmOperator *UNUSED(op),
-                                      struct PaintStroke *UNUSED(stroke),
+                                      struct PaintStroke *stroke,
                                       PointerRNA *itemptr)
 {
   UnifiedPaintSettings *ups = &CTX_data_tool_settings(C)->unified_paint_settings;
@@ -5401,6 +5401,8 @@ static void sculpt_stroke_update_step(bContext *C,
   SculptSession *ss = ob->sculpt;
   const Brush *brush = BKE_paint_brush(&sd->paint);
   ToolSettings *tool_settings = CTX_data_tool_settings(C);
+  StrokeCache *cache = ss->cache;
+  cache->stroke_distance = paint_stroke_distance_get(stroke);
 
   SCULPT_stroke_modifiers_check(C, ob, brush);
   sculpt_update_cache_variants(C, sd, ob, itemptr);
diff --git a/source/blender/editors/sculpt_paint/sculpt_intern.h b/source/blender/editors/sculpt_paint/sculpt_intern.h
index 86f89c3c2fa..6a10f7cad18 100644
--- a/source/blender/editors/sculpt_paint/sculpt_intern.h
+++ b/source/blender/editors/sculpt_paint/sculpt_intern.h
@@ -489,6 +489,7 @@ typedef struct StrokeCache {
   float true_last_location[3];
   float location[3];
   float last_location[3];
+  float stroke_distance;
 
   /* Used for alternating between deformation in brushes that need to apply different ones to
    * achieve certain effects. */
diff --git a/source/blender/editors/sculpt_paint/sculpt_paint_color.c b/source/blender/editors/sculpt_paint/sculpt_paint_color.c
index cb178b23008..c494c71f1eb 100644
--- a/source/blender/editors/sculpt_paint/sculpt_paint_color.c
+++ b/source/blender/editors/sculpt_paint/sculpt_paint_color.c
@@ -17,6 +17,7 @@
 #include "DNA_meshdata_types.h"
 
 #include "BKE_brush.h"
+#include "BKE_colorband.h"
 #include "BKE_colortools.h"
 #include "BKE_context.h"
 #include "BKE_mesh.h"
@@ -117,11 +118,31 @@ static void do_paint_brush_task_cb_ex(void *__restrict userdata,
   const int thread_id = BLI_task_parallel_thread_id(tls);
 
   float brush_color[4] = {0.0f, 0.0f, 0.0f, 1.0f};
+
   copy_v3_v3(brush_color,
              ss->cache->invert ? BKE_brush_secondary_color_get(ss->scene, brush) :
                                  BKE_brush_color_get(ss->scene, brush));
+
   IMB_colormanagement_srgb_to_scene_linear_v3(brush_color, brush_color);
 
+  if (brush->flag & BRUSH_USE_GRADIENT) {
+    switch (brush->gradient_stroke_mode) {
+      case BRUSH_GRADIENT_PRESSURE:
+        BKE_colorband_evaluate(brush->gradient, ss->cache->pressure, brush_color);
+        break;
+      case BRUSH_GRADIENT_SPACING_REPEAT: {
+        float coord = fmod(ss->cache->stroke_distance / brush->gradient_spacing, 1.0);
+        BKE_colorband_evaluate(brush->gradient, coord, brush_color);
+        break;
+      }
+      case BRUSH_GRADIENT_SPACING_CLAMP: {
+        BKE_colorband_evaluate(
+            brush->gradient, ss->cache->stroke_distance / brush->gradient_spacing, brush_color);
+        break;
+      }
+    }
+  }
+
   BKE_pbvh_vertex_iter_begin (ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE) {
     SCULPT_orig_vert_data_update(&orig_data, &vd);
 
diff --git a/source/blender/editors/sculpt_paint/sculpt_undo.c b/source/blender/editors/sculpt_paint/sculpt_undo.c
index 99f6a45ce1a..04b2b2f04bf 100644
--- a/source/blender/editors/sculpt_paint/sculpt_undo.c
+++ b/source/blender/editors/sculpt_paint/sculpt_undo.c
@@ -171,7 +171,7 @@ static void update_cb_partial(PBVHNode *node, void *userdata)
   }
   else {
     if (BKE_pbvh_node_has_vert_with_normal_update_tag(data->pbvh, node)) {
-      BKE_pbvh_node_mark_normals_update(node);
+      BKE_pbvh_node_mark_update(node);
     }
     int verts_num;
     const int *vert_indices;
diff --git a/source/blender/editors/sculpt_paint/sculpt_uv.c b/source/blender/editors/sculpt_paint/sculpt_uv.c
index dfa85e8e56d..f2017e68b4c 100644
--- a/source/blender/editors/sculpt_paint/sculpt_uv.c
+++ b/source/blender/editors/sculpt_paint/sculpt_uv.c
@@ -414,9 +414,8 @@ static void uv_sculpt_stroke_exit(bContext *C, wmOperator *op)
   if (data->timer) {
     WM_event_remove_timer(CTX_wm_manager(C), CTX_wm_window(C), data->timer);
   }
-  if (data->elementMap) {
-    BM_uv_element_map_free(data->elementMap);
-  }
+  BM_uv_element_map_free(data->elementMap);
+  data->elementMap = NULL;
   MEM_SAFE_FREE(data->uv);
   MEM_SAFE_FREE(data->uvedges);
   if (data->initial_stroke) {
@@ -435,7 +434,7 @@ static int uv_element_offset_from_face_get(
   if (!element || (doIslands && element->island != island_index)) {
     return -1;
   }
-  return element - map->buf;
+  return element - map->storage;
 }
 
 static uint uv_edge_hash(const void *key)
@@ -469,7 +468,6 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
   BKE_curvemapping_init(ts->uvsculpt->paint.brush->curve);
 
   if (data) {
-    int counter = 0, i;
     ARegion *region = CTX_wm_region(C);
     float co[2];
     BMFace *efa;
@@ -492,13 +490,12 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
 
     data->uvsculpt = &ts->uvsculpt->paint;
 
-    if (do_island_optimization) {
-      /* We will need island information */
-      data->elementMap = BM_uv_element_map_create(bm, scene, false, true, true);
-    }
-    else {
-      data->elementMap = BM_uv_element_map_create(bm, scene, false, true, false);
-    }
+    /* Winding was added to island detection in 5197aa04c6bd
+     * However the sculpt tools can flip faces, potentially creating orphaned islands.
+     * See T100132 */
+    bool use_winding = false;
+    data->elementMap = BM_uv_element_map_create(
+        bm, scene, false, use_winding, do_island_optimization);
 
     if (!data->elementMap) {
       uv_sculpt_stroke_exit(C, op);
@@ -519,20 +516,24 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
     }
 
     /* Count 'unique' UV's */
-    for (i = 0; i < data->elementMap->totalUVs; i++) {
-      if (data->elementMap->buf[i].separate &&
-          (!do_island_optimization || data->elementMap->buf[i].island == island_index)) {
-        counter++;
+    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++;
+        }
       }
     }
 
     /* Allocate the unique uv buffers */
-    data->uv = MEM_mallocN(sizeof(*data->uv) * counter, "uv_brush_unique_uvs");
-    uniqueUv = MEM_mallocN(sizeof(*uniqueUv) * data->elementMap->totalUVs,
+    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");
     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->totalUVs, "uv_brush_all_edges");
+    edges = MEM_mallocN(sizeof(*edges) * data->elementMap->total_uvs, "uv_brush_all_edges");
     if (!data->uv || !uniqueUv || !edgeHash || !edges) {
       MEM_SAFE_FREE(edges);
       MEM_SAFE_FREE(uniqueUv);
@@ -543,12 +544,12 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
       return NULL;
     }
 
-    data->totalUniqueUvs = counter;
-    /* So that we can use this as index for the UvElements */
-    counter = -1;
+    data->totalUniqueUvs = unique_uvs;
+    /* Index for the UvElements. */
+    int counter = -1;
     /* initialize the unique UVs */
-    for (i = 0; i < bm->totvert; i++) {
-      UvElement *element = data->elementMap->vert[i];
+    for (int i = 0; i < bm->totvert; i++) {
+      UvElement *element = data->elementMap->vertex[i];
       for (; element; element = element->next) {
         if (element->separate) {
           if (do_island_optimization && (element->island != island_index)) {
@@ -568,7 +569,7 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
           data->uv[counter].uv = luv->uv;
         }
         /* Pointer arithmetic to the rescue, as always :). */
-        uniqueUv[element - data->elementMap->buf] = counter;
+        uniqueUv[element - data->elementMap->storage] = counter;
       }
     }
 
@@ -628,7 +629,7 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
     }
 
     /* fill the edges with data */
-    i = 0;
+    int i = 0;
     GHASH_ITER (gh_iter, edgeHash) {
       data->uvedges[i++] = *((UvEdge *)BLI_ghashIterator_getKey(&gh_iter));
     }
@@ -640,7 +641,7 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
 
     /* transfer boundary edge property to UV's */
     if (ts->uv_sculpt_settings & UV_SCULPT_LOCK_BORDERS) {
-      for (i = 0; i < data->totalUvEdges; i++) {
+      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;
@@ -687,7 +688,7 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
 
       counter = 0;
 
-      for (i = 0; i < data->totalUniqueUvs; i++) {
+      for (int i = 0; i < data->totalUniqueUvs; i++) {
         float dist, diff[2];
         if (data->uv[i].flag & MARK_BOUNDARY) {
           continue;