Cleanup: style, use braces for 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 already allocated/initialized destination.
451  * You probably never want to use that directly, use BKE_id_copy or BKE_id_copy_ex for typical needs.
452  *
453  * WARNING! This function will not handle ID user count!
454  *
455  * \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
456  */
457 void BKE_paint_curve_copy_data(Main *UNUSED(bmain),
458                                PaintCurve *pc_dst,
459                                const PaintCurve *pc_src,
460                                const int UNUSED(flag))
461 {
462   if (pc_src->tot_points != 0) {
463     pc_dst->points = MEM_dupallocN(pc_src->points);
464   }
465 }
466
467 PaintCurve *BKE_paint_curve_copy(Main *bmain, const PaintCurve *pc)
468 {
469   PaintCurve *pc_copy;
470   BKE_id_copy(bmain, &pc->id, (ID **)&pc_copy);
471   return pc_copy;
472 }
473
474 void BKE_paint_curve_make_local(Main *bmain, PaintCurve *pc, const bool lib_local)
475 {
476   BKE_id_make_local_generic(bmain, &pc->id, true, lib_local);
477 }
478
479 Palette *BKE_paint_palette(Paint *p)
480 {
481   return p ? p->palette : NULL;
482 }
483
484 void BKE_paint_palette_set(Paint *p, Palette *palette)
485 {
486   if (p) {
487     id_us_min((ID *)p->palette);
488     p->palette = palette;
489     id_us_plus((ID *)p->palette);
490   }
491 }
492
493 void BKE_paint_curve_set(Brush *br, PaintCurve *pc)
494 {
495   if (br) {
496     id_us_min((ID *)br->paint_curve);
497     br->paint_curve = pc;
498     id_us_plus((ID *)br->paint_curve);
499   }
500 }
501
502 void BKE_paint_curve_clamp_endpoint_add_index(PaintCurve *pc, const int add_index)
503 {
504   pc->add_index = (add_index || pc->tot_points == 1) ? (add_index + 1) : 0;
505 }
506
507 /* remove colour from palette. Must be certain color is inside the palette! */
508 void BKE_palette_color_remove(Palette *palette, PaletteColor *color)
509 {
510   if (BLI_listbase_count_at_most(&palette->colors, palette->active_color) ==
511       palette->active_color) {
512     palette->active_color--;
513   }
514
515   BLI_remlink(&palette->colors, color);
516
517   if (palette->active_color < 0 && !BLI_listbase_is_empty(&palette->colors)) {
518     palette->active_color = 0;
519   }
520
521   MEM_freeN(color);
522 }
523
524 void BKE_palette_clear(Palette *palette)
525 {
526   BLI_freelistN(&palette->colors);
527   palette->active_color = 0;
528 }
529
530 Palette *BKE_palette_add(Main *bmain, const char *name)
531 {
532   Palette *palette = BKE_id_new(bmain, ID_PAL, name);
533   return palette;
534 }
535
536 /**
537  * Only copy internal data of Palette ID from source to already allocated/initialized destination.
538  * You probably never want to use that directly, use BKE_id_copy or BKE_id_copy_ex for typical needs.
539  *
540  * WARNING! This function will not handle ID user count!
541  *
542  * \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
543  */
544 void BKE_palette_copy_data(Main *UNUSED(bmain),
545                            Palette *palette_dst,
546                            const Palette *palette_src,
547                            const int UNUSED(flag))
548 {
549   BLI_duplicatelist(&palette_dst->colors, &palette_src->colors);
550 }
551
552 Palette *BKE_palette_copy(Main *bmain, const Palette *palette)
553 {
554   Palette *palette_copy;
555   BKE_id_copy(bmain, &palette->id, (ID **)&palette_copy);
556   return palette_copy;
557 }
558
559 void BKE_palette_make_local(Main *bmain, Palette *palette, const bool lib_local)
560 {
561   BKE_id_make_local_generic(bmain, &palette->id, true, lib_local);
562 }
563
564 void BKE_palette_init(Palette *palette)
565 {
566   /* Enable fake user by default. */
567   id_fake_user_set(&palette->id);
568 }
569
570 /** Free (or release) any data used by this palette (does not free the palette itself). */
571 void BKE_palette_free(Palette *palette)
572 {
573   BLI_freelistN(&palette->colors);
574 }
575
576 PaletteColor *BKE_palette_color_add(Palette *palette)
577 {
578   PaletteColor *color = MEM_callocN(sizeof(*color), "Palette Color");
579   BLI_addtail(&palette->colors, color);
580   return color;
581 }
582
583 bool BKE_palette_is_empty(const struct Palette *palette)
584 {
585   return BLI_listbase_is_empty(&palette->colors);
586 }
587
588 /* are we in vertex paint or weight paint face select mode? */
589 bool BKE_paint_select_face_test(Object *ob)
590 {
591   return ((ob != NULL) && (ob->type == OB_MESH) && (ob->data != NULL) &&
592           (((Mesh *)ob->data)->editflag & ME_EDIT_PAINT_FACE_SEL) &&
593           (ob->mode & (OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT | OB_MODE_TEXTURE_PAINT)));
594 }
595
596 /* are we in weight paint vertex select mode? */
597 bool BKE_paint_select_vert_test(Object *ob)
598 {
599   return ((ob != NULL) && (ob->type == OB_MESH) && (ob->data != NULL) &&
600           (((Mesh *)ob->data)->editflag & ME_EDIT_PAINT_VERT_SEL) &&
601           (ob->mode & OB_MODE_WEIGHT_PAINT || ob->mode & OB_MODE_VERTEX_PAINT));
602 }
603
604 /**
605  * used to check if selection is possible
606  * (when we don't care if its face or vert)
607  */
608 bool BKE_paint_select_elem_test(Object *ob)
609 {
610   return (BKE_paint_select_vert_test(ob) || BKE_paint_select_face_test(ob));
611 }
612
613 void BKE_paint_cavity_curve_preset(Paint *p, int preset)
614 {
615   CurveMap *cm = NULL;
616
617   if (!p->cavity_curve) {
618     p->cavity_curve = curvemapping_add(1, 0, 0, 1, 1);
619   }
620
621   cm = p->cavity_curve->cm;
622   cm->flag &= ~CUMA_EXTEND_EXTRAPOLATE;
623
624   p->cavity_curve->preset = preset;
625   curvemap_reset(cm, &p->cavity_curve->clipr, p->cavity_curve->preset, CURVEMAP_SLOPE_POSITIVE);
626   curvemapping_changed(p->cavity_curve, false);
627 }
628
629 eObjectMode BKE_paint_object_mode_from_paintmode(ePaintMode mode)
630 {
631   switch (mode) {
632     case PAINT_MODE_SCULPT:
633       return OB_MODE_SCULPT;
634     case PAINT_MODE_VERTEX:
635       return OB_MODE_VERTEX_PAINT;
636     case PAINT_MODE_WEIGHT:
637       return OB_MODE_WEIGHT_PAINT;
638     case PAINT_MODE_TEXTURE_2D:
639     case PAINT_MODE_TEXTURE_3D:
640       return OB_MODE_TEXTURE_PAINT;
641     case PAINT_MODE_SCULPT_UV:
642       return OB_MODE_EDIT;
643     case PAINT_MODE_INVALID:
644     default:
645       return 0;
646   }
647 }
648
649 /**
650  * Call when entering each respective paint mode.
651  */
652 bool BKE_paint_ensure(const ToolSettings *ts, struct Paint **r_paint)
653 {
654   Paint *paint = NULL;
655   if (*r_paint) {
656     /* Note: 'ts->imapaint' is ignored, it's not allocated. */
657     BLI_assert(ELEM(*r_paint,
658                     &ts->gp_paint->paint,
659                     &ts->sculpt->paint,
660                     &ts->vpaint->paint,
661                     &ts->wpaint->paint,
662                     &ts->uvsculpt->paint));
663
664 #ifdef DEBUG
665     struct Paint paint_test = **r_paint;
666     BKE_paint_runtime_init(ts, *r_paint);
667     /* Swap so debug doesn't hide errors when release fails. */
668     SWAP(Paint, **r_paint, paint_test);
669     BLI_assert(paint_test.runtime.ob_mode == (*r_paint)->runtime.ob_mode);
670     BLI_assert(paint_test.runtime.tool_offset == (*r_paint)->runtime.tool_offset);
671 #endif
672     return true;
673   }
674
675   if (((VPaint **)r_paint == &ts->vpaint) || ((VPaint **)r_paint == &ts->wpaint)) {
676     VPaint *data = MEM_callocN(sizeof(*data), __func__);
677     paint = &data->paint;
678   }
679   else if ((Sculpt **)r_paint == &ts->sculpt) {
680     Sculpt *data = MEM_callocN(sizeof(*data), __func__);
681     paint = &data->paint;
682
683     /* Turn on X plane mirror symmetry by default */
684     paint->symmetry_flags |= PAINT_SYMM_X;
685
686     /* Make sure at least dyntopo subdivision is enabled */
687     data->flags |= SCULPT_DYNTOPO_SUBDIVIDE | SCULPT_DYNTOPO_COLLAPSE;
688   }
689   else if ((GpPaint **)r_paint == &ts->gp_paint) {
690     GpPaint *data = MEM_callocN(sizeof(*data), __func__);
691     paint = &data->paint;
692   }
693   else if ((UvSculpt **)r_paint == &ts->uvsculpt) {
694     UvSculpt *data = MEM_callocN(sizeof(*data), __func__);
695     paint = &data->paint;
696   }
697
698   paint->flags |= PAINT_SHOW_BRUSH;
699
700   *r_paint = paint;
701
702   BKE_paint_runtime_init(ts, paint);
703
704   return false;
705 }
706
707 void BKE_paint_init(Main *bmain, Scene *sce, ePaintMode mode, const char col[3])
708 {
709   UnifiedPaintSettings *ups = &sce->toolsettings->unified_paint_settings;
710   Paint *paint = BKE_paint_get_active_from_paintmode(sce, mode);
711
712   /* If there's no brush, create one */
713   if (PAINT_MODE_HAS_BRUSH(mode)) {
714     Brush *brush = BKE_paint_brush(paint);
715     if (brush == NULL) {
716       eObjectMode ob_mode = BKE_paint_object_mode_from_paintmode(mode);
717       brush = BKE_brush_first_search(bmain, ob_mode);
718       if (!brush) {
719         brush = BKE_brush_add(bmain, "Brush", ob_mode);
720         id_us_min(&brush->id); /* fake user only */
721       }
722       BKE_paint_brush_set(paint, brush);
723     }
724   }
725
726   memcpy(paint->paint_cursor_col, col, 3);
727   paint->paint_cursor_col[3] = 128;
728   ups->last_stroke_valid = false;
729   zero_v3(ups->average_stroke_accum);
730   ups->average_stroke_counter = 0;
731   if (!paint->cavity_curve) {
732     BKE_paint_cavity_curve_preset(paint, CURVE_PRESET_LINE);
733   }
734 }
735
736 void BKE_paint_free(Paint *paint)
737 {
738   curvemapping_free(paint->cavity_curve);
739   MEM_SAFE_FREE(paint->tool_slots);
740 }
741
742 /* called when copying scene settings, so even if 'src' and 'tar' are the same
743  * still do a id_us_plus(), rather then if we were copying between 2 existing
744  * scenes where a matching value should decrease the existing user count as
745  * with paint_brush_set() */
746 void BKE_paint_copy(Paint *src, Paint *tar, const int flag)
747 {
748   tar->brush = src->brush;
749   tar->cavity_curve = curvemapping_copy(src->cavity_curve);
750   tar->tool_slots = MEM_dupallocN(src->tool_slots);
751
752   if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
753     id_us_plus((ID *)tar->brush);
754     id_us_plus((ID *)tar->palette);
755     if (src->tool_slots != NULL) {
756       for (int i = 0; i < tar->tool_slots_len; i++) {
757         id_us_plus((ID *)tar->tool_slots[i].brush);
758       }
759     }
760   }
761 }
762
763 void BKE_paint_stroke_get_average(Scene *scene, Object *ob, float stroke[3])
764 {
765   UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
766   if (ups->last_stroke_valid && ups->average_stroke_counter > 0) {
767     float fac = 1.0f / ups->average_stroke_counter;
768     mul_v3_v3fl(stroke, ups->average_stroke_accum, fac);
769   }
770   else {
771     copy_v3_v3(stroke, ob->obmat[3]);
772   }
773 }
774
775 /* returns non-zero if any of the face's vertices
776  * are hidden, zero otherwise */
777 bool paint_is_face_hidden(const MLoopTri *lt, const MVert *mvert, const MLoop *mloop)
778 {
779   return ((mvert[mloop[lt->tri[0]].v].flag & ME_HIDE) ||
780           (mvert[mloop[lt->tri[1]].v].flag & ME_HIDE) ||
781           (mvert[mloop[lt->tri[2]].v].flag & ME_HIDE));
782 }
783
784 /* returns non-zero if any of the corners of the grid
785  * face whose inner corner is at (x, y) are hidden,
786  * zero otherwise */
787 bool paint_is_grid_face_hidden(const unsigned int *grid_hidden, int gridsize, int x, int y)
788 {
789   /* skip face if any of its corners are hidden */
790   return (BLI_BITMAP_TEST(grid_hidden, y * gridsize + x) ||
791           BLI_BITMAP_TEST(grid_hidden, y * gridsize + x + 1) ||
792           BLI_BITMAP_TEST(grid_hidden, (y + 1) * gridsize + x + 1) ||
793           BLI_BITMAP_TEST(grid_hidden, (y + 1) * gridsize + x));
794 }
795
796 /* Return true if all vertices in the face are visible, false otherwise */
797 bool paint_is_bmesh_face_hidden(BMFace *f)
798 {
799   BMLoop *l_iter;
800   BMLoop *l_first;
801
802   l_iter = l_first = BM_FACE_FIRST_LOOP(f);
803   do {
804     if (BM_elem_flag_test(l_iter->v, BM_ELEM_HIDDEN)) {
805       return true;
806     }
807   } while ((l_iter = l_iter->next) != l_first);
808
809   return false;
810 }
811
812 float paint_grid_paint_mask(const GridPaintMask *gpm, unsigned level, unsigned x, unsigned y)
813 {
814   int factor = BKE_ccg_factor(level, gpm->level);
815   int gridsize = BKE_ccg_gridsize(gpm->level);
816
817   return gpm->data[(y * factor) * gridsize + (x * factor)];
818 }
819
820 /* threshold to move before updating the brush rotation */
821 #define RAKE_THRESHHOLD 20
822
823 void paint_update_brush_rake_rotation(UnifiedPaintSettings *ups, Brush *brush, float rotation)
824 {
825   if (brush->mtex.brush_angle_mode & MTEX_ANGLE_RAKE) {
826     ups->brush_rotation = rotation;
827   }
828   else {
829     ups->brush_rotation = 0.0f;
830   }
831
832   if (brush->mask_mtex.brush_angle_mode & MTEX_ANGLE_RAKE) {
833     ups->brush_rotation_sec = rotation;
834   }
835   else {
836     ups->brush_rotation_sec = 0.0f;
837   }
838 }
839
840 bool paint_calculate_rake_rotation(UnifiedPaintSettings *ups,
841                                    Brush *brush,
842                                    const float mouse_pos[2])
843 {
844   bool ok = false;
845   if ((brush->mtex.brush_angle_mode & MTEX_ANGLE_RAKE) ||
846       (brush->mask_mtex.brush_angle_mode & MTEX_ANGLE_RAKE)) {
847     const float r = RAKE_THRESHHOLD;
848     float rotation;
849
850     float dpos[2];
851     sub_v2_v2v2(dpos, ups->last_rake, mouse_pos);
852
853     if (len_squared_v2(dpos) >= r * r) {
854       rotation = atan2f(dpos[0], dpos[1]);
855
856       copy_v2_v2(ups->last_rake, mouse_pos);
857
858       ups->last_rake_angle = rotation;
859
860       paint_update_brush_rake_rotation(ups, brush, rotation);
861       ok = true;
862     }
863     /* make sure we reset here to the last rotation to avoid accumulating
864      * values in case a random rotation is also added */
865     else {
866       paint_update_brush_rake_rotation(ups, brush, ups->last_rake_angle);
867       ok = false;
868     }
869   }
870   else {
871     ups->brush_rotation = ups->brush_rotation_sec = 0.0f;
872     ok = true;
873   }
874   return ok;
875 }
876
877 void BKE_sculptsession_free_deformMats(SculptSession *ss)
878 {
879   MEM_SAFE_FREE(ss->orig_cos);
880   MEM_SAFE_FREE(ss->deform_cos);
881   MEM_SAFE_FREE(ss->deform_imats);
882 }
883
884 void BKE_sculptsession_free_vwpaint_data(struct SculptSession *ss)
885 {
886   struct SculptVertexPaintGeomMap *gmap = NULL;
887   if (ss->mode_type == OB_MODE_VERTEX_PAINT) {
888     gmap = &ss->mode.vpaint.gmap;
889
890     MEM_SAFE_FREE(ss->mode.vpaint.previous_color);
891   }
892   else if (ss->mode_type == OB_MODE_WEIGHT_PAINT) {
893     gmap = &ss->mode.wpaint.gmap;
894
895     MEM_SAFE_FREE(ss->mode.wpaint.alpha_weight);
896     if (ss->mode.wpaint.dvert_prev) {
897       BKE_defvert_array_free_elems(ss->mode.wpaint.dvert_prev, ss->totvert);
898       MEM_freeN(ss->mode.wpaint.dvert_prev);
899       ss->mode.wpaint.dvert_prev = NULL;
900     }
901   }
902   else {
903     return;
904   }
905   MEM_SAFE_FREE(gmap->vert_to_loop);
906   MEM_SAFE_FREE(gmap->vert_map_mem);
907   MEM_SAFE_FREE(gmap->vert_to_poly);
908   MEM_SAFE_FREE(gmap->poly_map_mem);
909 }
910
911 /* Write out the sculpt dynamic-topology BMesh to the Mesh */
912 static void sculptsession_bm_to_me_update_data_only(Object *ob, bool reorder)
913 {
914   SculptSession *ss = ob->sculpt;
915
916   if (ss->bm) {
917     if (ob->data) {
918       BMIter iter;
919       BMFace *efa;
920       BM_ITER_MESH (efa, &iter, ss->bm, BM_FACES_OF_MESH) {
921         BM_elem_flag_set(efa, BM_ELEM_SMOOTH, ss->bm_smooth_shading);
922       }
923       if (reorder) {
924         BM_log_mesh_elems_reorder(ss->bm, ss->bm_log);
925       }
926       BM_mesh_bm_to_me(NULL,
927                        ss->bm,
928                        ob->data,
929                        (&(struct BMeshToMeshParams){
930                            .calc_object_remap = false,
931                        }));
932     }
933   }
934 }
935
936 void BKE_sculptsession_bm_to_me(Object *ob, bool reorder)
937 {
938   if (ob && ob->sculpt) {
939     sculptsession_bm_to_me_update_data_only(ob, reorder);
940
941     /* ensure the objects evaluated mesh doesn't hold onto arrays now realloc'd in the mesh [#34473] */
942     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
943   }
944 }
945
946 void BKE_sculptsession_bm_to_me_for_render(Object *object)
947 {
948   if (object && object->sculpt) {
949     if (object->sculpt->bm) {
950       /* Ensure no points to old arrays are stored in DM
951        *
952        * Apparently, we could not use DEG_id_tag_update
953        * here because this will lead to the while object
954        * surface to disappear, so we'll release DM in place.
955        */
956       BKE_object_free_derived_caches(object);
957
958       if (object->sculpt->pbvh) {
959         BKE_pbvh_free(object->sculpt->pbvh);
960         object->sculpt->pbvh = NULL;
961       }
962
963       sculptsession_bm_to_me_update_data_only(object, false);
964
965       /* In contrast with sculptsession_bm_to_me no need in
966        * DAG tag update here - derived mesh was freed and
967        * old pointers are nowhere stored.
968        */
969     }
970   }
971 }
972
973 void BKE_sculptsession_free(Object *ob)
974 {
975   if (ob && ob->sculpt) {
976     SculptSession *ss = ob->sculpt;
977
978     if (ss->bm) {
979       BKE_sculptsession_bm_to_me(ob, true);
980       BM_mesh_free(ss->bm);
981     }
982
983     if (ss->pbvh) {
984       BKE_pbvh_free(ss->pbvh);
985     }
986     MEM_SAFE_FREE(ss->pmap);
987     MEM_SAFE_FREE(ss->pmap_mem);
988     if (ss->bm_log) {
989       BM_log_free(ss->bm_log);
990     }
991
992     if (ss->texcache) {
993       MEM_freeN(ss->texcache);
994     }
995
996     if (ss->tex_pool) {
997       BKE_image_pool_free(ss->tex_pool);
998     }
999
1000     if (ss->layer_co) {
1001       MEM_freeN(ss->layer_co);
1002     }
1003
1004     if (ss->orig_cos) {
1005       MEM_freeN(ss->orig_cos);
1006     }
1007     if (ss->deform_cos) {
1008       MEM_freeN(ss->deform_cos);
1009     }
1010     if (ss->deform_imats) {
1011       MEM_freeN(ss->deform_imats);
1012     }
1013
1014     BKE_sculptsession_free_vwpaint_data(ob->sculpt);
1015
1016     MEM_freeN(ss);
1017
1018     ob->sculpt = NULL;
1019   }
1020 }
1021
1022 /* Sculpt mode handles multires differently from regular meshes, but only if
1023  * it's the last modifier on the stack and it is not on the first level */
1024 MultiresModifierData *BKE_sculpt_multires_active(Scene *scene, Object *ob)
1025 {
1026   Mesh *me = (Mesh *)ob->data;
1027   ModifierData *md;
1028   VirtualModifierData virtualModifierData;
1029
1030   if (ob->sculpt && ob->sculpt->bm) {
1031     /* can't combine multires and dynamic topology */
1032     return NULL;
1033   }
1034
1035   if (!CustomData_get_layer(&me->ldata, CD_MDISPS)) {
1036     /* multires can't work without displacement layer */
1037     return NULL;
1038   }
1039
1040   for (md = modifiers_getVirtualModifierList(ob, &virtualModifierData); md; md = md->next) {
1041     if (md->type == eModifierType_Multires) {
1042       MultiresModifierData *mmd = (MultiresModifierData *)md;
1043
1044       if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) {
1045         continue;
1046       }
1047
1048       if (mmd->sculptlvl > 0) {
1049         return mmd;
1050       }
1051       else {
1052         return NULL;
1053       }
1054     }
1055   }
1056
1057   return NULL;
1058 }
1059
1060 /* Checks if there are any supported deformation modifiers active */
1061 static bool sculpt_modifiers_active(Scene *scene, Sculpt *sd, Object *ob)
1062 {
1063   ModifierData *md;
1064   Mesh *me = (Mesh *)ob->data;
1065   MultiresModifierData *mmd = BKE_sculpt_multires_active(scene, ob);
1066   VirtualModifierData virtualModifierData;
1067
1068   if (mmd || ob->sculpt->bm) {
1069     return false;
1070   }
1071
1072   /* non-locked shape keys could be handled in the same way as deformed mesh */
1073   if ((ob->shapeflag & OB_SHAPE_LOCK) == 0 && me->key && ob->shapenr) {
1074     return true;
1075   }
1076
1077   md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
1078
1079   /* exception for shape keys because we can edit those */
1080   for (; md; md = md->next) {
1081     const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1082     if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) {
1083       continue;
1084     }
1085     if (ELEM(md->type, eModifierType_ShapeKey, eModifierType_Multires)) {
1086       continue;
1087     }
1088
1089     if (mti->type == eModifierTypeType_OnlyDeform) {
1090       return true;
1091     }
1092     else if ((sd->flags & SCULPT_ONLY_DEFORM) == 0) {
1093       return true;
1094     }
1095   }
1096
1097   return false;
1098 }
1099
1100 /**
1101  * \param need_mask: So that the evaluated mesh that is returned has mask data.
1102  */
1103 void BKE_sculpt_update_mesh_elements(
1104     Depsgraph *depsgraph, Scene *scene, Sculpt *sd, Object *ob, bool need_pmap, bool need_mask)
1105 {
1106   /* TODO(sergey): Make sure ob points to an original object. This is what it
1107    * is supposed to be pointing to. The issue is, currently draw code takes
1108    * care of PBVH creation, even though this is something up to dependency
1109    * graph.
1110    * Probably, we need to being back logic which was checking for sculpt mode
1111    * and (re)create PBVH if needed in that case, similar to how DerivedMesh
1112    * was handling this.
1113    */
1114   ob = DEG_get_original_object(ob);
1115   Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
1116
1117   SculptSession *ss = ob->sculpt;
1118   Mesh *me = BKE_object_get_original_mesh(ob);
1119   MultiresModifierData *mmd = BKE_sculpt_multires_active(scene, ob);
1120
1121   ss->modifiers_active = sculpt_modifiers_active(scene, sd, ob);
1122   ss->show_diffuse_color = (sd->flags & SCULPT_SHOW_DIFFUSE) != 0;
1123   ss->show_mask = (sd->flags & SCULPT_HIDE_MASK) == 0;
1124
1125   ss->building_vp_handle = false;
1126
1127   if (need_mask) {
1128     if (mmd == NULL) {
1129       if (!CustomData_has_layer(&me->vdata, CD_PAINT_MASK)) {
1130         BKE_sculpt_mask_layers_ensure(ob, NULL);
1131       }
1132     }
1133     else {
1134       if (!CustomData_has_layer(&me->ldata, CD_GRID_PAINT_MASK)) {
1135 #if 1
1136         BKE_sculpt_mask_layers_ensure(ob, mmd);
1137 #else /* if we wanted to support adding mask data while multi-res painting, we would need to do this */
1138         if ((ED_sculpt_mask_layers_ensure(ob, mmd) & ED_SCULPT_MASK_LAYER_CALC_LOOP)) {
1139           /* remake the derived mesh */
1140           ob->recalc |= ID_RECALC_GEOMETRY;
1141           BKE_object_handle_update(scene, ob);
1142         }
1143 #endif
1144       }
1145     }
1146   }
1147
1148   /* tessfaces aren't used and will become invalid */
1149   BKE_mesh_tessface_clear(me);
1150
1151   ss->kb = (mmd == NULL) ? BKE_keyblock_from_object(ob) : NULL;
1152
1153   Mesh *me_eval = mesh_get_eval_final(depsgraph, scene, ob_eval, &CD_MASK_BAREMESH);
1154
1155   /* VWPaint require mesh info for loop lookup, so require sculpt mode here */
1156   if (mmd && ob->mode & OB_MODE_SCULPT) {
1157     ss->multires = mmd;
1158     ss->totvert = me_eval->totvert;
1159     ss->totpoly = me_eval->totpoly;
1160     ss->mvert = NULL;
1161     ss->mpoly = NULL;
1162     ss->mloop = NULL;
1163   }
1164   else {
1165     ss->totvert = me->totvert;
1166     ss->totpoly = me->totpoly;
1167     ss->mvert = me->mvert;
1168     ss->mpoly = me->mpoly;
1169     ss->mloop = me->mloop;
1170     ss->multires = NULL;
1171     ss->vmask = CustomData_get_layer(&me->vdata, CD_PAINT_MASK);
1172   }
1173
1174   ss->subdiv_ccg = me_eval->runtime.subdiv_ccg;
1175
1176   PBVH *pbvh = BKE_sculpt_object_pbvh_ensure(depsgraph, ob);
1177   BLI_assert(pbvh == ss->pbvh);
1178   UNUSED_VARS_NDEBUG(pbvh);
1179   MEM_SAFE_FREE(ss->pmap);
1180   MEM_SAFE_FREE(ss->pmap_mem);
1181   if (need_pmap && ob->type == OB_MESH) {
1182     BKE_mesh_vert_poly_map_create(
1183         &ss->pmap, &ss->pmap_mem, me->mpoly, me->mloop, me->totvert, me->totpoly, me->totloop);
1184   }
1185
1186   pbvh_show_diffuse_color_set(ss->pbvh, ss->show_diffuse_color);
1187   pbvh_show_mask_set(ss->pbvh, ss->show_mask);
1188
1189   if (ss->modifiers_active) {
1190     if (!ss->orig_cos) {
1191       Object *object_orig = DEG_get_original_object(ob);
1192       int a;
1193
1194       BKE_sculptsession_free_deformMats(ss);
1195
1196       ss->orig_cos = (ss->kb) ? BKE_keyblock_convert_to_vertcos(ob, ss->kb) :
1197                                 BKE_mesh_vertexCos_get(me, NULL);
1198
1199       BKE_crazyspace_build_sculpt(
1200           depsgraph, scene, object_orig, &ss->deform_imats, &ss->deform_cos);
1201       BKE_pbvh_apply_vertCos(ss->pbvh, ss->deform_cos, me->totvert);
1202
1203       for (a = 0; a < me->totvert; ++a) {
1204         invert_m3(ss->deform_imats[a]);
1205       }
1206     }
1207   }
1208   else {
1209     BKE_sculptsession_free_deformMats(ss);
1210   }
1211
1212   if (ss->kb != NULL && ss->deform_cos == NULL) {
1213     ss->deform_cos = BKE_keyblock_convert_to_vertcos(ob, ss->kb);
1214   }
1215
1216   /* if pbvh is deformed, key block is already applied to it */
1217   if (ss->kb) {
1218     bool pbvh_deformed = BKE_pbvh_isDeformed(ss->pbvh);
1219     if (!pbvh_deformed || ss->deform_cos == NULL) {
1220       float(*vertCos)[3] = BKE_keyblock_convert_to_vertcos(ob, ss->kb);
1221
1222       if (vertCos) {
1223         if (!pbvh_deformed) {
1224           /* apply shape keys coordinates to PBVH */
1225           BKE_pbvh_apply_vertCos(ss->pbvh, vertCos, me->totvert);
1226         }
1227         if (ss->deform_cos == NULL) {
1228           ss->deform_cos = vertCos;
1229         }
1230         if (vertCos != ss->deform_cos) {
1231           MEM_freeN(vertCos);
1232         }
1233       }
1234     }
1235   }
1236
1237   /* 2.8x - avoid full mesh update! */
1238   BKE_mesh_batch_cache_dirty_tag(me, BKE_MESH_BATCH_DIRTY_SCULPT_COORDS);
1239 }
1240
1241 int BKE_sculpt_mask_layers_ensure(Object *ob, MultiresModifierData *mmd)
1242 {
1243   const float *paint_mask;
1244   Mesh *me = ob->data;
1245   int ret = 0;
1246
1247   paint_mask = CustomData_get_layer(&me->vdata, CD_PAINT_MASK);
1248
1249   /* if multires is active, create a grid paint mask layer if there
1250    * isn't one already */
1251   if (mmd && !CustomData_has_layer(&me->ldata, CD_GRID_PAINT_MASK)) {
1252     GridPaintMask *gmask;
1253     int level = max_ii(1, mmd->sculptlvl);
1254     int gridsize = BKE_ccg_gridsize(level);
1255     int gridarea = gridsize * gridsize;
1256     int i, j;
1257
1258     gmask = CustomData_add_layer(&me->ldata, CD_GRID_PAINT_MASK, CD_CALLOC, NULL, me->totloop);
1259
1260     for (i = 0; i < me->totloop; i++) {
1261       GridPaintMask *gpm = &gmask[i];
1262
1263       gpm->level = level;
1264       gpm->data = MEM_callocN(sizeof(float) * gridarea, "GridPaintMask.data");
1265     }
1266
1267     /* if vertices already have mask, copy into multires data */
1268     if (paint_mask) {
1269       for (i = 0; i < me->totpoly; i++) {
1270         const MPoly *p = &me->mpoly[i];
1271         float avg = 0;
1272
1273         /* mask center */
1274         for (j = 0; j < p->totloop; j++) {
1275           const MLoop *l = &me->mloop[p->loopstart + j];
1276           avg += paint_mask[l->v];
1277         }
1278         avg /= (float)p->totloop;
1279
1280         /* fill in multires mask corner */
1281         for (j = 0; j < p->totloop; j++) {
1282           GridPaintMask *gpm = &gmask[p->loopstart + j];
1283           const MLoop *l = &me->mloop[p->loopstart + j];
1284           const MLoop *prev = ME_POLY_LOOP_PREV(me->mloop, p, j);
1285           const MLoop *next = ME_POLY_LOOP_NEXT(me->mloop, p, j);
1286
1287           gpm->data[0] = avg;
1288           gpm->data[1] = (paint_mask[l->v] + paint_mask[next->v]) * 0.5f;
1289           gpm->data[2] = (paint_mask[l->v] + paint_mask[prev->v]) * 0.5f;
1290           gpm->data[3] = paint_mask[l->v];
1291         }
1292       }
1293     }
1294
1295     ret |= SCULPT_MASK_LAYER_CALC_LOOP;
1296   }
1297
1298   /* create vertex paint mask layer if there isn't one already */
1299   if (!paint_mask) {
1300     CustomData_add_layer(&me->vdata, CD_PAINT_MASK, CD_CALLOC, NULL, me->totvert);
1301     ret |= SCULPT_MASK_LAYER_CALC_VERT;
1302   }
1303
1304   return ret;
1305 }
1306
1307 void BKE_sculpt_toolsettings_data_ensure(struct Scene *scene)
1308 {
1309   BKE_paint_ensure(scene->toolsettings, (Paint **)&scene->toolsettings->sculpt);
1310
1311   Sculpt *sd = scene->toolsettings->sculpt;
1312   if (!sd->detail_size) {
1313     sd->detail_size = 12;
1314   }
1315   if (!sd->detail_percent) {
1316     sd->detail_percent = 25;
1317   }
1318   if (sd->constant_detail == 0.0f) {
1319     sd->constant_detail = 3.0f;
1320   }
1321
1322   /* Set sane default tiling offsets */
1323   if (!sd->paint.tile_offset[0]) {
1324     sd->paint.tile_offset[0] = 1.0f;
1325   }
1326   if (!sd->paint.tile_offset[1]) {
1327     sd->paint.tile_offset[1] = 1.0f;
1328   }
1329   if (!sd->paint.tile_offset[2]) {
1330     sd->paint.tile_offset[2] = 1.0f;
1331   }
1332 }
1333
1334 static bool check_sculpt_object_deformed(Object *object, const bool for_construction)
1335 {
1336   bool deformed = false;
1337
1338   /* Active modifiers means extra deformation, which can't be handled correct
1339    * on birth of PBVH and sculpt "layer" levels, so use PBVH only for internal brush
1340    * stuff and show final evaluated mesh so user would see actual object shape.
1341    */
1342   deformed |= object->sculpt->modifiers_active;
1343
1344   if (for_construction) {
1345     deformed |= object->sculpt->kb != NULL;
1346   }
1347   else {
1348     /* As in case with modifiers, we can't synchronize deformation made against
1349      * PBVH and non-locked keyblock, so also use PBVH only for brushes and
1350      * final DM to give final result to user.
1351      */
1352     deformed |= object->sculpt->kb && (object->shapeflag & OB_SHAPE_LOCK) == 0;
1353   }
1354
1355   return deformed;
1356 }
1357
1358 static PBVH *build_pbvh_for_dynamic_topology(Object *ob)
1359 {
1360   PBVH *pbvh = BKE_pbvh_new();
1361   BKE_pbvh_build_bmesh(pbvh,
1362                        ob->sculpt->bm,
1363                        ob->sculpt->bm_smooth_shading,
1364                        ob->sculpt->bm_log,
1365                        ob->sculpt->cd_vert_node_offset,
1366                        ob->sculpt->cd_face_node_offset);
1367   pbvh_show_diffuse_color_set(pbvh, ob->sculpt->show_diffuse_color);
1368   pbvh_show_mask_set(pbvh, ob->sculpt->show_mask);
1369   return pbvh;
1370 }
1371
1372 static PBVH *build_pbvh_from_regular_mesh(Object *ob, Mesh *me_eval_deform)
1373 {
1374   Mesh *me = BKE_object_get_original_mesh(ob);
1375   const int looptris_num = poly_to_tri_count(me->totpoly, me->totloop);
1376   PBVH *pbvh = BKE_pbvh_new();
1377
1378   MLoopTri *looptri = MEM_malloc_arrayN(looptris_num, sizeof(*looptri), __func__);
1379
1380   BKE_mesh_recalc_looptri(me->mloop, me->mpoly, me->mvert, me->totloop, me->totpoly, looptri);
1381
1382   BKE_pbvh_build_mesh(
1383       pbvh, me->mpoly, me->mloop, me->mvert, me->totvert, &me->vdata, looptri, looptris_num);
1384
1385   pbvh_show_diffuse_color_set(pbvh, ob->sculpt->show_diffuse_color);
1386   pbvh_show_mask_set(pbvh, ob->sculpt->show_mask);
1387
1388   const bool is_deformed = check_sculpt_object_deformed(ob, true);
1389   if (is_deformed && me_eval_deform != NULL) {
1390     int totvert;
1391     float(*v_cos)[3] = BKE_mesh_vertexCos_get(me_eval_deform, &totvert);
1392     BKE_pbvh_apply_vertCos(pbvh, v_cos, totvert);
1393     MEM_freeN(v_cos);
1394   }
1395
1396   return pbvh;
1397 }
1398
1399 static PBVH *build_pbvh_from_ccg(Object *ob, SubdivCCG *subdiv_ccg)
1400 {
1401   CCGKey key;
1402   BKE_subdiv_ccg_key_top_level(&key, subdiv_ccg);
1403   PBVH *pbvh = BKE_pbvh_new();
1404   BKE_pbvh_build_grids(pbvh,
1405                        subdiv_ccg->grids,
1406                        subdiv_ccg->num_grids,
1407                        &key,
1408                        (void **)subdiv_ccg->grid_faces,
1409                        subdiv_ccg->grid_flag_mats,
1410                        subdiv_ccg->grid_hidden);
1411   pbvh_show_diffuse_color_set(pbvh, ob->sculpt->show_diffuse_color);
1412   pbvh_show_mask_set(pbvh, ob->sculpt->show_mask);
1413   return pbvh;
1414 }
1415
1416 PBVH *BKE_sculpt_object_pbvh_ensure(Depsgraph *depsgraph, Object *ob)
1417 {
1418   if (ob == NULL || ob->sculpt == NULL) {
1419     return NULL;
1420   }
1421   PBVH *pbvh = ob->sculpt->pbvh;
1422   if (pbvh != NULL) {
1423     /* NOTE: It is possible that grids were re-allocated due to modifier
1424      * stack. Need to update those pointers. */
1425     if (BKE_pbvh_type(pbvh) == PBVH_GRIDS) {
1426       Object *object_eval = DEG_get_evaluated_object(depsgraph, ob);
1427       Mesh *mesh_eval = object_eval->data;
1428       SubdivCCG *subdiv_ccg = mesh_eval->runtime.subdiv_ccg;
1429       if (subdiv_ccg != NULL) {
1430         BKE_sculpt_bvh_update_from_ccg(pbvh, subdiv_ccg);
1431       }
1432     }
1433     return pbvh;
1434   }
1435
1436   if (ob->sculpt->bm != NULL) {
1437     /* Sculpting on a BMesh (dynamic-topology) gets a special PBVH. */
1438     pbvh = build_pbvh_for_dynamic_topology(ob);
1439   }
1440   else {
1441     Object *object_eval = DEG_get_evaluated_object(depsgraph, ob);
1442     Mesh *mesh_eval = object_eval->data;
1443     if (mesh_eval->runtime.subdiv_ccg != NULL) {
1444       pbvh = build_pbvh_from_ccg(ob, mesh_eval->runtime.subdiv_ccg);
1445     }
1446     else if (ob->type == OB_MESH) {
1447       Mesh *me_eval_deform = mesh_get_eval_deform(
1448           depsgraph, DEG_get_evaluated_scene(depsgraph), object_eval, &CD_MASK_BAREMESH);
1449       pbvh = build_pbvh_from_regular_mesh(ob, me_eval_deform);
1450     }
1451   }
1452
1453   ob->sculpt->pbvh = pbvh;
1454   return pbvh;
1455 }
1456
1457 void BKE_sculpt_bvh_update_from_ccg(PBVH *pbvh, SubdivCCG *subdiv_ccg)
1458 {
1459   BKE_pbvh_grids_update(pbvh,
1460                         subdiv_ccg->grids,
1461                         (void **)subdiv_ccg->grid_faces,
1462                         subdiv_ccg->grid_flag_mats,
1463                         subdiv_ccg->grid_hidden);
1464 }