Merge branch 'master' into blender2.8

1 files changed, 257 insertions, 120 deletions

diff --git a/source/blender/editors/sculpt_paint/sculpt.c b/source/blender/editors/sculpt_paint/sculpt.c
index 6e08f47f60d..1af522ffd8d 100644
--- a/source/blender/editors/sculpt_paint/sculpt.c
+++ b/source/blender/editors/sculpt_paint/sculpt.c
@@ -377,7 +377,8 @@ static bool sculpt_stroke_is_dynamic_topology(
 
 /*** paint mesh ***/
 
-static void paint_mesh_restore_co_task_cb(void *userdata, const int n)
+static void paint_mesh_restore_co_task_cb(void *userdata, const int n,
+                                          const ParallelRangeTLS *UNUSED(tls))
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -439,9 +440,14 @@ static void paint_mesh_restore_co(Sculpt *sd, Object *ob)
 		.sd = sd, .ob = ob, .brush = brush, .nodes = nodes,
 	};
 
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && !ss->bm && totnode > SCULPT_THREADED_LIMIT);
 	BLI_task_parallel_range(
-	            0, totnode, &data, paint_mesh_restore_co_task_cb,
-	            ((sd->flags & SCULPT_USE_OPENMP) && !ss->bm && totnode > SCULPT_THREADED_LIMIT));
+	            0, totnode,
+	            &data,
+	            paint_mesh_restore_co_task_cb,
+	            &settings);
 
 	if (nodes)
 		MEM_freeN(nodes);
@@ -794,7 +800,8 @@ static float calc_symmetry_feather(Sculpt *sd, StrokeCache *cache)
  * \note These are all _very_ similar, when changing one, check others.
  * \{ */
 
-static void calc_area_normal_and_center_task_cb(void *userdata, const int n)
+static void calc_area_normal_and_center_task_cb(void *userdata, const int n,
+                                                const ParallelRangeTLS *UNUSED(tls))
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -946,9 +953,14 @@ static void calc_area_center(
 	};
 	BLI_mutex_init(&data.mutex);
 
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
 	BLI_task_parallel_range(
-	            0, totnode, &data, calc_area_normal_and_center_task_cb,
-	            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT));
+	            0, totnode,
+	            &data,
+	            calc_area_normal_and_center_task_cb,
+	            &settings);
 
 	BLI_mutex_end(&data.mutex);
 
@@ -996,9 +1008,14 @@ void sculpt_pbvh_calc_area_normal(
 	};
 	BLI_mutex_init(&data.mutex);
 
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = use_threading;
 	BLI_task_parallel_range(
-	            0, totnode, &data, calc_area_normal_and_center_task_cb,
-	            use_threading);
+	            0, totnode,
+	            &data,
+	            calc_area_normal_and_center_task_cb,
+	            &settings);
 
 	BLI_mutex_end(&data.mutex);
 
@@ -1036,9 +1053,14 @@ static void calc_area_normal_and_center(
 	};
 	BLI_mutex_init(&data.mutex);
 
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
 	BLI_task_parallel_range(
-	            0, totnode, &data, calc_area_normal_and_center_task_cb,
-	            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT));
+	            0, totnode,
+	            &data,
+	            calc_area_normal_and_center_task_cb,
+	            &settings);
 
 	BLI_mutex_end(&data.mutex);
 
