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