0c08af2b020643c8dd74520d4039183dd11f70d3
[blender.git] / source / blender / editors / sculpt_paint / paint_vertex.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) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edsculpt
22  *
23  * Used for vertex color & weight paint and mode switching.
24  *
25  * \note This file is already big,
26  * use `paint_vertex_color_ops.c` & `paint_vertex_weight_ops.c` for general purpose operators.
27  */
28
29 #include "MEM_guardedalloc.h"
30
31 #include "BLI_listbase.h"
32 #include "BLI_rect.h"
33 #include "BLI_math.h"
34 #include "BLI_array_utils.h"
35 #include "BLI_task.h"
36
37 #include "DNA_armature_types.h"
38 #include "DNA_mesh_types.h"
39 #include "DNA_particle_types.h"
40 #include "DNA_scene_types.h"
41 #include "DNA_brush_types.h"
42 #include "DNA_object_types.h"
43
44 #include "RNA_access.h"
45 #include "RNA_define.h"
46
47 #include "BKE_brush.h"
48 #include "BKE_context.h"
49 #include "BKE_deform.h"
50 #include "BKE_main.h"
51 #include "BKE_mesh.h"
52 #include "BKE_mesh_mapping.h"
53 #include "BKE_modifier.h"
54 #include "BKE_object.h"
55 #include "BKE_object_deform.h"
56 #include "BKE_paint.h"
57 #include "BKE_report.h"
58 #include "BKE_subsurf.h"
59
60 #include "DEG_depsgraph.h"
61
62 #include "WM_api.h"
63 #include "WM_types.h"
64 #include "WM_message.h"
65 #include "WM_toolsystem.h"
66
67 #include "ED_armature.h"
68 #include "ED_object.h"
69 #include "ED_mesh.h"
70 #include "ED_screen.h"
71 #include "ED_view3d.h"
72
73 /* For IMB_BlendMode only. */
74 #include "IMB_imbuf.h"
75
76 #include "bmesh.h"
77 #include "BKE_ccg.h"
78
79 #include "sculpt_intern.h"
80 #include "paint_intern.h" /* own include */
81
82 /* -------------------------------------------------------------------- */
83 /** \name Internal Utilities
84  * \{ */
85
86 /* Use for 'blur' brush, align with PBVH nodes, created and freed on each update. */
87 struct VPaintAverageAccum {
88   uint len;
89   uint value[3];
90 };
91
92 struct WPaintAverageAccum {
93   uint len;
94   double value;
95 };
96
97 struct NormalAnglePrecalc {
98   bool do_mask_normal;
99   /* what angle to mask at */
100   float angle;
101   /* cos(angle), faster to compare */
102   float angle__cos;
103   float angle_inner;
104   float angle_inner__cos;
105   /* difference between angle and angle_inner, for easy access */
106   float angle_range;
107 };
108
109 static void view_angle_limits_init(struct NormalAnglePrecalc *a, float angle, bool do_mask_normal)
110 {
111   angle = RAD2DEGF(angle);
112   a->do_mask_normal = do_mask_normal;
113   if (do_mask_normal) {
114     a->angle_inner = angle;
115     a->angle = (a->angle_inner + 90.0f) * 0.5f;
116   }
117   else {
118     a->angle_inner = a->angle = angle;
119   }
120
121   a->angle_inner *= (float)(M_PI_2 / 90);
122   a->angle *= (float)(M_PI_2 / 90);
123   a->angle_range = a->angle - a->angle_inner;
124
125   if (a->angle_range <= 0.0f) {
126     a->do_mask_normal = false; /* no need to do blending */
127   }
128
129   a->angle__cos = cosf(a->angle);
130   a->angle_inner__cos = cosf(a->angle_inner);
131 }
132
133 static float view_angle_limits_apply_falloff(const struct NormalAnglePrecalc *a,
134                                              float angle_cos,
135                                              float *mask_p)
136 {
137   if (angle_cos <= a->angle__cos) {
138     /* outsize the normal limit */
139     return false;
140   }
141   else if (angle_cos < a->angle_inner__cos) {
142     *mask_p *= (a->angle - acosf(angle_cos)) / a->angle_range;
143     return true;
144   }
145   else {
146     return true;
147   }
148 }
149
150 static bool vwpaint_use_normal(const VPaint *vp)
151 {
152   return ((vp->paint.brush->flag & BRUSH_FRONTFACE) != 0) ||
153          ((vp->paint.brush->flag & BRUSH_FRONTFACE_FALLOFF) != 0);
154 }
155
156 static bool brush_use_accumulate_ex(const Brush *brush, const int ob_mode)
157 {
158   return ((brush->flag & BRUSH_ACCUMULATE) != 0 ||
159           (ob_mode == OB_MODE_VERTEX_PAINT ? (brush->vertexpaint_tool == VPAINT_TOOL_SMEAR) :
160                                              (brush->weightpaint_tool == WPAINT_TOOL_SMEAR)));
161 }
162
163 static bool brush_use_accumulate(const VPaint *vp)
164 {
165   return brush_use_accumulate_ex(vp->paint.brush, vp->paint.runtime.ob_mode);
166 }
167
168 static MDeformVert *defweight_prev_init(MDeformVert *dvert_prev,
169                                         MDeformVert *dvert_curr,
170                                         int index)
171 {
172   MDeformVert *dv_curr = &dvert_curr[index];
173   MDeformVert *dv_prev = &dvert_prev[index];
174   if (dv_prev->flag == 1) {
175     dv_prev->flag = 0;
176     defvert_copy(dv_prev, dv_curr);
177   }
178   return dv_prev;
179 }
180
181 /* check if we can do partial updates and have them draw realtime
182  * (without evaluating modifiers) */
183 static bool vertex_paint_use_fast_update_check(Object *ob)
184 {
185   Mesh *me_eval = ob->runtime.mesh_eval;
186
187   if (me_eval != NULL) {
188     Mesh *me = BKE_mesh_from_object(ob);
189     if (me && me->mloopcol) {
190       return (me->mloopcol == CustomData_get_layer(&me_eval->ldata, CD_MLOOPCOL));
191     }
192   }
193
194   return false;
195 }
196
197 static void paint_last_stroke_update(Scene *scene, ARegion *ar, const float mval[2])
198 {
199   const int mval_i[2] = {mval[0], mval[1]};
200   float world[3];
201
202   if (ED_view3d_autodist_simple(ar, mval_i, world, 0, NULL)) {
203     UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
204     ups->average_stroke_counter++;
205     add_v3_v3(ups->average_stroke_accum, world);
206     ups->last_stroke_valid = true;
207   }
208 }
209
210 /* polling - retrieve whether cursor should be set or operator should be done */
211
212 /* Returns true if vertex paint mode is active */
213 bool vertex_paint_mode_poll(bContext *C)
214 {
215   Object *ob = CTX_data_active_object(C);
216
217   return ob && ob->mode == OB_MODE_VERTEX_PAINT && ((Mesh *)ob->data)->totpoly;
218 }
219
220 static bool vertex_paint_poll_ex(bContext *C, bool check_tool)
221 {
222   if (vertex_paint_mode_poll(C) && BKE_paint_brush(&CTX_data_tool_settings(C)->vpaint->paint)) {
223     ScrArea *sa = CTX_wm_area(C);
224     if (sa && sa->spacetype == SPACE_VIEW3D) {
225       ARegion *ar = CTX_wm_region(C);
226       if (ar->regiontype == RGN_TYPE_WINDOW) {
227         if (!check_tool || WM_toolsystem_active_tool_is_brush(C)) {
228           return 1;
229         }
230       }
231     }
232   }
233   return 0;
234 }
235
236 bool vertex_paint_poll(bContext *C)
237 {
238   return vertex_paint_poll_ex(C, true);
239 }
240
241 bool vertex_paint_poll_ignore_tool(bContext *C)
242 {
243   return vertex_paint_poll_ex(C, false);
244 }
245
246 bool weight_paint_mode_poll(bContext *C)
247 {
248   Object *ob = CTX_data_active_object(C);
249
250   return ob && ob->mode == OB_MODE_WEIGHT_PAINT && ((Mesh *)ob->data)->totpoly;
251 }
252
253 static bool weight_paint_poll_ex(bContext *C, bool check_tool)
254 {
255   Object *ob = CTX_data_active_object(C);
256   ScrArea *sa;
257
258   if ((ob != NULL) && (ob->mode & OB_MODE_WEIGHT_PAINT) &&
259       (BKE_paint_brush(&CTX_data_tool_settings(C)->wpaint->paint) != NULL) &&
260       (sa = CTX_wm_area(C)) && (sa->spacetype == SPACE_VIEW3D)) {
261     ARegion *ar = CTX_wm_region(C);
262     if (ar->regiontype == RGN_TYPE_WINDOW) {
263       if (!check_tool || WM_toolsystem_active_tool_is_brush(C)) {
264         return 1;
265       }
266     }
267   }
268   return 0;
269 }
270
271 bool weight_paint_poll(bContext *C)
272 {
273   return weight_paint_poll_ex(C, true);
274 }
275
276 bool weight_paint_poll_ignore_tool(bContext *C)
277 {
278   return weight_paint_poll_ex(C, false);
279 }
280
281 uint vpaint_get_current_col(Scene *scene, VPaint *vp, bool secondary)
282 {
283   Brush *brush = BKE_paint_brush(&vp->paint);
284   uchar col[4];
285   rgb_float_to_uchar(col,
286                      secondary ? BKE_brush_secondary_color_get(scene, brush) :
287                                  BKE_brush_color_get(scene, brush));
288   col[3] = 255; /* alpha isn't used, could even be removed to speedup paint a little */
289   return *(uint *)col;
290 }
291
292 /* wpaint has 'wpaint_blend' */
293 static uint vpaint_blend(const VPaint *vp,
294                          uint color_curr,
295                          uint color_orig,
296                          uint color_paint,
297                          const int alpha_i,
298                          /* pre scaled from [0-1] --> [0-255] */
299                          const int brush_alpha_value_i)
300 {
301   const Brush *brush = vp->paint.brush;
302   const IMB_BlendMode blend = brush->blend;
303
304   uint color_blend = ED_vpaint_blend_tool(blend, color_curr, color_paint, alpha_i);
305
306   /* if no accumulate, clip color adding with colorig & orig alpha */
307   if (!brush_use_accumulate(vp)) {
308     uint color_test, a;
309     char *cp, *ct, *co;
310
311     color_test = ED_vpaint_blend_tool(blend, color_orig, color_paint, brush_alpha_value_i);
312
313     cp = (char *)&color_blend;
314     ct = (char *)&color_test;
315     co = (char *)&color_orig;
316
317     for (a = 0; a < 4; a++) {
318       if (ct[a] < co[a]) {
319         if (cp[a] < ct[a]) {
320           cp[a] = ct[a];
321         }
322         else if (cp[a] > co[a]) {
323           cp[a] = co[a];
324         }
325       }
326       else {
327         if (cp[a] < co[a]) {
328           cp[a] = co[a];
329         }
330         else if (cp[a] > ct[a]) {
331           cp[a] = ct[a];
332         }
333       }
334     }
335   }
336
337   if ((brush->flag & BRUSH_LOCK_ALPHA) &&
338       !ELEM(blend, IMB_BLEND_ERASE_ALPHA, IMB_BLEND_ADD_ALPHA)) {
339     char *cp, *cc;
340     cp = (char *)&color_blend;
341     cc = (char *)&color_curr;
342     cp[3] = cc[3];
343   }
344
345   return color_blend;
346 }
347
348 static void tex_color_alpha(VPaint *vp, const ViewContext *vc, const float co[3], float r_rgba[4])
349 {
350   const Brush *brush = BKE_paint_brush(&vp->paint);
351   BLI_assert(brush->mtex.tex != NULL);
352   if (brush->mtex.brush_map_mode == MTEX_MAP_MODE_3D) {
353     BKE_brush_sample_tex_3d(vc->scene, brush, co, r_rgba, 0, NULL);
354   }
355   else {
356     float co_ss[2]; /* screenspace */
357     if (ED_view3d_project_float_object(
358             vc->ar, co, co_ss, V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_NEAR) ==
359         V3D_PROJ_RET_OK) {
360       const float co_ss_3d[3] = {co_ss[0], co_ss[1], 0.0f}; /* we need a 3rd empty value */
361       BKE_brush_sample_tex_3d(vc->scene, brush, co_ss_3d, r_rgba, 0, NULL);
362     }
363     else {
364       zero_v4(r_rgba);
365     }
366   }
367 }
368
369 /* vpaint has 'vpaint_blend' */
370 static float wpaint_blend(const VPaint *wp,
371                           float weight,
372                           const float alpha,
373                           float paintval,
374                           const float UNUSED(brush_alpha_value),
375                           const short do_flip)
376 {
377   const Brush *brush = wp->paint.brush;
378   IMB_BlendMode blend = brush->blend;
379
380   if (do_flip) {
381     switch (blend) {
382       case IMB_BLEND_MIX:
383         paintval = 1.f - paintval;
384         break;
385       case IMB_BLEND_ADD:
386         blend = IMB_BLEND_SUB;
387         break;
388       case IMB_BLEND_SUB:
389         blend = IMB_BLEND_ADD;
390         break;
391       case IMB_BLEND_LIGHTEN:
392         blend = IMB_BLEND_DARKEN;
393         break;
394       case IMB_BLEND_DARKEN:
395         blend = IMB_BLEND_LIGHTEN;
396         break;
397       default:
398         break;
399     }
400   }
401
402   weight = ED_wpaint_blend_tool(blend, weight, paintval, alpha);
403
404   CLAMP(weight, 0.0f, 1.0f);
405
406   return weight;
407 }
408
409 static float wpaint_clamp_monotonic(float oldval, float curval, float newval)
410 {
411   if (newval < oldval) {
412     return MIN2(newval, curval);
413   }
414   else if (newval > oldval) {
415     return MAX2(newval, curval);
416   }
417   else {
418     return newval;
419   }
420 }
421
422 /* ----------------------------------------------------- */
423
424 static void do_weight_paint_normalize_all(MDeformVert *dvert,
425                                           const int defbase_tot,
426                                           const bool *vgroup_validmap)
427 {
428   float sum = 0.0f, fac;
429   uint i, tot = 0;
430   MDeformWeight *dw;
431
432   for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
433     if (dw->def_nr < defbase_tot && vgroup_validmap[dw->def_nr]) {
434       tot++;
435       sum += dw->weight;
436     }
437   }
438
439   if ((tot == 0) || (sum == 1.0f)) {
440     return;
441   }
442
443   if (sum != 0.0f) {
444     fac = 1.0f / sum;
445
446     for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
447       if (dw->def_nr < defbase_tot && vgroup_validmap[dw->def_nr]) {
448         dw->weight *= fac;
449       }
450     }
451   }
452   else {
453     /* hrmf, not a factor in this case */
454     fac = 1.0f / tot;
455
456     for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
457       if (dw->def_nr < defbase_tot && vgroup_validmap[dw->def_nr]) {
458         dw->weight = fac;
459       }
460     }
461   }
462 }
463
464 /**
465  * A version of #do_weight_paint_normalize_all that includes locked weights
466  * but only changes unlocked weights.
467  */
468 static bool do_weight_paint_normalize_all_locked(MDeformVert *dvert,
469                                                  const int defbase_tot,
470                                                  const bool *vgroup_validmap,
471                                                  const bool *lock_flags)
472 {
473   float sum = 0.0f, fac;
474   float sum_unlock = 0.0f;
475   float lock_weight = 0.0f;
476   uint i, tot = 0;
477   MDeformWeight *dw;
478
479   if (lock_flags == NULL) {
480     do_weight_paint_normalize_all(dvert, defbase_tot, vgroup_validmap);
481     return true;
482   }
483
484   for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
485     if (dw->def_nr < defbase_tot && vgroup_validmap[dw->def_nr]) {
486       sum += dw->weight;
487
488       if (lock_flags[dw->def_nr]) {
489         lock_weight += dw->weight;
490       }
491       else {
492         tot++;
493         sum_unlock += dw->weight;
494       }
495     }
496   }
497
498   if (sum == 1.0f) {
499     return true;
500   }
501
502   if (tot == 0) {
503     return false;
504   }
505
506   if (lock_weight >= 1.0f) {
507     /* locked groups make it impossible to fully normalize,
508      * zero out what we can and return false */
509     for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
510       if (dw->def_nr < defbase_tot && vgroup_validmap[dw->def_nr]) {
511         if (lock_flags[dw->def_nr] == false) {
512           dw->weight = 0.0f;
513         }
514       }
515     }
516
517     return (lock_weight == 1.0f);
518   }
519   else if (sum_unlock != 0.0f) {
520     fac = (1.0f - lock_weight) / sum_unlock;
521
522     for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
523       if (dw->def_nr < defbase_tot && vgroup_validmap[dw->def_nr]) {
524         if (lock_flags[dw->def_nr] == false) {
525           dw->weight *= fac;
526           /* paranoid but possibly with float error */
527           CLAMP(dw->weight, 0.0f, 1.0f);
528         }
529       }
530     }
531   }
532   else {
533     /* hrmf, not a factor in this case */
534     fac = (1.0f - lock_weight) / tot;
535     /* paranoid but possibly with float error */
536     CLAMP(fac, 0.0f, 1.0f);
537
538     for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
539       if (dw->def_nr < defbase_tot && vgroup_validmap[dw->def_nr]) {
540         if (lock_flags[dw->def_nr] == false) {
541           dw->weight = fac;
542         }
543       }
544     }
545   }
546
547   return true;
548 }
549
550 /**
551  * \note same as function above except it does a second pass without active group
552  * if normalize fails with it.
553  */
554 static void do_weight_paint_normalize_all_locked_try_active(MDeformVert *dvert,
555                                                             const int defbase_tot,
556                                                             const bool *vgroup_validmap,
557                                                             const bool *lock_flags,
558                                                             const bool *lock_with_active)
559 {
560   /* first pass with both active and explicitly locked groups restricted from change */
561
562   bool success = do_weight_paint_normalize_all_locked(
563       dvert, defbase_tot, vgroup_validmap, lock_with_active);
564
565   if (!success) {
566     /**
567      * Locks prevented the first pass from full completion,
568      * so remove restriction on active group; e.g:
569      *
570      * - With 1.0 weight painted into active:
571      *   nonzero locked weight; first pass zeroed out unlocked weight; scale 1 down to fit.
572      * - With 0.0 weight painted into active:
573      *   no unlocked groups; first pass did nothing; increase 0 to fit.
574      */
575     do_weight_paint_normalize_all_locked(dvert, defbase_tot, vgroup_validmap, lock_flags);
576   }
577 }
578
579 #if 0 /* UNUSED */
580 static bool has_unselected_unlocked_bone_group(int defbase_tot,
581                                                bool *defbase_sel,
582                                                int selected,
583                                                const bool *lock_flags,
584                                                const bool *vgroup_validmap)
585 {
586   int i;
587   if (defbase_tot == selected) {
588     return false;
589   }
590   for (i = 0; i < defbase_tot; i++) {
591     if (vgroup_validmap[i] && !defbase_sel[i] && !lock_flags[i]) {
592       return true;
593     }
594   }
595   return false;
596 }
597 #endif
598
599 static void multipaint_clamp_change(MDeformVert *dvert,
600                                     const int defbase_tot,
601                                     const bool *defbase_sel,
602                                     float *change_p)
603 {
604   int i;
605   MDeformWeight *dw;
606   float val;
607   float change = *change_p;
608
609   /* verify that the change does not cause values exceeding 1 and clamp it */
610   for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
611     if (dw->def_nr < defbase_tot && defbase_sel[dw->def_nr]) {
612       if (dw->weight) {
613         val = dw->weight * change;
614         if (val > 1) {
615           change = 1.0f / dw->weight;
616         }
617       }
618     }
619   }
620
621   *change_p = change;
622 }
623
624 static bool multipaint_verify_change(MDeformVert *dvert,
625                                      const int defbase_tot,
626                                      float change,
627                                      const bool *defbase_sel)
628 {
629   int i;
630   MDeformWeight *dw;
631   float val;
632
633   /* in case the change is reduced, you need to recheck
634    * the earlier values to make sure they are not 0
635    * (precision error) */
636   for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
637     if (dw->def_nr < defbase_tot && defbase_sel[dw->def_nr]) {
638       if (dw->weight) {
639         val = dw->weight * change;
640         /* the value should never reach zero while multi-painting if it
641          * was nonzero beforehand */
642         if (val <= 0) {
643           return false;
644         }
645       }
646     }
647   }
648
649   return true;
650 }
651
652 static void multipaint_apply_change(MDeformVert *dvert,
653                                     const int defbase_tot,
654                                     float change,
655                                     const bool *defbase_sel)
656 {
657   int i;
658   MDeformWeight *dw;
659
660   /* apply the valid change */
661   for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
662     if (dw->def_nr < defbase_tot && defbase_sel[dw->def_nr]) {
663       if (dw->weight) {
664         dw->weight = dw->weight * change;
665         CLAMP(dw->weight, 0.0f, 1.0f);
666       }
667     }
668   }
669 }
670
671 /**
672  * Variables stored both for 'active' and 'mirror' sides.
673  */
674 struct WeightPaintGroupData {
675   /** index of active group or its mirror
676    *
677    * - 'active' is always `ob->actdef`.
678    * - 'mirror' is -1 when 'ME_EDIT_MIRROR_X' flag id disabled,
679    *   otherwise this will be set to the mirror or the active group (if the group isn't mirrored).
680    */
681   int index;
682   /** lock that includes the 'index' as locked too
683    *
684    * - 'active' is set of locked or active/selected groups
685    * - 'mirror' is set of locked or mirror groups
686    */
687   const bool *lock;
688 };
689
690 /* struct to avoid passing many args each call to do_weight_paint_vertex()
691  * this _could_ be made a part of the operators 'WPaintData' struct, or at
692  * least a member, but for now keep its own struct, initialized on every
693  * paint stroke update - campbell */
694 typedef struct WeightPaintInfo {
695
696   int defbase_tot;
697
698   /* both must add up to 'defbase_tot' */
699   int defbase_tot_sel;
700   int defbase_tot_unsel;
701
702   struct WeightPaintGroupData active, mirror;
703
704   /* boolean array for locked bones,
705    * length of defbase_tot */
706   const bool *lock_flags;
707   /* boolean array for selected bones,
708    * length of defbase_tot, cant be const because of how its passed */
709   const bool *defbase_sel;
710   /* same as WeightPaintData.vgroup_validmap,
711    * only added here for convenience */
712   const bool *vgroup_validmap;
713
714   bool do_flip;
715   bool do_multipaint;
716   bool do_auto_normalize;
717
718   float brush_alpha_value; /* result of BKE_brush_alpha_get() */
719 } WeightPaintInfo;
720
721 static void do_weight_paint_vertex_single(
722     /* vars which remain the same for every vert */
723     const VPaint *wp,
724     Object *ob,
725     const WeightPaintInfo *wpi,
726     /* vars which change on each stroke */
727     const uint index,
728     float alpha,
729     float paintweight)
730 {
731   Mesh *me = ob->data;
732   MDeformVert *dv = &me->dvert[index];
733   bool topology = (me->editflag & ME_EDIT_MIRROR_TOPO) != 0;
734
735   MDeformWeight *dw;
736   float weight_prev;
737
738   /* mirror vars */
739   int index_mirr;
740   int vgroup_mirr;
741
742   MDeformVert *dv_mirr;
743   MDeformWeight *dw_mirr;
744
745   /* from now on we can check if mirrors enabled if this var is -1 and not bother with the flag */
746   if (me->editflag & ME_EDIT_MIRROR_X) {
747     index_mirr = mesh_get_x_mirror_vert(ob, NULL, index, topology);
748     vgroup_mirr = wpi->mirror.index;
749
750     /* another possible error - mirror group _and_ active group are the same (which is fine),
751      * but we also are painting onto a center vertex - this would paint the same weight twice */
752     if (index_mirr == index && vgroup_mirr == wpi->active.index) {
753       index_mirr = vgroup_mirr = -1;
754     }
755   }
756   else {
757     index_mirr = vgroup_mirr = -1;
758   }
759
760   if (wp->flag & VP_FLAG_VGROUP_RESTRICT) {
761     dw = defvert_find_index(dv, wpi->active.index);
762   }
763   else {
764     dw = defvert_verify_index(dv, wpi->active.index);
765   }
766
767   if (dw == NULL) {
768     return;
769   }
770
771   /* get the mirror def vars */
772   if (index_mirr != -1) {
773     dv_mirr = &me->dvert[index_mirr];
774     if (wp->flag & VP_FLAG_VGROUP_RESTRICT) {
775       dw_mirr = defvert_find_index(dv_mirr, vgroup_mirr);
776
777       if (dw_mirr == NULL) {
778         index_mirr = vgroup_mirr = -1;
779         dv_mirr = NULL;
780       }
781     }
782     else {
783       if (index != index_mirr) {
784         dw_mirr = defvert_verify_index(dv_mirr, vgroup_mirr);
785       }
786       else {
787         /* dv and dv_mirr are the same */
788         int totweight_prev = dv_mirr->totweight;
789         int dw_offset = (int)(dw - dv_mirr->dw);
790         dw_mirr = defvert_verify_index(dv_mirr, vgroup_mirr);
791
792         /* if we added another, get our old one back */
793         if (totweight_prev != dv_mirr->totweight) {
794           dw = &dv_mirr->dw[dw_offset];
795         }
796       }
797     }
798   }
799   else {
800     dv_mirr = NULL;
801     dw_mirr = NULL;
802   }
803
804   if (!brush_use_accumulate(wp)) {
805     MDeformVert *dvert_prev = ob->sculpt->mode.wpaint.dvert_prev;
806     MDeformVert *dv_prev = defweight_prev_init(dvert_prev, me->dvert, index);
807     if (index_mirr != -1) {
808       defweight_prev_init(dvert_prev, me->dvert, index_mirr);
809     }
810
811     weight_prev = defvert_find_weight(dv_prev, wpi->active.index);
812   }
813   else {
814     weight_prev = dw->weight;
815   }
816
817   /* If there are no normalize-locks or multipaint,
818    * then there is no need to run the more complicated checks */
819
820   {
821     float new_weight = wpaint_blend(
822         wp, weight_prev, alpha, paintweight, wpi->brush_alpha_value, wpi->do_flip);
823
824     dw->weight = wpaint_clamp_monotonic(weight_prev, dw->weight, new_weight);
825
826     /* WATCH IT: take care of the ordering of applying mirror -> normalize,
827      * can give wrong results [#26193], least confusing if normalize is done last */
828
829     /* apply mirror */
830     if (index_mirr != -1) {
831       /* copy, not paint again */
832       dw_mirr->weight = dw->weight;
833     }
834
835     /* apply normalize */
836     if (wpi->do_auto_normalize) {
837       /* note on normalize - this used to be applied after painting and normalize all weights,
838        * in some ways this is good because there is feedback where the more weights involved would
839        * 'resist' so you couldn't instantly zero out other weights by painting 1.0 on the active.
840        *
841        * However this gave a problem since applying mirror, then normalize both verts
842        * the resulting weight wont match on both sides.
843        *
844        * If this 'resisting', slower normalize is nicer, we could call
845        * do_weight_paint_normalize_all() and only use...
846        * do_weight_paint_normalize_all_active() when normalizing the mirror vertex.
847        * - campbell
848        */
849       do_weight_paint_normalize_all_locked_try_active(
850           dv, wpi->defbase_tot, wpi->vgroup_validmap, wpi->lock_flags, wpi->active.lock);
851
852       if (index_mirr != -1) {
853         /* only normalize if this is not a center vertex,
854          * else we get a conflict, normalizing twice */
855         if (index != index_mirr) {
856           do_weight_paint_normalize_all_locked_try_active(
857               dv_mirr, wpi->defbase_tot, wpi->vgroup_validmap, wpi->lock_flags, wpi->mirror.lock);
858         }
859         else {
860           /* This case accounts for:
861            * - Painting onto a center vertex of a mesh.
862            * - X-mirror is enabled.
863            * - Auto normalize is enabled.
864            * - The group you are painting onto has a L / R version.
865            *
866            * We want L/R vgroups to have the same weight but this cant be if both are over 0.5,
867            * We _could_ have special check for that, but this would need its own
868            * normalize function which holds 2 groups from changing at once.
869            *
870            * So! just balance out the 2 weights, it keeps them equal and everything normalized.
871            *
872            * While it wont hit the desired weight immediately as the user waggles their mouse,
873            * constant painting and re-normalizing will get there. this is also just simpler logic.
874            * - campbell */
875           dw_mirr->weight = dw->weight = (dw_mirr->weight + dw->weight) * 0.5f;
876         }
877       }
878     }
879   }
880 }
881
882 static void do_weight_paint_vertex_multi(
883     /* vars which remain the same for every vert */
884     const VPaint *wp,
885     Object *ob,
886     const WeightPaintInfo *wpi,
887     /* vars which change on each stroke */
888     const uint index,
889     float alpha,
890     float paintweight)
891 {
892   Mesh *me = ob->data;
893   MDeformVert *dv = &me->dvert[index];
894   bool topology = (me->editflag & ME_EDIT_MIRROR_TOPO) != 0;
895
896   /* mirror vars */
897   int index_mirr = -1;
898   MDeformVert *dv_mirr = NULL;
899
900   /* weights */
901   float curw, oldw, neww, change, curw_mirr, change_mirr;
902
903   /* from now on we can check if mirrors enabled if this var is -1 and not bother with the flag */
904   if (me->editflag & ME_EDIT_MIRROR_X) {
905     index_mirr = mesh_get_x_mirror_vert(ob, NULL, index, topology);
906
907     if (index_mirr != -1 && index_mirr != index) {
908       dv_mirr = &me->dvert[index_mirr];
909     }
910     else {
911       index_mirr = -1;
912     }
913   }
914
915   /* compute weight change by applying the brush to average or sum of group weights */
916   curw = BKE_defvert_multipaint_collective_weight(
917       dv, wpi->defbase_tot, wpi->defbase_sel, wpi->defbase_tot_sel, wpi->do_auto_normalize);
918
919   if (curw == 0.0f) {
920     /* note: no weight to assign to this vertex, could add all groups? */
921     return;
922   }
923
924   if (!brush_use_accumulate(wp)) {
925     MDeformVert *dvert_prev = ob->sculpt->mode.wpaint.dvert_prev;
926     MDeformVert *dv_prev = defweight_prev_init(dvert_prev, me->dvert, index);
927     if (index_mirr != -1) {
928       defweight_prev_init(dvert_prev, me->dvert, index_mirr);
929     }
930
931     oldw = BKE_defvert_multipaint_collective_weight(
932         dv_prev, wpi->defbase_tot, wpi->defbase_sel, wpi->defbase_tot_sel, wpi->do_auto_normalize);
933   }
934   else {
935     oldw = curw;
936   }
937
938   neww = wpaint_blend(wp, oldw, alpha, paintweight, wpi->brush_alpha_value, wpi->do_flip);
939   neww = wpaint_clamp_monotonic(oldw, curw, neww);
940
941   change = neww / curw;
942
943   /* verify for all groups that 0 < result <= 1 */
944   multipaint_clamp_change(dv, wpi->defbase_tot, wpi->defbase_sel, &change);
945
946   if (dv_mirr != NULL) {
947     curw_mirr = BKE_defvert_multipaint_collective_weight(
948         dv_mirr, wpi->defbase_tot, wpi->defbase_sel, wpi->defbase_tot_sel, wpi->do_auto_normalize);
949
950     if (curw_mirr == 0.0f) {
951       /* can't mirror into a zero weight vertex */
952       dv_mirr = NULL;
953     }
954     else {
955       /* mirror is changed to achieve the same collective weight value */
956       float orig = change_mirr = curw * change / curw_mirr;
957
958       multipaint_clamp_change(dv_mirr, wpi->defbase_tot, wpi->defbase_sel, &change_mirr);
959
960       if (!multipaint_verify_change(dv_mirr, wpi->defbase_tot, change_mirr, wpi->defbase_sel)) {
961         return;
962       }
963
964       change *= change_mirr / orig;
965     }
966   }
967
968   if (!multipaint_verify_change(dv, wpi->defbase_tot, change, wpi->defbase_sel)) {
969     return;
970   }
971
972   /* apply validated change to vertex and mirror */
973   multipaint_apply_change(dv, wpi->defbase_tot, change, wpi->defbase_sel);
974
975   if (dv_mirr != NULL) {
976     multipaint_apply_change(dv_mirr, wpi->defbase_tot, change_mirr, wpi->defbase_sel);
977   }
978
979   /* normalize */
980   if (wpi->do_auto_normalize) {
981     do_weight_paint_normalize_all_locked_try_active(
982         dv, wpi->defbase_tot, wpi->vgroup_validmap, wpi->lock_flags, wpi->active.lock);
983
984     if (dv_mirr != NULL) {
985       do_weight_paint_normalize_all_locked_try_active(
986           dv_mirr, wpi->defbase_tot, wpi->vgroup_validmap, wpi->lock_flags, wpi->active.lock);
987     }
988   }
989 }
990
991 static void do_weight_paint_vertex(
992     /* vars which remain the same for every vert */
993     const VPaint *wp,
994     Object *ob,
995     const WeightPaintInfo *wpi,
996     /* vars which change on each stroke */
997     const uint index,
998     float alpha,
999     float paintweight)
1000 {
1001   if (wpi->do_multipaint) {
1002     do_weight_paint_vertex_multi(wp, ob, wpi, index, alpha, paintweight);
1003   }
1004   else {
1005     do_weight_paint_vertex_single(wp, ob, wpi, index, alpha, paintweight);
1006   }
1007 }
1008
1009 /* Toggle operator for turning vertex paint mode on or off (copied from sculpt.c) */
1010 static void vertex_paint_init_session(Depsgraph *depsgraph,
1011                                       Scene *scene,
1012                                       Object *ob,
1013                                       eObjectMode object_mode)
1014 {
1015   /* Create persistent sculpt mode data */
1016   BKE_sculpt_toolsettings_data_ensure(scene);
1017
1018   BLI_assert(ob->sculpt == NULL);
1019   ob->sculpt = MEM_callocN(sizeof(SculptSession), "sculpt session");
1020   ob->sculpt->mode_type = object_mode;
1021   BKE_sculpt_update_object_for_edit(depsgraph, ob, false, false);
1022 }
1023
1024 static void vertex_paint_init_stroke(Depsgraph *depsgraph, Object *ob)
1025 {
1026   BKE_sculpt_update_object_for_edit(depsgraph, ob, false, false);
1027 }
1028
1029 static void vertex_paint_init_session_data(const ToolSettings *ts, Object *ob)
1030 {
1031   /* Create maps */
1032   struct SculptVertexPaintGeomMap *gmap = NULL;
1033   if (ob->mode == OB_MODE_VERTEX_PAINT) {
1034     gmap = &ob->sculpt->mode.vpaint.gmap;
1035     BLI_assert(ob->sculpt->mode_type == OB_MODE_VERTEX_PAINT);
1036   }
1037   else if (ob->mode == OB_MODE_WEIGHT_PAINT) {
1038     gmap = &ob->sculpt->mode.wpaint.gmap;
1039     BLI_assert(ob->sculpt->mode_type == OB_MODE_WEIGHT_PAINT);
1040   }
1041   else {
1042     ob->sculpt->mode_type = 0;
1043     BLI_assert(0);
1044     return;
1045   }
1046
1047   Mesh *me = ob->data;
1048
1049   if (gmap->vert_to_loop == NULL) {
1050     gmap->vert_map_mem = NULL;
1051     gmap->vert_to_loop = NULL;
1052     gmap->poly_map_mem = NULL;
1053     gmap->vert_to_poly = NULL;
1054     BKE_mesh_vert_loop_map_create(&gmap->vert_to_loop,
1055                                   &gmap->vert_map_mem,
1056                                   me->mpoly,
1057                                   me->mloop,
1058                                   me->totvert,
1059                                   me->totpoly,
1060                                   me->totloop);
1061     BKE_mesh_vert_poly_map_create(&gmap->vert_to_poly,
1062                                   &gmap->poly_map_mem,
1063                                   me->mpoly,
1064                                   me->mloop,
1065                                   me->totvert,
1066                                   me->totpoly,
1067                                   me->totloop);
1068   }
1069
1070   /* Create average brush arrays */
1071   if (ob->mode == OB_MODE_VERTEX_PAINT) {
1072     if (!brush_use_accumulate(ts->vpaint)) {
1073       if (ob->sculpt->mode.vpaint.previous_color == NULL) {
1074         ob->sculpt->mode.vpaint.previous_color = MEM_callocN(me->totloop * sizeof(uint), __func__);
1075       }
1076     }
1077     else {
1078       MEM_SAFE_FREE(ob->sculpt->mode.vpaint.previous_color);
1079     }
1080   }
1081   else if (ob->mode == OB_MODE_WEIGHT_PAINT) {
1082     if (!brush_use_accumulate(ts->wpaint)) {
1083       if (ob->sculpt->mode.wpaint.alpha_weight == NULL) {
1084         ob->sculpt->mode.wpaint.alpha_weight = MEM_callocN(me->totvert * sizeof(float), __func__);
1085       }
1086       if (ob->sculpt->mode.wpaint.dvert_prev == NULL) {
1087         ob->sculpt->mode.wpaint.dvert_prev = MEM_callocN(me->totvert * sizeof(MDeformVert),
1088                                                          __func__);
1089         MDeformVert *dv = ob->sculpt->mode.wpaint.dvert_prev;
1090         for (int i = 0; i < me->totvert; i++, dv++) {
1091           /* Use to show this isn't initialized, never apply to the mesh data. */
1092           dv->flag = 1;
1093         }
1094       }
1095     }
1096     else {
1097       MEM_SAFE_FREE(ob->sculpt->mode.wpaint.alpha_weight);
1098       if (ob->sculpt->mode.wpaint.dvert_prev != NULL) {
1099         BKE_defvert_array_free_elems(ob->sculpt->mode.wpaint.dvert_prev, me->totvert);
1100         MEM_freeN(ob->sculpt->mode.wpaint.dvert_prev);
1101         ob->sculpt->mode.wpaint.dvert_prev = NULL;
1102       }
1103     }
1104   }
1105 }
1106
1107 /** \} */
1108
1109 /* -------------------------------------------------------------------- */
1110 /** \name Enter Vertex/Weight Paint Mode
1111  * \{ */
1112
1113 static void ed_vwpaintmode_enter_generic(Main *bmain,
1114                                          Depsgraph *depsgraph,
1115                                          wmWindowManager *wm,
1116                                          Scene *scene,
1117                                          Object *ob,
1118                                          const eObjectMode mode_flag)
1119 {
1120   ob->mode |= mode_flag;
1121   Mesh *me = BKE_mesh_from_object(ob);
1122
1123   /* Same as sculpt mode, make sure we don't have cached derived mesh which
1124    * points to freed arrays.
1125    */
1126   BKE_object_free_derived_caches(ob);
1127
1128   if (mode_flag == OB_MODE_VERTEX_PAINT) {
1129     const ePaintMode paint_mode = PAINT_MODE_VERTEX;
1130     ED_mesh_color_ensure(me, NULL);
1131
1132     BKE_paint_ensure(scene->toolsettings, (Paint **)&scene->toolsettings->vpaint);
1133     Paint *paint = BKE_paint_get_active_from_paintmode(scene, paint_mode);
1134     paint_cursor_start_explicit(paint, wm, vertex_paint_poll);
1135     BKE_paint_init(bmain, scene, paint_mode, PAINT_CURSOR_VERTEX_PAINT);
1136   }
1137   else if (mode_flag == OB_MODE_WEIGHT_PAINT) {
1138     const ePaintMode paint_mode = PAINT_MODE_WEIGHT;
1139
1140     BKE_paint_ensure(scene->toolsettings, (Paint **)&scene->toolsettings->wpaint);
1141     Paint *paint = BKE_paint_get_active_from_paintmode(scene, paint_mode);
1142     paint_cursor_start_explicit(paint, wm, weight_paint_poll);
1143     BKE_paint_init(bmain, scene, paint_mode, PAINT_CURSOR_WEIGHT_PAINT);
1144
1145     /* weight paint specific */
1146     ED_mesh_mirror_spatial_table(ob, NULL, NULL, NULL, 's');
1147     ED_vgroup_sync_from_pose(ob);
1148   }
1149   else {
1150     BLI_assert(0);
1151   }
1152
1153   /* Create vertex/weight paint mode session data */
1154   if (ob->sculpt) {
1155     if (ob->sculpt->cache) {
1156       sculpt_cache_free(ob->sculpt->cache);
1157       ob->sculpt->cache = NULL;
1158     }
1159     BKE_sculptsession_free(ob);
1160   }
1161
1162   vertex_paint_init_session(depsgraph, scene, ob, mode_flag);
1163
1164   /* Flush object mode. */
1165   DEG_id_tag_update(&ob->id, ID_RECALC_COPY_ON_WRITE);
1166 }
1167
1168 void ED_object_vpaintmode_enter_ex(
1169     Main *bmain, Depsgraph *depsgraph, wmWindowManager *wm, Scene *scene, Object *ob)
1170 {
1171   ed_vwpaintmode_enter_generic(bmain, depsgraph, wm, scene, ob, OB_MODE_VERTEX_PAINT);
1172 }
1173 void ED_object_vpaintmode_enter(struct bContext *C)
1174 {
1175   Main *bmain = CTX_data_main(C);
1176   Depsgraph *depsgraph = CTX_data_depsgraph(C);
1177   wmWindowManager *wm = CTX_wm_manager(C);
1178   Scene *scene = CTX_data_scene(C);
1179   Object *ob = CTX_data_active_object(C);
1180   ED_object_vpaintmode_enter_ex(bmain, depsgraph, wm, scene, ob);
1181 }
1182
1183 void ED_object_wpaintmode_enter_ex(
1184     Main *bmain, Depsgraph *depsgraph, wmWindowManager *wm, Scene *scene, Object *ob)
1185 {
1186   ed_vwpaintmode_enter_generic(bmain, depsgraph, wm, scene, ob, OB_MODE_WEIGHT_PAINT);
1187 }
1188 void ED_object_wpaintmode_enter(struct bContext *C)
1189 {
1190   Main *bmain = CTX_data_main(C);
1191   Depsgraph *depsgraph = CTX_data_depsgraph(C);
1192   wmWindowManager *wm = CTX_wm_manager(C);
1193   Scene *scene = CTX_data_scene(C);
1194   Object *ob = CTX_data_active_object(C);
1195   ED_object_wpaintmode_enter_ex(bmain, depsgraph, wm, scene, ob);
1196 }
1197
1198 /** \} */
1199
1200 /* -------------------------------------------------------------------- */
1201 /** \name Exit Vertex/Weight Paint Mode
1202  * \{ */
1203
1204 static void ed_vwpaintmode_exit_generic(Object *ob, const eObjectMode mode_flag)
1205 {
1206   Mesh *me = BKE_mesh_from_object(ob);
1207   ob->mode &= ~mode_flag;
1208
1209   if (mode_flag == OB_MODE_VERTEX_PAINT) {
1210     if (me->editflag & ME_EDIT_PAINT_FACE_SEL) {
1211       BKE_mesh_flush_select_from_polys(me);
1212     }
1213     else if (me->editflag & ME_EDIT_PAINT_VERT_SEL) {
1214       BKE_mesh_flush_select_from_verts(me);
1215     }
1216   }
1217   else if (mode_flag == OB_MODE_WEIGHT_PAINT) {
1218     if (me->editflag & ME_EDIT_PAINT_VERT_SEL) {
1219       BKE_mesh_flush_select_from_verts(me);
1220     }
1221     else if (me->editflag & ME_EDIT_PAINT_FACE_SEL) {
1222       BKE_mesh_flush_select_from_polys(me);
1223     }
1224   }
1225   else {
1226     BLI_assert(0);
1227   }
1228
1229   /* If the cache is not released by a cancel or a done, free it now. */
1230   if (ob->sculpt && ob->sculpt->cache) {
1231     sculpt_cache_free(ob->sculpt->cache);
1232     ob->sculpt->cache = NULL;
1233   }
1234
1235   BKE_sculptsession_free(ob);
1236
1237   paint_cursor_delete_textures();
1238
1239   if (mode_flag == OB_MODE_WEIGHT_PAINT) {
1240     ED_mesh_mirror_spatial_table(NULL, NULL, NULL, NULL, 'e');
1241     ED_mesh_mirror_topo_table(NULL, NULL, 'e');
1242   }
1243
1244   /* Never leave derived meshes behind. */
1245   BKE_object_free_derived_caches(ob);
1246
1247   /* Flush object mode. */
1248   DEG_id_tag_update(&ob->id, ID_RECALC_COPY_ON_WRITE);
1249 }
1250
1251 void ED_object_vpaintmode_exit_ex(Object *ob)
1252 {
1253   ed_vwpaintmode_exit_generic(ob, OB_MODE_VERTEX_PAINT);
1254 }
1255 void ED_object_vpaintmode_exit(struct bContext *C)
1256 {
1257   Object *ob = CTX_data_active_object(C);
1258   ED_object_vpaintmode_exit_ex(ob);
1259 }
1260
1261 void ED_object_wpaintmode_exit_ex(Object *ob)
1262 {
1263   ed_vwpaintmode_exit_generic(ob, OB_MODE_WEIGHT_PAINT);
1264 }
1265 void ED_object_wpaintmode_exit(struct bContext *C)
1266 {
1267   Object *ob = CTX_data_active_object(C);
1268   ED_object_wpaintmode_exit_ex(ob);
1269 }
1270
1271 /** \} */
1272
1273 /* -------------------------------------------------------------------- */
1274 /** \name Toggle Weight Paint Operator
1275  * \{ */
1276
1277 /**
1278  * \note Keep in sync with #vpaint_mode_toggle_exec
1279  */
1280 static int wpaint_mode_toggle_exec(bContext *C, wmOperator *op)
1281 {
1282   Main *bmain = CTX_data_main(C);
1283   struct wmMsgBus *mbus = CTX_wm_message_bus(C);
1284   Object *ob = CTX_data_active_object(C);
1285   const int mode_flag = OB_MODE_WEIGHT_PAINT;
1286   const bool is_mode_set = (ob->mode & mode_flag) != 0;
1287   Scene *scene = CTX_data_scene(C);
1288   ToolSettings *ts = scene->toolsettings;
1289
1290   if (!is_mode_set) {
1291     if (!ED_object_mode_compat_set(C, ob, mode_flag, op->reports)) {
1292       return OPERATOR_CANCELLED;
1293     }
1294   }
1295
1296   Mesh *me = BKE_mesh_from_object(ob);
1297
1298   if (is_mode_set) {
1299     ED_object_wpaintmode_exit_ex(ob);
1300   }
1301   else {
1302     Depsgraph *depsgraph = CTX_data_depsgraph_on_load(C);
1303     wmWindowManager *wm = CTX_wm_manager(C);
1304     ED_object_wpaintmode_enter_ex(bmain, depsgraph, wm, scene, ob);
1305     BKE_paint_toolslots_brush_validate(bmain, &ts->wpaint->paint);
1306   }
1307
1308   /* When locked, it's almost impossible to select the pose
1309    * then the object to enter weight paint mode.
1310    * In this case move our pose object in/out of pose mode.
1311    * This is in fits with the convention of selecting multiple objects and entering a mode. */
1312   if (scene->toolsettings->object_flag & SCE_OBJECT_MODE_LOCK) {
1313     Object *ob_arm = modifiers_isDeformedByArmature(ob);
1314     if (ob_arm && (ob_arm->base_flag & BASE_SELECTED)) {
1315       if (ob_arm->mode & OB_MODE_POSE) {
1316         ED_object_posemode_exit_ex(bmain, ob_arm);
1317       }
1318       else {
1319         ED_object_posemode_enter_ex(bmain, ob_arm);
1320       }
1321     }
1322   }
1323
1324   /* Weightpaint works by overriding colors in mesh,
1325    * so need to make sure we recalc on enter and
1326    * exit (exit needs doing regardless because we
1327    * should redeform).
1328    */
1329   DEG_id_tag_update(&me->id, 0);
1330
1331   WM_event_add_notifier(C, NC_SCENE | ND_MODE, scene);
1332
1333   WM_msg_publish_rna_prop(mbus, &ob->id, ob, Object, mode);
1334
1335   WM_toolsystem_update_from_context_view3d(C);
1336
1337   return OPERATOR_FINISHED;
1338 }
1339
1340 /* for switching to/from mode */
1341 static bool paint_poll_test(bContext *C)
1342 {
1343   Object *ob = CTX_data_active_object(C);
1344   if (ob == NULL || ob->type != OB_MESH) {
1345     return 0;
1346   }
1347   if (!ob->data || ID_IS_LINKED(ob->data)) {
1348     return 0;
1349   }
1350   if (CTX_data_edit_object(C)) {
1351     return 0;
1352   }
1353   return 1;
1354 }
1355
1356 void PAINT_OT_weight_paint_toggle(wmOperatorType *ot)
1357 {
1358
1359   /* identifiers */
1360   ot->name = "Weight Paint Mode";
1361   ot->idname = "PAINT_OT_weight_paint_toggle";
1362   ot->description = "Toggle weight paint mode in 3D view";
1363
1364   /* api callbacks */
1365   ot->exec = wpaint_mode_toggle_exec;
1366   ot->poll = paint_poll_test;
1367
1368   /* flags */
1369   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_USE_EVAL_DATA;
1370 }
1371
1372 /** \} */
1373
1374 /* -------------------------------------------------------------------- */
1375 /** \name Weight Paint Operator
1376  * \{ */
1377
1378 struct WPaintData {
1379   ViewContext vc;
1380   struct NormalAnglePrecalc normal_angle_precalc;
1381
1382   struct WeightPaintGroupData active, mirror;
1383
1384   /* variables for auto normalize */
1385   const bool *vgroup_validmap; /* stores if vgroups tie to deforming bones or not */
1386   const bool *lock_flags;
1387
1388   /* variables for multipaint */
1389   const bool *defbase_sel; /* set of selected groups */
1390   int defbase_tot_sel;     /* number of selected groups */
1391   bool do_multipaint;      /* true if multipaint enabled and multiple groups selected */
1392
1393   int defbase_tot;
1394
1395   /* original weight values for use in blur/smear */
1396   float *precomputed_weight;
1397   bool precomputed_weight_ready;
1398 };
1399
1400 /* Initialize the stroke cache invariants from operator properties */
1401 static void vwpaint_update_cache_invariants(
1402     bContext *C, const VPaint *vp, SculptSession *ss, wmOperator *op, const float mouse[2])
1403 {
1404   StrokeCache *cache;
1405   Scene *scene = CTX_data_scene(C);
1406   UnifiedPaintSettings *ups = &CTX_data_tool_settings(C)->unified_paint_settings;
1407   const Brush *brush = vp->paint.brush;
1408   ViewContext *vc = paint_stroke_view_context(op->customdata);
1409   Object *ob = CTX_data_active_object(C);
1410   float mat[3][3];
1411   float view_dir[3] = {0.0f, 0.0f, 1.0f};
1412   int mode;
1413
1414   /* VW paint needs to allocate stroke cache before update is called. */
1415   if (!ss->cache) {
1416     cache = MEM_callocN(sizeof(StrokeCache), "stroke cache");
1417     ss->cache = cache;
1418   }
1419   else {
1420     cache = ss->cache;
1421   }
1422
1423   /* Initial mouse location */
1424   if (mouse) {
1425     copy_v2_v2(cache->initial_mouse, mouse);
1426   }
1427   else {
1428     zero_v2(cache->initial_mouse);
1429   }
1430
1431   mode = RNA_enum_get(op->ptr, "mode");
1432   cache->invert = mode == BRUSH_STROKE_INVERT;
1433   cache->alt_smooth = mode == BRUSH_STROKE_SMOOTH;
1434   /* not very nice, but with current events system implementation
1435    * we can't handle brush appearance inversion hotkey separately (sergey) */
1436   if (cache->invert) {
1437     ups->draw_inverted = true;
1438   }
1439   else {
1440     ups->draw_inverted = false;
1441   }
1442
1443   copy_v2_v2(cache->mouse, cache->initial_mouse);
1444   /* Truly temporary data that isn't stored in properties */
1445   cache->vc = vc;
1446   cache->brush = brush;
1447   cache->first_time = 1;
1448
1449   /* cache projection matrix */
1450   ED_view3d_ob_project_mat_get(cache->vc->rv3d, ob, cache->projection_mat);
1451
1452   invert_m4_m4(ob->imat, ob->obmat);
1453   copy_m3_m4(mat, cache->vc->rv3d->viewinv);
1454   mul_m3_v3(mat, view_dir);
1455   copy_m3_m4(mat, ob->imat);
1456   mul_m3_v3(mat, view_dir);
1457   normalize_v3_v3(cache->true_view_normal, view_dir);
1458
1459   copy_v3_v3(cache->view_normal, cache->true_view_normal);
1460   cache->bstrength = BKE_brush_alpha_get(scene, brush);
1461   cache->is_last_valid = false;
1462 }
1463
1464 /* Initialize the stroke cache variants from operator properties */
1465 static void vwpaint_update_cache_variants(bContext *C, VPaint *vp, Object *ob, PointerRNA *ptr)
1466 {
1467   Scene *scene = CTX_data_scene(C);
1468   SculptSession *ss = ob->sculpt;
1469   StrokeCache *cache = ss->cache;
1470   Brush *brush = BKE_paint_brush(&vp->paint);
1471
1472   /* This effects the actual brush radius, so things farther away
1473    * are compared with a larger radius and vice versa. */
1474   if (cache->first_time) {
1475     RNA_float_get_array(ptr, "location", cache->true_location);
1476   }
1477
1478   RNA_float_get_array(ptr, "mouse", cache->mouse);
1479
1480   /* XXX: Use pressure value from first brush step for brushes which don't
1481    * support strokes (grab, thumb). They depends on initial state and
1482    * brush coord/pressure/etc.
1483    * It's more an events design issue, which doesn't split coordinate/pressure/angle
1484    * changing events. We should avoid this after events system re-design */
1485   if (paint_supports_dynamic_size(brush, PAINT_MODE_SCULPT) || cache->first_time) {
1486     cache->pressure = RNA_float_get(ptr, "pressure");
1487   }
1488
1489   /* Truly temporary data that isn't stored in properties */
1490   if (cache->first_time) {
1491     if (!BKE_brush_use_locked_size(scene, brush)) {
1492       cache->initial_radius = paint_calc_object_space_radius(
1493           cache->vc, cache->true_location, BKE_brush_size_get(scene, brush));
1494       BKE_brush_unprojected_radius_set(scene, brush, cache->initial_radius);
1495     }
1496     else {
1497       cache->initial_radius = BKE_brush_unprojected_radius_get(scene, brush);
1498     }
1499   }
1500
1501   if (BKE_brush_use_size_pressure(scene, brush) &&
1502       paint_supports_dynamic_size(brush, PAINT_MODE_SCULPT)) {
1503     cache->radius = cache->initial_radius * cache->pressure;
1504   }
1505   else {
1506     cache->radius = cache->initial_radius;
1507   }
1508
1509   cache->radius_squared = cache->radius * cache->radius;
1510
1511   if (ss->pbvh) {
1512     BKE_pbvh_update_bounds(ss->pbvh, PBVH_UpdateRedraw | PBVH_UpdateBB);
1513   }
1514 }
1515
1516 static bool wpaint_stroke_test_start(bContext *C, wmOperator *op, const float mouse[2])
1517 {
1518   Scene *scene = CTX_data_scene(C);
1519   struct PaintStroke *stroke = op->customdata;
1520   ToolSettings *ts = scene->toolsettings;
1521   Object *ob = CTX_data_active_object(C);
1522   Mesh *me = BKE_mesh_from_object(ob);
1523   struct WPaintData *wpd;
1524   struct WPaintVGroupIndex vgroup_index;
1525   int defbase_tot, defbase_tot_sel;
1526   bool *defbase_sel;
1527   SculptSession *ss = ob->sculpt;
1528   VPaint *vp = CTX_data_tool_settings(C)->wpaint;
1529   Depsgraph *depsgraph = CTX_data_depsgraph(C);
1530
1531   if (ED_wpaint_ensure_data(C, op->reports, WPAINT_ENSURE_MIRROR, &vgroup_index) == false) {
1532     return false;
1533   }
1534
1535   {
1536     /* check if we are attempting to paint onto a locked vertex group,
1537      * and other options disallow it from doing anything useful */
1538     bDeformGroup *dg;
1539     dg = BLI_findlink(&ob->defbase, vgroup_index.active);
1540     if (dg->flag & DG_LOCK_WEIGHT) {
1541       BKE_report(op->reports, RPT_WARNING, "Active group is locked, aborting");
1542       return false;
1543     }
1544     if (vgroup_index.mirror != -1) {
1545       dg = BLI_findlink(&ob->defbase, vgroup_index.mirror);
1546       if (dg->flag & DG_LOCK_WEIGHT) {
1547         BKE_report(op->reports, RPT_WARNING, "Mirror group is locked, aborting");
1548         return false;
1549       }
1550     }
1551   }
1552
1553   /* check that multipaint groups are unlocked */
1554   defbase_tot = BLI_listbase_count(&ob->defbase);
1555   defbase_sel = BKE_object_defgroup_selected_get(ob, defbase_tot, &defbase_tot_sel);
1556
1557   if (ts->multipaint && defbase_tot_sel > 1) {
1558     int i;
1559     bDeformGroup *dg;
1560
1561     if (me->editflag & ME_EDIT_MIRROR_X) {
1562       BKE_object_defgroup_mirror_selection(
1563           ob, defbase_tot, defbase_sel, defbase_sel, &defbase_tot_sel);
1564     }
1565
1566     for (i = 0; i < defbase_tot; i++) {
1567       if (defbase_sel[i]) {
1568         dg = BLI_findlink(&ob->defbase, i);
1569         if (dg->flag & DG_LOCK_WEIGHT) {
1570           BKE_report(op->reports, RPT_WARNING, "Multipaint group is locked, aborting");
1571           MEM_freeN(defbase_sel);
1572           return false;
1573         }
1574       }
1575     }
1576   }
1577
1578   /* ALLOCATIONS! no return after this line */
1579   /* make mode data storage */
1580   wpd = MEM_callocN(sizeof(struct WPaintData), "WPaintData");
1581   paint_stroke_set_mode_data(stroke, wpd);
1582   ED_view3d_viewcontext_init(C, &wpd->vc);
1583   view_angle_limits_init(&wpd->normal_angle_precalc,
1584                          vp->paint.brush->falloff_angle,
1585                          (vp->paint.brush->flag & BRUSH_FRONTFACE_FALLOFF) != 0);
1586
1587   wpd->active.index = vgroup_index.active;
1588   wpd->mirror.index = vgroup_index.mirror;
1589
1590   /* multipaint */
1591   wpd->defbase_tot = defbase_tot;
1592   wpd->defbase_sel = defbase_sel;
1593   wpd->defbase_tot_sel = defbase_tot_sel > 1 ? defbase_tot_sel : 1;
1594   wpd->do_multipaint = (ts->multipaint && defbase_tot_sel > 1);
1595
1596   /* set up auto-normalize, and generate map for detecting which
1597    * vgroups affect deform bones */
1598   wpd->lock_flags = BKE_object_defgroup_lock_flags_get(ob, wpd->defbase_tot);
1599   if (ts->auto_normalize || ts->multipaint || wpd->lock_flags) {
1600     wpd->vgroup_validmap = BKE_object_defgroup_validmap_get(ob, wpd->defbase_tot);
1601   }
1602
1603   if (wpd->do_multipaint && ts->auto_normalize) {
1604     bool *tmpflags;
1605     tmpflags = MEM_mallocN(sizeof(bool) * defbase_tot, __func__);
1606     if (wpd->lock_flags) {
1607       BLI_array_binary_or(tmpflags, wpd->defbase_sel, wpd->lock_flags, wpd->defbase_tot);
1608     }
1609     else {
1610       memcpy(tmpflags, wpd->defbase_sel, sizeof(*tmpflags) * wpd->defbase_tot);
1611     }
1612     wpd->active.lock = tmpflags;
1613   }
1614   else if (ts->auto_normalize) {
1615     bool *tmpflags;
1616
1617     tmpflags = wpd->lock_flags ? MEM_dupallocN(wpd->lock_flags) :
1618                                  MEM_callocN(sizeof(bool) * defbase_tot, __func__);
1619     tmpflags[wpd->active.index] = true;
1620     wpd->active.lock = tmpflags;
1621
1622     tmpflags = wpd->lock_flags ? MEM_dupallocN(wpd->lock_flags) :
1623                                  MEM_callocN(sizeof(bool) * defbase_tot, __func__);
1624     tmpflags[(wpd->mirror.index != -1) ? wpd->mirror.index : wpd->active.index] = true;
1625     wpd->mirror.lock = tmpflags;
1626   }
1627
1628   if (ELEM(vp->paint.brush->weightpaint_tool, WPAINT_TOOL_SMEAR, WPAINT_TOOL_BLUR)) {
1629     wpd->precomputed_weight = MEM_mallocN(sizeof(float) * me->totvert, __func__);
1630   }
1631
1632   /* If not previously created, create vertex/weight paint mode session data */
1633   vertex_paint_init_stroke(depsgraph, ob);
1634   vwpaint_update_cache_invariants(C, vp, ss, op, mouse);
1635   vertex_paint_init_session_data(ts, ob);
1636
1637   if (ob->sculpt->mode.wpaint.dvert_prev != NULL) {
1638     MDeformVert *dv = ob->sculpt->mode.wpaint.dvert_prev;
1639     for (int i = 0; i < me->totvert; i++, dv++) {
1640       /* Use to show this isn't initialized, never apply to the mesh data. */
1641       dv->flag = 1;
1642     }
1643   }
1644
1645   return true;
1646 }
1647
1648 static float dot_vf3vs3(const float brushNormal[3], const short vertexNormal[3])
1649 {
1650   float normal[3];
1651   normal_short_to_float_v3(normal, vertexNormal);
1652   return dot_v3v3(brushNormal, normal);
1653 }
1654
1655 static void get_brush_alpha_data(const Scene *scene,
1656                                  const SculptSession *ss,
1657                                  const Brush *brush,
1658                                  float *r_brush_size_pressure,
1659                                  float *r_brush_alpha_value,
1660                                  float *r_brush_alpha_pressure)
1661 {
1662   *r_brush_size_pressure = BKE_brush_size_get(scene, brush) *
1663                            (BKE_brush_use_size_pressure(scene, brush) ? ss->cache->pressure :
1664                                                                         1.0f);
1665   *r_brush_alpha_value = BKE_brush_alpha_get(scene, brush);
1666   *r_brush_alpha_pressure = (BKE_brush_use_alpha_pressure(scene, brush) ? ss->cache->pressure :
1667                                                                           1.0f);
1668 }
1669
1670 static float wpaint_get_active_weight(const MDeformVert *dv, const WeightPaintInfo *wpi)
1671 {
1672   if (wpi->do_multipaint) {
1673     float weight = BKE_defvert_multipaint_collective_weight(
1674         dv, wpi->defbase_tot, wpi->defbase_sel, wpi->defbase_tot_sel, wpi->do_auto_normalize);
1675
1676     CLAMP(weight, 0.0f, 1.0f);
1677     return weight;
1678   }
1679   else {
1680     return defvert_find_weight(dv, wpi->active.index);
1681   }
1682 }
1683
1684 static void do_wpaint_precompute_weight_cb_ex(void *__restrict userdata,
1685                                               const int n,
1686                                               const ParallelRangeTLS *__restrict UNUSED(tls))
1687 {
1688   SculptThreadedTaskData *data = userdata;
1689   const MDeformVert *dv = &data->me->dvert[n];
1690
1691   data->wpd->precomputed_weight[n] = wpaint_get_active_weight(dv, data->wpi);
1692 }
1693
1694 static void precompute_weight_values(
1695     bContext *C, Object *ob, Brush *brush, struct WPaintData *wpd, WeightPaintInfo *wpi, Mesh *me)
1696 {
1697   if (wpd->precomputed_weight_ready && !brush_use_accumulate_ex(brush, ob->mode)) {
1698     return;
1699   }
1700
1701   /* threaded loop over vertices */
1702   SculptThreadedTaskData data = {
1703       .C = C,
1704       .ob = ob,
1705       .wpd = wpd,
1706       .wpi = wpi,
1707       .me = me,
1708   };
1709
1710   ParallelRangeSettings settings;
1711   BLI_parallel_range_settings_defaults(&settings);
1712   BLI_task_parallel_range(0, me->totvert, &data, do_wpaint_precompute_weight_cb_ex, &settings);
1713
1714   wpd->precomputed_weight_ready = true;
1715 }
1716
1717 static void do_wpaint_brush_blur_task_cb_ex(void *__restrict userdata,
1718                                             const int n,
1719                                             const ParallelRangeTLS *__restrict UNUSED(tls))
1720 {
1721   SculptThreadedTaskData *data = userdata;
1722   SculptSession *ss = data->ob->sculpt;
1723   const PBVHType pbvh_type = BKE_pbvh_type(ss->pbvh);
1724   const bool has_grids = (pbvh_type == PBVH_GRIDS);
1725   const struct SculptVertexPaintGeomMap *gmap = &ss->mode.wpaint.gmap;
1726
1727   const Brush *brush = data->brush;
1728   const StrokeCache *cache = ss->cache;
1729   Scene *scene = CTX_data_scene(data->C);
1730
1731   float brush_size_pressure, brush_alpha_value, brush_alpha_pressure;
1732   get_brush_alpha_data(
1733       scene, ss, brush, &brush_size_pressure, &brush_alpha_value, &brush_alpha_pressure);
1734   const bool use_normal = vwpaint_use_normal(data->vp);
1735   const bool use_face_sel = (data->me->editflag & ME_EDIT_PAINT_FACE_SEL) != 0;
1736   const bool use_vert_sel = (data->me->editflag & ME_EDIT_PAINT_VERT_SEL) != 0;
1737
1738   SculptBrushTest test;
1739   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
1740       ss, &test, data->brush->falloff_shape);
1741   const float *sculpt_normal_frontface = sculpt_brush_frontface_normal_from_falloff_shape(
1742       ss, data->brush->falloff_shape);
1743
1744   /* For each vertex */
1745   PBVHVertexIter vd;
1746   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
1747   {
1748     /* Test to see if the vertex coordinates are within the spherical brush region. */
1749     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
1750       /* For grid based pbvh, take the vert whose loop corresponds to the current grid.
1751        * Otherwise, take the current vert. */
1752       const int v_index = has_grids ? data->me->mloop[vd.grid_indices[vd.g]].v :
1753                                       vd.vert_indices[vd.i];
1754       const float grid_alpha = has_grids ? 1.0f / vd.gridsize : 1.0f;
1755       const char v_flag = data->me->mvert[v_index].flag;
1756       /* If the vertex is selected */
1757       if (!(use_face_sel || use_vert_sel) || v_flag & SELECT) {
1758         /* Get the average poly weight */
1759         int total_hit_loops = 0;
1760         float weight_final = 0.0f;
1761         for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
1762           const int p_index = gmap->vert_to_poly[v_index].indices[j];
1763           const MPoly *mp = &data->me->mpoly[p_index];
1764
1765           total_hit_loops += mp->totloop;
1766           for (int k = 0; k < mp->totloop; k++) {
1767             const int l_index = mp->loopstart + k;
1768             const MLoop *ml = &data->me->mloop[l_index];
1769             weight_final += data->wpd->precomputed_weight[ml->v];
1770           }
1771         }
1772
1773         /* Apply the weight to the vertex. */
1774         if (total_hit_loops != 0) {
1775           float brush_strength = cache->bstrength;
1776           const float angle_cos = (use_normal && vd.no) ?
1777                                       dot_vf3vs3(sculpt_normal_frontface, vd.no) :
1778                                       1.0f;
1779           if (((brush->flag & BRUSH_FRONTFACE) == 0 || (angle_cos > 0.0f)) &&
1780               ((brush->flag & BRUSH_FRONTFACE_FALLOFF) == 0 ||
1781                view_angle_limits_apply_falloff(
1782                    &data->wpd->normal_angle_precalc, angle_cos, &brush_strength))) {
1783             const float brush_fade = BKE_brush_curve_strength(
1784                 brush, sqrtf(test.dist), cache->radius);
1785             const float final_alpha = brush_fade * brush_strength * grid_alpha *
1786                                       brush_alpha_pressure;
1787
1788             if ((brush->flag & BRUSH_ACCUMULATE) == 0) {
1789               if (ss->mode.wpaint.alpha_weight[v_index] < final_alpha) {
1790                 ss->mode.wpaint.alpha_weight[v_index] = final_alpha;
1791               }
1792               else {
1793                 continue;
1794               }
1795             }
1796
1797             weight_final /= total_hit_loops;
1798             /* Only paint visible verts */
1799             do_weight_paint_vertex(
1800                 data->vp, data->ob, data->wpi, v_index, final_alpha, weight_final);
1801           }
1802         }
1803       }
1804     }
1805   }
1806   BKE_pbvh_vertex_iter_end;
1807 }
1808
1809 static void do_wpaint_brush_smear_task_cb_ex(void *__restrict userdata,
1810                                              const int n,
1811                                              const ParallelRangeTLS *__restrict UNUSED(tls))
1812 {
1813   SculptThreadedTaskData *data = userdata;
1814   SculptSession *ss = data->ob->sculpt;
1815   const PBVHType pbvh_type = BKE_pbvh_type(ss->pbvh);
1816   const bool has_grids = (pbvh_type == PBVH_GRIDS);
1817   const struct SculptVertexPaintGeomMap *gmap = &ss->mode.wpaint.gmap;
1818
1819   const Brush *brush = data->brush;
1820   const Scene *scene = CTX_data_scene(data->C);
1821   const StrokeCache *cache = ss->cache;
1822   float brush_size_pressure, brush_alpha_value, brush_alpha_pressure;
1823   get_brush_alpha_data(
1824       scene, ss, brush, &brush_size_pressure, &brush_alpha_value, &brush_alpha_pressure);
1825   const bool use_normal = vwpaint_use_normal(data->vp);
1826   const bool use_face_sel = (data->me->editflag & ME_EDIT_PAINT_FACE_SEL) != 0;
1827   const bool use_vert_sel = (data->me->editflag & ME_EDIT_PAINT_VERT_SEL) != 0;
1828   float brush_dir[3];
1829
1830   sub_v3_v3v3(brush_dir, cache->location, cache->last_location);
1831   project_plane_v3_v3v3(brush_dir, brush_dir, cache->view_normal);
1832
1833   if (cache->is_last_valid && (normalize_v3(brush_dir) != 0.0f)) {
1834
1835     SculptBrushTest test;
1836     SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
1837         ss, &test, data->brush->falloff_shape);
1838     const float *sculpt_normal_frontface = sculpt_brush_frontface_normal_from_falloff_shape(
1839         ss, data->brush->falloff_shape);
1840
1841     /* For each vertex */
1842     PBVHVertexIter vd;
1843     BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
1844     {
1845       /* Test to see if the vertex coordinates are within the spherical brush region. */
1846       if (sculpt_brush_test_sq_fn(&test, vd.co)) {
1847         /* For grid based pbvh, take the vert whose loop corresponds to the current grid.
1848          * Otherwise, take the current vert. */
1849         const int v_index = has_grids ? data->me->mloop[vd.grid_indices[vd.g]].v :
1850                                         vd.vert_indices[vd.i];
1851         const float grid_alpha = has_grids ? 1.0f / vd.gridsize : 1.0f;
1852         const MVert *mv_curr = &data->me->mvert[v_index];
1853
1854         /* If the vertex is selected */
1855         if (!(use_face_sel || use_vert_sel) || mv_curr->flag & SELECT) {
1856           float brush_strength = cache->bstrength;
1857           const float angle_cos = (use_normal && vd.no) ?
1858                                       dot_vf3vs3(sculpt_normal_frontface, vd.no) :
1859                                       1.0f;
1860           if (((brush->flag & BRUSH_FRONTFACE) == 0 || (angle_cos > 0.0f)) &&
1861               ((brush->flag & BRUSH_FRONTFACE_FALLOFF) == 0 ||
1862                view_angle_limits_apply_falloff(
1863                    &data->wpd->normal_angle_precalc, angle_cos, &brush_strength))) {
1864             bool do_color = false;
1865             /* Minimum dot product between brush direction and current
1866              * to neighbor direction is 0.0, meaning orthogonal. */
1867             float stroke_dot_max = 0.0f;
1868
1869             /* Get the color of the loop in the opposite direction of the brush movement
1870              * (this callback is specifically for smear.) */
1871             float weight_final = 0.0;
1872             for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
1873               const int p_index = gmap->vert_to_poly[v_index].indices[j];
1874               const MPoly *mp = &data->me->mpoly[p_index];
1875               const MLoop *ml_other = &data->me->mloop[mp->loopstart];
1876               for (int k = 0; k < mp->totloop; k++, ml_other++) {
1877                 const uint v_other_index = ml_other->v;
1878                 if (v_other_index != v_index) {
1879                   const MVert *mv_other = &data->me->mvert[v_other_index];
1880
1881                   /* Get the direction from the selected vert to the neighbor. */
1882                   float other_dir[3];
1883                   sub_v3_v3v3(other_dir, mv_curr->co, mv_other->co);
1884                   project_plane_v3_v3v3(other_dir, other_dir, cache->view_normal);
1885
1886                   normalize_v3(other_dir);
1887
1888                   const float stroke_dot = dot_v3v3(other_dir, brush_dir);
1889
1890                   if (stroke_dot > stroke_dot_max) {
1891                     stroke_dot_max = stroke_dot;
1892                     weight_final = data->wpd->precomputed_weight[v_other_index];
1893                     do_color = true;
1894                   }
1895                 }
1896               }
1897             }
1898             /* Apply weight to vertex */
1899             if (do_color) {
1900               const float brush_fade = BKE_brush_curve_strength(
1901                   brush, sqrtf(test.dist), cache->radius);
1902               const float final_alpha = brush_fade * brush_strength * grid_alpha *
1903                                         brush_alpha_pressure;
1904
1905               if (final_alpha <= 0.0f) {
1906                 continue;
1907               }
1908
1909               do_weight_paint_vertex(
1910                   data->vp, data->ob, data->wpi, v_index, final_alpha, (float)weight_final);
1911             }
1912           }
1913         }
1914       }
1915     }
1916     BKE_pbvh_vertex_iter_end;
1917   }
1918 }
1919
1920 static void do_wpaint_brush_draw_task_cb_ex(void *__restrict userdata,
1921                                             const int n,
1922                                             const ParallelRangeTLS *__restrict UNUSED(tls))
1923 {
1924   SculptThreadedTaskData *data = userdata;
1925   SculptSession *ss = data->ob->sculpt;
1926   const PBVHType pbvh_type = BKE_pbvh_type(ss->pbvh);
1927   const bool has_grids = (pbvh_type == PBVH_GRIDS);
1928   const Scene *scene = CTX_data_scene(data->C);
1929
1930   const Brush *brush = data->brush;
1931   const StrokeCache *cache = ss->cache;
1932   /* note: normally `BKE_brush_weight_get(scene, brush)` is used,
1933    * however in this case we calculate a new weight each time. */
1934   const float paintweight = data->strength;
1935   float brush_size_pressure, brush_alpha_value, brush_alpha_pressure;
1936   get_brush_alpha_data(
1937       scene, ss, brush, &brush_size_pressure, &brush_alpha_value, &brush_alpha_pressure);
1938   const bool use_normal = vwpaint_use_normal(data->vp);
1939   const bool use_face_sel = (data->me->editflag & ME_EDIT_PAINT_FACE_SEL) != 0;
1940   const bool use_vert_sel = (data->me->editflag & ME_EDIT_PAINT_VERT_SEL) != 0;
1941
1942   SculptBrushTest test;
1943   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
1944       ss, &test, data->brush->falloff_shape);
1945   const float *sculpt_normal_frontface = sculpt_brush_frontface_normal_from_falloff_shape(
1946       ss, data->brush->falloff_shape);
1947
1948   /* For each vertex */
1949   PBVHVertexIter vd;
1950   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
1951   {
1952     /* Test to see if the vertex coordinates are within the spherical brush region. */
1953     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
1954       /* Note: grids are 1:1 with corners (aka loops).
1955        * For multires, take the vert whose loop corresponds to the current grid.
1956        * Otherwise, take the current vert. */
1957       const int v_index = has_grids ? data->me->mloop[vd.grid_indices[vd.g]].v :
1958                                       vd.vert_indices[vd.i];
1959       const float grid_alpha = has_grids ? 1.0f / vd.gridsize : 1.0f;
1960
1961       const char v_flag = data->me->mvert[v_index].flag;
1962       /* If the vertex is selected */
1963       if (!(use_face_sel || use_vert_sel) || v_flag & SELECT) {
1964         float brush_strength = cache->bstrength;
1965         const float angle_cos = (use_normal && vd.no) ?
1966                                     dot_vf3vs3(sculpt_normal_frontface, vd.no) :
1967                                     1.0f;
1968         if (((brush->flag & BRUSH_FRONTFACE) == 0 || (angle_cos > 0.0f)) &&
1969             ((brush->flag & BRUSH_FRONTFACE_FALLOFF) == 0 ||
1970              view_angle_limits_apply_falloff(
1971                  &data->wpd->normal_angle_precalc, angle_cos, &brush_strength))) {
1972           const float brush_fade = BKE_brush_curve_strength(
1973               brush, sqrtf(test.dist), cache->radius);
1974           const float final_alpha = brush_fade * brush_strength * grid_alpha *
1975                                     brush_alpha_pressure;
1976
1977           if ((brush->flag & BRUSH_ACCUMULATE) == 0) {
1978             if (ss->mode.wpaint.alpha_weight[v_index] < final_alpha) {
1979               ss->mode.wpaint.alpha_weight[v_index] = final_alpha;
1980             }
1981             else {
1982               continue;
1983             }
1984           }
1985
1986           do_weight_paint_vertex(data->vp, data->ob, data->wpi, v_index, final_alpha, paintweight);
1987         }
1988       }
1989     }
1990   }
1991   BKE_pbvh_vertex_iter_end;
1992 }
1993
1994 static void do_wpaint_brush_calc_average_weight_cb_ex(
1995     void *__restrict userdata, const int n, const ParallelRangeTLS *__restrict UNUSED(tls))
1996 {
1997   SculptThreadedTaskData *data = userdata;
1998   SculptSession *ss = data->ob->sculpt;
1999   StrokeCache *cache = ss->cache;
2000   const PBVHType pbvh_type = BKE_pbvh_type(ss->pbvh);
2001   const bool has_grids = (pbvh_type == PBVH_GRIDS);
2002
2003   const bool use_normal = vwpaint_use_normal(data->vp);
2004   const bool use_face_sel = (data->me->editflag & ME_EDIT_PAINT_FACE_SEL) != 0;
2005   const bool use_vert_sel = (data->me->editflag & ME_EDIT_PAINT_VERT_SEL) != 0;
2006
2007   struct WPaintAverageAccum *accum = (struct WPaintAverageAccum *)data->custom_data + n;
2008   accum->len = 0;
2009   accum->value = 0.0;
2010
2011   SculptBrushTest test;
2012   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
2013       ss, &test, data->brush->falloff_shape);
2014   const float *sculpt_normal_frontface = sculpt_brush_frontface_normal_from_falloff_shape(
2015       ss, data->brush->falloff_shape);
2016
2017   /* For each vertex */
2018   PBVHVertexIter vd;
2019   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
2020   {
2021     /* Test to see if the vertex coordinates are within the spherical brush region. */
2022     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
2023       const float angle_cos = (use_normal && vd.no) ? dot_vf3vs3(sculpt_normal_frontface, vd.no) :
2024                                                       1.0f;
2025       if (angle_cos > 0.0 &&
2026           BKE_brush_curve_strength(data->brush, sqrtf(test.dist), cache->radius) > 0.0) {
2027         const int v_index = has_grids ? data->me->mloop[vd.grid_indices[vd.g]].v :
2028                                         vd.vert_indices[vd.i];
2029         // const float grid_alpha = has_grids ? 1.0f / vd.gridsize : 1.0f;
2030         const char v_flag = data->me->mvert[v_index].flag;
2031
2032         /* If the vertex is selected. */
2033         if (!(use_face_sel || use_vert_sel) || v_flag & SELECT) {
2034           const MDeformVert *dv = &data->me->dvert[v_index];
2035           accum->len += 1;
2036           accum->value += wpaint_get_active_weight(dv, data->wpi);
2037         }
2038       }
2039     }
2040   }
2041   BKE_pbvh_vertex_iter_end;
2042 }
2043
2044 static void calculate_average_weight(SculptThreadedTaskData *data,
2045                                      PBVHNode **UNUSED(nodes),
2046                                      int totnode)
2047 {
2048   struct WPaintAverageAccum *accum = MEM_mallocN(sizeof(*accum) * totnode, __func__);
2049   data->custom_data = accum;
2050
2051   ParallelRangeSettings settings;
2052   BLI_parallel_range_settings_defaults(&settings);
2053   settings.use_threading = ((data->sd->flags & SCULPT_USE_OPENMP) &&
2054                             totnode > SCULPT_THREADED_LIMIT);
2055   BLI_task_parallel_range(0, totnode, data, do_wpaint_brush_calc_average_weight_cb_ex, &settings);
2056
2057   uint accum_len = 0;
2058   double accum_weight = 0.0;
2059   for (int i = 0; i < totnode; i++) {
2060     accum_len += accum[i].len;
2061     accum_weight += accum[i].value;
2062   }
2063   if (accum_len != 0) {
2064     accum_weight /= accum_len;
2065     data->strength = (float)accum_weight;
2066   }
2067
2068   MEM_SAFE_FREE(data->custom_data); /* 'accum' */
2069 }
2070
2071 static void wpaint_paint_leaves(bContext *C,
2072                                 Object *ob,
2073                                 Sculpt *sd,
2074                                 VPaint *vp,
2075                                 struct WPaintData *wpd,
2076                                 WeightPaintInfo *wpi,
2077                                 Mesh *me,
2078                                 PBVHNode **nodes,
2079                                 int totnode)
2080 {
2081   Scene *scene = CTX_data_scene(C);
2082   const Brush *brush = ob->sculpt->cache->brush;
2083
2084   /* threaded loop over nodes */
2085   SculptThreadedTaskData data = {
2086       .C = C,
2087       .sd = sd,
2088       .ob = ob,
2089       .brush = brush,
2090       .nodes = nodes,
2091       .vp = vp,
2092       .wpd = wpd,
2093       .wpi = wpi,
2094       .me = me,
2095   };
2096
2097   /* Use this so average can modify its weight without touching the brush. */
2098   data.strength = BKE_brush_weight_get(scene, brush);
2099
2100   ParallelRangeSettings settings;
2101   BLI_parallel_range_settings_defaults(&settings);
2102   /* NOTE: current mirroring code cannot be run in parallel */
2103   settings.use_threading = !(me->editflag & ME_EDIT_MIRROR_X);
2104
2105   switch ((eBrushWeightPaintTool)brush->weightpaint_tool) {
2106     case WPAINT_TOOL_AVERAGE:
2107       calculate_average_weight(&data, nodes, totnode);
2108       BLI_task_parallel_range(0, totnode, &data, do_wpaint_brush_draw_task_cb_ex, &settings);
2109       break;
2110     case WPAINT_TOOL_SMEAR:
2111       BLI_task_parallel_range(0, totnode, &data, do_wpaint_brush_smear_task_cb_ex, &settings);
2112       break;
2113     case WPAINT_TOOL_BLUR:
2114       BLI_task_parallel_range(0, totnode, &data, do_wpaint_brush_blur_task_cb_ex, &settings);
2115       break;
2116     case WPAINT_TOOL_DRAW:
2117       BLI_task_parallel_range(0, totnode, &data, do_wpaint_brush_draw_task_cb_ex, &settings);
2118       break;
2119   }
2120 }
2121
2122 static PBVHNode **vwpaint_pbvh_gather_generic(
2123     Object *ob, VPaint *wp, Sculpt *sd, Brush *brush, int *r_totnode)
2124 {
2125   SculptSession *ss = ob->sculpt;
2126   const bool use_normal = vwpaint_use_normal(wp);
2127   PBVHNode **nodes = NULL;
2128
2129   /* Build a list of all nodes that are potentially within the brush's area of influence */
2130   if (brush->falloff_shape == PAINT_FALLOFF_SHAPE_SPHERE) {
2131     SculptSearchSphereData data = {
2132         .ss = ss,
2133         .sd = sd,
2134         .radius_squared = ss->cache->radius_squared,
2135         .original = true,
2136     };
2137     BKE_pbvh_search_gather(ss->pbvh, sculpt_search_sphere_cb, &data, &nodes, r_totnode);
2138     if (use_normal) {
2139       sculpt_pbvh_calc_area_normal(
2140           brush, ob, nodes, *r_totnode, true, ss->cache->sculpt_normal_symm);
2141     }
2142     else {
2143       zero_v3(ss->cache->sculpt_normal_symm);
2144     }
2145   }
2146   else {
2147     struct DistRayAABB_Precalc dist_ray_to_aabb_precalc;
2148     dist_squared_ray_to_aabb_v3_precalc(
2149         &dist_ray_to_aabb_precalc, ss->cache->location, ss->cache->view_normal);
2150     SculptSearchCircleData data = {
2151         .ss = ss,
2152         .sd = sd,
2153         .radius_squared = ss->cache->radius_squared,
2154         .original = true,
2155         .dist_ray_to_aabb_precalc = &dist_ray_to_aabb_precalc,
2156     };
2157     BKE_pbvh_search_gather(ss->pbvh, sculpt_search_circle_cb, &data, &nodes, r_totnode);
2158     if (use_normal) {
2159       copy_v3_v3(ss->cache->sculpt_normal_symm, ss->cache->view_normal);
2160     }
2161     else {
2162       zero_v3(ss->cache->sculpt_normal_symm);
2163     }
2164   }
2165   return nodes;
2166 }
2167
2168 static void wpaint_do_paint(bContext *C,
2169                             Object *ob,
2170                             VPaint *wp,
2171                             Sculpt *sd,
2172                             struct WPaintData *wpd,
2173                             WeightPaintInfo *wpi,
2174                             Mesh *me,
2175                             Brush *brush,
2176                             const char symm,
2177                             const int axis,
2178                             const int i,
2179                             const float angle)
2180 {
2181   SculptSession *ss = ob->sculpt;
2182   ss->cache->radial_symmetry_pass = i;
2183   sculpt_cache_calc_brushdata_symm(ss->cache, symm, axis, angle);
2184
2185   int totnode;
2186   PBVHNode **nodes = vwpaint_pbvh_gather_generic(ob, wp, sd, brush, &totnode);
2187
2188   wpaint_paint_leaves(C, ob, sd, wp, wpd, wpi, me, nodes, totnode);
2189
2190   if (nodes) {
2191     MEM_freeN(nodes);
2192   }
2193 }
2194
2195 static void wpaint_do_radial_symmetry(bContext *C,
2196                                       Object *ob,
2197                                       VPaint *wp,
2198                                       Sculpt *sd,
2199                                       struct WPaintData *wpd,
2200                                       WeightPaintInfo *wpi,
2201                                       Mesh *me,
2202                                       Brush *brush,
2203                                       const char symm,
2204                                       const int axis)
2205 {
2206   for (int i = 1; i < wp->radial_symm[axis - 'X']; i++) {
2207     const float angle = (2.0 * M_PI) * i / wp->radial_symm[axis - 'X'];
2208     wpaint_do_paint(C, ob, wp, sd, wpd, wpi, me, brush, symm, axis, i, angle);
2209   }
2210 }
2211
2212 /* near duplicate of: sculpt.c's,
2213  * 'do_symmetrical_brush_actions' and 'vpaint_do_symmetrical_brush_actions'. */
2214 static void wpaint_do_symmetrical_brush_actions(
2215     bContext *C, Object *ob, VPaint *wp, Sculpt *sd, struct WPaintData *wpd, WeightPaintInfo *wpi)
2216 {
2217   Brush *brush = BKE_paint_brush(&wp->paint);
2218   Mesh *me = ob->data;
2219   SculptSession *ss = ob->sculpt;
2220   StrokeCache *cache = ss->cache;
2221   const char symm = wp->paint.symmetry_flags & PAINT_SYMM_AXIS_ALL;
2222   int i = 0;
2223
2224   /* initial stroke */
2225   wpaint_do_paint(C, ob, wp, sd, wpd, wpi, me, brush, 0, 'X', 0, 0);
2226   wpaint_do_radial_symmetry(C, ob, wp, sd, wpd, wpi, me, brush, 0, 'X');
2227   wpaint_do_radial_symmetry(C, ob, wp, sd, wpd, wpi, me, brush, 0, 'Y');
2228   wpaint_do_radial_symmetry(C, ob, wp, sd, wpd, wpi, me, brush, 0, 'Z');
2229
2230   cache->symmetry = symm;
2231
2232   /* symm is a bit combination of XYZ - 1 is mirror
2233    * X; 2 is Y; 3 is XY; 4 is Z; 5 is XZ; 6 is YZ; 7 is XYZ */
2234   for (i = 1; i <= symm; i++) {
2235     if ((symm & i && (symm != 5 || i != 3) && (symm != 6 || (i != 3 && i != 5)))) {
2236       cache->mirror_symmetry_pass = i;
2237       cache->radial_symmetry_pass = 0;
2238       sculpt_cache_calc_brushdata_symm(cache, i, 0, 0);
2239
2240       if (i & (1 << 0)) {
2241         wpaint_do_paint(C, ob, wp, sd, wpd, wpi, me, brush, i, 'X', 0, 0);
2242         wpaint_do_radial_symmetry(C, ob, wp, sd, wpd, wpi, me, brush, i, 'X');
2243       }
2244       if (i & (1 << 1)) {
2245         wpaint_do_paint(C, ob, wp, sd, wpd, wpi, me, brush, i, 'Y', 0, 0);
2246         wpaint_do_radial_symmetry(C, ob, wp, sd, wpd, wpi, me, brush, i, 'Y');
2247       }
2248       if (i & (1 << 2)) {
2249         wpaint_do_paint(C, ob, wp, sd, wpd, wpi, me, brush, i, 'Z', 0, 0);
2250         wpaint_do_radial_symmetry(C, ob, wp, sd, wpd, wpi, me, brush, i, 'Z');
2251       }
2252     }
2253   }
2254   copy_v3_v3(cache->true_last_location, cache->true_location);
2255   cache->is_last_valid = true;
2256 }
2257
2258 static void wpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, PointerRNA *itemptr)
2259 {
2260   Scene *scene = CTX_data_scene(C);
2261   ToolSettings *ts = CTX_data_tool_settings(C);
2262   VPaint *wp = ts->wpaint;
2263   Brush *brush = BKE_paint_brush(&wp->paint);
2264   struct WPaintData *wpd = paint_stroke_mode_data(stroke);
2265   ViewContext *vc;
2266   Object *ob = CTX_data_active_object(C);
2267
2268   SculptSession *ss = ob->sculpt;
2269   Sculpt *sd = CTX_data_tool_settings(C)->sculpt;
2270
2271   vwpaint_update_cache_variants(C, wp, ob, itemptr);
2272
2273   float mat[4][4];
2274
2275   const float brush_alpha_value = BKE_brush_alpha_get(scene, brush);
2276
2277   /* intentionally don't initialize as NULL, make sure we initialize all members below */
2278   WeightPaintInfo wpi;
2279
2280   /* cannot paint if there is no stroke data */
2281   if (wpd == NULL) {
2282     /* XXX: force a redraw here, since even though we can't paint,
2283      * at least view won't freeze until stroke ends */
2284     ED_region_tag_redraw(CTX_wm_region(C));
2285     return;
2286   }
2287
2288   vc = &wpd->vc;
2289   ob = vc->obact;
2290
2291   view3d_operator_needs_opengl(C);
2292   ED_view3d_init_mats_rv3d(ob, vc->rv3d);
2293
2294   /* load projection matrix */
2295   mul_m4_m4m4(mat, vc->rv3d->persmat, ob->obmat);
2296
2297   /* *** setup WeightPaintInfo - pass onto do_weight_paint_vertex *** */
2298   wpi.defbase_tot = wpd->defbase_tot;
2299   wpi.defbase_sel = wpd->defbase_sel;
2300   wpi.defbase_tot_sel = wpd->defbase_tot_sel;
2301
2302   wpi.defbase_tot_unsel = wpi.defbase_tot - wpi.defbase_tot_sel;
2303   wpi.active = wpd->active;
2304   wpi.mirror = wpd->mirror;
2305   wpi.lock_flags = wpd->lock_flags;
2306   wpi.vgroup_validmap = wpd->vgroup_validmap;
2307   wpi.do_flip = RNA_boolean_get(itemptr, "pen_flip");
2308   wpi.do_multipaint = wpd->do_multipaint;
2309   wpi.do_auto_normalize = ((ts->auto_normalize != 0) && (wpi.vgroup_validmap != NULL));
2310   wpi.brush_alpha_value = brush_alpha_value;
2311   /* *** done setting up WeightPaintInfo *** */
2312
2313   if (wpd->precomputed_weight) {
2314     precompute_weight_values(C, ob, brush, wpd, &wpi, ob->data);
2315   }
2316
2317   wpaint_do_symmetrical_brush_actions(C, ob, wp, sd, wpd, &wpi);
2318
2319   swap_m4m4(vc->rv3d->persmat, mat);
2320
2321   /* calculate pivot for rotation around seletion if needed */
2322   /* also needed for "View Selected" on last stroke */
2323   paint_last_stroke_update(scene, vc->ar, ss->cache->mouse);
2324
2325   BKE_mesh_batch_cache_dirty_tag(ob->data, BKE_MESH_BATCH_DIRTY_ALL);
2326
2327   DEG_id_tag_update(ob->data, 0);
2328   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
2329   swap_m4m4(wpd->vc.rv3d->persmat, mat);
2330
2331   rcti r;
2332   if (sculpt_get_redraw_rect(vc->ar, CTX_wm_region_view3d(C), ob, &r)) {
2333     if (ss->cache) {
2334       ss->cache->current_r = r;
2335     }
2336
2337     /* previous is not set in the current cache else
2338      * the partial rect will always grow */
2339     if (ss->cache) {
2340       if (!BLI_rcti_is_empty(&ss->cache->previous_r)) {
2341         BLI_rcti_union(&r, &ss->cache->previous_r);
2342       }
2343     }
2344
2345     r.xmin += vc->ar->winrct.xmin - 2;
2346     r.xmax += vc->ar->winrct.xmin + 2;
2347     r.ymin += vc->ar->winrct.ymin - 2;
2348     r.ymax += vc->ar->winrct.ymin + 2;
2349   }
2350   ED_region_tag_redraw_partial(vc->ar, &r, true);
2351 }
2352
2353 static void wpaint_stroke_done(const bContext *C, struct PaintStroke *stroke)
2354 {
2355   Object *ob = CTX_data_active_object(C);
2356   struct WPaintData *wpd = paint_stroke_mode_data(stroke);
2357
2358   if (wpd) {
2359     if (wpd->defbase_sel) {
2360       MEM_freeN((void *)wpd->defbase_sel);
2361     }
2362     if (wpd->vgroup_validmap) {
2363       MEM_freeN((void *)wpd->vgroup_validmap);
2364     }
2365     if (wpd->lock_flags) {
2366       MEM_freeN((void *)wpd->lock_flags);
2367     }
2368     if (wpd->active.lock) {
2369       MEM_freeN((void *)wpd->active.lock);
2370     }
2371     if (wpd->mirror.lock) {
2372       MEM_freeN((void *)wpd->mirror.lock);
2373     }
2374     if (wpd->precomputed_weight) {
2375       MEM_freeN(wpd->precomputed_weight);
2376     }
2377
2378     MEM_freeN(wpd);
2379   }
2380
2381   /* and particles too */
2382   if (ob->particlesystem.first) {
2383     ParticleSystem *psys;
2384     int i;
2385
2386     for (psys = ob->particlesystem.first; psys; psys = psys->next) {
2387       for (i = 0; i < PSYS_TOT_VG; i++) {
2388         if (psys->vgroup[i] == ob->actdef) {
2389           psys->recalc |= ID_RECALC_PSYS_RESET;
2390           break;
2391         }
2392       }
2393     }
2394   }
2395
2396   DEG_id_tag_update(ob->data, 0);
2397
2398   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
2399
2400   sculpt_cache_free(ob->sculpt->cache);
2401   ob->sculpt->cache = NULL;
2402 }
2403
2404 static int wpaint_invoke(bContext *C, wmOperator *op, const wmEvent *event)
2405 {
2406   int retval;
2407
2408   op->customdata = paint_stroke_new(C,
2409                                     op,
2410                                     sculpt_stroke_get_location,
2411                                     wpaint_stroke_test_start,
2412                                     wpaint_stroke_update_step,
2413                                     NULL,
2414                                     wpaint_stroke_done,
2415                                     event->type);
2416
2417   if ((retval = op->type->modal(C, op, event)) == OPERATOR_FINISHED) {
2418     paint_stroke_data_free(op);
2419     return OPERATOR_FINISHED;
2420   }
2421   /* add modal handler */
2422   WM_event_add_modal_handler(C, op);
2423
2424   OPERATOR_RETVAL_CHECK(retval);
2425   BLI_assert(retval == OPERATOR_RUNNING_MODAL);
2426
2427   return OPERATOR_RUNNING_MODAL;
2428 }
2429
2430 static int wpaint_exec(bContext *C, wmOperator *op)
2431 {
2432   op->customdata = paint_stroke_new(C,
2433                                     op,
2434                                     sculpt_stroke_get_location,
2435                                     wpaint_stroke_test_start,
2436                                     wpaint_stroke_update_step,
2437                                     NULL,
2438                                     wpaint_stroke_done,
2439                                     0);
2440
2441   /* frees op->customdata */
2442   paint_stroke_exec(C, op);
2443
2444   return OPERATOR_FINISHED;
2445 }
2446
2447 static void wpaint_cancel(bContext *C, wmOperator *op)
2448 {
2449   Object *ob = CTX_data_active_object(C);
2450   if (ob->sculpt->cache) {
2451     sculpt_cache_free(ob->sculpt->cache);
2452     ob->sculpt->cache = NULL;
2453   }
2454
2455   paint_stroke_cancel(C, op);
2456 }
2457
2458 void PAINT_OT_weight_paint(wmOperatorType *ot)
2459 {
2460   /* identifiers */
2461   ot->name = "Weight Paint";
2462   ot->idname = "PAINT_OT_weight_paint";
2463   ot->description = "Paint a stroke in the current vertex group's weights";
2464
2465   /* api callbacks */
2466   ot->invoke = wpaint_invoke;
2467   ot->modal = paint_stroke_modal;
2468   ot->exec = wpaint_exec;
2469   ot->poll = weight_paint_poll;
2470   ot->cancel = wpaint_cancel;
2471
2472   /* flags */
2473   ot->flag = OPTYPE_UNDO | OPTYPE_BLOCKING;
2474
2475   paint_stroke_operator_properties(ot);
2476 }
2477
2478 /** \} */
2479
2480 /* -------------------------------------------------------------------- */
2481 /** \name Toggle Vertex Paint Operator
2482  * \{ */
2483
2484 /**
2485  * \note Keep in sync with #wpaint_mode_toggle_exec
2486  */
2487 static int vpaint_mode_toggle_exec(bContext *C, wmOperator *op)
2488 {
2489   Main *bmain = CTX_data_main(C);
2490   struct wmMsgBus *mbus = CTX_wm_message_bus(C);
2491   Object *ob = CTX_data_active_object(C);
2492   const int mode_flag = OB_MODE_VERTEX_PAINT;
2493   const bool is_mode_set = (ob->mode & mode_flag) != 0;
2494   Scene *scene = CTX_data_scene(C);
2495   ToolSettings *ts = scene->toolsettings;
2496
2497   if (!is_mode_set) {
2498     if (!ED_object_mode_compat_set(C, ob, mode_flag, op->reports)) {
2499       return OPERATOR_CANCELLED;
2500     }
2501   }
2502
2503   Mesh *me = BKE_mesh_from_object(ob);
2504
2505   /* toggle: end vpaint */
2506   if (is_mode_set) {
2507     ED_object_vpaintmode_exit_ex(ob);
2508   }
2509   else {
2510     Depsgraph *depsgraph = CTX_data_depsgraph_on_load(C);
2511     wmWindowManager *wm = CTX_wm_manager(C);
2512     ED_object_vpaintmode_enter_ex(bmain, depsgraph, wm, scene, ob);
2513     BKE_paint_toolslots_brush_validate(bmain, &ts->vpaint->paint);
2514   }
2515
2516   BKE_mesh_batch_cache_dirty_tag(ob->data, BKE_MESH_BATCH_DIRTY_ALL);
2517
2518   /* update modifier stack for mapping requirements */
2519   DEG_id_tag_update(&me->id, 0);
2520
2521   WM_event_add_notifier(C, NC_SCENE | ND_MODE, scene);
2522
2523   WM_msg_publish_rna_prop(mbus, &ob->id, ob, Object, mode);
2524
2525   WM_toolsystem_update_from_context_view3d(C);
2526
2527   return OPERATOR_FINISHED;
2528 }
2529
2530 void PAINT_OT_vertex_paint_toggle(wmOperatorType *ot)
2531 {
2532   /* identifiers */
2533   ot->name = "Vertex Paint Mode";
2534   ot->idname = "PAINT_OT_vertex_paint_toggle";
2535   ot->description = "Toggle the vertex paint mode in 3D view";
2536
2537   /* api callbacks */
2538   ot->exec = vpaint_mode_toggle_exec;
2539   ot->poll = paint_poll_test;
2540
2541   /* flags */
2542   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_USE_EVAL_DATA;
2543 }
2544
2545 /** \} */
2546
2547 /* -------------------------------------------------------------------- */
2548 /** \name Vertex Paint Operator
2549  * \{ */
2550
2551 /* Implementation notes:
2552  *
2553  * Operator->invoke()
2554  * - validate context (add mcol)
2555  * - create customdata storage
2556  * - call paint once (mouse click)
2557  * - add modal handler
2558  *
2559  * Operator->modal()
2560  * - for every mousemove, apply vertex paint
2561  * - exit on mouse release, free customdata
2562  *   (return OPERATOR_FINISHED also removes handler and operator)
2563  *
2564  * For future:
2565  * - implement a stroke event (or mousemove with past positions)
2566  * - revise whether op->customdata should be added in object, in set_vpaint
2567  */
2568
2569 typedef struct PolyFaceMap {
2570   struct PolyFaceMap *next, *prev;
2571   int facenr;
2572 } PolyFaceMap;
2573
2574 struct VPaintData {
2575   ViewContext vc;
2576   struct NormalAnglePrecalc normal_angle_precalc;
2577
2578   uint paintcol;
2579
2580   struct VertProjHandle *vp_handle;
2581   struct CoNo *vertexcosnos;
2582
2583   /* modify 'me->mcol' directly, since the derived mesh is drawing from this
2584    * array, otherwise we need to refresh the modifier stack */
2585   bool use_fast_update;
2586
2587   /* loops tagged as having been painted, to apply shared vertex color
2588    * blending only to modified loops */
2589   bool *mlooptag;
2590
2591   bool is_texbrush;
2592
2593   /* Special storage for smear brush, avoid feedback loop - update each step. */
2594   struct {
2595     uint *color_prev;
2596     uint *color_curr;
2597   } smear;
2598 };
2599
2600 static bool vpaint_stroke_test_start(bContext *C, struct wmOperator *op, const float mouse[2])
2601 {
2602   Scene *scene = CTX_data_scene(C);
2603   ToolSettings *ts = scene->toolsettings;
2604   struct PaintStroke *stroke = op->customdata;
2605   VPaint *vp = ts->vpaint;
2606   Brush *brush = BKE_paint_brush(&vp->paint);
2607   struct VPaintData *vpd;
2608   Object *ob = CTX_data_active_object(C);
2609   Mesh *me;
2610   SculptSession *ss = ob->sculpt;
2611   Depsgraph *depsgraph = CTX_data_depsgraph(C);
2612
2613   /* context checks could be a poll() */
2614   me = BKE_mesh_from_object(ob);
2615   if (me == NULL || me->totpoly == 0) {
2616     return false;
2617   }
2618
2619   ED_mesh_color_ensure(me, NULL);
2620   if (me->mloopcol == NULL) {
2621     return false;
2622   }
2623
2624   /* make mode data storage */
2625   vpd = MEM_callocN(sizeof(*vpd), "VPaintData");
2626   paint_stroke_set_mode_data(stroke, vpd);
2627   ED_view3d_viewcontext_init(C, &vpd->vc);
2628   view_angle_limits_init(&vpd->normal_angle_precalc,
2629                          vp->paint.brush->falloff_angle,
2630                          (vp->paint.brush->flag & BRUSH_FRONTFACE_FALLOFF) != 0);
2631
2632   vpd->paintcol = vpaint_get_current_col(
2633       scene, vp, (RNA_enum_get(op->ptr, "mode") == BRUSH_STROKE_INVERT));
2634
2635   vpd->is_texbrush = !(brush->vertexpaint_tool == VPAINT_TOOL_BLUR) && brush->mtex.tex;
2636
2637   /* are we painting onto a modified mesh?,
2638    * if not we can skip face map trickiness */
2639   if (vertex_paint_use_fast_update_check(ob)) {
2640     vpd->use_fast_update = true;
2641     /*      printf("Fast update!\n");*/
2642   }
2643   else {
2644     vpd->use_fast_update = false;
2645     /*      printf("No fast update!\n");*/
2646   }
2647
2648   /* to keep tracked of modified loops for shared vertex color blending */
2649   if (brush->vertexpaint_tool == VPAINT_TOOL_BLUR) {
2650     vpd->mlooptag = MEM_mallocN(sizeof(bool) * me->totloop, "VPaintData mlooptag");
2651   }
2652
2653   if (brush->vertexpaint_tool == VPAINT_TOOL_SMEAR) {
2654     vpd->smear.color_prev = MEM_mallocN(sizeof(uint) * me->totloop, __func__);
2655     memcpy(vpd->smear.color_prev, me->mloopcol, sizeof(uint) * me->totloop);
2656     vpd->smear.color_curr = MEM_dupallocN(vpd->smear.color_prev);
2657   }
2658
2659   /* Create projection handle */
2660   if (vpd->is_texbrush) {
2661     ob->sculpt->building_vp_handle = true;
2662     vpd->vp_handle = ED_vpaint_proj_handle_create(depsgraph, scene, ob, &vpd->vertexcosnos);
2663     ob->sculpt->building_vp_handle = false;
2664   }
2665
2666   /* If not previously created, create vertex/weight paint mode session data */
2667   vertex_paint_init_stroke(depsgraph, ob);
2668   vwpaint_update_cache_invariants(C, vp, ss, op, mouse);
2669   vertex_paint_init_session_data(ts, ob);
2670
2671   if (ob->sculpt->mode.vpaint.previous_color != NULL) {
2672     memset(ob->sculpt->mode.vpaint.previous_color, 0, sizeof(uint) * me->totloop);
2673   }
2674
2675   return 1;
2676 }
2677
2678 static void do_vpaint_brush_calc_average_color_cb_ex(
2679     void *__restrict userdata, const int n, const ParallelRangeTLS *__restrict UNUSED(tls))
2680 {
2681   SculptThreadedTaskData *data = userdata;
2682   SculptSession *ss = data->ob->sculpt;
2683   const PBVHType pbvh_type = BKE_pbvh_type(ss->pbvh);
2684   const bool has_grids = (pbvh_type == PBVH_GRIDS);
2685   const struct SculptVertexPaintGeomMap *gmap = &ss->mode.vpaint.gmap;
2686
2687   StrokeCache *cache = ss->cache;
2688   uint *lcol = data->lcol;
2689   char *col;
2690   const bool use_vert_sel = (data->me->editflag &
2691                              (ME_EDIT_PAINT_FACE_SEL | ME_EDIT_PAINT_VERT_SEL)) != 0;
2692
2693   struct VPaintAverageAccum *accum = (struct VPaintAverageAccum *)data->custom_data + n;
2694   accum->len = 0;
2695   memset(accum->value, 0, sizeof(accum->value));
2696
2697   SculptBrushTest test;
2698   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
2699       ss, &test, data->brush->falloff_shape);
2700
2701   /* For each vertex */
2702   PBVHVertexIter vd;
2703   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
2704   {
2705     /* Test to see if the vertex coordinates are within the spherical brush region. */
2706     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
2707       const int v_index = has_grids ? data->me->mloop[vd.grid_indices[vd.g]].v :
2708                                       vd.vert_indices[vd.i];
2709       if (BKE_brush_curve_strength(data->brush, 0.0, cache->radius) > 0.0) {
2710         /* If the vertex is selected for painting. */
2711         const MVert *mv = &data->me->mvert[v_index];
2712         if (!use_vert_sel || mv->flag & SELECT) {
2713           accum->len += gmap->vert_to_loop[v_index].count;
2714           /* if a vertex is within the brush region, then add it's color to the blend. */
2715           for (int j = 0; j < gmap->vert_to_loop[v_index].count; j++) {
2716             const int l_index = gmap->vert_to_loop[v_index].indices[j];
2717             col = (char *)(&lcol[l_index]);
2718             /* Color is squared to compensate the sqrt color encoding. */
2719             accum->value[0] += col[0] * col[0];
2720             accum->value[1] += col[1] * col[1];
2721             accum->value[2] += col[2] * col[2];
2722           }
2723         }
2724       }
2725     }
2726   }
2727   BKE_pbvh_vertex_iter_end;
2728 }
2729
2730 static float tex_color_alpha_ubyte(SculptThreadedTaskData *data,
2731                                    const float v_co[3],
2732                                    uint *r_color)
2733 {
2734   float rgba[4];
2735   float rgba_br[3];
2736   tex_color_alpha(data->vp, &data->vpd->vc, v_co, rgba);
2737   rgb_uchar_to_float(rgba_br, (const uchar *)&data->vpd->paintcol);
2738   mul_v3_v3(rgba_br, rgba);
2739   rgb_float_to_uchar((uchar *)r_color, rgba_br);
2740   return rgba[3];
2741 }
2742
2743 static void do_vpaint_brush_draw_task_cb_ex(void *__restrict userdata,
2744                                             const int n,
2745                                             const ParallelRangeTLS *__restrict UNUSED(tls))
2746 {
2747   SculptThreadedTaskData *data = userdata;
2748   SculptSession *ss = data->ob->sculpt;
2749   const PBVHType pbvh_type = BKE_pbvh_type(ss->pbvh);
2750   const bool has_grids = (pbvh_type == PBVH_GRIDS);
2751   const struct SculptVertexPaintGeomMap *gmap = &ss->mode.vpaint.gmap;
2752
2753   const Brush *brush = data->brush;
2754   const StrokeCache *cache = ss->cache;
2755   uint *lcol = data->lcol;
2756   const Scene *scene = CTX_data_scene(data->C);
2757   float brush_size_pressure, brush_alpha_value, brush_alpha_pressure;
2758   get_brush_alpha_data(
2759       scene, ss, brush, &brush_size_pressure, &brush_alpha_value, &brush_alpha_pressure);
2760   const bool use_normal = vwpaint_use_normal(data->vp);
2761   const bool use_vert_sel = (data->me->editflag &
2762                              (ME_EDIT_PAINT_FACE_SEL | ME_EDIT_PAINT_VERT_SEL)) != 0;
2763   const bool use_face_sel = (data->me->editflag & ME_EDIT_PAINT_FACE_SEL) != 0;
2764
2765   SculptBrushTest test;
2766   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
2767       ss, &test, data->brush->falloff_shape);
2768   const float *sculpt_normal_frontface = sculpt_brush_frontface_normal_from_falloff_shape(
2769       ss, data->brush->falloff_shape);
2770
2771   /* For each vertex */
2772   PBVHVertexIter vd;
2773   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
2774   {
2775     /* Test to see if the vertex coordinates are within the spherical brush region. */
2776     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
2777       /* Note: Grids are 1:1 with corners (aka loops).
2778        * For grid based pbvh, take the vert whose loop corresponds to the current grid.
2779        * Otherwise, take the current vert. */
2780       const int v_index = has_grids ? data->me->mloop[vd.grid_indices[vd.g]].v :
2781                                       vd.vert_indices[vd.i];
2782       const float grid_alpha = has_grids ? 1.0f / vd.gridsize : 1.0f;
2783       const MVert *mv = &data->me->mvert[v_index];
2784
2785       /* If the vertex is selected for painting. */
2786       if (!use_vert_sel || mv->flag & SELECT) {
2787         /* Calc the dot prod. between ray norm on surf and current vert
2788          * (ie splash prevention factor), and only paint front facing verts. */
2789         float brush_strength = cache->bstrength;
2790         const float angle_cos = (use_normal && vd.no) ?
2791                                     dot_vf3vs3(sculpt_normal_frontface, vd.no) :
2792                                     1.0f;
2793         if (((brush->flag & BRUSH_FRONTFACE) == 0 || (angle_cos > 0.0f)) &&
2794             ((brush->flag & BRUSH_FRONTFACE_FALLOFF) == 0 ||
2795              view_angle_limits_apply_falloff(
2796                  &data->vpd->normal_angle_precalc, angle_cos, &brush_strength))) {
2797           const float brush_fade = BKE_brush_curve_strength(
2798               brush, sqrtf(test.dist), cache->radius);
2799           uint color_final = data->vpd->paintcol;
2800
2801           /* If we're painting with a texture, sample the texture color and alpha. */
2802           float tex_alpha = 1.0;
2803           if (data->vpd->is_texbrush) {
2804             /* Note: we may want to paint alpha as vertex color alpha. */
2805             tex_alpha = tex_color_alpha_ubyte(
2806                 data, data->vpd->vertexcosnos[v_index].co, &color_final);
2807           }
2808           /* For each poly owning this vert, paint each loop belonging to this vert. */
2809           for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
2810             const int p_index = gmap->vert_to_poly[v_index].indices[j];
2811             const int l_index = gmap->vert_to_loop[v_index].indices[j];
2812             BLI_assert(data->me->mloop[l_index].v == v_index);
2813             const MPoly *mp = &data->me->mpoly[p_index];
2814             if (!use_face_sel || mp->flag & ME_FACE_SEL) {
2815               uint color_orig = 0; /* unused when array is NULL */
2816               if (ss->mode.vpaint.previous_color != NULL) {
2817                 /* Get the previous loop color */
2818                 if (ss->mode.vpaint.previous_color[l_index] == 0) {
2819                   ss->mode.vpaint.previous_color[l_index] = lcol[l_index];
2820                 }
2821                 color_orig = ss->mode.vpaint.previous_color[l_index];
2822               }
2823               const float final_alpha = 255 * brush_fade * brush_strength * tex_alpha *
2824                                         brush_alpha_pressure * grid_alpha;
2825
2826               /* Mix the new color with the original based on final_alpha. */
2827               lcol[l_index] = vpaint_blend(data->vp,
2828                                            lcol[l_index],
2829                                            color_orig,
2830                                            color_final,
2831                                            final_alpha,
2832                                            255 * brush_strength);
2833             }
2834           }
2835         }
2836       }
2837     }
2838   }
2839   BKE_pbvh_vertex_iter_end;
2840 }
2841
2842 static void do_vpaint_brush_blur_task_cb_ex(void *__restrict userdata,
2843                                             const int n,
2844                                             const ParallelRangeTLS *__restrict UNUSED(tls))
2845 {
2846   SculptThreadedTaskData *data = userdata;
2847   SculptSession *ss = data->ob->sculpt;
2848   const PBVHType pbvh_type = BKE_pbvh_type(ss->pbvh);
2849   const bool has_grids = (pbvh_type == PBVH_GRIDS);
2850
2851   Scene *scene = CTX_data_scene(data->C);
2852   const struct SculptVertexPaintGeomMap *gmap = &ss->mode.vpaint.gmap;
2853   const Brush *brush = data->brush;
2854   const StrokeCache *cache = ss->cache;
2855   uint *lcol = data->lcol;
2856   float brush_size_pressure, brush_alpha_value, brush_alpha_pressure;
2857   get_brush_alpha_data(
2858       scene, ss, brush, &brush_size_pressure, &brush_alpha_value, &brush_alpha_pressure);
2859   const bool use_normal = vwpaint_use_normal(data->vp);
2860   const bool use_vert_sel = (data->me->editflag &
2861                              (ME_EDIT_PAINT_FACE_SEL | ME_EDIT_PAINT_VERT_SEL)) != 0;
2862   const bool use_face_sel = (data->me->editflag & ME_EDIT_PAINT_FACE_SEL) != 0;
2863
2864   SculptBrushTest test;
2865   SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
2866       ss, &test, data->brush->falloff_shape);
2867   const float *sculpt_normal_frontface = sculpt_brush_frontface_normal_from_falloff_shape(
2868       ss, data->brush->falloff_shape);
2869
2870   /* For each vertex */
2871   PBVHVertexIter vd;
2872   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
2873   {
2874     /* Test to see if the vertex coordinates are within the spherical brush region. */
2875     if (sculpt_brush_test_sq_fn(&test, vd.co)) {
2876       /* For grid based pbvh, take the vert whose loop corresponds to the current grid.
2877        * Otherwise, take the current vert. */
2878       const int v_index = has_grids ? data->me->mloop[vd.grid_indices[vd.g]].v :
2879                                       vd.vert_indices[vd.i];
2880       const float grid_alpha = has_grids ? 1.0f / vd.gridsize : 1.0f;
2881       const MVert *mv = &data->me->mvert[v_index];
2882
2883       /* If the vertex is selected for painting. */
2884       if (!use_vert_sel || mv->flag & SELECT) {
2885         float brush_strength = cache->bstrength;
2886         const float angle_cos = (use_normal && vd.no) ?
2887                                     dot_vf3vs3(sculpt_normal_frontface, vd.no) :
2888                                     1.0f;
2889         if (((brush->flag & BRUSH_FRONTFACE) == 0 || (angle_cos > 0.0f)) &&
2890             ((brush->flag & BRUSH_FRONTFACE_FALLOFF) == 0 ||
2891              view_angle_limits_apply_falloff(
2892                  &data->vpd->normal_angle_precalc, angle_cos, &brush_strength))) {
2893           const float brush_fade = BKE_brush_curve_strength(
2894               brush, sqrtf(test.dist), cache->radius);
2895
2896           /* Get the average poly color */
2897           uint color_final = 0;
2898           int total_hit_loops = 0;
2899           uint blend[4] = {0};
2900           for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
2901             int p_index = gmap->vert_to_poly[v_index].indices[j];
2902             const MPoly *mp = &data->me->mpoly[p_index];
2903             if (!use_face_sel || mp->flag & ME_FACE_SEL) {
2904               total_hit_loops += mp->totloop;
2905               for (int k = 0; k < mp->totloop; k++) {
2906                 const uint l_index = mp->loopstart + k;
2907                 const char *col = (const char *)(&lcol[l_index]);
2908                 /* Color is squared to compensate the sqrt color encoding. */
2909                 blend[0] += (uint)col[0] * (uint)col[0];
2910                 blend[1] += (uint)col[1] * (uint)col[1];
2911                 blend[2] += (uint)col[2] * (uint)col[2];
2912                 blend[3] += (uint)col[3] * (uint)col[3];
2913               }
2914             }
2915           }
2916           if (total_hit_loops != 0) {
2917             /* Use rgb^2 color averaging. */
2918             char *col = (char *)(&color_final);
2919             col[0] = round_fl_to_uchar(sqrtf(divide_round_i(blend[0], total_hit_loops)));
2920             col[1] = round_fl_to_uchar(sqrtf(divide_round_i(blend[1], total_hit_loops)));
2921             col[2] = round_fl_to_uchar(sqrtf(divide_round_i(blend[2], total_hit_loops)));
2922             col[3] = round_fl_to_uchar(sqrtf(divide_round_i(blend[3], total_hit_loops)));
2923
2924             /* For each poly owning this vert,
2925              * paint each loop belonging to this vert. */
2926             for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
2927               const int p_index = gmap->vert_to_poly[v_index].indices[j];
2928               const int l_index = gmap->vert_to_loop[v_index].indices[j];
2929               BLI_assert(data->me->mloop[l_index].v == v_index);
2930               const MPoly *mp = &data->me->mpoly[p_index];
2931               if (!use_face_sel || mp->flag & ME_FACE_SEL) {
2932                 uint color_orig = 0; /* unused when array is NULL */
2933                 if (ss->mode.vpaint.previous_color != NULL) {
2934                   /* Get the previous loop color */
2935                   if (ss->mode.vpaint.previous_color[l_index] == 0) {
2936                     ss->mode.vpaint.previous_color[l_index] = lcol[l_index];
2937                   }
2938                   color_orig = ss->mode.vpaint.previous_color[l_index];
2939                 }
2940                 const float final_alpha = 255 * brush_fade * brush_strength *
2941                                           brush_alpha_pressure * grid_alpha;
2942                 /* Mix the new color with the original
2943                  * based on the brush strength and the curve. */
2944                 lcol[l_index] = vpaint_blend(data->vp,
2945                                              lcol[l_index],
2946                                              color_orig,
2947                                              *((uint *)col),
2948                                              final_alpha,
2949                                              255 * brush_strength);
2950               }
2951             }
2952           }
2953         }
2954       }
2955     }
2956   }
2957   BKE_pbvh_vertex_iter_end;
2958 }
2959
2960 static void do_vpaint_brush_smear_task_cb_ex(void *__restrict userdata,
2961                                              const int n,
2962                                              const ParallelRangeTLS *__restrict UNUSED(tls))
2963 {
2964   SculptThreadedTaskData *data = userdata;
2965   SculptSession *ss = data->ob->sculpt;
2966   const PBVHType pbvh_type = BKE_pbvh_type(ss->pbvh);
2967   const bool has_grids = (pbvh_type == PBVH_GRIDS);
2968
2969   Scene *scene = CTX_data_scene(data->C);
2970   const struct SculptVertexPaintGeomMap *gmap = &ss->mode.vpaint.gmap;
2971   const Brush *brush = data->brush;
2972   const StrokeCache *cache = ss->cache;
2973   uint *lcol = data->lcol;
2974   float brush_size_pressure, brush_alpha_value, brush_alpha_pressure;
2975   get_brush_alpha_data(
2976       scene, ss, brush, &brush_size_pressure, &brush_alpha_value, &brush_alpha_pressure);
2977   float brush_dir[3];
2978   const bool use_normal = vwpaint_use_normal(data->vp);
2979   const bool use_vert_sel = (data->me->editflag &
2980                              (ME_EDIT_PAINT_FACE_SEL | ME_EDIT_PAINT_VERT_SEL)) != 0;
2981   const bool use_face_sel = (data->me->editflag & ME_EDIT_PAINT_FACE_SEL) != 0;
2982
2983   sub_v3_v3v3(brush_dir, cache->location, cache->last_location);
2984   project_plane_v3_v3v3(brush_dir, brush_dir, cache->view_normal);
2985
2986   if (cache->is_last_valid && (normalize_v3(brush_dir) != 0.0f)) {
2987
2988     SculptBrushTest test;
2989     SculptBrushTestFn sculpt_brush_test_sq_fn = sculpt_brush_test_init_with_falloff_shape(
2990         ss, &test, data->brush->falloff_shape);
2991     const float *sculpt_normal_frontface = sculpt_brush_frontface_normal_from_falloff_shape(
2992         ss, data->brush->falloff_shape);
2993
2994     /* For each vertex */
2995     PBVHVertexIter vd;
2996     BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
2997     {
2998       /* Test to see if the vertex coordinates are within the spherical brush region. */
2999       if (sculpt_brush_test_sq_fn(&test, vd.co)) {
3000         /* For grid based pbvh, take the vert whose loop corresponds to the current grid.
3001          * Otherwise, take the current vert. */
3002         const int v_index = has_grids ? data->me->mloop[vd.grid_indices[vd.g]].v :
3003                                         vd.vert_indices[vd.i];
3004         const float grid_alpha = has_grids ? 1.0f / vd.gridsize : 1.0f;
3005         const MVert *mv_curr = &data->me->mvert[v_index];
3006
3007         /* if the vertex is selected for painting. */
3008         if (!use_vert_sel || mv_curr->flag & SELECT) {
3009           /* Calc the dot prod. between ray norm on surf and current vert
3010            * (ie splash prevention factor), and only paint front facing verts. */
3011           float brush_strength = cache->bstrength;
3012           const float angle_cos = (use_normal && vd.no) ?
3013                                       dot_vf3vs3(sculpt_normal_frontface, vd.no) :
3014                                       1.0f;
3015           if (((brush->flag & BRUSH_FRONTFACE) == 0 || (angle_cos > 0.0f)) &&
3016               ((brush->flag & BRUSH_FRONTFACE_FALLOFF) == 0 ||
3017                view_angle_limits_apply_falloff(
3018                    &data->vpd->normal_angle_precalc, angle_cos, &brush_strength))) {
3019             const float brush_fade = BKE_brush_curve_strength(
3020                 brush, sqrtf(test.dist), cache->radius);
3021
3022             bool do_color = false;
3023             /* Minimum dot product between brush direction and current
3024              * to neighbor direction is 0.0, meaning orthogonal. */
3025             float stroke_dot_max = 0.0f;
3026
3027             /* Get the color of the loop in the opposite
3028              * direction of the brush movement */
3029             uint color_final = 0;
3030             for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
3031               const int p_index = gmap->vert_to_poly[v_index].indices[j];
3032               const int l_index = gmap->vert_to_loop[v_index].indices[j];
3033               BLI_assert(data->me->mloop[l_index].v == v_index);
3034               UNUSED_VARS_NDEBUG(l_index);
3035               const MPoly *mp = &data->me->mpoly[p_index];
3036               if (!use_face_sel || mp->flag & ME_FACE_SEL) {
3037                 const MLoop *ml_other = &data->me->mloop[mp->loopstart];
3038                 for (int k = 0; k < mp->totloop; k++, ml_other++) {
3039                   const uint v_other_index = ml_other->v;
3040                   if (v_other_index != v_index) {
3041                     const MVert *mv_other = &data->me->mvert[v_other_index];
3042
3043                     /* Get the direction from the
3044                      * selected vert to the neighbor. */
3045                     float other_dir[3];
3046                     sub_v3_v3v3(other_dir, mv_curr->co, mv_other->co);
3047                     project_plane_v3_v3v3(other_dir, other_dir, cache->view_normal);
3048
3049                     normalize_v3(other_dir);
3050
3051                     const float stroke_dot = dot_v3v3(other_dir, brush_dir);
3052
3053                     if (stroke_dot > stroke_dot_max) {
3054                       stroke_dot_max = stroke_dot;
3055                       color_final = data->vpd->smear.color_prev[mp->loopstart + k];
3056                       do_color = true;
3057                     }
3058                   }
3059                 }
3060               }
3061             }
3062
3063             if (do_color) {
3064               const float final_alpha = 255 * brush_fade * brush_strength * brush_alpha_pressure *
3065                                         grid_alpha;
3066
3067               /* For each poly owning this vert,
3068                * paint each loop belonging to this vert. */
3069               for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
3070                 const int p_index = gmap->vert_to_poly[v_index].indices[j];
3071                 const int l_index = gmap->vert_to_loop[v_index].indices[j];
3072                 BLI_assert(data->me->mloop[l_index].v == v_index);
3073                 const MPoly *mp = &data->me->mpoly[p_index];
3074                 if (!use_face_sel || mp->flag & ME_FACE_SEL) {
3075                   /* Get the previous loop color */
3076                   uint color_orig = 0; /* unused when array is NULL */
3077                   if (ss->mode.vpaint.previous_color != NULL) {
3078                     /* Get the previous loop color */
3079                     if (ss->mode.vpaint.previous_color[l_index] == 0) {
3080                       ss->mode.vpaint.previous_color[l_index] = lcol[l_index];
3081                     }
3082                     color_orig = ss->mode.vpaint.previous_color[l_index];
3083                   }
3084                   /* Mix the new color with the original
3085                    * based on the brush strength and the curve. */
3086                   lcol[l_index] = vpaint_blend(data->vp,
3087                                                lcol[l_index],
3088                                                color_orig,
3089                                                color_final,
3090                                                final_alpha,
3091                                                255 * brush_strength);
3092
3093                   data->vpd->smear.color_curr[l_index] = lcol[l_index];
3094                 }
3095               }
3096             }
3097           }
3098         }
3099       }
3100     }
3101     BKE_pbvh_vertex_iter_end;
3102   }
3103 }
3104
3105 static void calculate_average_color(SculptThreadedTaskData *data,
3106                                     PBVHNode **UNUSED(nodes),
3107                                     int totnode)
3108 {
3109   struct VPaintAverageAccum *accum = MEM_mallocN(sizeof(*accum) * totnode, __func__);
3110   data->custom_data = accum;
3111
3112   ParallelRangeSettings settings;
3113   BLI_parallel_range_settings_defaults(&settings);
3114   BLI_task_parallel_range(0, totnode, data, do_vpaint_brush_calc_average_color_cb_ex, &settings);
3115
3116   uint accum_len = 0;
3117   uint accum_value[3] = {0};
3118   uchar blend[4] = {0};
3119   for (int i = 0; i < totnode; i++) {
3120     accum_len += accum[i].len;
3121     accum_value[0] += accum[i].value[0];
3122     accum_value[1] += accum[i].value[1];
3123     accum_value[2] += accum[i].value[2];
3124   }
3125   if (accum_len != 0) {
3126     blend[0] = round_fl_to_uchar(sqrtf(divide_round_i(accum_value[0], accum_len)));
3127     blend[1] = round_fl_to_uchar(sqrtf(divide_round_i(accum_value[1], accum_len)));
3128     blend[2] = round_fl_to_uchar(sqrtf(divide_round_i(accum_value[2], accum_len)));
3129     blend[3] = 255;
3130     data->vpd->paintcol = *((uint *)blend);
3131   }
3132
3133   MEM_SAFE_FREE(data->custom_data); /* 'accum' */
3134 }
3135
3136 static void vpaint_paint_leaves(bContext *C,
3137                                 Sculpt *sd,
3138                                 VPaint *vp,
3139                                 struct VPaintData *vpd,
3140                                 Object *ob,
3141                                 Mesh *me,
3142                                 PBVHNode **nodes,
3143                                 int totnode)
3144 {
3145   const Brush *brush = ob->sculpt->cache->brush;
3146
3147   SculptThreadedTaskData data = {
3148       .C = C,
3149       .sd = sd,
3150       .ob = ob,
3151       .brush = brush,
3152       .nodes = nodes,
3153       .vp = vp,
3154       .vpd = vpd,
3155       .lcol = (uint *)me->mloopcol,
3156       .me = me,
3157   };
3158   ParallelRangeSettings settings;
3159   BLI_parallel_range_settings_defaults(&settings);
3160   switch ((eBrushVertexPaintTool)brush->vertexpaint_tool) {
3161     case VPAINT_TOOL_AVERAGE:
3162       calculate_average_color(&data, nodes, totnode);
3163       BLI_task_parallel_range(0, totnode, &data, do_vpaint_brush_draw_task_cb_ex, &settings);
3164       break;
3165     case VPAINT_TOOL_BLUR:
3166       BLI_task_parallel_range(0, totnode, &data, do_vpaint_brush_blur_task_cb_ex, &settings);
3167       break;
3168     case VPAINT_TOOL_SMEAR:
3169       BLI_task_parallel_range(0, totnode, &data, do_vpaint_brush_smear_task_cb_ex, &settings);
3170       break;
3171     case VPAINT_TOOL_DRAW:
3172       BLI_task_parallel_range(0, totnode, &data, do_vpaint_brush_draw_task_cb_ex, &settings);
3173       break;
3174   }
3175 }
3176
3177 static void vpaint_do_paint(bContext *C,
3178                             Sculpt *sd,
3179                             VPaint *vp,
3180                             struct VPaintData *vpd,
3181                             Object *ob,
3182                             Mesh *me,
3183                             Brush *brush,
3184                             const char symm,
3185                             const int axis,
3186                             const int i,
3187                             const float angle)
3188 {
3189   SculptSession *ss = ob->sculpt;
3190   ss->cache->radial_symmetry_pass = i;
3191   sculpt_cache_calc_brushdata_symm(ss->cache, symm, axis, angle);
3192
3193   int totnode;
3194   PBVHNode **nodes = vwpaint_pbvh_gather_generic(ob, vp, sd, brush, &totnode);
3195
3196   /* Paint those leaves. */
3197   vpaint_paint_leaves(C, sd, vp, vpd, ob, me, nodes, totnode);
3198
3199   if (nodes) {
3200     MEM_freeN(nodes);
3201   }
3202 }
3203
3204 static void vpaint_do_radial_symmetry(bContext *C,
3205                                       Sculpt *sd,
3206                                       VPaint *vp,
3207                                       struct VPaintData *vpd,
3208                                       Object *ob,
3209                                       Mesh *me,
3210                                       Brush *brush,
3211                                       const char symm,
3212                                       const int axis)
3213 {
3214   for (int i = 1; i < vp->radial_symm[axis - 'X']; i++) {
3215     const float angle = (2.0 * M_PI) * i / vp->radial_symm[axis - 'X'];
3216     vpaint_do_paint(C, sd, vp, vpd, ob, me, brush, symm, axis, i, angle);
3217   }
3218 }
3219
3220 /* near duplicate of: sculpt.c's,
3221  * 'do_symmetrical_brush_actions' and 'wpaint_do_symmetrical_brush_actions'. */
3222 static void vpaint_do_symmetrical_brush_actions(
3223     bContext *C, Sculpt *sd, VPaint *vp, struct VPaintData *vpd, Object *ob)
3224 {
3225   Brush *brush = BKE_paint_brush(&vp->paint);
3226   Mesh *me = ob->data;
3227   SculptSession *ss = ob->sculpt;
3228   StrokeCache *cache = ss->cache;
3229   const char symm = vp->paint.symmetry_flags & PAINT_SYMM_AXIS_ALL;
3230   int i = 0;
3231
3232   /* initial stroke */
3233   vpaint_do_paint(C, sd, vp, vpd, ob, me, brush, i, 'X', 0, 0);
3234   vpaint_do_radial_symmetry(C, sd, vp, vpd, ob, me, brush, i, 'X');
3235   vpaint_do_radial_symmetry(C, sd, vp, vpd, ob, me, brush, i, 'Y');
3236   vpaint_do_radial_symmetry(C, sd, vp, vpd, ob, me, brush, i, 'Z');
3237
3238   cache->symmetry = symm;
3239
3240   /* symm is a bit combination of XYZ - 1 is mirror
3241    * X; 2 is Y; 3 is XY; 4 is Z; 5 is XZ; 6 is YZ; 7 is XYZ */
3242   for (i = 1; i <= symm; i++) {
3243     if (symm & i && (symm != 5 || i != 3) && (symm != 6 || (i != 3 && i != 5))) {
3244       cache->mirror_symmetry_pass = i;
3245       cache->radial_symmetry_pass = 0;
3246       sculpt_cache_calc_brushdata_symm(cache, i, 0, 0);
3247
3248       if (i & (1 << 0)) {
3249         vpaint_do_paint(C, sd, vp, vpd, ob, me, brush, i, 'X', 0, 0);
3250         vpaint_do_radial_symmetry(C, sd, vp, vpd, ob, me, brush, i, 'X');
3251       }
3252       if (i & (1 << 1)) {
3253         vpaint_do_paint(C, sd, vp, vpd, ob, me, brush, i, 'Y', 0, 0);
3254         vpaint_do_radial_symmetry(C, sd, vp, vpd, ob, me, brush, i, 'Y');
3255       }
3256       if (i & (1 << 2)) {
3257         vpaint_do_paint(C, sd, vp, vpd, ob, me, brush, i, 'Z', 0, 0);
3258         vpaint_do_radial_symmetry(C, sd, vp, vpd, ob, me, brush, i, 'Z');
3259       }
3260     }
3261   }
3262
3263   copy_v3_v3(cache->true_last_location, cache->true_location);
3264   cache->is_last_valid = true;
3265 }
3266
3267 static void vpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, PointerRNA *itemptr)
3268 {
3269   Scene *scene = CTX_data_scene(C);
3270   ToolSettings *ts = CTX_data_tool_settings(C);
3271   struct VPaintData *vpd = paint_stroke_mode_data(stroke);
3272   VPaint *vp = ts->vpaint;
3273   ViewContext *vc = &vpd->vc;
3274   Object *ob = vc->obact;
3275   SculptSession *ss = ob->sculpt;
3276   Sculpt *sd = CTX_data_tool_settings(C)->sculpt;
3277
3278   vwpaint_update_cache_variants(C, vp, ob, itemptr);
3279
3280   float mat[4][4];
3281
3282   ED_view3d_init_mats_rv3d(ob, vc->rv3d);
3283
3284   /* load projection matrix */
3285   mul_m4_m4m4(mat, vc->rv3d->persmat, ob->obmat);
3286
3287   swap_m4m4(vc->rv3d->persmat, mat);
3288
3289   vpaint_do_symmetrical_brush_actions(C, sd, vp, vpd, ob);
3290
3291   swap_m4m4(vc->rv3d->persmat, mat);
3292
3293   BKE_mesh_batch_cache_dirty_tag(ob->data, BKE_MESH_BATCH_DIRTY_ALL);
3294
3295   if (vp->paint.brush->vertexpaint_tool == VPAINT_TOOL_SMEAR) {
3296     memcpy(
3297         vpd->smear.color_prev, vpd->smear.color_curr, sizeof(uint) * ((Mesh *)ob->data)->totloop);
3298   }
3299
3300   /* calculate pivot for rotation around seletion if needed */
3301   /* also needed for "View Selected" on last stroke */
3302   paint_last_stroke_update(scene, vc->ar, ss->cache->mouse);
3303
3304   ED_region_tag_redraw(vc->ar);
3305
3306   if (vpd->use_fast_update == false) {
3307     /* recalculate modifier stack to get new colors, slow,
3308      * avoid this if we can! */
3309     DEG_id_tag_update(ob->data, 0);
3310   }
3311   else {
3312     /* Flush changes through DEG. */
3313     DEG_id_tag_update(ob->data, ID_RECALC_COPY_ON_WRITE);
3314   }
3315 }
3316
3317 static void vpaint_stroke_done(const bContext *C, struct PaintStroke *stroke)
3318 {
3319   struct VPaintData *vpd = paint_stroke_mode_data(stroke);
3320   ViewContext *vc = &vpd->vc;
3321   Object *ob = vc->obact;
3322
3323   if (vpd->is_texbrush) {
3324     ED_vpaint_proj_handle_free(vpd->vp_handle);
3325   }
3326
3327   if (vpd->mlooptag) {
3328     MEM_freeN(vpd->mlooptag);
3329   }
3330   if (vpd->smear.color_prev) {
3331     MEM_freeN(vpd->smear.color_prev);
3332   }
3333   if (vpd->smear.color_curr) {
3334     MEM_freeN(vpd->smear.color_curr);
3335   }
3336
3337   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
3338
3339   MEM_freeN(vpd);
3340
3341   sculpt_cache_free(ob->sculpt->cache);
3342   ob->sculpt->cache = NULL;
3343 }
3344
3345 static int vpaint_invoke(bContext *C, wmOperator *op, const wmEvent *event)
3346 {
3347   int retval;
3348
3349   op->customdata = paint_stroke_new(C,
3350                                     op,
3351                                     sculpt_stroke_get_location,
3352                                     vpaint_stroke_test_start,
3353                                     vpaint_stroke_update_step,
3354                                     NULL,
3355                                     vpaint_stroke_done,
3356                                     event->type);
3357
3358   if ((retval = op->type->modal(C, op, event)) == OPERATOR_FINISHED) {
3359     paint_stroke_data_free(op);
3360     return OPERATOR_FINISHED;
3361   }
3362
3363   /* add modal handler */
3364   WM_event_add_modal_handler(C, op);
3365
3366   OPERATOR_RETVAL_CHECK(retval);
3367   BLI_assert(retval == OPERATOR_RUNNING_MODAL);
3368
3369   return OPERATOR_RUNNING_MODAL;
3370 }
3371
3372 static int vpaint_exec(bContext *C, wmOperator *op)
3373 {
3374   op->customdata = paint_stroke_new(C,
3375                                     op,
3376                                     sculpt_stroke_get_location,
3377                                     vpaint_stroke_test_start,
3378                                     vpaint_stroke_update_step,
3379                                     NULL,
3380                                     vpaint_stroke_done,
3381                                     0);
3382
3383   /* frees op->customdata */
3384   paint_stroke_exec(C, op);
3385
3386   return OPERATOR_FINISHED;
3387 }
3388
3389 static void vpaint_cancel(bContext *C, wmOperator *op)
3390 {
3391   Object *ob = CTX_data_active_object(C);
3392   if (ob->sculpt->cache) {
3393     sculpt_cache_free(ob->sculpt->cache);
3394     ob->sculpt->cache = NULL;
3395   }
3396
3397   paint_stroke_cancel(C, op);
3398 }
3399
3400 void PAINT_OT_vertex_paint(wmOperatorType *ot)
3401 {
3402   /* identifiers */
3403   ot->name = "Vertex Paint";
3404   ot->idname = "PAINT_OT_vertex_paint";
3405   ot->description = "Paint a stroke in the active vertex color layer";
3406
3407   /* api callbacks */
3408   ot->invoke = vpaint_invoke;
3409   ot->modal = paint_stroke_modal;
3410   ot->exec = vpaint_exec;
3411   ot->poll = vertex_paint_poll;
3412   ot->cancel = vpaint_cancel;
3413
3414   /* flags */
3415   ot->flag = OPTYPE_UNDO | OPTYPE_BLOCKING;
3416
3417   paint_stroke_operator_properties(ot);
3418 }
3419
3420 /** \} */