@@ -1626,7 +1648,7 @@ typedef struct {
 } SculptFindNearestToRayData;
 
 static void do_smooth_brush_mesh_task_cb_ex(
-        void *userdata, void *UNUSED(userdata_chunk), const int n, const int thread_id)
+        void *userdata, const int n, const ParallelRangeTLS *tls)
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -1648,7 +1670,7 @@ static void do_smooth_brush_mesh_task_cb_ex(
 		if (sculpt_brush_test_sq_fn(&test, vd.co)) {
 			const float fade = bstrength * tex_strength(
 			        ss, brush, vd.co, sqrtf(test.dist),
-			        vd.no, vd.fno, smooth_mask ? 0.0f : (vd.mask ? *vd.mask : 0.0f), thread_id);
+			        vd.no, vd.fno, smooth_mask ? 0.0f : (vd.mask ? *vd.mask : 0.0f), tls->thread_id);
 			if (smooth_mask) {
 				float val = neighbor_average_mask(ss, vd.vert_indices[vd.i]) - *vd.mask;
 				val *= fade * bstrength;
@@ -1674,7 +1696,7 @@ static void do_smooth_brush_mesh_task_cb_ex(
 }
 
 static void do_smooth_brush_bmesh_task_cb_ex(
-        void *userdata, void *UNUSED(userdata_chunk), const int n, const int thread_id)
+        void *userdata, const int n, const ParallelRangeTLS *tls)
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -1696,7 +1718,7 @@ static void do_smooth_brush_bmesh_task_cb_ex(
 		if (sculpt_brush_test_sq_fn(&test, vd.co)) {
 			const float fade = bstrength * tex_strength(
 			        ss, brush, vd.co, sqrtf(test.dist),
-			        vd.no, vd.fno, smooth_mask ? 0.0f : *vd.mask, thread_id);
+			        vd.no, vd.fno, smooth_mask ? 0.0f : *vd.mask, tls->thread_id);
 			if (smooth_mask) {
 				float val = bmesh_neighbor_average_mask(vd.bm_vert, vd.cd_vert_mask_offset) - *vd.mask;
 				val *= fade * bstrength;
@@ -1722,10 +1744,10 @@ static void do_smooth_brush_bmesh_task_cb_ex(
 }
 
 static void do_smooth_brush_multires_task_cb_ex(
-        void *userdata, void *userdata_chunk, const int n, const int thread_id)
+        void *userdata, const int n, const ParallelRangeTLS *tls)
 {
 	SculptThreadedTaskData *data = userdata;
-	SculptDoBrushSmoothGridDataChunk *data_chunk = userdata_chunk;
+	SculptDoBrushSmoothGridDataChunk *data_chunk = tls->userdata_chunk;
 	SculptSession *ss = data->ob->sculpt;
 	Sculpt *sd = data->sd;
 	const Brush *brush = data->brush;
@@ -1837,7 +1859,7 @@ static void do_smooth_brush_multires_task_cb_ex(
 					const float strength_mask = (smooth_mask ? 0.0f : *mask);
 					const float fade = bstrength * tex_strength(
 					        ss, brush, co, sqrtf(test.dist),
-					        NULL, fno, strength_mask, thread_id);
+					        NULL, fno, strength_mask, tls->thread_id);
 					float f = 1.0f / 16.0f;
 
 					if (x == 0 || x == gridsize - 1)
@@ -1895,6 +1917,10 @@ static void smooth(
 		    .smooth_mask = smooth_mask, .strength = strength,
 		};
 
+		ParallelRangeSettings settings;
+		BLI_parallel_range_settings_defaults(&settings);
+		settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
+
 		switch (type) {
 			case PBVH_GRIDS:
 			{
@@ -1909,22 +1935,30 @@ static void smooth(
 				data_chunk->tmpgrid_size = size;
 				size += sizeof(*data_chunk);
 
-				BLI_task_parallel_range_ex(
-				            0, totnode, &data, data_chunk, size, do_smooth_brush_multires_task_cb_ex,
-				            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
+				settings.userdata_chunk = data_chunk;
+				settings.userdata_chunk_size = size;
+				BLI_task_parallel_range(
+				            0, totnode,
+				            &data,
+				            do_smooth_brush_multires_task_cb_ex,
+				            &settings);
 
 				MEM_freeN(data_chunk);
 				break;
 			}
 			case PBVH_FACES:
-				BLI_task_parallel_range_ex(
-				            0, totnode, &data, NULL, 0, do_smooth_brush_mesh_task_cb_ex,
-				            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
+				BLI_task_parallel_range(
+				            0, totnode,
+				            &data,
+				            do_smooth_brush_mesh_task_cb_ex,
+				            &settings);
 				break;
 			case PBVH_BMESH:
-				BLI_task_parallel_range_ex(
-				            0, totnode, &data, NULL, 0, do_smooth_brush_bmesh_task_cb_ex,
-				            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
+				BLI_task_parallel_range(
+				            0, totnode,
+				            &data,
+				            do_smooth_brush_bmesh_task_cb_ex,
+				            &settings);
 				break;
 		}
 
@@ -1940,7 +1974,7 @@ static void do_smooth_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnod
 }
 
 static void do_mask_brush_draw_task_cb_ex(
-        void *userdata, void *UNUSED(userdata_chunk), const int n, const int thread_id)
+        void *userdata, const int n, const ParallelRangeTLS *tls)
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -1958,7 +1992,7 @@ static void do_mask_brush_draw_task_cb_ex(
 		if (sculpt_brush_test_sq_fn(&test, vd.co)) {
 			const float fade = tex_strength(
 			        ss, brush, vd.co, sqrtf(test.dist),
-			        vd.no, vd.fno, 0.0f, thread_id);
+			        vd.no, vd.fno, 0.0f, tls->thread_id);
 
 			(*vd.mask) += fade * bstrength;
 			CLAMP(*vd.mask, 0, 1);
@@ -1979,9 +2013,14 @@ static void do_mask_brush_draw(Sculpt *sd, Object *ob, PBVHNode **nodes, int tot
 	    .sd = sd, .ob = ob, .brush = brush, .nodes = nodes,
 	};
 
-	BLI_task_parallel_range_ex(
-	            0, totnode, &data, NULL, 0, do_mask_brush_draw_task_cb_ex,
-	            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
+	BLI_task_parallel_range(
+	            0, totnode,
+	            &data,
+	            do_mask_brush_draw_task_cb_ex,
+	            &settings);
 }
 
 static void do_mask_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
@@ -2000,7 +2039,7 @@ static void do_mask_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
 }
 
 static void do_draw_brush_task_cb_ex(
-        void *userdata, void *UNUSED(userdata_chunk), const int n, const int thread_id)
+        void *userdata, const int n, const ParallelRangeTLS *tls)
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -2022,7 +2061,7 @@ static void do_draw_brush_task_cb_ex(
 			/* offset vertex */
 			const float fade = tex_strength(
 			        ss, brush, vd.co, sqrtf(test.dist),
-			        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, thread_id);
+			        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, tls->thread_id);
 
 			mul_v3_v3fl(proxy[vd.i], offset, fade);
 
@@ -2055,16 +2094,21 @@ static void do_draw_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
 	    .offset = offset,
 	};
 
-	BLI_task_parallel_range_ex(
-	            0, totnode, &data, NULL, 0, do_draw_brush_task_cb_ex,
-	            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
+	BLI_task_parallel_range(
+	            0, totnode,
+	            &data,
+	            do_draw_brush_task_cb_ex,
+	            &settings);
 }
 
 /**
  * Used for 'SCULPT_TOOL_CREASE' and 'SCULPT_TOOL_BLOB'
  */
 static void do_crease_brush_task_cb_ex(
-        void *userdata, void *UNUSED(userdata_chunk), const int n, const int thread_id)
+        void *userdata, const int n, const ParallelRangeTLS *tls)
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -2088,7 +2132,7 @@ static void do_crease_brush_task_cb_ex(
 			/* offset vertex */
 			const float fade = tex_strength(
 			        ss, brush, vd.co, sqrtf(test.dist),
-			        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, thread_id);
+			        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, tls->thread_id);
 			float val1[3];
 			float val2[3];
 
@@ -2152,13 +2196,18 @@ static void do_crease_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnod
 	    .spvc = &spvc, .offset = offset, .flippedbstrength = flippedbstrength,
 	};
 
-	BLI_task_parallel_range_ex(
-	            0, totnode, &data, NULL, 0, do_crease_brush_task_cb_ex,
-	            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
+	BLI_task_parallel_range(
+	            0, totnode,
+	            &data,
+	            do_crease_brush_task_cb_ex,
+	            &settings);
 }
 
 static void do_pinch_brush_task_cb_ex(
-        void *userdata, void *UNUSED(userdata_chunk), const int n, const int thread_id)
+        void *userdata, const int n, const ParallelRangeTLS *tls)
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -2179,7 +2228,7 @@ static void do_pinch_brush_task_cb_ex(
 		if (sculpt_brush_test_sq_fn(&test, vd.co)) {
 			const float fade = bstrength * tex_strength(
 			        ss, brush, vd.co, sqrtf(test.dist),
-			        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, thread_id);
+			        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, tls->thread_id);
 			float val[3];
 
 			sub_v3_v3v3(val, test.location, vd.co);
@@ -2203,13 +2252,18 @@ static void do_pinch_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode
 	    .sd = sd, .ob = ob, .brush = brush, .nodes = nodes,
 	};
 
