Merge branch 'master' into bevelv2

1 files changed, 44 insertions, 47 deletions

diff --git a/source/blender/draw/intern/draw_cache_impl_curves.cc b/source/blender/draw/intern/draw_cache_impl_curves.cc
index 33b97388620..85dd9ca8695 100644
--- a/source/blender/draw/intern/draw_cache_impl_curves.cc
+++ b/source/blender/draw/intern/draw_cache_impl_curves.cc
@@ -14,9 +14,9 @@
 #include "BLI_listbase.h"
 #include "BLI_math_base.h"
 #include "BLI_math_vec_types.hh"
-#include "BLI_math_vector.h"
 #include "BLI_math_vector.hh"
 #include "BLI_span.hh"
+#include "BLI_task.hh"
 #include "BLI_utildefines.h"
 
 #include "DNA_curves_types.h"
@@ -60,7 +60,7 @@ struct CurvesBatchCache {
    * some locking would be necessary because multiple objects can use the same curves data with
    * different materials, etc. This is a placeholder to make multi-threading easier in the future.
    */
-  ThreadMutex render_mutex;
+  std::mutex render_mutex;
 };
 
 static bool curves_batch_cache_valid(const Curves &curves)
@@ -74,15 +74,13 @@ static void curves_batch_cache_init(Curves &curves)
   CurvesBatchCache *cache = static_cast<CurvesBatchCache *>(curves.batch_cache);
 
   if (!cache) {
-    cache = MEM_cnew<CurvesBatchCache>(__func__);
+    cache = MEM_new<CurvesBatchCache>(__func__);
     curves.batch_cache = cache;
   }
   else {
-    memset(cache, 0, sizeof(*cache));
+    cache->curves_cache = {};
   }
 
-  BLI_mutex_init(&cache->render_mutex);
-
   cache->is_dirty = false;
 }
 
@@ -172,9 +170,8 @@ void DRW_curves_batch_cache_dirty_tag(Curves *curves, int mode)
 void DRW_curves_batch_cache_free(Curves *curves)
 {
   curves_batch_cache_clear(*curves);
-  CurvesBatchCache *cache = static_cast<CurvesBatchCache *>(curves->batch_cache);
-  BLI_mutex_end(&cache->render_mutex);
-  MEM_SAFE_FREE(curves->batch_cache);
+  MEM_delete(static_cast<CurvesBatchCache *>(curves->batch_cache));
+  curves->batch_cache = nullptr;
 }
 
 void DRW_curves_batch_cache_free_old(Curves *curves, int ctime)
