2855e3181c066412c1f8a513dea76d2c14a2b490
[blender.git] / source / blender / editors / sculpt_paint / sculpt.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software  Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2006 by Nicholas Bishop
17  * All rights reserved.
18  * Implements the Sculpt Mode tools
19  */
20
21 /** \file
22  * \ingroup edsculpt
23  */
24
25 #include "MEM_guardedalloc.h"
26
27 #include "BLI_math.h"
28 #include "BLI_blenlib.h"
29 #include "BLI_dial_2d.h"
30 #include "BLI_task.h"
31 #include "BLI_utildefines.h"
32 #include "BLI_ghash.h"
33
34 #include "BLT_translation.h"
35
36 #include "DNA_customdata_types.h"
37 #include "DNA_mesh_types.h"
38 #include "DNA_meshdata_types.h"
39 #include "DNA_node_types.h"
40 #include "DNA_object_types.h"
41 #include "DNA_scene_types.h"
42 #include "DNA_brush_types.h"
43
44 #include "BKE_brush.h"
45 #include "BKE_ccg.h"
46 #include "BKE_colortools.h"
47 #include "BKE_context.h"
48 #include "BKE_image.h"
49 #include "BKE_key.h"
50 #include "BKE_library.h"
51 #include "BKE_main.h"
52 #include "BKE_mesh.h"
53 #include "BKE_mesh_mapping.h"
54 #include "BKE_modifier.h"
55 #include "BKE_multires.h"
56 #include "BKE_node.h"
57 #include "BKE_object.h"
58 #include "BKE_paint.h"
59 #include "BKE_particle.h"
60 #include "BKE_pbvh.h"
61 #include "BKE_pointcache.h"
62 #include "BKE_report.h"
63 #include "BKE_scene.h"
64 #include "BKE_screen.h"
65 #include "BKE_subsurf.h"
66
67 #include "DEG_depsgraph.h"
68 #include "DEG_depsgraph_query.h"
69
70 #include "WM_api.h"
71 #include "WM_types.h"
72 #include "WM_message.h"
73 #include "WM_toolsystem.h"
74
75 #include "ED_sculpt.h"
76 #include "ED_object.h"
77 #include "ED_screen.h"
78 #include "ED_view3d.h"
79 #include "paint_intern.h"
80 #include "sculpt_intern.h"
81
82 #include "RNA_access.h"
83 #include "RNA_define.h"
84
85 #include "UI_interface.h"
86 #include "UI_resources.h"
87
88 #include "bmesh.h"
89 #include "bmesh_tools.h"
90
91 #include <math.h>
92 #include <stdlib.h>
93 #include <string.h>
94
95 /** \name Tool Capabilities
96  *
97  * Avoid duplicate checks, internal logic only,
98  * share logic with #rna_def_sculpt_capabilities where possible.
99  *
100  * \{ */
101
102 /* Check if there are any active modifiers in stack
103  * (used for flushing updates at enter/exit sculpt mode) */
104 static bool sculpt_has_active_modifiers(Scene *scene, Object *ob)
105 {
106   ModifierData *md;
107   VirtualModifierData virtualModifierData;
108
109   md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
110
111   /* exception for shape keys because we can edit those */
112   for (; md; md = md->next) {
113     if (modifier_isEnabled(scene, md, eModifierMode_Realtime)) {
114       return 1;
115     }
116   }
117
118   return 0;
119 }
120
121 static bool sculpt_tool_needs_original(const char sculpt_tool)
122 {
123   return ELEM(
124       sculpt_tool, SCULPT_TOOL_GRAB, SCULPT_TOOL_ROTATE, SCULPT_TOOL_THUMB, SCULPT_TOOL_LAYER);
125 }
126
127 static bool sculpt_tool_is_proxy_used(const char sculpt_tool)
128 {
129   return ELEM(sculpt_tool, SCULPT_TOOL_SMOOTH, SCULPT_TOOL_LAYER);
130 }
131
132 static bool sculpt_brush_use_topology_rake(const SculptSession *ss, const Brush *brush)
133 {
134   return SCULPT_TOOL_HAS_TOPOLOGY_RAKE(brush->sculpt_tool) &&
135          (brush->topology_rake_factor > 0.0f) && (ss->bm != NULL);
136 }
137
138 /**
139  * Test whether the #StrokeCache.sculpt_normal needs update in #do_brush_action
140  */
141 static int sculpt_brush_needs_normal(const SculptSession *ss, const Brush *brush)
142 {
143   return ((SCULPT_TOOL_HAS_NORMAL_WEIGHT(brush->sculpt_tool) &&
144            (ss->cache->normal_weight > 0.0f)) ||
145
146           ELEM(brush->sculpt_tool,
147                SCULPT_TOOL_BLOB,
148                SCULPT_TOOL_CREASE,
149                SCULPT_TOOL_DRAW,
150                SCULPT_TOOL_LAYER,
151                SCULPT_TOOL_NUDGE,
152                SCULPT_TOOL_ROTATE,
153                SCULPT_TOOL_THUMB) ||
154
155           (brush->mtex.brush_map_mode == MTEX_MAP_MODE_AREA)) ||
156          sculpt_brush_use_topology_rake(ss, brush);
157 }
158 /** \} */
159
160 static bool sculpt_brush_needs_rake_rotation(const Brush *brush)
161 {
162   return SCULPT_TOOL_HAS_RAKE(brush->sculpt_tool) && (brush->rake_factor != 0.0f);
163 }
164
165 typedef enum StrokeFlags {
166   CLIP_X = 1,
167   CLIP_Y = 2,
168   CLIP_Z = 4,
169 } StrokeFlags;
170
171 /************** Access to original unmodified vertex data *************/
172
173 typedef struct {
174   BMLog *bm_log;
175
176   SculptUndoNode *unode;
177   float (*coords)[3];
178   short (*normals)[3];
179   const float *vmasks;
180
181   /* Original coordinate, normal, and mask */
182   const float *co;
183   const short *no;
184   float mask;
185 } SculptOrigVertData;
186
187 /* Initialize a SculptOrigVertData for accessing original vertex data;
188  * handles BMesh, mesh, and multires */
189 static void sculpt_orig_vert_data_unode_init(SculptOrigVertData *data,
190                                              Object *ob,
191                                              SculptUndoNode *unode)
192 {
193   SculptSession *ss = ob->sculpt;
194   BMesh *bm = ss->bm;
195
196   memset(data, 0, sizeof(*data));
197   data->unode = unode;
198
199   if (bm) {
200     data->bm_log = ss->bm_log;
201   }
202   else {
203     data->coords = data->unode->co;
204     data->normals = data->unode->no;
205     data->vmasks = data->unode->mask;
206   }
207 }
208
209 /* Initialize a SculptOrigVertData for accessing original vertex data;
210  * handles BMesh, mesh, and multires */
211 static void sculpt_orig_vert_data_init(SculptOrigVertData *data, Object *ob, PBVHNode *node)
212 {
213   SculptUndoNode *unode;
214   unode = sculpt_undo_push_node(ob, node, SCULPT_UNDO_COORDS);
215   sculpt_orig_vert_data_unode_init(data, ob, unode);
216 }
217
218 /* Update a SculptOrigVertData for a particular vertex from the PBVH
219  * iterator */
220 static void sculpt_orig_vert_data_update(SculptOrigVertData *orig_data, PBVHVertexIter *iter)
221 {
222   if (orig_data->unode->type == SCULPT_UNDO_COORDS) {
223     if (orig_data->bm_log) {
224       BM_log_original_vert_data(orig_data->bm_log, iter->bm_vert, &orig_data->co, &orig_data->no);
225     }
226     else {
227       orig_data->co = orig_data->coords[iter->i];
228       orig_data->no = orig_data->normals[iter->i];
229     }
230   }
231   else if (orig_data->unode->type == SCULPT_UNDO_MASK) {
232     if (orig_data->bm_log) {
233       orig_data->mask = BM_log_original_mask(orig_data->bm_log, iter->bm_vert);
234     }
235     else {
236       orig_data->mask = orig_data->vmasks[iter->i];
237     }
238   }
239 }
240
241 static void sculpt_rake_data_update(struct SculptRakeData *srd, const float co[3])
242 {
243   float rake_dist = len_v3v3(srd->follow_co, co);
244   if (rake_dist > srd->follow_dist) {
245     interp_v3_v3v3(srd->follow_co, srd->follow_co, co, rake_dist - srd->follow_dist);
246   }
247 }
248
249 static void sculpt_rake_rotate(const SculptSession *ss,
250                                const float sculpt_co[3],
251                                const float v_co[3],
252                                float factor,
253                                float r_delta[3])
254 {
255   float vec_rot[3];
256
257 #if 0
258   /* lerp */
259   sub_v3_v3v3(vec_rot, v_co, sculpt_co);
260   mul_qt_v3(ss->cache->rake_rotation_symmetry, vec_rot);
261   add_v3_v3(vec_rot, sculpt_co);
262   sub_v3_v3v3(r_delta, vec_rot, v_co);
263   mul_v3_fl(r_delta, factor);
264 #else
265   /* slerp */
266   float q_interp[4];
267   sub_v3_v3v3(vec_rot, v_co, sculpt_co);
268
269   copy_qt_qt(q_interp, ss->cache->rake_rotation_symmetry);
270   pow_qt_fl_normalized(q_interp, factor);
271   mul_qt_v3(q_interp, vec_rot);
272
273   add_v3_v3(vec_rot, sculpt_co);
274   sub_v3_v3v3(r_delta, vec_rot, v_co);
275 #endif
276 }
277
278 /**
279  * Align the grab delta to the brush normal.
280  *
281  * \param grab_delta: Typically from `ss->cache->grab_delta_symmetry`.
282  */
283 static void sculpt_project_v3_normal_align(SculptSession *ss,
284                                            const float normal_weight,
285                                            float grab_delta[3])
286 {
287   /* signed to support grabbing in (to make a hole) as well as out. */
288   const float len_signed = dot_v3v3(ss->cache->sculpt_normal_symm, grab_delta);
289
290   /* this scale effectively projects the offset so dragging follows the cursor,
291    * as the normal points towards the view, the scale increases. */
292   float len_view_scale;
293   {
294     float view_aligned_normal[3];
295     project_plane_v3_v3v3(
296         view_aligned_normal, ss->cache->sculpt_normal_symm, ss->cache->view_normal);
297     len_view_scale = fabsf(dot_v3v3(view_aligned_normal, ss->cache->sculpt_normal_symm));
298     len_view_scale = (len_view_scale > FLT_EPSILON) ? 1.0f / len_view_scale : 1.0f;
299   }
300
301   mul_v3_fl(grab_delta, 1.0f - normal_weight);
302   madd_v3_v3fl(
303       grab_delta, ss->cache->sculpt_normal_symm, (len_signed * normal_weight) * len_view_scale);
304 }
305
306 /** \name SculptProjectVector
307  *
308  * Fast-path for #project_plane_v3_v3v3
309  *
310  * \{ */
311
312 typedef struct SculptProjectVector {
313   float plane[3];
314   float len_sq;
315   float len_sq_inv_neg;
316   bool is_valid;
317
318 } SculptProjectVector;
319
320 /**
321  * \param plane: Direction, can be any length.
322  */
323 static void sculpt_project_v3_cache_init(SculptProjectVector *spvc, const float plane[3])
324 {
325   copy_v3_v3(spvc->plane, plane);
326   spvc->len_sq = len_squared_v3(spvc->plane);
327   spvc->is_valid = (spvc->len_sq > FLT_EPSILON);
328   spvc->len_sq_inv_neg = (spvc->is_valid) ? -1.0f / spvc->len_sq : 0.0f;
329 }
330
331 /**
332  * Calculate the projection.
333  */
334 static void sculpt_project_v3(const SculptProjectVector *spvc, const float vec[3], float r_vec[3])
335 {
336 #if 0
337   project_plane_v3_v3v3(r_vec, vec, spvc->plane);
338 #else
339   /* inline the projection, cache `-1.0 / dot_v3_v3(v_proj, v_proj)` */
340   madd_v3_v3fl(r_vec, spvc->plane, dot_v3v3(vec, spvc->plane) * spvc->len_sq_inv_neg);
341 #endif
342 }
343
344 /** \} */
345
346 /**********************************************************************/
347
348 /* Returns true if the stroke will use dynamic topology, false
349  * otherwise.
350  *
351  * Factors: some brushes like grab cannot do dynamic topology.
352  * Others, like smooth, are better without. Same goes for alt-
353  * key smoothing. */
354 static bool sculpt_stroke_is_dynamic_topology(const SculptSession *ss, const Brush *brush)
355 {
356   return ((BKE_pbvh_type(ss->pbvh) == PBVH_BMESH) &&
357
358           (!ss->cache || (!ss->cache->alt_smooth)) &&
359
360           /* Requires mesh restore, which doesn't work with
361            * dynamic-topology */
362           !(brush->flag & BRUSH_ANCHORED) && !(brush->flag & BRUSH_DRAG_DOT) &&
363
364           SCULPT_TOOL_HAS_DYNTOPO(brush->sculpt_tool));
365 }
366
367 /*** paint mesh ***/
368
369 static void paint_mesh_restore_co_task_cb(void *__restrict userdata,
370                                           const int n,
371                                           const ParallelRangeTLS *__restrict UNUSED(tls))
372 {
373   SculptThreadedTaskData *data = userdata;
374   SculptSession *ss = data->ob->sculpt;
375
376   SculptUndoNode *unode;
377   SculptUndoType type = (data->brush->sculpt_tool == SCULPT_TOOL_MASK ? SCULPT_UNDO_MASK :
378                                                                         SCULPT_UNDO_COORDS);
379
380   if (ss->bm) {
381     unode = sculpt_undo_push_node(data->ob, data->nodes[n], type);
382   }
383   else {
384     unode = sculpt_undo_get_node(data->nodes[n]);
385   }
386
387   if (unode) {
388     PBVHVertexIter vd;
389     SculptOrigVertData orig_data;
390
391     sculpt_orig_vert_data_unode_init(&orig_data, data->ob, unode);
392
393     BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
394     {
395       sculpt_orig_vert_data_update(&orig_data, &vd);
396
397       if (orig_data.unode->type == SCULPT_UNDO_COORDS) {
398         copy_v3_v3(vd.co, orig_data.co);
399         if (vd.no) {
400           copy_v3_v3_short(vd.no, orig_data.no);
401         }
402         else {
403           normal_short_to_float_v3(vd.fno, orig_data.no);
404         }
405       }
406       else if (orig_data.unode->type == SCULPT_UNDO_MASK) {
407         *vd.mask = orig_data.mask;
408       }
409
410       if (vd.mvert) {
411         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
412       }
413     }
414     BKE_pbvh_vertex_iter_end;
415
416     BKE_pbvh_node_mark_update(data->nodes[n]);
417   }
418 }
419
420 static void paint_mesh_restore_co(Sculpt *sd, Object *ob)
421 {
422   SculptSession *ss = ob->sculpt;
423   Brush *brush = BKE_paint_brush(&sd->paint);
424
425   PBVHNode **nodes;
426   int totnode;
427
428   BKE_pbvh_search_gather(ss->pbvh, NULL, NULL, &nodes, &totnode);
429
430   /**
431    * Disable OpenMP when dynamic-topology is enabled. Otherwise, new entries might be inserted by
432    * #sculpt_undo_push_node() into the GHash used internally by #BM_log_original_vert_co()
433    * by a different thread. See T33787. */
434   SculptThreadedTaskData data = {
435       .sd = sd,
436       .ob = ob,
437       .brush = brush,
438       .nodes = nodes,
439   };
440
441   ParallelRangeSettings settings;
442   BLI_parallel_range_settings_defaults(&settings);
443   settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && !ss->bm &&
444                             totnode > SCULPT_THREADED_LIMIT);
445   BLI_task_parallel_range(0, totnode, &data, paint_mesh_restore_co_task_cb, &settings);
446
447   if (nodes) {
448     MEM_freeN(nodes);
449   }
450 }
451
452 /*** BVH Tree ***/
453
454 static void sculpt_extend_redraw_rect_previous(Object *ob, rcti *rect)
455 {
456   /* expand redraw rect with redraw rect from previous step to
457    * prevent partial-redraw issues caused by fast strokes. This is
458    * needed here (not in sculpt_flush_update) as it was before
459    * because redraw rectangle should be the same in both of
460    * optimized PBVH draw function and 3d view redraw (if not -- some
461    * mesh parts could disappear from screen (sergey) */
462   SculptSession *ss = ob->sculpt;
463
464   if (ss->cache) {
465     if (!BLI_rcti_is_empty(&ss->cache->previous_r)) {
466       BLI_rcti_union(rect, &ss->cache->previous_r);
467     }
468   }
469 }
470
471 /* Get a screen-space rectangle of the modified area */
472 bool sculpt_get_redraw_rect(ARegion *ar, RegionView3D *rv3d, Object *ob, rcti *rect)
473 {
474   PBVH *pbvh = ob->sculpt->pbvh;
475   float bb_min[3], bb_max[3];
476
477   if (!pbvh) {
478     return 0;
479   }
480
481   BKE_pbvh_redraw_BB(pbvh, bb_min, bb_max);
482
483   /* convert 3D bounding box to screen space */
484   if (!paint_convert_bb_to_rect(rect, bb_min, bb_max, ar, rv3d, ob)) {
485     return 0;
486   }
487
488   return 1;
489 }
490
491 void ED_sculpt_redraw_planes_get(float planes[4][4], ARegion *ar, Object *ob)
492 {
493   PBVH *pbvh = ob->sculpt->pbvh;
494   /* copy here, original will be used below */
495   rcti rect = ob->sculpt->cache->current_r;
496
497   sculpt_extend_redraw_rect_previous(ob, &rect);
498
499   paint_calc_redraw_planes(planes, ar, ob, &rect);
500
501   /* we will draw this rect, so now we can set it as the previous partial rect.
502    * Note that we don't update with the union of previous/current (rect), only with
503    * the current. Thus we avoid the rectangle needlessly growing to include
504    * all the stroke area */
505   ob->sculpt->cache->previous_r = ob->sculpt->cache->current_r;
506
507   /* clear redraw flag from nodes */
508   if (pbvh) {
509     BKE_pbvh_update(pbvh, PBVH_UpdateRedraw, NULL);
510   }
511 }
512
513 /************************ Brush Testing *******************/
514
515 void sculpt_brush_test_init(SculptSession *ss, SculptBrushTest *test)
516 {
517   RegionView3D *rv3d = ss->cache->vc->rv3d;
518
519   test->radius_squared = ss->cache->radius_squared;
520   copy_v3_v3(test->location, ss->cache->location);
521   test->dist = 0.0f; /* just for initialize */
522
523   /* Only for 2D projection. */
524   zero_v4(test->plane_view);
525   zero_v4(test->plane_tool);
526
527   test->mirror_symmetry_pass = ss->cache->mirror_symmetry_pass;
528
529   if (rv3d->rflag & RV3D_CLIPPING) {
530     test->clip_rv3d = rv3d;
531   }
532   else {
533     test->clip_rv3d = NULL;
534   }
535 }
536
537 BLI_INLINE bool sculpt_brush_test_clipping(const SculptBrushTest *test, const float co[3])
538 {
539   RegionView3D *rv3d = test->clip_rv3d;
540   if (!rv3d) {
541     return false;
542   }
543   float symm_co[3];
544   flip_v3_v3(symm_co, co, test->mirror_symmetry_pass);
545   return ED_view3d_clipping_test(rv3d, symm_co, true);
546 }
547
548 bool sculpt_brush_test_sphere(SculptBrushTest *test, const float co[3])
549 {
550   float distsq = len_squared_v3v3(co, test->location);
551
552   if (distsq <= test->radius_squared) {
553     if (sculpt_brush_test_clipping(test, co)) {
554       return 0;
555     }
556     test->dist = sqrtf(distsq);
557     return 1;
558   }
559   else {
560     return 0;
561   }
562 }
563
564 bool sculpt_brush_test_sphere_sq(SculptBrushTest *test, const float co[3])
565 {
566   float distsq = len_squared_v3v3(co, test->location);
567
568   if (distsq <= test->radius_squared) {
569     if (sculpt_brush_test_clipping(test, co)) {
570       return 0;
571     }
572     test->dist = distsq;
573     return 1;
574   }
575   else {
576     return 0;
577   }
578 }
579
580 bool sculpt_brush_test_sphere_fast(const SculptBrushTest *test, const float co[3])
581 {
582   if (sculpt_brush_test_clipping(test, co)) {
583     return 0;
584   }
585   return len_squared_v3v3(co, test->location) <= test->radius_squared;
586 }
587
588 bool sculpt_brush_test_circle_sq(SculptBrushTest *test, const float co[3])
589 {
590   float co_proj[3];
591   closest_to_plane_normalized_v3(co_proj, test->plane_view, co);
592   float distsq = len_squared_v3v3(co_proj, test->location);
593
594   if (distsq <= test->radius_squared) {
595     if (sculpt_brush_test_clipping(test, co)) {
596       return 0;
597     }
598     test->dist = distsq;
599     return 1;
600   }
601   else {
602     return 0;
603   }
604 }
605
606 bool sculpt_brush_test_cube(SculptBrushTest *test, const float co[3], float local[4][4])
607 {
608   float side = M_SQRT1_2;
609   float local_co[3];
610
611   if (sculpt_brush_test_clipping(test, co)) {
612     return 0;
613   }
614
615   mul_v3_m4v3(local_co, local, co);
616
617   local_co[0] = fabsf(local_co[0]);
618   local_co[1] = fabsf(local_co[1]);
619   local_co[2] = fabsf(local_co[2]);
620
621   if (local_co[0] <= side && local_co[1] <= side && local_co[2] <= side) {
622     float p = 4.0f;
623
624     test->dist = ((powf(local_co[0], p) + powf(local_co[1], p) + powf(local_co[2], p)) /
625                   powf(side, p));
626
627     return 1;
628   }
629   else {
630     return 0;
631   }
632 }
633
634 SculptBrushTestFn sculpt_brush_test_init_with_falloff_shape(SculptSession *ss,
635                                                             SculptBrushTest *test,
636                                                             char falloff_shape)
637 {
638   sculpt_brush_test_init(ss, test);
639   SculptBrushTestFn sculpt_brush_test_sq_fn;
640   if (falloff_shape == PAINT_FALLOFF_SHAPE_SPHERE) {
641     sculpt_brush_test_sq_fn = sculpt_brush_test_sphere_sq;
642   }
643   else {
644     /* PAINT_FALLOFF_SHAPE_TUBE */
645     plane_from_point_normal_v3(test->plane_view, test->location, ss->cache->view_normal);
646     sculpt_brush_test_sq_fn = sculpt_brush_test_circle_sq;
647   }
648   return sculpt_brush_test_sq_fn;
649 }
650
651 const float *sculpt_brush_frontface_normal_from_falloff_shape(SculptSession *ss,
652                                                               char falloff_shape)
653 {
654   if (falloff_shape == PAINT_FALLOFF_SHAPE_SPHERE) {
655     return ss->cache->sculpt_normal_symm;
656   }
657   else {
658     /* PAINT_FALLOFF_SHAPE_TUBE */
659     return ss->cache->view_normal;
660   }
661 }
662
663 static float frontface(const Brush *br,
664                        const float sculpt_normal[3],
665                        const short no[3],
666                        const float fno[3])
667 {
668   if (br->flag & BRUSH_FRONTFACE) {
669     float dot;
670
671     if (no) {
672       float tmp[3];
673
674       normal_short_to_float_v3(tmp, no);
675       dot = dot_v3v3(tmp, sculpt_normal);
676     }
677     else {
678       dot = dot_v3v3(fno, sculpt_normal);
679     }
680     return dot > 0 ? dot : 0;
681   }
682   else {
683     return 1;
684   }
685 }
686
687 #if 0
688
689 static bool sculpt_brush_test_cyl(SculptBrushTest *test,
690                                   float co[3],
691                                   float location[3],
692                                   const float area_no[3])
693 {
694   if (sculpt_brush_test_sphere_fast(test, co)) {
695     float t1[3], t2[3], t3[3], dist;
696
697     sub_v3_v3v3(t1, location, co);
698     sub_v3_v3v3(t2, x2, location);
699
700     cross_v3_v3v3(t3, area_no, t1);
701
702     dist = len_v3(t3) / len_v3(t2);
703
704     test->dist = dist;
705
706     return 1;
707   }
708
709   return 0;
710 }
711
712 #endif
713
714 /* ===== Sculpting =====
715  */
716 static void flip_v3(float v[3], const char symm)
717 {
718   flip_v3_v3(v, v, symm);
719 }
720
721 static float calc_overlap(StrokeCache *cache, const char symm, const char axis, const float angle)
722 {
723   float mirror[3];
724   float distsq;
725
726   /* flip_v3_v3(mirror, cache->traced_location, symm); */
727   flip_v3_v3(mirror, cache->true_location, symm);
728
729   if (axis != 0) {
730     float mat[3][3];
731     axis_angle_to_mat3_single(mat, axis, angle);
732     mul_m3_v3(mat, mirror);
733   }
734
735   /* distsq = len_squared_v3v3(mirror, cache->traced_location); */
736   distsq = len_squared_v3v3(mirror, cache->true_location);
737
738   if (distsq <= 4.0f * (cache->radius_squared)) {
739     return (2.0f * (cache->radius) - sqrtf(distsq)) / (2.0f * (cache->radius));
740   }
741   else {
742     return 0;
743   }
744 }
745
746 static float calc_radial_symmetry_feather(Sculpt *sd,
747                                           StrokeCache *cache,
748                                           const char symm,
749                                           const char axis)
750 {
751   int i;
752   float overlap;
753
754   overlap = 0;
755   for (i = 1; i < sd->radial_symm[axis - 'X']; ++i) {
756     const float angle = 2 * M_PI * i / sd->radial_symm[axis - 'X'];
757     overlap += calc_overlap(cache, symm, axis, angle);
758   }
759
760   return overlap;
761 }
762
763 static float calc_symmetry_feather(Sculpt *sd, StrokeCache *cache)
764 {
765   if (sd->paint.symmetry_flags & PAINT_SYMMETRY_FEATHER) {
766     float overlap;
767     int symm = cache->symmetry;
768     int i;
769
770     overlap = 0;
771     for (i = 0; i <= symm; i++) {
772       if (i == 0 || (symm & i && (symm != 5 || i != 3) && (symm != 6 || (i != 3 && i != 5)))) {
773
774         overlap += calc_overlap(cache, i, 0, 0);
775
776         overlap += calc_radial_symmetry_feather(sd, cache, i, 'X');
777         overlap += calc_radial_symmetry_feather(sd, cache, i, 'Y');
778         overlap += calc_radial_symmetry_feather(sd, cache, i, 'Z');
779       }
780     }
781
782     return 1 / overlap;
783   }
784   else {
785     return 1;
786   }
787 }
788
789 /** \name Calculate Normal and Center
790  *
791  * Calculate geometry surrounding the brush center.
792  * (optionally using original coordinates).
793  *
794  * Functions are:
795  * - #calc_area_center
796  * - #calc_area_normal
797  * - #calc_area_normal_and_center
798  *
799  * \note These are all _very_ similar, when changing one, check others.
800  * \{ */
801
802 static void calc_area_normal_and_center_task_cb(void *__restrict userdata,
803                                                 const int n,
804                                                 const ParallelRangeTLS *__restrict UNUSED(tls))
805 {
806   SculptThreadedTaskData *data = userdata;
807   SculptSession *ss = data->ob->sculpt;
808   float(*area_nos)[3] = data->area_nos;
809   float(*area_cos)[3] = data->area_cos;
810
811   PBVHVertexIter vd;
812   SculptUndoNode *unode = NULL;
813
814   float private_co[2][3] = {{0.0f}};
815   float private_no[2][3] = {{0.0f}};
816   int private_count[2] = {0};
817   bool use_original = false;
818
819   if (ss->cache->original) {
820     unode = sculpt_undo_push_node(data->ob, data->nodes[n], SCULPT_UNDO_COORDS);
821     use_original = (unode->co || unode->bm_entry);
822   }
823
824   SculptBrushTest test;
825   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
826       ss, &test, data->brush->falloff_shape);
827
828   /* when the mesh is edited we can't rely on original coords
829    * (original mesh may not even have verts in brush radius) */
830   if (use_original && data->has_bm_orco) {
831     float(*orco_coords)[3];
832     int(*orco_tris)[3];
833     int orco_tris_num;
834     int i;
835
836     BKE_pbvh_node_get_bm_orco_data(data->nodes[n], &orco_tris, &orco_tris_num, &orco_coords);
837
838     for (i = 0; i < orco_tris_num; i++) {
839       const float *co_tri[3] = {
840           orco_coords[orco_tris[i][0]],
841           orco_coords[orco_tris[i][1]],
842           orco_coords[orco_tris[i][2]],
843       };
844       float co[3];
845
846       closest_on_tri_to_point_v3(co, test.location, UNPACK3(co_tri));
847
848       if (sculpt_brush_test_sq_fn(&test, co)) {
849         float no[3];
850         int flip_index;
851
852         normal_tri_v3(no, UNPACK3(co_tri));
853
854         flip_index = (dot_v3v3(ss->cache->view_normal, no) <= 0.0f);
855         if (area_cos) {
856           add_v3_v3(private_co[flip_index], co);
857         }
858         if (area_nos) {
859           add_v3_v3(private_no[flip_index], no);
860         }
861         private_count[flip_index] += 1;
862       }
863     }
864   }
865   else {
866     BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
867     {
868       const float *co;
869       const short *no_s; /* bm_vert only */
870
871       if (use_original) {
872         if (unode->bm_entry) {
873           BM_log_original_vert_data(ss->bm_log, vd.bm_vert, &co, &no_s);
874         }
875         else {
876           co = unode->co[vd.i];
877           no_s = unode->no[vd.i];
878         }
879       }
880       else {
881         co = vd.co;
882       }
883
884       if (sculpt_brush_test_sq_fn(&test, co)) {
885         float no_buf[3];
886         const float *no;
887         int flip_index;
888
889         if (use_original) {
890           normal_short_to_float_v3(no_buf, no_s);
891           no = no_buf;
892         }
893         else {
894           if (vd.no) {
895             normal_short_to_float_v3(no_buf, vd.no);
896             no = no_buf;
897           }
898           else {
899             no = vd.fno;
900           }
901         }
902
903         flip_index = (dot_v3v3(ss->cache->view_normal, no) <= 0.0f);
904         if (area_cos) {
905           add_v3_v3(private_co[flip_index], co);
906         }
907         if (area_nos) {
908           add_v3_v3(private_no[flip_index], no);
909         }
910         private_count[flip_index] += 1;
911       }
912     }
913     BKE_pbvh_vertex_iter_end;
914   }
915
916   BLI_mutex_lock(&data->mutex);
917
918   /* for flatten center */
919   if (area_cos) {
920     add_v3_v3(area_cos[0], private_co[0]);
921     add_v3_v3(area_cos[1], private_co[1]);
922   }
923
924   /* for area normal */
925   if (area_nos) {
926     add_v3_v3(area_nos[0], private_no[0]);
927     add_v3_v3(area_nos[1], private_no[1]);
928   }
929
930   /* weights */
931   data->count[0] += private_count[0];
932   data->count[1] += private_count[1];
933
934   BLI_mutex_unlock(&data->mutex);
935 }
936
937 static void calc_area_center(
938     Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode, float r_area_co[3])
939 {
940   const Brush *brush = BKE_paint_brush(&sd->paint);
941   SculptSession *ss = ob->sculpt;
942   const bool has_bm_orco = ss->bm && sculpt_stroke_is_dynamic_topology(ss, brush);
943   int n;
944
945   /* 0=towards view, 1=flipped */
946   float area_cos[2][3] = {{0.0f}};
947
948   int count[2] = {0};
949
950   /* Intentionally set 'sd' to NULL since we share logic with vertex paint. */
951   SculptThreadedTaskData data = {
952       .sd = NULL,
953       .ob = ob,
954       .brush = brush,
955       .nodes = nodes,
956       .totnode = totnode,
957       .has_bm_orco = has_bm_orco,
958       .area_cos = area_cos,
959       .area_nos = NULL,
960       .count = count,
961   };
962   BLI_mutex_init(&data.mutex);
963
964   ParallelRangeSettings settings;
965   BLI_parallel_range_settings_defaults(&settings);
966   settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
967   BLI_task_parallel_range(0, totnode, &data, calc_area_normal_and_center_task_cb, &settings);
968
969   BLI_mutex_end(&data.mutex);
970
971   /* for flatten center */
972   for (n = 0; n < ARRAY_SIZE(area_cos); n++) {
973     if (count[n] != 0) {
974       mul_v3_v3fl(r_area_co, area_cos[n], 1.0f / count[n]);
975       break;
976     }
977   }
978   if (n == 2) {
979     zero_v3(r_area_co);
980   }
981 }
982
983 static void calc_area_normal(
984     Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode, float r_area_no[3])
985 {
986   const Brush *brush = BKE_paint_brush(&sd->paint);
987   bool use_threading = (sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT;
988   sculpt_pbvh_calc_area_normal(brush, ob, nodes, totnode, use_threading, r_area_no);
989 }
990
991 /* expose 'calc_area_normal' externally. */
992 void sculpt_pbvh_calc_area_normal(const Brush *brush,
993                                   Object *ob,
994                                   PBVHNode **nodes,
995                                   int totnode,
996                                   bool use_threading,
997                                   float r_area_no[3])
998 {
999   SculptSession *ss = ob->sculpt;
1000   const bool has_bm_orco = ss->bm && sculpt_stroke_is_dynamic_topology(ss, brush);
1001
1002   /* 0=towards view, 1=flipped */
1003   float area_nos[2][3] = {{0.0f}};
1004
1005   int count[2] = {0};
1006
1007   /* Intentionally set 'sd' to NULL since this is used for vertex paint too. */
1008   SculptThreadedTaskData data = {
1009       .sd = NULL,
1010       .ob = ob,
1011       .brush = brush,
1012       .nodes = nodes,
1013       .totnode = totnode,
1014       .has_bm_orco = has_bm_orco,
1015       .area_cos = NULL,
1016       .area_nos = area_nos,
1017       .count = count,
1018   };
1019   BLI_mutex_init(&data.mutex);
1020
1021   ParallelRangeSettings settings;
1022   BLI_parallel_range_settings_defaults(&settings);
1023   settings.use_threading = use_threading;
1024   BLI_task_parallel_range(0, totnode, &data, calc_area_normal_and_center_task_cb, &settings);
1025
1026   BLI_mutex_end(&data.mutex);
1027
1028   /* for area normal */
1029   for (int i = 0; i < ARRAY_SIZE(area_nos); i++) {
1030     if (normalize_v3_v3(r_area_no, area_nos[i]) != 0.0f) {
1031       break;
1032     }
1033   }
1034 }
1035
1036 /* this calculates flatten center and area normal together,
1037  * amortizing the memory bandwidth and loop overhead to calculate both at the same time */
1038 static void calc_area_normal_and_center(
1039     Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode, float r_area_no[3], float r_area_co[3])
1040 {
1041   const Brush *brush = BKE_paint_brush(&sd->paint);
1042   SculptSession *ss = ob->sculpt;
1043   const bool has_bm_orco = ss->bm && sculpt_stroke_is_dynamic_topology(ss, brush);
1044   int n;
1045
1046   /* 0=towards view, 1=flipped */
1047   float area_cos[2][3] = {{0.0f}};
1048   float area_nos[2][3] = {{0.0f}};
1049
1050   int count[2] = {0};
1051
1052   /* Intentionally set 'sd' to NULL since this is used for vertex paint too. */
1053   SculptThreadedTaskData data = {
1054       .sd = NULL,
1055       .ob = ob,
1056       .brush = brush,
1057       .nodes = nodes,
1058       .totnode = totnode,
1059       .has_bm_orco = has_bm_orco,
1060       .area_cos = area_cos,
1061       .area_nos = area_nos,
1062       .count = count,
1063   };
1064   BLI_mutex_init(&data.mutex);
1065
1066   ParallelRangeSettings settings;
1067   BLI_parallel_range_settings_defaults(&settings);
1068   settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
1069   BLI_task_parallel_range(0, totnode, &data, calc_area_normal_and_center_task_cb, &settings);
1070
1071   BLI_mutex_end(&data.mutex);
1072
1073   /* for flatten center */
1074   for (n = 0; n < ARRAY_SIZE(area_cos); n++) {
1075     if (count[n] != 0) {
1076       mul_v3_v3fl(r_area_co, area_cos[n], 1.0f / count[n]);
1077       break;
1078     }
1079   }
1080   if (n == 2) {
1081     zero_v3(r_area_co);
1082   }
1083
1084   /* for area normal */
1085   for (n = 0; n < ARRAY_SIZE(area_nos); n++) {
1086     if (normalize_v3_v3(r_area_no, area_nos[n]) != 0.0f) {
1087       break;
1088     }
1089   }
1090 }
1091
1092 /** \} */
1093
1094 /* Return modified brush strength. Includes the direction of the brush, positive
1095  * values pull vertices, negative values push. Uses tablet pressure and a
1096  * special multiplier found experimentally to scale the strength factor. */
1097 static float brush_strength(const Sculpt *sd,
1098                             const StrokeCache *cache,
1099                             const float feather,
1100                             const UnifiedPaintSettings *ups)
1101 {
1102   const Scene *scene = cache->vc->scene;
1103   const Brush *brush = BKE_paint_brush((Paint *)&sd->paint);
1104
1105   /* Primary strength input; square it to make lower values more sensitive */
1106   const float root_alpha = BKE_brush_alpha_get(scene, brush);
1107   float alpha = root_alpha * root_alpha;
1108   float dir = (brush->flag & BRUSH_DIR_IN) ? -1 : 1;
1109   float pressure = BKE_brush_use_alpha_pressure(scene, brush) ? cache->pressure : 1;
1110   float pen_flip = cache->pen_flip ? -1 : 1;
1111   float invert = cache->invert ? -1 : 1;
1112   float overlap = ups->overlap_factor;
1113   /* spacing is integer percentage of radius, divide by 50 to get
1114    * normalized diameter */
1115
1116   float flip = dir * invert * pen_flip;
1117
1118   switch (brush->sculpt_tool) {
1119     case SCULPT_TOOL_CLAY:
1120     case SCULPT_TOOL_CLAY_STRIPS:
1121     case SCULPT_TOOL_DRAW:
1122     case SCULPT_TOOL_LAYER:
1123       return alpha * flip * pressure * overlap * feather;
1124
1125     case SCULPT_TOOL_MASK:
1126       overlap = (1 + overlap) / 2;
1127       switch ((BrushMaskTool)brush->mask_tool) {
1128         case BRUSH_MASK_DRAW:
1129           return alpha * flip * pressure * overlap * feather;
1130         case BRUSH_MASK_SMOOTH:
1131           return alpha * pressure * feather;
1132       }
1133       BLI_assert(!"Not supposed to happen");
1134       return 0.0f;
1135
1136     case SCULPT_TOOL_CREASE:
1137     case SCULPT_TOOL_BLOB:
1138       return alpha * flip * pressure * overlap * feather;
1139
1140     case SCULPT_TOOL_INFLATE:
1141       if (flip > 0) {
1142         return 0.250f * alpha * flip * pressure * overlap * feather;
1143       }
1144       else {
1145         return 0.125f * alpha * flip * pressure * overlap * feather;
1146       }
1147
1148     case SCULPT_TOOL_FILL:
1149     case SCULPT_TOOL_SCRAPE:
1150     case SCULPT_TOOL_FLATTEN:
1151       if (flip > 0) {
1152         overlap = (1 + overlap) / 2;
1153         return alpha * flip * pressure * overlap * feather;
1154       }
1155       else {
1156         /* reduce strength for DEEPEN, PEAKS, and CONTRAST */
1157         return 0.5f * alpha * flip * pressure * overlap * feather;
1158       }
1159
1160     case SCULPT_TOOL_SMOOTH:
1161       return alpha * pressure * feather;
1162
1163     case SCULPT_TOOL_PINCH:
1164       if (flip > 0) {
1165         return alpha * flip * pressure * overlap * feather;
1166       }
1167       else {
1168         return 0.25f * alpha * flip * pressure * overlap * feather;
1169       }
1170
1171     case SCULPT_TOOL_NUDGE:
1172       overlap = (1 + overlap) / 2;
1173       return alpha * pressure * overlap * feather;
1174
1175     case SCULPT_TOOL_THUMB:
1176       return alpha * pressure * feather;
1177
1178     case SCULPT_TOOL_SNAKE_HOOK:
1179       return root_alpha * feather;
1180
1181     case SCULPT_TOOL_GRAB:
1182       return root_alpha * feather;
1183
1184     case SCULPT_TOOL_ROTATE:
1185       return alpha * pressure * feather;
1186
1187     default:
1188       return 0;
1189   }
1190 }
1191
1192 /* Return a multiplier for brush strength on a particular vertex. */
1193 float tex_strength(SculptSession *ss,
1194                    const Brush *br,
1195                    const float brush_point[3],
1196                    const float len,
1197                    const short vno[3],
1198                    const float fno[3],
1199                    const float mask,
1200                    const int thread_id)
1201 {
1202   StrokeCache *cache = ss->cache;
1203   const Scene *scene = cache->vc->scene;
1204   const MTex *mtex = &br->mtex;
1205   float avg = 1;
1206   float rgba[4];
1207   float point[3];
1208
1209   sub_v3_v3v3(point, brush_point, cache->plane_offset);
1210
1211   if (!mtex->tex) {
1212     avg = 1;
1213   }
1214   else if (mtex->brush_map_mode == MTEX_MAP_MODE_3D) {
1215     /* Get strength by feeding the vertex
1216      * location directly into a texture */
1217     avg = BKE_brush_sample_tex_3d(scene, br, point, rgba, 0, ss->tex_pool);
1218   }
1219   else if (ss->texcache) {
1220     float symm_point[3], point_2d[2];
1221     float x = 0.0f, y = 0.0f; /* Quite warnings */
1222
1223     /* if the active area is being applied for symmetry, flip it
1224      * across the symmetry axis and rotate it back to the original
1225      * position in order to project it. This insures that the
1226      * brush texture will be oriented correctly. */
1227
1228     flip_v3_v3(symm_point, point, cache->mirror_symmetry_pass);
1229
1230     if (cache->radial_symmetry_pass) {
1231       mul_m4_v3(cache->symm_rot_mat_inv, symm_point);
1232     }
1233
1234     ED_view3d_project_float_v2_m4(cache->vc->ar, symm_point, point_2d, cache->projection_mat);
1235
1236     /* still no symmetry supported for other paint modes.
1237      * Sculpt does it DIY */
1238     if (mtex->brush_map_mode == MTEX_MAP_MODE_AREA) {
1239       /* Similar to fixed mode, but projects from brush angle
1240        * rather than view direction */
1241
1242       mul_m4_v3(cache->brush_local_mat, symm_point);
1243
1244       x = symm_point[0];
1245       y = symm_point[1];
1246
1247       x *= br->mtex.size[0];
1248       y *= br->mtex.size[1];
1249
1250       x += br->mtex.ofs[0];
1251       y += br->mtex.ofs[1];
1252
1253       avg = paint_get_tex_pixel(&br->mtex, x, y, ss->tex_pool, thread_id);
1254
1255       avg += br->texture_sample_bias;
1256     }
1257     else {
1258       const float point_3d[3] = {point_2d[0], point_2d[1], 0.0f};
1259       avg = BKE_brush_sample_tex_3d(scene, br, point_3d, rgba, 0, ss->tex_pool);
1260     }
1261   }
1262
1263   /* Falloff curve */
1264   avg *= BKE_brush_curve_strength(br, len, cache->radius);
1265
1266   avg *= frontface(br, cache->view_normal, vno, fno);
1267
1268   /* Paint mask */
1269   avg *= 1.0f - mask;
1270
1271   return avg;
1272 }
1273
1274 /* Test AABB against sphere */
1275 bool sculpt_search_sphere_cb(PBVHNode *node, void *data_v)
1276 {
1277   SculptSearchSphereData *data = data_v;
1278   float *center = data->ss->cache->location, nearest[3];
1279   float t[3], bb_min[3], bb_max[3];
1280   int i;
1281
1282   if (data->original) {
1283     BKE_pbvh_node_get_original_BB(node, bb_min, bb_max);
1284   }
1285   else {
1286     BKE_pbvh_node_get_BB(node, bb_min, bb_max);
1287   }
1288
1289   for (i = 0; i < 3; ++i) {
1290     if (bb_min[i] > center[i]) {
1291       nearest[i] = bb_min[i];
1292     }
1293     else if (bb_max[i] < center[i]) {
1294       nearest[i] = bb_max[i];
1295     }
1296     else {
1297       nearest[i] = center[i];
1298     }
1299   }
1300
1301   sub_v3_v3v3(t, center, nearest);
1302
1303   return len_squared_v3(t) < data->radius_squared;
1304 }
1305
1306 /* 2D projection (distance to line). */
1307 bool sculpt_search_circle_cb(PBVHNode *node, void *data_v)
1308 {
1309   SculptSearchCircleData *data = data_v;
1310   float bb_min[3], bb_max[3];
1311
1312   if (data->original) {
1313     BKE_pbvh_node_get_original_BB(node, bb_min, bb_max);
1314   }
1315   else {
1316     BKE_pbvh_node_get_BB(node, bb_min, bb_min);
1317   }
1318
1319   float dummy_co[3], dummy_depth;
1320   const float dist_sq = dist_squared_ray_to_aabb_v3(
1321       data->dist_ray_to_aabb_precalc, bb_min, bb_max, dummy_co, &dummy_depth);
1322
1323   return dist_sq < data->radius_squared || 1;
1324 }
1325
1326 /* Handles clipping against a mirror modifier and SCULPT_LOCK axis flags */
1327 static void sculpt_clip(Sculpt *sd, SculptSession *ss, float co[3], const float val[3])
1328 {
1329   int i;
1330
1331   for (i = 0; i < 3; ++i) {
1332     if (sd->flags & (SCULPT_LOCK_X << i)) {
1333       continue;
1334     }
1335
1336     if ((ss->cache->flag & (CLIP_X << i)) && (fabsf(co[i]) <= ss->cache->clip_tolerance[i])) {
1337       co[i] = 0.0f;
1338     }
1339     else {
1340       co[i] = val[i];
1341     }
1342   }
1343 }
1344
1345 static PBVHNode **sculpt_pbvh_gather_generic(Object *ob,
1346                                              Sculpt *sd,
1347                                              const Brush *brush,
1348                                              bool use_original,
1349                                              float radius_scale,
1350                                              int *r_totnode)
1351 {
1352   SculptSession *ss = ob->sculpt;
1353   PBVHNode **nodes = NULL;
1354
1355   /* Build a list of all nodes that are potentially within the brush's area of influence */
1356   if (brush->falloff_shape == PAINT_FALLOFF_SHAPE_SPHERE) {
1357     SculptSearchSphereData data = {
1358         .ss = ss,
1359         .sd = sd,
1360         .radius_squared = SQUARE(ss->cache->radius * radius_scale),
1361         .original = use_original,
1362     };
1363     BKE_pbvh_search_gather(ss->pbvh, sculpt_search_sphere_cb, &data, &nodes, r_totnode);
1364   }
1365   else {
1366     struct DistRayAABB_Precalc dist_ray_to_aabb_precalc;
1367     dist_squared_ray_to_aabb_v3_precalc(
1368         &dist_ray_to_aabb_precalc, ss->cache->location, ss->cache->view_normal);
1369     SculptSearchCircleData data = {
1370         .ss = ss,
1371         .sd = sd,
1372         .radius_squared = SQUARE(ss->cache->radius * radius_scale),
1373         .original = use_original,
1374         .dist_ray_to_aabb_precalc = &dist_ray_to_aabb_precalc,
1375     };
1376     BKE_pbvh_search_gather(ss->pbvh, sculpt_search_circle_cb, &data, &nodes, r_totnode);
1377   }
1378   return nodes;
1379 }
1380
1381 /* Calculate primary direction of movement for many brushes */
1382 static void calc_sculpt_normal(
1383     Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode, float r_area_no[3])
1384 {
1385   const Brush *brush = BKE_paint_brush(&sd->paint);
1386   const SculptSession *ss = ob->sculpt;
1387
1388   switch (brush->sculpt_plane) {
1389     case SCULPT_DISP_DIR_VIEW:
1390       copy_v3_v3(r_area_no, ss->cache->true_view_normal);
1391       break;
1392
1393     case SCULPT_DISP_DIR_X:
1394       ARRAY_SET_ITEMS(r_area_no, 1, 0, 0);
1395       break;
1396
1397     case SCULPT_DISP_DIR_Y:
1398       ARRAY_SET_ITEMS(r_area_no, 0, 1, 0);
1399       break;
1400
1401     case SCULPT_DISP_DIR_Z:
1402       ARRAY_SET_ITEMS(r_area_no, 0, 0, 1);
1403       break;
1404
1405     case SCULPT_DISP_DIR_AREA:
1406       calc_area_normal(sd, ob, nodes, totnode, r_area_no);
1407       break;
1408
1409     default:
1410       break;
1411   }
1412 }
1413
1414 static void update_sculpt_normal(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
1415 {
1416   const Brush *brush = BKE_paint_brush(&sd->paint);
1417   StrokeCache *cache = ob->sculpt->cache;
1418
1419   if (cache->mirror_symmetry_pass == 0 && cache->radial_symmetry_pass == 0 &&
1420       (cache->first_time || !(brush->flag & BRUSH_ORIGINAL_NORMAL))) {
1421     calc_sculpt_normal(sd, ob, nodes, totnode, cache->sculpt_normal);
1422     if (brush->falloff_shape == PAINT_FALLOFF_SHAPE_TUBE) {
1423       project_plane_v3_v3v3(cache->sculpt_normal, cache->sculpt_normal, cache->view_normal);
1424       normalize_v3(cache->sculpt_normal);
1425     }
1426     copy_v3_v3(cache->sculpt_normal_symm, cache->sculpt_normal);
1427   }
1428   else {
1429     copy_v3_v3(cache->sculpt_normal_symm, cache->sculpt_normal);
1430     flip_v3(cache->sculpt_normal_symm, cache->mirror_symmetry_pass);
1431     mul_m4_v3(cache->symm_rot_mat, cache->sculpt_normal_symm);
1432   }
1433 }
1434
1435 static void calc_local_y(ViewContext *vc, const float center[3], float y[3])
1436 {
1437   Object *ob = vc->obact;
1438   float loc[3], mval_f[2] = {0.0f, 1.0f};
1439   float zfac;
1440
1441   mul_v3_m4v3(loc, ob->imat, center);
1442   zfac = ED_view3d_calc_zfac(vc->rv3d, loc, NULL);
1443
1444   ED_view3d_win_to_delta(vc->ar, mval_f, y, zfac);
1445   normalize_v3(y);
1446
1447   add_v3_v3(y, ob->loc);
1448   mul_m4_v3(ob->imat, y);
1449 }
1450
1451 static void calc_brush_local_mat(const Brush *brush, Object *ob, float local_mat[4][4])
1452 {
1453   const StrokeCache *cache = ob->sculpt->cache;
1454   float tmat[4][4];
1455   float mat[4][4];
1456   float scale[4][4];
1457   float angle, v[3];
1458   float up[3];
1459
1460   /* Ensure ob->imat is up to date */
1461   invert_m4_m4(ob->imat, ob->obmat);
1462
1463   /* Initialize last column of matrix */
1464   mat[0][3] = 0;
1465   mat[1][3] = 0;
1466   mat[2][3] = 0;
1467   mat[3][3] = 1;
1468
1469   /* Get view's up vector in object-space */
1470   calc_local_y(cache->vc, cache->location, up);
1471
1472   /* Calculate the X axis of the local matrix */
1473   cross_v3_v3v3(v, up, cache->sculpt_normal);
1474   /* Apply rotation (user angle, rake, etc.) to X axis */
1475   angle = brush->mtex.rot - cache->special_rotation;
1476   rotate_v3_v3v3fl(mat[0], v, cache->sculpt_normal, angle);
1477
1478   /* Get other axes */
1479   cross_v3_v3v3(mat[1], cache->sculpt_normal, mat[0]);
1480   copy_v3_v3(mat[2], cache->sculpt_normal);
1481
1482   /* Set location */
1483   copy_v3_v3(mat[3], cache->location);
1484
1485   /* Scale by brush radius */
1486   normalize_m4(mat);
1487   scale_m4_fl(scale, cache->radius);
1488   mul_m4_m4m4(tmat, mat, scale);
1489
1490   /* Return inverse (for converting from modelspace coords to local
1491    * area coords) */
1492   invert_m4_m4(local_mat, tmat);
1493 }
1494
1495 static void update_brush_local_mat(Sculpt *sd, Object *ob)
1496 {
1497   StrokeCache *cache = ob->sculpt->cache;
1498
1499   if (cache->mirror_symmetry_pass == 0 && cache->radial_symmetry_pass == 0) {
1500     calc_brush_local_mat(BKE_paint_brush(&sd->paint), ob, cache->brush_local_mat);
1501   }
1502 }
1503
1504 /* For the smooth brush, uses the neighboring vertices around vert to calculate
1505  * a smoothed location for vert. Skips corner vertices (used by only one
1506  * polygon.) */
1507 static void neighbor_average(SculptSession *ss, float avg[3], unsigned vert)
1508 {
1509   const MeshElemMap *vert_map = &ss->pmap[vert];
1510   const MVert *mvert = ss->mvert;
1511   float(*deform_co)[3] = ss->deform_cos;
1512
1513   /* Don't modify corner vertices */
1514   if (vert_map->count > 1) {
1515     int i, total = 0;
1516
1517     zero_v3(avg);
1518
1519     for (i = 0; i < vert_map->count; i++) {
1520       const MPoly *p = &ss->mpoly[vert_map->indices[i]];
1521       unsigned f_adj_v[2];
1522
1523       if (poly_get_adj_loops_from_vert(p, ss->mloop, vert, f_adj_v) != -1) {
1524         int j;
1525         for (j = 0; j < ARRAY_SIZE(f_adj_v); j += 1) {
1526           if (vert_map->count != 2 || ss->pmap[f_adj_v[j]].count <= 2) {
1527             add_v3_v3(avg, deform_co ? deform_co[f_adj_v[j]] : mvert[f_adj_v[j]].co);
1528
1529             total++;
1530           }
1531         }
1532       }
1533     }
1534
1535     if (total > 0) {
1536       mul_v3_fl(avg, 1.0f / total);
1537       return;
1538     }
1539   }
1540
1541   copy_v3_v3(avg, deform_co ? deform_co[vert] : mvert[vert].co);
1542 }
1543
1544 /* Similar to neighbor_average(), but returns an averaged mask value
1545  * instead of coordinate. Also does not restrict based on border or
1546  * corner vertices. */
1547 static float neighbor_average_mask(SculptSession *ss, unsigned vert)
1548 {
1549   const float *vmask = ss->vmask;
1550   float avg = 0;
1551   int i, total = 0;
1552
1553   for (i = 0; i < ss->pmap[vert].count; i++) {
1554     const MPoly *p = &ss->mpoly[ss->pmap[vert].indices[i]];
1555     unsigned f_adj_v[2];
1556
1557     if (poly_get_adj_loops_from_vert(p, ss->mloop, vert, f_adj_v) != -1) {
1558       int j;
1559       for (j = 0; j < ARRAY_SIZE(f_adj_v); j += 1) {
1560         avg += vmask[f_adj_v[j]];
1561         total++;
1562       }
1563     }
1564   }
1565
1566   if (total > 0) {
1567     return avg / (float)total;
1568   }
1569   else {
1570     return vmask[vert];
1571   }
1572 }
1573
1574 /* Same logic as neighbor_average(), but for bmesh rather than mesh */
1575 static void bmesh_neighbor_average(float avg[3], BMVert *v)
1576 {
1577   /* logic for 3 or more is identical */
1578   const int vfcount = BM_vert_face_count_at_most(v, 3);
1579
1580   /* Don't modify corner vertices */
1581   if (vfcount > 1) {
1582     BMIter liter;
1583     BMLoop *l;
1584     int i, total = 0;
1585
1586     zero_v3(avg);
1587
1588     BM_ITER_ELEM (l, &liter, v, BM_LOOPS_OF_VERT) {
1589       const BMVert *adj_v[2] = {l->prev->v, l->next->v};
1590
1591       for (i = 0; i < ARRAY_SIZE(adj_v); i++) {
1592         const BMVert *v_other = adj_v[i];
1593         if (vfcount != 2 || BM_vert_face_count_at_most(v_other, 2) <= 2) {
1594           add_v3_v3(avg, v_other->co);
1595           total++;
1596         }
1597       }
1598     }
1599
1600     if (total > 0) {
1601       mul_v3_fl(avg, 1.0f / total);
1602       return;
1603     }
1604   }
1605
1606   copy_v3_v3(avg, v->co);
1607 }
1608
1609 /* For bmesh: average only the four most aligned (parallel and perpendicular) edges
1610  * relative to a direction. Naturally converges to a quad-like tessellation. */
1611 static void bmesh_four_neighbor_average(float avg[3], float direction[3], BMVert *v)
1612 {
1613   /* Logic for 3 or more is identical. */
1614   const int vfcount = BM_vert_face_count_at_most(v, 3);
1615
1616   /* Don't modify corner vertices. */
1617   if (vfcount < 2) {
1618     copy_v3_v3(avg, v->co);
1619     return;
1620   }
1621
1622   /* Project the direction to the vertex normal and create an additional
1623    * parallel vector. */
1624   float dir_a[3], dir_b[3];
1625   cross_v3_v3v3(dir_a, direction, v->no);
1626   cross_v3_v3v3(dir_b, dir_a, v->no);
1627
1628   /* The four vectors which will be used for smoothing.
1629    * Occasionally less than 4 verts match the requirements in that case
1630    * use 'v' as fallback. */
1631   BMVert *pos_a = v;
1632   BMVert *neg_a = v;
1633   BMVert *pos_b = v;
1634   BMVert *neg_b = v;
1635
1636   float pos_score_a = 0.0f;
1637   float neg_score_a = 0.0f;
1638   float pos_score_b = 0.0f;
1639   float neg_score_b = 0.0f;
1640
1641   BMIter liter;
1642   BMLoop *l;
1643
1644   BM_ITER_ELEM (l, &liter, v, BM_LOOPS_OF_VERT) {
1645     BMVert *adj_v[2] = {l->prev->v, l->next->v};
1646
1647     for (int i = 0; i < ARRAY_SIZE(adj_v); i++) {
1648       BMVert *v_other = adj_v[i];
1649
1650       if (vfcount != 2 || BM_vert_face_count_at_most(v_other, 2) <= 2) {
1651         float vec[3];
1652         sub_v3_v3v3(vec, v_other->co, v->co);
1653         normalize_v3(vec);
1654
1655         /* The score is a measure of how orthogonal the edge is. */
1656         float score = dot_v3v3(vec, dir_a);
1657
1658         if (score >= pos_score_a) {
1659           pos_a = v_other;
1660           pos_score_a = score;
1661         }
1662         else if (score < neg_score_a) {
1663           neg_a = v_other;
1664           neg_score_a = score;
1665         }
1666         /* The same scoring but for the perpendicular direction. */
1667         score = dot_v3v3(vec, dir_b);
1668
1669         if (score >= pos_score_b) {
1670           pos_b = v_other;
1671           pos_score_b = score;
1672         }
1673         else if (score < neg_score_b) {
1674           neg_b = v_other;
1675           neg_score_b = score;
1676         }
1677       }
1678     }
1679   }
1680
1681   /* Average everything together. */
1682   zero_v3(avg);
1683   add_v3_v3(avg, pos_a->co);
1684   add_v3_v3(avg, neg_a->co);
1685   add_v3_v3(avg, pos_b->co);
1686   add_v3_v3(avg, neg_b->co);
1687   mul_v3_fl(avg, 0.25f);
1688
1689   /* Preserve volume. */
1690   float vec[3];
1691   sub_v3_v3(avg, v->co);
1692   mul_v3_v3fl(vec, v->no, dot_v3v3(avg, v->no));
1693   sub_v3_v3(avg, vec);
1694   add_v3_v3(avg, v->co);
1695 }
1696
1697 /* Same logic as neighbor_average_mask(), but for bmesh rather than mesh */
1698 static float bmesh_neighbor_average_mask(BMVert *v, const int cd_vert_mask_offset)
1699 {
1700   BMIter liter;
1701   BMLoop *l;
1702   float avg = 0;
1703   int i, total = 0;
1704
1705   BM_ITER_ELEM (l, &liter, v, BM_LOOPS_OF_VERT) {
1706     /* skip this vertex */
1707     const BMVert *adj_v[2] = {l->prev->v, l->next->v};
1708
1709     for (i = 0; i < ARRAY_SIZE(adj_v); i++) {
1710       const BMVert *v_other = adj_v[i];
1711       const float *vmask = BM_ELEM_CD_GET_VOID_P(v_other, cd_vert_mask_offset);
1712       avg += (*vmask);
1713       total++;
1714     }
1715   }
1716
1717   if (total > 0) {
1718     return avg / (float)total;
1719   }
1720   else {
1721     const float *vmask = BM_ELEM_CD_GET_VOID_P(v, cd_vert_mask_offset);
1722     return (*vmask);
1723   }
1724 }
1725
1726 /* Note: uses after-struct allocated mem to store actual cache... */
1727 typedef struct SculptDoBrushSmoothGridDataChunk {
1728   size_t tmpgrid_size;
1729 } SculptDoBrushSmoothGridDataChunk;
1730
1731 typedef struct {
1732   SculptSession *ss;
1733   const float *ray_start, *ray_normal;
1734   bool hit;
1735   float depth;
1736   bool original;
1737 } SculptRaycastData;
1738
1739 typedef struct {
1740   const float *ray_start, *ray_normal;
1741   bool hit;
1742   float depth;
1743   float edge_length;
1744 } SculptDetailRaycastData;
1745
1746 typedef struct {
1747   SculptSession *ss;
1748   const float *ray_start, *ray_normal;
1749   bool hit;
1750   float depth;
1751   float dist_sq_to_ray;
1752   bool original;
1753 } SculptFindNearestToRayData;
1754
1755 static void do_smooth_brush_mesh_task_cb_ex(void *__restrict userdata,
1756                                             const int n,
1757                                             const ParallelRangeTLS *__restrict tls)
1758 {
1759   SculptThreadedTaskData *data = userdata;
1760   SculptSession *ss = data->ob->sculpt;
1761   Sculpt *sd = data->sd;
1762   const Brush *brush = data->brush;
1763   const bool smooth_mask = data->smooth_mask;
1764   float bstrength = data->strength;
1765
1766   PBVHVertexIter vd;
1767
1768   CLAMP(bstrength, 0.0f, 1.0f);
1769
1770   SculptBrushTest test;
1771   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
1772       ss, &test, data->brush->falloff_shape);
1773
1774   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
1775   {
1776     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
1777       const float fade = bstrength * tex_strength(ss,
1778                                                   brush,
1779                                                   vd.co,
1780                                                   sqrtf(test.dist),
1781                                                   vd.no,
1782                                                   vd.fno,
1783                                                   smooth_mask ? 0.0f : (vd.mask ? *vd.mask : 0.0f),
1784                                                   tls->thread_id);
1785       if (smooth_mask) {
1786         float val = neighbor_average_mask(ss, vd.vert_indices[vd.i]) - *vd.mask;
1787         val *= fade * bstrength;
1788         *vd.mask += val;
1789         CLAMP(*vd.mask, 0.0f, 1.0f);
1790       }
1791       else {
1792         float avg[3], val[3];
1793
1794         neighbor_average(ss, avg, vd.vert_indices[vd.i]);
1795         sub_v3_v3v3(val, avg, vd.co);
1796
1797         madd_v3_v3v3fl(val, vd.co, val, fade);
1798
1799         sculpt_clip(sd, ss, vd.co, val);
1800       }
1801
1802       if (vd.mvert) {
1803         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
1804       }
1805     }
1806   }
1807   BKE_pbvh_vertex_iter_end;
1808 }
1809
1810 static void do_smooth_brush_bmesh_task_cb_ex(void *__restrict userdata,
1811                                              const int n,
1812                                              const ParallelRangeTLS *__restrict tls)
1813 {
1814   SculptThreadedTaskData *data = userdata;
1815   SculptSession *ss = data->ob->sculpt;
1816   Sculpt *sd = data->sd;
1817   const Brush *brush = data->brush;
1818   const bool smooth_mask = data->smooth_mask;
1819   float bstrength = data->strength;
1820
1821   PBVHVertexIter vd;
1822
1823   CLAMP(bstrength, 0.0f, 1.0f);
1824
1825   SculptBrushTest test;
1826   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
1827       ss, &test, data->brush->falloff_shape);
1828
1829   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
1830   {
1831     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
1832       const float fade = bstrength * tex_strength(ss,
1833                                                   brush,
1834                                                   vd.co,
1835                                                   sqrtf(test.dist),
1836                                                   vd.no,
1837                                                   vd.fno,
1838                                                   smooth_mask ? 0.0f : *vd.mask,
1839                                                   tls->thread_id);
1840       if (smooth_mask) {
1841         float val = bmesh_neighbor_average_mask(vd.bm_vert, vd.cd_vert_mask_offset) - *vd.mask;
1842         val *= fade * bstrength;
1843         *vd.mask += val;
1844         CLAMP(*vd.mask, 0.0f, 1.0f);
1845       }
1846       else {
1847         float avg[3], val[3];
1848
1849         bmesh_neighbor_average(avg, vd.bm_vert);
1850         sub_v3_v3v3(val, avg, vd.co);
1851
1852         madd_v3_v3v3fl(val, vd.co, val, fade);
1853
1854         sculpt_clip(sd, ss, vd.co, val);
1855       }
1856
1857       if (vd.mvert) {
1858         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
1859       }
1860     }
1861   }
1862   BKE_pbvh_vertex_iter_end;
1863 }
1864
1865 static void do_topology_rake_bmesh_task_cb_ex(void *__restrict userdata,
1866                                               const int n,
1867                                               const ParallelRangeTLS *__restrict tls)
1868 {
1869   SculptThreadedTaskData *data = userdata;
1870   SculptSession *ss = data->ob->sculpt;
1871   Sculpt *sd = data->sd;
1872   const Brush *brush = data->brush;
1873
1874   float direction[3];
1875   copy_v3_v3(direction, ss->cache->grab_delta_symmetry);
1876
1877   float tmp[3];
1878   mul_v3_v3fl(
1879       tmp, ss->cache->sculpt_normal_symm, dot_v3v3(ss->cache->sculpt_normal_symm, direction));
1880   sub_v3_v3(direction, tmp);
1881
1882   /* Cancel if there's no grab data. */
1883   if (is_zero_v3(direction)) {
1884     return;
1885   }
1886
1887   float bstrength = data->strength;
1888   CLAMP(bstrength, 0.0f, 1.0f);
1889
1890   SculptBrushTest test;
1891   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
1892       ss, &test, data->brush->falloff_shape);
1893
1894   PBVHVertexIter vd;
1895   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
1896   {
1897     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
1898       const float fade =
1899           bstrength *
1900           tex_strength(
1901               ss, brush, vd.co, sqrtf(test.dist), vd.no, vd.fno, *vd.mask, tls->thread_id) *
1902           ss->cache->pressure;
1903
1904       float avg[3], val[3];
1905
1906       bmesh_four_neighbor_average(avg, direction, vd.bm_vert);
1907
1908       sub_v3_v3v3(val, avg, vd.co);
1909
1910       madd_v3_v3v3fl(val, vd.co, val, fade);
1911
1912       sculpt_clip(sd, ss, vd.co, val);
1913
1914       if (vd.mvert) {
1915         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
1916       }
1917     }
1918   }
1919   BKE_pbvh_vertex_iter_end;
1920 }
1921
1922 static void do_smooth_brush_multires_task_cb_ex(void *__restrict userdata,
1923                                                 const int n,
1924                                                 const ParallelRangeTLS *__restrict tls)
1925 {
1926   SculptThreadedTaskData *data = userdata;
1927   SculptDoBrushSmoothGridDataChunk *data_chunk = tls->userdata_chunk;
1928   SculptSession *ss = data->ob->sculpt;
1929   Sculpt *sd = data->sd;
1930   const Brush *brush = data->brush;
1931   const bool smooth_mask = data->smooth_mask;
1932   float bstrength = data->strength;
1933
1934   CCGElem **griddata, *gddata;
1935   CCGKey key;
1936
1937   float(*tmpgrid_co)[3] = NULL;
1938   float tmprow_co[2][3];
1939   float *tmpgrid_mask = NULL;
1940   float tmprow_mask[2];
1941
1942   BLI_bitmap *const *grid_hidden;
1943   int *grid_indices, totgrid, gridsize;
1944   int i, x, y;
1945
1946   SculptBrushTest test;
1947   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
1948       ss, &test, data->brush->falloff_shape);
1949
1950   CLAMP(bstrength, 0.0f, 1.0f);
1951
1952   BKE_pbvh_node_get_grids(
1953       ss->pbvh, data->nodes[n], &grid_indices, &totgrid, NULL, &gridsize, &griddata);
1954   BKE_pbvh_get_grid_key(ss->pbvh, &key);
1955
1956   grid_hidden = BKE_pbvh_grid_hidden(ss->pbvh);
1957
1958   if (smooth_mask) {
1959     tmpgrid_mask = (void *)(data_chunk + 1);
1960   }
1961   else {
1962     tmpgrid_co = (void *)(data_chunk + 1);
1963   }
1964
1965   for (i = 0; i < totgrid; i++) {
1966     int gi = grid_indices[i];
1967     const BLI_bitmap *gh = grid_hidden[gi];
1968     gddata = griddata[gi];
1969
1970     if (smooth_mask) {
1971       memset(tmpgrid_mask, 0, data_chunk->tmpgrid_size);
1972     }
1973     else {
1974       memset(tmpgrid_co, 0, data_chunk->tmpgrid_size);
1975     }
1976
1977     for (y = 0; y < gridsize - 1; y++) {
1978       const int v = y * gridsize;
1979       if (smooth_mask) {
1980         tmprow_mask[0] = (*CCG_elem_offset_mask(&key, gddata, v) +
1981                           *CCG_elem_offset_mask(&key, gddata, v + gridsize));
1982       }
1983       else {
1984         add_v3_v3v3(tmprow_co[0],
1985                     CCG_elem_offset_co(&key, gddata, v),
1986                     CCG_elem_offset_co(&key, gddata, v + gridsize));
1987       }
1988
1989       for (x = 0; x < gridsize - 1; x++) {
1990         const int v1 = x + y * gridsize;
1991         const int v2 = v1 + 1;
1992         const int v3 = v1 + gridsize;
1993         const int v4 = v3 + 1;
1994
1995         if (smooth_mask) {
1996           float tmp;
1997
1998           tmprow_mask[(x + 1) % 2] = (*CCG_elem_offset_mask(&key, gddata, v2) +
1999                                       *CCG_elem_offset_mask(&key, gddata, v4));
2000           tmp = tmprow_mask[(x + 1) % 2] + tmprow_mask[x % 2];
2001
2002           tmpgrid_mask[v1] += tmp;
2003           tmpgrid_mask[v2] += tmp;
2004           tmpgrid_mask[v3] += tmp;
2005           tmpgrid_mask[v4] += tmp;
2006         }
2007         else {
2008           float tmp[3];
2009
2010           add_v3_v3v3(tmprow_co[(x + 1) % 2],
2011                       CCG_elem_offset_co(&key, gddata, v2),
2012                       CCG_elem_offset_co(&key, gddata, v4));
2013           add_v3_v3v3(tmp, tmprow_co[(x + 1) % 2], tmprow_co[x % 2]);
2014
2015           add_v3_v3(tmpgrid_co[v1], tmp);
2016           add_v3_v3(tmpgrid_co[v2], tmp);
2017           add_v3_v3(tmpgrid_co[v3], tmp);
2018           add_v3_v3(tmpgrid_co[v4], tmp);
2019         }
2020       }
2021     }
2022
2023     /* blend with existing coordinates */
2024     for (y = 0; y < gridsize; y++) {
2025       for (x = 0; x < gridsize; x++) {
2026         float *co;
2027         const float *fno;
2028         float *mask;
2029         const int index = y * gridsize + x;
2030
2031         if (gh) {
2032           if (BLI_BITMAP_TEST(gh, index)) {
2033             continue;
2034           }
2035         }
2036
2037         co = CCG_elem_offset_co(&key, gddata, index);
2038         fno = CCG_elem_offset_no(&key, gddata, index);
2039         mask = CCG_elem_offset_mask(&key, gddata, index);
2040
2041         if (sculpt_brush_test_sq_fn(&test, co)) {
2042           const float strength_mask = (smooth_mask ? 0.0f : *mask);
2043           const float fade =
2044               bstrength *
2045               tex_strength(
2046                   ss, brush, co, sqrtf(test.dist), NULL, fno, strength_mask, tls->thread_id);
2047           float f = 1.0f / 16.0f;
2048
2049           if (x == 0 || x == gridsize - 1) {
2050             f *= 2.0f;
2051           }
2052
2053           if (y == 0 || y == gridsize - 1) {
2054             f *= 2.0f;
2055           }
2056
2057           if (smooth_mask) {
2058             *mask += ((tmpgrid_mask[index] * f) - *mask) * fade;
2059           }
2060           else {
2061             float *avg = tmpgrid_co[index];
2062             float val[3];
2063
2064             mul_v3_fl(avg, f);
2065             sub_v3_v3v3(val, avg, co);
2066             madd_v3_v3v3fl(val, co, val, fade);
2067
2068             sculpt_clip(sd, ss, co, val);
2069           }
2070         }
2071       }
2072     }
2073   }
2074 }
2075
2076 static void smooth(Sculpt *sd,
2077                    Object *ob,
2078                    PBVHNode **nodes,
2079                    const int totnode,
2080                    float bstrength,
2081                    const bool smooth_mask)
2082 {
2083   SculptSession *ss = ob->sculpt;
2084   Brush *brush = BKE_paint_brush(&sd->paint);
2085
2086   const int max_iterations = 4;
2087   const float fract = 1.0f / max_iterations;
2088   PBVHType type = BKE_pbvh_type(ss->pbvh);
2089   int iteration, count;
2090   float last;
2091
2092   CLAMP(bstrength, 0.0f, 1.0f);
2093
2094   count = (int)(bstrength * max_iterations);
2095   last = max_iterations * (bstrength - count * fract);
2096
2097   if (type == PBVH_FACES && !ss->pmap) {
2098     BLI_assert(!"sculpt smooth: pmap missing");
2099     return;
2100   }
2101
2102   for (iteration = 0; iteration <= count; ++iteration) {
2103     const float strength = (iteration != count) ? 1.0f : last;
2104
2105     SculptThreadedTaskData data = {
2106         .sd = sd,
2107         .ob = ob,
2108         .brush = brush,
2109         .nodes = nodes,
2110         .smooth_mask = smooth_mask,
2111         .strength = strength,
2112     };
2113
2114     ParallelRangeSettings settings;
2115     BLI_parallel_range_settings_defaults(&settings);
2116     settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
2117
2118     switch (type) {
2119       case PBVH_GRIDS: {
2120         int gridsize;
2121         size_t size;
2122         SculptDoBrushSmoothGridDataChunk *data_chunk;
2123
2124         BKE_pbvh_node_get_grids(ss->pbvh, NULL, NULL, NULL, NULL, &gridsize, NULL);
2125         size = (size_t)gridsize;
2126         size = sizeof(float) * size * size * (smooth_mask ? 1 : 3);
2127         data_chunk = MEM_mallocN(sizeof(*data_chunk) + size, __func__);
2128         data_chunk->tmpgrid_size = size;
2129         size += sizeof(*data_chunk);
2130
2131         settings.userdata_chunk = data_chunk;
2132         settings.userdata_chunk_size = size;
2133         BLI_task_parallel_range(0, totnode, &data, do_smooth_brush_multires_task_cb_ex, &settings);
2134
2135         MEM_freeN(data_chunk);
2136         break;
2137       }
2138       case PBVH_FACES:
2139         BLI_task_parallel_range(0, totnode, &data, do_smooth_brush_mesh_task_cb_ex, &settings);
2140         break;
2141       case PBVH_BMESH:
2142         BLI_task_parallel_range(0, totnode, &data, do_smooth_brush_bmesh_task_cb_ex, &settings);
2143         break;
2144     }
2145
2146     if (ss->multires) {
2147       multires_stitch_grids(ob);
2148     }
2149   }
2150 }
2151
2152 static void bmesh_topology_rake(
2153     Sculpt *sd, Object *ob, PBVHNode **nodes, const int totnode, float bstrength)
2154 {
2155   Brush *brush = BKE_paint_brush(&sd->paint);
2156   CLAMP(bstrength, 0.0f, 1.0f);
2157
2158   /* Interactions increase both strength and quality. */
2159   const int iterations = 3;
2160
2161   int iteration;
2162   const int count = iterations * bstrength + 1;
2163   const float factor = iterations * bstrength / count;
2164
2165   for (iteration = 0; iteration <= count; ++iteration) {
2166
2167     SculptThreadedTaskData data = {
2168         .sd = sd,
2169         .ob = ob,
2170         .brush = brush,
2171         .nodes = nodes,
2172         .strength = factor,
2173     };
2174     ParallelRangeSettings settings;
2175     BLI_parallel_range_settings_defaults(&settings);
2176     settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
2177
2178     BLI_task_parallel_range(0, totnode, &data, do_topology_rake_bmesh_task_cb_ex, &settings);
2179   }
2180 }
2181
2182 static void do_smooth_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
2183 {
2184   SculptSession *ss = ob->sculpt;
2185   smooth(sd, ob, nodes, totnode, ss->cache->bstrength, false);
2186 }
2187
2188 static void do_mask_brush_draw_task_cb_ex(void *__restrict userdata,
2189                                           const int n,
2190                                           const ParallelRangeTLS *__restrict tls)
2191 {
2192   SculptThreadedTaskData *data = userdata;
2193   SculptSession *ss = data->ob->sculpt;
2194   const Brush *brush = data->brush;
2195   const float bstrength = ss->cache->bstrength;
2196
2197   PBVHVertexIter vd;
2198
2199   SculptBrushTest test;
2200   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
2201       ss, &test, data->brush->falloff_shape);
2202
2203   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
2204   {
2205     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
2206       const float fade = tex_strength(
2207           ss, brush, vd.co, sqrtf(test.dist), vd.no, vd.fno, 0.0f, tls->thread_id);
2208
2209       (*vd.mask) += fade * bstrength;
2210       CLAMP(*vd.mask, 0, 1);
2211
2212       if (vd.mvert) {
2213         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
2214       }
2215     }
2216     BKE_pbvh_vertex_iter_end;
2217   }
2218 }
2219
2220 static void do_mask_brush_draw(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
2221 {
2222   Brush *brush = BKE_paint_brush(&sd->paint);
2223
2224   /* threaded loop over nodes */
2225   SculptThreadedTaskData data = {
2226       .sd = sd,
2227       .ob = ob,
2228       .brush = brush,
2229       .nodes = nodes,
2230   };
2231
2232   ParallelRangeSettings settings;
2233   BLI_parallel_range_settings_defaults(&settings);
2234   settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
2235   BLI_task_parallel_range(0, totnode, &data, do_mask_brush_draw_task_cb_ex, &settings);
2236 }
2237
2238 static void do_mask_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
2239 {
2240   SculptSession *ss = ob->sculpt;
2241   Brush *brush = BKE_paint_brush(&sd->paint);
2242
2243   switch ((BrushMaskTool)brush->mask_tool) {
2244     case BRUSH_MASK_DRAW:
2245       do_mask_brush_draw(sd, ob, nodes, totnode);
2246       break;
2247     case BRUSH_MASK_SMOOTH:
2248       smooth(sd, ob, nodes, totnode, ss->cache->bstrength, true);
2249       break;
2250   }
2251 }
2252
2253 static void do_draw_brush_task_cb_ex(void *__restrict userdata,
2254                                      const int n,
2255                                      const ParallelRangeTLS *__restrict tls)
2256 {
2257   SculptThreadedTaskData *data = userdata;
2258   SculptSession *ss = data->ob->sculpt;
2259   const Brush *brush = data->brush;
2260   const float *offset = data->offset;
2261
2262   PBVHVertexIter vd;
2263   float(*proxy)[3];
2264
2265   proxy = BKE_pbvh_node_add_proxy(ss->pbvh, data->nodes[n])->co;
2266
2267   SculptBrushTest test;
2268   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
2269       ss, &test, data->brush->falloff_shape);
2270
2271   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
2272   {
2273     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
2274       /* offset vertex */
2275       const float fade = tex_strength(ss,
2276                                       brush,
2277                                       vd.co,
2278                                       sqrtf(test.dist),
2279                                       vd.no,
2280                                       vd.fno,
2281                                       vd.mask ? *vd.mask : 0.0f,
2282                                       tls->thread_id);
2283
2284       mul_v3_v3fl(proxy[vd.i], offset, fade);
2285
2286       if (vd.mvert) {
2287         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
2288       }
2289     }
2290   }
2291   BKE_pbvh_vertex_iter_end;
2292 }
2293
2294 static void do_draw_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
2295 {
2296   SculptSession *ss = ob->sculpt;
2297   Brush *brush = BKE_paint_brush(&sd->paint);
2298   float offset[3];
2299   const float bstrength = ss->cache->bstrength;
2300
2301   /* offset with as much as possible factored in already */
2302   mul_v3_v3fl(offset, ss->cache->sculpt_normal_symm, ss->cache->radius);
2303   mul_v3_v3(offset, ss->cache->scale);
2304   mul_v3_fl(offset, bstrength);
2305
2306   /* XXX - this shouldn't be necessary, but sculpting crashes in blender2.8 otherwise
2307    * initialize before threads so they can do curve mapping */
2308   curvemapping_initialize(brush->curve);
2309
2310   /* threaded loop over nodes */
2311   SculptThreadedTaskData data = {
2312       .sd = sd,
2313       .ob = ob,
2314       .brush = brush,
2315       .nodes = nodes,
2316       .offset = offset,
2317   };
2318
2319   ParallelRangeSettings settings;
2320   BLI_parallel_range_settings_defaults(&settings);
2321   settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
2322   BLI_task_parallel_range(0, totnode, &data, do_draw_brush_task_cb_ex, &settings);
2323 }
2324
2325 /**
2326  * Used for 'SCULPT_TOOL_CREASE' and 'SCULPT_TOOL_BLOB'
2327  */
2328 static void do_crease_brush_task_cb_ex(void *__restrict userdata,
2329                                        const int n,
2330                                        const ParallelRangeTLS *__restrict tls)
2331 {
2332   SculptThreadedTaskData *data = userdata;
2333   SculptSession *ss = data->ob->sculpt;
2334   const Brush *brush = data->brush;
2335   SculptProjectVector *spvc = data->spvc;
2336   const float flippedbstrength = data->flippedbstrength;
2337   const float *offset = data->offset;
2338
2339   PBVHVertexIter vd;
2340   float(*proxy)[3];
2341
2342   proxy = BKE_pbvh_node_add_proxy(ss->pbvh, data->nodes[n])->co;
2343
2344   SculptBrushTest test;
2345   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
2346       ss, &test, data->brush->falloff_shape);
2347
2348   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
2349   {
2350     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
2351       /* offset vertex */
2352       const float fade = tex_strength(ss,
2353                                       brush,
2354                                       vd.co,
2355                                       sqrtf(test.dist),
2356                                       vd.no,
2357                                       vd.fno,
2358                                       vd.mask ? *vd.mask : 0.0f,
2359                                       tls->thread_id);
2360       float val1[3];
2361       float val2[3];
2362
2363       /* first we pinch */
2364       sub_v3_v3v3(val1, test.location, vd.co);
2365       if (brush->falloff_shape == PAINT_FALLOFF_SHAPE_TUBE) {
2366         project_plane_v3_v3v3(val1, val1, ss->cache->view_normal);
2367       }
2368
2369       mul_v3_fl(val1, fade * flippedbstrength);
2370
2371       sculpt_project_v3(spvc, val1, val1);
2372
2373       /* then we draw */
2374       mul_v3_v3fl(val2, offset, fade);
2375
2376       add_v3_v3v3(proxy[vd.i], val1, val2);
2377
2378       if (vd.mvert) {
2379         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
2380       }
2381     }
2382   }
2383   BKE_pbvh_vertex_iter_end;
2384 }
2385
2386 static void do_crease_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
2387 {
2388   SculptSession *ss = ob->sculpt;
2389   const Scene *scene = ss->cache->vc->scene;
2390   Brush *brush = BKE_paint_brush(&sd->paint);
2391   float offset[3];
2392   float bstrength = ss->cache->bstrength;
2393   float flippedbstrength, crease_correction;
2394   float brush_alpha;
2395
2396   SculptProjectVector spvc;
2397
2398   /* offset with as much as possible factored in already */
2399   mul_v3_v3fl(offset, ss->cache->sculpt_normal_symm, ss->cache->radius);
2400   mul_v3_v3(offset, ss->cache->scale);
2401   mul_v3_fl(offset, bstrength);
2402
2403   /* We divide out the squared alpha and multiply by the squared crease
2404    * to give us the pinch strength. */
2405   crease_correction = brush->crease_pinch_factor * brush->crease_pinch_factor;
2406   brush_alpha = BKE_brush_alpha_get(scene, brush);
2407   if (brush_alpha > 0.0f) {
2408     crease_correction /= brush_alpha * brush_alpha;
2409   }
2410
2411   /* we always want crease to pinch or blob to relax even when draw is negative */
2412   flippedbstrength = (bstrength < 0) ? -crease_correction * bstrength :
2413                                        crease_correction * bstrength;
2414
2415   if (brush->sculpt_tool == SCULPT_TOOL_BLOB) {
2416     flippedbstrength *= -1.0f;
2417   }
2418
2419   /* Use surface normal for 'spvc',
2420    * so the vertices are pinched towards a line instead of a single point.
2421    * Without this we get a 'flat' surface surrounding the pinch */
2422   sculpt_project_v3_cache_init(&spvc, ss->cache->sculpt_normal_symm);
2423
2424   /* threaded loop over nodes */
2425   SculptThreadedTaskData data = {
2426       .sd = sd,
2427       .ob = ob,
2428       .brush = brush,
2429       .nodes = nodes,
2430       .spvc = &spvc,
2431       .offset = offset,
2432       .flippedbstrength = flippedbstrength,
2433   };
2434
2435   ParallelRangeSettings settings;
2436   BLI_parallel_range_settings_defaults(&settings);
2437   settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
2438   BLI_task_parallel_range(0, totnode, &data, do_crease_brush_task_cb_ex, &settings);
2439 }
2440
2441 static void do_pinch_brush_task_cb_ex(void *__restrict userdata,
2442                                       const int n,
2443                                       const ParallelRangeTLS *__restrict tls)
2444 {
2445   SculptThreadedTaskData *data = userdata;
2446   SculptSession *ss = data->ob->sculpt;
2447   const Brush *brush = data->brush;
2448
2449   PBVHVertexIter vd;
2450   float(*proxy)[3];
2451   const float bstrength = ss->cache->bstrength;
2452
2453   proxy = BKE_pbvh_node_add_proxy(ss->pbvh, data->nodes[n])->co;
2454
2455   SculptBrushTest test;
2456   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
2457       ss, &test, data->brush->falloff_shape);
2458
2459   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
2460   {
2461     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
2462       const float fade = bstrength * tex_strength(ss,
2463                                                   brush,
2464                                                   vd.co,
2465                                                   sqrtf(test.dist),
2466                                                   vd.no,
2467                                                   vd.fno,
2468                                                   vd.mask ? *vd.mask : 0.0f,
2469                                                   tls->thread_id);
2470       float val[3];
2471
2472       sub_v3_v3v3(val, test.location, vd.co);
2473       if (brush->falloff_shape == PAINT_FALLOFF_SHAPE_TUBE) {
2474         project_plane_v3_v3v3(val, val, ss->cache->view_normal);
2475       }
2476       mul_v3_v3fl(proxy[vd.i], val, fade);
2477
2478       if (vd.mvert) {
2479         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
2480       }
2481     }
2482   }
2483   BKE_pbvh_vertex_iter_end;
2484 }
2485
2486 static void do_pinch_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
2487 {
2488   Brush *brush = BKE_paint_brush(&sd->paint);
2489
2490   SculptThreadedTaskData data = {
2491       .sd = sd,
2492       .ob = ob,
2493       .brush = brush,
2494       .nodes = nodes,
2495   };
2496
2497   ParallelRangeSettings settings;
2498   BLI_parallel_range_settings_defaults(&settings);
2499   settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
2500   BLI_task_parallel_range(0, totnode, &data, do_pinch_brush_task_cb_ex, &settings);
2501 }
2502
2503 static void do_grab_brush_task_cb_ex(void *__restrict userdata,
2504                                      const int n,
2505                                      const ParallelRangeTLS *__restrict tls)
2506 {
2507   SculptThreadedTaskData *data = userdata;
2508   SculptSession *ss = data->ob->sculpt;
2509   const Brush *brush = data->brush;
2510   const float *grab_delta = data->grab_delta;
2511
2512   PBVHVertexIter vd;
2513   SculptOrigVertData orig_data;
2514   float(*proxy)[3];
2515   const float bstrength = ss->cache->bstrength;
2516
2517   sculpt_orig_vert_data_init(&orig_data, data->ob, data->nodes[n]);
2518
2519   proxy = BKE_pbvh_node_add_proxy(ss->pbvh, data->nodes[n])->co;
2520
2521   SculptBrushTest test;
2522   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
2523       ss, &test, data->brush->falloff_shape);
2524
2525   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
2526   {
2527     sculpt_orig_vert_data_update(&orig_data, &vd);
2528
2529     if (sculpt_brush_test_sq_fn(&test, orig_data.co)) {
2530       const float fade = bstrength * tex_strength(ss,
2531                                                   brush,
2532                                                   orig_data.co,
2533                                                   sqrtf(test.dist),
2534                                                   orig_data.no,
2535                                                   NULL,
2536                                                   vd.mask ? *vd.mask : 0.0f,
2537                                                   tls->thread_id);
2538
2539       mul_v3_v3fl(proxy[vd.i], grab_delta, fade);
2540
2541       if (vd.mvert) {
2542         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
2543       }
2544     }
2545   }
2546   BKE_pbvh_vertex_iter_end;
2547 }
2548
2549 static void do_grab_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
2550 {
2551   SculptSession *ss = ob->sculpt;
2552   Brush *brush = BKE_paint_brush(&sd->paint);
2553   float grab_delta[3];
2554
2555   copy_v3_v3(grab_delta, ss->cache->grab_delta_symmetry);
2556
2557   if (ss->cache->normal_weight > 0.0f) {
2558     sculpt_project_v3_normal_align(ss, ss->cache->normal_weight, grab_delta);
2559   }
2560
2561   SculptThreadedTaskData data = {
2562       .sd = sd,
2563       .ob = ob,
2564       .brush = brush,
2565       .nodes = nodes,
2566       .grab_delta = grab_delta,
2567   };
2568
2569   ParallelRangeSettings settings;
2570   BLI_parallel_range_settings_defaults(&settings);
2571   settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
2572   BLI_task_parallel_range(0, totnode, &data, do_grab_brush_task_cb_ex, &settings);
2573 }
2574
2575 static void do_nudge_brush_task_cb_ex(void *__restrict userdata,
2576                                       const int n,
2577                                       const ParallelRangeTLS *__restrict tls)
2578 {
2579   SculptThreadedTaskData *data = userdata;
2580   SculptSession *ss = data->ob->sculpt;
2581   const Brush *brush = data->brush;
2582   const float *cono = data->cono;
2583
2584   PBVHVertexIter vd;
2585   float(*proxy)[3];
2586   const float bstrength = ss->cache->bstrength;
2587
2588   proxy = BKE_pbvh_node_add_proxy(ss->pbvh, data->nodes[n])->co;
2589
2590   SculptBrushTest test;
2591   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
2592       ss, &test, data->brush->falloff_shape);
2593
2594   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
2595   {
2596     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
2597       const float fade = bstrength * tex_strength(ss,
2598                                                   brush,
2599                                                   vd.co,
2600                                                   sqrtf(test.dist),
2601                                                   vd.no,
2602                                                   vd.fno,
2603                                                   vd.mask ? *vd.mask : 0.0f,
2604                                                   tls->thread_id);
2605
2606       mul_v3_v3fl(proxy[vd.i], cono, fade);
2607
2608       if (vd.mvert) {
2609         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
2610       }
2611     }
2612   }
2613   BKE_pbvh_vertex_iter_end;
2614 }
2615
2616 static void do_nudge_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
2617 {
2618   SculptSession *ss = ob->sculpt;
2619   Brush *brush = BKE_paint_brush(&sd->paint);
2620   float grab_delta[3];
2621   float tmp[3], cono[3];
2622
2623   copy_v3_v3(grab_delta, ss->cache->grab_delta_symmetry);
2624
2625   cross_v3_v3v3(tmp, ss->cache->sculpt_normal_symm, grab_delta);
2626   cross_v3_v3v3(cono, tmp, ss->cache->sculpt_normal_symm);
2627
2628   SculptThreadedTaskData data = {
2629       .sd = sd,
2630       .ob = ob,
2631       .brush = brush,
2632       .nodes = nodes,
2633       .cono = cono,
2634   };
2635
2636   ParallelRangeSettings settings;
2637   BLI_parallel_range_settings_defaults(&settings);
2638   settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
2639   BLI_task_parallel_range(0, totnode, &data, do_nudge_brush_task_cb_ex, &settings);
2640 }
2641
2642 static void do_snake_hook_brush_task_cb_ex(void *__restrict userdata,
2643                                            const int n,
2644                                            const ParallelRangeTLS *__restrict tls)
2645 {
2646   SculptThreadedTaskData *data = userdata;
2647   SculptSession *ss = data->ob->sculpt;
2648   const Brush *brush = data->brush;
2649   SculptProjectVector *spvc = data->spvc;
2650   const float *grab_delta = data->grab_delta;
2651
2652   PBVHVertexIter vd;
2653   float(*proxy)[3];
2654   const float bstrength = ss->cache->bstrength;
2655   const bool do_rake_rotation = ss->cache->is_rake_rotation_valid;
2656   const bool do_pinch = (brush->crease_pinch_factor != 0.5f);
2657   const float pinch = do_pinch ? (2.0f * (0.5f - brush->crease_pinch_factor) *
2658                                   (len_v3(grab_delta) / ss->cache->radius)) :
2659                                  0.0f;
2660
2661   proxy = BKE_pbvh_node_add_proxy(ss->pbvh, data->nodes[n])->co;
2662
2663   SculptBrushTest test;
2664   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
2665       ss, &test, data->brush->falloff_shape);
2666
2667   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
2668   {
2669     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
2670       const float fade = bstrength * tex_strength(ss,
2671                                                   brush,
2672                                                   vd.co,
2673                                                   sqrtf(test.dist),
2674                                                   vd.no,
2675                                                   vd.fno,
2676                                                   vd.mask ? *vd.mask : 0.0f,
2677                                                   tls->thread_id);
2678
2679       mul_v3_v3fl(proxy[vd.i], grab_delta, fade);
2680
2681       /* negative pinch will inflate, helps maintain volume */
2682       if (do_pinch) {
2683         float delta_pinch_init[3], delta_pinch[3];
2684
2685         sub_v3_v3v3(delta_pinch, vd.co, test.location);
2686         if (brush->falloff_shape == PAINT_FALLOFF_SHAPE_TUBE) {
2687           project_plane_v3_v3v3(delta_pinch, delta_pinch, ss->cache->true_view_normal);
2688         }
2689
2690         /* important to calculate based on the grabbed location
2691          * (intentionally ignore fade here). */
2692         add_v3_v3(delta_pinch, grab_delta);
2693
2694         sculpt_project_v3(spvc, delta_pinch, delta_pinch);
2695
2696         copy_v3_v3(delta_pinch_init, delta_pinch);
2697
2698         float pinch_fade = pinch * fade;
2699         /* when reducing, scale reduction back by how close to the center we are,
2700          * so we don't pinch into nothingness */
2701         if (pinch > 0.0f) {
2702           /* square to have even less impact for close vertices */
2703           pinch_fade *= pow2f(min_ff(1.0f, len_v3(delta_pinch) / ss->cache->radius));
2704         }
2705         mul_v3_fl(delta_pinch, 1.0f + pinch_fade);
2706         sub_v3_v3v3(delta_pinch, delta_pinch_init, delta_pinch);
2707         add_v3_v3(proxy[vd.i], delta_pinch);
2708       }
2709
2710       if (do_rake_rotation) {
2711         float delta_rotate[3];
2712         sculpt_rake_rotate(ss, test.location, vd.co, fade, delta_rotate);
2713         add_v3_v3(proxy[vd.i], delta_rotate);
2714       }
2715
2716       if (vd.mvert) {
2717         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
2718       }
2719     }
2720   }
2721   BKE_pbvh_vertex_iter_end;
2722 }
2723
2724 static void do_snake_hook_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
2725 {
2726   SculptSession *ss = ob->sculpt;
2727   Brush *brush = BKE_paint_brush(&sd->paint);
2728   const float bstrength = ss->cache->bstrength;
2729   float grab_delta[3];
2730
2731   SculptProjectVector spvc;
2732
2733   copy_v3_v3(grab_delta, ss->cache->grab_delta_symmetry);
2734
2735   if (bstrength < 0) {
2736     negate_v3(grab_delta);
2737   }
2738
2739   if (ss->cache->normal_weight > 0.0f) {
2740     sculpt_project_v3_normal_align(ss, ss->cache->normal_weight, grab_delta);
2741   }
2742
2743   /* optionally pinch while painting */
2744   if (brush->crease_pinch_factor != 0.5f) {
2745     sculpt_project_v3_cache_init(&spvc, grab_delta);
2746   }
2747
2748   SculptThreadedTaskData data = {
2749       .sd = sd,
2750       .ob = ob,
2751       .brush = brush,
2752       .nodes = nodes,
2753       .spvc = &spvc,
2754       .grab_delta = grab_delta,
2755   };
2756
2757   ParallelRangeSettings settings;
2758   BLI_parallel_range_settings_defaults(&settings);
2759   settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
2760   BLI_task_parallel_range(0, totnode, &data, do_snake_hook_brush_task_cb_ex, &settings);
2761 }
2762
2763 static void do_thumb_brush_task_cb_ex(void *__restrict userdata,
2764                                       const int n,
2765                                       const ParallelRangeTLS *__restrict tls)
2766 {
2767   SculptThreadedTaskData *data = userdata;
2768   SculptSession *ss = data->ob->sculpt;
2769   const Brush *brush = data->brush;
2770   const float *cono = data->cono;
2771
2772   PBVHVertexIter vd;
2773   SculptOrigVertData orig_data;
2774   float(*proxy)[3];
2775   const float bstrength = ss->cache->bstrength;
2776
2777   sculpt_orig_vert_data_init(&orig_data, data->ob, data->nodes[n]);
2778
2779   proxy = BKE_pbvh_node_add_proxy(ss->pbvh, data->nodes[n])->co;
2780
2781   SculptBrushTest test;
2782   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
2783       ss, &test, data->brush->falloff_shape);
2784
2785   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
2786   {
2787     sculpt_orig_vert_data_update(&orig_data, &vd);
2788
2789     if (sculpt_brush_test_sq_fn(&test, orig_data.co)) {
2790       const float fade = bstrength * tex_strength(ss,
2791                                                   brush,
2792                                                   orig_data.co,
2793                                                   sqrtf(test.dist),
2794                                                   orig_data.no,
2795                                                   NULL,
2796                                                   vd.mask ? *vd.mask : 0.0f,
2797                                                   tls->thread_id);
2798
2799       mul_v3_v3fl(proxy[vd.i], cono, fade);
2800
2801       if (vd.mvert) {
2802         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
2803       }
2804     }
2805   }
2806   BKE_pbvh_vertex_iter_end;
2807 }
2808
2809 static void do_thumb_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
2810 {
2811   SculptSession *ss = ob->sculpt;
2812   Brush *brush = BKE_paint_brush(&sd->paint);
2813   float grab_delta[3];
2814   float tmp[3], cono[3];
2815
2816   copy_v3_v3(grab_delta, ss->cache->grab_delta_symmetry);
2817
2818   cross_v3_v3v3(tmp, ss->cache->sculpt_normal_symm, grab_delta);
2819   cross_v3_v3v3(cono, tmp, ss->cache->sculpt_normal_symm);
2820
2821   SculptThreadedTaskData data = {
2822       .sd = sd,
2823       .ob = ob,
2824       .brush = brush,
2825       .nodes = nodes,
2826       .cono = cono,
2827   };
2828
2829   ParallelRangeSettings settings;
2830   BLI_parallel_range_settings_defaults(&settings);
2831   settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
2832   BLI_task_parallel_range(0, totnode, &data, do_thumb_brush_task_cb_ex, &settings);
2833 }
2834
2835 static void do_rotate_brush_task_cb_ex(void *__restrict userdata,
2836                                        const int n,
2837                                        const ParallelRangeTLS *__restrict tls)
2838 {
2839   SculptThreadedTaskData *data = userdata;
2840   SculptSession *ss = data->ob->sculpt;
2841   const Brush *brush = data->brush;
2842   const float angle = data->angle;
2843
2844   PBVHVertexIter vd;
2845   SculptOrigVertData orig_data;
2846   float(*proxy)[3];
2847   const float bstrength = ss->cache->bstrength;
2848
2849   sculpt_orig_vert_data_init(&orig_data, data->ob, data->nodes[n]);
2850
2851   proxy = BKE_pbvh_node_add_proxy(ss->pbvh, data->nodes[n])->co;
2852
2853   SculptBrushTest test;
2854   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
2855       ss, &test, data->brush->falloff_shape);
2856
2857   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
2858   {
2859     sculpt_orig_vert_data_update(&orig_data, &vd);
2860
2861     if (sculpt_brush_test_sq_fn(&test, orig_data.co)) {
2862       float vec[3], rot[3][3];
2863       const float fade = bstrength * tex_strength(ss,
2864                                                   brush,
2865                                                   orig_data.co,
2866                                                   sqrtf(test.dist),
2867                                                   orig_data.no,
2868                                                   NULL,
2869                                                   vd.mask ? *vd.mask : 0.0f,
2870                                                   tls->thread_id);
2871
2872       sub_v3_v3v3(vec, orig_data.co, ss->cache->location);
2873       axis_angle_normalized_to_mat3(rot, ss->cache->sculpt_normal_symm, angle * fade);
2874       mul_v3_m3v3(proxy[vd.i], rot, vec);
2875       add_v3_v3(proxy[vd.i], ss->cache->location);
2876       sub_v3_v3(proxy[vd.i], orig_data.co);
2877
2878       if (vd.mvert) {
2879         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
2880       }
2881     }
2882   }
2883   BKE_pbvh_vertex_iter_end;
2884 }
2885
2886 static void do_rotate_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
2887 {
2888   SculptSession *ss = ob->sculpt;
2889   Brush *brush = BKE_paint_brush(&sd->paint);
2890
2891   static const int flip[8] = {1, -1, -1, 1, -1, 1, 1, -1};
2892   const float angle = ss->cache->vertex_rotation * flip[ss->cache->mirror_symmetry_pass];
2893
2894   SculptThreadedTaskData data = {
2895       .sd = sd,
2896       .ob = ob,
2897       .brush = brush,
2898       .nodes = nodes,
2899       .angle = angle,
2900   };
2901
2902   ParallelRangeSettings settings;
2903   BLI_parallel_range_settings_defaults(&settings);
2904   settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
2905   BLI_task_parallel_range(0, totnode, &data, do_rotate_brush_task_cb_ex, &settings);
2906 }
2907
2908 static void do_layer_brush_task_cb_ex(void *__restrict userdata,
2909                                       const int n,
2910                                       const ParallelRangeTLS *__restrict tls)
2911 {
2912   SculptThreadedTaskData *data = userdata;
2913   SculptSession *ss = data->ob->sculpt;
2914   Sculpt *sd = data->sd;
2915   const Brush *brush = data->brush;
2916   const float *offset = data->offset;
2917
2918   PBVHVertexIter vd;
2919   SculptOrigVertData orig_data;
2920   float *layer_disp;
2921   const float bstrength = ss->cache->bstrength;
2922   const float lim = (bstrength < 0) ? -data->brush->height : data->brush->height;
2923   /* XXX: layer brush needs conversion to proxy but its more complicated */
2924   /* proxy = BKE_pbvh_node_add_proxy(ss->pbvh, nodes[n])->co; */
2925
2926   sculpt_orig_vert_data_init(&orig_data, data->ob, data->nodes[n]);
2927
2928   /* Why does this have to be thread-protected? */
2929   BLI_mutex_lock(&data->mutex);
2930   layer_disp = BKE_pbvh_node_layer_disp_get(ss->pbvh, data->nodes[n]);
2931   BLI_mutex_unlock(&data->mutex);
2932
2933   SculptBrushTest test;
2934   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
2935       ss, &test, data->brush->falloff_shape);
2936
2937   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
2938   {
2939     sculpt_orig_vert_data_update(&orig_data, &vd);
2940
2941     if (sculpt_brush_test_sq_fn(&test, orig_data.co)) {
2942       const float fade = bstrength * tex_strength(ss,
2943                                                   brush,
2944                                                   vd.co,
2945                                                   sqrtf(test.dist),
2946                                                   vd.no,
2947                                                   vd.fno,
2948                                                   vd.mask ? *vd.mask : 0.0f,
2949                                                   tls->thread_id);
2950       float *disp = &layer_disp[vd.i];
2951       float val[3];
2952
2953       *disp += fade;
2954
2955       /* Don't let the displacement go past the limit */
2956       if ((lim < 0.0f && *disp < lim) || (lim >= 0.0f && *disp > lim)) {
2957         *disp = lim;
2958       }
2959
2960       mul_v3_v3fl(val, offset, *disp);
2961
2962       if (!ss->multires && !ss->bm && ss->layer_co && (brush->flag & BRUSH_PERSISTENT)) {
2963         int index = vd.vert_indices[vd.i];
2964
2965         /* persistent base */
2966         add_v3_v3(val, ss->layer_co[index]);
2967       }
2968       else {
2969         add_v3_v3(val, orig_data.co);
2970       }
2971
2972       sculpt_clip(sd, ss, vd.co, val);
2973
2974       if (vd.mvert) {
2975         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
2976       }
2977     }
2978   }
2979   BKE_pbvh_vertex_iter_end;
2980 }
2981
2982 static void do_layer_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
2983 {
2984   SculptSession *ss = ob->sculpt;
2985   Brush *brush = BKE_paint_brush(&sd->paint);
2986   float offset[3];
2987
2988   mul_v3_v3v3(offset, ss->cache->scale, ss->cache->sculpt_normal_symm);
2989
2990   SculptThreadedTaskData data = {
2991       .sd = sd,
2992       .ob = ob,
2993       .brush = brush,
2994       .nodes = nodes,
2995       .offset = offset,
2996   };
2997   BLI_mutex_init(&data.mutex);
2998
2999   ParallelRangeSettings settings;
3000   BLI_parallel_range_settings_defaults(&settings);
3001   settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
3002   BLI_task_parallel_range(0, totnode, &data, do_layer_brush_task_cb_ex, &settings);
3003
3004   BLI_mutex_end(&data.mutex);
3005 }
3006
3007 static void do_inflate_brush_task_cb_ex(void *__restrict userdata,
3008                                         const int n,
3009                                         const ParallelRangeTLS *__restrict tls)
3010 {
3011   SculptThreadedTaskData *data = userdata;
3012   SculptSession *ss = data->ob->sculpt;
3013   const Brush *brush = data->brush;
3014
3015   PBVHVertexIter vd;
3016   float(*proxy)[3];
3017   const float bstrength = ss->cache->bstrength;
3018
3019   proxy = BKE_pbvh_node_add_proxy(ss->pbvh, data->nodes[n])->co;
3020
3021   SculptBrushTest test;
3022   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
3023       ss, &test, data->brush->falloff_shape);
3024
3025   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
3026   {
3027     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
3028       const float fade = bstrength * tex_strength(ss,
3029                                                   brush,
3030                                                   vd.co,
3031                                                   sqrtf(test.dist),
3032                                                   vd.no,
3033                                                   vd.fno,
3034                                                   vd.mask ? *vd.mask : 0.0f,
3035                                                   tls->thread_id);
3036       float val[3];
3037
3038       if (vd.fno) {
3039         copy_v3_v3(val, vd.fno);
3040       }
3041       else {
3042         normal_short_to_float_v3(val, vd.no);
3043       }
3044
3045       mul_v3_fl(val, fade * ss->cache->radius);
3046       mul_v3_v3v3(proxy[vd.i], val, ss->cache->scale);
3047
3048       if (vd.mvert) {
3049         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
3050       }
3051     }
3052   }
3053   BKE_pbvh_vertex_iter_end;
3054 }
3055
3056 static void do_inflate_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
3057 {
3058   Brush *brush = BKE_paint_brush(&sd->paint);
3059
3060   SculptThreadedTaskData data = {
3061       .sd = sd,
3062       .ob = ob,
3063       .brush = brush,
3064       .nodes = nodes,
3065   };
3066
3067   ParallelRangeSettings settings;
3068   BLI_parallel_range_settings_defaults(&settings);
3069   settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
3070   BLI_task_parallel_range(0, totnode, &data, do_inflate_brush_task_cb_ex, &settings);
3071 }
3072
3073 static void calc_sculpt_plane(
3074     Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode, float r_area_no[3], float r_area_co[3])
3075 {
3076   SculptSession *ss = ob->sculpt;
3077   Brush *brush = BKE_paint_brush(&sd->paint);
3078
3079   if (ss->cache->mirror_symmetry_pass == 0 && ss->cache->radial_symmetry_pass == 0 &&
3080       ss->cache->tile_pass == 0 &&
3081       (ss->cache->first_time || !(brush->flag & BRUSH_ORIGINAL_NORMAL))) {
3082     switch (brush->sculpt_plane) {
3083       case SCULPT_DISP_DIR_VIEW:
3084         copy_v3_v3(r_area_no, ss->cache->true_view_normal);
3085         break;
3086
3087       case SCULPT_DISP_DIR_X:
3088         ARRAY_SET_ITEMS(r_area_no, 1, 0, 0);
3089         break;
3090
3091       case SCULPT_DISP_DIR_Y:
3092         ARRAY_SET_ITEMS(r_area_no, 0, 1, 0);
3093         break;
3094
3095       case SCULPT_DISP_DIR_Z:
3096         ARRAY_SET_ITEMS(r_area_no, 0, 0, 1);
3097         break;
3098
3099       case SCULPT_DISP_DIR_AREA:
3100         calc_area_normal_and_center(sd, ob, nodes, totnode, r_area_no, r_area_co);
3101         if (brush->falloff_shape == PAINT_FALLOFF_SHAPE_TUBE) {
3102           project_plane_v3_v3v3(r_area_no, r_area_no, ss->cache->view_normal);
3103           normalize_v3(r_area_no);
3104         }
3105         break;
3106
3107       default:
3108         break;
3109     }
3110
3111     /* for flatten center */
3112     /* flatten center has not been calculated yet if we are not using the area normal */
3113     if (brush->sculpt_plane != SCULPT_DISP_DIR_AREA) {
3114       calc_area_center(sd, ob, nodes, totnode, r_area_co);
3115     }
3116
3117     /* for area normal */
3118     copy_v3_v3(ss->cache->sculpt_normal, r_area_no);
3119
3120     /* for flatten center */
3121     copy_v3_v3(ss->cache->last_center, r_area_co);
3122   }
3123   else {
3124     /* for area normal */
3125     copy_v3_v3(r_area_no, ss->cache->sculpt_normal);
3126
3127     /* for flatten center */
3128     copy_v3_v3(r_area_co, ss->cache->last_center);
3129
3130     /* for area normal */
3131     flip_v3(r_area_no, ss->cache->mirror_symmetry_pass);
3132
3133     /* for flatten center */
3134     flip_v3(r_area_co, ss->cache->mirror_symmetry_pass);
3135
3136     /* for area normal */
3137     mul_m4_v3(ss->cache->symm_rot_mat, r_area_no);
3138
3139     /* for flatten center */
3140     mul_m4_v3(ss->cache->symm_rot_mat, r_area_co);
3141
3142     /* shift the plane for the current tile */
3143     add_v3_v3(r_area_co, ss->cache->plane_offset);
3144   }
3145 }
3146
3147 static int plane_trim(const StrokeCache *cache, const Brush *brush, const float val[3])
3148 {
3149   return (!(brush->flag & BRUSH_PLANE_TRIM) ||
3150           ((dot_v3v3(val, val) <= cache->radius_squared * cache->plane_trim_squared)));
3151 }
3152
3153 static bool plane_point_side_flip(const float co[3], const float plane[4], const bool flip)
3154 {
3155   float d = plane_point_side_v3(plane, co);
3156   if (flip) {
3157     d = -d;
3158   }
3159   return d <= 0.0f;
3160 }
3161
3162 static int plane_point_side(const float co[3], const float plane[4])
3163 {
3164   float d = plane_point_side_v3(plane, co);
3165   return d <= 0.0f;
3166 }
3167
3168 static float get_offset(Sculpt *sd, SculptSession *ss)
3169 {
3170   Brush *brush = BKE_paint_brush(&sd->paint);
3171
3172   float rv = brush->plane_offset;
3173
3174   if (brush->flag & BRUSH_OFFSET_PRESSURE) {
3175     rv *= ss->cache->pressure;
3176   }
3177
3178   return rv;
3179 }
3180
3181 static void do_flatten_brush_task_cb_ex(void *__restrict userdata,
3182                                         const int n,
3183                                         const ParallelRangeTLS *__restrict tls)
3184 {
3185   SculptThreadedTaskData *data = userdata;
3186   SculptSession *ss = data->ob->sculpt;
3187   const Brush *brush = data->brush;
3188   const float *area_no = data->area_no;
3189   const float *area_co = data->area_co;
3190
3191   PBVHVertexIter vd;
3192   float(*proxy)[3];
3193   const float bstrength = ss->cache->bstrength;
3194
3195   proxy = BKE_pbvh_node_add_proxy(ss->pbvh, data->nodes[n])->co;
3196
3197   SculptBrushTest test;
3198   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
3199       ss, &test, data->brush->falloff_shape);
3200
3201   plane_from_point_normal_v3(test.plane_tool, area_co, area_no);
3202
3203   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
3204   {
3205     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
3206       float intr[3];
3207       float val[3];
3208
3209       closest_to_plane_normalized_v3(intr, test.plane_tool, vd.co);
3210
3211       sub_v3_v3v3(val, intr, vd.co);
3212
3213       if (plane_trim(ss->cache, brush, val)) {
3214         const float fade = bstrength * tex_strength(ss,
3215                                                     brush,
3216                                                     vd.co,
3217                                                     sqrtf(test.dist),
3218                                                     vd.no,
3219                                                     vd.fno,
3220                                                     vd.mask ? *vd.mask : 0.0f,
3221                                                     tls->thread_id);
3222
3223         mul_v3_v3fl(proxy[vd.i], val, fade);
3224
3225         if (vd.mvert) {
3226           vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
3227         }
3228       }
3229     }
3230   }
3231   BKE_pbvh_vertex_iter_end;
3232 }
3233
3234 static void do_flatten_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
3235 {
3236   SculptSession *ss = ob->sculpt;
3237   Brush *brush = BKE_paint_brush(&sd->paint);
3238
3239   const float radius = ss->cache->radius;
3240
3241   float area_no[3];
3242   float area_co[3];
3243
3244   float offset = get_offset(sd, ss);
3245   float displace;
3246   float temp[3];
3247
3248   calc_sculpt_plane(sd, ob, nodes, totnode, area_no, area_co);
3249
3250   displace = radius * offset;
3251
3252   mul_v3_v3v3(temp, area_no, ss->cache->scale);
3253   mul_v3_fl(temp, displace);
3254   add_v3_v3(area_co, temp);
3255
3256   SculptThreadedTaskData data = {
3257       .sd = sd,
3258       .ob = ob,
3259       .brush = brush,
3260       .nodes = nodes,
3261       .area_no = area_no,
3262       .area_co = area_co,
3263   };
3264
3265   ParallelRangeSettings settings;
3266   BLI_parallel_range_settings_defaults(&settings);
3267   settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
3268   BLI_task_parallel_range(0, totnode, &data, do_flatten_brush_task_cb_ex, &settings);
3269 }
3270
3271 static void do_clay_brush_task_cb_ex(void *__restrict userdata,
3272                                      const int n,
3273                                      const ParallelRangeTLS *__restrict tls)
3274 {
3275   SculptThreadedTaskData *data = userdata;
3276   SculptSession *ss = data->ob->sculpt;
3277   const Brush *brush = data->brush;
3278   const float *area_no = data->area_no;
3279   const float *area_co = data->area_co;
3280
3281   PBVHVertexIter vd;
3282   float(*proxy)[3];
3283   const bool flip = (ss->cache->bstrength < 0);
3284   const float bstrength = flip ? -ss->cache->bstrength : ss->cache->bstrength;
3285
3286   proxy = BKE_pbvh_node_add_proxy(ss->pbvh, data->nodes[n])->co;
3287
3288   SculptBrushTest test;
3289   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
3290       ss, &test, data->brush->falloff_shape);
3291
3292   plane_from_point_normal_v3(test.plane_tool, area_co, area_no);
3293
3294   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
3295   {
3296     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
3297       if (plane_point_side_flip(vd.co, test.plane_tool, flip)) {
3298         float intr[3];
3299         float val[3];
3300
3301         closest_to_plane_normalized_v3(intr, test.plane_tool, vd.co);
3302
3303         sub_v3_v3v3(val, intr, vd.co);
3304
3305         if (plane_trim(ss->cache, brush, val)) {
3306           /* note, the normal from the vertices is ignored,
3307            * causes glitch with planes, see: T44390 */
3308           const float fade = bstrength * tex_strength(ss,
3309                                                       brush,
3310                                                       vd.co,
3311                                                       sqrtf(test.dist),
3312                                                       vd.no,
3313                                                       vd.fno,
3314                                                       vd.mask ? *vd.mask : 0.0f,
3315                                                       tls->thread_id);
3316
3317           mul_v3_v3fl(proxy[vd.i], val, fade);
3318
3319           if (vd.mvert) {
3320             vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
3321           }
3322         }
3323       }
3324     }
3325   }
3326   BKE_pbvh_vertex_iter_end;
3327 }
3328
3329 static void do_clay_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
3330 {
3331   SculptSession *ss = ob->sculpt;
3332   Brush *brush = BKE_paint_brush(&sd->paint);
3333
3334   const bool flip = (ss->cache->bstrength < 0);
3335   const float radius = flip ? -ss->cache->radius : ss->cache->radius;
3336
3337   float offset = get_offset(sd, ss);
3338   float displace;
3339
3340   float area_no[3];
3341   float area_co[3];
3342   float temp[3];
3343
3344   calc_sculpt_plane(sd, ob, nodes, totnode, area_no, area_co);
3345
3346   displace = radius * (0.25f + offset);
3347
3348   mul_v3_v3v3(temp, area_no, ss->cache->scale);
3349   mul_v3_fl(temp, displace);
3350   add_v3_v3(area_co, temp);
3351
3352   /* add_v3_v3v3(p, ss->cache->location, area_no); */
3353
3354   SculptThreadedTaskData data = {
3355       .sd = sd,
3356       .ob = ob,
3357       .brush = brush,
3358       .nodes = nodes,
3359       .area_no = area_no,
3360       .area_co = area_co,
3361   };
3362
3363   ParallelRangeSettings settings;
3364   BLI_parallel_range_settings_defaults(&settings);
3365   settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
3366   BLI_task_parallel_range(0, totnode, &data, do_clay_brush_task_cb_ex, &settings);
3367 }
3368
3369 static void do_clay_strips_brush_task_cb_ex(void *__restrict userdata,
3370                                             const int n,
3371                                             const ParallelRangeTLS *__restrict tls)
3372 {
3373   SculptThreadedTaskData *data = userdata;
3374   SculptSession *ss = data->ob->sculpt;
3375   const Brush *brush = data->brush;
3376   float(*mat)[4] = data->mat;
3377   const float *area_no_sp = data->area_no_sp;
3378   const float *area_co = data->area_co;
3379
3380   PBVHVertexIter vd;
3381   SculptBrushTest test;
3382   float(*proxy)[3];
3383   const bool flip = (ss->cache->bstrength < 0);
3384   const float bstrength = flip ? -ss->cache->bstrength : ss->cache->bstrength;
3385
3386   proxy = BKE_pbvh_node_add_proxy(ss->pbvh, data->nodes[n])->co;
3387
3388   sculpt_brush_test_init(ss, &test);
3389   plane_from_point_normal_v3(test.plane_tool, area_co, area_no_sp);
3390
3391   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
3392   {
3393     if (sculpt_brush_test_cube(&test, vd.co, mat)) {
3394       if (plane_point_side_flip(vd.co, test.plane_tool, flip)) {
3395         float intr[3];
3396         float val[3];
3397
3398         closest_to_plane_normalized_v3(intr, test.plane_tool, vd.co);
3399
3400         sub_v3_v3v3(val, intr, vd.co);
3401
3402         if (plane_trim(ss->cache, brush, val)) {
3403           /* note, the normal from the vertices is ignored,
3404            * causes glitch with planes, see: T44390 */
3405           const float fade = bstrength * tex_strength(ss,
3406                                                       brush,
3407                                                       vd.co,
3408                                                       ss->cache->radius * test.dist,
3409                                                       vd.no,
3410                                                       vd.fno,
3411                                                       vd.mask ? *vd.mask : 0.0f,
3412                                                       tls->thread_id);
3413
3414           mul_v3_v3fl(proxy[vd.i], val, fade);
3415
3416           if (vd.mvert) {
3417             vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
3418           }
3419         }
3420       }
3421     }
3422   }
3423   BKE_pbvh_vertex_iter_end;
3424 }
3425
3426 static void do_clay_strips_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
3427 {
3428   SculptSession *ss = ob->sculpt;
3429   Brush *brush = BKE_paint_brush(&sd->paint);
3430
3431   const bool flip = (ss->cache->bstrength < 0);
3432   const float radius = flip ? -ss->cache->radius : ss->cache->radius;
3433   const float offset = get_offset(sd, ss);
3434   const float displace = radius * (0.25f + offset);
3435
3436   float area_no_sp[3]; /* the sculpt-plane normal (whatever its set to) */
3437   float area_no[3];    /* geometry normal */
3438   float area_co[3];
3439
3440   float temp[3];
3441   float mat[4][4];
3442   float scale[4][4];
3443   float tmat[4][4];
3444
3445   calc_sculpt_plane(sd, ob, nodes, totnode, area_no_sp, area_co);
3446
3447   if (brush->sculpt_plane != SCULPT_DISP_DIR_AREA || (brush->flag & BRUSH_ORIGINAL_NORMAL)) {
3448     calc_area_normal(sd, ob, nodes, totnode, area_no);
3449   }
3450   else {
3451     copy_v3_v3(area_no, area_no_sp);
3452   }
3453
3454   /* delay the first daub because grab delta is not setup */
3455   if (ss->cache->first_time) {
3456     return;
3457   }
3458
3459   if (is_zero_v3(ss->cache->grab_delta_symmetry)) {
3460     return;
3461   }
3462
3463   mul_v3_v3v3(temp, area_no_sp, ss->cache->scale);
3464   mul_v3_fl(temp, displace);
3465   add_v3_v3(area_co, temp);
3466
3467   /* init mat */
3468   cross_v3_v3v3(mat[0], area_no, ss->cache->grab_delta_symmetry);
3469   mat[0][3] = 0;
3470   cross_v3_v3v3(mat[1], area_no, mat[0]);
3471   mat[1][3] = 0;
3472   copy_v3_v3(mat[2], area_no);
3473   mat[2][3] = 0;
3474   copy_v3_v3(mat[3], ss->cache->location);
3475   mat[3][3] = 1;
3476   normalize_m4(mat);
3477
3478   /* scale mat */
3479   scale_m4_fl(scale, ss->cache->radius);
3480   mul_m4_m4m4(tmat, mat, scale);
3481   invert_m4_m4(mat, tmat);
3482
3483   SculptThreadedTaskData data = {
3484       .sd = sd,
3485       .ob = ob,
3486       .brush = brush,
3487       .nodes = nodes,
3488       .area_no_sp = area_no_sp,
3489       .area_co = area_co,
3490       .mat = mat,
3491   };
3492
3493   ParallelRangeSettings settings;
3494   BLI_parallel_range_settings_defaults(&settings);
3495   settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
3496   BLI_task_parallel_range(0, totnode, &data, do_clay_strips_brush_task_cb_ex, &settings);
3497 }
3498
3499 static void do_fill_brush_task_cb_ex(void *__restrict userdata,
3500                                      const int n,
3501                                      const ParallelRangeTLS *__restrict tls)
3502 {
3503   SculptThreadedTaskData *data = userdata;
3504   SculptSession *ss = data->ob->sculpt;
3505   const Brush *brush = data->brush;
3506   const float *area_no = data->area_no;
3507   const float *area_co = data->area_co;
3508
3509   PBVHVertexIter vd;
3510   float(*proxy)[3];
3511   const float bstrength = ss->cache->bstrength;
3512
3513   proxy = BKE_pbvh_node_add_proxy(ss->pbvh, data->nodes[n])->co;
3514
3515   SculptBrushTest test;
3516   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
3517       ss, &test, data->brush->falloff_shape);
3518
3519   plane_from_point_normal_v3(test.plane_tool, area_co, area_no);
3520
3521   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
3522   {
3523     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
3524       if (plane_point_side(vd.co, test.plane_tool)) {
3525         float intr[3];
3526         float val[3];
3527
3528         closest_to_plane_normalized_v3(intr, test.plane_tool, vd.co);
3529
3530         sub_v3_v3v3(val, intr, vd.co);
3531
3532         if (plane_trim(ss->cache, brush, val)) {
3533           const float fade = bstrength * tex_strength(ss,
3534                                                       brush,
3535                                                       vd.co,
3536                                                       sqrtf(test.dist),
3537                                                       vd.no,
3538                                                       vd.fno,
3539                                                       vd.mask ? *vd.mask : 0.0f,
3540                                                       tls->thread_id);
3541
3542           mul_v3_v3fl(proxy[vd.i], val, fade);
3543
3544           if (vd.mvert) {
3545             vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
3546           }
3547         }
3548       }
3549     }
3550   }
3551   BKE_pbvh_vertex_iter_end;
3552 }
3553
3554 static void do_fill_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
3555 {
3556   SculptSession *ss = ob->sculpt;
3557   Brush *brush = BKE_paint_brush(&sd->paint);
3558
3559   const float radius = ss->cache->radius;
3560
3561   float area_no[3];
3562   float area_co[3];
3563   float offset = get_offset(sd, ss);
3564
3565   float displace;
3566
3567   float temp[3];
3568
3569   calc_sculpt_plane(sd, ob, nodes, totnode, area_no, area_co);
3570
3571   displace = radius * offset;
3572
3573   mul_v3_v3v3(temp, area_no, ss->cache->scale);
3574   mul_v3_fl(temp, displace);
3575   add_v3_v3(area_co, temp);
3576
3577   SculptThreadedTaskData data = {
3578       .sd = sd,
3579       .ob = ob,
3580       .brush = brush,
3581       .nodes = nodes,
3582       .area_no = area_no,
3583       .area_co = area_co,
3584   };
3585
3586   ParallelRangeSettings settings;
3587   BLI_parallel_range_settings_defaults(&settings);
3588   settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
3589   BLI_task_parallel_range(0, totnode, &data, do_fill_brush_task_cb_ex, &settings);
3590 }
3591
3592 static void do_scrape_brush_task_cb_ex(void *__restrict userdata,
3593                                        const int n,
3594                                        const ParallelRangeTLS *__restrict tls)
3595 {
3596   SculptThreadedTaskData *data = userdata;
3597   SculptSession *ss = data->ob->sculpt;
3598   const Brush *brush = data->brush;
3599   const float *area_no = data->area_no;
3600   const float *area_co = data->area_co;
3601
3602   PBVHVertexIter vd;
3603   float(*proxy)[3];
3604   const float bstrength = ss->cache->bstrength;
3605
3606   proxy = BKE_pbvh_node_add_proxy(ss->pbvh, data->nodes[n])->co;
3607
3608   SculptBrushTest test;
3609   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
3610       ss, &test, data->brush->falloff_shape);
3611   plane_from_point_normal_v3(test.plane_tool, area_co, area_no);
3612
3613   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
3614   {
3615     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
3616       if (!plane_point_side(vd.co, test.plane_tool)) {
3617         float intr[3];
3618         float val[3];
3619
3620         closest_to_plane_normalized_v3(intr, test.plane_tool, vd.co);
3621
3622         sub_v3_v3v3(val, intr, vd.co);
3623
3624         if (plane_trim(ss->cache, brush, val)) {
3625           const float fade = bstrength * tex_strength(ss,
3626                                                       brush,
3627                                                       vd.co,
3628                                                       sqrtf(test.dist),
3629                                &