-	BLI_task_parallel_range_ex(
-	            0, totnode, &data, NULL, 0, do_pinch_brush_task_cb_ex,
-	            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
+	BLI_task_parallel_range(
+	            0, totnode,
+	            &data,
+	            do_pinch_brush_task_cb_ex,
+	            &settings);
 }
 
 static void do_grab_brush_task_cb_ex(
-        void *userdata, void *UNUSED(userdata_chunk), const int n, const int thread_id)
+        void *userdata, const int n, const ParallelRangeTLS *tls)
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -2236,7 +2290,7 @@ static void do_grab_brush_task_cb_ex(
 		if (sculpt_brush_test_sq_fn(&test, orig_data.co)) {
 			const float fade = bstrength * tex_strength(
 			        ss, brush, orig_data.co, sqrtf(test.dist),
-			        orig_data.no, NULL, vd.mask ? *vd.mask : 0.0f, thread_id);
+			        orig_data.no, NULL, vd.mask ? *vd.mask : 0.0f, tls->thread_id);
 
 			mul_v3_v3fl(proxy[vd.i], grab_delta, fade);
 
@@ -2264,13 +2318,18 @@ static void do_grab_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
 	    .grab_delta = grab_delta,
 	};
 
-	BLI_task_parallel_range_ex(
-	            0, totnode, &data, NULL, 0, do_grab_brush_task_cb_ex,
-	            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
+	BLI_task_parallel_range(
+	            0, totnode,
+	            &data,
+	            do_grab_brush_task_cb_ex,
+	            &settings);
 }
 
 static void do_nudge_brush_task_cb_ex(
-        void *userdata, void *UNUSED(userdata_chunk), const int n, const int thread_id)
+        void *userdata, const int n, const ParallelRangeTLS *tls)
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -2292,7 +2351,7 @@ static void do_nudge_brush_task_cb_ex(
 		if (sculpt_brush_test_sq_fn(&test, vd.co)) {
 			const float fade = bstrength * tex_strength(
 			        ss, brush, vd.co, sqrtf(test.dist),
-			        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, thread_id);
+			        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, tls->thread_id);
 
 			mul_v3_v3fl(proxy[vd.i], cono, fade);
 
@@ -2320,13 +2379,18 @@ static void do_nudge_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode
 	    .cono = cono,
 	};
 
