CMake: add WITH_LINKER_LLD option for unix platforms
[blender-staging.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_brush_types.h"
30 #include "DNA_gpencil_types.h"
31 #include "DNA_mesh_types.h"
32 #include "DNA_meshdata_types.h"
33 #include "DNA_modifier_types.h"
34 #include "DNA_object_types.h"
35 #include "DNA_scene_types.h"
36 #include "DNA_space_types.h"
37 #include "DNA_view3d_types.h"
38 #include "DNA_workspace_types.h"
39
40 #include "BLI_bitmap.h"
41 #include "BLI_listbase.h"
42 #include "BLI_math_vector.h"
43 #include "BLI_utildefines.h"
44
45 #include "BLT_translation.h"
46
47 #include "BKE_brush.h"
48 #include "BKE_ccg.h"
49 #include "BKE_colortools.h"
50 #include "BKE_context.h"
51 #include "BKE_crazyspace.h"
52 #include "BKE_deform.h"
53 #include "BKE_gpencil.h"
54 #include "BKE_idtype.h"
55 #include "BKE_image.h"
56 #include "BKE_key.h"
57 #include "BKE_lib_id.h"
58 #include "BKE_main.h"
59 #include "BKE_mesh.h"
60 #include "BKE_mesh_mapping.h"
61 #include "BKE_mesh_runtime.h"
62 #include "BKE_modifier.h"
63 #include "BKE_multires.h"
64 #include "BKE_object.h"
65 #include "BKE_paint.h"
66 #include "BKE_pbvh.h"
67 #include "BKE_subdiv_ccg.h"
68 #include "BKE_subsurf.h"
69
70 #include "DEG_depsgraph.h"
71 #include "DEG_depsgraph_query.h"
72
73 #include "RNA_enum_types.h"
74
75 #include "bmesh.h"
76
77 static void palette_init_data(ID *id)
78 {
79   Palette *palette = (Palette *)id;
80
81   BLI_assert(MEMCMP_STRUCT_AFTER_IS_ZERO(palette, id));
82
83   /* Enable fake user by default. */
84   id_fake_user_set(&palette->id);
85 }
86
87 static void palette_copy_data(Main *UNUSED(bmain),
88                               ID *id_dst,
89                               const ID *id_src,
90                               const int UNUSED(flag))
91 {
92   Palette *palette_dst = (Palette *)id_dst;
93   const Palette *palette_src = (const Palette *)id_src;
94
95   BLI_duplicatelist(&palette_dst->colors, &palette_src->colors);
96 }
97
98 static void palette_free_data(ID *id)
99 {
100   Palette *palette = (Palette *)id;
101
102   BLI_freelistN(&palette->colors);
103 }
104
105 IDTypeInfo IDType_ID_PAL = {
106     .id_code = ID_PAL,
107     .id_filter = FILTER_ID_PAL,
108     .main_listbase_index = INDEX_ID_PAL,
109     .struct_size = sizeof(Palette),
110     .name = "Palette",
111     .name_plural = "palettes",
112     .translation_context = BLT_I18NCONTEXT_ID_PALETTE,
113     .flags = 0,
114
115     .init_data = palette_init_data,
116     .copy_data = palette_copy_data,
117     .free_data = palette_free_data,
118     .make_local = NULL,
119 };
120
121 static void paint_curve_copy_data(Main *UNUSED(bmain),
122                                   ID *id_dst,
123                                   const ID *id_src,
124                                   const int UNUSED(flag))
125 {
126   PaintCurve *paint_curve_dst = (PaintCurve *)id_dst;
127   const PaintCurve *paint_curve_src = (const PaintCurve *)id_src;
128
129   if (paint_curve_src->tot_points != 0) {
130     paint_curve_dst->points = MEM_dupallocN(paint_curve_src->points);
131   }
132 }
133
134 static void paint_curve_free_data(ID *id)
135 {
136   PaintCurve *paint_curve = (PaintCurve *)id;
137
138   MEM_SAFE_FREE(paint_curve->points);
139   paint_curve->tot_points = 0;
140 }
141
142 IDTypeInfo IDType_ID_PC = {
143     .id_code = ID_PC,
144     .id_filter = FILTER_ID_PC,
145     .main_listbase_index = INDEX_ID_PC,
146     .struct_size = sizeof(PaintCurve),
147     .name = "PaintCurve",
148     .name_plural = "paint_curves",
149     .translation_context = BLT_I18NCONTEXT_ID_PAINTCURVE,
150     .flags = 0,
151
152     .init_data = NULL,
153     .copy_data = paint_curve_copy_data,
154     .free_data = paint_curve_free_data,
155     .make_local = NULL,
156 };
157
158 const char PAINT_CURSOR_SCULPT[3] = {255, 100, 100};
159 const char PAINT_CURSOR_VERTEX_PAINT[3] = {255, 255, 255};
160 const char PAINT_CURSOR_WEIGHT_PAINT[3] = {200, 200, 255};
161 const char PAINT_CURSOR_TEXTURE_PAINT[3] = {255, 255, 255};
162
163 static ePaintOverlayControlFlags overlay_flags = 0;
164
165 void BKE_paint_invalidate_overlay_tex(Scene *scene, ViewLayer *view_layer, const Tex *tex)
166 {
167   Paint *p = BKE_paint_get_active(scene, view_layer);
168   if (!p) {
169     return;
170   }
171
172   Brush *br = p->brush;
173   if (!br) {
174     return;
175   }
176
177   if (br->mtex.tex == tex) {
178     overlay_flags |= PAINT_OVERLAY_INVALID_TEXTURE_PRIMARY;
179   }
180   if (br->mask_mtex.tex == tex) {
181     overlay_flags |= PAINT_OVERLAY_INVALID_TEXTURE_SECONDARY;
182   }
183 }
184
185 void BKE_paint_invalidate_cursor_overlay(Scene *scene, ViewLayer *view_layer, CurveMapping *curve)
186 {
187   Paint *p = BKE_paint_get_active(scene, view_layer);
188   if (p == NULL) {
189     return;
190   }
191
192   Brush *br = p->brush;
193   if (br && br->curve == curve) {
194     overlay_flags |= PAINT_OVERLAY_INVALID_CURVE;
195   }
196 }
197
198 void BKE_paint_invalidate_overlay_all(void)
199 {
200   overlay_flags |= (PAINT_OVERLAY_INVALID_TEXTURE_SECONDARY |
201                     PAINT_OVERLAY_INVALID_TEXTURE_PRIMARY | PAINT_OVERLAY_INVALID_CURVE);
202 }
203
204 ePaintOverlayControlFlags BKE_paint_get_overlay_flags(void)
205 {
206   return overlay_flags;
207 }
208
209 void BKE_paint_set_overlay_override(eOverlayFlags flags)
210 {
211   if (flags & BRUSH_OVERLAY_OVERRIDE_MASK) {
212     if (flags & BRUSH_OVERLAY_CURSOR_OVERRIDE_ON_STROKE) {
213       overlay_flags |= PAINT_OVERLAY_OVERRIDE_CURSOR;
214     }
215     if (flags & BRUSH_OVERLAY_PRIMARY_OVERRIDE_ON_STROKE) {
216       overlay_flags |= PAINT_OVERLAY_OVERRIDE_PRIMARY;
217     }
218     if (flags & BRUSH_OVERLAY_SECONDARY_OVERRIDE_ON_STROKE) {
219       overlay_flags |= PAINT_OVERLAY_OVERRIDE_SECONDARY;
220     }
221   }
222   else {
223     overlay_flags &= ~(PAINT_OVERRIDE_MASK);
224   }
225 }
226
227 void BKE_paint_reset_overlay_invalid(ePaintOverlayControlFlags flag)
228 {
229   overlay_flags &= ~(flag);
230 }
231
232 bool BKE_paint_ensure_from_paintmode(Scene *sce, ePaintMode mode)
233 {
234   ToolSettings *ts = sce->toolsettings;
235   Paint **paint_ptr = NULL;
236   /* Some paint modes don't store paint settings as pointer, for these this can be set and
237    * referenced by paint_ptr. */
238   Paint *paint_tmp = NULL;
239
240   switch (mode) {
241     case PAINT_MODE_SCULPT:
242       paint_ptr = (Paint **)&ts->sculpt;
243       break;
244     case PAINT_MODE_VERTEX:
245       paint_ptr = (Paint **)&ts->vpaint;
246       break;
247     case PAINT_MODE_WEIGHT:
248       paint_ptr = (Paint **)&ts->wpaint;
249       break;
250     case PAINT_MODE_TEXTURE_2D:
251     case PAINT_MODE_TEXTURE_3D:
252       paint_tmp = (Paint *)&ts->imapaint;
253       paint_ptr = &paint_tmp;
254       break;
255     case PAINT_MODE_SCULPT_UV:
256       paint_ptr = (Paint **)&ts->uvsculpt;
257       break;
258     case PAINT_MODE_GPENCIL:
259       paint_ptr = (Paint **)&ts->gp_paint;
260       break;
261     case PAINT_MODE_VERTEX_GPENCIL:
262       paint_ptr = (Paint **)&ts->gp_vertexpaint;
263       break;
264     case PAINT_MODE_SCULPT_GPENCIL:
265       paint_ptr = (Paint **)&ts->gp_sculptpaint;
266       break;
267     case PAINT_MODE_WEIGHT_GPENCIL:
268       paint_ptr = (Paint **)&ts->gp_weightpaint;
269       break;
270     case PAINT_MODE_INVALID:
271       break;
272   }
273   if (paint_ptr) {
274     BKE_paint_ensure(ts, paint_ptr);
275     return true;
276   }
277   return false;
278 }
279
280 Paint *BKE_paint_get_active_from_paintmode(Scene *sce, ePaintMode mode)
281 {
282   if (sce) {
283     ToolSettings *ts = sce->toolsettings;
284
285     switch (mode) {
286       case PAINT_MODE_SCULPT:
287         return &ts->sculpt->paint;
288       case PAINT_MODE_VERTEX:
289         return &ts->vpaint->paint;
290       case PAINT_MODE_WEIGHT:
291         return &ts->wpaint->paint;
292       case PAINT_MODE_TEXTURE_2D:
293       case PAINT_MODE_TEXTURE_3D:
294         return &ts->imapaint.paint;
295       case PAINT_MODE_SCULPT_UV:
296         return &ts->uvsculpt->paint;
297       case PAINT_MODE_GPENCIL:
298         return &ts->gp_paint->paint;
299       case PAINT_MODE_VERTEX_GPENCIL:
300         return &ts->gp_vertexpaint->paint;
301       case PAINT_MODE_SCULPT_GPENCIL:
302         return &ts->gp_sculptpaint->paint;
303       case PAINT_MODE_WEIGHT_GPENCIL:
304         return &ts->gp_weightpaint->paint;
305       case PAINT_MODE_INVALID:
306         return NULL;
307       default:
308         return &ts->imapaint.paint;
309     }
310   }
311
312   return NULL;
313 }
314
315 const EnumPropertyItem *BKE_paint_get_tool_enum_from_paintmode(ePaintMode mode)
316 {
317   switch (mode) {
318     case PAINT_MODE_SCULPT:
319       return rna_enum_brush_sculpt_tool_items;
320     case PAINT_MODE_VERTEX:
321       return rna_enum_brush_vertex_tool_items;
322     case PAINT_MODE_WEIGHT:
323       return rna_enum_brush_weight_tool_items;
324     case PAINT_MODE_TEXTURE_2D:
325     case PAINT_MODE_TEXTURE_3D:
326       return rna_enum_brush_image_tool_items;
327     case PAINT_MODE_SCULPT_UV:
328       return rna_enum_brush_uv_sculpt_tool_items;
329     case PAINT_MODE_GPENCIL:
330       return rna_enum_brush_gpencil_types_items;
331     case PAINT_MODE_VERTEX_GPENCIL:
332       return rna_enum_brush_gpencil_vertex_types_items;
333     case PAINT_MODE_SCULPT_GPENCIL:
334       return rna_enum_brush_gpencil_sculpt_types_items;
335     case PAINT_MODE_WEIGHT_GPENCIL:
336       return rna_enum_brush_gpencil_weight_types_items;
337     case PAINT_MODE_INVALID:
338       break;
339   }
340   return NULL;
341 }
342
343 const char *BKE_paint_get_tool_prop_id_from_paintmode(ePaintMode mode)
344 {
345   switch (mode) {
346     case PAINT_MODE_SCULPT:
347       return "sculpt_tool";
348     case PAINT_MODE_VERTEX:
349       return "vertex_tool";
350     case PAINT_MODE_WEIGHT:
351       return "weight_tool";
352     case PAINT_MODE_TEXTURE_2D:
353     case PAINT_MODE_TEXTURE_3D:
354       return "image_tool";
355     case PAINT_MODE_SCULPT_UV:
356       return "uv_sculpt_tool";
357     case PAINT_MODE_GPENCIL:
358       return "gpencil_tool";
359     case PAINT_MODE_VERTEX_GPENCIL:
360       return "gpencil_vertex_tool";
361     case PAINT_MODE_SCULPT_GPENCIL:
362       return "gpencil_sculpt_tool";
363     case PAINT_MODE_WEIGHT_GPENCIL:
364       return "gpencil_weight_tool";
365     default:
366       /* invalid paint mode */
367       return NULL;
368   }
369 }
370
371 Paint *BKE_paint_get_active(Scene *sce, ViewLayer *view_layer)
372 {
373   if (sce && view_layer) {
374     ToolSettings *ts = sce->toolsettings;
375
376     if (view_layer->basact && view_layer->basact->object) {
377       switch (view_layer->basact->object->mode) {
378         case OB_MODE_SCULPT:
379           return &ts->sculpt->paint;
380         case OB_MODE_VERTEX_PAINT:
381           return &ts->vpaint->paint;
382         case OB_MODE_WEIGHT_PAINT:
383           return &ts->wpaint->paint;
384         case OB_MODE_TEXTURE_PAINT:
385           return &ts->imapaint.paint;
386         case OB_MODE_PAINT_GPENCIL:
387           return &ts->gp_paint->paint;
388         case OB_MODE_VERTEX_GPENCIL:
389           return &ts->gp_vertexpaint->paint;
390         case OB_MODE_SCULPT_GPENCIL:
391           return &ts->gp_sculptpaint->paint;
392         case OB_MODE_WEIGHT_GPENCIL:
393           return &ts->gp_weightpaint->paint;
394         case OB_MODE_EDIT:
395           return &ts->uvsculpt->paint;
396         default:
397           break;
398       }
399     }
400
401     /* default to image paint */
402     return &ts->imapaint.paint;
403   }
404
405   return NULL;
406 }
407
408 Paint *BKE_paint_get_active_from_context(const bContext *C)
409 {
410   Scene *sce = CTX_data_scene(C);
411   ViewLayer *view_layer = CTX_data_view_layer(C);
412   SpaceImage *sima;
413
414   if (sce && view_layer) {
415     ToolSettings *ts = sce->toolsettings;
416     Object *obact = NULL;
417
418     if (view_layer->basact && view_layer->basact->object) {
419       obact = view_layer->basact->object;
420     }
421
422     if ((sima = CTX_wm_space_image(C)) != NULL) {
423       if (obact && obact->mode == OB_MODE_EDIT) {
424         if (sima->mode == SI_MODE_PAINT) {
425           return &ts->imapaint.paint;
426         }
427         else if (sima->mode == SI_MODE_UV) {
428           return &ts->uvsculpt->paint;
429         }
430       }
431       else {
432         return &ts->imapaint.paint;
433       }
434     }
435     else {
436       return BKE_paint_get_active(sce, view_layer);
437     }
438   }
439
440   return NULL;
441 }
442
443 ePaintMode BKE_paintmode_get_active_from_context(const bContext *C)
444 {
445   Scene *sce = CTX_data_scene(C);
446   ViewLayer *view_layer = CTX_data_view_layer(C);
447   SpaceImage *sima;
448
449   if (sce && view_layer) {
450     Object *obact = NULL;
451
452     if (view_layer->basact && view_layer->basact->object) {
453       obact = view_layer->basact->object;
454     }
455
456     if ((sima = CTX_wm_space_image(C)) != NULL) {
457       if (obact && obact->mode == OB_MODE_EDIT) {
458         if (sima->mode == SI_MODE_PAINT) {
459           return PAINT_MODE_TEXTURE_2D;
460         }
461         else if (sima->mode == SI_MODE_UV) {
462           return PAINT_MODE_SCULPT_UV;
463         }
464       }
465       else {
466         return PAINT_MODE_TEXTURE_2D;
467       }
468     }
469     else if (obact) {
470       switch (obact->mode) {
471         case OB_MODE_SCULPT:
472           return PAINT_MODE_SCULPT;
473         case OB_MODE_VERTEX_PAINT:
474           return PAINT_MODE_VERTEX;
475         case OB_MODE_WEIGHT_PAINT:
476           return PAINT_MODE_WEIGHT;
477         case OB_MODE_TEXTURE_PAINT:
478           return PAINT_MODE_TEXTURE_3D;
479         case OB_MODE_EDIT:
480           return PAINT_MODE_SCULPT_UV;
481         default:
482           return PAINT_MODE_TEXTURE_2D;
483       }
484     }
485     else {
486       /* default to image paint */
487       return PAINT_MODE_TEXTURE_2D;
488     }
489   }
490
491   return PAINT_MODE_INVALID;
492 }
493
494 ePaintMode BKE_paintmode_get_from_tool(const struct bToolRef *tref)
495 {
496   if (tref->space_type == SPACE_VIEW3D) {
497     switch (tref->mode) {
498       case CTX_MODE_SCULPT:
499         return PAINT_MODE_SCULPT;
500       case CTX_MODE_PAINT_VERTEX:
501         return PAINT_MODE_VERTEX;
502       case CTX_MODE_PAINT_WEIGHT:
503         return PAINT_MODE_WEIGHT;
504       case CTX_MODE_PAINT_GPENCIL:
505         return PAINT_MODE_GPENCIL;
506       case CTX_MODE_PAINT_TEXTURE:
507         return PAINT_MODE_TEXTURE_3D;
508       case CTX_MODE_VERTEX_GPENCIL:
509         return PAINT_MODE_VERTEX_GPENCIL;
510       case CTX_MODE_SCULPT_GPENCIL:
511         return PAINT_MODE_SCULPT_GPENCIL;
512       case CTX_MODE_WEIGHT_GPENCIL:
513         return PAINT_MODE_WEIGHT_GPENCIL;
514     }
515   }
516   else if (tref->space_type == SPACE_IMAGE) {
517     switch (tref->mode) {
518       case SI_MODE_PAINT:
519         return PAINT_MODE_TEXTURE_2D;
520       case SI_MODE_UV:
521         return PAINT_MODE_SCULPT_UV;
522     }
523   }
524
525   return PAINT_MODE_INVALID;
526 }
527
528 Brush *BKE_paint_brush(Paint *p)
529 {
530   return p ? p->brush : NULL;
531 }
532
533 void BKE_paint_brush_set(Paint *p, Brush *br)
534 {
535   if (p) {
536     id_us_min((ID *)p->brush);
537     id_us_plus((ID *)br);
538     p->brush = br;
539
540     BKE_paint_toolslots_brush_update(p);
541   }
542 }
543
544 void BKE_paint_runtime_init(const ToolSettings *ts, Paint *paint)
545 {
546   if (paint == &ts->imapaint.paint) {
547     paint->runtime.tool_offset = offsetof(Brush, imagepaint_tool);
548     paint->runtime.ob_mode = OB_MODE_TEXTURE_PAINT;
549   }
550   else if (paint == &ts->sculpt->paint) {
551     paint->runtime.tool_offset = offsetof(Brush, sculpt_tool);
552     paint->runtime.ob_mode = OB_MODE_SCULPT;
553   }
554   else if (paint == &ts->vpaint->paint) {
555     paint->runtime.tool_offset = offsetof(Brush, vertexpaint_tool);
556     paint->runtime.ob_mode = OB_MODE_VERTEX_PAINT;
557   }
558   else if (paint == &ts->wpaint->paint) {
559     paint->runtime.tool_offset = offsetof(Brush, weightpaint_tool);
560     paint->runtime.ob_mode = OB_MODE_WEIGHT_PAINT;
561   }
562   else if (paint == &ts->uvsculpt->paint) {
563     paint->runtime.tool_offset = offsetof(Brush, uv_sculpt_tool);
564     paint->runtime.ob_mode = OB_MODE_EDIT;
565   }
566   else if (paint == &ts->gp_paint->paint) {
567     paint->runtime.tool_offset = offsetof(Brush, gpencil_tool);
568     paint->runtime.ob_mode = OB_MODE_PAINT_GPENCIL;
569   }
570   else if (paint == &ts->gp_vertexpaint->paint) {
571     paint->runtime.tool_offset = offsetof(Brush, gpencil_vertex_tool);
572     paint->runtime.ob_mode = OB_MODE_VERTEX_GPENCIL;
573   }
574   else if (paint == &ts->gp_sculptpaint->paint) {
575     paint->runtime.tool_offset = offsetof(Brush, gpencil_sculpt_tool);
576     paint->runtime.ob_mode = OB_MODE_SCULPT_GPENCIL;
577   }
578   else if (paint == &ts->gp_weightpaint->paint) {
579     paint->runtime.tool_offset = offsetof(Brush, gpencil_weight_tool);
580     paint->runtime.ob_mode = OB_MODE_WEIGHT_GPENCIL;
581   }
582   else {
583     BLI_assert(0);
584   }
585 }
586
587 uint BKE_paint_get_brush_tool_offset_from_paintmode(const ePaintMode mode)
588 {
589   switch (mode) {
590     case PAINT_MODE_TEXTURE_2D:
591     case PAINT_MODE_TEXTURE_3D:
592       return offsetof(Brush, imagepaint_tool);
593     case PAINT_MODE_SCULPT:
594       return offsetof(Brush, sculpt_tool);
595     case PAINT_MODE_VERTEX:
596       return offsetof(Brush, vertexpaint_tool);
597     case PAINT_MODE_WEIGHT:
598       return offsetof(Brush, weightpaint_tool);
599     case PAINT_MODE_SCULPT_UV:
600       return offsetof(Brush, uv_sculpt_tool);
601     case PAINT_MODE_GPENCIL:
602       return offsetof(Brush, gpencil_tool);
603     case PAINT_MODE_VERTEX_GPENCIL:
604       return offsetof(Brush, gpencil_vertex_tool);
605     case PAINT_MODE_SCULPT_GPENCIL:
606       return offsetof(Brush, gpencil_sculpt_tool);
607     case PAINT_MODE_WEIGHT_GPENCIL:
608       return offsetof(Brush, gpencil_weight_tool);
609     case PAINT_MODE_INVALID:
610       break; /* We don't use these yet. */
611   }
612   return 0;
613 }
614
615 PaintCurve *BKE_paint_curve_add(Main *bmain, const char *name)
616 {
617   PaintCurve *pc;
618
619   pc = BKE_libblock_alloc(bmain, ID_PC, name, 0);
620
621   return pc;
622 }
623
624 PaintCurve *BKE_paint_curve_copy(Main *bmain, const PaintCurve *pc)
625 {
626   PaintCurve *pc_copy;
627   BKE_id_copy(bmain, &pc->id, (ID **)&pc_copy);
628   return pc_copy;
629 }
630
631 Palette *BKE_paint_palette(Paint *p)
632 {
633   return p ? p->palette : NULL;
634 }
635
636 void BKE_paint_palette_set(Paint *p, Palette *palette)
637 {
638   if (p) {
639     id_us_min((ID *)p->palette);
640     p->palette = palette;
641     id_us_plus((ID *)p->palette);
642   }
643 }
644
645 void BKE_paint_curve_set(Brush *br, PaintCurve *pc)
646 {
647   if (br) {
648     id_us_min((ID *)br->paint_curve);
649     br->paint_curve = pc;
650     id_us_plus((ID *)br->paint_curve);
651   }
652 }
653
654 void BKE_paint_curve_clamp_endpoint_add_index(PaintCurve *pc, const int add_index)
655 {
656   pc->add_index = (add_index || pc->tot_points == 1) ? (add_index + 1) : 0;
657 }
658
659 /** Remove color from palette. Must be certain color is inside the palette! */
660 void BKE_palette_color_remove(Palette *palette, PaletteColor *color)
661 {
662   if (BLI_listbase_count_at_most(&palette->colors, palette->active_color) ==
663       palette->active_color) {
664     palette->active_color--;
665   }
666
667   BLI_remlink(&palette->colors, color);
668
669   if (palette->active_color < 0 && !BLI_listbase_is_empty(&palette->colors)) {
670     palette->active_color = 0;
671   }
672
673   MEM_freeN(color);
674 }
675
676 void BKE_palette_clear(Palette *palette)
677 {
678   BLI_freelistN(&palette->colors);
679   palette->active_color = 0;
680 }
681
682 Palette *BKE_palette_add(Main *bmain, const char *name)
683 {
684   Palette *palette = BKE_id_new(bmain, ID_PAL, name);
685   return palette;
686 }
687
688 Palette *BKE_palette_copy(Main *bmain, const Palette *palette)
689 {
690   Palette *palette_copy;
691   BKE_id_copy(bmain, &palette->id, (ID **)&palette_copy);
692   return palette_copy;
693 }
694
695 PaletteColor *BKE_palette_color_add(Palette *palette)
696 {
697   PaletteColor *color = MEM_callocN(sizeof(*color), "Palette Color");
698   BLI_addtail(&palette->colors, color);
699   return color;
700 }
701
702 bool BKE_palette_is_empty(const struct Palette *palette)
703 {
704   return BLI_listbase_is_empty(&palette->colors);
705 }
706
707 /* helper function to sort using qsort */
708 static int palettecolor_compare_hsv(const void *a1, const void *a2)
709 {
710   const tPaletteColorHSV *ps1 = a1, *ps2 = a2;
711
712   /* Hue */
713   if (ps1->h > ps2->h) {
714     return 1;
715   }
716   else if (ps1->h < ps2->h) {
717     return -1;
718   }
719
720   /* Saturation. */
721   if (ps1->s > ps2->s) {
722     return 1;
723   }
724   else if (ps1->s < ps2->s) {
725     return -1;
726   }
727
728   /* Value. */
729   if (1.0f - ps1->v > 1.0f - ps2->v) {
730     return 1;
731   }
732   else if (1.0f - ps1->v < 1.0f - ps2->v) {
733     return -1;
734   }
735
736   return 0;
737 }
738
739 /* helper function to sort using qsort */
740 static int palettecolor_compare_svh(const void *a1, const void *a2)
741 {
742   const tPaletteColorHSV *ps1 = a1, *ps2 = a2;
743
744   /* Saturation. */
745   if (ps1->s > ps2->s) {
746     return 1;
747   }
748   else if (ps1->s < ps2->s) {
749     return -1;
750   }
751
752   /* Value. */
753   if (1.0f - ps1->v > 1.0f - ps2->v) {
754     return 1;
755   }
756   else if (1.0f - ps1->v < 1.0f - ps2->v) {
757     return -1;
758   }
759
760   /* Hue */
761   if (ps1->h > ps2->h) {
762     return 1;
763   }
764   else if (ps1->h < ps2->h) {
765     return -1;
766   }
767
768   return 0;
769 }
770
771 static int palettecolor_compare_vhs(const void *a1, const void *a2)
772 {
773   const tPaletteColorHSV *ps1 = a1, *ps2 = a2;
774
775   /* Value. */
776   if (1.0f - ps1->v > 1.0f - ps2->v) {
777     return 1;
778   }
779   else if (1.0f - ps1->v < 1.0f - ps2->v) {
780     return -1;
781   }
782
783   /* Hue */
784   if (ps1->h > ps2->h) {
785     return 1;
786   }
787   else if (ps1->h < ps2->h) {
788     return -1;
789   }
790
791   /* Saturation. */
792   if (ps1->s > ps2->s) {
793     return 1;
794   }
795   else if (ps1->s < ps2->s) {
796     return -1;
797   }
798
799   return 0;
800 }
801
802 static int palettecolor_compare_luminance(const void *a1, const void *a2)
803 {
804   const tPaletteColorHSV *ps1 = a1, *ps2 = a2;
805
806   float lumi1 = (ps1->rgb[0] + ps1->rgb[1] + ps1->rgb[2]) / 3.0f;
807   float lumi2 = (ps2->rgb[0] + ps2->rgb[1] + ps2->rgb[2]) / 3.0f;
808
809   if (lumi1 > lumi2) {
810     return -1;
811   }
812   else if (lumi1 < lumi2) {
813     return 1;
814   }
815
816   return 0;
817 }
818
819 void BKE_palette_sort_hsv(tPaletteColorHSV *color_array, const int totcol)
820 {
821   /* Sort by Hue , Saturation and Value. */
822   qsort(color_array, totcol, sizeof(tPaletteColorHSV), palettecolor_compare_hsv);
823 }
824
825 void BKE_palette_sort_svh(tPaletteColorHSV *color_array, const int totcol)
826 {
827   /* Sort by Saturation, Value and Hue. */
828   qsort(color_array, totcol, sizeof(tPaletteColorHSV), palettecolor_compare_svh);
829 }
830
831 void BKE_palette_sort_vhs(tPaletteColorHSV *color_array, const int totcol)
832 {
833   /* Sort by Saturation, Value and Hue. */
834   qsort(color_array, totcol, sizeof(tPaletteColorHSV), palettecolor_compare_vhs);
835 }
836
837 void BKE_palette_sort_luminance(tPaletteColorHSV *color_array, const int totcol)
838 {
839   /* Sort by Luminance (calculated with the average, enough for sorting). */
840   qsort(color_array, totcol, sizeof(tPaletteColorHSV), palettecolor_compare_luminance);
841 }
842
843 bool BKE_palette_from_hash(Main *bmain, GHash *color_table, const char *name, const bool linear)
844 {
845   tPaletteColorHSV *color_array = NULL;
846   tPaletteColorHSV *col_elm = NULL;
847   bool done = false;
848
849   const int totpal = BLI_ghash_len(color_table);
850
851   if (totpal > 0) {
852     color_array = MEM_calloc_arrayN(totpal, sizeof(tPaletteColorHSV), __func__);
853     /* Put all colors in an array. */
854     GHashIterator gh_iter;
855     int t = 0;
856     GHASH_ITER (gh_iter, color_table) {
857       const uint col = POINTER_AS_INT(BLI_ghashIterator_getValue(&gh_iter));
858       float r, g, b;
859       float h, s, v;
860       cpack_to_rgb(col, &r, &g, &b);
861       rgb_to_hsv(r, g, b, &h, &s, &v);
862
863       col_elm = &color_array[t];
864       col_elm->rgb[0] = r;
865       col_elm->rgb[1] = g;
866       col_elm->rgb[2] = b;
867       col_elm->h = h;
868       col_elm->s = s;
869       col_elm->v = v;
870       t++;
871     }
872   }
873
874   /* Create the Palette. */
875   if (totpal > 0) {
876     /* Sort by Hue and saturation. */
877     BKE_palette_sort_hsv(color_array, totpal);
878
879     Palette *palette = BKE_palette_add(bmain, name);
880     if (palette) {
881       for (int i = 0; i < totpal; i++) {
882         col_elm = &color_array[i];
883         PaletteColor *palcol = BKE_palette_color_add(palette);
884         if (palcol) {
885           copy_v3_v3(palcol->rgb, col_elm->rgb);
886           if (linear) {
887             linearrgb_to_srgb_v3_v3(palcol->rgb, palcol->rgb);
888           }
889         }
890       }
891       done = true;
892     }
893   }
894   else {
895     done = false;
896   }
897
898   if (totpal > 0) {
899     MEM_SAFE_FREE(color_array);
900   }
901
902   return done;
903 }
904
905 /* are we in vertex paint or weight paint face select mode? */
906 bool BKE_paint_select_face_test(Object *ob)
907 {
908   return ((ob != NULL) && (ob->type == OB_MESH) && (ob->data != NULL) &&
909           (((Mesh *)ob->data)->editflag & ME_EDIT_PAINT_FACE_SEL) &&
910           (ob->mode & (OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT | OB_MODE_TEXTURE_PAINT)));
911 }
912
913 /* are we in weight paint vertex select mode? */
914 bool BKE_paint_select_vert_test(Object *ob)
915 {
916   return ((ob != NULL) && (ob->type == OB_MESH) && (ob->data != NULL) &&
917           (((Mesh *)ob->data)->editflag & ME_EDIT_PAINT_VERT_SEL) &&
918           (ob->mode & OB_MODE_WEIGHT_PAINT || ob->mode & OB_MODE_VERTEX_PAINT));
919 }
920
921 /**
922  * used to check if selection is possible
923  * (when we don't care if its face or vert)
924  */
925 bool BKE_paint_select_elem_test(Object *ob)
926 {
927   return (BKE_paint_select_vert_test(ob) || BKE_paint_select_face_test(ob));
928 }
929
930 void BKE_paint_cavity_curve_preset(Paint *p, int preset)
931 {
932   CurveMapping *cumap = NULL;
933   CurveMap *cuma = NULL;
934
935   if (!p->cavity_curve) {
936     p->cavity_curve = BKE_curvemapping_add(1, 0, 0, 1, 1);
937   }
938   cumap = p->cavity_curve;
939   cumap->flag &= ~CUMA_EXTEND_EXTRAPOLATE;
940   cumap->preset = preset;
941
942   cuma = cumap->cm;
943   BKE_curvemap_reset(cuma, &cumap->clipr, cumap->preset, CURVEMAP_SLOPE_POSITIVE);
944   BKE_curvemapping_changed(cumap, false);
945 }
946
947 eObjectMode BKE_paint_object_mode_from_paintmode(ePaintMode mode)
948 {
949   switch (mode) {
950     case PAINT_MODE_SCULPT:
951       return OB_MODE_SCULPT;
952     case PAINT_MODE_VERTEX:
953       return OB_MODE_VERTEX_PAINT;
954     case PAINT_MODE_WEIGHT:
955       return OB_MODE_WEIGHT_PAINT;
956     case PAINT_MODE_TEXTURE_2D:
957     case PAINT_MODE_TEXTURE_3D:
958       return OB_MODE_TEXTURE_PAINT;
959     case PAINT_MODE_SCULPT_UV:
960       return OB_MODE_EDIT;
961     case PAINT_MODE_INVALID:
962     default:
963       return 0;
964   }
965 }
966
967 /**
968  * Call when entering each respective paint mode.
969  */
970 bool BKE_paint_ensure(ToolSettings *ts, struct Paint **r_paint)
971 {
972   Paint *paint = NULL;
973   if (*r_paint) {
974     /* Tool offset should never be 0 for initialized paint settings, so it's a reliable way to
975      * check if already initialized. */
976     if ((*r_paint)->runtime.tool_offset == 0) {
977       /* Currently only image painting is initialized this way, others have to be allocated. */
978       BLI_assert(ELEM(*r_paint, (Paint *)&ts->imapaint));
979
980       BKE_paint_runtime_init(ts, *r_paint);
981     }
982     else {
983       BLI_assert(ELEM(*r_paint,
984                       /* Cast is annoying, but prevent NULL-pointer access. */
985                       (Paint *)ts->gp_paint,
986                       (Paint *)ts->gp_vertexpaint,
987                       (Paint *)ts->gp_sculptpaint,
988                       (Paint *)ts->gp_weightpaint,
989                       (Paint *)ts->sculpt,
990                       (Paint *)ts->vpaint,
991                       (Paint *)ts->wpaint,
992                       (Paint *)ts->uvsculpt,
993                       (Paint *)&ts->imapaint));
994 #ifdef DEBUG
995       struct Paint paint_test = **r_paint;
996       BKE_paint_runtime_init(ts, *r_paint);
997       /* Swap so debug doesn't hide errors when release fails. */
998       SWAP(Paint, **r_paint, paint_test);
999       BLI_assert(paint_test.runtime.ob_mode == (*r_paint)->runtime.ob_mode);
1000       BLI_assert(paint_test.runtime.tool_offset == (*r_paint)->runtime.tool_offset);
1001 #endif
1002     }
1003     return true;
1004   }
1005
1006   if (((VPaint **)r_paint == &ts->vpaint) || ((VPaint **)r_paint == &ts->wpaint)) {
1007     VPaint *data = MEM_callocN(sizeof(*data), __func__);
1008     paint = &data->paint;
1009   }
1010   else if ((Sculpt **)r_paint == &ts->sculpt) {
1011     Sculpt *data = MEM_callocN(sizeof(*data), __func__);
1012     paint = &data->paint;
1013
1014     /* Turn on X plane mirror symmetry by default */
1015     paint->symmetry_flags |= PAINT_SYMM_X;
1016
1017     /* Make sure at least dyntopo subdivision is enabled */
1018     data->flags |= SCULPT_DYNTOPO_SUBDIVIDE | SCULPT_DYNTOPO_COLLAPSE;
1019   }
1020   else if ((GpPaint **)r_paint == &ts->gp_paint) {
1021     GpPaint *data = MEM_callocN(sizeof(*data), __func__);
1022     paint = &data->paint;
1023   }
1024   else if ((GpVertexPaint **)r_paint == &ts->gp_vertexpaint) {
1025     GpVertexPaint *data = MEM_callocN(sizeof(*data), __func__);
1026     paint = &data->paint;
1027   }
1028   else if ((GpSculptPaint **)r_paint == &ts->gp_sculptpaint) {
1029     GpSculptPaint *data = MEM_callocN(sizeof(*data), __func__);
1030     paint = &data->paint;
1031   }
1032   else if ((GpWeightPaint **)r_paint == &ts->gp_weightpaint) {
1033     GpWeightPaint *data = MEM_callocN(sizeof(*data), __func__);
1034     paint = &data->paint;
1035   }
1036   else if ((UvSculpt **)r_paint == &ts->uvsculpt) {
1037     UvSculpt *data = MEM_callocN(sizeof(*data), __func__);
1038     paint = &data->paint;
1039   }
1040   else if (*r_paint == &ts->imapaint.paint) {
1041     paint = &ts->imapaint.paint;
1042   }
1043
1044   paint->flags |= PAINT_SHOW_BRUSH;
1045
1046   *r_paint = paint;
1047
1048   BKE_paint_runtime_init(ts, paint);
1049
1050   return false;
1051 }
1052
1053 void BKE_paint_init(Main *bmain, Scene *sce, ePaintMode mode, const char col[3])
1054 {
1055   UnifiedPaintSettings *ups = &sce->toolsettings->unified_paint_settings;
1056   Paint *paint = BKE_paint_get_active_from_paintmode(sce, mode);
1057
1058   BKE_paint_ensure_from_paintmode(sce, mode);
1059
1060   /* If there's no brush, create one */
1061   if (PAINT_MODE_HAS_BRUSH(mode)) {
1062     Brush *brush = BKE_paint_brush(paint);
1063     if (brush == NULL) {
1064       eObjectMode ob_mode = BKE_paint_object_mode_from_paintmode(mode);
1065       brush = BKE_brush_first_search(bmain, ob_mode);
1066       if (!brush) {
1067         brush = BKE_brush_add(bmain, "Brush", ob_mode);
1068         id_us_min(&brush->id); /* fake user only */
1069       }
1070       BKE_paint_brush_set(paint, brush);
1071     }
1072   }
1073
1074   memcpy(paint->paint_cursor_col, col, 3);
1075   paint->paint_cursor_col[3] = 128;
1076   ups->last_stroke_valid = false;
1077   zero_v3(ups->average_stroke_accum);
1078   ups->average_stroke_counter = 0;
1079   if (!paint->cavity_curve) {
1080     BKE_paint_cavity_curve_preset(paint, CURVE_PRESET_LINE);
1081   }
1082 }
1083
1084 void BKE_paint_free(Paint *paint)
1085 {
1086   BKE_curvemapping_free(paint->cavity_curve);
1087   MEM_SAFE_FREE(paint->tool_slots);
1088 }
1089
1090 /* called when copying scene settings, so even if 'src' and 'tar' are the same
1091  * still do a id_us_plus(), rather then if we were copying between 2 existing
1092  * scenes where a matching value should decrease the existing user count as
1093  * with paint_brush_set() */
1094 void BKE_paint_copy(Paint *src, Paint *tar, const int flag)
1095 {
1096   tar->brush = src->brush;
1097   tar->cavity_curve = BKE_curvemapping_copy(src->cavity_curve);
1098   tar->tool_slots = MEM_dupallocN(src->tool_slots);
1099
1100   if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
1101     id_us_plus((ID *)tar->brush);
1102     id_us_plus((ID *)tar->palette);
1103     if (src->tool_slots != NULL) {
1104       for (int i = 0; i < tar->tool_slots_len; i++) {
1105         id_us_plus((ID *)tar->tool_slots[i].brush);
1106       }
1107     }
1108   }
1109 }
1110
1111 void BKE_paint_stroke_get_average(Scene *scene, Object *ob, float stroke[3])
1112 {
1113   UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
1114   if (ups->last_stroke_valid && ups->average_stroke_counter > 0) {
1115     float fac = 1.0f / ups->average_stroke_counter;
1116     mul_v3_v3fl(stroke, ups->average_stroke_accum, fac);
1117   }
1118   else {
1119     copy_v3_v3(stroke, ob->obmat[3]);
1120   }
1121 }
1122
1123 /* returns non-zero if any of the face's vertices
1124  * are hidden, zero otherwise */
1125 bool paint_is_face_hidden(const MLoopTri *lt, const MVert *mvert, const MLoop *mloop)
1126 {
1127   return ((mvert[mloop[lt->tri[0]].v].flag & ME_HIDE) ||
1128           (mvert[mloop[lt->tri[1]].v].flag & ME_HIDE) ||
1129           (mvert[mloop[lt->tri[2]].v].flag & ME_HIDE));
1130 }
1131
1132 /* returns non-zero if any of the corners of the grid
1133  * face whose inner corner is at (x, y) are hidden,
1134  * zero otherwise */
1135 bool paint_is_grid_face_hidden(const uint *grid_hidden, int gridsize, int x, int y)
1136 {
1137   /* skip face if any of its corners are hidden */
1138   return (BLI_BITMAP_TEST(grid_hidden, y * gridsize + x) ||
1139           BLI_BITMAP_TEST(grid_hidden, y * gridsize + x + 1) ||
1140           BLI_BITMAP_TEST(grid_hidden, (y + 1) * gridsize + x + 1) ||
1141           BLI_BITMAP_TEST(grid_hidden, (y + 1) * gridsize + x));
1142 }
1143
1144 /* Return true if all vertices in the face are visible, false otherwise */
1145 bool paint_is_bmesh_face_hidden(BMFace *f)
1146 {
1147   BMLoop *l_iter;
1148   BMLoop *l_first;
1149
1150   l_iter = l_first = BM_FACE_FIRST_LOOP(f);
1151   do {
1152     if (BM_elem_flag_test(l_iter->v, BM_ELEM_HIDDEN)) {
1153       return true;
1154     }
1155   } while ((l_iter = l_iter->next) != l_first);
1156
1157   return false;
1158 }
1159
1160 float paint_grid_paint_mask(const GridPaintMask *gpm, uint level, uint x, uint y)
1161 {
1162   int factor = BKE_ccg_factor(level, gpm->level);
1163   int gridsize = BKE_ccg_gridsize(gpm->level);
1164
1165   return gpm->data[(y * factor) * gridsize + (x * factor)];
1166 }
1167
1168 /* threshold to move before updating the brush rotation */
1169 #define RAKE_THRESHHOLD 20
1170
1171 void paint_update_brush_rake_rotation(UnifiedPaintSettings *ups, Brush *brush, float rotation)
1172 {
1173   if (brush->mtex.brush_angle_mode & MTEX_ANGLE_RAKE) {
1174     ups->brush_rotation = rotation;
1175   }
1176   else {
1177     ups->brush_rotation = 0.0f;
1178   }
1179
1180   if (brush->mask_mtex.brush_angle_mode & MTEX_ANGLE_RAKE) {
1181     ups->brush_rotation_sec = rotation;
1182   }
1183   else {
1184     ups->brush_rotation_sec = 0.0f;
1185   }
1186 }
1187
1188 bool paint_calculate_rake_rotation(UnifiedPaintSettings *ups,
1189                                    Brush *brush,
1190                                    const float mouse_pos[2])
1191 {
1192   bool ok = false;
1193   if ((brush->mtex.brush_angle_mode & MTEX_ANGLE_RAKE) ||
1194       (brush->mask_mtex.brush_angle_mode & MTEX_ANGLE_RAKE)) {
1195     const float r = RAKE_THRESHHOLD;
1196     float rotation;
1197
1198     float dpos[2];
1199     sub_v2_v2v2(dpos, ups->last_rake, mouse_pos);
1200
1201     if (len_squared_v2(dpos) >= r * r) {
1202       rotation = atan2f(dpos[0], dpos[1]);
1203
1204       copy_v2_v2(ups->last_rake, mouse_pos);
1205
1206       ups->last_rake_angle = rotation;
1207
1208       paint_update_brush_rake_rotation(ups, brush, rotation);
1209       ok = true;
1210     }
1211     /* make sure we reset here to the last rotation to avoid accumulating
1212      * values in case a random rotation is also added */
1213     else {
1214       paint_update_brush_rake_rotation(ups, brush, ups->last_rake_angle);
1215       ok = false;
1216     }
1217   }
1218   else {
1219     ups->brush_rotation = ups->brush_rotation_sec = 0.0f;
1220     ok = true;
1221   }
1222   return ok;
1223 }
1224
1225 void BKE_sculptsession_free_deformMats(SculptSession *ss)
1226 {
1227   MEM_SAFE_FREE(ss->orig_cos);
1228   MEM_SAFE_FREE(ss->deform_cos);
1229   MEM_SAFE_FREE(ss->deform_imats);
1230 }
1231
1232 void BKE_sculptsession_free_vwpaint_data(struct SculptSession *ss)
1233 {
1234   struct SculptVertexPaintGeomMap *gmap = NULL;
1235   if (ss->mode_type == OB_MODE_VERTEX_PAINT) {
1236     gmap = &ss->mode.vpaint.gmap;
1237
1238     MEM_SAFE_FREE(ss->mode.vpaint.previous_color);
1239   }
1240   else if (ss->mode_type == OB_MODE_WEIGHT_PAINT) {
1241     gmap = &ss->mode.wpaint.gmap;
1242
1243     MEM_SAFE_FREE(ss->mode.wpaint.alpha_weight);
1244     if (ss->mode.wpaint.dvert_prev) {
1245       BKE_defvert_array_free_elems(ss->mode.wpaint.dvert_prev, ss->totvert);
1246       MEM_freeN(ss->mode.wpaint.dvert_prev);
1247       ss->mode.wpaint.dvert_prev = NULL;
1248     }
1249   }
1250   else {
1251     return;
1252   }
1253   MEM_SAFE_FREE(gmap->vert_to_loop);
1254   MEM_SAFE_FREE(gmap->vert_map_mem);
1255   MEM_SAFE_FREE(gmap->vert_to_poly);
1256   MEM_SAFE_FREE(gmap->poly_map_mem);
1257 }
1258
1259 /* Write out the sculpt dynamic-topology BMesh to the Mesh */
1260 static void sculptsession_bm_to_me_update_data_only(Object *ob, bool reorder)
1261 {
1262   SculptSession *ss = ob->sculpt;
1263
1264   if (ss->bm) {
1265     if (ob->data) {
1266       BMIter iter;
1267       BMFace *efa;
1268       BM_ITER_MESH (efa, &iter, ss->bm, BM_FACES_OF_MESH) {
1269         BM_elem_flag_set(efa, BM_ELEM_SMOOTH, ss->bm_smooth_shading);
1270       }
1271       if (reorder) {
1272         BM_log_mesh_elems_reorder(ss->bm, ss->bm_log);
1273       }
1274       BM_mesh_bm_to_me(NULL,
1275                        ss->bm,
1276                        ob->data,
1277                        (&(struct BMeshToMeshParams){
1278                            .calc_object_remap = false,
1279                        }));
1280     }
1281   }
1282 }
1283
1284 void BKE_sculptsession_bm_to_me(Object *ob, bool reorder)
1285 {
1286   if (ob && ob->sculpt) {
1287     sculptsession_bm_to_me_update_data_only(ob, reorder);
1288
1289     /* Ensure the objects evaluated mesh doesn't hold onto arrays
1290      * now realloc'd in the mesh T34473. */
1291     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
1292   }
1293 }
1294
1295 static void sculptsession_free_pbvh(Object *object)
1296 {
1297   SculptSession *ss = object->sculpt;
1298
1299   if (!ss) {
1300     return;
1301   }
1302
1303   if (ss->pbvh) {
1304     BKE_pbvh_free(ss->pbvh);
1305     ss->pbvh = NULL;
1306   }
1307
1308   MEM_SAFE_FREE(ss->pmap);
1309   MEM_SAFE_FREE(ss->pmap_mem);
1310
1311   MEM_SAFE_FREE(ss->layer_base);
1312
1313   MEM_SAFE_FREE(ss->preview_vert_index_list);
1314   ss->preview_vert_index_count = 0;
1315 }
1316
1317 void BKE_sculptsession_bm_to_me_for_render(Object *object)
1318 {
1319   if (object && object->sculpt) {
1320     if (object->sculpt->bm) {
1321       /* Ensure no points to old arrays are stored in DM
1322        *
1323        * Apparently, we could not use DEG_id_tag_update
1324        * here because this will lead to the while object
1325        * surface to disappear, so we'll release DM in place.
1326        */
1327       BKE_object_free_derived_caches(object);
1328
1329       sculptsession_bm_to_me_update_data_only(object, false);
1330
1331       /* In contrast with sculptsession_bm_to_me no need in
1332        * DAG tag update here - derived mesh was freed and
1333        * old pointers are nowhere stored.
1334        */
1335     }
1336   }
1337 }
1338
1339 void BKE_sculptsession_free(Object *ob)
1340 {
1341   if (ob && ob->sculpt) {
1342     SculptSession *ss = ob->sculpt;
1343
1344     if (ss->bm) {
1345       BKE_sculptsession_bm_to_me(ob, true);
1346       BM_mesh_free(ss->bm);
1347     }
1348
1349     sculptsession_free_pbvh(ob);
1350
1351     MEM_SAFE_FREE(ss->pmap);
1352     MEM_SAFE_FREE(ss->pmap_mem);
1353     if (ss->bm_log) {
1354       BM_log_free(ss->bm_log);
1355     }
1356
1357     MEM_SAFE_FREE(ss->texcache);
1358
1359     if (ss->tex_pool) {
1360       BKE_image_pool_free(ss->tex_pool);
1361     }
1362
1363     MEM_SAFE_FREE(ss->orig_cos);
1364     MEM_SAFE_FREE(ss->deform_cos);
1365     MEM_SAFE_FREE(ss->deform_imats);
1366
1367     MEM_SAFE_FREE(ss->preview_vert_index_list);
1368
1369     if (ss->pose_ik_chain_preview) {
1370       for (int i = 0; i < ss->pose_ik_chain_preview->tot_segments; i++) {
1371         MEM_SAFE_FREE(ss->pose_ik_chain_preview->segments[i].weights);
1372       }
1373       MEM_SAFE_FREE(ss->pose_ik_chain_preview->segments);
1374       MEM_SAFE_FREE(ss->pose_ik_chain_preview);
1375     }
1376
1377     BKE_sculptsession_free_vwpaint_data(ob->sculpt);
1378
1379     MEM_freeN(ss);
1380
1381     ob->sculpt = NULL;
1382   }
1383 }
1384
1385 /* Sculpt mode handles multires differently from regular meshes, but only if
1386  * it's the last modifier on the stack and it is not on the first level */
1387 MultiresModifierData *BKE_sculpt_multires_active(Scene *scene, Object *ob)
1388 {
1389   Mesh *me = (Mesh *)ob->data;
1390   ModifierData *md;
1391   VirtualModifierData virtualModifierData;
1392
1393   if (ob->sculpt && ob->sculpt->bm) {
1394     /* can't combine multires and dynamic topology */
1395     return NULL;
1396   }
1397
1398   if (!CustomData_get_layer(&me->ldata, CD_MDISPS)) {
1399     /* multires can't work without displacement layer */
1400     return NULL;
1401   }
1402
1403   /* Weight paint operates on original vertices, and needs to treat multires as regular modifier
1404    * to make it so that PBVH vertices are at the multires surface. */
1405   if ((ob->mode & OB_MODE_SCULPT) == 0) {
1406     return NULL;
1407   }
1408
1409   for (md = modifiers_getVirtualModifierList(ob, &virtualModifierData); md; md = md->next) {
1410     if (md->type == eModifierType_Multires) {
1411       MultiresModifierData *mmd = (MultiresModifierData *)md;
1412
1413       if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) {
1414         continue;
1415       }
1416
1417       if (BKE_multires_sculpt_level_get(mmd) > 0) {
1418         return mmd;
1419       }
1420       else {
1421         return NULL;
1422       }
1423     }
1424   }
1425
1426   return NULL;
1427 }
1428
1429 /* Checks if there are any supported deformation modifiers active */
1430 static bool sculpt_modifiers_active(Scene *scene, Sculpt *sd, Object *ob)
1431 {
1432   ModifierData *md;
1433   Mesh *me = (Mesh *)ob->data;
1434   MultiresModifierData *mmd = BKE_sculpt_multires_active(scene, ob);
1435   VirtualModifierData virtualModifierData;
1436
1437   if (mmd || ob->sculpt->bm) {
1438     return false;
1439   }
1440
1441   /* non-locked shape keys could be handled in the same way as deformed mesh */
1442   if ((ob->shapeflag & OB_SHAPE_LOCK) == 0 && me->key && ob->shapenr) {
1443     return true;
1444   }
1445
1446   md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
1447
1448   /* exception for shape keys because we can edit those */
1449   for (; md; md = md->next) {
1450     const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1451     if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) {
1452       continue;
1453     }
1454     if (md->type == eModifierType_Multires && (ob->mode & OB_MODE_SCULPT)) {
1455       continue;
1456     }
1457     if (md->type == eModifierType_ShapeKey) {
1458       continue;
1459     }
1460
1461     if (mti->type == eModifierTypeType_OnlyDeform) {
1462       return true;
1463     }
1464     else if ((sd->flags & SCULPT_ONLY_DEFORM) == 0) {
1465       return true;
1466     }
1467   }
1468
1469   return false;
1470 }
1471
1472 /**
1473  * \param need_mask: So that the evaluated mesh that is returned has mask data.
1474  */
1475 static void sculpt_update_object(
1476     Depsgraph *depsgraph, Object *ob, Mesh *me_eval, bool need_pmap, bool need_mask)
1477 {
1478   Scene *scene = DEG_get_input_scene(depsgraph);
1479   Sculpt *sd = scene->toolsettings->sculpt;
1480   SculptSession *ss = ob->sculpt;
1481   Mesh *me = BKE_object_get_original_mesh(ob);
1482   MultiresModifierData *mmd = BKE_sculpt_multires_active(scene, ob);
1483
1484   ss->deform_modifiers_active = sculpt_modifiers_active(scene, sd, ob);
1485   ss->show_mask = (sd->flags & SCULPT_HIDE_MASK) == 0;
1486   ss->show_face_sets = (sd->flags & SCULPT_HIDE_FACE_SETS) == 0;
1487
1488   ss->building_vp_handle = false;
1489
1490   if (need_mask) {
1491     if (mmd == NULL) {
1492       if (!CustomData_has_layer(&me->vdata, CD_PAINT_MASK)) {
1493         BKE_sculpt_mask_layers_ensure(ob, NULL);
1494       }
1495     }
1496     else {
1497       if (!CustomData_has_layer(&me->ldata, CD_GRID_PAINT_MASK)) {
1498         BKE_sculpt_mask_layers_ensure(ob, mmd);
1499       }
1500     }
1501   }
1502
1503   /* tessfaces aren't used and will become invalid */
1504   BKE_mesh_tessface_clear(me);
1505
1506   ss->shapekey_active = (mmd == NULL) ? BKE_keyblock_from_object(ob) : NULL;
1507
1508   /* NOTE: Weight pPaint require mesh info for loop lookup, but it never uses multires code path,
1509    * so no extra checks is needed here. */
1510   if (mmd) {
1511     ss->multires.active = true;
1512     ss->multires.modifier = mmd;
1513     ss->multires.level = mmd->sculptlvl;
1514     ss->totvert = me_eval->totvert;
1515     ss->totpoly = me_eval->totpoly;
1516     ss->totfaces = me->totpoly;
1517
1518     /* These are assigned to the base mesh in Multires. This is needed because Face Sets operators
1519      * and tools use the Face Sets data from the base mesh when Multires is active. */
1520     ss->mvert = me->mvert;
1521     ss->mpoly = me->mpoly;
1522     ss->mloop = me->mloop;
1523   }
1524   else {
1525     ss->totvert = me->totvert;
1526     ss->totpoly = me->totpoly;
1527     ss->totfaces = me->totpoly;
1528     ss->mvert = me->mvert;
1529     ss->mpoly = me->mpoly;
1530     ss->mloop = me->mloop;
1531     ss->multires.active = false;
1532     ss->multires.modifier = NULL;
1533     ss->multires.level = 0;
1534     ss->vmask = CustomData_get_layer(&me->vdata, CD_PAINT_MASK);
1535   }
1536
1537   /* Sculpt Face Sets. */
1538   if (!CustomData_has_layer(&me->pdata, CD_SCULPT_FACE_SETS)) {
1539     ss->face_sets = CustomData_add_layer(
1540         &me->pdata, CD_SCULPT_FACE_SETS, CD_CALLOC, NULL, me->totpoly);
1541     for (int i = 0; i < me->totpoly; i++) {
1542       ss->face_sets[i] = 1;
1543     }
1544
1545     /* Set the default face set color if the datalayer did not exist. */
1546     me->face_sets_color_default = 1;
1547   }
1548   ss->face_sets = CustomData_get_layer(&me->pdata, CD_SCULPT_FACE_SETS);
1549
1550   ss->subdiv_ccg = me_eval->runtime.subdiv_ccg;
1551
1552   PBVH *pbvh = BKE_sculpt_object_pbvh_ensure(depsgraph, ob);
1553   BLI_assert(pbvh == ss->pbvh);
1554   UNUSED_VARS_NDEBUG(pbvh);
1555
1556   BKE_pbvh_subdiv_cgg_set(ss->pbvh, ss->subdiv_ccg);
1557   BKE_pbvh_face_sets_set(ss->pbvh, ss->face_sets);
1558
1559   BKE_pbvh_face_sets_color_set(ss->pbvh, me->face_sets_color_seed, me->face_sets_color_default);
1560
1561   if (need_pmap && ob->type == OB_MESH && !ss->pmap) {
1562     BKE_mesh_vert_poly_map_create(
1563         &ss->pmap, &ss->pmap_mem, me->mpoly, me->mloop, me->totvert, me->totpoly, me->totloop);
1564   }
1565
1566   pbvh_show_mask_set(ss->pbvh, ss->show_mask);
1567   pbvh_show_face_sets_set(ss->pbvh, ss->show_face_sets);
1568
1569   if (ss->deform_modifiers_active) {
1570     if (!ss->orig_cos) {
1571       int a;
1572
1573       BKE_sculptsession_free_deformMats(ss);
1574
1575       ss->orig_cos = (ss->shapekey_active) ?
1576                          BKE_keyblock_convert_to_vertcos(ob, ss->shapekey_active) :
1577                          BKE_mesh_vert_coords_alloc(me, NULL);
1578
1579       BKE_crazyspace_build_sculpt(depsgraph, scene, ob, &ss->deform_imats, &ss->deform_cos);
1580       BKE_pbvh_vert_coords_apply(ss->pbvh, ss->deform_cos, me->totvert);
1581
1582       for (a = 0; a < me->totvert; a++) {
1583         invert_m3(ss->deform_imats[a]);
1584       }
1585     }
1586   }
1587   else {
1588     BKE_sculptsession_free_deformMats(ss);
1589   }
1590
1591   if (ss->shapekey_active != NULL && ss->deform_cos == NULL) {
1592     ss->deform_cos = BKE_keyblock_convert_to_vertcos(ob, ss->shapekey_active);
1593   }
1594
1595   /* if pbvh is deformed, key block is already applied to it */
1596   if (ss->shapekey_active) {
1597     bool pbvh_deformed = BKE_pbvh_is_deformed(ss->pbvh);
1598     if (!pbvh_deformed || ss->deform_cos == NULL) {
1599       float(*vertCos)[3] = BKE_keyblock_convert_to_vertcos(ob, ss->shapekey_active);
1600
1601       if (vertCos) {
1602         if (!pbvh_deformed) {
1603           /* apply shape keys coordinates to PBVH */
1604           BKE_pbvh_vert_coords_apply(ss->pbvh, vertCos, me->totvert);
1605         }
1606         if (ss->deform_cos == NULL) {
1607           ss->deform_cos = vertCos;
1608         }
1609         if (vertCos != ss->deform_cos) {
1610           MEM_freeN(vertCos);
1611         }
1612       }
1613     }
1614   }
1615 }
1616
1617 void BKE_sculpt_update_object_before_eval(Object *ob)
1618 {
1619   /* Update before mesh evaluation in the dependency graph. */
1620   SculptSession *ss = ob->sculpt;
1621
1622   if (ss && ss->building_vp_handle == false) {
1623     if (!ss->cache && !ss->filter_cache) {
1624       /* We free pbvh on changes, except in the middle of drawing a stroke
1625        * since it can't deal with changing PVBH node organization, we hope
1626        * topology does not change in the meantime .. weak. */
1627       sculptsession_free_pbvh(ob);
1628
1629       BKE_sculptsession_free_deformMats(ob->sculpt);
1630
1631       /* In vertex/weight paint, force maps to be rebuilt. */
1632       BKE_sculptsession_free_vwpaint_data(ob->sculpt);
1633     }
1634     else {
1635       PBVHNode **nodes;
1636       int n, totnode;
1637
1638       BKE_pbvh_search_gather(ss->pbvh, NULL, NULL, &nodes, &totnode);
1639
1640       for (n = 0; n < totnode; n++) {
1641         BKE_pbvh_node_mark_update(nodes[n]);
1642       }
1643
1644       MEM_freeN(nodes);
1645     }
1646   }
1647 }
1648
1649 void BKE_sculpt_update_object_after_eval(Depsgraph *depsgraph, Object *ob_eval)
1650 {
1651   /* Update after mesh evaluation in the dependency graph, to rebuild PBVH or
1652    * other data when modifiers change the mesh. */
1653   Object *ob_orig = DEG_get_original_object(ob_eval);
1654   Mesh *me_eval = BKE_object_get_evaluated_mesh(ob_eval);
1655
1656   BLI_assert(me_eval != NULL);
1657
1658   sculpt_update_object(depsgraph, ob_orig, me_eval, false, false);
1659 }
1660
1661 void BKE_sculpt_update_object_for_edit(Depsgraph *depsgraph,
1662                                        Object *ob_orig,
1663                                        bool need_pmap,
1664                                        bool need_mask)
1665 {
1666   /* Update from sculpt operators and undo, to update sculpt session
1667    * and PBVH after edits. */
1668   Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
1669   Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob_orig);
1670   Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH);
1671
1672   BLI_assert(ob_orig == DEG_get_original_object(ob_orig));
1673
1674   sculpt_update_object(depsgraph, ob_orig, me_eval, need_pmap, need_mask);
1675 }
1676
1677 int BKE_sculpt_mask_layers_ensure(Object *ob, MultiresModifierData *mmd)
1678 {
1679   const float *paint_mask;
1680   Mesh *me = ob->data;
1681   int ret = 0;
1682
1683   paint_mask = CustomData_get_layer(&me->vdata, CD_PAINT_MASK);
1684
1685   /* if multires is active, create a grid paint mask layer if there
1686    * isn't one already */
1687   if (mmd && !CustomData_has_layer(&me->ldata, CD_GRID_PAINT_MASK)) {
1688     GridPaintMask *gmask;
1689     int level = max_ii(1, BKE_multires_sculpt_level_get(mmd));
1690     int gridsize = BKE_ccg_gridsize(level);
1691     int gridarea = gridsize * gridsize;
1692     int i, j;
1693
1694     gmask = CustomData_add_layer(&me->ldata, CD_GRID_PAINT_MASK, CD_CALLOC, NULL, me->totloop);
1695
1696     for (i = 0; i < me->totloop; i++) {
1697       GridPaintMask *gpm = &gmask[i];
1698
1699       gpm->level = level;
1700       gpm->data = MEM_callocN(sizeof(float) * gridarea, "GridPaintMask.data");
1701     }
1702
1703     /* if vertices already have mask, copy into multires data */
1704     if (paint_mask) {
1705       for (i = 0; i < me->totpoly; i++) {
1706         const MPoly *p = &me->mpoly[i];
1707         float avg = 0;
1708
1709         /* mask center */
1710         for (j = 0; j < p->totloop; j++) {
1711           const MLoop *l = &me->mloop[p->loopstart + j];
1712           avg += paint_mask[l->v];
1713         }
1714         avg /= (float)p->totloop;
1715
1716         /* fill in multires mask corner */
1717         for (j = 0; j < p->totloop; j++) {
1718           GridPaintMask *gpm = &gmask[p->loopstart + j];
1719           const MLoop *l = &me->mloop[p->loopstart + j];
1720           const MLoop *prev = ME_POLY_LOOP_PREV(me->mloop, p, j);
1721           const MLoop *next = ME_POLY_LOOP_NEXT(me->mloop, p, j);
1722
1723           gpm->data[0] = avg;
1724           gpm->data[1] = (paint_mask[l->v] + paint_mask[next->v]) * 0.5f;
1725           gpm->data[2] = (paint_mask[l->v] + paint_mask[prev->v]) * 0.5f;
1726           gpm->data[3] = paint_mask[l->v];
1727         }
1728       }
1729     }
1730
1731     ret |= SCULPT_MASK_LAYER_CALC_LOOP;
1732   }
1733
1734   /* create vertex paint mask layer if there isn't one already */
1735   if (!paint_mask) {
1736     CustomData_add_layer(&me->vdata, CD_PAINT_MASK, CD_CALLOC, NULL, me->totvert);
1737     ret |= SCULPT_MASK_LAYER_CALC_VERT;
1738   }
1739
1740   return ret;
1741 }
1742
1743 void BKE_sculpt_toolsettings_data_ensure(struct Scene *scene)
1744 {
1745   BKE_paint_ensure(scene->toolsettings, (Paint **)&scene->toolsettings->sculpt);
1746
1747   Sculpt *sd = scene->toolsettings->sculpt;
1748   if (!sd->detail_size) {
1749     sd->detail_size = 12;
1750   }
1751   if (!sd->detail_percent) {
1752     sd->detail_percent = 25;
1753   }
1754   if (sd->constant_detail == 0.0f) {
1755     sd->constant_detail = 3.0f;
1756   }
1757
1758   /* Set sane default tiling offsets */
1759   if (!sd->paint.tile_offset[0]) {
1760     sd->paint.tile_offset[0] = 1.0f;
1761   }
1762   if (!sd->paint.tile_offset[1]) {
1763     sd->paint.tile_offset[1] = 1.0f;
1764   }
1765   if (!sd->paint.tile_offset[2]) {
1766     sd->paint.tile_offset[2] = 1.0f;
1767   }
1768 }
1769
1770 static bool check_sculpt_object_deformed(Object *object, const bool for_construction)
1771 {
1772   bool deformed = false;
1773
1774   /* Active modifiers means extra deformation, which can't be handled correct
1775    * on birth of PBVH and sculpt "layer" levels, so use PBVH only for internal brush
1776    * stuff and show final evaluated mesh so user would see actual object shape.
1777    */
1778   deformed |= object->sculpt->deform_modifiers_active;
1779
1780   if (for_construction) {
1781     deformed |= object->sculpt->shapekey_active != NULL;
1782   }
1783   else {
1784     /* As in case with modifiers, we can't synchronize deformation made against
1785      * PBVH and non-locked keyblock, so also use PBVH only for brushes and
1786      * final DM to give final result to user.
1787      */
1788     deformed |= object->sculpt->shapekey_active && (object->shapeflag & OB_SHAPE_LOCK) == 0;
1789   }
1790
1791   return deformed;
1792 }
1793
1794 static PBVH *build_pbvh_for_dynamic_topology(Object *ob)
1795 {
1796   PBVH *pbvh = BKE_pbvh_new();
1797   BKE_pbvh_build_bmesh(pbvh,
1798                        ob->sculpt->bm,
1799                        ob->sculpt->bm_smooth_shading,
1800                        ob->sculpt->bm_log,
1801                        ob->sculpt->cd_vert_node_offset,
1802                        ob->sculpt->cd_face_node_offset);
1803   pbvh_show_mask_set(pbvh, ob->sculpt->show_mask);
1804   pbvh_show_face_sets_set(pbvh, false);
1805   return pbvh;
1806 }
1807
1808 static PBVH *build_pbvh_from_regular_mesh(Object *ob, Mesh *me_eval_deform)
1809 {
1810   Mesh *me = BKE_object_get_original_mesh(ob);
1811   const int looptris_num = poly_to_tri_count(me->totpoly, me->totloop);
1812   PBVH *pbvh = BKE_pbvh_new();
1813
1814   MLoopTri *looptri = MEM_malloc_arrayN(looptris_num, sizeof(*looptri), __func__);
1815
1816   BKE_mesh_recalc_looptri(me->mloop, me->mpoly, me->mvert, me->totloop, me->totpoly, looptri);
1817
1818   BKE_pbvh_build_mesh(pbvh,
1819                       me,
1820                       me->mpoly,
1821                       me->mloop,
1822                       me->mvert,
1823                       me->totvert,
1824                       &me->vdata,
1825                       &me->ldata,
1826                       &me->pdata,
1827                       looptri,
1828                       looptris_num);
1829
1830   pbvh_show_mask_set(pbvh, ob->sculpt->show_mask);
1831   pbvh_show_face_sets_set(pbvh, ob->sculpt->show_face_sets);
1832
1833   const bool is_deformed = check_sculpt_object_deformed(ob, true);
1834   if (is_deformed && me_eval_deform != NULL) {
1835     int totvert;
1836     float(*v_cos)[3] = BKE_mesh_vert_coords_alloc(me_eval_deform, &totvert);
1837     BKE_pbvh_vert_coords_apply(pbvh, v_cos, totvert);
1838     MEM_freeN(v_cos);
1839   }
1840
1841   return pbvh;
1842 }
1843
1844 static PBVH *build_pbvh_from_ccg(Object *ob, SubdivCCG *subdiv_ccg)
1845 {
1846   CCGKey key;
1847   BKE_subdiv_ccg_key_top_level(&key, subdiv_ccg);
1848   PBVH *pbvh = BKE_pbvh_new();
1849   BKE_pbvh_build_grids(pbvh,
1850                        subdiv_ccg->grids,
1851                        subdiv_ccg->num_grids,
1852                        &key,
1853                        (void **)subdiv_ccg->grid_faces,
1854                        subdiv_ccg->grid_flag_mats,
1855                        subdiv_ccg->grid_hidden);
1856   pbvh_show_mask_set(pbvh, ob->sculpt->show_mask);
1857   pbvh_show_face_sets_set(pbvh, ob->sculpt->show_face_sets);
1858   return pbvh;
1859 }
1860
1861 PBVH *BKE_sculpt_object_pbvh_ensure(Depsgraph *depsgraph, Object *ob)
1862 {
1863   if (ob == NULL || ob->sculpt == NULL) {
1864     return NULL;
1865   }
1866   PBVH *pbvh = ob->sculpt->pbvh;
1867   if (pbvh != NULL) {
1868     /* NOTE: It is possible that grids were re-allocated due to modifier
1869      * stack. Need to update those pointers. */
1870     if (BKE_pbvh_type(pbvh) == PBVH_GRIDS) {
1871       Object *object_eval = DEG_get_evaluated_object(depsgraph, ob);
1872       Mesh *mesh_eval = object_eval->data;
1873       SubdivCCG *subdiv_ccg = mesh_eval->runtime.subdiv_ccg;
1874       if (subdiv_ccg != NULL) {
1875         BKE_sculpt_bvh_update_from_ccg(pbvh, subdiv_ccg);
1876       }
1877     }
1878     return pbvh;
1879   }
1880
1881   if (ob->sculpt->bm != NULL) {
1882     /* Sculpting on a BMesh (dynamic-topology) gets a special PBVH. */
1883     pbvh = build_pbvh_for_dynamic_topology(ob);
1884   }
1885   else {
1886     Object *object_eval = DEG_get_evaluated_object(depsgraph, ob);
1887     Mesh *mesh_eval = object_eval->data;
1888     if (mesh_eval->runtime.subdiv_ccg != NULL) {
1889       pbvh = build_pbvh_from_ccg(ob, mesh_eval->runtime.subdiv_ccg);
1890     }
1891     else if (ob->type == OB_MESH) {
1892       Mesh *me_eval_deform = object_eval->runtime.mesh_deform_eval;
1893       pbvh = build_pbvh_from_regular_mesh(ob, me_eval_deform);
1894     }
1895   }
1896
1897   ob->sculpt->pbvh = pbvh;
1898   return pbvh;
1899 }
1900
1901 void BKE_sculpt_bvh_update_from_ccg(PBVH *pbvh, SubdivCCG *subdiv_ccg)
1902 {
1903   BKE_pbvh_grids_update(pbvh,
1904                         subdiv_ccg->grids,
1905                         (void **)subdiv_ccg->grid_faces,
1906                         subdiv_ccg->grid_flag_mats,
1907                         subdiv_ccg->grid_hidden);
1908 }
1909
1910 /* Test if PBVH can be used directly for drawing, which is faster than
1911  * drawing the mesh and all updates that come with it. */
1912 bool BKE_sculptsession_use_pbvh_draw(const Object *ob, const View3D *v3d)
1913 {
1914   SculptSession *ss = ob->sculpt;
1915   if (ss == NULL || ss->pbvh == NULL || ss->mode_type != OB_MODE_SCULPT) {
1916     return false;
1917   }
1918
1919   if (BKE_pbvh_type(ss->pbvh) == PBVH_FACES) {
1920     /* Regular mesh only draws from PBVH without modifiers and shape keys. */
1921     const bool full_shading = (v3d && (v3d->shading.type > OB_SOLID));
1922     return !(ss->shapekey_active || ss->deform_modifiers_active || full_shading);
1923   }
1924   else {
1925     /* Multires and dyntopo always draw directly from the PBVH. */
1926     return true;
1927   }
1928 }