@@ -226,38 +223,38 @@ static void curves_batch_cache_fill_segments_proc_pos(
     MutableSpan<PositionAndParameter> posTime_data,
     MutableSpan<float> hairLength_data)
 {
+  using namespace blender;
   /* TODO: use hair radius layer if available. */
-  const int curve_num = curves_id.geometry.curve_num;
-  const blender::bke::CurvesGeometry &curves = blender::bke::CurvesGeometry::wrap(
-      curves_id.geometry);
-  Span<float3> positions = curves.positions();
+  const bke::CurvesGeometry &curves = bke::CurvesGeometry::wrap(curves_id.geometry);
+  const Span<float3> positions = curves.positions();
 
-  for (const int i_curve : IndexRange(curve_num)) {
-    const IndexRange points = curves.points_for_curve(i_curve);
+  threading::parallel_for(curves.curves_range(), 1024, [&](const IndexRange range) {
+    for (const int i_curve : range) {
+      const IndexRange points = curves.points_for_curve(i_curve);
 
-    Span<float3> curve_positions = positions.slice(points);
-    MutableSpan<PositionAndParameter> curve_posTime_data = posTime_data.slice(points);
-
-    float total_len = 0.0f;
-    for (const int i_point : curve_positions.index_range()) {
-      if (i_point > 0) {
-        total_len += blender::math::distance(curve_positions[i_point - 1],
-                                             curve_positions[i_point]);
-      }
-      curve_posTime_data[i_point].position = curve_positions[i_point];
-      curve_posTime_data[i_point].parameter = total_len;
-    }
-    hairLength_data[i_curve] = total_len;
+      Span<float3> curve_positions = positions.slice(points);
+      MutableSpan<PositionAndParameter> curve_posTime_data = posTime_data.slice(points);
 
-    /* Assign length value. */
-    if (total_len > 0.0f) {
-      const float factor = 1.0f / total_len;
-      /* Divide by total length to have a [0-1] number. */
+      float total_len = 0.0f;
       for (const int i_point : curve_positions.index_range()) {
-        curve_posTime_data[i_point].parameter *= factor;
+        if (i_point > 0) {
+          total_len += math::distance(curve_positions[i_point - 1], curve_positions[i_point]);
+        }
+        curve_posTime_data[i_point].position = curve_positions[i_point];
+        curve_posTime_data[i_point].parameter = total_len;
+      }
+      hairLength_data[i_curve] = total_len;
+
+      /* Assign length value. */
+      if (total_len > 0.0f) {
+        const float factor = 1.0f / total_len;
+        /* Divide by total length to have a [0-1] number. */
+        for (const int i_point : curve_positions.index_range()) {
+          curve_posTime_data[i_point].parameter *= factor;
+        }
       }
     }
-  }
+  });
 }
 
 static void curves_batch_cache_ensure_procedural_pos(const Curves &curves,
@@ -275,7 +272,7 @@ static void curves_batch_cache_ensure_procedural_pos(const Curves &curves,
     GPU_vertbuf_data_alloc(cache.proc_point_buf, cache.point_len);
 
     MutableSpan posTime_data{
-        reinterpret_cast<PositionAndParameter *>(GPU_vertbuf_get_data(cache.proc_point_buf)),
+        static_cast<PositionAndParameter *>(GPU_vertbuf_get_data(cache.proc_point_buf)),
         cache.point_len};
 
     GPUVertFormat length_format = {0};
@@ -285,8 +282,8 @@ static void curves_batch_cache_ensure_procedural_pos(const Curves &curves,
         &length_format, GPU_USAGE_STATIC | GPU_USAGE_FLAG_BUFFER_TEXTURE_ONLY);
     GPU_vertbuf_data_alloc(cache.proc_length_buf, cache.strands_len);
 
-    MutableSpan hairLength_data{
-        reinterpret_cast<float *>(GPU_vertbuf_get_data(cache.proc_length_buf)), cache.strands_len};
+    MutableSpan hairLength_data{static_cast<float *>(GPU_vertbuf_get_data(cache.proc_length_buf)),
+                                cache.strands_len};
 
     curves_batch_cache_fill_segments_proc_pos(curves, posTime_data, hairLength_data);
 
@@ -310,15 +307,15 @@ static void curves_batch_cache_ensure_procedural_pos(const Curves &curves,
 static void curves_batch_cache_ensure_data_edit_points(const Curves &curves_id,
                                                        CurvesEvalCache &cache)
 {
-  const blender::bke::CurvesGeometry &curves = blender::bke::CurvesGeometry::wrap(
-      curves_id.geometry);
+  using namespace blender;
+  const bke::CurvesGeometry &curves = bke::CurvesGeometry::wrap(curves_id.geometry);
 
   static GPUVertFormat format_data = {0};
   uint data = GPU_vertformat_attr_add(&format_data, "data", GPU_COMP_U8, 1, GPU_FETCH_INT);
   GPU_vertbuf_init_with_format(cache.data_edit_points, &format_data);
   GPU_vertbuf_data_alloc(cache.data_edit_points, curves.points_num());
 
-  blender::VArray<float> selection;
+  VArray<float> selection;
   switch (curves_id.selection_domain) {
     case ATTR_DOMAIN_POINT:
       selection = curves.selection_point_float();
@@ -380,6 +377,7 @@ static void curves_batch_ensure_attribute(const Curves &curves,
                                           const int subdiv,
                                           const int index)
 {
+  using namespace blender;
   GPU_VERTBUF_DISCARD_SAFE(cache.proc_attributes_buf[index]);
   DRW_TEXTURE_FREE_SAFE(cache.proc_attributes_tex[index]);
 
@@ -399,15 +397,15 @@ static void curves_batch_ensure_attribute(const Curves &curves,
                          request.domain == ATTR_DOMAIN_POINT ? curves.geometry.point_num :
                                                                curves.geometry.curve_num);
 
-  const blender::bke::AttributeAccessor attributes =
-      blender::bke::CurvesGeometry::wrap(curves.geometry).attributes();
+  const bke::AttributeAccessor attributes =
+      bke::CurvesGeometry::wrap(curves.geometry).attributes();
 
   /* TODO(@kevindietrich): float4 is used for scalar attributes as the implicit conversion done
    * by OpenGL to vec4 for a scalar `s` will produce a `vec4(s, 0, 0, 1)`. However, following
    * the Blender convention, it should be `vec4(s, s, s, 1)`. This could be resolved using a
    * similar texture state swizzle to map the attribute correctly as for volume attributes, so we
    * can control the conversion ourselves. */
-  blender::VArray<ColorGeometry4f> attribute = attributes.lookup_or_default<ColorGeometry4f>(
+  VArray<ColorGeometry4f> attribute = attributes.lookup_or_default<ColorGeometry4f>(
       request.attribute_name, request.domain, {0.0f, 0.0f, 0.0f, 1.0f});
 
   MutableSpan<ColorGeometry4f> vbo_span{
@@ -554,7 +552,6 @@ static bool curves_ensure_attributes(const Curves &curves,
                                      GPUMaterial *gpu_material,
                                      int subdiv)
 {
-  ThreadMutex *render_mutex = &cache.render_mutex;
   const CustomData *cd_curve = &curves.geometry.curve_data;
   const CustomData *cd_point = &curves.geometry.point_data;
   CurvesEvalFinalCache &final_cache = cache.curves_cache.final[subdiv];
@@ -588,9 +585,9 @@ static bool curves_ensure_attributes(const Curves &curves,
         GPU_VERTBUF_DISCARD_SAFE(cache.curves_cache.proc_attributes_buf[i]);
         DRW_TEXTURE_FREE_SAFE(cache.curves_cache.proc_attributes_tex[i]);
       }
-      drw_attributes_merge(&final_cache.attr_used, &attrs_needed, render_mutex);
+      drw_attributes_merge(&final_cache.attr_used, &attrs_needed, cache.render_mutex);
     }
-    drw_attributes_merge(&final_cache.attr_used_over_time, &attrs_needed, render_mutex);
+    drw_attributes_merge(&final_cache.attr_used_over_time, &attrs_needed, cache.render_mutex);
   }
 
   bool need_tf_update = false;
@@ -689,7 +686,7 @@ static void request_attribute(Curves &curves, const char *name)
   drw_attributes_add_request(
       &attributes, name, type, CustomData_get_named_layer(&custom_data, type, name), domain);
 
-  drw_attributes_merge(&final_cache.attr_used, &attributes, &cache.render_mutex);
+  drw_attributes_merge(&final_cache.attr_used, &attributes, cache.render_mutex);
 }
 
 GPUTexture **DRW_curves_texture_for_evaluated_attribute(Curves *curves,