-	BLI_task_parallel_range_ex(
-	            0, totnode, &data, NULL, 0, do_nudge_brush_task_cb_ex,
-	            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
+	BLI_task_parallel_range(
+	            0, totnode,
+	            &data,
+	            do_nudge_brush_task_cb_ex,
+	            &settings);
 }
 
 static void do_snake_hook_brush_task_cb_ex(
-        void *userdata, void *UNUSED(userdata_chunk), const int n, const int thread_id)
+        void *userdata, const int n, const ParallelRangeTLS *tls)
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -2353,7 +2417,7 @@ static void do_snake_hook_brush_task_cb_ex(
 		if (sculpt_brush_test_sq_fn(&test, vd.co)) {
 			const float fade = bstrength * tex_strength(
 			        ss, brush, vd.co, sqrtf(test.dist),
-			        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, thread_id);
+			        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, tls->thread_id);
 
 			mul_v3_v3fl(proxy[vd.i], grab_delta, fade);
 
@@ -2426,13 +2490,18 @@ static void do_snake_hook_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int to
 	    .spvc = &spvc, .grab_delta = grab_delta,
 	};
 
-	BLI_task_parallel_range_ex(
-	            0, totnode, &data, NULL, 0, do_snake_hook_brush_task_cb_ex,
-	            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
+	BLI_task_parallel_range(
+	            0, totnode,
+	            &data,
+	            do_snake_hook_brush_task_cb_ex,
+	            &settings);
 }
 
 static void do_thumb_brush_task_cb_ex(
-        void *userdata, void *UNUSED(userdata_chunk), const int n, const int thread_id)
+        void *userdata, const int n, const ParallelRangeTLS *tls)
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -2459,7 +2528,7 @@ static void do_thumb_brush_task_cb_ex(
 		if (sculpt_brush_test_sq_fn(&test, orig_data.co)) {
 			const float fade = bstrength * tex_strength(
 			        ss, brush, orig_data.co, sqrtf(test.dist),
-			        orig_data.no, NULL, vd.mask ? *vd.mask : 0.0f, thread_id);
+			        orig_data.no, NULL, vd.mask ? *vd.mask : 0.0f, tls->thread_id);
 
 			mul_v3_v3fl(proxy[vd.i], cono, fade);
 
@@ -2487,13 +2556,18 @@ static void do_thumb_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode
 	    .cono = cono,
 	};
 
