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