Industry Compat keymap: Fix inconsistencies and conflicts with color swatches and...
[blender.git] / source / blender / makesrna / intern / rna_sculpt_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
17 /** \file
18  * \ingroup RNA
19  */
20
21 #include <stdlib.h>
22
23 #include "BLI_math.h"
24 #include "BLI_utildefines.h"
25
26 #include "RNA_define.h"
27 #include "RNA_enum_types.h"
28
29 #include "rna_internal.h"
30
31 #include "DNA_ID.h"
32 #include "DNA_gpencil_types.h"
33 #include "DNA_scene_types.h"
34 #include "DNA_brush_types.h"
35 #include "DNA_screen_types.h"
36 #include "DNA_space_types.h"
37
38 #include "BKE_material.h"
39 #include "BKE_paint.h"
40 #include "BKE_brush.h"
41
42 #include "ED_image.h"
43
44 #include "WM_api.h"
45 #include "WM_types.h"
46
47 #include "bmesh.h"
48
49 const EnumPropertyItem rna_enum_particle_edit_hair_brush_items[] = {
50     {PE_BRUSH_COMB, "COMB", 0, "Comb", "Comb hairs"},
51     {PE_BRUSH_SMOOTH, "SMOOTH", 0, "Smooth", "Smooth hairs"},
52     {PE_BRUSH_ADD, "ADD", 0, "Add", "Add hairs"},
53     {PE_BRUSH_LENGTH, "LENGTH", 0, "Length", "Make hairs longer or shorter"},
54     {PE_BRUSH_PUFF, "PUFF", 0, "Puff", "Make hairs stand up"},
55     {PE_BRUSH_CUT, "CUT", 0, "Cut", "Cut hairs"},
56     {PE_BRUSH_WEIGHT, "WEIGHT", 0, "Weight", "Weight hair particles"},
57     {0, NULL, 0, NULL, NULL},
58 };
59
60 const EnumPropertyItem rna_enum_gpencil_sculpt_brush_items[] = {
61     {GP_SCULPT_TYPE_SMOOTH, "SMOOTH", ICON_GPBRUSH_SMOOTH, "Smooth", "Smooth stroke points"},
62     {GP_SCULPT_TYPE_THICKNESS,
63      "THICKNESS",
64      ICON_GPBRUSH_THICKNESS,
65      "Thickness",
66      "Adjust thickness of strokes"},
67     {GP_SCULPT_TYPE_STRENGTH,
68      "STRENGTH",
69      ICON_GPBRUSH_STRENGTH,
70      "Strength",
71      "Adjust color strength of strokes"},
72     {GP_SCULPT_TYPE_RANDOMIZE,
73      "RANDOMIZE",
74      ICON_GPBRUSH_RANDOMIZE,
75      "Randomize",
76      "Introduce jitter/randomness into strokes"},
77     {GP_SCULPT_TYPE_GRAB,
78      "GRAB",
79      ICON_GPBRUSH_GRAB,
80      "Grab",
81      "Translate the set of points initially within the brush circle"},
82     {GP_SCULPT_TYPE_PUSH,
83      "PUSH",
84      ICON_GPBRUSH_PUSH,
85      "Push",
86      "Move points out of the way, as if combing them"},
87     {GP_SCULPT_TYPE_TWIST,
88      "TWIST",
89      ICON_GPBRUSH_TWIST,
90      "Twist",
91      "Rotate points around the midpoint of the brush"},
92     {GP_SCULPT_TYPE_PINCH,
93      "PINCH",
94      ICON_GPBRUSH_PINCH,
95      "Pinch",
96      "Pull points towards the midpoint of the brush"},
97     {GP_SCULPT_TYPE_CLONE,
98      "CLONE",
99      ICON_GPBRUSH_CLONE,
100      "Clone",
101      "Paste copies of the strokes stored on the clipboard"},
102     {0, NULL, 0, NULL, NULL}};
103
104 const EnumPropertyItem rna_enum_gpencil_weight_brush_items[] = {
105     {GP_SCULPT_TYPE_WEIGHT,
106      "WEIGHT",
107      ICON_GPBRUSH_WEIGHT,
108      "Weight",
109      "Weight Paint for Vertex Groups"},
110     {0, NULL, 0, NULL, NULL},
111 };
112
113 #ifndef RNA_RUNTIME
114 static const EnumPropertyItem rna_enum_gpencil_lock_axis_items[] = {
115     {GP_LOCKAXIS_VIEW,
116      "VIEW",
117      ICON_RESTRICT_VIEW_ON,
118      "View",
119      "Align strokes to current view plane"},
120     {GP_LOCKAXIS_Y,
121      "AXIS_Y",
122      ICON_AXIS_FRONT,
123      "Front (X-Z)",
124      "Project strokes to plane locked to Y"},
125     {GP_LOCKAXIS_X,
126      "AXIS_X",
127      ICON_AXIS_SIDE,
128      "Side (Y-Z)",
129      "Project strokes to plane locked to X"},
130     {GP_LOCKAXIS_Z, "AXIS_Z", ICON_AXIS_TOP, "Top (X-Y)", "Project strokes to plane locked to Z"},
131     {GP_LOCKAXIS_CURSOR,
132      "CURSOR",
133      ICON_PIVOT_CURSOR,
134      "Cursor",
135      "Align strokes to current 3D cursor orientation"},
136     {0, NULL, 0, NULL, NULL},
137 };
138 #endif
139
140 const EnumPropertyItem rna_enum_symmetrize_direction_items[] = {
141     {BMO_SYMMETRIZE_NEGATIVE_X, "NEGATIVE_X", 0, "-X to +X", ""},
142     {BMO_SYMMETRIZE_POSITIVE_X, "POSITIVE_X", 0, "+X to -X", ""},
143
144     {BMO_SYMMETRIZE_NEGATIVE_Y, "NEGATIVE_Y", 0, "-Y to +Y", ""},
145     {BMO_SYMMETRIZE_POSITIVE_Y, "POSITIVE_Y", 0, "+Y to -Y", ""},
146
147     {BMO_SYMMETRIZE_NEGATIVE_Z, "NEGATIVE_Z", 0, "-Z to +Z", ""},
148     {BMO_SYMMETRIZE_POSITIVE_Z, "POSITIVE_Z", 0, "+Z to -Z", ""},
149     {0, NULL, 0, NULL, NULL},
150 };
151
152 #ifdef RNA_RUNTIME
153 #  include "MEM_guardedalloc.h"
154
155 #  include "BKE_collection.h"
156 #  include "BKE_context.h"
157 #  include "BKE_particle.h"
158 #  include "BKE_pbvh.h"
159 #  include "BKE_pointcache.h"
160 #  include "BKE_object.h"
161 #  include "BKE_gpencil.h"
162
163 #  include "DEG_depsgraph.h"
164
165 #  include "ED_particle.h"
166
167 static void rna_GPencil_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *UNUSED(ptr))
168 {
169   /* mark all grease pencil datablocks of the scene */
170   FOREACH_SCENE_COLLECTION_BEGIN (scene, collection) {
171     FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (collection, ob) {
172       if (ob->type == OB_GPENCIL) {
173         bGPdata *gpd = (bGPdata *)ob->data;
174         gpd->flag |= GP_DATA_CACHE_IS_DIRTY;
175         DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
176       }
177     }
178     FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
179   }
180   FOREACH_SCENE_COLLECTION_END;
181
182   WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
183 }
184
185 const EnumPropertyItem rna_enum_particle_edit_disconnected_hair_brush_items[] = {
186     {PE_BRUSH_COMB, "COMB", 0, "Comb", "Comb hairs"},
187     {PE_BRUSH_SMOOTH, "SMOOTH", 0, "Smooth", "Smooth hairs"},
188     {PE_BRUSH_LENGTH, "LENGTH", 0, "Length", "Make hairs longer or shorter"},
189     {PE_BRUSH_CUT, "CUT", 0, "Cut", "Cut hairs"},
190     {PE_BRUSH_WEIGHT, "WEIGHT", 0, "Weight", "Weight hair particles"},
191     {0, NULL, 0, NULL, NULL},
192 };
193
194 static const EnumPropertyItem particle_edit_cache_brush_items[] = {
195     {PE_BRUSH_COMB, "COMB", 0, "Comb", "Comb paths"},
196     {PE_BRUSH_SMOOTH, "SMOOTH", 0, "Smooth", "Smooth paths"},
197     {PE_BRUSH_LENGTH, "LENGTH", 0, "Length", "Make paths longer or shorter"},
198     {0, NULL, 0, NULL, NULL},
199 };
200
201 static PointerRNA rna_ParticleEdit_brush_get(PointerRNA *ptr)
202 {
203   ParticleEditSettings *pset = (ParticleEditSettings *)ptr->data;
204   ParticleBrushData *brush = NULL;
205
206   brush = &pset->brush[pset->brushtype];
207
208   return rna_pointer_inherit_refine(ptr, &RNA_ParticleBrush, brush);
209 }
210
211 static PointerRNA rna_ParticleBrush_curve_get(PointerRNA *ptr)
212 {
213   return rna_pointer_inherit_refine(ptr, &RNA_CurveMapping, NULL);
214 }
215
216 static void rna_ParticleEdit_redo(bContext *C, PointerRNA *UNUSED(ptr))
217 {
218   Scene *scene = CTX_data_scene(C);
219   ViewLayer *view_layer = CTX_data_view_layer(C);
220   Object *ob = OBACT(view_layer);
221   PTCacheEdit *edit = PE_get_current(scene, ob);
222
223   if (!edit) {
224     return;
225   }
226
227   if (ob) {
228     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
229   }
230
231   BKE_particle_batch_cache_dirty_tag(edit->psys, BKE_PARTICLE_BATCH_DIRTY_ALL);
232   psys_free_path_cache(edit->psys, edit);
233   DEG_id_tag_update(&scene->id, ID_RECALC_COPY_ON_WRITE);
234 }
235
236 static void rna_ParticleEdit_update(bContext *C, PointerRNA *UNUSED(ptr))
237 {
238   Scene *scene = CTX_data_scene(C);
239   ViewLayer *view_layer = CTX_data_view_layer(C);
240   Object *ob = OBACT(view_layer);
241
242   if (ob) {
243     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
244   }
245
246   /* Sync tool setting changes from original to evaluated scenes. */
247   DEG_id_tag_update(&scene->id, ID_RECALC_COPY_ON_WRITE);
248 }
249
250 static void rna_ParticleEdit_tool_set(PointerRNA *ptr, int value)
251 {
252   ParticleEditSettings *pset = (ParticleEditSettings *)ptr->data;
253
254   /* redraw hair completely if weight brush is/was used */
255   if ((pset->brushtype == PE_BRUSH_WEIGHT || value == PE_BRUSH_WEIGHT) && pset->object) {
256     Object *ob = pset->object;
257     if (ob) {
258       DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
259       WM_main_add_notifier(NC_OBJECT | ND_PARTICLE | NA_EDITED, NULL);
260     }
261   }
262
263   pset->brushtype = value;
264 }
265 static const EnumPropertyItem *rna_ParticleEdit_tool_itemf(bContext *C,
266                                                            PointerRNA *UNUSED(ptr),
267                                                            PropertyRNA *UNUSED(prop),
268                                                            bool *UNUSED(r_free))
269 {
270   ViewLayer *view_layer = CTX_data_view_layer(C);
271   Object *ob = OBACT(view_layer);
272 #  if 0
273   Scene *scene = CTX_data_scene(C);
274   PTCacheEdit *edit = PE_get_current(scene, ob);
275   ParticleSystem *psys = edit ? edit->psys : NULL;
276 #  else
277   /* use this rather than PE_get_current() - because the editing cache is
278    * dependent on the cache being updated which can happen after this UI
279    * draws causing a glitch [#28883] */
280   ParticleSystem *psys = psys_get_current(ob);
281 #  endif
282
283   if (psys) {
284     if (psys->flag & PSYS_GLOBAL_HAIR) {
285       return rna_enum_particle_edit_disconnected_hair_brush_items;
286     }
287     else {
288       return rna_enum_particle_edit_hair_brush_items;
289     }
290   }
291
292   return particle_edit_cache_brush_items;
293 }
294
295 static bool rna_ParticleEdit_editable_get(PointerRNA *ptr)
296 {
297   ParticleEditSettings *pset = (ParticleEditSettings *)ptr->data;
298
299   return (pset->object && pset->scene && PE_get_current(pset->scene, pset->object));
300 }
301 static bool rna_ParticleEdit_hair_get(PointerRNA *ptr)
302 {
303   ParticleEditSettings *pset = (ParticleEditSettings *)ptr->data;
304
305   if (pset->scene) {
306     PTCacheEdit *edit = PE_get_current(pset->scene, pset->object);
307
308     return (edit && edit->psys);
309   }
310
311   return 0;
312 }
313
314 static char *rna_ParticleEdit_path(PointerRNA *UNUSED(ptr))
315 {
316   return BLI_strdup("tool_settings.particle_edit");
317 }
318
319 static bool rna_Brush_mode_poll(PointerRNA *ptr, PointerRNA value)
320 {
321   const Paint *paint = ptr->data;
322   Brush *brush = value.id.data;
323   const uint tool_offset = paint->runtime.tool_offset;
324   const eObjectMode ob_mode = paint->runtime.ob_mode;
325   UNUSED_VARS_NDEBUG(tool_offset);
326   BLI_assert(tool_offset && ob_mode);
327
328   if (brush->ob_mode & ob_mode) {
329     if (paint->brush) {
330       if (BKE_brush_tool_get(paint->brush, paint) == BKE_brush_tool_get(brush, paint)) {
331         return true;
332       }
333     }
334     else {
335       return true;
336     }
337   }
338
339   return false;
340 }
341
342 static bool paint_contains_brush_slot(const Paint *paint, const PaintToolSlot *tslot, int *r_index)
343 {
344   if ((tslot >= paint->tool_slots) && (tslot < (paint->tool_slots + paint->tool_slots_len))) {
345     *r_index = (int)(tslot - paint->tool_slots);
346     return true;
347   }
348   return false;
349 }
350
351 static bool rna_Brush_mode_with_tool_poll(PointerRNA *ptr, PointerRNA value)
352 {
353   Scene *scene = (Scene *)ptr->id.data;
354   const PaintToolSlot *tslot = ptr->data;
355   ToolSettings *ts = scene->toolsettings;
356   Brush *brush = value.id.data;
357   int mode = 0;
358   int slot_index = 0;
359
360   if (paint_contains_brush_slot(&ts->imapaint.paint, tslot, &slot_index)) {
361     if (slot_index != brush->imagepaint_tool) {
362       return false;
363     }
364     mode = OB_MODE_TEXTURE_PAINT;
365   }
366   else if (paint_contains_brush_slot(&ts->sculpt->paint, tslot, &slot_index)) {
367     if (slot_index != brush->sculpt_tool) {
368       return false;
369     }
370     mode = OB_MODE_SCULPT;
371   }
372   else if (paint_contains_brush_slot(&ts->uvsculpt->paint, tslot, &slot_index)) {
373     if (slot_index != brush->uv_sculpt_tool) {
374       return false;
375     }
376     mode = OB_MODE_EDIT;
377   }
378   else if (paint_contains_brush_slot(&ts->vpaint->paint, tslot, &slot_index)) {
379     if (slot_index != brush->vertexpaint_tool) {
380       return false;
381     }
382     mode = OB_MODE_VERTEX_PAINT;
383   }
384   else if (paint_contains_brush_slot(&ts->wpaint->paint, tslot, &slot_index)) {
385     if (slot_index != brush->weightpaint_tool) {
386       return false;
387     }
388     mode = OB_MODE_WEIGHT_PAINT;
389   }
390   else if (paint_contains_brush_slot(&ts->gp_paint->paint, tslot, &slot_index)) {
391     if (slot_index != brush->gpencil_tool) {
392       return false;
393     }
394     mode = OB_MODE_PAINT_GPENCIL;
395   }
396
397   return brush->ob_mode & mode;
398 }
399
400 static void rna_Sculpt_update(bContext *C, PointerRNA *UNUSED(ptr))
401 {
402   Scene *scene = CTX_data_scene(C);
403   ViewLayer *view_layer = CTX_data_view_layer(C);
404   Object *ob = OBACT(view_layer);
405
406   if (ob) {
407     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
408     WM_main_add_notifier(NC_OBJECT | ND_MODIFIER, ob);
409
410     if (ob->sculpt) {
411       ob->sculpt->bm_smooth_shading = ((scene->toolsettings->sculpt->flags &
412                                         SCULPT_DYNTOPO_SMOOTH_SHADING) != 0);
413     }
414   }
415 }
416
417 static void rna_Sculpt_ShowDiffuseColor_update(bContext *C, PointerRNA *UNUSED(ptr))
418 {
419   ViewLayer *view_layer = CTX_data_view_layer(C);
420   Object *ob = OBACT(view_layer);
421
422   if (ob && ob->sculpt) {
423     Scene *scene = CTX_data_scene(C);
424     Sculpt *sd = scene->toolsettings->sculpt;
425     ob->sculpt->show_diffuse_color = ((sd->flags & SCULPT_SHOW_DIFFUSE) != 0);
426
427     if (ob->sculpt->pbvh) {
428       pbvh_show_diffuse_color_set(ob->sculpt->pbvh, ob->sculpt->show_diffuse_color);
429     }
430
431     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
432     WM_main_add_notifier(NC_OBJECT | ND_MODIFIER, ob);
433   }
434 }
435
436 static void rna_Sculpt_ShowMask_update(bContext *C, PointerRNA *UNUSED(ptr))
437 {
438   ViewLayer *view_layer = CTX_data_view_layer(C);
439   Object *object = OBACT(view_layer);
440   if (object == NULL || object->sculpt == NULL) {
441     return;
442   }
443   Scene *scene = CTX_data_scene(C);
444   Sculpt *sd = scene->toolsettings->sculpt;
445   object->sculpt->show_mask = ((sd->flags & SCULPT_HIDE_MASK) == 0);
446   if (object->sculpt->pbvh != NULL) {
447     pbvh_show_mask_set(object->sculpt->pbvh, object->sculpt->show_mask);
448   }
449   DEG_id_tag_update(&object->id, ID_RECALC_GEOMETRY);
450   WM_main_add_notifier(NC_OBJECT | ND_MODIFIER, object);
451 }
452
453 static char *rna_Sculpt_path(PointerRNA *UNUSED(ptr))
454 {
455   return BLI_strdup("tool_settings.sculpt");
456 }
457
458 static char *rna_VertexPaint_path(PointerRNA *ptr)
459 {
460   Scene *scene = (Scene *)ptr->id.data;
461   ToolSettings *ts = scene->toolsettings;
462   if (ptr->data == ts->vpaint) {
463     return BLI_strdup("tool_settings.vertex_paint");
464   }
465   else {
466     return BLI_strdup("tool_settings.weight_paint");
467   }
468 }
469
470 static char *rna_ImagePaintSettings_path(PointerRNA *UNUSED(ptr))
471 {
472   return BLI_strdup("tool_settings.image_paint");
473 }
474
475 static char *rna_UvSculpt_path(PointerRNA *UNUSED(ptr))
476 {
477   return BLI_strdup("tool_settings.uv_sculpt");
478 }
479
480 static char *rna_GpPaint_path(PointerRNA *UNUSED(ptr))
481 {
482   return BLI_strdup("tool_settings.gpencil_paint");
483 }
484
485 static char *rna_ParticleBrush_path(PointerRNA *UNUSED(ptr))
486 {
487   return BLI_strdup("tool_settings.particle_edit.brush");
488 }
489
490 static void rna_Paint_brush_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
491 {
492   Paint *paint = ptr->data;
493   Brush *br = paint->brush;
494   BKE_paint_invalidate_overlay_all();
495   /* Needed because we're not calling 'BKE_paint_brush_set' which handles this. */
496   BKE_paint_toolslots_brush_update(paint);
497   WM_main_add_notifier(NC_BRUSH | NA_SELECTED, br);
498 }
499
500 static void rna_ImaPaint_viewport_update(Main *UNUSED(bmain),
501                                          Scene *UNUSED(scene),
502                                          PointerRNA *UNUSED(ptr))
503 {
504   /* not the best solution maybe, but will refresh the 3D viewport */
505   WM_main_add_notifier(NC_OBJECT | ND_DRAW, NULL);
506 }
507
508 static void rna_ImaPaint_mode_update(bContext *C, PointerRNA *UNUSED(ptr))
509 {
510   Scene *scene = CTX_data_scene(C);
511   ViewLayer *view_layer = CTX_data_view_layer(C);
512   Object *ob = OBACT(view_layer);
513
514   if (ob && ob->type == OB_MESH) {
515     /* of course we need to invalidate here */
516     BKE_texpaint_slots_refresh_object(scene, ob);
517
518     /* We assume that changing the current mode will invalidate the uv layers
519      * so we need to refresh display. */
520     BKE_paint_proj_mesh_data_check(scene, ob, NULL, NULL, NULL, NULL);
521     WM_main_add_notifier(NC_OBJECT | ND_DRAW, NULL);
522   }
523 }
524
525 static void rna_ImaPaint_stencil_update(bContext *C, PointerRNA *UNUSED(ptr))
526 {
527   Scene *scene = CTX_data_scene(C);
528   ViewLayer *view_layer = CTX_data_view_layer(C);
529   Object *ob = OBACT(view_layer);
530
531   if (ob && ob->type == OB_MESH) {
532     BKE_paint_proj_mesh_data_check(scene, ob, NULL, NULL, NULL, NULL);
533     WM_main_add_notifier(NC_OBJECT | ND_DRAW, NULL);
534   }
535 }
536
537 static void rna_ImaPaint_canvas_update(bContext *C, PointerRNA *UNUSED(ptr))
538 {
539   Main *bmain = CTX_data_main(C);
540   Scene *scene = CTX_data_scene(C);
541   ViewLayer *view_layer = CTX_data_view_layer(C);
542   Object *ob = OBACT(view_layer);
543   Object *obedit = OBEDIT_FROM_OBACT(ob);
544   bScreen *sc;
545   Image *ima = scene->toolsettings->imapaint.canvas;
546
547   for (sc = bmain->screens.first; sc; sc = sc->id.next) {
548     ScrArea *sa;
549     for (sa = sc->areabase.first; sa; sa = sa->next) {
550       SpaceLink *slink;
551       for (slink = sa->spacedata.first; slink; slink = slink->next) {
552         if (slink->spacetype == SPACE_IMAGE) {
553           SpaceImage *sima = (SpaceImage *)slink;
554
555           if (!sima->pin) {
556             ED_space_image_set(bmain, sima, obedit, ima, true);
557           }
558         }
559       }
560     }
561   }
562
563   if (ob && ob->type == OB_MESH) {
564     BKE_paint_proj_mesh_data_check(scene, ob, NULL, NULL, NULL, NULL);
565     WM_main_add_notifier(NC_OBJECT | ND_DRAW, NULL);
566   }
567 }
568
569 static bool rna_ImaPaint_detect_data(ImagePaintSettings *imapaint)
570 {
571   return imapaint->missing_data == 0;
572 }
573
574 static PointerRNA rna_GPencilSculptSettings_brush_get(PointerRNA *ptr)
575 {
576   GP_Sculpt_Settings *gset = (GP_Sculpt_Settings *)ptr->data;
577   GP_Sculpt_Data *brush = NULL;
578
579   if ((gset) && (gset->flag & GP_SCULPT_SETT_FLAG_WEIGHT_MODE)) {
580     if ((gset->weighttype >= GP_SCULPT_TYPE_WEIGHT) && (gset->weighttype < GP_SCULPT_TYPE_MAX)) {
581       brush = &gset->brush[gset->weighttype];
582     }
583   }
584   else {
585     if ((gset->brushtype >= 0) && (gset->brushtype < GP_SCULPT_TYPE_WEIGHT)) {
586       brush = &gset->brush[gset->brushtype];
587     }
588   }
589   return rna_pointer_inherit_refine(ptr, &RNA_GPencilSculptBrush, brush);
590 }
591
592 static char *rna_GPencilSculptSettings_path(PointerRNA *UNUSED(ptr))
593 {
594   return BLI_strdup("tool_settings.gpencil_sculpt");
595 }
596
597 static char *rna_GPencilSculptBrush_path(PointerRNA *UNUSED(ptr))
598 {
599   return BLI_strdup("tool_settings.gpencil_sculpt.brush");
600 }
601
602 static char *rna_GPencilSculptGuide_path(PointerRNA *UNUSED(ptr))
603 {
604   return BLI_strdup("tool_settings.gpencil_sculpt.guide");
605 }
606
607 #else
608
609 static void rna_def_paint_curve(BlenderRNA *brna)
610 {
611   StructRNA *srna;
612
613   srna = RNA_def_struct(brna, "PaintCurve", "ID");
614   RNA_def_struct_ui_text(srna, "Paint Curve", "");
615   RNA_def_struct_ui_icon(srna, ICON_CURVE_BEZCURVE);
616 }
617
618 static void rna_def_paint_tool_slot(BlenderRNA *brna)
619 {
620   StructRNA *srna;
621   PropertyRNA *prop;
622
623   srna = RNA_def_struct(brna, "PaintToolSlot", NULL);
624   RNA_def_struct_ui_text(srna, "Paint Tool Slot", "");
625
626   prop = RNA_def_property(srna, "brush", PROP_POINTER, PROP_NONE);
627   RNA_def_property_flag(prop, PROP_EDITABLE);
628   RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, "rna_Brush_mode_with_tool_poll");
629   RNA_def_property_ui_text(prop, "Brush", "");
630 }
631
632 static void rna_def_paint(BlenderRNA *brna)
633 {
634   StructRNA *srna;
635   PropertyRNA *prop;
636
637   srna = RNA_def_struct(brna, "Paint", NULL);
638   RNA_def_struct_ui_text(srna, "Paint", "");
639
640   /* Global Settings */
641   prop = RNA_def_property(srna, "brush", PROP_POINTER, PROP_NONE);
642   RNA_def_property_flag(prop, PROP_EDITABLE);
643   RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, "rna_Brush_mode_poll");
644   RNA_def_property_ui_text(prop, "Brush", "Active Brush");
645   RNA_def_property_update(prop, 0, "rna_Paint_brush_update");
646
647   /* paint_tool_slots */
648   prop = RNA_def_property(srna, "tool_slots", PROP_COLLECTION, PROP_NONE);
649   RNA_def_property_collection_sdna(prop, NULL, "tool_slots", "tool_slots_len");
650   RNA_def_property_struct_type(prop, "PaintToolSlot");
651   /* don't dereference pointer! */
652   RNA_def_property_collection_funcs(
653       prop, NULL, NULL, NULL, "rna_iterator_array_get", NULL, NULL, NULL, NULL);
654   RNA_def_property_ui_text(prop, "Paint Tool Slots", "");
655
656   prop = RNA_def_property(srna, "palette", PROP_POINTER, PROP_NONE);
657   RNA_def_property_flag(prop, PROP_EDITABLE);
658   RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, NULL);
659   RNA_def_property_ui_text(prop, "Palette", "Active Palette");
660
661   prop = RNA_def_property(srna, "show_brush", PROP_BOOLEAN, PROP_NONE);
662   RNA_def_property_boolean_sdna(prop, NULL, "flags", PAINT_SHOW_BRUSH);
663   RNA_def_property_ui_text(prop, "Show Brush", "");
664   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
665
666   prop = RNA_def_property(srna, "show_brush_on_surface", PROP_BOOLEAN, PROP_NONE);
667   RNA_def_property_boolean_sdna(prop, NULL, "flags", PAINT_SHOW_BRUSH_ON_SURFACE);
668   RNA_def_property_ui_text(prop, "Show Brush On Surface", "");
669   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
670
671   prop = RNA_def_property(srna, "show_low_resolution", PROP_BOOLEAN, PROP_NONE);
672   RNA_def_property_boolean_sdna(prop, NULL, "flags", PAINT_FAST_NAVIGATE);
673   RNA_def_property_ui_text(
674       prop, "Fast Navigate", "For multires, show low resolution while navigating the view");
675   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
676
677   prop = RNA_def_property(srna, "input_samples", PROP_INT, PROP_UNSIGNED);
678   RNA_def_property_int_sdna(prop, NULL, "num_input_samples");
679   RNA_def_property_ui_range(prop, 1, PAINT_MAX_INPUT_SAMPLES, 0, -1);
680   RNA_def_property_ui_text(
681       prop, "Input Samples", "Average multiple input samples together to smooth the brush stroke");
682   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
683
684   prop = RNA_def_property(srna, "use_symmetry_x", PROP_BOOLEAN, PROP_NONE);
685   RNA_def_property_boolean_sdna(prop, NULL, "symmetry_flags", PAINT_SYMM_X);
686   RNA_def_property_ui_text(prop, "Symmetry X", "Mirror brush across the X axis");
687   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
688
689   prop = RNA_def_property(srna, "use_symmetry_y", PROP_BOOLEAN, PROP_NONE);
690   RNA_def_property_boolean_sdna(prop, NULL, "symmetry_flags", PAINT_SYMM_Y);
691   RNA_def_property_ui_text(prop, "Symmetry Y", "Mirror brush across the Y axis");
692   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
693
694   prop = RNA_def_property(srna, "use_symmetry_z", PROP_BOOLEAN, PROP_NONE);
695   RNA_def_property_boolean_sdna(prop, NULL, "symmetry_flags", PAINT_SYMM_Z);
696   RNA_def_property_ui_text(prop, "Symmetry Z", "Mirror brush across the Z axis");
697   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
698
699   prop = RNA_def_property(srna, "use_symmetry_feather", PROP_BOOLEAN, PROP_NONE);
700   RNA_def_property_boolean_sdna(prop, NULL, "symmetry_flags", PAINT_SYMMETRY_FEATHER);
701   RNA_def_property_ui_text(prop,
702                            "Symmetry Feathering",
703                            "Reduce the strength of the brush where it overlaps symmetrical daubs");
704   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
705
706   prop = RNA_def_property(srna, "cavity_curve", PROP_POINTER, PROP_NONE);
707   RNA_def_property_flag(prop, PROP_NEVER_NULL);
708   RNA_def_property_ui_text(prop, "Curve", "Editable cavity curve");
709   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
710
711   prop = RNA_def_property(srna, "use_cavity", PROP_BOOLEAN, PROP_NONE);
712   RNA_def_property_boolean_sdna(prop, NULL, "flags", PAINT_USE_CAVITY_MASK);
713   RNA_def_property_ui_text(prop, "Cavity Mask", "Mask painting according to mesh geometry cavity");
714   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
715
716   prop = RNA_def_property(srna, "tile_offset", PROP_FLOAT, PROP_XYZ);
717   RNA_def_property_float_sdna(prop, NULL, "tile_offset");
718   RNA_def_property_array(prop, 3);
719   RNA_def_property_range(prop, 0.01, FLT_MAX);
720   RNA_def_property_ui_range(prop, 0.01, 100, 1 * 100, 2);
721   RNA_def_property_ui_text(
722       prop, "Tiling offset for the X Axis", "Stride at which tiled strokes are copied");
723
724   prop = RNA_def_property(srna, "tile_x", PROP_BOOLEAN, PROP_NONE);
725   RNA_def_property_boolean_sdna(prop, NULL, "symmetry_flags", PAINT_TILE_X);
726   RNA_def_property_ui_text(prop, "Tile X", "Tile along X axis");
727   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
728
729   prop = RNA_def_property(srna, "tile_y", PROP_BOOLEAN, PROP_NONE);
730   RNA_def_property_boolean_sdna(prop, NULL, "symmetry_flags", PAINT_TILE_Y);
731   RNA_def_property_ui_text(prop, "Tile Y", "Tile along Y axis");
732   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
733
734   prop = RNA_def_property(srna, "tile_z", PROP_BOOLEAN, PROP_NONE);
735   RNA_def_property_boolean_sdna(prop, NULL, "symmetry_flags", PAINT_TILE_Z);
736   RNA_def_property_ui_text(prop, "Tile Z", "Tile along Z axis");
737   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
738 }
739
740 static void rna_def_sculpt(BlenderRNA *brna)
741 {
742   static const EnumPropertyItem detail_refine_items[] = {
743       {SCULPT_DYNTOPO_SUBDIVIDE,
744        "SUBDIVIDE",
745        0,
746        "Subdivide Edges",
747        "Subdivide long edges to add mesh detail where needed"},
748       {SCULPT_DYNTOPO_COLLAPSE,
749        "COLLAPSE",
750        0,
751        "Collapse Edges",
752        "Collapse short edges to remove mesh detail where possible"},
753       {SCULPT_DYNTOPO_SUBDIVIDE | SCULPT_DYNTOPO_COLLAPSE,
754        "SUBDIVIDE_COLLAPSE",
755        0,
756        "Subdivide Collapse",
757        "Both subdivide long edges and collapse short edges to refine mesh detail"},
758       {0, NULL, 0, NULL, NULL},
759   };
760
761   static const EnumPropertyItem detail_type_items[] = {
762       {0,
763        "RELATIVE",
764        0,
765        "Relative Detail",
766        "Mesh detail is relative to the brush size and detail size"},
767       {SCULPT_DYNTOPO_DETAIL_CONSTANT,
768        "CONSTANT",
769        0,
770        "Constant Detail",
771        "Mesh detail is constant in world space according to detail size"},
772       {SCULPT_DYNTOPO_DETAIL_BRUSH,
773        "BRUSH",
774        0,
775        "Brush Detail",
776        "Mesh detail is relative to brush radius"},
777       {SCULPT_DYNTOPO_DETAIL_MANUAL,
778        "MANUAL",
779        0,
780        "Manual Detail",
781        "Mesh detail does not change on each stroke, only when using Flood Fill"},
782       {0, NULL, 0, NULL, NULL},
783   };
784
785   StructRNA *srna;
786   PropertyRNA *prop;
787
788   srna = RNA_def_struct(brna, "Sculpt", "Paint");
789   RNA_def_struct_path_func(srna, "rna_Sculpt_path");
790   RNA_def_struct_ui_text(srna, "Sculpt", "");
791
792   prop = RNA_def_property(srna, "radial_symmetry", PROP_INT, PROP_XYZ);
793   RNA_def_property_int_sdna(prop, NULL, "radial_symm");
794   RNA_def_property_int_default(prop, 1);
795   RNA_def_property_range(prop, 1, 64);
796   RNA_def_property_ui_range(prop, 0, 32, 1, 1);
797   RNA_def_property_ui_text(
798       prop, "Radial Symmetry Count X Axis", "Number of times to copy strokes across the surface");
799
800   prop = RNA_def_property(srna, "lock_x", PROP_BOOLEAN, PROP_NONE);
801   RNA_def_property_boolean_sdna(prop, NULL, "flags", SCULPT_LOCK_X);
802   RNA_def_property_ui_text(prop, "Lock X", "Disallow changes to the X axis of vertices");
803   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
804
805   prop = RNA_def_property(srna, "lock_y", PROP_BOOLEAN, PROP_NONE);
806   RNA_def_property_boolean_sdna(prop, NULL, "flags", SCULPT_LOCK_Y);
807   RNA_def_property_ui_text(prop, "Lock Y", "Disallow changes to the Y axis of vertices");
808   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
809
810   prop = RNA_def_property(srna, "lock_z", PROP_BOOLEAN, PROP_NONE);
811   RNA_def_property_boolean_sdna(prop, NULL, "flags", SCULPT_LOCK_Z);
812   RNA_def_property_ui_text(prop, "Lock Z", "Disallow changes to the Z axis of vertices");
813   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
814
815   prop = RNA_def_property(srna, "use_threaded", PROP_BOOLEAN, PROP_NONE);
816   RNA_def_property_boolean_sdna(prop, NULL, "flags", SCULPT_USE_OPENMP);
817   RNA_def_property_ui_text(
818       prop, "Use OpenMP", "Take advantage of multiple CPU cores to improve sculpting performance");
819   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
820
821   prop = RNA_def_property(srna, "use_deform_only", PROP_BOOLEAN, PROP_NONE);
822   RNA_def_property_boolean_sdna(prop, NULL, "flags", SCULPT_ONLY_DEFORM);
823   RNA_def_property_ui_text(prop,
824                            "Use Deform Only",
825                            "Use only deformation modifiers (temporary disable all "
826                            "constructive modifiers except multi-resolution)");
827   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
828   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Sculpt_update");
829
830   prop = RNA_def_property(srna, "show_diffuse_color", PROP_BOOLEAN, PROP_NONE);
831   RNA_def_property_boolean_sdna(prop, NULL, "flags", SCULPT_SHOW_DIFFUSE);
832   RNA_def_property_ui_text(prop,
833                            "Show Diffuse Color",
834                            "Show diffuse color of object and overlay sculpt mask on top of it");
835   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
836   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Sculpt_ShowDiffuseColor_update");
837
838   prop = RNA_def_property(srna, "show_mask", PROP_BOOLEAN, PROP_NONE);
839   RNA_def_property_boolean_negative_sdna(prop, NULL, "flags", SCULPT_HIDE_MASK);
840   RNA_def_property_ui_text(prop, "Show Mask", "Show mask as overlay on object");
841   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
842   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Sculpt_ShowMask_update");
843
844   prop = RNA_def_property(srna, "detail_size", PROP_FLOAT, PROP_PIXEL);
845   RNA_def_property_ui_range(prop, 0.5, 40.0, 10, 2);
846   RNA_def_property_ui_text(
847       prop, "Detail Size", "Maximum edge length for dynamic topology sculpting (in pixels)");
848   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
849
850   prop = RNA_def_property(srna, "detail_percent", PROP_FLOAT, PROP_PERCENTAGE);
851   RNA_def_property_ui_range(prop, 0.5, 100.0, 10, 2);
852   RNA_def_property_ui_text(
853       prop,
854       "Detail Percentage",
855       "Maximum edge length for dynamic topology sculpting (in brush percenage)");
856   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
857
858   prop = RNA_def_property(srna, "constant_detail_resolution", PROP_FLOAT, PROP_NONE);
859   RNA_def_property_float_sdna(prop, NULL, "constant_detail");
860   RNA_def_property_range(prop, 0.0001, FLT_MAX);
861   RNA_def_property_ui_range(prop, 0.001, 1000.0, 10, 2);
862   RNA_def_property_ui_text(prop,
863                            "Resolution",
864                            "Maximum edge length for dynamic topology sculpting (as divisor "
865                            "of blender unit - higher value means smaller edge length)");
866   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
867
868   prop = RNA_def_property(srna, "use_smooth_shading", PROP_BOOLEAN, PROP_NONE);
869   RNA_def_property_boolean_sdna(prop, NULL, "flags", SCULPT_DYNTOPO_SMOOTH_SHADING);
870   RNA_def_property_ui_text(prop,
871                            "Smooth Shading",
872                            "Show faces in dynamic-topology mode with smooth "
873                            "shading rather than flat shaded");
874   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
875   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Sculpt_update");
876
877   prop = RNA_def_property(srna, "symmetrize_direction", PROP_ENUM, PROP_NONE);
878   RNA_def_property_enum_items(prop, rna_enum_symmetrize_direction_items);
879   RNA_def_property_ui_text(prop, "Direction", "Source and destination for symmetrize operator");
880
881   prop = RNA_def_property(srna, "detail_refine_method", PROP_ENUM, PROP_NONE);
882   RNA_def_property_enum_bitflag_sdna(prop, NULL, "flags");
883   RNA_def_property_enum_items(prop, detail_refine_items);
884   RNA_def_property_ui_text(
885       prop, "Detail Refine Method", "In dynamic-topology mode, how to add or remove mesh detail");
886   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
887
888   prop = RNA_def_property(srna, "detail_type_method", PROP_ENUM, PROP_NONE);
889   RNA_def_property_enum_bitflag_sdna(prop, NULL, "flags");
890   RNA_def_property_enum_items(prop, detail_type_items);
891   RNA_def_property_ui_text(
892       prop, "Detail Type Method", "In dynamic-topology mode, how mesh detail size is calculated");
893   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
894
895   prop = RNA_def_property(srna, "gravity", PROP_FLOAT, PROP_FACTOR);
896   RNA_def_property_float_sdna(prop, NULL, "gravity_factor");
897   RNA_def_property_range(prop, 0.0f, 1.0f);
898   RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.1, 3);
899   RNA_def_property_ui_text(prop, "Gravity", "Amount of gravity after each dab");
900   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
901
902   prop = RNA_def_property(srna, "gravity_object", PROP_POINTER, PROP_NONE);
903   RNA_def_property_flag(prop, PROP_EDITABLE);
904   RNA_def_property_ui_text(
905       prop, "Orientation", "Object whose Z axis defines orientation of gravity");
906   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
907 }
908
909 static void rna_def_uv_sculpt(BlenderRNA *brna)
910 {
911   StructRNA *srna;
912
913   srna = RNA_def_struct(brna, "UvSculpt", "Paint");
914   RNA_def_struct_path_func(srna, "rna_UvSculpt_path");
915   RNA_def_struct_ui_text(srna, "UV Sculpting", "");
916 }
917
918 static void rna_def_gp_paint(BlenderRNA *brna)
919 {
920   StructRNA *srna;
921
922   srna = RNA_def_struct(brna, "GpPaint", "Paint");
923   RNA_def_struct_path_func(srna, "rna_GpPaint_path");
924   RNA_def_struct_ui_text(srna, "Grease Pencil Paint", "");
925 }
926
927 /* use for weight paint too */
928 static void rna_def_vertex_paint(BlenderRNA *brna)
929 {
930   StructRNA *srna;
931   PropertyRNA *prop;
932
933   srna = RNA_def_struct(brna, "VertexPaint", "Paint");
934   RNA_def_struct_sdna(srna, "VPaint");
935   RNA_def_struct_path_func(srna, "rna_VertexPaint_path");
936   RNA_def_struct_ui_text(srna, "Vertex Paint", "Properties of vertex and weight paint mode");
937
938   /* weight paint only */
939   prop = RNA_def_property(srna, "use_group_restrict", PROP_BOOLEAN, PROP_NONE);
940   RNA_def_property_boolean_sdna(prop, NULL, "flag", VP_FLAG_VGROUP_RESTRICT);
941   RNA_def_property_ui_text(prop, "Restrict", "Restrict painting to vertices in the group");
942   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
943
944   /* Mirroring */
945   prop = RNA_def_property(srna, "radial_symmetry", PROP_INT, PROP_XYZ);
946   RNA_def_property_int_sdna(prop, NULL, "radial_symm");
947   RNA_def_property_int_default(prop, 1);
948   RNA_def_property_range(prop, 1, 64);
949   RNA_def_property_ui_range(prop, 1, 32, 1, 1);
950   RNA_def_property_ui_text(
951       prop, "Radial Symmetry Count X Axis", "Number of times to copy strokes across the surface");
952 }
953
954 static void rna_def_image_paint(BlenderRNA *brna)
955 {
956   StructRNA *srna;
957   PropertyRNA *prop;
958   FunctionRNA *func;
959
960   static const EnumPropertyItem paint_type_items[] = {
961       {IMAGEPAINT_MODE_MATERIAL,
962        "MATERIAL",
963        0,
964        "Material",
965        "Detect image slots from the material"},
966       {IMAGEPAINT_MODE_IMAGE,
967        "IMAGE",
968        0,
969        "Single Image",
970        "Set image for texture painting directly"},
971       {0, NULL, 0, NULL, NULL},
972   };
973
974   static const EnumPropertyItem paint_interp_items[] = {
975       {IMAGEPAINT_INTERP_LINEAR, "LINEAR", 0, "Linear", "Linear interpolation"},
976       {IMAGEPAINT_INTERP_CLOSEST,
977        "CLOSEST",
978        0,
979        "Closest",
980        "No interpolation (sample closest texel)"},
981       {0, NULL, 0, NULL, NULL},
982   };
983
984   srna = RNA_def_struct(brna, "ImagePaint", "Paint");
985   RNA_def_struct_sdna(srna, "ImagePaintSettings");
986   RNA_def_struct_path_func(srna, "rna_ImagePaintSettings_path");
987   RNA_def_struct_ui_text(srna, "Image Paint", "Properties of image and texture painting mode");
988
989   /* functions */
990   func = RNA_def_function(srna, "detect_data", "rna_ImaPaint_detect_data");
991   RNA_def_function_ui_description(func, "Check if required texpaint data exist");
992
993   /* return type */
994   RNA_def_function_return(func, RNA_def_boolean(func, "ok", 1, "", ""));
995
996   /* booleans */
997   prop = RNA_def_property(srna, "use_occlude", PROP_BOOLEAN, PROP_NONE);
998   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", IMAGEPAINT_PROJECT_XRAY);
999   RNA_def_property_ui_text(
1000       prop, "Occlude", "Only paint onto the faces directly under the brush (slower)");
1001   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1002
1003   prop = RNA_def_property(srna, "use_backface_culling", PROP_BOOLEAN, PROP_NONE);
1004   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", IMAGEPAINT_PROJECT_BACKFACE);
1005   RNA_def_property_ui_text(prop, "Cull", "Ignore faces pointing away from the view (faster)");
1006   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1007
1008   prop = RNA_def_property(srna, "use_normal_falloff", PROP_BOOLEAN, PROP_NONE);
1009   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", IMAGEPAINT_PROJECT_FLAT);
1010   RNA_def_property_ui_text(prop, "Normal", "Paint most on faces pointing towards the view");
1011   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1012
1013   prop = RNA_def_property(srna, "use_stencil_layer", PROP_BOOLEAN, PROP_NONE);
1014   RNA_def_property_boolean_sdna(prop, NULL, "flag", IMAGEPAINT_PROJECT_LAYER_STENCIL);
1015   RNA_def_property_ui_text(prop, "Stencil Layer", "Set the mask layer from the UV map buttons");
1016   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_viewport_update");
1017
1018   prop = RNA_def_property(srna, "invert_stencil", PROP_BOOLEAN, PROP_NONE);
1019   RNA_def_property_boolean_sdna(prop, NULL, "flag", IMAGEPAINT_PROJECT_LAYER_STENCIL_INV);
1020   RNA_def_property_ui_text(prop, "Invert", "Invert the stencil layer");
1021   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_viewport_update");
1022
1023   prop = RNA_def_property(srna, "stencil_image", PROP_POINTER, PROP_NONE);
1024   RNA_def_property_pointer_sdna(prop, NULL, "stencil");
1025   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_CONTEXT_UPDATE);
1026   RNA_def_property_ui_text(prop, "Stencil Image", "Image used as stencil");
1027   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_stencil_update");
1028
1029   prop = RNA_def_property(srna, "canvas", PROP_POINTER, PROP_NONE);
1030   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_CONTEXT_UPDATE);
1031   RNA_def_property_ui_text(prop, "Canvas", "Image used as canvas");
1032   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_canvas_update");
1033
1034   prop = RNA_def_property(srna, "clone_image", PROP_POINTER, PROP_NONE);
1035   RNA_def_property_pointer_sdna(prop, NULL, "clone");
1036   RNA_def_property_flag(prop, PROP_EDITABLE);
1037   RNA_def_property_ui_text(prop, "Clone Image", "Image used as clone source");
1038   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1039
1040   prop = RNA_def_property(srna, "stencil_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1041   RNA_def_property_range(prop, 0.0, 1.0);
1042   RNA_def_property_float_sdna(prop, NULL, "stencil_col");
1043   RNA_def_property_ui_text(prop, "Stencil Color", "Stencil color in the viewport");
1044   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_viewport_update");
1045
1046   prop = RNA_def_property(srna, "dither", PROP_FLOAT, PROP_NONE);
1047   RNA_def_property_range(prop, 0.0, 2.0);
1048   RNA_def_property_ui_text(prop, "Dither", "Amount of dithering when painting on byte images");
1049   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1050
1051   prop = RNA_def_property(srna, "use_clone_layer", PROP_BOOLEAN, PROP_NONE);
1052   RNA_def_property_boolean_sdna(prop, NULL, "flag", IMAGEPAINT_PROJECT_LAYER_CLONE);
1053   RNA_def_property_ui_text(
1054       prop,
1055       "Clone Map",
1056       "Use another UV map as clone source, otherwise use the 3D cursor as the source");
1057   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_viewport_update");
1058
1059   /* integers */
1060
1061   prop = RNA_def_property(srna, "seam_bleed", PROP_INT, PROP_PIXEL);
1062   RNA_def_property_ui_range(prop, 0, 8, 0, -1);
1063   RNA_def_property_ui_text(
1064       prop, "Bleed", "Extend paint beyond the faces UVs to reduce seams (in pixels, slower)");
1065
1066   prop = RNA_def_property(srna, "normal_angle", PROP_INT, PROP_UNSIGNED);
1067   RNA_def_property_range(prop, 0, 90);
1068   RNA_def_property_ui_text(
1069       prop, "Angle", "Paint most on faces pointing towards the view according to this angle");
1070
1071   prop = RNA_def_int_array(srna,
1072                            "screen_grab_size",
1073                            2,
1074                            NULL,
1075                            0,
1076                            0,
1077                            "screen_grab_size",
1078                            "Size to capture the image for re-projecting",
1079                            0,
1080                            0);
1081   RNA_def_property_range(prop, 512, 16384);
1082
1083   prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
1084   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
1085   RNA_def_property_enum_items(prop, paint_type_items);
1086   RNA_def_property_ui_text(prop, "Mode", "Mode of operation for projection painting");
1087   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_mode_update");
1088
1089   prop = RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
1090   RNA_def_property_enum_sdna(prop, NULL, "interp");
1091   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
1092   RNA_def_property_enum_items(prop, paint_interp_items);
1093   RNA_def_property_ui_text(prop, "Interpolation", "Texture filtering type");
1094   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_mode_update");
1095
1096   /* Missing data */
1097   prop = RNA_def_property(srna, "missing_uvs", PROP_BOOLEAN, PROP_NONE);
1098   RNA_def_property_boolean_sdna(prop, NULL, "missing_data", IMAGEPAINT_MISSING_UVS);
1099   RNA_def_property_ui_text(prop, "Missing UVs", "A UV layer is missing on the mesh");
1100   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1101
1102   prop = RNA_def_property(srna, "missing_materials", PROP_BOOLEAN, PROP_NONE);
1103   RNA_def_property_boolean_sdna(prop, NULL, "missing_data", IMAGEPAINT_MISSING_MATERIAL);
1104   RNA_def_property_ui_text(prop, "Missing Materials", "The mesh is missing materials");
1105   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1106
1107   prop = RNA_def_property(srna, "missing_stencil", PROP_BOOLEAN, PROP_NONE);
1108   RNA_def_property_boolean_sdna(prop, NULL, "missing_data", IMAGEPAINT_MISSING_STENCIL);
1109   RNA_def_property_ui_text(prop, "Missing Stencil", "Image Painting does not have a stencil");
1110   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1111
1112   prop = RNA_def_property(srna, "missing_texture", PROP_BOOLEAN, PROP_NONE);
1113   RNA_def_property_boolean_sdna(prop, NULL, "missing_data", IMAGEPAINT_MISSING_TEX);
1114   RNA_def_property_ui_text(
1115       prop, "Missing Texture", "Image Painting does not have a texture to paint on");
1116   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1117 }
1118
1119 static void rna_def_particle_edit(BlenderRNA *brna)
1120 {
1121   StructRNA *srna;
1122   PropertyRNA *prop;
1123
1124   static const EnumPropertyItem select_mode_items[] = {
1125       {SCE_SELECT_PATH, "PATH", ICON_PARTICLE_PATH, "Path", "Path edit mode"},
1126       {SCE_SELECT_POINT, "POINT", ICON_PARTICLE_POINT, "Point", "Point select mode"},
1127       {SCE_SELECT_END, "TIP", ICON_PARTICLE_TIP, "Tip", "Tip select mode"},
1128       {0, NULL, 0, NULL, NULL},
1129   };
1130
1131   static const EnumPropertyItem puff_mode[] = {
1132       {0, "ADD", 0, "Add", "Make hairs more puffy"},
1133       {1, "SUB", 0, "Sub", "Make hairs less puffy"},
1134       {0, NULL, 0, NULL, NULL},
1135   };
1136
1137   static const EnumPropertyItem length_mode[] = {
1138       {0, "GROW", 0, "Grow", "Make hairs longer"},
1139       {1, "SHRINK", 0, "Shrink", "Make hairs shorter"},
1140       {0, NULL, 0, NULL, NULL},
1141   };
1142
1143   static const EnumPropertyItem edit_type_items[] = {
1144       {PE_TYPE_PARTICLES, "PARTICLES", 0, "Particles", ""},
1145       {PE_TYPE_SOFTBODY, "SOFT_BODY", 0, "Soft body", ""},
1146       {PE_TYPE_CLOTH, "CLOTH", 0, "Cloth", ""},
1147       {0, NULL, 0, NULL, NULL},
1148   };
1149
1150   /* edit */
1151
1152   srna = RNA_def_struct(brna, "ParticleEdit", NULL);
1153   RNA_def_struct_sdna(srna, "ParticleEditSettings");
1154   RNA_def_struct_path_func(srna, "rna_ParticleEdit_path");
1155   RNA_def_struct_ui_text(srna, "Particle Edit", "Properties of particle editing mode");
1156
1157   prop = RNA_def_property(srna, "tool", PROP_ENUM, PROP_NONE);
1158   RNA_def_property_enum_sdna(prop, NULL, "brushtype");
1159   RNA_def_property_enum_items(prop, rna_enum_particle_edit_hair_brush_items);
1160   RNA_def_property_enum_funcs(
1161       prop, NULL, "rna_ParticleEdit_tool_set", "rna_ParticleEdit_tool_itemf");
1162   RNA_def_property_ui_text(prop, "Tool", "");
1163
1164   prop = RNA_def_property(srna, "select_mode", PROP_ENUM, PROP_NONE);
1165   RNA_def_property_enum_bitflag_sdna(prop, NULL, "selectmode");
1166   RNA_def_property_enum_items(prop, select_mode_items);
1167   RNA_def_property_ui_text(prop, "Selection Mode", "Particle select and display mode");
1168   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
1169   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_ParticleEdit_update");
1170
1171   prop = RNA_def_property(srna, "use_preserve_length", PROP_BOOLEAN, PROP_NONE);
1172   RNA_def_property_boolean_sdna(prop, NULL, "flag", PE_KEEP_LENGTHS);
1173   RNA_def_property_ui_text(prop, "Keep Lengths", "Keep path lengths constant");
1174
1175   prop = RNA_def_property(srna, "use_preserve_root", PROP_BOOLEAN, PROP_NONE);
1176   RNA_def_property_boolean_sdna(prop, NULL, "flag", PE_LOCK_FIRST);
1177   RNA_def_property_ui_text(prop, "Keep Root", "Keep root keys unmodified");
1178
1179   prop = RNA_def_property(srna, "use_emitter_deflect", PROP_BOOLEAN, PROP_NONE);
1180   RNA_def_property_boolean_sdna(prop, NULL, "flag", PE_DEFLECT_EMITTER);
1181   RNA_def_property_ui_text(prop, "Deflect Emitter", "Keep paths from intersecting the emitter");
1182
1183   prop = RNA_def_property(srna, "emitter_distance", PROP_FLOAT, PROP_DISTANCE);
1184   RNA_def_property_float_sdna(prop, NULL, "emitterdist");
1185   RNA_def_property_ui_range(prop, 0.0f, 10.0f, 10, 3);
1186   RNA_def_property_ui_text(
1187       prop, "Emitter Distance", "Distance to keep particles away from the emitter");
1188
1189   prop = RNA_def_property(srna, "use_fade_time", PROP_BOOLEAN, PROP_NONE);
1190   RNA_def_property_boolean_sdna(prop, NULL, "flag", PE_FADE_TIME);
1191   RNA_def_property_ui_text(
1192       prop, "Fade Time", "Fade paths and keys further away from current frame");
1193   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
1194   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_ParticleEdit_update");
1195
1196   prop = RNA_def_property(srna, "use_auto_velocity", PROP_BOOLEAN, PROP_NONE);
1197   RNA_def_property_boolean_sdna(prop, NULL, "flag", PE_AUTO_VELOCITY);
1198   RNA_def_property_ui_text(prop, "Auto Velocity", "Calculate point velocities automatically");
1199
1200   prop = RNA_def_property(srna, "show_particles", PROP_BOOLEAN, PROP_NONE);
1201   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
1202   RNA_def_property_boolean_sdna(prop, NULL, "flag", PE_DRAW_PART);
1203   RNA_def_property_ui_text(prop, "Display Particles", "Display actual particles");
1204   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_ParticleEdit_redo");
1205
1206   prop = RNA_def_property(srna, "use_default_interpolate", PROP_BOOLEAN, PROP_NONE);
1207   RNA_def_property_boolean_sdna(prop, NULL, "flag", PE_INTERPOLATE_ADDED);
1208   RNA_def_property_ui_text(
1209       prop, "Interpolate", "Interpolate new particles from the existing ones");
1210
1211   prop = RNA_def_property(srna, "default_key_count", PROP_INT, PROP_NONE);
1212   RNA_def_property_int_sdna(prop, NULL, "totaddkey");
1213   RNA_def_property_range(prop, 2, SHRT_MAX);
1214   RNA_def_property_ui_range(prop, 2, 20, 10, 3);
1215   RNA_def_property_ui_text(prop, "Keys", "How many keys to make new particles with");
1216
1217   prop = RNA_def_property(srna, "brush", PROP_POINTER, PROP_NONE);
1218   RNA_def_property_struct_type(prop, "ParticleBrush");
1219   RNA_def_property_pointer_funcs(prop, "rna_ParticleEdit_brush_get", NULL, NULL, NULL);
1220   RNA_def_property_ui_text(prop, "Brush", "");
1221
1222   prop = RNA_def_property(srna, "display_step", PROP_INT, PROP_NONE);
1223   RNA_def_property_int_sdna(prop, NULL, "draw_step");
1224   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
1225   RNA_def_property_range(prop, 1, 10);
1226   RNA_def_property_ui_text(prop, "Steps", "How many steps to display the path with");
1227   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_ParticleEdit_redo");
1228
1229   prop = RNA_def_property(srna, "fade_frames", PROP_INT, PROP_NONE);
1230   RNA_def_property_range(prop, 1, 100);
1231   RNA_def_property_ui_text(prop, "Frames", "How many frames to fade");
1232   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
1233   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_ParticleEdit_update");
1234
1235   prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1236   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
1237   RNA_def_property_enum_sdna(prop, NULL, "edittype");
1238   RNA_def_property_enum_items(prop, edit_type_items);
1239   RNA_def_property_ui_text(prop, "Type", "");
1240   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_ParticleEdit_redo");
1241
1242   prop = RNA_def_property(srna, "is_editable", PROP_BOOLEAN, PROP_NONE);
1243   RNA_def_property_boolean_funcs(prop, "rna_ParticleEdit_editable_get", NULL);
1244   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1245   RNA_def_property_ui_text(prop, "Editable", "A valid edit mode exists");
1246
1247   prop = RNA_def_property(srna, "is_hair", PROP_BOOLEAN, PROP_NONE);
1248   RNA_def_property_boolean_funcs(prop, "rna_ParticleEdit_hair_get", NULL);
1249   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1250   RNA_def_property_ui_text(prop, "Hair", "Editing hair");
1251
1252   prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
1253   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1254   RNA_def_property_ui_text(prop, "Object", "The edited object");
1255
1256   prop = RNA_def_property(srna, "shape_object", PROP_POINTER, PROP_NONE);
1257   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_CONTEXT_UPDATE);
1258   RNA_def_property_ui_text(prop, "Shape Object", "Outer shape to use for tools");
1259   RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, "rna_Mesh_object_poll");
1260   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_ParticleEdit_redo");
1261
1262   /* brush */
1263
1264   srna = RNA_def_struct(brna, "ParticleBrush", NULL);
1265   RNA_def_struct_sdna(srna, "ParticleBrushData");
1266   RNA_def_struct_path_func(srna, "rna_ParticleBrush_path");
1267   RNA_def_struct_ui_text(srna, "Particle Brush", "Particle editing brush");
1268
1269   prop = RNA_def_property(srna, "size", PROP_INT, PROP_PIXEL);
1270   RNA_def_property_range(prop, 1, SHRT_MAX);
1271   RNA_def_property_ui_range(prop, 1, MAX_BRUSH_PIXEL_RADIUS, 10, 3);
1272   RNA_def_property_ui_text(prop, "Radius", "Radius of the brush in pixels");
1273
1274   prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_FACTOR);
1275   RNA_def_property_range(prop, 0.001, 1.0);
1276   RNA_def_property_ui_text(prop, "Strength", "Brush strength");
1277
1278   prop = RNA_def_property(srna, "count", PROP_INT, PROP_NONE);
1279   RNA_def_property_range(prop, 1, 1000);
1280   RNA_def_property_ui_range(prop, 1, 100, 10, 3);
1281   RNA_def_property_ui_text(prop, "Count", "Particle count");
1282
1283   prop = RNA_def_property(srna, "steps", PROP_INT, PROP_NONE);
1284   RNA_def_property_int_sdna(prop, NULL, "step");
1285   RNA_def_property_range(prop, 1, SHRT_MAX);
1286   RNA_def_property_ui_range(prop, 1, 50, 10, 3);
1287   RNA_def_property_ui_text(prop, "Steps", "Brush steps");
1288
1289   prop = RNA_def_property(srna, "puff_mode", PROP_ENUM, PROP_NONE);
1290   RNA_def_property_enum_sdna(prop, NULL, "invert");
1291   RNA_def_property_enum_items(prop, puff_mode);
1292   RNA_def_property_ui_text(prop, "Puff Mode", "");
1293
1294   prop = RNA_def_property(srna, "use_puff_volume", PROP_BOOLEAN, PROP_NONE);
1295   RNA_def_property_boolean_sdna(prop, NULL, "flag", PE_BRUSH_DATA_PUFF_VOLUME);
1296   RNA_def_property_ui_text(
1297       prop,
1298       "Puff Volume",
1299       "Apply puff to unselected end-points (helps maintain hair volume when puffing root)");
1300
1301   prop = RNA_def_property(srna, "length_mode", PROP_ENUM, PROP_NONE);
1302   RNA_def_property_enum_sdna(prop, NULL, "invert");
1303   RNA_def_property_enum_items(prop, length_mode);
1304   RNA_def_property_ui_text(prop, "Length Mode", "");
1305
1306   /* dummy */
1307   prop = RNA_def_property(srna, "curve", PROP_POINTER, PROP_NONE);
1308   RNA_def_property_struct_type(prop, "CurveMapping");
1309   RNA_def_property_pointer_funcs(prop, "rna_ParticleBrush_curve_get", NULL, NULL, NULL);
1310   RNA_def_property_ui_text(prop, "Curve", "");
1311 }
1312
1313 /* srna -- gpencil speed guides */
1314 static void rna_def_gpencil_guides(BlenderRNA *brna)
1315 {
1316   StructRNA *srna;
1317   PropertyRNA *prop;
1318
1319   srna = RNA_def_struct(brna, "GPencilSculptGuide", NULL);
1320   RNA_def_struct_sdna(srna, "GP_Sculpt_Guide");
1321   RNA_def_struct_path_func(srna, "rna_GPencilSculptGuide_path");
1322   RNA_def_struct_ui_text(srna, "GPencil Sculpt Guide", "Guides for drawing");
1323
1324   static const EnumPropertyItem prop_gpencil_guidetypes[] = {
1325       {GP_GUIDE_CIRCULAR, "CIRCULAR", 0, "Circular", "Use single point to create rings"},
1326       {GP_GUIDE_RADIAL, "RADIAL", 0, "Radial", "Use single point as direction"},
1327       {GP_GUIDE_PARALLEL, "PARALLEL", 0, "Parallel", "Parallel lines"},
1328       {GP_GUIDE_GRID, "GRID", 0, "Grid", "Grid allows horizontal and vertical lines"},
1329       {0, NULL, 0, NULL, NULL},
1330   };
1331
1332   static const EnumPropertyItem prop_gpencil_guide_references[] = {
1333       {GP_GUIDE_REF_CURSOR, "CURSOR", 0, "Cursor", "Use cursor as reference point"},
1334       {GP_GUIDE_REF_CUSTOM, "CUSTOM", 0, "Custom", "Use custom reference point"},
1335       {GP_GUIDE_REF_OBJECT, "OBJECT", 0, "Object", "Use object as reference point"},
1336       {0, NULL, 0, NULL, NULL},
1337   };
1338
1339   prop = RNA_def_property(srna, "use_guide", PROP_BOOLEAN, PROP_NONE);
1340   RNA_def_property_boolean_sdna(prop, NULL, "use_guide", false);
1341   RNA_def_property_boolean_default(prop, false);
1342   RNA_def_property_ui_text(prop, "Use Guides", "Enable speed guides");
1343   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1344   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1345
1346   prop = RNA_def_property(srna, "use_snapping", PROP_BOOLEAN, PROP_NONE);
1347   RNA_def_property_boolean_sdna(prop, NULL, "use_snapping", false);
1348   RNA_def_property_boolean_default(prop, false);
1349   RNA_def_property_ui_text(
1350       prop, "Use Snapping", "Enable snapping to guides angle or spacing options");
1351   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1352   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1353
1354   prop = RNA_def_property(srna, "reference_object", PROP_POINTER, PROP_NONE);
1355   RNA_def_property_pointer_sdna(prop, NULL, "reference_object");
1356   RNA_def_property_ui_text(prop, "Object", "Object used for reference point");
1357   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
1358   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_viewport_update");
1359
1360   prop = RNA_def_property(srna, "reference_point", PROP_ENUM, PROP_NONE);
1361   RNA_def_property_enum_sdna(prop, NULL, "reference_point");
1362   RNA_def_property_enum_items(prop, prop_gpencil_guide_references);
1363   RNA_def_property_ui_text(prop, "Type", "Type of speed guide");
1364   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1365   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_viewport_update");
1366
1367   prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1368   RNA_def_property_enum_sdna(prop, NULL, "type");
1369   RNA_def_property_enum_items(prop, prop_gpencil_guidetypes);
1370   RNA_def_property_ui_text(prop, "Type", "Type of speed guide");
1371   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1372   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1373
1374   prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
1375   RNA_def_property_float_sdna(prop, NULL, "angle");
1376   RNA_def_property_range(prop, -(M_PI * 2.0f), (M_PI * 2.0f));
1377   RNA_def_property_ui_text(prop, "Angle", "Direction of lines");
1378   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1379   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1380
1381   prop = RNA_def_property(srna, "angle_snap", PROP_FLOAT, PROP_ANGLE);
1382   RNA_def_property_float_sdna(prop, NULL, "angle_snap");
1383   RNA_def_property_range(prop, -(M_PI * 2.0f), (M_PI * 2.0f));
1384   RNA_def_property_ui_text(prop, "Angle Snap", "Angle snapping");
1385   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1386   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1387
1388   prop = RNA_def_property(srna, "spacing", PROP_FLOAT, PROP_DISTANCE);
1389   RNA_def_property_float_sdna(prop, NULL, "spacing");
1390   RNA_def_property_float_default(prop, 0.01f);
1391   RNA_def_property_range(prop, 0.0f, FLT_MAX);
1392   RNA_def_property_ui_range(prop, 0.0f, FLT_MAX, 1, 3);
1393   RNA_def_property_ui_text(prop, "Spacing", "Guide spacing");
1394   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1395   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1396
1397   prop = RNA_def_property(srna, "location", PROP_FLOAT, PROP_DISTANCE);
1398   RNA_def_property_float_sdna(prop, NULL, "location");
1399   RNA_def_property_array(prop, 3);
1400   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1401   RNA_def_property_ui_text(prop, "Location", "Custom reference point for guides");
1402   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
1403   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, 3);
1404   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_viewport_update");
1405 }
1406
1407 static void rna_def_gpencil_sculpt(BlenderRNA *brna)
1408 {
1409   static const EnumPropertyItem prop_direction_items[] = {
1410       {0, "ADD", ICON_ADD, "Add", "Add effect of brush"},
1411       {GP_SCULPT_FLAG_INVERT, "SUBTRACT", ICON_REMOVE, "Subtract", "Subtract effect of brush"},
1412       {0, NULL, 0, NULL, NULL},
1413   };
1414
1415   StructRNA *srna;
1416   PropertyRNA *prop;
1417
1418   /* == Settings == */
1419   srna = RNA_def_struct(brna, "GPencilSculptSettings", NULL);
1420   RNA_def_struct_sdna(srna, "GP_Sculpt_Settings");
1421   RNA_def_struct_path_func(srna, "rna_GPencilSculptSettings_path");
1422   RNA_def_struct_ui_text(
1423       srna, "GPencil Sculpt Settings", "Properties for Grease Pencil stroke sculpting tool");
1424
1425   prop = RNA_def_property(srna, "sculpt_tool", PROP_ENUM, PROP_NONE);
1426   RNA_def_property_enum_sdna(prop, NULL, "brushtype");
1427   RNA_def_property_enum_items(prop, rna_enum_gpencil_sculpt_brush_items);
1428   RNA_def_property_ui_text(prop, "Tool", "");
1429   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1430   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_GPencil_update");
1431
1432   prop = RNA_def_property(srna, "weight_tool", PROP_ENUM, PROP_NONE);
1433   RNA_def_property_enum_sdna(prop, NULL, "weighttype");
1434   RNA_def_property_enum_items(prop, rna_enum_gpencil_weight_brush_items);
1435   RNA_def_property_ui_text(prop, "Tool", "Tool for weight painting");
1436   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1437   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_GPencil_update");
1438
1439   prop = RNA_def_property(srna, "brush", PROP_POINTER, PROP_NONE);
1440   RNA_def_property_struct_type(prop, "GPencilSculptBrush");
1441   RNA_def_property_pointer_funcs(prop, "rna_GPencilSculptSettings_brush_get", NULL, NULL, NULL);
1442   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1443   RNA_def_property_ui_text(prop, "Brush", "");
1444
1445   prop = RNA_def_property(srna, "guide", PROP_POINTER, PROP_NONE);
1446   RNA_def_property_struct_type(prop, "GPencilSculptGuide");
1447   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1448   RNA_def_property_ui_text(prop, "Guide", "");
1449
1450   prop = RNA_def_property(srna, "use_select_mask", PROP_BOOLEAN, PROP_NONE);
1451   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_SETT_FLAG_SELECT_MASK);
1452   RNA_def_property_ui_text(prop, "Selection Mask", "Only sculpt selected stroke points");
1453   RNA_def_property_ui_icon(prop, ICON_GP_ONLY_SELECTED, 0);
1454   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1455   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1456
1457   prop = RNA_def_property(srna, "use_edit_position", PROP_BOOLEAN, PROP_NONE);
1458   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_SETT_FLAG_APPLY_POSITION);
1459   RNA_def_property_ui_text(prop, "Affect Position", "The brush affects the position of the point");
1460   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1461   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1462
1463   prop = RNA_def_property(srna, "use_edit_strength", PROP_BOOLEAN, PROP_NONE);
1464   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_SETT_FLAG_APPLY_STRENGTH);
1465   RNA_def_property_ui_text(
1466       prop, "Affect Strength", "The brush affects the color strength of the point");
1467   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1468   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1469
1470   prop = RNA_def_property(srna, "use_edit_thickness", PROP_BOOLEAN, PROP_NONE);
1471   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_SETT_FLAG_APPLY_THICKNESS);
1472   RNA_def_property_ui_text(
1473       prop, "Affect Thickness", "The brush affects the thickness of the point");
1474   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1475   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1476
1477   prop = RNA_def_property(srna, "use_edit_uv", PROP_BOOLEAN, PROP_NONE);
1478   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_SETT_FLAG_APPLY_UV);
1479   RNA_def_property_ui_text(prop, "Affect UV", "The brush affects the UV rotation of the point");
1480   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1481   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1482
1483   prop = RNA_def_property(srna, "use_multiframe_falloff", PROP_BOOLEAN, PROP_NONE);
1484   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_SETT_FLAG_FRAME_FALLOFF);
1485   RNA_def_property_ui_text(
1486       prop,
1487       "Use Falloff",
1488       "Use falloff effect when edit in multiframe mode to compute brush effect by frame");
1489   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1490   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1491
1492   prop = RNA_def_property(srna, "use_thickness_curve", PROP_BOOLEAN, PROP_NONE);
1493   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_SETT_FLAG_PRIMITIVE_CURVE);
1494   RNA_def_property_ui_text(prop, "Use Curve", "Use curve to define primitive stroke thickness");
1495   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1496   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1497
1498   /* custom falloff curve */
1499   prop = RNA_def_property(srna, "multiframe_falloff_curve", PROP_POINTER, PROP_NONE);
1500   RNA_def_property_pointer_sdna(prop, NULL, "cur_falloff");
1501   RNA_def_property_struct_type(prop, "CurveMapping");
1502   RNA_def_property_ui_text(
1503       prop, "Curve", "Custom curve to control falloff of brush effect by Grease Pencil frames");
1504   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1505   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1506
1507   /* custom primitive curve */
1508   prop = RNA_def_property(srna, "thickness_primitive_curve", PROP_POINTER, PROP_NONE);
1509   RNA_def_property_pointer_sdna(prop, NULL, "cur_primitive");
1510   RNA_def_property_struct_type(prop, "CurveMapping");
1511   RNA_def_property_ui_text(prop, "Curve", "Custom curve to control primitive thickness");
1512   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1513   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1514
1515   /* lock axis */
1516   prop = RNA_def_property(srna, "lock_axis", PROP_ENUM, PROP_NONE);
1517   RNA_def_property_enum_sdna(prop, NULL, "lock_axis");
1518   RNA_def_property_enum_items(prop, rna_enum_gpencil_lock_axis_items);
1519   RNA_def_property_ui_text(prop, "Lock Axis", "");
1520   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1521   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1522
1523   /* threshold for cutter */
1524   prop = RNA_def_property(srna, "intersection_threshold", PROP_FLOAT, PROP_NONE);
1525   RNA_def_property_float_sdna(prop, NULL, "isect_threshold");
1526   RNA_def_property_range(prop, 0.0f, 10.0f);
1527   RNA_def_property_float_default(prop, 0.1f);
1528   RNA_def_property_ui_text(prop, "Threshold", "Threshold for stroke intersections");
1529   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1530
1531   /* brush */
1532   srna = RNA_def_struct(brna, "GPencilSculptBrush", NULL);
1533   RNA_def_struct_sdna(srna, "GP_Sculpt_Data");
1534   RNA_def_struct_path_func(srna, "rna_GPencilSculptBrush_path");
1535   RNA_def_struct_ui_text(srna, "GPencil Sculpt Brush", "Stroke editing brush");
1536
1537   prop = RNA_def_property(srna, "size", PROP_INT, PROP_PIXEL);
1538   RNA_def_property_range(prop, 1, GP_MAX_BRUSH_PIXEL_RADIUS);
1539   RNA_def_property_ui_range(prop, 1, 500, 10, 3);
1540   RNA_def_property_ui_text(prop, "Radius", "Radius of the brush in pixels");
1541   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1542   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1543
1544   prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_FACTOR);
1545   RNA_def_property_range(prop, 0.001, 1.0);
1546   RNA_def_property_ui_text(prop, "Strength", "Brush strength");
1547   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1548   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1549
1550   prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_FACTOR);
1551   RNA_def_property_range(prop, 0.0, 1.0);
1552   RNA_def_property_ui_text(prop,
1553                            "Weight",
1554                            "Target weight (define a maximum range limit for the weight. Any value "
1555                            "above will be clamped)");
1556   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1557   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1558
1559   prop = RNA_def_property(srna, "use_pressure_strength", PROP_BOOLEAN, PROP_NONE);
1560   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_FLAG_USE_PRESSURE);
1561   RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1562   RNA_def_property_ui_text(
1563       prop, "Strength Pressure", "Enable tablet pressure sensitivity for strength");
1564   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1565   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1566
1567   prop = RNA_def_property(srna, "use_pressure_radius", PROP_BOOLEAN, PROP_NONE);
1568   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_FLAG_PRESSURE_RADIUS);
1569   RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1570   RNA_def_property_ui_text(
1571       prop, "Radius Pressure", "Enable tablet pressure sensitivity for radius");
1572   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1573   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1574
1575   prop = RNA_def_property(srna, "use_falloff", PROP_BOOLEAN, PROP_NONE);
1576   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_FLAG_USE_FALLOFF);
1577   RNA_def_property_ui_text(
1578       prop, "Use Falloff", "Strength of brush decays with distance from cursor");
1579   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1580   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1581
1582   prop = RNA_def_property(srna, "use_edit_pressure", PROP_BOOLEAN, PROP_NONE);
1583   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_FLAG_SMOOTH_PRESSURE);
1584   RNA_def_property_ui_text(
1585       prop, "Affect Pressure", "Affect pressure values as well when smoothing strokes");
1586   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1587   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1588
1589   prop = RNA_def_property(srna, "direction", PROP_ENUM, PROP_NONE);
1590   RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
1591   RNA_def_property_enum_items(prop, prop_direction_items);
1592   RNA_def_property_ui_text(prop, "Direction", "");
1593   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1594   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1595
1596   /* Cursor Color */
1597   static float default_1[3] = {1.0f, 0.6f, 0.6f};
1598   static float default_2[3] = {0.6f, 0.6f, 1.0f};
1599
1600   prop = RNA_def_property(srna, "cursor_color_add", PROP_FLOAT, PROP_COLOR_GAMMA);
1601   RNA_def_property_float_sdna(prop, NULL, "curcolor_add");
1602   RNA_def_property_array(prop, 3);
1603   RNA_def_property_range(prop, 0.0f, 1.0f);
1604   RNA_def_property_float_array_default(prop, default_1);
1605   RNA_def_property_ui_text(prop, "Cursor Add", "Color for the cursor for addition");
1606   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1607
1608   prop = RNA_def_property(srna, "cursor_color_sub", PROP_FLOAT, PROP_COLOR_GAMMA);
1609   RNA_def_property_float_sdna(prop, NULL, "curcolor_sub");
1610   RNA_def_property_array(prop, 3);
1611   RNA_def_property_range(prop, 0.0f, 1.0f);
1612   RNA_def_property_float_array_default(prop, default_2);
1613   RNA_def_property_ui_text(prop, "Cursor Sub", "Color for the cursor for subtraction");
1614   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1615
1616   prop = RNA_def_property(srna, "use_cursor", PROP_BOOLEAN, PROP_NONE);
1617   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_FLAG_ENABLE_CURSOR);
1618   RNA_def_property_boolean_default(prop, true);
1619   RNA_def_property_ui_text(prop, "Enable Cursor", "Enable cursor on screen");
1620   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1621 }
1622
1623 void RNA_def_sculpt_paint(BlenderRNA *brna)
1624 {
1625   /* *** Non-Animated *** */
1626   RNA_define_animate_sdna(false);
1627   rna_def_paint_curve(brna);
1628   rna_def_paint_tool_slot(brna);
1629   rna_def_paint(brna);
1630   rna_def_sculpt(brna);
1631   rna_def_uv_sculpt(brna);
1632   rna_def_gp_paint(brna);
1633   rna_def_vertex_paint(brna);
1634   rna_def_image_paint(brna);
1635   rna_def_particle_edit(brna);
1636   rna_def_gpencil_guides(brna);
1637   rna_def_gpencil_sculpt(brna);
1638   RNA_define_animate_sdna(true);
1639 }
1640
1641 #endif