-	BLI_task_parallel_range_ex(
-	            0, totnode, &data, NULL, 0, do_thumb_brush_task_cb_ex,
-	            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
+	BLI_task_parallel_range(
+	            0, totnode,
+	            &data,
+	            do_thumb_brush_task_cb_ex,
+	            &settings);
 }
 
 static void do_rotate_brush_task_cb_ex(
-        void *userdata, void *UNUSED(userdata_chunk), const int n, const int thread_id)
+        void *userdata, const int n, const ParallelRangeTLS *tls)
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -2521,7 +2595,7 @@ static void do_rotate_brush_task_cb_ex(
 			float vec[3], rot[3][3];
 			const float fade = bstrength * tex_strength(
 			        ss, brush, orig_data.co, sqrtf(test.dist),
-			        orig_data.no, NULL, vd.mask ? *vd.mask : 0.0f, thread_id);
+			        orig_data.no, NULL, vd.mask ? *vd.mask : 0.0f, tls->thread_id);
 
 			sub_v3_v3v3(vec, orig_data.co, ss->cache->location);
 			axis_angle_normalized_to_mat3(rot, ss->cache->sculpt_normal_symm, angle * fade);
@@ -2549,13 +2623,18 @@ static void do_rotate_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnod
 	    .angle = angle,
 	};
 
-	BLI_task_parallel_range_ex(
-	            0, totnode, &data, NULL, 0, do_rotate_brush_task_cb_ex,
-	            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
+	BLI_task_parallel_range(
+	            0, totnode,
+	            &data,
+	            do_rotate_brush_task_cb_ex,
+	            &settings);
 }
 
 static void do_layer_brush_task_cb_ex(
-        void *userdata, void *UNUSED(userdata_chunk), const int n, const int thread_id)
+        void *userdata, const int n, const ParallelRangeTLS *tls)
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -2589,7 +2668,7 @@ static void do_layer_brush_task_cb_ex(
 		if (sculpt_brush_test_sq_fn(&test, orig_data.co)) {
 			const float fade = bstrength * tex_strength(
 			        ss, brush, vd.co, sqrtf(test.dist),
-			        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, thread_id);
+			        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, tls->thread_id);
 			float *disp = &layer_disp[vd.i];
 			float val[3];
 
@@ -2634,15 +2713,20 @@ static void do_layer_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode
 	};
 	BLI_mutex_init(&data.mutex);
 
