Cleanup: comments (long lines) in blenkernel
[blender.git] / source / blender / blenkernel / intern / paint.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) 2009 by Nicholas Bishop
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <stdlib.h>
25 #include <string.h>
26
27 #include "MEM_guardedalloc.h"
28
29 #include "DNA_object_types.h"
30 #include "DNA_mesh_types.h"
31 #include "DNA_meshdata_types.h"
32 #include "DNA_modifier_types.h"
33 #include "DNA_scene_types.h"
34 #include "DNA_brush_types.h"
35 #include "DNA_space_types.h"
36 #include "DNA_gpencil_types.h"
37 #include "DNA_workspace_types.h"
38
39 #include "BLI_bitmap.h"
40 #include "BLI_utildefines.h"
41 #include "BLI_math_vector.h"
42 #include "BLI_listbase.h"
43
44 #include "BLT_translation.h"
45
46 #include "BKE_animsys.h"
47 #include "BKE_brush.h"
48 #include "BKE_ccg.h"
49 #include "BKE_colortools.h"
50 #include "BKE_deform.h"
51 #include "BKE_main.h"
52 #include "BKE_context.h"
53 #include "BKE_crazyspace.h"
54 #include "BKE_gpencil.h"
55 #include "BKE_image.h"
56 #include "BKE_key.h"
57 #include "BKE_library.h"
58 #include "BKE_mesh.h"
59 #include "BKE_mesh_mapping.h"
60 #include "BKE_mesh_runtime.h"
61 #include "BKE_modifier.h"
62 #include "BKE_object.h"
63 #include "BKE_paint.h"
64 #include "BKE_pbvh.h"
65 #include "BKE_subdiv_ccg.h"
66 #include "BKE_subsurf.h"
67
68 #include "DEG_depsgraph.h"
69 #include "DEG_depsgraph_query.h"
70
71 #include "RNA_enum_types.h"
72
73 #include "bmesh.h"
74
75 const char PAINT_CURSOR_SCULPT[3] = {255, 100, 100};
76 const char PAINT_CURSOR_VERTEX_PAINT[3] = {255, 255, 255};
77 const char PAINT_CURSOR_WEIGHT_PAINT[3] = {200, 200, 255};
78 const char PAINT_CURSOR_TEXTURE_PAINT[3] = {255, 255, 255};
79
80 static eOverlayControlFlags overlay_flags = 0;
81
82 void BKE_paint_invalidate_overlay_tex(Scene *scene, ViewLayer *view_layer, const Tex *tex)
83 {
84   Paint *p = BKE_paint_get_active(scene, view_layer);
85   Brush *br = p->brush;
86
87   if (!br) {
88     return;
89   }
90
91   if (br->mtex.tex == tex) {
92     overlay_flags |= PAINT_OVERLAY_INVALID_TEXTURE_PRIMARY;
93   }
94   if (br->mask_mtex.tex == tex) {
95     overlay_flags |= PAINT_OVERLAY_INVALID_TEXTURE_SECONDARY;
96   }
97 }
98
99 void BKE_paint_invalidate_cursor_overlay(Scene *scene, ViewLayer *view_layer, CurveMapping *curve)
100 {
101   Paint *p = BKE_paint_get_active(scene, view_layer);
102   Brush *br = p->brush;
103
104   if (br && br->curve == curve) {
105     overlay_flags |= PAINT_OVERLAY_INVALID_CURVE;
106   }
107 }
108
109 void BKE_paint_invalidate_overlay_all(void)
110 {
111   overlay_flags |= (PAINT_OVERLAY_INVALID_TEXTURE_SECONDARY |
112                     PAINT_OVERLAY_INVALID_TEXTURE_PRIMARY | PAINT_OVERLAY_INVALID_CURVE);
113 }
114
115 eOverlayControlFlags BKE_paint_get_overlay_flags(void)
116 {
117   return overlay_flags;
118 }
119
120 void BKE_paint_set_overlay_override(eOverlayFlags flags)
121 {
122   if (flags & BRUSH_OVERLAY_OVERRIDE_MASK) {
123     if (flags & BRUSH_OVERLAY_CURSOR_OVERRIDE_ON_STROKE) {
124       overlay_flags |= PAINT_OVERLAY_OVERRIDE_CURSOR;
125     }
126     if (flags & BRUSH_OVERLAY_PRIMARY_OVERRIDE_ON_STROKE) {
127       overlay_flags |= PAINT_OVERLAY_OVERRIDE_PRIMARY;
128     }
129     if (flags & BRUSH_OVERLAY_SECONDARY_OVERRIDE_ON_STROKE) {
130       overlay_flags |= PAINT_OVERLAY_OVERRIDE_SECONDARY;
131     }
132   }
133   else {
134     overlay_flags &= ~(PAINT_OVERRIDE_MASK);
135   }
136 }
137
138 void BKE_paint_reset_overlay_invalid(eOverlayControlFlags flag)
139 {
140   overlay_flags &= ~(flag);
141 }
142
143 Paint *BKE_paint_get_active_from_paintmode(Scene *sce, ePaintMode mode)
144 {
145   if (sce) {
146     ToolSettings *ts = sce->toolsettings;
147
148     switch (mode) {
149       case PAINT_MODE_SCULPT:
150         return &ts->sculpt->paint;
151       case PAINT_MODE_VERTEX:
152         return &ts->vpaint->paint;
153       case PAINT_MODE_WEIGHT:
154         return &ts->wpaint->paint;
155       case PAINT_MODE_TEXTURE_2D:
156       case PAINT_MODE_TEXTURE_3D:
157         return &ts->imapaint.paint;
158       case PAINT_MODE_SCULPT_UV:
159         return &ts->uvsculpt->paint;
160       case PAINT_MODE_GPENCIL:
161         return &ts->gp_paint->paint;
162       case PAINT_MODE_INVALID:
163         return NULL;
164       default:
165         return &ts->imapaint.paint;
166     }
167   }
168
169   return NULL;
170 }
171
172 const EnumPropertyItem *BKE_paint_get_tool_enum_from_paintmode(ePaintMode mode)
173 {
174   switch (mode) {
175     case PAINT_MODE_SCULPT:
176       return rna_enum_brush_sculpt_tool_items;
177     case PAINT_MODE_VERTEX:
178       return rna_enum_brush_vertex_tool_items;
179     case PAINT_MODE_WEIGHT:
180       return rna_enum_brush_weight_tool_items;
181     case PAINT_MODE_TEXTURE_2D:
182     case PAINT_MODE_TEXTURE_3D:
183       return rna_enum_brush_image_tool_items;
184     case PAINT_MODE_SCULPT_UV:
185       return NULL;
186     case PAINT_MODE_GPENCIL:
187       return rna_enum_brush_gpencil_types_items;
188     case PAINT_MODE_INVALID:
189       break;
190   }
191   return NULL;
192 }
193
194 const char *BKE_paint_get_tool_prop_id_from_paintmode(ePaintMode mode)
195 {
196   switch (mode) {
197     case PAINT_MODE_SCULPT:
198       return "sculpt_tool";
199     case PAINT_MODE_VERTEX:
200       return "vertex_tool";
201     case PAINT_MODE_WEIGHT:
202       return "weight_tool";
203     case PAINT_MODE_TEXTURE_2D:
204     case PAINT_MODE_TEXTURE_3D:
205       return "image_tool";
206     case PAINT_MODE_GPENCIL:
207       return "gpencil_tool";
208     default:
209       /* invalid paint mode */
210       return NULL;
211   }
212 }
213
214 Paint *BKE_paint_get_active(Scene *sce, ViewLayer *view_layer)
215 {
216   if (sce && view_layer) {
217     ToolSettings *ts = sce->toolsettings;
218
219     if (view_layer->basact && view_layer->basact->object) {
220       switch (view_layer->basact->object->mode) {
221         case OB_MODE_SCULPT:
222           return &ts->sculpt->paint;
223         case OB_MODE_VERTEX_PAINT:
224           return &ts->vpaint->paint;
225         case OB_MODE_WEIGHT_PAINT:
226           return &ts->wpaint->paint;
227         case OB_MODE_TEXTURE_PAINT:
228           return &ts->imapaint.paint;
229         case OB_MODE_PAINT_GPENCIL:
230           return &ts->gp_paint->paint;
231         case OB_MODE_EDIT:
232           if (ts->use_uv_sculpt) {
233             return &ts->uvsculpt->paint;
234           }
235           return &ts->imapaint.paint;
236         default:
237           break;
238       }
239     }
240
241     /* default to image paint */
242     return &ts->imapaint.paint;
243   }
244
245   return NULL;
246 }
247
248 Paint *BKE_paint_get_active_from_context(const bContext *C)
249 {
250   Scene *sce = CTX_data_scene(C);
251   ViewLayer *view_layer = CTX_data_view_layer(C);
252   SpaceImage *sima;
253
254   if (sce && view_layer) {
255     ToolSettings *ts = sce->toolsettings;
256     Object *obact = NULL;
257
258     if (view_layer->basact && view_layer->basact->object) {
259       obact = view_layer->basact->object;
260     }
261
262     if ((sima = CTX_wm_space_image(C)) != NULL) {
263       if (obact && obact->mode == OB_MODE_EDIT) {
264         if (sima->mode == SI_MODE_PAINT) {
265           return &ts->imapaint.paint;
266         }
267         else if (ts->use_uv_sculpt) {
268           return &ts->uvsculpt->paint;
269         }
270       }
271       else {
272         return &ts->imapaint.paint;
273       }
274     }
275     else {
276       return BKE_paint_get_active(sce, view_layer);
277     }
278   }
279
280   return NULL;
281 }
282
283 ePaintMode BKE_paintmode_get_active_from_context(const bContext *C)
284 {
285   Scene *sce = CTX_data_scene(C);
286   ViewLayer *view_layer = CTX_data_view_layer(C);
287   SpaceImage *sima;
288
289   if (sce && view_layer) {
290     ToolSettings *ts = sce->toolsettings;
291     Object *obact = NULL;
292
293     if (view_layer->basact && view_layer->basact->object) {
294       obact = view_layer->basact->object;
295     }
296
297     if ((sima = CTX_wm_space_image(C)) != NULL) {
298       if (obact && obact->mode == OB_MODE_EDIT) {
299         if (sima->mode == SI_MODE_PAINT) {
300           return PAINT_MODE_TEXTURE_2D;
301         }
302         else if (ts->use_uv_sculpt) {
303           return PAINT_MODE_SCULPT_UV;
304         }
305       }
306       else {
307         return PAINT_MODE_TEXTURE_2D;
308       }
309     }
310     else if (obact) {
311       switch (obact->mode) {
312         case OB_MODE_SCULPT:
313           return PAINT_MODE_SCULPT;
314         case OB_MODE_VERTEX_PAINT:
315           return PAINT_MODE_VERTEX;
316         case OB_MODE_WEIGHT_PAINT:
317           return PAINT_MODE_WEIGHT;
318         case OB_MODE_TEXTURE_PAINT:
319           return PAINT_MODE_TEXTURE_3D;
320         case OB_MODE_EDIT:
321           if (ts->use_uv_sculpt) {
322             return PAINT_MODE_SCULPT_UV;
323           }
324           return PAINT_MODE_TEXTURE_2D;
325         default:
326           return PAINT_MODE_TEXTURE_2D;
327       }
328     }
329     else {
330       /* default to image paint */
331       return PAINT_MODE_TEXTURE_2D;
332     }
333   }
334
335   return PAINT_MODE_INVALID;
336 }
337
338 ePaintMode BKE_paintmode_get_from_tool(const struct bToolRef *tref)
339 {
340   if (tref->space_type == SPACE_VIEW3D) {
341     switch (tref->mode) {
342       case CTX_MODE_SCULPT:
343         return PAINT_MODE_SCULPT;
344       case CTX_MODE_PAINT_VERTEX:
345         return PAINT_MODE_VERTEX;
346       case CTX_MODE_PAINT_WEIGHT:
347         return PAINT_MODE_WEIGHT;
348       case CTX_MODE_PAINT_GPENCIL:
349         return PAINT_MODE_GPENCIL;
350       case CTX_MODE_PAINT_TEXTURE:
351         return PAINT_MODE_TEXTURE_3D;
352     }
353   }
354   else if (tref->space_type == SPACE_IMAGE) {
355     switch (tref->mode) {
356       case SI_MODE_PAINT:
357         return PAINT_MODE_TEXTURE_2D;
358     }
359   }
360
361   return PAINT_MODE_INVALID;
362 }
363
364 Brush *BKE_paint_brush(Paint *p)
365 {
366   return p ? p->brush : NULL;
367 }
368
369 void BKE_paint_brush_set(Paint *p, Brush *br)
370 {
371   if (p) {
372     id_us_min((ID *)p->brush);
373     id_us_plus((ID *)br);
374     p->brush = br;
375
376     BKE_paint_toolslots_brush_update(p);
377   }
378 }
379
380 void BKE_paint_runtime_init(const ToolSettings *ts, Paint *paint)
381 {
382   if (paint == &ts->imapaint.paint) {
383     paint->runtime.tool_offset = offsetof(Brush, imagepaint_tool);
384     paint->runtime.ob_mode = OB_MODE_TEXTURE_PAINT;
385   }
386   else if (paint == &ts->sculpt->paint) {
387     paint->runtime.tool_offset = offsetof(Brush, sculpt_tool);
388     paint->runtime.ob_mode = OB_MODE_SCULPT;
389   }
390   else if (paint == &ts->vpaint->paint) {
391     paint->runtime.tool_offset = offsetof(Brush, vertexpaint_tool);
392     paint->runtime.ob_mode = OB_MODE_VERTEX_PAINT;
393   }
394   else if (paint == &ts->wpaint->paint) {
395     paint->runtime.tool_offset = offsetof(Brush, weightpaint_tool);
396     paint->runtime.ob_mode = OB_MODE_WEIGHT_PAINT;
397   }
398   else if (paint == &ts->gp_paint->paint) {
399     paint->runtime.tool_offset = offsetof(Brush, gpencil_tool);
400     paint->runtime.ob_mode = OB_MODE_PAINT_GPENCIL;
401   }
402   else if (paint == &ts->uvsculpt->paint) {
403     /* We don't use these yet. */
404     paint->runtime.tool_offset = 0;
405     paint->runtime.ob_mode = 0;
406   }
407   else {
408     BLI_assert(0);
409   }
410 }
411
412 uint BKE_paint_get_brush_tool_offset_from_paintmode(const ePaintMode mode)
413 {
414   switch (mode) {
415     case PAINT_MODE_TEXTURE_2D:
416     case PAINT_MODE_TEXTURE_3D:
417       return offsetof(Brush, imagepaint_tool);
418     case PAINT_MODE_SCULPT:
419       return offsetof(Brush, sculpt_tool);
420     case PAINT_MODE_VERTEX:
421       return offsetof(Brush, vertexpaint_tool);
422     case PAINT_MODE_WEIGHT:
423       return offsetof(Brush, weightpaint_tool);
424     case PAINT_MODE_GPENCIL:
425       return offsetof(Brush, gpencil_tool);
426     case PAINT_MODE_SCULPT_UV:
427     case PAINT_MODE_INVALID:
428       break; /* We don't use these yet. */
429   }
430   return 0;
431 }
432
433 /** Free (or release) any data used by this paint curve (does not free the pcurve itself). */
434 void BKE_paint_curve_free(PaintCurve *pc)
435 {
436   MEM_SAFE_FREE(pc->points);
437   pc->tot_points = 0;
438 }
439
440 PaintCurve *BKE_paint_curve_add(Main *bmain, const char *name)
441 {
442   PaintCurve *pc;
443
444   pc = BKE_libblock_alloc(bmain, ID_PC, name, 0);
445
446   return pc;
447 }
448
449 /**
450  * Only copy internal data of PaintCurve ID from source to
451  * already allocated/initialized destination.
452  * You probably never want to use that directly,
453  * use #BKE_id_copy or #BKE_id_copy_ex for typical needs.
454  *
455  * WARNING! This function will not handle ID user count!
456  *
457  * \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
458  */
459 void BKE_paint_curve_copy_data(Main *UNUSED(bmain),
460                                PaintCurve *pc_dst,
461                                const PaintCurve *pc_src,
462                                const int UNUSED(flag))
463 {
464   if (pc_src->tot_points != 0) {
465     pc_dst->points = MEM_dupallocN(pc_src->points);
466   }
467 }
468
469 PaintCurve *BKE_paint_curve_copy(Main *bmain, const PaintCurve *pc)
470 {
471   PaintCurve *pc_copy;
472   BKE_id_copy(bmain, &pc->id, (ID **)&pc_copy);
473   return pc_copy;
474 }
475
476 void BKE_paint_curve_make_local(Main *bmain, PaintCurve *pc, const bool lib_local)
477 {
478   BKE_id_make_local_generic(bmain, &pc->id, true, lib_local);
479 }
480
481 Palette *BKE_paint_palette(Paint *p)
482 {
483   return p ? p->palette : NULL;
484 }
485
486 void BKE_paint_palette_set(Paint *p, Palette *palette)
487 {
488   if (p) {
489     id_us_min((ID *)p->palette);
490     p->palette = palette;
491     id_us_plus((ID *)p->palette);
492   }
493 }
494
495 void BKE_paint_curve_set(Brush *br, PaintCurve *pc)
496 {
497   if (br) {
498     id_us_min((ID *)br->paint_curve);
499     br->paint_curve = pc;
500     id_us_plus((ID *)br->paint_curve);
501   }
502 }
503
504 void BKE_paint_curve_clamp_endpoint_add_index(PaintCurve *pc, const int add_index)
505 {
506   pc->add_index = (add_index || pc->tot_points == 1) ? (add_index + 1) : 0;
507 }
508
509 /* remove colour from palette. Must be certain color is inside the palette! */
510 void BKE_palette_color_remove(Palette *palette, PaletteColor *color)
511 {
512   if (BLI_listbase_count_at_most(&palette->colors, palette->active_color) ==
513       palette->active_color) {
514     palette->active_color--;
515   }
516
517   BLI_remlink(&palette->colors, color);
518
519   if (palette->active_color < 0 && !BLI_listbase_is_empty(&palette->colors)) {
520     palette->active_color = 0;
521   }
522
523   MEM_freeN(color);
524 }
525
526 void BKE_palette_clear(Palette *palette)
527 {
528   BLI_freelistN(&palette->colors);
529   palette->active_color = 0;
530 }
531
532 Palette *BKE_palette_add(Main *bmain, const char *name)
533 {
534   Palette *palette = BKE_id_new(bmain, ID_PAL, name);
535   return palette;
536 }
537
538 /**
539  * Only copy internal data of Palette ID from source
540  * to already allocated/initialized destination.
541  * You probably never want to use that directly,
542  * use #BKE_id_copy or #BKE_id_copy_ex for typical needs.
543  *
544  * WARNING! This function will not handle ID user count!
545  *
546  * \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
547  */
548 void BKE_palette_copy_data(Main *UNUSED(bmain),
549                            Palette *palette_dst,
550                            const Palette *palette_src,
551                            const int UNUSED(flag))
552 {
553   BLI_duplicatelist(&palette_dst->colors, &palette_src->colors);
554 }
555
556 Palette *BKE_palette_copy(Main *bmain, const Palette *palette)
557 {
558   Palette *palette_copy;
559   BKE_id_copy(bmain, &palette->id, (ID **)&palette_copy);
560   return palette_copy;
561 }
562
563 void BKE_palette_make_local(Main *bmain, Palette *palette, const bool lib_local)
564 {
565   BKE_id_make_local_generic(bmain, &palette->id, true, lib_local);
566 }
567
568 void BKE_palette_init(Palette *palette)
569 {
570   /* Enable fake user by default. */
571   id_fake_user_set(&palette->id);
572 }
573
574 /** Free (or release) any data used by this palette (does not free the palette itself). */
575 void BKE_palette_free(Palette *palette)
576 {
577   BLI_freelistN(&palette->colors);
578 }
579
580 PaletteColor *BKE_palette_color_add(Palette *palette)
581 {
582   PaletteColor *color = MEM_callocN(sizeof(*color), "Palette Color");
583   BLI_addtail(&palette->colors, color);
584   return color;
585 }
586
587 bool BKE_palette_is_empty(const struct Palette *palette)
588 {
589   return BLI_listbase_is_empty(&palette->colors);
590 }
591
592 /* are we in vertex paint or weight paint face select mode? */
593 bool BKE_paint_select_face_test(Object *ob)
594 {
595   return ((ob != NULL) && (ob->type == OB_MESH) && (ob->data != NULL) &&
596           (((Mesh *)ob->data)->editflag & ME_EDIT_PAINT_FACE_SEL) &&
597           (ob->mode & (OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT | OB_MODE_TEXTURE_PAINT)));
598 }
599
600 /* are we in weight paint vertex select mode? */
601 bool BKE_paint_select_vert_test(Object *ob)
602 {
603   return ((ob != NULL) && (ob->type == OB_MESH) && (ob->data != NULL) &&
604           (((Mesh *)ob->data)->editflag & ME_EDIT_PAINT_VERT_SEL) &&
605           (ob->mode & OB_MODE_WEIGHT_PAINT || ob->mode & OB_MODE_VERTEX_PAINT));
606 }
607
608 /**
609  * used to check if selection is possible
610  * (when we don't care if its face or vert)
611  */
612 bool BKE_paint_select_elem_test(Object *ob)
613 {
614   return (BKE_paint_select_vert_test(ob) || BKE_paint_select_face_test(ob));
615 }
616
617 void BKE_paint_cavity_curve_preset(Paint *p, int preset)
618 {
619   CurveMap *cm = NULL;
620
621   if (!p->cavity_curve) {
622     p->cavity_curve = curvemapping_add(1, 0, 0, 1, 1);
623   }
624
625   cm = p->cavity_curve->cm;
626   cm->flag &= ~CUMA_EXTEND_EXTRAPOLATE;
627
628   p->cavity_curve->preset = preset;
629   curvemap_reset(cm, &p->cavity_curve->clipr, p->cavity_curve->preset, CURVEMAP_SLOPE_POSITIVE);
630   curvemapping_changed(p->cavity_curve, false);
631 }
632
633 eObjectMode BKE_paint_object_mode_from_paintmode(ePaintMode mode)
634 {
635   switch (mode) {
636     case PAINT_MODE_SCULPT:
637       return OB_MODE_SCULPT;
638     case PAINT_MODE_VERTEX:
639       return OB_MODE_VERTEX_PAINT;
640     case PAINT_MODE_WEIGHT:
641       return OB_MODE_WEIGHT_PAINT;
642     case PAINT_MODE_TEXTURE_2D:
643     case PAINT_MODE_TEXTURE_3D:
644       return OB_MODE_TEXTURE_PAINT;
645     case PAINT_MODE_SCULPT_UV:
646       return OB_MODE_EDIT;
647     case PAINT_MODE_INVALID:
648     default:
649       return 0;
650   }
651 }
652
653 /**
654  * Call when entering each respective paint mode.
655  */
656 bool BKE_paint_ensure(const ToolSettings *ts, struct Paint **r_paint)
657 {
658   Paint *paint = NULL;
659   if (*r_paint) {
660     /* Note: 'ts->imapaint' is ignored, it's not allocated. */
661     BLI_assert(ELEM(*r_paint,
662                     &ts->gp_paint->paint,
663                     &ts->sculpt->paint,
664                     &ts->vpaint->paint,
665                     &ts->wpaint->paint,
666                     &ts->uvsculpt->paint));
667
668 #ifdef DEBUG
669     struct Paint paint_test = **r_paint;
670     BKE_paint_runtime_init(ts, *r_paint);
671     /* Swap so debug doesn't hide errors when release fails. */
672     SWAP(Paint, **r_paint, paint_test);
673     BLI_assert(paint_test.runtime.ob_mode == (*r_paint)->runtime.ob_mode);
674     BLI_assert(paint_test.runtime.tool_offset == (*r_paint)->runtime.tool_offset);
675 #endif
676     return true;
677   }
678
679   if (((VPaint **)r_paint == &ts->vpaint) || ((VPaint **)r_paint == &ts->wpaint)) {
680     VPaint *data = MEM_callocN(sizeof(*data), __func__);
681     paint = &data->paint;
682   }
683   else if ((Sculpt **)r_paint == &ts->sculpt) {
684     Sculpt *data = MEM_callocN(sizeof(*data), __func__);
685     paint = &data->paint;
686
687     /* Turn on X plane mirror symmetry by default */
688     paint->symmetry_flags |= PAINT_SYMM_X;
689
690     /* Make sure at least dyntopo subdivision is enabled */
691     data->flags |= SCULPT_DYNTOPO_SUBDIVIDE | SCULPT_DYNTOPO_COLLAPSE;
692   }
693   else if ((GpPaint **)r_paint == &ts->gp_paint) {
694     GpPaint *data = MEM_callocN(sizeof(*data), __func__);
695     paint = &data->paint;
696   }
697   else if ((UvSculpt **)r_paint == &ts->uvsculpt) {
698     UvSculpt *data = MEM_callocN(sizeof(*data), __func__);
699     paint = &data->paint;
700   }
701
702   paint->flags |= PAINT_SHOW_BRUSH;
703
704   *r_paint = paint;
705
706   BKE_paint_runtime_init(ts, paint);
707
708   return false;
709 }
710
711 void BKE_paint_init(Main *bmain, Scene *sce, ePaintMode mode, const char col[3])
712 {
713   UnifiedPaintSettings *ups = &sce->toolsettings->unified_paint_settings;
714   Paint *paint = BKE_paint_get_active_from_paintmode(sce, mode);
715
716   /* If there's no brush, create one */
717   if (PAINT_MODE_HAS_BRUSH(mode)) {
718     Brush *brush = BKE_paint_brush(paint);
719     if (brush == NULL) {
720       eObjectMode ob_mode = BKE_paint_object_mode_from_paintmode(mode);
721       brush = BKE_brush_first_search(bmain, ob_mode);
722       if (!brush) {
723         brush = BKE_brush_add(bmain, "Brush", ob_mode);
724         id_us_min(&brush->id); /* fake user only */
725       }
726       BKE_paint_brush_set(paint, brush);
727     }
728   }
729
730   memcpy(paint->paint_cursor_col, col, 3);
731   paint->paint_cursor_col[3] = 128;
732   ups->last_stroke_valid = false;
733   zero_v3(ups->average_stroke_accum);
734   ups->average_stroke_counter = 0;
735   if (!paint->cavity_curve) {
736     BKE_paint_cavity_curve_preset(paint, CURVE_PRESET_LINE);
737   }
738 }
739
740 void BKE_paint_free(Paint *paint)
741 {
742   curvemapping_free(paint->cavity_curve);
743   MEM_SAFE_FREE(paint->tool_slots);
744 }
745
746 /* called when copying scene settings, so even if 'src' and 'tar' are the same
747  * still do a id_us_plus(), rather then if we were copying between 2 existing
748  * scenes where a matching value should decrease the existing user count as
749  * with paint_brush_set() */
750 void BKE_paint_copy(Paint *src, Paint *tar, const int flag)
751 {
752   tar->brush = src->brush;
753   tar->cavity_curve = curvemapping_copy(src->cavity_curve);
754   tar->tool_slots = MEM_dupallocN(src->tool_slots);
755
756   if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
757     id_us_plus((ID *)tar->brush);
758     id_us_plus((ID *)tar->palette);
759     if (src->tool_slots != NULL) {
760       for (int i = 0; i < tar->tool_slots_len; i++) {
761         id_us_plus((ID *)tar->tool_slots[i].brush);
762       }
763     }
764   }
765 }
766
767 void BKE_paint_stroke_get_average(Scene *scene, Object *ob, float stroke[3])
768 {
769   UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
770   if (ups->last_stroke_valid && ups->average_stroke_counter > 0) {
771     float fac = 1.0f / ups->average_stroke_counter;
772     mul_v3_v3fl(stroke, ups->average_stroke_accum, fac);
773   }
774   else {
775     copy_v3_v3(stroke, ob->obmat[3]);
776   }
777 }
778
779 /* returns non-zero if any of the face's vertices
780  * are hidden, zero otherwise */
781 bool paint_is_face_hidden(const MLoopTri *lt, const MVert *mvert, const MLoop *mloop)
782 {
783   return ((mvert[mloop[lt->tri[0]].v].flag & ME_HIDE) ||
784           (mvert[mloop[lt->tri[1]].v].flag & ME_HIDE) ||
785           (mvert[mloop[lt->tri[2]].v].flag & ME_HIDE));
786 }
787
788 /* returns non-zero if any of the corners of the grid
789  * face whose inner corner is at (x, y) are hidden,
790  * zero otherwise */
791 bool paint_is_grid_face_hidden(const unsigned int *grid_hidden, int gridsize, int x, int y)
792 {
793   /* skip face if any of its corners are hidden */
794   return (BLI_BITMAP_TEST(grid_hidden, y * gridsize + x) ||
795           BLI_BITMAP_TEST(grid_hidden, y * gridsize + x + 1) ||
796           BLI_BITMAP_TEST(grid_hidden, (y + 1) * gridsize + x + 1) ||
797           BLI_BITMAP_TEST(grid_hidden, (y + 1) * gridsize + x));
798 }
799
800 /* Return true if all vertices in the face are visible, false otherwise */
801 bool paint_is_bmesh_face_hidden(BMFace *f)
802 {
803   BMLoop *l_iter;
804   BMLoop *l_first;
805
806   l_iter = l_first = BM_FACE_FIRST_LOOP(f);
807   do {
808     if (BM_elem_flag_test(l_iter->v, BM_ELEM_HIDDEN)) {
809       return true;
810     }
811   } while ((l_iter = l_iter->next) != l_first);
812
813   return false;
814 }
815
816 float paint_grid_paint_mask(const GridPaintMask *gpm, unsigned level, unsigned x, unsigned y)
817 {
818   int factor = BKE_ccg_factor(level, gpm->level);
819   int gridsize = BKE_ccg_gridsize(gpm->level);
820
821   return gpm->data[(y * factor) * gridsize + (x * factor)];
822 }
823
824 /* threshold to move before updating the brush rotation */
825 #define RAKE_THRESHHOLD 20
826
827 void paint_update_brush_rake_rotation(UnifiedPaintSettings *ups, Brush *brush, float rotation)
828 {
829   if (brush->mtex.brush_angle_mode & MTEX_ANGLE_RAKE) {
830     ups->brush_rotation = rotation;
831   }
832   else {
833     ups->brush_rotation = 0.0f;
834   }
835
836   if (brush->mask_mtex.brush_angle_mode & MTEX_ANGLE_RAKE) {
837     ups->brush_rotation_sec = rotation;
838   }
839   else {
840     ups->brush_rotation_sec = 0.0f;
841   }
842 }
843
844 bool paint_calculate_rake_rotation(UnifiedPaintSettings *ups,
845                                    Brush *brush,
846                                    const float mouse_pos[2])
847 {
848   bool ok = false;
849   if ((brush->mtex.brush_angle_mode & MTEX_ANGLE_RAKE) ||
850       (brush->mask_mtex.brush_angle_mode & MTEX_ANGLE_RAKE)) {
851     const float r = RAKE_THRESHHOLD;
852     float rotation;
853
854     float dpos[2];
855     sub_v2_v2v2(dpos, ups->last_rake, mouse_pos);
856
857     if (len_squared_v2(dpos) >= r * r) {
858       rotation = atan2f(dpos[0], dpos[1]);
859
860       copy_v2_v2(ups->last_rake, mouse_pos);
861
862       ups->last_rake_angle = rotation;
863
864       paint_update_brush_rake_rotation(ups, brush, rotation);
865       ok = true;
866     }
867     /* make sure we reset here to the last rotation to avoid accumulating
868      * values in case a random rotation is also added */
869     else {
870       paint_update_brush_rake_rotation(ups, brush, ups->last_rake_angle);
871       ok = false;
872     }
873   }
874   else {
875     ups->brush_rotation = ups->brush_rotation_sec = 0.0f;
876     ok = true;
877   }
878   return ok;
879 }
880
881 void BKE_sculptsession_free_deformMats(SculptSession *ss)
882 {
883   MEM_SAFE_FREE(ss->orig_cos);
884   MEM_SAFE_FREE(ss->deform_cos);
885   MEM_SAFE_FREE(ss->deform_imats);
886 }
887
888 void BKE_sculptsession_free_vwpaint_data(struct SculptSession *ss)
889 {
890   struct SculptVertexPaintGeomMap *gmap = NULL;
891   if (ss->mode_type == OB_MODE_VERTEX_PAINT) {
892     gmap = &ss->mode.vpaint.gmap;
893
894     MEM_SAFE_FREE(ss->mode.vpaint.previous_color);
895   }
896   else if (ss->mode_type == OB_MODE_WEIGHT_PAINT) {
897     gmap = &ss->mode.wpaint.gmap;
898
899     MEM_SAFE_FREE(ss->mode.wpaint.alpha_weight);
900     if (ss->mode.wpaint.dvert_prev) {
901       BKE_defvert_array_free_elems(ss->mode.wpaint.dvert_prev, ss->totvert);
902       MEM_freeN(ss->mode.wpaint.dvert_prev);
903       ss->mode.wpaint.dvert_prev = NULL;
904     }
905   }
906   else {
907     return;
908   }
909   MEM_SAFE_FREE(gmap->vert_to_loop);
910   MEM_SAFE_FREE(gmap->vert_map_mem);
911   MEM_SAFE_FREE(gmap->vert_to_poly);
912   MEM_SAFE_FREE(gmap->poly_map_mem);
913 }
914
915 /* Write out the sculpt dynamic-topology BMesh to the Mesh */
916 static void sculptsession_bm_to_me_update_data_only(Object *ob, bool reorder)
917 {
918   SculptSession *ss = ob->sculpt;
919
920   if (ss->bm) {
921     if (ob->data) {
922       BMIter iter;
923       BMFace *efa;
924       BM_ITER_MESH (efa, &iter, ss->bm, BM_FACES_OF_MESH) {
925         BM_elem_flag_set(efa, BM_ELEM_SMOOTH, ss->bm_smooth_shading);
926       }
927       if (reorder) {
928         BM_log_mesh_elems_reorder(ss->bm, ss->bm_log);
929       }
930       BM_mesh_bm_to_me(NULL,
931                        ss->bm,
932                        ob->data,
933                        (&(struct BMeshToMeshParams){
934                            .calc_object_remap = false,
935                        }));
936     }
937   }
938 }
939
940 void BKE_sculptsession_bm_to_me(Object *ob, bool reorder)
941 {
942   if (ob && ob->sculpt) {
943     sculptsession_bm_to_me_update_data_only(ob, reorder);
944
945     /* Ensure the objects evaluated mesh doesn't hold onto arrays
946      * now realloc'd in the mesh T34473. */
947     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
948   }
949 }
950
951 void BKE_sculptsession_bm_to_me_for_render(Object *object)
952 {
953   if (object && object->sculpt) {
954     if (object->sculpt->bm) {
955       /* Ensure no points to old arrays are stored in DM
956        *
957        * Apparently, we could not use DEG_id_tag_update
958        * here because this will lead to the while object
959        * surface to disappear, so we'll release DM in place.
960        */
961       BKE_object_free_derived_caches(object);
962
963       if (object->sculpt->pbvh) {
964         BKE_pbvh_free(object->sculpt->pbvh);
965         object->sculpt->pbvh = NULL;
966       }
967
968       sculptsession_bm_to_me_update_data_only(object, false);
969
970       /* In contrast with sculptsession_bm_to_me no need in
971        * DAG tag update here - derived mesh was freed and
972        * old pointers are nowhere stored.
973        */
974     }
975   }
976 }
977
978 void BKE_sculptsession_free(Object *ob)
979 {
980   if (ob && ob->sculpt) {
981     SculptSession *ss = ob->sculpt;
982
983     if (ss->bm) {
984       BKE_sculptsession_bm_to_me(ob, true);
985       BM_mesh_free(ss->bm);
986     }
987
988     if (ss->pbvh) {
989       BKE_pbvh_free(ss->pbvh);
990     }
991     MEM_SAFE_FREE(ss->pmap);
992     MEM_SAFE_FREE(ss->pmap_mem);
993     if (ss->bm_log) {
994       BM_log_free(ss->bm_log);
995     }
996
997     if (ss->texcache) {
998       MEM_freeN(ss->texcache);
999     }
1000
1001     if (ss->tex_pool) {
1002       BKE_image_pool_free(ss->tex_pool);
1003     }
1004
1005     if (ss->layer_co) {
1006       MEM_freeN(ss->layer_co);
1007     }
1008
1009     if (ss->orig_cos) {
1010       MEM_freeN(ss->orig_cos);
1011     }
1012     if (ss->deform_cos) {
1013       MEM_freeN(ss->deform_cos);
1014     }
1015     if (ss->deform_imats) {
1016       MEM_freeN(ss->deform_imats);
1017     }
1018
1019     BKE_sculptsession_free_vwpaint_data(ob->sculpt);
1020
1021     MEM_freeN(ss);
1022
1023     ob->sculpt = NULL;
1024   }
1025 }
1026
1027 /* Sculpt mode handles multires differently from regular meshes, but only if
1028  * it's the last modifier on the stack and it is not on the first level */
1029 MultiresModifierData *BKE_sculpt_multires_active(Scene *scene, Object *ob)
1030 {
1031   Mesh *me = (Mesh *)ob->data;
1032   ModifierData *md;
1033   VirtualModifierData virtualModifierData;
1034
1035   if (ob->sculpt && ob->sculpt->bm) {
1036     /* can't combine multires and dynamic topology */
1037     return NULL;
1038   }
1039
1040   if (!CustomData_get_layer(&me->ldata, CD_MDISPS)) {
1041     /* multires can't work without displacement layer */
1042     return NULL;
1043   }
1044
1045   for (md = modifiers_getVirtualModifierList(ob, &virtualModifierData); md; md = md->next) {
1046     if (md->type == eModifierType_Multires) {
1047       MultiresModifierData *mmd = (MultiresModifierData *)md;
1048
1049       if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) {
1050         continue;
1051       }
1052
1053       if (mmd->sculptlvl > 0) {
1054         return mmd;
1055       }
1056       else {
1057         return NULL;
1058       }
1059     }
1060   }
1061
1062   return NULL;
1063 }
1064
1065 /* Checks if there are any supported deformation modifiers active */
1066 static bool sculpt_modifiers_active(Scene *scene, Sculpt *sd, Object *ob)
1067 {
1068   ModifierData *md;
1069   Mesh *me = (Mesh *)ob->data;
1070   MultiresModifierData *mmd = BKE_sculpt_multires_active(scene, ob);
1071   VirtualModifierData virtualModifierData;
1072
1073   if (mmd || ob->sculpt->bm) {
1074     return false;
1075   }
1076
1077   /* non-locked shape keys could be handled in the same way as deformed mesh */
1078   if ((ob->shapeflag & OB_SHAPE_LOCK) == 0 && me->key && ob->shapenr) {
1079     return true;
1080   }
1081
1082   md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
1083
1084   /* exception for shape keys because we can edit those */
1085   for (; md; md = md->next) {
1086     const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1087     if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) {
1088       continue;
1089     }
1090     if (ELEM(md->type, eModifierType_ShapeKey, eModifierType_Multires)) {
1091       continue;
1092     }
1093
1094     if (mti->type == eModifierTypeType_OnlyDeform) {
1095       return true;
1096     }
1097     else if ((sd->flags & SCULPT_ONLY_DEFORM) == 0) {
1098       return true;
1099     }
1100   }
1101
1102   return false;
1103 }
1104
1105 /**
1106  * \param need_mask: So that the evaluated mesh that is returned has mask data.
1107  */
1108 void BKE_sculpt_update_mesh_elements(
1109     Depsgraph *depsgraph, Scene *scene, Sculpt *sd, Object *ob, bool need_pmap, bool need_mask)
1110 {
1111   /* TODO(sergey): Make sure ob points to an original object. This is what it
1112    * is supposed to be pointing to. The issue is, currently draw code takes
1113    * care of PBVH creation, even though this is something up to dependency
1114    * graph.
1115    * Probably, we need to being back logic which was checking for sculpt mode
1116    * and (re)create PBVH if needed in that case, similar to how DerivedMesh
1117    * was handling this.
1118    */
1119   ob = DEG_get_original_object(ob);
1120   Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
1121
1122   SculptSession *ss = ob->sculpt;
1123   Mesh *me = BKE_object_get_original_mesh(ob);
1124   MultiresModifierData *mmd = BKE_sculpt_multires_active(scene, ob);
1125
1126   ss->modifiers_active = sculpt_modifiers_active(scene, sd, ob);
1127   ss->show_diffuse_color = (sd->flags & SCULPT_SHOW_DIFFUSE) != 0;
1128   ss->show_mask = (sd->flags & SCULPT_HIDE_MASK) == 0;
1129
1130   ss->building_vp_handle = false;
1131
1132   if (need_mask) {
1133     if (mmd == NULL) {
1134       if (!CustomData_has_layer(&me->vdata, CD_PAINT_MASK)) {
1135         BKE_sculpt_mask_layers_ensure(ob, NULL);
1136       }
1137     }
1138     else {
1139       if (!CustomData_has_layer(&me->ldata, CD_GRID_PAINT_MASK)) {
1140 #if 1
1141         BKE_sculpt_mask_layers_ensure(ob, mmd);
1142 #else
1143         /* If we wanted to support adding mask data while multi-res painting,
1144          * we would need to do this. */
1145
1146         if ((ED_sculpt_mask_layers_ensure(ob, mmd) & ED_SCULPT_MASK_LAYER_CALC_LOOP)) {
1147           /* remake the derived mesh */
1148           ob->recalc |= ID_RECALC_GEOMETRY;
1149           BKE_object_handle_update(scene, ob);
1150         }
1151 #endif
1152       }
1153     }
1154   }
1155
1156   /* tessfaces aren't used and will become invalid */
1157   BKE_mesh_tessface_clear(me);
1158
1159   ss->kb = (mmd == NULL) ? BKE_keyblock_from_object(ob) : NULL;
1160
1161   Mesh *me_eval = mesh_get_eval_final(depsgraph, scene, ob_eval, &CD_MASK_BAREMESH);
1162
1163   /* VWPaint require mesh info for loop lookup, so require sculpt mode here */
1164   if (mmd && ob->mode & OB_MODE_SCULPT) {
1165     ss->multires = mmd;
1166     ss->totvert = me_eval->totvert;
1167     ss->totpoly = me_eval->totpoly;
1168     ss->mvert = NULL;
1169     ss->mpoly = NULL;
1170     ss->mloop = NULL;
1171   }
1172   else {
1173     ss->totvert = me->totvert;
1174     ss->totpoly = me->totpoly;
1175     ss->mvert = me->mvert;
1176     ss->mpoly = me->mpoly;
1177     ss->mloop = me->mloop;
1178     ss->multires = NULL;
1179     ss->vmask = CustomData_get_layer(&me->vdata, CD_PAINT_MASK);
1180   }
1181
1182   ss->subdiv_ccg = me_eval->runtime.subdiv_ccg;
1183
1184   PBVH *pbvh = BKE_sculpt_object_pbvh_ensure(depsgraph, ob);
1185   BLI_assert(pbvh == ss->pbvh);
1186   UNUSED_VARS_NDEBUG(pbvh);
1187   MEM_SAFE_FREE(ss->pmap);
1188   MEM_SAFE_FREE(ss->pmap_mem);
1189   if (need_pmap && ob->type == OB_MESH) {
1190     BKE_mesh_vert_poly_map_create(
1191         &ss->pmap, &ss->pmap_mem, me->mpoly, me->mloop, me->totvert, me->totpoly, me->totloop);
1192   }
1193
1194   pbvh_show_diffuse_color_set(ss->pbvh, ss->show_diffuse_color);
1195   pbvh_show_mask_set(ss->pbvh, ss->show_mask);
1196
1197   if (ss->modifiers_active) {
1198     if (!ss->orig_cos) {
1199       Object *object_orig = DEG_get_original_object(ob);
1200       int a;
1201
1202       BKE_sculptsession_free_deformMats(ss);
1203
1204       ss->orig_cos = (ss->kb) ? BKE_keyblock_convert_to_vertcos(ob, ss->kb) :
1205                                 BKE_mesh_vertexCos_get(me, NULL);
1206
1207       BKE_crazyspace_build_sculpt(
1208           depsgraph, scene, object_orig, &ss->deform_imats, &ss->deform_cos);
1209       BKE_pbvh_apply_vertCos(ss->pbvh, ss->deform_cos, me->totvert);
1210
1211       for (a = 0; a < me->totvert; ++a) {
1212         invert_m3(ss->deform_imats[a]);
1213       }
1214     }
1215   }
1216   else {
1217     BKE_sculptsession_free_deformMats(ss);
1218   }
1219
1220   if (ss->kb != NULL && ss->deform_cos == NULL) {
1221     ss->deform_cos = BKE_keyblock_convert_to_vertcos(ob, ss->kb);
1222   }
1223
1224   /* if pbvh is deformed, key block is already applied to it */
1225   if (ss->kb) {
1226     bool pbvh_deformed = BKE_pbvh_isDeformed(ss->pbvh);
1227     if (!pbvh_deformed || ss->deform_cos == NULL) {
1228       float(*vertCos)[3] = BKE_keyblock_convert_to_vertcos(ob, ss->kb);
1229
1230       if (vertCos) {
1231         if (!pbvh_deformed) {
1232           /* apply shape keys coordinates to PBVH */
1233           BKE_pbvh_apply_vertCos(ss->pbvh, vertCos, me->totvert);
1234         }
1235         if (ss->deform_cos == NULL) {
1236           ss->deform_cos = vertCos;
1237         }
1238         if (vertCos != ss->deform_cos) {
1239           MEM_freeN(vertCos);
1240         }
1241       }
1242     }
1243   }
1244
1245   /* 2.8x - avoid full mesh update! */
1246   BKE_mesh_batch_cache_dirty_tag(me, BKE_MESH_BATCH_DIRTY_SCULPT_COORDS);
1247 }
1248
1249 int BKE_sculpt_mask_layers_ensure(Object *ob, MultiresModifierData *mmd)
1250 {
1251   const float *paint_mask;
1252   Mesh *me = ob->data;
1253   int ret = 0;
1254
1255   paint_mask = CustomData_get_layer(&me->vdata, CD_PAINT_MASK);
1256
1257   /* if multires is active, create a grid paint mask layer if there
1258    * isn't one already */
1259   if (mmd && !CustomData_has_layer(&me->ldata, CD_GRID_PAINT_MASK)) {
1260     GridPaintMask *gmask;
1261     int level = max_ii(1, mmd->sculptlvl);
1262     int gridsize = BKE_ccg_gridsize(level);
1263     int gridarea = gridsize * gridsize;
1264     int i, j;
1265
1266     gmask = CustomData_add_layer(&me->ldata, CD_GRID_PAINT_MASK, CD_CALLOC, NULL, me->totloop);
1267
1268     for (i = 0; i < me->totloop; i++) {
1269       GridPaintMask *gpm = &gmask[i];
1270
1271       gpm->level = level;
1272       gpm->data = MEM_callocN(sizeof(float) * gridarea, "GridPaintMask.data");
1273     }
1274
1275     /* if vertices already have mask, copy into multires data */
1276     if (paint_mask) {
1277       for (i = 0; i < me->totpoly; i++) {
1278         const MPoly *p = &me->mpoly[i];
1279         float avg = 0;
1280
1281         /* mask center */
1282         for (j = 0; j < p->totloop; j++) {
1283           const MLoop *l = &me->mloop[p->loopstart + j];
1284           avg += paint_mask[l->v];
1285         }
1286         avg /= (float)p->totloop;
1287
1288         /* fill in multires mask corner */
1289         for (j = 0; j < p->totloop; j++) {
1290           GridPaintMask *gpm = &gmask[p->loopstart + j];
1291           const MLoop *l = &me->mloop[p->loopstart + j];
1292           const MLoop *prev = ME_POLY_LOOP_PREV(me->mloop, p, j);
1293           const MLoop *next = ME_POLY_LOOP_NEXT(me->mloop, p, j);
1294
1295           gpm->data[0] = avg;
1296           gpm->data[1] = (paint_mask[l->v] + paint_mask[next->v]) * 0.5f;
1297           gpm->data[2] = (paint_mask[l->v] + paint_mask[prev->v]) * 0.5f;
1298           gpm->data[3] = paint_mask[l->v];
1299         }
1300       }
1301     }
1302
1303     ret |= SCULPT_MASK_LAYER_CALC_LOOP;
1304   }
1305
1306   /* create vertex paint mask layer if there isn't one already */
1307   if (!paint_mask) {
1308     CustomData_add_layer(&me->vdata, CD_PAINT_MASK, CD_CALLOC, NULL, me->totvert);
1309     ret |= SCULPT_MASK_LAYER_CALC_VERT;
1310   }
1311
1312   return ret;
1313 }
1314
1315 void BKE_sculpt_toolsettings_data_ensure(struct Scene *scene)
1316 {
1317   BKE_paint_ensure(scene->toolsettings, (Paint **)&scene->toolsettings->sculpt);
1318
1319   Sculpt *sd = scene->toolsettings->sculpt;
1320   if (!sd->detail_size) {
1321     sd->detail_size = 12;
1322   }
1323   if (!sd->detail_percent) {
1324     sd->detail_percent = 25;
1325   }
1326   if (sd->constant_detail == 0.0f) {
1327     sd->constant_detail = 3.0f;
1328   }
1329
1330   /* Set sane default tiling offsets */
1331   if (!sd->paint.tile_offset[0]) {
1332     sd->paint.tile_offset[0] = 1.0f;
1333   }
1334   if (!sd->paint.tile_offset[1]) {
1335     sd->paint.tile_offset[1] = 1.0f;
1336   }
1337   if (!sd->paint.tile_offset[2]) {
1338     sd->paint.tile_offset[2] = 1.0f;
1339   }
1340 }
1341
1342 static bool check_sculpt_object_deformed(Object *object, const bool for_construction)
1343 {
1344   bool deformed = false;
1345
1346   /* Active modifiers means extra deformation, which can't be handled correct
1347    * on birth of PBVH and sculpt "layer" levels, so use PBVH only for internal brush
1348    * stuff and show final evaluated mesh so user would see actual object shape.
1349    */
1350   deformed |= object->sculpt->modifiers_active;
1351
1352   if (for_construction) {
1353     deformed |= object->sculpt->kb != NULL;
1354   }
1355   else {
1356     /* As in case with modifiers, we can't synchronize deformation made against
1357      * PBVH and non-locked keyblock, so also use PBVH only for brushes and
1358      * final DM to give final result to user.
1359      */
1360     deformed |= object->sculpt->kb && (object->shapeflag & OB_SHAPE_LOCK) == 0;
1361   }
1362
1363   return deformed;
1364 }
1365
1366 static PBVH *build_pbvh_for_dynamic_topology(Object *ob)
1367 {
1368   PBVH *pbvh = BKE_pbvh_new();
1369   BKE_pbvh_build_bmesh(pbvh,
1370                        ob->sculpt->bm,
1371                        ob->sculpt->bm_smooth_shading,
1372                        ob->sculpt->bm_log,
1373                        ob->sculpt->cd_vert_node_offset,
1374                        ob->sculpt->cd_face_node_offset);
1375   pbvh_show_diffuse_color_set(pbvh, ob->sculpt->show_diffuse_color);
1376   pbvh_show_mask_set(pbvh, ob->sculpt->show_mask);
1377   return pbvh;
1378 }
1379
1380 static PBVH *build_pbvh_from_regular_mesh(Object *ob, Mesh *me_eval_deform)
1381 {
1382   Mesh *me = BKE_object_get_original_mesh(ob);
1383   const int looptris_num = poly_to_tri_count(me->totpoly, me->totloop);
1384   PBVH *pbvh = BKE_pbvh_new();
1385
1386   MLoopTri *looptri = MEM_malloc_arrayN(looptris_num, sizeof(*looptri), __func__);
1387
1388   BKE_mesh_recalc_looptri(me->mloop, me->mpoly, me->mvert, me->totloop, me->totpoly, looptri);
1389
1390   BKE_pbvh_build_mesh(pbvh,
1391                       me->mpoly,
1392                       me->mloop,
1393                       me->mvert,
1394                       me->totvert,
1395                       &me->vdata,
1396                       &me->ldata,
1397                       looptri,
1398                       looptris_num);
1399
1400   pbvh_show_diffuse_color_set(pbvh, ob->sculpt->show_diffuse_color);
1401   pbvh_show_mask_set(pbvh, ob->sculpt->show_mask);
1402
1403   const bool is_deformed = check_sculpt_object_deformed(ob, true);
1404   if (is_deformed && me_eval_deform != NULL) {
1405     int totvert;
1406     float(*v_cos)[3] = BKE_mesh_vertexCos_get(me_eval_deform, &totvert);
1407     BKE_pbvh_apply_vertCos(pbvh, v_cos, totvert);
1408     MEM_freeN(v_cos);
1409   }
1410
1411   return pbvh;
1412 }
1413
1414 static PBVH *build_pbvh_from_ccg(Object *ob, SubdivCCG *subdiv_ccg)
1415 {
1416   CCGKey key;
1417   BKE_subdiv_ccg_key_top_level(&key, subdiv_ccg);
1418   PBVH *pbvh = BKE_pbvh_new();
1419   BKE_pbvh_build_grids(pbvh,
1420                        subdiv_ccg->grids,
1421                        subdiv_ccg->num_grids,
1422                        &key,
1423                        (void **)subdiv_ccg->grid_faces,
1424                        subdiv_ccg->grid_flag_mats,
1425                        subdiv_ccg->grid_hidden);
1426   pbvh_show_diffuse_color_set(pbvh, ob->sculpt->show_diffuse_color);
1427   pbvh_show_mask_set(pbvh, ob->sculpt->show_mask);
1428   return pbvh;
1429 }
1430
1431 PBVH *BKE_sculpt_object_pbvh_ensure(Depsgraph *depsgraph, Object *ob)
1432 {
1433   if (ob == NULL || ob->sculpt == NULL) {
1434     return NULL;
1435   }
1436   PBVH *pbvh = ob->sculpt->pbvh;
1437   if (pbvh != NULL) {
1438     /* NOTE: It is possible that grids were re-allocated due to modifier
1439      * stack. Need to update those pointers. */
1440     if (BKE_pbvh_type(pbvh) == PBVH_GRIDS) {
1441       Object *object_eval = DEG_get_evaluated_object(depsgraph, ob);
1442       Mesh *mesh_eval = object_eval->data;
1443       SubdivCCG *subdiv_ccg = mesh_eval->runtime.subdiv_ccg;
1444       if (subdiv_ccg != NULL) {
1445         BKE_sculpt_bvh_update_from_ccg(pbvh, subdiv_ccg);
1446       }
1447     }
1448     return pbvh;
1449   }
1450
1451   if (ob->sculpt->bm != NULL) {
1452     /* Sculpting on a BMesh (dynamic-topology) gets a special PBVH. */
1453     pbvh = build_pbvh_for_dynamic_topology(ob);
1454   }
1455   else {
1456     Object *object_eval = DEG_get_evaluated_object(depsgraph, ob);
1457     Mesh *mesh_eval = object_eval->data;
1458     if (mesh_eval->runtime.subdiv_ccg != NULL) {
1459       pbvh = build_pbvh_from_ccg(ob, mesh_eval->runtime.subdiv_ccg);
1460     }
1461     else if (ob->type == OB_MESH) {
1462       Mesh *me_eval_deform = mesh_get_eval_deform(
1463           depsgraph, DEG_get_evaluated_scene(depsgraph), object_eval, &CD_MASK_BAREMESH);
1464       pbvh = build_pbvh_from_regular_mesh(ob, me_eval_deform);
1465     }
1466   }
1467
1468   ob->sculpt->pbvh = pbvh;
1469   return pbvh;
1470 }
1471
1472 void BKE_sculpt_bvh_update_from_ccg(PBVH *pbvh, SubdivCCG *subdiv_ccg)
1473 {
1474   BKE_pbvh_grids_update(pbvh,
1475                         subdiv_ccg->grids,
1476                         (void **)subdiv_ccg->grid_faces,
1477                         subdiv_ccg->grid_flag_mats,
1478                         subdiv_ccg->grid_hidden);
1479 }