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