-	BLI_task_parallel_range_ex(
-	            0, totnode, &data, NULL, 0, do_layer_brush_task_cb_ex,
-	            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
+	BLI_task_parallel_range(
+	            0, totnode,
+	            &data,
+	            do_layer_brush_task_cb_ex,
+	            &settings);
 
 	BLI_mutex_end(&data.mutex);
 }
 
 static void do_inflate_brush_task_cb_ex(
-        void *userdata, void *UNUSED(userdata_chunk), const int n, const int thread_id)
+        void *userdata, const int n, const ParallelRangeTLS *tls)
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -2663,7 +2747,7 @@ static void do_inflate_brush_task_cb_ex(
 		if (sculpt_brush_test_sq_fn(&test, vd.co)) {
 			const float fade = bstrength * tex_strength(
 			        ss, brush, vd.co, sqrtf(test.dist),
-			        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, thread_id);
+			        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, tls->thread_id);
 			float val[3];
 
 			if (vd.fno)
@@ -2689,9 +2773,14 @@ static void do_inflate_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totno
 	    .sd = sd, .ob = ob, .brush = brush, .nodes = nodes,
 	};
 
-	BLI_task_parallel_range_ex(
-	            0, totnode, &data, NULL, 0, do_inflate_brush_task_cb_ex,
-	            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
+	BLI_task_parallel_range(
+	            0, totnode,
+	            &data,
+	            do_inflate_brush_task_cb_ex,
+	            &settings);
 }
 
 static void calc_sculpt_plane(
@@ -2806,7 +2895,7 @@ static float get_offset(Sculpt *sd, SculptSession *ss)
 }
 
 static void do_flatten_brush_task_cb_ex(
-        void *userdata, void *UNUSED(userdata_chunk), const int n, const int thread_id)
+        void *userdata, const int n, const ParallelRangeTLS *tls)
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -2839,7 +2928,7 @@ static void do_flatten_brush_task_cb_ex(
 			if (plane_trim(ss->cache, brush, val)) {
 				const float fade = bstrength * tex_strength(
 				        ss, brush, vd.co, sqrtf(test.dist),
-				        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, thread_id);
+				        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, tls->thread_id);
 
 				mul_v3_v3fl(proxy[vd.i], val, fade);
 
@@ -2878,13 +2967,18 @@ static void do_flatten_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totno
 	    .area_no = area_no, .area_co = area_co,
 	};
 
-	BLI_task_parallel_range_ex(
-	            0, totnode, &data, NULL, 0, do_flatten_brush_task_cb_ex,
-	            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
+	BLI_task_parallel_range(
+	            0, totnode,
+	            &data,
+	            do_flatten_brush_task_cb_ex,
+	            &settings);
 }
 
 static void do_clay_brush_task_cb_ex(
-        void *userdata, void *UNUSED(userdata_chunk), const int n, const int thread_id)
+        void *userdata, const int n, const ParallelRangeTLS *tls)
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -2921,7 +3015,7 @@ static void do_clay_brush_task_cb_ex(
 					 * causes glitch with planes, see: T44390 */
 					const float fade = bstrength * tex_strength(
 					        ss, brush, vd.co, sqrtf(test.dist),
-					        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, thread_id);
+					        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, tls->thread_id);
 
 					mul_v3_v3fl(proxy[vd.i], val, fade);
 
@@ -2964,13 +3058,18 @@ static void do_clay_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
 	    .area_no = area_no, .area_co = area_co,
 	};
 
