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