-	BLI_task_parallel_range_ex(
-	            0, totnode, &data, NULL, 0, do_clay_brush_task_cb_ex,
-	            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
+	BLI_task_parallel_range(
+	            0, totnode,
+	            &data,
+	            do_clay_brush_task_cb_ex,
+	            &settings);
 }
 
 static void do_clay_strips_brush_task_cb_ex(
-        void *userdata, void *UNUSED(userdata_chunk), const int n, const int thread_id)
+        void *userdata, const int n, const ParallelRangeTLS *tls)
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -3006,7 +3105,7 @@ static void do_clay_strips_brush_task_cb_ex(
 					 * causes glitch with planes, see: T44390 */
 					const float fade = bstrength * tex_strength(
 					        ss, brush, vd.co, ss->cache->radius * test.dist,
-					        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, thread_id);
+					        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, tls->thread_id);
 
 					mul_v3_v3fl(proxy[vd.i], val, fade);
 
@@ -3074,13 +3173,18 @@ static void do_clay_strips_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int t
 	    .area_no_sp = area_no_sp, .area_co = area_co, .mat = mat,
 	};
 
-	BLI_task_parallel_range_ex(
-	            0, totnode, &data, NULL, 0, do_clay_strips_brush_task_cb_ex,
-	            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
+	BLI_task_parallel_range(
+	            0, totnode,
+	            &data,
+	            do_clay_strips_brush_task_cb_ex,
+	            &settings);
 }
 
 static void do_fill_brush_task_cb_ex(
-        void *userdata, void *UNUSED(userdata_chunk), const int n, const int thread_id)
+        void *userdata, const int n, const ParallelRangeTLS *tls)
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -3114,7 +3218,7 @@ static void do_fill_brush_task_cb_ex(
 				if (plane_trim(ss->cache, brush, val)) {
 					const float fade = bstrength * tex_strength(
 					        ss, brush, vd.co, sqrtf(test.dist),
-					        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, thread_id);
+					        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, tls->thread_id);
 
 					mul_v3_v3fl(proxy[vd.i], val, fade);
 
@@ -3155,13 +3259,18 @@ static void do_fill_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
 	    .area_no = area_no, .area_co = area_co,
 	};
 
-	BLI_task_parallel_range_ex(
-	            0, totnode, &data, NULL, 0, do_fill_brush_task_cb_ex,
-	            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
+	BLI_task_parallel_range(
+	            0, totnode,
+	            &data,
+	            do_fill_brush_task_cb_ex,
+	            &settings);
 }
 
 static void do_scrape_brush_task_cb_ex(
-        void *userdata, void *UNUSED(userdata_chunk), const int n, const int thread_id)
+        void *userdata, const int n, const ParallelRangeTLS *tls)
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -3194,7 +3303,7 @@ static void do_scrape_brush_task_cb_ex(
 				if (plane_trim(ss->cache, brush, val)) {
 					const float fade = bstrength * tex_strength(
 					        ss, brush, vd.co, sqrtf(test.dist),
-					        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, thread_id);
+					        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, tls->thread_id);
 
 					mul_v3_v3fl(proxy[vd.i], val, fade);
 
@@ -3235,13 +3344,18 @@ static void do_scrape_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnod
 	    .area_no = area_no, .area_co = area_co,
 	};
 
-	BLI_task_parallel_range_ex(
-	            0, totnode, &data, NULL, 0, do_scrape_brush_task_cb_ex,
-	            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
+	BLI_task_parallel_range(
+	            0, totnode,
+	            &data,
+	            do_scrape_brush_task_cb_ex,
+	            &settings);
 }
 
 static void do_gravity_task_cb_ex(
-        void *userdata, void *UNUSED(userdata_chunk), const int n, const int thread_id)
+        void *userdata, const int n, const ParallelRangeTLS *tls)
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -3261,7 +3375,7 @@ static void do_gravity_task_cb_ex(
 		if (sculpt_brush_test_sq_fn(&test, vd.co)) {
 			const float fade = tex_strength(
 			        ss, brush, vd.co, sqrtf(test.dist),
-			        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, thread_id);
+			        vd.no, vd.fno, vd.mask ? *vd.mask : 0.0f, tls->thread_id);
 
 			mul_v3_v3fl(proxy[vd.i], offset, fade);
 
@@ -3292,9 +3406,14 @@ static void do_gravity(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode, fl
 	    .offset = offset,
 	};
 
-	BLI_task_parallel_range_ex(
-	            0, totnode, &data, NULL, 0, do_gravity_task_cb_ex,
-	            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
+	BLI_task_parallel_range(
+	            0, totnode,
+	            &data,
+	            do_gravity_task_cb_ex,
+	            &settings);
 }
 
 
@@ -3396,7 +3515,8 @@ static void sculpt_topology_update(Sculpt *sd, Object *ob, Brush *brush, Unified
 	}
 }
 
-static void do_brush_action_task_cb(void *userdata, const int n)
+static void do_brush_action_task_cb(void *userdata, const int n,
+                                    const ParallelRangeTLS *UNUSED(tls))
 {
 	SculptThreadedTaskData *data = userdata;
 
@@ -3423,9 +3543,14 @@ static void do_brush_action(Sculpt *sd, Object *ob, Brush *brush, UnifiedPaintSe
 			.sd = sd, .ob = ob, .brush = brush, .nodes = nodes,
 		};
 
+		ParallelRangeSettings settings;
+		BLI_parallel_range_settings_defaults(&settings);
+		settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
 		BLI_task_parallel_range(
-		            0, totnode, &task_data, do_brush_action_task_cb,
-		            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT));
+		            0, totnode,
+		            &task_data,
+		            do_brush_action_task_cb,
+		            &settings);
 
 		if (sculpt_brush_needs_normal(brush, ss->cache->normal_weight))
 			update_sculpt_normal(sd, ob, nodes, totnode);
@@ -3537,7 +3662,8 @@ static void sculpt_flush_pbvhvert_deform(Object *ob, PBVHVertexIter *vd)
 		copy_v3_v3(me->mvert[index].co, newco);
 }
 
-static void sculpt_combine_proxies_task_cb(void *userdata, const int n)
+static void sculpt_combine_proxies_task_cb(void *userdata, const int n,
+                                           const ParallelRangeTLS *UNUSED(tls))
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -3604,9 +3730,14 @@ static void sculpt_combine_proxies(Sculpt *sd, Object *ob)
 			.sd = sd, .ob = ob, .brush = brush, .nodes = nodes,
 		};
 
+		ParallelRangeSettings settings;
+		BLI_parallel_range_settings_defaults(&settings);
+		settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
 		BLI_task_parallel_range(
-		            0, totnode, &data, sculpt_combine_proxies_task_cb,
-		            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT));
+		            0, totnode,
+		            &data,
+		            sculpt_combine_proxies_task_cb,
+		            &settings);
 	}
 
 	if (nodes)
@@ -3632,7 +3763,8 @@ static void sculpt_update_keyblock(Object *ob)
 	}
 }
 
-static void sculpt_flush_stroke_deform_task_cb(void *userdata, const int n)
+static void sculpt_flush_stroke_deform_task_cb(void *userdata, const int n,
+                                               const ParallelRangeTLS *UNUSED(tls))
 {
 	SculptThreadedTaskData *data = userdata;
 	SculptSession *ss = data->ob->sculpt;
@@ -3685,9 +3817,14 @@ static void sculpt_flush_stroke_deform(Sculpt *sd, Object *ob)
 			.vertCos = vertCos,
 		};
 
+		ParallelRangeSettings settings;
+		BLI_parallel_range_settings_defaults(&settings);
+		settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
 		BLI_task_parallel_range(
-		            0, totnode, &data, sculpt_flush_stroke_deform_task_cb,
-		            ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT));
+		            0, totnode,
+		            &data,
+		            sculpt_flush_stroke_deform_task_cb,
+		            &settings);
 
 		if (vertCos) {
 			sculpt_vertcos_to_key(ob, ss->kb, vertCos);