GP: Add RNA path function for gp brush settings
[blender.git] / source / blender / makesrna / intern / rna_brush.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Blender Foundation (2008), Juho Veps�l�inen
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/makesrna/intern/rna_brush.c
24  *  \ingroup RNA
25  */
26
27 #include <stdlib.h>
28 #include <assert.h>
29
30 #include "DNA_brush_types.h"
31 #include "DNA_texture_types.h"
32 #include "DNA_scene_types.h"
33 #include "DNA_object_types.h"
34 #include "DNA_workspace_types.h"
35 #include "DNA_gpencil_types.h"
36
37 #include "BLI_math.h"
38
39 #include "RNA_define.h"
40 #include "RNA_enum_types.h"
41
42 #include "rna_internal.h"
43
44 #include "IMB_imbuf.h"
45
46 #include "WM_types.h"
47
48 static const EnumPropertyItem prop_direction_items[] = {
49         {0, "ADD", ICON_ADD, "Add", "Add effect of brush"},
50         {BRUSH_DIR_IN, "SUBTRACT", ICON_REMOVE, "Subtract", "Subtract effect of brush"},
51         {0, NULL, 0, NULL, NULL}
52 };
53
54 static const EnumPropertyItem sculpt_stroke_method_items[] = {
55         {0, "DOTS", 0, "Dots", "Apply paint on each mouse move step"},
56         {BRUSH_DRAG_DOT, "DRAG_DOT", 0, "Drag Dot", "Allows a single dot to be carefully positioned"},
57         {BRUSH_SPACE, "SPACE", 0, "Space", "Limit brush application to the distance specified by spacing"},
58         {BRUSH_AIRBRUSH, "AIRBRUSH", 0, "Airbrush", "Keep applying paint effect while holding mouse (spray)"},
59         {BRUSH_ANCHORED, "ANCHORED", 0, "Anchored", "Keep the brush anchored to the initial location"},
60         {BRUSH_LINE, "LINE", 0, "Line", "Draw a line with dabs separated according to spacing"},
61         {BRUSH_CURVE, "CURVE", 0, "Curve",
62                       "Define the stroke curve with a bezier curve (dabs are separated according to spacing)"},
63         {0, NULL, 0, NULL, NULL}
64 };
65
66
67 const EnumPropertyItem rna_enum_brush_sculpt_tool_items[] = {
68         {SCULPT_TOOL_BLOB, "BLOB", ICON_BRUSH_BLOB, "Blob", ""},
69         {SCULPT_TOOL_CLAY, "CLAY", ICON_BRUSH_CLAY, "Clay", ""},
70         {SCULPT_TOOL_CLAY_STRIPS, "CLAY_STRIPS", ICON_BRUSH_CLAY_STRIPS, "Clay Strips", ""},
71         {SCULPT_TOOL_CREASE, "CREASE", ICON_BRUSH_CREASE, "Crease", ""},
72         {SCULPT_TOOL_DRAW, "DRAW", ICON_BRUSH_SCULPT_DRAW, "Draw", ""},
73         {SCULPT_TOOL_FILL, "FILL", ICON_BRUSH_FILL, "Fill", ""},
74         {SCULPT_TOOL_FLATTEN, "FLATTEN", ICON_BRUSH_FLATTEN, "Flatten", ""},
75         {SCULPT_TOOL_GRAB, "GRAB", ICON_BRUSH_GRAB, "Grab", ""},
76         {SCULPT_TOOL_INFLATE, "INFLATE", ICON_BRUSH_INFLATE, "Inflate", ""},
77         {SCULPT_TOOL_LAYER, "LAYER", ICON_BRUSH_LAYER, "Layer", ""},
78         {SCULPT_TOOL_MASK, "MASK", ICON_BRUSH_MASK, "Mask", ""},
79         {SCULPT_TOOL_NUDGE, "NUDGE", ICON_BRUSH_NUDGE, "Nudge", ""},
80         {SCULPT_TOOL_PINCH, "PINCH", ICON_BRUSH_PINCH, "Pinch", ""},
81         {SCULPT_TOOL_ROTATE, "ROTATE", ICON_BRUSH_ROTATE, "Rotate", ""},
82         {SCULPT_TOOL_SCRAPE, "SCRAPE", ICON_BRUSH_SCRAPE, "Scrape", ""},
83         {SCULPT_TOOL_SIMPLIFY, "SIMPLIFY", ICON_BRUSH_SUBTRACT /* icon TODO */, "Simplify", ""},
84         {SCULPT_TOOL_SMOOTH, "SMOOTH", ICON_BRUSH_SMOOTH, "Smooth", ""},
85         {SCULPT_TOOL_SNAKE_HOOK, "SNAKE_HOOK", ICON_BRUSH_SNAKE_HOOK, "Snake Hook", ""},
86         {SCULPT_TOOL_THUMB, "THUMB", ICON_BRUSH_THUMB, "Thumb", ""},
87         {0, NULL, 0, NULL, NULL}
88 };
89
90
91 const EnumPropertyItem rna_enum_brush_vertex_tool_items[] = {
92         {PAINT_BLEND_MIX, "MIX", ICON_BRUSH_MIX, "Mix", "Use mix blending mode while painting"},
93         {PAINT_BLEND_ADD, "ADD", ICON_BRUSH_ADD, "Add", "Use add blending mode while painting"},
94         {PAINT_BLEND_SUB, "SUB", ICON_BRUSH_SUBTRACT, "Subtract", "Use subtract blending mode while painting"},
95         {PAINT_BLEND_MUL, "MUL", ICON_BRUSH_MULTIPLY, "Multiply", "Use multiply blending mode while painting"},
96         {PAINT_BLEND_BLUR, "BLUR", ICON_BRUSH_BLUR, "Blur", "Blur the color with surrounding values"},
97         {PAINT_BLEND_LIGHTEN, "LIGHTEN", ICON_BRUSH_LIGHTEN, "Lighten", "Use lighten blending mode while painting"},
98         {PAINT_BLEND_DARKEN, "DARKEN", ICON_BRUSH_DARKEN, "Darken", "Use darken blending mode while painting"},
99         {PAINT_BLEND_AVERAGE, "AVERAGE", ICON_BRUSH_BLUR, "Average", "Use average blending mode while painting"},
100         {PAINT_BLEND_SMEAR, "SMEAR", ICON_BRUSH_BLUR, "Smear", "Use smear blending mode while painting"},
101         {PAINT_BLEND_COLORDODGE, "COLORDODGE", ICON_BRUSH_BLUR, "Color Dodge", "Use color dodge blending mode while painting" },
102         {PAINT_BLEND_DIFFERENCE, "DIFFERENCE", ICON_BRUSH_BLUR, "Difference", "Use difference blending mode while painting"},
103         {PAINT_BLEND_SCREEN, "SCREEN", ICON_BRUSH_BLUR, "Screen", "Use screen blending mode while painting"},
104         {PAINT_BLEND_HARDLIGHT, "HARDLIGHT", ICON_BRUSH_BLUR, "Hardlight", "Use hardlight blending mode while painting"},
105         {PAINT_BLEND_OVERLAY, "OVERLAY", ICON_BRUSH_BLUR, "Overlay", "Use overlay blending mode while painting"},
106         {PAINT_BLEND_SOFTLIGHT, "SOFTLIGHT", ICON_BRUSH_BLUR, "Softlight", "Use softlight blending mode while painting"},
107         {PAINT_BLEND_EXCLUSION, "EXCLUSION", ICON_BRUSH_BLUR, "Exclusion", "Use exclusion blending mode while painting"},
108         {PAINT_BLEND_LUMINOCITY, "LUMINOCITY", ICON_BRUSH_BLUR, "Luminocity", "Use luminocity blending mode while painting"},
109         {PAINT_BLEND_SATURATION, "SATURATION", ICON_BRUSH_BLUR, "Saturation", "Use saturation blending mode while painting"},
110         {PAINT_BLEND_HUE, "HUE", ICON_BRUSH_BLUR, "Hue", "Use hue blending mode while painting"},
111         {PAINT_BLEND_ALPHA_SUB, "ERASE_ALPHA", 0, "Erase Alpha", "Erase alpha while painting"},
112         {PAINT_BLEND_ALPHA_ADD, "ADD_ALPHA", 0, "Add Alpha", "Add alpha while painting"},
113
114         {0, NULL, 0, NULL, NULL}
115 };
116
117 const EnumPropertyItem rna_enum_brush_image_tool_items[] = {
118         {PAINT_TOOL_DRAW, "DRAW", ICON_BRUSH_TEXDRAW, "Draw", ""},
119         {PAINT_TOOL_SOFTEN, "SOFTEN", ICON_BRUSH_SOFTEN, "Soften", ""},
120         {PAINT_TOOL_SMEAR, "SMEAR", ICON_BRUSH_SMEAR, "Smear", ""},
121         {PAINT_TOOL_CLONE, "CLONE", ICON_BRUSH_CLONE, "Clone", ""},
122         {PAINT_TOOL_FILL, "FILL", ICON_BRUSH_TEXFILL, "Fill", ""},
123         {PAINT_TOOL_MASK, "MASK", ICON_BRUSH_TEXMASK, "Mask", ""},
124         {0, NULL, 0, NULL, NULL}
125 };
126
127 #ifndef RNA_RUNTIME
128 static EnumPropertyItem rna_enum_gpencil_brush_types_items[] = {
129         { GP_BRUSH_TYPE_DRAW, "DRAW", ICON_GREASEPENCIL_STROKE_PAINT, "Draw", "The brush is of type used for drawing strokes" },
130         { GP_BRUSH_TYPE_FILL, "FILL", ICON_COLOR, "Fill", "The brush is of type used for filling areas" },
131         { GP_BRUSH_TYPE_ERASE, "ERASE", ICON_PANEL_CLOSE, "Erase", "The brush is used for erasing strokes" },
132         { 0, NULL, 0, NULL, NULL }
133 };
134
135 static EnumPropertyItem rna_enum_gpencil_brush_eraser_modes_items[] = {
136         { GP_BRUSH_ERASER_SOFT, "SOFT", 0, "Soft", "Use soft eraser" },
137         { GP_BRUSH_ERASER_HARD, "HARD", 0, "Hard", "Use hard eraser" },
138         { GP_BRUSH_ERASER_STROKE, "STROKE", 0, "Stroke", "Use stroke eraser" },
139         { 0, NULL, 0, NULL, NULL }
140 };
141
142 static EnumPropertyItem rna_enum_gpencil_fill_draw_modes_items[] = {
143         { GP_FILL_DMODE_STROKE, "STROKE", 0, "Strokes", "Use visible strokes as fill boundary limits" },
144         { GP_FILL_DMODE_CONTROL, "CONTROL", 0, "Control", "Use internal control lines as fill boundary limits" },
145         { GP_FILL_DMODE_BOTH, "BOTH", 0, "Both", "Use visible strokes and control lines as fill boundary limits" },
146         { 0, NULL, 0, NULL, NULL }
147 };
148
149 static EnumPropertyItem rna_enum_gpencil_brush_icons_items[] = {
150         { GP_BRUSH_ICON_PENCIL, "PENCIL", ICON_GPBRUSH_PENCIL, "Pencil", "" },
151         { GP_BRUSH_ICON_PEN, "PEN", ICON_GPBRUSH_PEN, "Pen", "" },
152         { GP_BRUSH_ICON_INK, "INK", ICON_GPBRUSH_INK, "Ink", "" },
153         { GP_BRUSH_ICON_INKNOISE, "INKNOISE", ICON_GPBRUSH_INKNOISE, "Ink Noise", "" },
154         { GP_BRUSH_ICON_BLOCK, "BLOCK", ICON_GPBRUSH_BLOCK, "Block", "" },
155         { GP_BRUSH_ICON_MARKER, "MARKER", ICON_GPBRUSH_MARKER, "Marker", "" },
156         { GP_BRUSH_ICON_FILL, "FILL", ICON_GPBRUSH_FILL, "Fill", "" },
157         { GP_BRUSH_ICON_ERASE_SOFT, "SOFT", ICON_GPBRUSH_ERASE_SOFT, "Eraser Soft", "" },
158         { GP_BRUSH_ICON_ERASE_HARD, "HARD", ICON_GPBRUSH_ERASE_HARD, "Eraser Hard", "" },
159         { GP_BRUSH_ICON_ERASE_STROKE, "STROKE", ICON_GPBRUSH_ERASE_STROKE, "Eraser Stroke", "" },
160         { 0, NULL, 0, NULL, NULL }
161 };
162 #endif
163
164
165 #ifdef RNA_RUNTIME
166
167 #include "MEM_guardedalloc.h"
168
169 #include "RNA_access.h"
170
171 #include "BKE_colorband.h"
172 #include "BKE_brush.h"
173 #include "BKE_icons.h"
174 #include "BKE_gpencil.h"
175 #include "BKE_paint.h"
176
177 #include "WM_api.h"
178
179 static bool rna_SculptToolCapabilities_has_accumulate_get(PointerRNA *ptr)
180 {
181         Brush *br = (Brush *)ptr->data;
182         return SCULPT_TOOL_HAS_ACCUMULATE(br->sculpt_tool);
183 }
184
185 static bool rna_SculptToolCapabilities_has_auto_smooth_get(PointerRNA *ptr)
186 {
187         Brush *br = (Brush *)ptr->data;
188         return !ELEM(br->sculpt_tool, SCULPT_TOOL_MASK, SCULPT_TOOL_SMOOTH);
189 }
190
191 static bool rna_SculptToolCapabilities_has_height_get(PointerRNA *ptr)
192 {
193         Brush *br = (Brush *)ptr->data;
194         return br->sculpt_tool == SCULPT_TOOL_LAYER;
195 }
196
197 static bool rna_SculptToolCapabilities_has_jitter_get(PointerRNA *ptr)
198 {
199         Brush *br = (Brush *)ptr->data;
200         return (!(br->flag & BRUSH_ANCHORED) &&
201                 !(br->flag & BRUSH_DRAG_DOT) &&
202                 !ELEM(br->sculpt_tool,
203                       SCULPT_TOOL_GRAB, SCULPT_TOOL_ROTATE,
204                       SCULPT_TOOL_SNAKE_HOOK, SCULPT_TOOL_THUMB));
205 }
206
207 static bool rna_SculptToolCapabilities_has_normal_weight_get(PointerRNA *ptr)
208 {
209         Brush *br = (Brush *)ptr->data;
210         return SCULPT_TOOL_HAS_NORMAL_WEIGHT(br->sculpt_tool);
211 }
212
213 static bool rna_SculptToolCapabilities_has_rake_factor_get(PointerRNA *ptr)
214 {
215         Brush *br = (Brush *)ptr->data;
216         return SCULPT_TOOL_HAS_RAKE(br->sculpt_tool);
217 }
218
219 static bool rna_BrushCapabilities_has_overlay_get(PointerRNA *ptr)
220 {
221         Brush *br = (Brush *)ptr->data;
222         return ELEM(br->mtex.brush_map_mode,
223                     MTEX_MAP_MODE_VIEW,
224                     MTEX_MAP_MODE_TILED,
225                     MTEX_MAP_MODE_STENCIL);
226 }
227
228 static bool rna_SculptToolCapabilities_has_persistence_get(PointerRNA *ptr)
229 {
230         Brush *br = (Brush *)ptr->data;
231         return br->sculpt_tool == SCULPT_TOOL_LAYER;
232 }
233
234 static bool rna_SculptToolCapabilities_has_pinch_factor_get(PointerRNA *ptr)
235 {
236         Brush *br = (Brush *)ptr->data;
237         return ELEM(br->sculpt_tool, SCULPT_TOOL_BLOB, SCULPT_TOOL_CREASE, SCULPT_TOOL_SNAKE_HOOK);
238 }
239
240 static bool rna_SculptToolCapabilities_has_plane_offset_get(PointerRNA *ptr)
241 {
242         Brush *br = (Brush *)ptr->data;
243         return ELEM(br->sculpt_tool, SCULPT_TOOL_CLAY, SCULPT_TOOL_CLAY_STRIPS,
244                     SCULPT_TOOL_FILL, SCULPT_TOOL_FLATTEN, SCULPT_TOOL_SCRAPE);
245 }
246
247 static bool rna_SculptToolCapabilities_has_random_texture_angle_get(PointerRNA *ptr)
248 {
249         Brush *br = (Brush *)ptr->data;
250         return (!ELEM(br->sculpt_tool,
251                       SCULPT_TOOL_GRAB, SCULPT_TOOL_ROTATE,
252                       SCULPT_TOOL_SNAKE_HOOK, SCULPT_TOOL_THUMB));
253 }
254
255 static bool rna_TextureCapabilities_has_random_texture_angle_get(PointerRNA *ptr)
256 {
257         MTex *mtex = (MTex *)ptr->data;
258         return ELEM(mtex->brush_map_mode,
259                      MTEX_MAP_MODE_VIEW,
260                      MTEX_MAP_MODE_AREA,
261                      MTEX_MAP_MODE_RANDOM);
262 }
263
264
265 static bool rna_BrushCapabilities_has_random_texture_angle_get(PointerRNA *ptr)
266 {
267         Brush *br = (Brush *)ptr->data;
268         return !(br->flag & BRUSH_ANCHORED);
269 }
270
271 static bool rna_SculptToolCapabilities_has_sculpt_plane_get(PointerRNA *ptr)
272 {
273         Brush *br = (Brush *)ptr->data;
274         return !ELEM(br->sculpt_tool, SCULPT_TOOL_INFLATE,
275                      SCULPT_TOOL_MASK, SCULPT_TOOL_PINCH,
276                      SCULPT_TOOL_SMOOTH);
277 }
278
279 static bool rna_SculptToolCapabilities_has_secondary_color_get(PointerRNA *ptr)
280 {
281         Brush *br = (Brush *)ptr->data;
282         return BKE_brush_sculpt_has_secondary_color(br);
283 }
284
285 static bool rna_SculptToolCapabilities_has_smooth_stroke_get(PointerRNA *ptr)
286 {
287         Brush *br = (Brush *)ptr->data;
288         return (!(br->flag & BRUSH_ANCHORED) &&
289                 !(br->flag & BRUSH_DRAG_DOT) &&
290                 !(br->flag & BRUSH_LINE) &&
291                 !(br->flag & BRUSH_CURVE) &&
292                 !ELEM(br->sculpt_tool,
293                        SCULPT_TOOL_GRAB, SCULPT_TOOL_ROTATE,
294                        SCULPT_TOOL_SNAKE_HOOK, SCULPT_TOOL_THUMB));
295 }
296
297 static bool rna_BrushCapabilities_has_smooth_stroke_get(PointerRNA *ptr)
298 {
299         Brush *br = (Brush *)ptr->data;
300         return (!(br->flag & BRUSH_ANCHORED) &&
301                 !(br->flag & BRUSH_DRAG_DOT) &&
302                 !(br->flag & BRUSH_LINE) &&
303                 !(br->flag & BRUSH_CURVE));
304 }
305
306 static bool rna_SculptToolCapabilities_has_space_attenuation_get(PointerRNA *ptr)
307 {
308         Brush *br = (Brush *)ptr->data;
309         return ((br->flag & (BRUSH_SPACE | BRUSH_LINE | BRUSH_CURVE)) &&
310                 !ELEM(br->sculpt_tool, SCULPT_TOOL_GRAB, SCULPT_TOOL_ROTATE,
311                        SCULPT_TOOL_SMOOTH, SCULPT_TOOL_SNAKE_HOOK));
312 }
313
314 static bool rna_ImapaintToolCapabilities_has_space_attenuation_get(PointerRNA *ptr)
315 {
316         Brush *br = (Brush *)ptr->data;
317         return (br->flag & (BRUSH_SPACE | BRUSH_LINE | BRUSH_CURVE)) &&
318                 br->imagepaint_tool != PAINT_TOOL_FILL;
319 }
320
321 static bool rna_BrushCapabilities_has_spacing_get(PointerRNA *ptr)
322 {
323         Brush *br = (Brush *)ptr->data;
324         return (!(br->flag & BRUSH_ANCHORED));
325 }
326
327 static bool rna_SculptToolCapabilities_has_strength_pressure_get(PointerRNA *ptr)
328 {
329         Brush *br = (Brush *)ptr->data;
330         return !ELEM(br->sculpt_tool, SCULPT_TOOL_GRAB, SCULPT_TOOL_SNAKE_HOOK);
331 }
332
333 static bool rna_TextureCapabilities_has_texture_angle_get(PointerRNA *ptr)
334 {
335         MTex *mtex = (MTex *)ptr->data;
336         return mtex->brush_map_mode != MTEX_MAP_MODE_3D;
337 }
338
339 static bool rna_SculptToolCapabilities_has_gravity_get(PointerRNA *ptr)
340 {
341         Brush *br = (Brush *)ptr->data;
342         return !ELEM(br->sculpt_tool, SCULPT_TOOL_MASK, SCULPT_TOOL_SMOOTH);
343 }
344
345 static bool rna_TextureCapabilities_has_texture_angle_source_get(PointerRNA *ptr)
346 {
347         MTex *mtex = (MTex *)ptr->data;
348         return ELEM(mtex->brush_map_mode,
349                     MTEX_MAP_MODE_VIEW,
350                     MTEX_MAP_MODE_AREA,
351                     MTEX_MAP_MODE_RANDOM);
352 }
353
354 static bool rna_ImapaintToolCapabilities_has_accumulate_get(PointerRNA *ptr)
355 {
356         /* only support for draw tool */
357         Brush *br = (Brush *)ptr->data;
358
359         return ((br->flag & BRUSH_AIRBRUSH) ||
360                 (br->flag & BRUSH_DRAG_DOT) ||
361                 (br->flag & BRUSH_ANCHORED) ||
362                 (br->imagepaint_tool == PAINT_TOOL_SOFTEN) ||
363                 (br->imagepaint_tool == PAINT_TOOL_SMEAR) ||
364                 (br->imagepaint_tool == PAINT_TOOL_FILL) ||
365                 (br->mtex.tex && !ELEM(br->mtex.brush_map_mode, MTEX_MAP_MODE_TILED, MTEX_MAP_MODE_STENCIL, MTEX_MAP_MODE_3D))
366                 ) ? false : true;
367 }
368
369 static bool rna_ImapaintToolCapabilities_has_radius_get(PointerRNA *ptr)
370 {
371         /* only support for draw tool */
372         Brush *br = (Brush *)ptr->data;
373
374         return (br->imagepaint_tool != PAINT_TOOL_FILL);
375 }
376
377
378 static PointerRNA rna_Sculpt_tool_capabilities_get(PointerRNA *ptr)
379 {
380         return rna_pointer_inherit_refine(ptr, &RNA_SculptToolCapabilities, ptr->id.data);
381 }
382
383 static PointerRNA rna_Imapaint_tool_capabilities_get(PointerRNA *ptr)
384 {
385         return rna_pointer_inherit_refine(ptr, &RNA_ImapaintToolCapabilities, ptr->id.data);
386 }
387
388 static PointerRNA rna_Brush_capabilities_get(PointerRNA *ptr)
389 {
390         return rna_pointer_inherit_refine(ptr, &RNA_BrushCapabilities, ptr->id.data);
391 }
392
393 static void rna_Brush_reset_icon(Brush *br, const char *UNUSED(type))
394 {
395         ID *id = &br->id;
396
397         if (br->flag & BRUSH_CUSTOM_ICON)
398                 return;
399
400         if (id->icon_id >= BIFICONID_LAST) {
401                 BKE_icon_id_delete(id);
402                 BKE_previewimg_id_free(id);
403         }
404
405         id->icon_id = 0;
406 }
407
408 static void rna_Brush_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
409 {
410         Brush *br = (Brush *)ptr->data;
411         WM_main_add_notifier(NC_BRUSH | NA_EDITED, br);
412         /*WM_main_add_notifier(NC_SPACE|ND_SPACE_VIEW3D, NULL); */
413 }
414
415 static void rna_Brush_material_update(bContext *C, PointerRNA *ptr)
416 {
417         Main *bmain = CTX_data_main(C);
418         ViewLayer *view_layer = CTX_data_view_layer(C);
419         Object *ob = OBACT(view_layer);
420         Brush *br = (Brush *)ptr->id.data;
421         int index;
422
423         /* set material slot to same material */
424         if ((ob) && (ob->type == OB_GPENCIL) && (br->gpencil_settings != NULL)) {
425                 BrushGpencilSettings *gpencil_settings = br->gpencil_settings;
426                 if (gpencil_settings->material != NULL) {
427
428                         index = BKE_gpencil_get_material_index(ob, gpencil_settings->material);
429                         if ((index > 0) && (ob->actcol != index)) {
430                                 ob->actcol = index;
431                                 /* update other brushes to keep all synchro */
432                                 BKE_brush_update_material(bmain, gpencil_settings->material, br);
433                         }
434
435                 }
436                 WM_main_add_notifier(NC_SPACE | ND_SPACE_PROPERTIES, NULL);
437         }
438 }
439
440 static void rna_Brush_main_tex_update(bContext *C, PointerRNA *ptr)
441 {
442         Main *bmain = CTX_data_main(C);
443         Scene *scene = CTX_data_scene(C);
444         ViewLayer *view_layer = CTX_data_view_layer(C);
445         Brush *br = (Brush *)ptr->data;
446         BKE_paint_invalidate_overlay_tex(scene, view_layer, br->mtex.tex);
447         rna_Brush_update(bmain, scene, ptr);
448 }
449
450 static void rna_Brush_secondary_tex_update(bContext *C, PointerRNA *ptr)
451 {
452         Main *bmain = CTX_data_main(C);
453         Scene *scene = CTX_data_scene(C);
454         ViewLayer *view_layer = CTX_data_view_layer(C);
455         Brush *br = (Brush *)ptr->data;
456         BKE_paint_invalidate_overlay_tex(scene, view_layer, br->mask_mtex.tex);
457         rna_Brush_update(bmain, scene, ptr);
458 }
459
460 static void rna_Brush_size_update(Main *bmain, Scene *scene, PointerRNA *ptr)
461 {
462         BKE_paint_invalidate_overlay_all();
463         rna_Brush_update(bmain, scene, ptr);
464 }
465
466 static void rna_Brush_sculpt_tool_update(Main *bmain, Scene *scene, PointerRNA *ptr)
467 {
468         Brush *br = (Brush *)ptr->data;
469         rna_Brush_reset_icon(br, "sculpt");
470         rna_Brush_update(bmain, scene, ptr);
471 }
472
473 static void rna_Brush_vertex_tool_update(Main *bmain, Scene *scene, PointerRNA *ptr)
474 {
475         Brush *br = (Brush *)ptr->data;
476         rna_Brush_reset_icon(br, "vertex_paint");
477         rna_Brush_update(bmain, scene, ptr);
478 }
479
480 static void rna_Brush_imagepaint_tool_update(Main *bmain, Scene *scene, PointerRNA *ptr)
481 {
482         Brush *br = (Brush *)ptr->data;
483         rna_Brush_reset_icon(br, "image_paint");
484         rna_Brush_update(bmain, scene, ptr);
485 }
486
487 static void rna_Brush_stroke_update(Main *bmain, Scene *scene, PointerRNA *ptr)
488 {
489         WM_main_add_notifier(NC_SCENE | ND_TOOLSETTINGS, scene);
490         rna_Brush_update(bmain, scene, ptr);
491 }
492
493 static void rna_Brush_icon_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
494 {
495         Brush *br = (Brush *)ptr->data;
496
497         if (br->icon_imbuf) {
498                 IMB_freeImBuf(br->icon_imbuf);
499                 br->icon_imbuf = NULL;
500         }
501
502         br->id.icon_id = 0;
503
504         if (br->flag & BRUSH_CUSTOM_ICON) {
505                 BKE_icon_changed(BKE_icon_id_ensure(&br->id));
506         }
507
508         WM_main_add_notifier(NC_BRUSH | NA_EDITED, br);
509 }
510
511 static const EnumPropertyItem *rna_DynamicGpencil_type_itemf(
512         bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
513 {
514         Main *bmain = CTX_data_main(C);
515         EnumPropertyItem *item = NULL, item_tmp = { 0 };
516         int totitem = 0;
517         int i = 0;
518
519         Brush *brush;
520         for (brush = bmain->brush.first; brush; brush = brush->id.next, i++) {
521                 if (brush->gpencil_settings == NULL)
522                         continue;
523
524                 item_tmp.identifier = brush->id.name + 2;
525                 item_tmp.name = brush->id.name + 2;
526                 item_tmp.value = i;
527                 item_tmp.icon = brush->gpencil_settings->icon_id;
528
529                 RNA_enum_item_add(&item, &totitem, &item_tmp);
530         }
531
532         RNA_enum_item_end(&item, &totitem);
533         *r_free = true;
534
535         return item;
536 }
537
538 static void rna_TextureSlot_brush_angle_update(bContext *C, PointerRNA *ptr)
539 {
540         Scene *scene = CTX_data_scene(C);
541         MTex *mtex = ptr->data;
542         /* skip invalidation of overlay for stencil mode */
543         if (mtex->mapping != MTEX_MAP_MODE_STENCIL) {
544                 ViewLayer *view_layer = CTX_data_view_layer(C);
545                 BKE_paint_invalidate_overlay_tex(scene, view_layer, mtex->tex);
546         }
547
548         rna_TextureSlot_update(C, ptr);
549 }
550
551 static void rna_Brush_set_size(PointerRNA *ptr, int value)
552 {
553         Brush *brush = ptr->data;
554
555         /* scale unprojected radius so it stays consistent with brush size */
556         BKE_brush_scale_unprojected_radius(&brush->unprojected_radius,
557                                            value, brush->size);
558         brush->size = value;
559 }
560
561 static void rna_Brush_use_gradient_set(PointerRNA *ptr, bool value)
562 {
563         Brush *br = (Brush *)ptr->data;
564
565         if (value) br->flag |= BRUSH_USE_GRADIENT;
566         else br->flag &= ~BRUSH_USE_GRADIENT;
567
568         if ((br->flag & BRUSH_USE_GRADIENT) && br->gradient == NULL)
569                 br->gradient = BKE_colorband_add(true);
570 }
571
572 static void rna_Brush_set_unprojected_radius(PointerRNA *ptr, float value)
573 {
574         Brush *brush = ptr->data;
575
576         /* scale brush size so it stays consistent with unprojected_radius */
577         BKE_brush_scale_size(&brush->size, value, brush->unprojected_radius);
578         brush->unprojected_radius = value;
579 }
580
581 static const EnumPropertyItem *rna_Brush_direction_itemf(bContext *C, PointerRNA *ptr,
582                                                    PropertyRNA *UNUSED(prop), bool *UNUSED(r_free))
583 {
584         ePaintMode mode = BKE_paintmode_get_active_from_context(C);
585
586         static const EnumPropertyItem prop_default_items[] = {
587                 {0, NULL, 0, NULL, NULL}
588         };
589
590         /* sculpt mode */
591         static const EnumPropertyItem prop_flatten_contrast_items[] = {
592                 {BRUSH_DIR_IN, "CONTRAST", ICON_ADD, "Contrast", "Subtract effect of brush"},
593                 {0, "FLATTEN", ICON_REMOVE, "Flatten", "Add effect of brush"},
594                 {0, NULL, 0, NULL, NULL}
595         };
596
597         static const EnumPropertyItem prop_fill_deepen_items[] = {
598                 {0, "FILL", ICON_ADD, "Fill", "Add effect of brush"},
599                 {BRUSH_DIR_IN, "DEEPEN", ICON_REMOVE, "Deepen", "Subtract effect of brush"},
600                 {0, NULL, 0, NULL, NULL}
601         };
602
603         static const EnumPropertyItem prop_scrape_peaks_items[] = {
604                 {0, "SCRAPE", ICON_ADD, "Scrape", "Add effect of brush"},
605                 {BRUSH_DIR_IN, "PEAKS", ICON_REMOVE, "Peaks", "Subtract effect of brush"},
606                 {0, NULL, 0, NULL, NULL}
607         };
608
609         static const EnumPropertyItem prop_pinch_magnify_items[] = {
610                 {BRUSH_DIR_IN, "MAGNIFY", ICON_ADD, "Magnify", "Subtract effect of brush"},
611                 {0, "PINCH", ICON_REMOVE, "Pinch", "Add effect of brush"},
612                 {0, NULL, 0, NULL, NULL}
613         };
614
615         static const EnumPropertyItem prop_inflate_deflate_items[] = {
616                 {0, "INFLATE", ICON_ADD, "Inflate", "Add effect of brush"},
617                 {BRUSH_DIR_IN, "DEFLATE", ICON_REMOVE, "Deflate", "Subtract effect of brush"},
618                 {0, NULL, 0, NULL, NULL}
619         };
620
621         /* texture paint mode */
622         static const EnumPropertyItem prop_soften_sharpen_items[] = {
623                 {BRUSH_DIR_IN, "SHARPEN", ICON_ADD, "Sharpen", "Sharpen effect of brush"},
624                 {0, "SOFTEN", ICON_REMOVE, "Soften", "Blur effect of brush"},
625                 {0, NULL, 0, NULL, NULL}
626         };
627
628         Brush *me = (Brush *)(ptr->data);
629
630         switch (mode) {
631                 case ePaintSculpt:
632                         switch (me->sculpt_tool) {
633                                 case SCULPT_TOOL_DRAW:
634                                 case SCULPT_TOOL_CREASE:
635                                 case SCULPT_TOOL_BLOB:
636                                 case SCULPT_TOOL_LAYER:
637                                 case SCULPT_TOOL_CLAY:
638                                 case SCULPT_TOOL_CLAY_STRIPS:
639                                         return prop_direction_items;
640
641                                 case SCULPT_TOOL_MASK:
642                                         switch ((BrushMaskTool)me->mask_tool) {
643                                                 case BRUSH_MASK_DRAW:
644                                                         return prop_direction_items;
645
646                                                 case BRUSH_MASK_SMOOTH:
647                                                         return prop_default_items;
648
649                                                 default:
650                                                         return prop_default_items;
651                                         }
652
653                                 case SCULPT_TOOL_FLATTEN:
654                                         return prop_flatten_contrast_items;
655
656                                 case SCULPT_TOOL_FILL:
657                                         return prop_fill_deepen_items;
658
659                                 case SCULPT_TOOL_SCRAPE:
660                                         return prop_scrape_peaks_items;
661
662                                 case SCULPT_TOOL_PINCH:
663                                         return prop_pinch_magnify_items;
664
665                                 case SCULPT_TOOL_INFLATE:
666                                         return prop_inflate_deflate_items;
667
668                                 default:
669                                         return prop_default_items;
670                         }
671
672                 case ePaintTexture2D:
673                 case ePaintTextureProjective:
674                         switch (me->imagepaint_tool) {
675                                 case PAINT_TOOL_SOFTEN:
676                                         return prop_soften_sharpen_items;
677
678                                 default:
679                                         return prop_default_items;
680                         }
681
682                 default:
683                         return prop_default_items;
684         }
685 }
686
687 static const EnumPropertyItem *rna_Brush_stroke_itemf(bContext *C, PointerRNA *UNUSED(ptr),
688                                                 PropertyRNA *UNUSED(prop), bool *UNUSED(r_free))
689 {
690         ePaintMode mode = BKE_paintmode_get_active_from_context(C);
691
692         static const EnumPropertyItem brush_stroke_method_items[] = {
693                 {0, "DOTS", 0, "Dots", "Apply paint on each mouse move step"},
694                 {BRUSH_SPACE, "SPACE", 0, "Space", "Limit brush application to the distance specified by spacing"},
695                 {BRUSH_AIRBRUSH, "AIRBRUSH", 0, "Airbrush", "Keep applying paint effect while holding mouse (spray)"},
696                 {BRUSH_LINE, "LINE", 0, "Line", "Drag a line with dabs separated according to spacing"},
697                 {BRUSH_CURVE, "CURVE", 0, "Curve", "Define the stroke curve with a bezier curve. Dabs are separated according to spacing"},
698                 {0, NULL, 0, NULL, NULL}
699         };
700
701         switch (mode) {
702                 case ePaintSculpt:
703                 case ePaintTexture2D:
704                 case ePaintTextureProjective:
705                         return sculpt_stroke_method_items;
706
707                 default:
708                         return brush_stroke_method_items;
709         }
710 }
711
712 /* Grease Pencil Drawing Brushes Settings */
713 static char *rna_BrushGpencilSettings_path(PointerRNA *UNUSED(ptr))
714 {
715         return BLI_strdup("tool_settings.gpencil_paint.brush.gpencil_settings");
716 }
717
718 static void rna_BrushGpencilSettings_default_eraser_update(Main *bmain, Scene *scene, PointerRNA *UNUSED(ptr))
719 {
720         ToolSettings *ts = scene->toolsettings;
721         Paint *paint = &ts->gp_paint->paint;
722         Brush *brush_cur = paint->brush;
723
724         /* disable default eraser in all brushes */
725         for (Brush *brush = bmain->brush.first; brush; brush = brush->id.next) {
726                 if ((brush != brush_cur) &&
727                     (brush->ob_mode == OB_MODE_GPENCIL_PAINT) &&
728                     (brush->gpencil_settings->brush_type == GP_BRUSH_TYPE_ERASE))
729                 {
730                         brush->gpencil_settings->flag &= ~GP_BRUSH_DEFAULT_ERASER;
731                 }
732         }
733 }
734
735 static void rna_BrushGpencilSettings_eraser_mode_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *UNUSED(ptr))
736 {
737         ToolSettings *ts = scene->toolsettings;
738         Paint *paint = &ts->gp_paint->paint;
739         Brush *brush = paint->brush;
740
741         /* set eraser icon */
742         if ((brush) && (brush->gpencil_settings->brush_type == GP_BRUSH_TYPE_ERASE)) {
743                 switch (brush->gpencil_settings->eraser_mode) {
744                         case GP_BRUSH_ERASER_SOFT:
745                                 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_ERASE_SOFT;
746                                 break;
747                         case GP_BRUSH_ERASER_HARD:
748                                 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_ERASE_HARD;
749                                 break;
750                         case GP_BRUSH_ERASER_STROKE:
751                                 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_ERASE_STROKE;
752                                 break;
753                         default:
754                                 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_ERASE_SOFT;
755                                 break;
756                 }
757         }
758 }
759
760 static bool rna_BrushGpencilSettings_material_poll(PointerRNA *UNUSED(ptr), PointerRNA value)
761 {
762         Material *ma = (Material *)value.data;
763
764         /* GP materials only */
765         return (ma->gp_style != NULL);
766 }
767
768 #else
769
770 static void rna_def_brush_texture_slot(BlenderRNA *brna)
771 {
772         StructRNA *srna;
773         PropertyRNA *prop;
774
775         static const EnumPropertyItem prop_map_mode_items[] = {
776                 {MTEX_MAP_MODE_VIEW, "VIEW_PLANE", 0, "View Plane", ""},
777                 {MTEX_MAP_MODE_AREA, "AREA_PLANE", 0, "Area Plane", ""},
778                 {MTEX_MAP_MODE_TILED, "TILED", 0, "Tiled", ""},
779                 {MTEX_MAP_MODE_3D, "3D", 0, "3D", ""},
780                 {MTEX_MAP_MODE_RANDOM, "RANDOM", 0, "Random", ""},
781                 {MTEX_MAP_MODE_STENCIL, "STENCIL", 0, "Stencil", ""},
782                 {0, NULL, 0, NULL, NULL}
783         };
784
785         static const EnumPropertyItem prop_tex_paint_map_mode_items[] = {
786                 {MTEX_MAP_MODE_VIEW, "VIEW_PLANE", 0, "View Plane", ""},
787                 {MTEX_MAP_MODE_TILED, "TILED", 0, "Tiled", ""},
788                 {MTEX_MAP_MODE_3D, "3D", 0, "3D", ""},
789                 {MTEX_MAP_MODE_RANDOM, "RANDOM", 0, "Random", ""},
790                 {MTEX_MAP_MODE_STENCIL, "STENCIL", 0, "Stencil", ""},
791                 {0, NULL, 0, NULL, NULL}
792         };
793
794         static const EnumPropertyItem prop_mask_paint_map_mode_items[] = {
795                 {MTEX_MAP_MODE_VIEW, "VIEW_PLANE", 0, "View Plane", ""},
796                 {MTEX_MAP_MODE_TILED, "TILED", 0, "Tiled", ""},
797                 {MTEX_MAP_MODE_RANDOM, "RANDOM", 0, "Random", ""},
798                 {MTEX_MAP_MODE_STENCIL, "STENCIL", 0, "Stencil", ""},
799                 {0, NULL, 0, NULL, NULL}
800         };
801
802 #define TEXTURE_CAPABILITY(prop_name_, ui_name_)                          \
803         prop = RNA_def_property(srna, #prop_name_,                          \
804                                 PROP_BOOLEAN, PROP_NONE);                   \
805         RNA_def_property_clear_flag(prop, PROP_EDITABLE);                   \
806         RNA_def_property_boolean_funcs(prop, "rna_TextureCapabilities_"      \
807                                        #prop_name_ "_get", NULL);           \
808         RNA_def_property_ui_text(prop, ui_name_, NULL)
809
810
811         srna = RNA_def_struct(brna, "BrushTextureSlot", "TextureSlot");
812         RNA_def_struct_sdna(srna, "MTex");
813         RNA_def_struct_ui_text(srna, "Brush Texture Slot", "Texture slot for textures in a Brush data-block");
814
815         prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
816         RNA_def_property_float_sdna(prop, NULL, "rot");
817         RNA_def_property_range(prop, 0, M_PI * 2);
818         RNA_def_property_ui_text(prop, "Angle", "Brush texture rotation");
819         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
820         RNA_def_property_update(prop, 0, "rna_TextureSlot_brush_angle_update");
821
822         prop = RNA_def_property(srna, "map_mode", PROP_ENUM, PROP_NONE);
823         RNA_def_property_enum_sdna(prop, NULL, "brush_map_mode");
824         RNA_def_property_enum_items(prop, prop_map_mode_items);
825         RNA_def_property_ui_text(prop, "Mode", "");
826         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
827         RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
828
829         prop = RNA_def_property(srna, "tex_paint_map_mode", PROP_ENUM, PROP_NONE);
830         RNA_def_property_enum_sdna(prop, NULL, "brush_map_mode");
831         RNA_def_property_enum_items(prop, prop_tex_paint_map_mode_items);
832         RNA_def_property_ui_text(prop, "Mode", "");
833         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
834         RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
835
836         prop = RNA_def_property(srna, "mask_map_mode", PROP_ENUM, PROP_NONE);
837         RNA_def_property_enum_sdna(prop, NULL, "brush_map_mode");
838         RNA_def_property_enum_items(prop, prop_mask_paint_map_mode_items);
839         RNA_def_property_ui_text(prop, "Mode", "");
840         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
841         RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
842
843         prop = RNA_def_property(srna, "use_rake", PROP_BOOLEAN, PROP_NONE);
844         RNA_def_property_boolean_sdna(prop, NULL, "brush_angle_mode", MTEX_ANGLE_RAKE);
845         RNA_def_property_ui_text(prop, "Rake", "");
846         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
847         RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
848
849         prop = RNA_def_property(srna, "use_random", PROP_BOOLEAN, PROP_NONE);
850         RNA_def_property_boolean_sdna(prop, NULL, "brush_angle_mode", MTEX_ANGLE_RANDOM);
851         RNA_def_property_ui_text(prop, "Random", "");
852         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
853         RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
854
855         prop = RNA_def_property(srna, "random_angle", PROP_FLOAT, PROP_ANGLE);
856         RNA_def_property_range(prop, 0, M_PI * 2);
857         RNA_def_property_ui_text(prop, "Random Angle", "Brush texture random angle");
858         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
859         RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
860
861         TEXTURE_CAPABILITY(has_texture_angle_source, "Has Texture Angle Source");
862         TEXTURE_CAPABILITY(has_random_texture_angle, "Has Random Texture Angle");
863         TEXTURE_CAPABILITY(has_texture_angle, "Has Texture Angle Source");
864 }
865
866 static void rna_def_sculpt_capabilities(BlenderRNA *brna)
867 {
868         StructRNA *srna;
869         PropertyRNA *prop;
870
871         srna = RNA_def_struct(brna, "SculptToolCapabilities", NULL);
872         RNA_def_struct_sdna(srna, "Brush");
873         RNA_def_struct_nested(brna, srna, "Brush");
874         RNA_def_struct_ui_text(srna, "Sculpt Capabilities",
875                                "Read-only indications of which brush operations "
876                                "are supported by the current sculpt tool");
877
878 #define SCULPT_TOOL_CAPABILITY(prop_name_, ui_name_)                      \
879         prop = RNA_def_property(srna, #prop_name_,                          \
880                                 PROP_BOOLEAN, PROP_NONE);                   \
881         RNA_def_property_clear_flag(prop, PROP_EDITABLE);                   \
882         RNA_def_property_boolean_funcs(prop, "rna_SculptToolCapabilities_"      \
883                                        #prop_name_ "_get", NULL);           \
884         RNA_def_property_ui_text(prop, ui_name_, NULL)
885
886         SCULPT_TOOL_CAPABILITY(has_accumulate, "Has Accumulate");
887         SCULPT_TOOL_CAPABILITY(has_auto_smooth, "Has Auto Smooth");
888         SCULPT_TOOL_CAPABILITY(has_height, "Has Height");
889         SCULPT_TOOL_CAPABILITY(has_jitter, "Has Jitter");
890         SCULPT_TOOL_CAPABILITY(has_normal_weight, "Has Crease/Pinch Factor");
891         SCULPT_TOOL_CAPABILITY(has_rake_factor, "Has Rake Factor");
892         SCULPT_TOOL_CAPABILITY(has_persistence, "Has Persistence");
893         SCULPT_TOOL_CAPABILITY(has_pinch_factor, "Has Pinch Factor");
894         SCULPT_TOOL_CAPABILITY(has_plane_offset, "Has Plane Offset");
895         SCULPT_TOOL_CAPABILITY(has_random_texture_angle, "Has Random Texture Angle");
896         SCULPT_TOOL_CAPABILITY(has_sculpt_plane, "Has Sculpt Plane");
897         SCULPT_TOOL_CAPABILITY(has_secondary_color, "Has Secondary Color");
898         SCULPT_TOOL_CAPABILITY(has_smooth_stroke, "Has Smooth Stroke");
899         SCULPT_TOOL_CAPABILITY(has_space_attenuation, "Has Space Attenuation");
900         SCULPT_TOOL_CAPABILITY(has_strength_pressure, "Has Strength Pressure");
901         SCULPT_TOOL_CAPABILITY(has_gravity, "Has Gravity");
902
903 #undef SCULPT_CAPABILITY
904 }
905
906 static void rna_def_brush_capabilities(BlenderRNA *brna)
907 {
908         StructRNA *srna;
909         PropertyRNA *prop;
910
911         srna = RNA_def_struct(brna, "BrushCapabilities", NULL);
912         RNA_def_struct_sdna(srna, "Brush");
913         RNA_def_struct_nested(brna, srna, "Brush");
914         RNA_def_struct_ui_text(srna, "Brush Capabilities",
915                                "Read-only indications of which brush operations "
916                                "are supported by the current brush");
917
918 #define BRUSH_CAPABILITY(prop_name_, ui_name_)                          \
919         prop = RNA_def_property(srna, #prop_name_,                          \
920                                 PROP_BOOLEAN, PROP_NONE);                   \
921         RNA_def_property_clear_flag(prop, PROP_EDITABLE);                   \
922         RNA_def_property_boolean_funcs(prop, "rna_BrushCapabilities_"      \
923                                        #prop_name_ "_get", NULL);           \
924         RNA_def_property_ui_text(prop, ui_name_, NULL)
925
926         BRUSH_CAPABILITY(has_overlay, "Has Overlay");
927         BRUSH_CAPABILITY(has_random_texture_angle, "Has Random Texture Angle");
928         BRUSH_CAPABILITY(has_spacing, "Has Spacing");
929         BRUSH_CAPABILITY(has_smooth_stroke, "Has Smooth Stroke");
930
931
932 #undef BRUSH_CAPABILITY
933 }
934
935 static void rna_def_image_paint_capabilities(BlenderRNA *brna)
936 {
937         StructRNA *srna;
938         PropertyRNA *prop;
939
940         srna = RNA_def_struct(brna, "ImapaintToolCapabilities", NULL);
941         RNA_def_struct_sdna(srna, "Brush");
942         RNA_def_struct_nested(brna, srna, "Brush");
943         RNA_def_struct_ui_text(srna, "Image Paint Capabilities",
944                                "Read-only indications of which brush operations "
945                                "are supported by the current image paint brush");
946
947 #define IMAPAINT_TOOL_CAPABILITY(prop_name_, ui_name_)                       \
948         prop = RNA_def_property(srna, #prop_name_,                               \
949                                 PROP_BOOLEAN, PROP_NONE);                        \
950         RNA_def_property_clear_flag(prop, PROP_EDITABLE);                        \
951         RNA_def_property_boolean_funcs(prop, "rna_ImapaintToolCapabilities_"     \
952                                        #prop_name_ "_get", NULL);                \
953         RNA_def_property_ui_text(prop, ui_name_, NULL)
954
955         IMAPAINT_TOOL_CAPABILITY(has_accumulate, "Has Accumulate");
956         IMAPAINT_TOOL_CAPABILITY(has_space_attenuation, "Has Space Attenuation");
957         IMAPAINT_TOOL_CAPABILITY(has_radius, "Has Radius");
958
959 #undef IMAPAINT_TOOL_CAPABILITY
960 }
961
962 static void rna_def_gpencil_options(BlenderRNA *brna)
963 {
964         StructRNA *srna;
965         PropertyRNA *prop;
966
967         /*  Grease Pencil Drawing - generated dynamically */
968         static const EnumPropertyItem prop_dynamic_gpencil_type[] = {
969                 {1, "DRAW", 0, "Draw", ""},
970                 {0, NULL, 0, NULL, NULL}
971         };
972
973         srna = RNA_def_struct(brna, "BrushGpencilSettings", NULL);
974         RNA_def_struct_sdna(srna, "BrushGpencilSettings");
975         RNA_def_struct_path_func(srna, "rna_BrushGpencilSettings_path");
976         RNA_def_struct_ui_text(srna, "Grease Pencil Brush Settings", "Settings for grease pencil brush");
977
978         /* grease pencil drawing brushes */
979         prop = RNA_def_property(srna, "grease_pencil_tool", PROP_ENUM, PROP_NONE);
980         RNA_def_property_enum_sdna(prop, NULL, "brush_type");
981         RNA_def_property_enum_items(prop, prop_dynamic_gpencil_type);
982         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_DynamicGpencil_type_itemf");
983         RNA_def_property_ui_text(prop, "Grease Pencil Tool", "");
984         /* TODO: GPXX review update */
985         RNA_def_property_update(prop, 0, NULL);
986         //RNA_def_property_update(prop, 0, "rna_Brush_gpencil_tool_update");
987
988         /* Sensitivity factor for new strokes */
989         prop = RNA_def_property(srna, "pen_sensitivity_factor", PROP_FLOAT, PROP_NONE);
990         RNA_def_property_float_sdna(prop, NULL, "draw_sensitivity");
991         RNA_def_property_range(prop, 0.1f, 3.0f);
992         RNA_def_property_ui_text(prop, "Sensitivity", "Pressure sensitivity factor for new strokes");
993         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
994         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
995
996         /* Strength factor for new strokes */
997         prop = RNA_def_property(srna, "pen_strength", PROP_FLOAT, PROP_NONE);
998         RNA_def_property_float_sdna(prop, NULL, "draw_strength");
999         RNA_def_property_range(prop, 0.0f, 1.0f);
1000         RNA_def_property_ui_text(prop, "Strength", "Color strength for new strokes (affect alpha factor of color)");
1001         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1002         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1003
1004         /* Jitter factor for new strokes */
1005         prop = RNA_def_property(srna, "pen_jitter", PROP_FLOAT, PROP_NONE);
1006         RNA_def_property_float_sdna(prop, NULL, "draw_jitter");
1007         RNA_def_property_range(prop, 0.0f, 1.0f);
1008         RNA_def_property_ui_text(prop, "Jitter", "Jitter factor for new strokes");
1009         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1010         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1011
1012         /* Randomnes factor for pressure */
1013         prop = RNA_def_property(srna, "random_pressure", PROP_FLOAT, PROP_NONE);
1014         RNA_def_property_float_sdna(prop, NULL, "draw_random_press");
1015         RNA_def_property_range(prop, 0.0f, 1.0f);
1016         RNA_def_property_ui_text(prop, "Pressure Randomness", "Randomness factor for pressure in new strokes");
1017         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1018         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1019
1020         /* Randomnes factor for strength */
1021         prop = RNA_def_property(srna, "random_strength", PROP_FLOAT, PROP_NONE);
1022         RNA_def_property_float_sdna(prop, NULL, "draw_random_strength");
1023         RNA_def_property_range(prop, 0.0f, 1.0f);
1024         RNA_def_property_ui_text(prop, "Strength Randomness", "Randomness factor strength in new strokes");
1025         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1026         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1027
1028         /* Randomnes factor for subdivision */
1029         prop = RNA_def_property(srna, "random_subdiv", PROP_FLOAT, PROP_NONE);
1030         RNA_def_property_float_sdna(prop, NULL, "draw_random_sub");
1031         RNA_def_property_range(prop, 0.0f, 1.0f);
1032         RNA_def_property_ui_text(prop, "Random Subdivision", "Randomness factor for new strokes after subdivision");
1033         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1034         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1035
1036         /* Angle when brush is full size */
1037         prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
1038         RNA_def_property_float_sdna(prop, NULL, "draw_angle");
1039         RNA_def_property_range(prop, -M_PI_2, M_PI_2);
1040         RNA_def_property_ui_text(prop, "Angle",
1041                 "Direction of the stroke at which brush gives maximal thickness "
1042                 "(0° for horizontal)");
1043         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1044         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1045
1046         /* Factor to change brush size depending of angle */
1047         prop = RNA_def_property(srna, "angle_factor", PROP_FLOAT, PROP_NONE);
1048         RNA_def_property_float_sdna(prop, NULL, "draw_angle_factor");
1049         RNA_def_property_range(prop, 0.0f, 1.0f);
1050         RNA_def_property_ui_text(prop, "Angle Factor",
1051                 "Reduce brush thickness by this factor when stroke is perpendicular to 'Angle' direction");
1052         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1053         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1054
1055         /* Smoothing factor for new strokes */
1056         prop = RNA_def_property(srna, "pen_smooth_factor", PROP_FLOAT, PROP_NONE);
1057         RNA_def_property_float_sdna(prop, NULL, "draw_smoothfac");
1058         RNA_def_property_range(prop, 0.0, 2.0f);
1059         RNA_def_property_ui_text(prop, "Smooth",
1060                 "Amount of smoothing to apply after finish newly created strokes, to reduce jitter/noise");
1061         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1062         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1063
1064         /* Iterations of the Smoothing factor */
1065         prop = RNA_def_property(srna, "pen_smooth_steps", PROP_INT, PROP_NONE);
1066         RNA_def_property_int_sdna(prop, NULL, "draw_smoothlvl");
1067         RNA_def_property_range(prop, 1, 3);
1068         RNA_def_property_ui_text(prop, "Iterations",
1069                 "Number of times to smooth newly created strokes");
1070         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1071         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1072
1073         /* Thickness smoothing factor for new strokes */
1074         prop = RNA_def_property(srna, "pen_thick_smooth_factor", PROP_FLOAT, PROP_NONE);
1075         RNA_def_property_float_sdna(prop, NULL, "thick_smoothfac");
1076         RNA_def_property_range(prop, 0.0, 2.0f);
1077         RNA_def_property_ui_text(prop, "Smooth Thickness",
1078                 "Amount of thickness smoothing to apply after finish newly created strokes, to reduce jitter/noise");
1079         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1080         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1081
1082         /* Thickness iterations of the Smoothing factor */
1083         prop = RNA_def_property(srna, "pen_thick_smooth_steps", PROP_INT, PROP_NONE);
1084         RNA_def_property_int_sdna(prop, NULL, "thick_smoothlvl");
1085         RNA_def_property_range(prop, 1, 3);
1086         RNA_def_property_ui_text(prop, "Iterations Thickness",
1087                 "Number of times to smooth thickness for newly created strokes");
1088         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1089         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1090
1091         /* Subdivision level for new strokes */
1092         prop = RNA_def_property(srna, "pen_subdivision_steps", PROP_INT, PROP_NONE);
1093         RNA_def_property_int_sdna(prop, NULL, "draw_subdivide");
1094         RNA_def_property_range(prop, 0, 3);
1095         RNA_def_property_ui_text(prop, "Subdivision Steps",
1096                 "Number of times to subdivide newly created strokes, for less jagged strokes");
1097         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1098         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1099
1100         /* Curves for pressure */
1101         prop = RNA_def_property(srna, "curve_sensitivity", PROP_POINTER, PROP_NONE);
1102         RNA_def_property_pointer_sdna(prop, NULL, "curve_sensitivity");
1103         RNA_def_property_struct_type(prop, "CurveMapping");
1104         RNA_def_property_ui_text(prop, "Curve Sensitivity", "Curve used for the sensitivity");
1105         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1106         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1107
1108         prop = RNA_def_property(srna, "curve_strength", PROP_POINTER, PROP_NONE);
1109         RNA_def_property_pointer_sdna(prop, NULL, "curve_strength");
1110         RNA_def_property_struct_type(prop, "CurveMapping");
1111         RNA_def_property_ui_text(prop, "Curve Strength", "Curve used for the strength");
1112         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1113         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1114
1115         prop = RNA_def_property(srna, "curve_jitter", PROP_POINTER, PROP_NONE);
1116         RNA_def_property_pointer_sdna(prop, NULL, "curve_jitter");
1117         RNA_def_property_struct_type(prop, "CurveMapping");
1118         RNA_def_property_ui_text(prop, "Curve Jitter", "Curve used for the jitter effect");
1119         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1120         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1121
1122         /* fill threshold for transparence */
1123         prop = RNA_def_property(srna, "gpencil_fill_threshold", PROP_FLOAT, PROP_NONE);
1124         RNA_def_property_float_sdna(prop, NULL, "fill_threshold");
1125         RNA_def_property_range(prop, 0.0f, 1.0f);
1126         RNA_def_property_ui_text(prop, "Threshold",
1127                 "Threshold to consider color transparent for filling");
1128         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1129         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1130
1131         /* fill leak size */
1132         prop = RNA_def_property(srna, "gpencil_fill_leak", PROP_INT, PROP_PIXEL);
1133         RNA_def_property_int_sdna(prop, NULL, "fill_leak");
1134         RNA_def_property_range(prop, 0, 100);
1135         RNA_def_property_ui_text(prop, "Leak Size",
1136                 "Size in pixels to consider the leak closed");
1137         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1138         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1139
1140         /* fill simplify steps */
1141         prop = RNA_def_property(srna, "gpencil_fill_simplyfy_level", PROP_INT, PROP_NONE);
1142         RNA_def_property_int_sdna(prop, NULL, "fill_simplylvl");
1143         RNA_def_property_range(prop, 0, 10);
1144         RNA_def_property_ui_text(prop, "Simplify",
1145                 "Number of simplify steps (large values reduce fill accuracy)");
1146         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1147         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1148
1149         prop = RNA_def_property(srna, "uv_random", PROP_FLOAT, PROP_FACTOR);
1150         RNA_def_property_float_sdna(prop, NULL, "uv_random");
1151         RNA_def_property_range(prop, 0.0, 1.0);
1152         RNA_def_property_ui_text(prop, "UV Random", "Random factor for autogenerated UV rotation");
1153         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1154         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1155
1156         prop = RNA_def_property(srna, "input_samples", PROP_INT, PROP_NONE);
1157         RNA_def_property_int_sdna(prop, NULL, "input_samples");
1158         RNA_def_property_range(prop, 0, GP_MAX_INPUT_SAMPLES);
1159         RNA_def_property_ui_text(prop, "Input Samples", "Generate intermediate points for very fast mouse movements. Set to 0 to disable");
1160         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1161         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1162
1163         /* active smooth factor while drawing */
1164         prop = RNA_def_property(srna, "active_smooth_factor", PROP_FLOAT, PROP_NONE);
1165         RNA_def_property_float_sdna(prop, NULL, "active_smooth");
1166         RNA_def_property_range(prop, 0.0f, 1.0f);
1167         RNA_def_property_ui_text(prop, "Active Smooth",
1168                 "Amount of smoothing while drawing ");
1169         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1170         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1171
1172         prop = RNA_def_property(srna, "eraser_strength_factor", PROP_FLOAT, PROP_PERCENTAGE);
1173         RNA_def_property_float_sdna(prop, NULL, "era_strength_f");
1174         RNA_def_property_range(prop, 0.0, 100.0);
1175         RNA_def_property_ui_range(prop, 0.0, 100.0, 10, 1);
1176         RNA_def_property_ui_text(prop, "Affect Stroke Strength",
1177                 "Amount of erasing for strength ");
1178         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1179         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1180
1181         prop = RNA_def_property(srna, "eraser_thickness_factor", PROP_FLOAT, PROP_PERCENTAGE);
1182         RNA_def_property_float_sdna(prop, NULL, "era_thickness_f");
1183         RNA_def_property_range(prop, 0.0, 100.0);
1184         RNA_def_property_ui_range(prop, 0.0, 100.0, 10, 1);
1185         RNA_def_property_ui_text(prop, "Affect Stroke Thickness",
1186                 "Amount of erasing for thickness ");
1187         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1188         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1189
1190         /* brush standard icon */
1191         prop = RNA_def_property(srna, "gp_icon", PROP_ENUM, PROP_NONE);
1192         RNA_def_property_enum_sdna(prop, NULL, "icon_id");
1193         RNA_def_property_enum_items(prop, rna_enum_gpencil_brush_icons_items);
1194         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1195         RNA_def_property_ui_text(prop, "Grease Pencil Icon", "");
1196
1197         /* Flags */
1198         prop = RNA_def_property(srna, "use_pressure", PROP_BOOLEAN, PROP_NONE);
1199         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_USE_PRESSURE);
1200         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1201         RNA_def_property_ui_text(prop, "Use Pressure", "Use tablet pressure");
1202         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1203         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1204
1205         prop = RNA_def_property(srna, "use_strength_pressure", PROP_BOOLEAN, PROP_NONE);
1206         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_USE_STENGTH_PRESSURE);
1207         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1208         RNA_def_property_ui_text(prop, "Use Pressure Strength", "Use tablet pressure for color strength");
1209         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1210         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1211
1212         prop = RNA_def_property(srna, "use_jitter_pressure", PROP_BOOLEAN, PROP_NONE);
1213         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_USE_JITTER_PRESSURE);
1214         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1215         RNA_def_property_ui_text(prop, "Use Pressure Jitter", "Use tablet pressure for jitter");
1216         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1217         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1218
1219         prop = RNA_def_property(srna, "use_stabilizer", PROP_BOOLEAN, PROP_NONE);
1220         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_STABILIZE_MOUSE);
1221         RNA_def_property_boolean_default(prop, true);
1222         RNA_def_property_ui_text(prop, "Stabilizer",
1223                 "Draw lines with a delay to allow smooth strokes. Press Shift key to override while drawing");
1224         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1225
1226         prop = RNA_def_property(srna, "use_cursor", PROP_BOOLEAN, PROP_NONE);
1227         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_ENABLE_CURSOR);
1228         RNA_def_property_boolean_default(prop, true);
1229         RNA_def_property_ui_text(prop, "Enable Cursor", "Enable cursor on screen");
1230         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1231
1232         prop = RNA_def_property(srna, "gpencil_brush_type", PROP_ENUM, PROP_NONE);
1233         RNA_def_property_enum_sdna(prop, NULL, "brush_type");
1234         RNA_def_property_enum_items(prop, rna_enum_gpencil_brush_types_items);
1235         RNA_def_property_ui_text(prop, "Type", "Category of the brush");
1236         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1237
1238         prop = RNA_def_property(srna, "eraser_mode", PROP_ENUM, PROP_NONE);
1239         RNA_def_property_enum_sdna(prop, NULL, "eraser_mode");
1240         RNA_def_property_enum_items(prop, rna_enum_gpencil_brush_eraser_modes_items);
1241         RNA_def_property_ui_text(prop, "Mode", "Eraser Mode");
1242         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1243         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_BrushGpencilSettings_eraser_mode_update");
1244
1245         prop = RNA_def_property(srna, "gpencil_fill_draw_mode", PROP_ENUM, PROP_NONE);
1246         RNA_def_property_enum_sdna(prop, NULL, "fill_draw_mode");
1247         RNA_def_property_enum_items(prop, rna_enum_gpencil_fill_draw_modes_items);
1248         RNA_def_property_ui_text(prop, "Mode", "Mode to draw boundary limits");
1249         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1250
1251         /* Material */
1252         prop = RNA_def_property(srna, "material", PROP_POINTER, PROP_NONE);
1253         RNA_def_property_struct_type(prop, "Material");
1254         RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, "rna_BrushGpencilSettings_material_poll");
1255         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK | PROP_CONTEXT_UPDATE);
1256         RNA_def_property_ui_text(prop, "Material", "Material used for strokes drawn using this brush");
1257         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1258         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_Brush_material_update");
1259
1260         prop = RNA_def_property(srna, "gpencil_fill_show_boundary", PROP_BOOLEAN, PROP_NONE);
1261         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_FILL_SHOW_HELPLINES);
1262         RNA_def_property_boolean_default(prop, true);
1263         RNA_def_property_ui_text(prop, "Show Lines", "Show help lines for filling to see boundaries");
1264         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1265
1266         prop = RNA_def_property(srna, "gpencil_fill_hide", PROP_BOOLEAN, PROP_NONE);
1267         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_FILL_HIDE);
1268         RNA_def_property_boolean_default(prop, true);
1269         RNA_def_property_ui_text(prop, "Hide", "Hide transparent lines to use as boundary for filling");
1270         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1271
1272         prop = RNA_def_property(srna, "default_eraser", PROP_BOOLEAN, PROP_NONE);
1273         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_DEFAULT_ERASER);
1274         RNA_def_property_boolean_default(prop, true);
1275         RNA_def_property_ui_icon(prop, ICON_UNPINNED, 1);
1276         RNA_def_property_ui_text(prop, "Default Eraser", "Use this brush when enable eraser with fast switch key");
1277         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1278         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_BrushGpencilSettings_default_eraser_update");
1279
1280         prop = RNA_def_property(srna, "enable_settings", PROP_BOOLEAN, PROP_NONE);
1281         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_GROUP_SETTINGS);
1282         RNA_def_property_ui_text(prop, "Settings", "Enable additional post processing options for new strokes");
1283         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1284
1285         prop = RNA_def_property(srna, "enable_random", PROP_BOOLEAN, PROP_NONE);
1286         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_GROUP_RANDOM);
1287         RNA_def_property_ui_text(prop, "Random Settings", "Enable random settings for brush");
1288         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1289
1290         prop = RNA_def_property(srna, "pin_material", PROP_BOOLEAN, PROP_NONE);
1291         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_MATERIAL_PINNED);
1292         RNA_def_property_ui_icon(prop, ICON_UNPINNED, 1);
1293         RNA_def_property_ui_text(prop, "Pin Material", "Keep material assigned to brush");
1294         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1295
1296         prop = RNA_def_property(srna, "disable_lasso", PROP_BOOLEAN, PROP_NONE);
1297         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_DISSABLE_LASSO);
1298         RNA_def_property_ui_text(prop, "Disable Lasso", "Do not draw fill color while drawing the stroke");
1299         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1300 }
1301
1302 static void rna_def_brush(BlenderRNA *brna)
1303 {
1304         StructRNA *srna;
1305         PropertyRNA *prop;
1306
1307         static const EnumPropertyItem prop_blend_items[] = {
1308                 {IMB_BLEND_MIX, "MIX", 0, "Mix", "Use mix blending mode while painting"},
1309                 {IMB_BLEND_ADD, "ADD", 0, "Add", "Use add blending mode while painting"},
1310                 {IMB_BLEND_SUB, "SUB", 0, "Subtract", "Use subtract blending mode while painting"},
1311                 {IMB_BLEND_MUL, "MUL", 0, "Multiply", "Use multiply blending mode while painting"},
1312                 {IMB_BLEND_LIGHTEN, "LIGHTEN", 0, "Lighten", "Use lighten blending mode while painting"},
1313                 {IMB_BLEND_DARKEN, "DARKEN", 0, "Darken", "Use darken blending mode while painting"},
1314                 {IMB_BLEND_ERASE_ALPHA, "ERASE_ALPHA", 0, "Erase Alpha", "Erase alpha while painting"},
1315                 {IMB_BLEND_ADD_ALPHA, "ADD_ALPHA", 0, "Add Alpha", "Add alpha while painting"},
1316                 {IMB_BLEND_OVERLAY, "OVERLAY", 0, "Overlay", "Use overlay blending mode while painting"},
1317                 {IMB_BLEND_HARDLIGHT, "HARDLIGHT", 0, "Hard light", "Use hard light blending mode while painting"},
1318                 {IMB_BLEND_COLORBURN, "COLORBURN", 0, "Color burn", "Use color burn blending mode while painting"},
1319                 {IMB_BLEND_LINEARBURN, "LINEARBURN", 0, "Linear burn", "Use linear burn blending mode while painting"},
1320                 {IMB_BLEND_COLORDODGE, "COLORDODGE", 0, "Color dodge", "Use color dodge blending mode while painting"},
1321                 {IMB_BLEND_SCREEN, "SCREEN", 0, "Screen", "Use screen blending mode while painting"},
1322                 {IMB_BLEND_SOFTLIGHT, "SOFTLIGHT", 0, "Soft light", "Use softlight blending mode while painting"},
1323                 {IMB_BLEND_PINLIGHT, "PINLIGHT", 0, "Pin light", "Use pinlight blending mode while painting"},
1324                 {IMB_BLEND_VIVIDLIGHT, "VIVIDLIGHT", 0, "Vivid light", "Use vividlight blending mode while painting"},
1325                 {IMB_BLEND_LINEARLIGHT, "LINEARLIGHT", 0, "Linear light", "Use linearlight blending mode while painting"},
1326                 {IMB_BLEND_DIFFERENCE, "DIFFERENCE", 0, "Difference", "Use difference blending mode while painting"},
1327                 {IMB_BLEND_EXCLUSION, "EXCLUSION", 0, "Exclusion", "Use exclusion blending mode while painting"},
1328                 {IMB_BLEND_HUE, "HUE", 0, "Hue", "Use hue blending mode while painting"},
1329                 {IMB_BLEND_SATURATION, "SATURATION", 0, "Saturation", "Use saturation blending mode while painting"},
1330                 {IMB_BLEND_LUMINOSITY, "LUMINOSITY", 0, "Luminosity", "Use luminosity blending mode while painting"},
1331                 {IMB_BLEND_COLOR, "COLOR", 0, "Color", "Use color blending mode while painting"},
1332                 {0, NULL, 0, NULL, NULL}
1333         };
1334
1335         static const EnumPropertyItem brush_sculpt_plane_items[] = {
1336                 {SCULPT_DISP_DIR_AREA, "AREA", 0, "Area Plane", ""},
1337                 {SCULPT_DISP_DIR_VIEW, "VIEW", 0, "View Plane", ""},
1338                 {SCULPT_DISP_DIR_X, "X", 0, "X Plane", ""},
1339                 {SCULPT_DISP_DIR_Y, "Y", 0, "Y Plane", ""},
1340                 {SCULPT_DISP_DIR_Z, "Z", 0, "Z Plane", ""},
1341                 {0, NULL, 0, NULL, NULL}
1342         };
1343
1344         static const EnumPropertyItem brush_mask_tool_items[] = {
1345                 {BRUSH_MASK_DRAW, "DRAW", 0, "Draw", ""},
1346                 {BRUSH_MASK_SMOOTH, "SMOOTH", 0, "Smooth", ""},
1347                 {0, NULL, 0, NULL, NULL}
1348         };
1349
1350         static const EnumPropertyItem brush_blur_mode_items[] = {
1351                 {KERNEL_BOX, "BOX", 0, "Box", ""},
1352                 {KERNEL_GAUSSIAN, "GAUSSIAN", 0, "Gaussian", ""},
1353                 {0, NULL, 0, NULL, NULL}
1354         };
1355
1356         static const EnumPropertyItem brush_gradient_items[] = {
1357                 {BRUSH_GRADIENT_PRESSURE, "PRESSURE", 0, "Pressure", ""},
1358                 {BRUSH_GRADIENT_SPACING_REPEAT, "SPACING_REPEAT", 0, "Repeat", ""},
1359                 {BRUSH_GRADIENT_SPACING_CLAMP, "SPACING_CLAMP", 0, "Clamp", ""},
1360                 {0, NULL, 0, NULL, NULL}
1361         };
1362
1363         static const EnumPropertyItem brush_gradient_fill_items[] = {
1364                 {BRUSH_GRADIENT_LINEAR, "LINEAR", 0, "Linear", ""},
1365                 {BRUSH_GRADIENT_RADIAL, "RADIAL", 0, "Radial", ""},
1366                 {0, NULL, 0, NULL, NULL}
1367         };
1368
1369         static const EnumPropertyItem brush_mask_pressure_items[] = {
1370                 {0, "NONE", 0, "Off", ""},
1371                 {BRUSH_MASK_PRESSURE_RAMP, "RAMP", ICON_STYLUS_PRESSURE, "Ramp", ""},
1372                 {BRUSH_MASK_PRESSURE_CUTOFF, "CUTOFF", ICON_STYLUS_PRESSURE, "Cutoff", ""},
1373                 {0, NULL, 0, NULL, NULL}
1374         };
1375
1376         srna = RNA_def_struct(brna, "Brush", "ID");
1377         RNA_def_struct_ui_text(srna, "Brush", "Brush data-block for storing brush settings for painting and sculpting");
1378         RNA_def_struct_ui_icon(srna, ICON_BRUSH_DATA);
1379
1380         /* enums */
1381         prop = RNA_def_property(srna, "blend", PROP_ENUM, PROP_NONE);
1382         RNA_def_property_enum_items(prop, prop_blend_items);
1383         RNA_def_property_ui_text(prop, "Blending mode", "Brush blending mode");
1384         RNA_def_property_update(prop, 0, "rna_Brush_update");
1385
1386         prop = RNA_def_property(srna, "sculpt_tool", PROP_ENUM, PROP_NONE);
1387         RNA_def_property_enum_items(prop, rna_enum_brush_sculpt_tool_items);
1388         RNA_def_property_ui_text(prop, "Sculpt Tool", "");
1389         RNA_def_property_update(prop, 0, "rna_Brush_sculpt_tool_update");
1390
1391         prop = RNA_def_property(srna, "vertex_tool", PROP_ENUM, PROP_NONE);
1392         RNA_def_property_enum_sdna(prop, NULL, "vertexpaint_tool");
1393         RNA_def_property_enum_items(prop, rna_enum_brush_vertex_tool_items);
1394         RNA_def_property_ui_text(prop, "Blending mode", "Brush blending mode");
1395         RNA_def_property_update(prop, 0, "rna_Brush_vertex_tool_update");
1396
1397         prop = RNA_def_property(srna, "image_tool", PROP_ENUM, PROP_NONE);
1398         RNA_def_property_enum_sdna(prop, NULL, "imagepaint_tool");
1399         RNA_def_property_enum_items(prop, rna_enum_brush_image_tool_items);
1400         RNA_def_property_ui_text(prop, "Image Paint Tool", "");
1401         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, "rna_Brush_imagepaint_tool_update");
1402
1403         prop = RNA_def_property(srna, "direction", PROP_ENUM, PROP_NONE);
1404         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
1405         RNA_def_property_enum_items(prop, prop_direction_items);
1406         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Brush_direction_itemf");
1407         RNA_def_property_ui_text(prop, "Direction", "");
1408         RNA_def_property_update(prop, 0, "rna_Brush_update");
1409
1410         prop = RNA_def_property(srna, "stroke_method", PROP_ENUM, PROP_NONE);
1411         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
1412         RNA_def_property_enum_items(prop, sculpt_stroke_method_items);
1413         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Brush_stroke_itemf");
1414         RNA_def_property_ui_text(prop, "Stroke Method", "");
1415         RNA_def_property_update(prop, 0, "rna_Brush_stroke_update");
1416
1417         prop = RNA_def_property(srna, "sculpt_plane", PROP_ENUM, PROP_NONE);
1418         RNA_def_property_enum_items(prop, brush_sculpt_plane_items);
1419         RNA_def_property_ui_text(prop, "Sculpt Plane", "");
1420         RNA_def_property_update(prop, 0, "rna_Brush_update");
1421
1422         prop = RNA_def_property(srna, "mask_tool", PROP_ENUM, PROP_NONE);
1423         RNA_def_property_enum_items(prop, brush_mask_tool_items);
1424         RNA_def_property_ui_text(prop, "Mask Tool", "");
1425         RNA_def_property_update(prop, 0, "rna_Brush_update");
1426
1427         /* number values */
1428         prop = RNA_def_property(srna, "size", PROP_INT, PROP_PIXEL);
1429         RNA_def_property_int_funcs(prop, NULL, "rna_Brush_set_size", NULL);
1430         RNA_def_property_range(prop, 1, MAX_BRUSH_PIXEL_RADIUS * 10);
1431         RNA_def_property_ui_range(prop, 1, MAX_BRUSH_PIXEL_RADIUS, 1, -1);
1432         RNA_def_property_ui_text(prop, "Radius", "Radius of the brush in pixels");
1433         RNA_def_property_update(prop, 0, "rna_Brush_size_update");
1434
1435         prop = RNA_def_property(srna, "unprojected_radius", PROP_FLOAT, PROP_DISTANCE);
1436         RNA_def_property_float_funcs(prop, NULL, "rna_Brush_set_unprojected_radius", NULL);
1437         RNA_def_property_range(prop, 0.001, FLT_MAX);
1438         RNA_def_property_ui_range(prop, 0.001, 1, 0, -1);
1439         RNA_def_property_ui_text(prop, "Unprojected Radius", "Radius of brush in Blender units");
1440         RNA_def_property_update(prop, 0, "rna_Brush_size_update");
1441
1442         prop = RNA_def_property(srna, "jitter", PROP_FLOAT, PROP_NONE);
1443         RNA_def_property_float_sdna(prop, NULL, "jitter");
1444         RNA_def_property_range(prop, 0.0f, 1000.0f);
1445         RNA_def_property_ui_range(prop, 0.0f, 2.0f, 0.1, 4);
1446         RNA_def_property_ui_text(prop, "Jitter", "Jitter the position of the brush while painting");
1447         RNA_def_property_update(prop, 0, "rna_Brush_update");
1448
1449         prop = RNA_def_property(srna, "jitter_absolute", PROP_INT, PROP_PIXEL);
1450         RNA_def_property_int_sdna(prop, NULL, "jitter_absolute");
1451         RNA_def_property_range(prop, 0, 1000000);
1452         RNA_def_property_ui_text(prop, "Jitter", "Jitter the position of the brush in pixels while painting");
1453         RNA_def_property_update(prop, 0, "rna_Brush_update");
1454
1455         prop = RNA_def_property(srna, "spacing", PROP_INT, PROP_PERCENTAGE);
1456         RNA_def_property_int_sdna(prop, NULL, "spacing");
1457         RNA_def_property_range(prop, 1, 1000);
1458         RNA_def_property_ui_range(prop, 1, 500, 5, -1);
1459         RNA_def_property_ui_text(prop, "Spacing", "Spacing between brush daubs as a percentage of brush diameter");
1460         RNA_def_property_update(prop, 0, "rna_Brush_update");
1461
1462         prop = RNA_def_property(srna, "grad_spacing", PROP_INT, PROP_NONE);
1463         RNA_def_property_int_sdna(prop, NULL, "gradient_spacing");
1464         RNA_def_property_range(prop, 1, 10000);
1465         RNA_def_property_ui_range(prop, 1, 10000, 5, -1);
1466         RNA_def_property_ui_text(prop, "Gradient Spacing", "Spacing before brush gradient goes full circle");
1467         RNA_def_property_update(prop, 0, "rna_Brush_update");
1468
1469         prop = RNA_def_property(srna, "smooth_stroke_radius", PROP_INT, PROP_NONE);
1470         RNA_def_property_range(prop, 10, 200);
1471         RNA_def_property_ui_text(prop, "Smooth Stroke Radius", "Minimum distance from last point before stroke continues");
1472         RNA_def_property_update(prop, 0, "rna_Brush_update");
1473
1474         prop = RNA_def_property(srna, "smooth_stroke_factor", PROP_FLOAT, PROP_FACTOR);
1475         RNA_def_property_range(prop, 0.5, 0.99);
1476         RNA_def_property_ui_text(prop, "Smooth Stroke Factor", "Higher values give a smoother stroke");
1477         RNA_def_property_update(prop, 0, "rna_Brush_update");
1478
1479         prop = RNA_def_property(srna, "rate", PROP_FLOAT, PROP_NONE);
1480         RNA_def_property_float_sdna(prop, NULL, "rate");
1481         RNA_def_property_range(prop, 0.0001f, 10000.0f);
1482         RNA_def_property_ui_range(prop, 0.01f, 1.0f, 1, 3);
1483         RNA_def_property_ui_text(prop, "Rate", "Interval between paints for Airbrush");
1484         RNA_def_property_update(prop, 0, "rna_Brush_update");
1485
1486         prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
1487         RNA_def_property_range(prop, 0.0, 1.0);
1488         RNA_def_property_float_sdna(prop, NULL, "rgb");
1489         RNA_def_property_ui_text(prop, "Color", "");
1490         RNA_def_property_update(prop, 0, "rna_Brush_update");
1491
1492         prop = RNA_def_property(srna, "secondary_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1493         RNA_def_property_range(prop, 0.0, 1.0);
1494         RNA_def_property_float_sdna(prop, NULL, "secondary_rgb");
1495         RNA_def_property_ui_text(prop, "Secondary Color", "");
1496         RNA_def_property_update(prop, 0, "rna_Brush_update");
1497
1498         prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_FACTOR);
1499         RNA_def_property_float_default(prop, 1.0f);
1500         RNA_def_property_range(prop, 0.0f, 1.0f);
1501         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 3);
1502         RNA_def_property_ui_text(prop, "Weight", "Vertex weight when brush is applied");
1503         RNA_def_property_update(prop, 0, "rna_Brush_update");
1504
1505         prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_FACTOR);
1506         RNA_def_property_float_sdna(prop, NULL, "alpha");
1507         RNA_def_property_float_default(prop, 0.5f);
1508         RNA_def_property_range(prop, 0.0f, 10.0f);
1509         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 3);
1510         RNA_def_property_ui_text(prop, "Strength", "How powerful the effect of the brush is when applied");
1511         RNA_def_property_update(prop, 0, "rna_Brush_update");
1512
1513         prop = RNA_def_property(srna, "plane_offset", PROP_FLOAT, PROP_DISTANCE);
1514         RNA_def_property_float_sdna(prop, NULL, "plane_offset");
1515         RNA_def_property_float_default(prop, 0);
1516         RNA_def_property_range(prop, -2.0f, 2.0f);
1517         RNA_def_property_ui_range(prop, -0.5f, 0.5f, 0.001, 3);
1518         RNA_def_property_ui_text(prop, "Plane Offset",
1519                                  "Adjust plane on which the brush acts towards or away from the object surface");
1520         RNA_def_property_update(prop, 0, "rna_Brush_update");
1521
1522         prop = RNA_def_property(srna, "plane_trim", PROP_FLOAT, PROP_DISTANCE);
1523         RNA_def_property_float_sdna(prop, NULL, "plane_trim");
1524         RNA_def_property_float_default(prop, 0.5f);
1525         RNA_def_property_range(prop, 0, 1.0f);
1526         RNA_def_property_ui_text(prop, "Plane Trim",
1527                                  "If a vertex is further away from offset plane than this, then it is not affected");
1528         RNA_def_property_update(prop, 0, "rna_Brush_update");
1529
1530         prop = RNA_def_property(srna, "height", PROP_FLOAT, PROP_DISTANCE);
1531         RNA_def_property_float_sdna(prop, NULL, "height");
1532         RNA_def_property_float_default(prop, 0.5f);
1533         RNA_def_property_range(prop, 0, 1.0f);
1534         RNA_def_property_ui_text(prop, "Brush Height", "Affectable height of brush (layer height for layer tool, i.e.)");
1535         RNA_def_property_update(prop, 0, "rna_Brush_update");
1536
1537         prop = RNA_def_property(srna, "texture_sample_bias", PROP_FLOAT, PROP_DISTANCE);
1538         RNA_def_property_float_sdna(prop, NULL, "texture_sample_bias");
1539         RNA_def_property_float_default(prop, 0);
1540         RNA_def_property_range(prop, -1, 1);
1541         RNA_def_property_ui_text(prop, "Texture Sample Bias", "Value added to texture samples");
1542         RNA_def_property_update(prop, 0, "rna_Brush_update");
1543
1544         prop = RNA_def_property(srna, "normal_weight", PROP_FLOAT, PROP_FACTOR);
1545         RNA_def_property_float_sdna(prop, NULL, "normal_weight");
1546         RNA_def_property_float_default(prop, 0);
1547         RNA_def_property_range(prop, 0.0f, 1.0f);
1548         RNA_def_property_ui_text(prop, "Normal Weight", "How much grab will pull vertexes out of surface during a grab");
1549         RNA_def_property_update(prop, 0, "rna_Brush_update");
1550
1551         prop = RNA_def_property(srna, "rake_factor", PROP_FLOAT, PROP_FACTOR);
1552         RNA_def_property_float_sdna(prop, NULL, "rake_factor");
1553         RNA_def_property_float_default(prop, 0);
1554         RNA_def_property_range(prop, 0.0f, 10.0f);
1555         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 3);
1556         RNA_def_property_ui_text(prop, "Rake", "How much grab will follow cursor rotation");
1557         RNA_def_property_update(prop, 0, "rna_Brush_update");
1558
1559         prop = RNA_def_property(srna, "crease_pinch_factor", PROP_FLOAT, PROP_FACTOR);
1560         RNA_def_property_float_sdna(prop, NULL, "crease_pinch_factor");
1561         RNA_def_property_float_default(prop, 2.0f / 3.0f);
1562         RNA_def_property_range(prop, 0.0f, 1.0f);
1563         RNA_def_property_ui_text(prop, "Crease Brush Pinch Factor", "How much the crease brush pinches");
1564         RNA_def_property_update(prop, 0, "rna_Brush_update");
1565
1566         prop = RNA_def_property(srna, "auto_smooth_factor", PROP_FLOAT, PROP_FACTOR);
1567         RNA_def_property_float_sdna(prop, NULL, "autosmooth_factor");
1568         RNA_def_property_float_default(prop, 0);
1569         RNA_def_property_range(prop, 0.0f, 1.0f);
1570         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 3);
1571         RNA_def_property_ui_text(prop, "Autosmooth", "Amount of smoothing to automatically apply to each stroke");
1572         RNA_def_property_update(prop, 0, "rna_Brush_update");
1573
1574         prop = RNA_def_property(srna, "stencil_pos", PROP_FLOAT, PROP_XYZ);
1575         RNA_def_property_float_sdna(prop, NULL, "stencil_pos");
1576         RNA_def_property_array(prop, 2);
1577         RNA_def_property_ui_text(prop, "Stencil Position", "Position of stencil in viewport");
1578         RNA_def_property_update(prop, 0, "rna_Brush_update");
1579
1580         prop = RNA_def_property(srna, "stencil_dimension", PROP_FLOAT, PROP_XYZ);
1581         RNA_def_property_float_sdna(prop, NULL, "stencil_dimension");
1582         RNA_def_property_array(prop, 2);
1583         RNA_def_property_ui_text(prop, "Stencil Dimensions", "Dimensions of stencil in viewport");
1584         RNA_def_property_update(prop, 0, "rna_Brush_update");
1585
1586         prop = RNA_def_property(srna, "mask_stencil_pos", PROP_FLOAT, PROP_XYZ);
1587         RNA_def_property_float_sdna(prop, NULL, "mask_stencil_pos");
1588         RNA_def_property_array(prop, 2);
1589         RNA_def_property_ui_text(prop, "Mask Stencil Position", "Position of mask stencil in viewport");
1590         RNA_def_property_update(prop, 0, "rna_Brush_update");
1591
1592         prop = RNA_def_property(srna, "mask_stencil_dimension", PROP_FLOAT, PROP_XYZ);
1593         RNA_def_property_float_sdna(prop, NULL, "mask_stencil_dimension");
1594         RNA_def_property_array(prop, 2);
1595         RNA_def_property_ui_text(prop, "Mask Stencil Dimensions", "Dimensions of mask stencil in viewport");
1596         RNA_def_property_update(prop, 0, "rna_Brush_update");
1597
1598         prop = RNA_def_property(srna, "sharp_threshold", PROP_FLOAT, PROP_NONE);
1599         RNA_def_property_range(prop, 0.0, 100.0);
1600         RNA_def_property_ui_range(prop, 0.0, 1.0, 1, 3);
1601         RNA_def_property_float_sdna(prop, NULL, "sharp_threshold");
1602         RNA_def_property_ui_text(prop, "Sharp Threshold", "Threshold below which, no sharpening is done");
1603         RNA_def_property_update(prop, 0, "rna_Brush_update");
1604
1605         prop = RNA_def_property(srna, "fill_threshold", PROP_FLOAT, PROP_NONE);
1606         RNA_def_property_range(prop, 0.0, 100.0);
1607         RNA_def_property_ui_range(prop, 0.0, 1.0, 1, 3);
1608         RNA_def_property_float_sdna(prop, NULL, "fill_threshold");
1609         RNA_def_property_ui_text(prop, "Fill Threshold", "Threshold above which filling is not propagated");
1610         RNA_def_property_update(prop, 0, "rna_Brush_update");
1611
1612         prop = RNA_def_property(srna, "blur_kernel_radius", PROP_INT, PROP_NONE);
1613         RNA_def_property_int_sdna(prop, NULL, "blur_kernel_radius");
1614         RNA_def_property_range(prop, 1, 10000);
1615         RNA_def_property_ui_range(prop, 1, 50, 1, -1);
1616         RNA_def_property_ui_text(prop, "Kernel Radius", "Radius of kernel used for soften and sharpen in pixels");
1617         RNA_def_property_update(prop, 0, "rna_Brush_update");
1618
1619         prop = RNA_def_property(srna, "blur_mode", PROP_ENUM, PROP_NONE);
1620         RNA_def_property_enum_items(prop, brush_blur_mode_items);
1621         RNA_def_property_ui_text(prop, "Blur Mode", "");
1622         RNA_def_property_update(prop, 0, "rna_Brush_update");
1623
1624         prop = RNA_def_property(srna, "falloff_angle", PROP_FLOAT, PROP_ANGLE);
1625         RNA_def_property_float_sdna(prop, NULL, "falloff_angle");
1626         RNA_def_property_range(prop, 0, M_PI / 2);
1627         RNA_def_property_ui_text(prop, "Falloff Angle",
1628                                  "Paint most on faces pointing towards the view according to this angle");
1629         RNA_def_property_update(prop, 0, "rna_Brush_update");
1630
1631         /* flag */
1632         /* This is an enum but its unlikely we add other shapes, so expose as a boolean. */
1633         prop = RNA_def_property(srna, "use_projected", PROP_BOOLEAN, PROP_NONE);
1634         RNA_def_property_boolean_sdna(prop, NULL, "falloff_shape", BRUSH_AIRBRUSH);
1635         RNA_def_property_ui_text(prop, "2D Falloff", "Apply brush influence in 2D circle instead of a sphere");
1636         RNA_def_property_update(prop, 0, "rna_Brush_update");
1637
1638         prop = RNA_def_property(srna, "use_airbrush", PROP_BOOLEAN, PROP_NONE);
1639         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_AIRBRUSH);
1640         RNA_def_property_ui_text(prop, "Airbrush", "Keep applying paint effect while holding mouse (spray)");
1641         RNA_def_property_update(prop, 0, "rna_Brush_update");
1642
1643         prop = RNA_def_property(srna, "use_original_normal", PROP_BOOLEAN, PROP_NONE);
1644         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_ORIGINAL_NORMAL);
1645         RNA_def_property_ui_icon(prop, ICON_UNLOCKED, true);
1646         RNA_def_property_ui_text(prop, "Original Normal",
1647                                  "When locked keep using normal of surface where stroke was initiated");
1648         RNA_def_property_update(prop, 0, "rna_Brush_update");
1649
1650         prop = RNA_def_property(srna, "use_pressure_strength", PROP_BOOLEAN, PROP_NONE);
1651         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_ALPHA_PRESSURE);
1652         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1653         RNA_def_property_ui_text(prop, "Strength Pressure", "Enable tablet pressure sensitivity for strength");
1654         RNA_def_property_update(prop, 0, "rna_Brush_update");
1655
1656         prop = RNA_def_property(srna, "use_offset_pressure", PROP_BOOLEAN, PROP_NONE);
1657         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_OFFSET_PRESSURE);
1658         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1659         RNA_def_property_ui_text(prop, "Plane Offset Pressure", "Enable tablet pressure sensitivity for offset");
1660         RNA_def_property_update(prop, 0, "rna_Brush_update");
1661
1662         prop = RNA_def_property(srna, "use_pressure_size", PROP_BOOLEAN, PROP_NONE);
1663         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_SIZE_PRESSURE);
1664         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1665         RNA_def_property_ui_text(prop, "Size Pressure", "Enable tablet pressure sensitivity for size");
1666         RNA_def_property_update(prop, 0, "rna_Brush_update");
1667
1668         prop = RNA_def_property(srna, "use_gradient", PROP_BOOLEAN, PROP_NONE);
1669         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_USE_GRADIENT);
1670         RNA_def_property_boolean_funcs(prop, NULL, "rna_Brush_use_gradient_set");
1671         RNA_def_property_ui_text(prop, "Use Gradient", "Use Gradient by utilizing a sampling method");
1672         RNA_def_property_update(prop, 0, "rna_Brush_update");
1673
1674         prop = RNA_def_property(srna, "use_pressure_jitter", PROP_BOOLEAN, PROP_NONE);
1675         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_JITTER_PRESSURE);
1676         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1677         RNA_def_property_ui_text(prop, "Jitter Pressure", "Enable tablet pressure sensitivity for jitter");
1678         RNA_def_property_update(prop, 0, "rna_Brush_update");
1679
1680         prop = RNA_def_property(srna, "use_pressure_spacing", PROP_BOOLEAN, PROP_NONE);
1681         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_SPACING_PRESSURE);
1682         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1683         RNA_def_property_ui_text(prop, "Spacing Pressure", "Enable tablet pressure sensitivity for spacing");
1684         RNA_def_property_update(prop, 0, "rna_Brush_update");
1685
1686         prop = RNA_def_property(srna, "use_pressure_masking", PROP_ENUM, PROP_NONE);
1687         RNA_def_property_enum_sdna(prop, NULL, "mask_pressure");
1688         RNA_def_property_enum_items(prop, brush_mask_pressure_items);
1689         RNA_def_property_ui_text(prop, "Mask Pressure Mode", "Pen pressure makes texture influence smaller");
1690         RNA_def_property_update(prop, 0, "rna_Brush_update");
1691
1692         prop = RNA_def_property(srna, "use_inverse_smooth_pressure", PROP_BOOLEAN, PROP_NONE);
1693         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_INVERSE_SMOOTH_PRESSURE);
1694         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1695         RNA_def_property_ui_text(prop, "Inverse Smooth Pressure", "Lighter pressure causes more smoothing to be applied");
1696         RNA_def_property_update(prop, 0, "rna_Brush_update");
1697
1698         prop = RNA_def_property(srna, "use_relative_jitter", PROP_BOOLEAN, PROP_NONE);
1699         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BRUSH_ABSOLUTE_JITTER);
1700         RNA_def_property_ui_icon(prop, ICON_UNLOCKED, true);
1701         RNA_def_property_ui_text(prop, "Absolute Jitter", "Jittering happens in screen space, not relative to brush size");
1702         RNA_def_property_update(prop, 0, "rna_Brush_update");
1703
1704         prop = RNA_def_property(srna, "use_plane_trim", PROP_BOOLEAN, PROP_NONE);
1705         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_PLANE_TRIM);
1706         RNA_def_property_ui_text(prop, "Use Plane Trim", "Enable Plane Trim");
1707         RNA_def_property_update(prop, 0, "rna_Brush_update");
1708
1709         prop = RNA_def_property(srna, "use_frontface", PROP_BOOLEAN, PROP_NONE);
1710         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_FRONTFACE);
1711         RNA_def_property_ui_text(prop, "Use Front-Face", "Brush only affects vertexes that face the viewer");
1712         RNA_def_property_update(prop, 0, "rna_Brush_update");
1713
1714         prop = RNA_def_property(srna, "use_frontface_falloff", PROP_BOOLEAN, PROP_NONE);
1715         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_FRONTFACE_FALLOFF);
1716         RNA_def_property_ui_text(prop, "Use Front-Face Falloff", "Blend brush influence by how much they face the front");
1717         RNA_def_property_update(prop, 0, "rna_Brush_update");
1718
1719         prop = RNA_def_property(srna, "use_anchor", PROP_BOOLEAN, PROP_NONE);
1720         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_ANCHORED);
1721         RNA_def_property_ui_text(prop, "Anchored", "Keep the brush anchored to the initial location");
1722         RNA_def_property_update(prop, 0, "rna_Brush_update");
1723
1724         prop = RNA_def_property(srna, "use_space", PROP_BOOLEAN, PROP_NONE);
1725         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_SPACE);
1726         RNA_def_property_ui_text(prop, "Space", "Limit brush application to the distance specified by spacing");
1727         RNA_def_property_update(prop, 0, "rna_Brush_update");
1728
1729         prop = RNA_def_property(srna, "use_line", PROP_BOOLEAN, PROP_NONE);
1730         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_LINE);
1731         RNA_def_property_ui_text(prop, "Line", "Draw a line with dabs separated according to spacing");
1732         RNA_def_property_update(prop, 0, "rna_Brush_update");
1733
1734         prop = RNA_def_property(srna, "use_curve", PROP_BOOLEAN, PROP_NONE);
1735         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_CURVE);
1736         RNA_def_property_ui_text(prop, "Curve", "Define the stroke curve with a bezier curve. Dabs are separated according to spacing");
1737         RNA_def_property_update(prop, 0, "rna_Brush_update");
1738
1739         prop = RNA_def_property(srna, "use_smooth_stroke", PROP_BOOLEAN, PROP_NONE);
1740         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_SMOOTH_STROKE);
1741         RNA_def_property_ui_text(prop, "Smooth Stroke", "Brush lags behind mouse and follows a smoother path");
1742         RNA_def_property_update(prop, 0, "rna_Brush_update");
1743
1744         prop = RNA_def_property(srna, "use_persistent", PROP_BOOLEAN, PROP_NONE);
1745         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_PERSISTENT);
1746         RNA_def_property_ui_text(prop, "Persistent", "Sculpt on a persistent layer of the mesh");
1747         RNA_def_property_update(prop, 0, "rna_Brush_update");
1748
1749         prop = RNA_def_property(srna, "use_accumulate", PROP_BOOLEAN, PROP_NONE);
1750         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_ACCUMULATE);
1751         RNA_def_property_ui_text(prop, "Accumulate", "Accumulate stroke daubs on top of each other");
1752         RNA_def_property_update(prop, 0, "rna_Brush_update");
1753
1754         prop = RNA_def_property(srna, "use_space_attenuation", PROP_BOOLEAN, PROP_NONE);
1755         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_SPACE_ATTEN);
1756         RNA_def_property_ui_icon(prop, ICON_UNLOCKED, true);
1757         RNA_def_property_ui_text(prop, "Use Automatic Strength Adjustment",
1758                                  "Automatically adjust strength to give consistent results for different spacings");
1759         RNA_def_property_update(prop, 0, "rna_Brush_update");
1760
1761         /* adaptive space is not implemented yet */
1762         prop = RNA_def_property(srna, "use_adaptive_space", PROP_BOOLEAN, PROP_NONE);
1763         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_ADAPTIVE_SPACE);
1764         RNA_def_property_ui_text(prop, "Adaptive Spacing",
1765                                  "Space daubs according to surface orientation instead of screen space");
1766         RNA_def_property_update(prop, 0, "rna_Brush_update");
1767
1768         prop = RNA_def_property(srna, "use_locked_size", PROP_BOOLEAN, PROP_NONE);
1769         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_LOCK_SIZE);
1770         RNA_def_property_ui_text(prop, "Use Blender Units",
1771                                  "When locked brush stays same size relative to object; when unlocked brush size is "
1772                                  "given in pixels");
1773         RNA_def_property_update(prop, 0, "rna_Brush_update");
1774
1775         prop = RNA_def_property(srna, "use_edge_to_edge", PROP_BOOLEAN, PROP_NONE);
1776         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_EDGE_TO_EDGE);
1777         RNA_def_property_ui_text(prop, "Edge-to-edge", "Drag anchor brush from edge-to-edge");
1778         RNA_def_property_update(prop, 0, "rna_Brush_update");
1779
1780         prop = RNA_def_property(srna, "use_restore_mesh", PROP_BOOLEAN, PROP_NONE);
1781         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_DRAG_DOT);
1782         RNA_def_property_ui_text(prop, "Restore Mesh", "Allow a single dot to be carefully positioned");
1783         RNA_def_property_update(prop, 0, "rna_Brush_update");
1784
1785         /* only for projection paint & vertex paint, TODO, other paint modes */
1786         prop = RNA_def_property(srna, "use_alpha", PROP_BOOLEAN, PROP_NONE);
1787         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BRUSH_LOCK_ALPHA);
1788         RNA_def_property_ui_text(prop, "Alpha", "When this is disabled, lock alpha while painting");
1789         RNA_def_property_update(prop, 0, "rna_Brush_update");
1790
1791         prop = RNA_def_property(srna, "curve", PROP_POINTER, PROP_NONE);
1792         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1793         RNA_def_property_ui_text(prop, "Curve", "Editable falloff curve");
1794         RNA_def_property_update(prop, 0, "rna_Brush_update");
1795
1796         prop = RNA_def_property(srna, "paint_curve", PROP_POINTER, PROP_NONE);
1797         RNA_def_property_flag(prop, PROP_EDITABLE);
1798         RNA_def_property_ui_text(prop, "Paint Curve", "Active Paint Curve");
1799         RNA_def_property_update(prop, 0, "rna_Brush_update");
1800
1801         prop = RNA_def_property(srna, "gradient", PROP_POINTER, PROP_NEVER_NULL);
1802         RNA_def_property_pointer_sdna(prop, NULL, "gradient");
1803         RNA_def_property_struct_type(prop, "ColorRamp");
1804         RNA_def_property_ui_text(prop, "Gradient", "");
1805         RNA_def_property_update(prop, 0, "rna_Brush_update");
1806
1807         /* gradient source */
1808         prop = RNA_def_property(srna, "gradient_stroke_mode", PROP_ENUM, PROP_NONE);
1809         RNA_def_property_enum_items(prop, brush_gradient_items);
1810         RNA_def_property_ui_text(prop, "Gradient Stroke Mode", "");
1811         RNA_def_property_update(prop, 0, "rna_Brush_update");
1812
1813         prop = RNA_def_property(srna, "gradient_fill_mode", PROP_ENUM, PROP_NONE);
1814         RNA_def_property_enum_items(prop, brush_gradient_fill_items);
1815         RNA_def_property_ui_text(prop, "Gradient Fill Mode", "");
1816         RNA_def_property_update(prop, 0, "rna_Brush_update");
1817
1818         /* overlay flags */
1819         prop = RNA_def_property(srna, "use_primary_overlay", PROP_BOOLEAN, PROP_NONE);
1820         RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_PRIMARY);
1821         RNA_def_property_ui_text(prop, "Use Texture Overlay", "Show texture in viewport");
1822         RNA_def_property_update(prop, 0, "rna_Brush_update");
1823
1824         prop = RNA_def_property(srna, "use_secondary_overlay", PROP_BOOLEAN, PROP_NONE);
1825         RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_SECONDARY);
1826         RNA_def_property_ui_text(prop, "Use Texture Overlay", "Show texture in viewport");
1827         RNA_def_property_update(prop, 0, "rna_Brush_update");
1828
1829         prop = RNA_def_property(srna, "use_cursor_overlay", PROP_BOOLEAN, PROP_NONE);
1830         RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_CURSOR);
1831         RNA_def_property_ui_text(prop, "Use Cursor Overlay", "Show cursor in viewport");
1832         RNA_def_property_update(prop, 0, "rna_Brush_update");
1833
1834         prop = RNA_def_property(srna, "use_cursor_overlay_override", PROP_BOOLEAN, PROP_NONE);
1835         RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_CURSOR_OVERRIDE_ON_STROKE);
1836         RNA_def_property_ui_text(prop, "Override Overlay", "Don't show overlay during a stroke");
1837         RNA_def_property_update(prop, 0, "rna_Brush_update");
1838
1839         prop = RNA_def_property(srna, "use_primary_overlay_override", PROP_BOOLEAN, PROP_NONE);
1840         RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_PRIMARY_OVERRIDE_ON_STROKE);
1841         RNA_def_property_ui_text(prop, "Override Overlay", "Don't show overlay during a stroke");
1842         RNA_def_property_update(prop, 0, "rna_Brush_update");
1843
1844         prop = RNA_def_property(srna, "use_secondary_overlay_override", PROP_BOOLEAN, PROP_NONE);
1845         RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_SECONDARY_OVERRIDE_ON_STROKE);
1846         RNA_def_property_ui_text(prop, "Override Overlay", "Don't show overlay during a stroke");
1847         RNA_def_property_update(prop, 0, "rna_Brush_update");
1848
1849         /* paint mode flags */
1850         prop = RNA_def_property(srna, "use_paint_sculpt", PROP_BOOLEAN, PROP_NONE);
1851         RNA_def_property_boolean_sdna(prop, NULL, "ob_mode", OB_MODE_SCULPT);
1852         RNA_def_property_ui_text(prop, "Use Sculpt", "Use this brush in sculpt mode");
1853
1854         prop = RNA_def_property(srna, "use_paint_vertex", PROP_BOOLEAN, PROP_NONE);
1855         RNA_def_property_boolean_sdna(prop, NULL, "ob_mode", OB_MODE_VERTEX_PAINT);
1856         RNA_def_property_ui_text(prop, "Use Vertex", "Use this brush in vertex paint mode");
1857
1858         prop = RNA_def_property(srna, "use_paint_weight", PROP_BOOLEAN, PROP_NONE);
1859         RNA_def_property_boolean_sdna(prop, NULL, "ob_mode", OB_MODE_WEIGHT_PAINT);
1860         RNA_def_property_ui_text(prop, "Use Weight", "Use this brush in weight paint mode");
1861
1862         prop = RNA_def_property(srna, "use_paint_image", PROP_BOOLEAN, PROP_NONE);
1863         RNA_def_property_boolean_sdna(prop, NULL, "ob_mode", OB_MODE_TEXTURE_PAINT);
1864         RNA_def_property_ui_text(prop, "Use Texture", "Use this brush in texture paint mode");
1865
1866         prop = RNA_def_property(srna, "use_paint_grease_pencil", PROP_BOOLEAN, PROP_NONE);
1867         RNA_def_property_boolean_sdna(prop, NULL, "ob_mode", OB_MODE_GPENCIL_PAINT);
1868         RNA_def_property_ui_text(prop, "Use Sculpt", "Use this brush in grease pencil drawing mode");
1869
1870         /* texture */
1871         prop = RNA_def_property(srna, "texture_slot", PROP_POINTER, PROP_NONE);
1872         RNA_def_property_struct_type(prop, "BrushTextureSlot");
1873         RNA_def_property_pointer_sdna(prop, NULL, "mtex");
1874         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1875         RNA_def_property_ui_text(prop, "Texture Slot", "");
1876
1877         prop = RNA_def_property(srna, "texture", PROP_POINTER, PROP_NONE);
1878         RNA_def_property_pointer_sdna(prop, NULL, "mtex.tex");
1879         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_CONTEXT_UPDATE);
1880         RNA_def_property_ui_text(prop, "Texture", "");
1881         RNA_def_property_update(prop, NC_TEXTURE, "rna_Brush_main_tex_update");
1882
1883         prop = RNA_def_property(srna, "mask_texture_slot", PROP_POINTER, PROP_NONE);
1884         RNA_def_property_struct_type(prop, "BrushTextureSlot");
1885         RNA_def_property_pointer_sdna(prop, NULL, "mask_mtex");
1886         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1887         RNA_def_property_ui_text(prop, "Mask Texture Slot", "");
1888
1889         prop = RNA_def_property(srna, "mask_texture", PROP_POINTER, PROP_NONE);
1890         RNA_def_property_pointer_sdna(prop, NULL, "mask_mtex.tex");
1891         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_CONTEXT_UPDATE);
1892         RNA_def_property_ui_text(prop, "Mask Texture", "");
1893         RNA_def_property_update(prop, NC_TEXTURE, "rna_Brush_secondary_tex_update");
1894
1895         prop = RNA_def_property(srna, "texture_overlay_alpha", PROP_INT, PROP_PERCENTAGE);
1896         RNA_def_property_int_sdna(prop, NULL, "texture_overlay_alpha");
1897         RNA_def_property_range(prop, 0, 100);
1898         RNA_def_property_ui_text(prop, "Texture Overlay Alpha", "");
1899         RNA_def_property_update(prop, 0, "rna_Brush_update");
1900
1901         prop = RNA_def_property(srna, "mask_overlay_alpha", PROP_INT, PROP_PERCENTAGE);
1902         RNA_def_property_int_sdna(prop, NULL, "mask_overlay_alpha");
1903         RNA_def_property_range(prop, 0, 100);
1904         RNA_def_property_ui_text(prop, "Mask Texture Overlay Alpha", "");
1905         RNA_def_property_update(prop, 0, "rna_Brush_update");
1906
1907         prop = RNA_def_property(srna, "cursor_overlay_alpha", PROP_INT, PROP_PERCENTAGE);
1908         RNA_def_property_int_sdna(prop, NULL, "cursor_overlay_alpha");
1909         RNA_def_property_range(prop, 0, 100);
1910         RNA_def_property_ui_text(prop, "Mask Texture Overlay Alpha", "");
1911         RNA_def_property_update(prop, 0, "rna_Brush_update");
1912
1913         prop = RNA_def_property(srna, "cursor_color_add", PROP_FLOAT, PROP_COLOR);
1914         RNA_def_property_float_sdna(prop, NULL, "add_col");
1915         RNA_def_property_array(prop, 3);
1916         RNA_def_property_ui_text(prop, "Add Color", "Color of cursor when adding");
1917         RNA_def_property_update(prop, 0, "rna_Brush_update");
1918
1919         prop = RNA_def_property(srna, "cursor_color_subtract", PROP_FLOAT, PROP_COLOR);
1920         RNA_def_property_float_sdna(prop, NULL, "sub_col");
1921         RNA_def_property_array(prop, 3);
1922         RNA_def_property_ui_text(prop, "Subtract Color", "Color of cursor when subtracting");
1923         RNA_def_property_update(prop, 0, "rna_Brush_update");
1924
1925         prop = RNA_def_property(srna, "use_custom_icon", PROP_BOOLEAN, PROP_NONE);
1926         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_CUSTOM_ICON);
1927         RNA_def_property_ui_text(prop, "Custom Icon", "Set the brush icon from an image file");
1928         RNA_def_property_update(prop, 0, "rna_Brush_icon_update");
1929
1930         prop = RNA_def_property(srna, "icon_filepath", PROP_STRING, PROP_FILEPATH);
1931         RNA_def_property_string_sdna(prop, NULL, "icon_filepath");
1932         RNA_def_property_ui_text(prop, "Brush Icon Filepath", "File path to brush icon");
1933         RNA_def_property_update(prop, 0, "rna_Brush_icon_update");
1934
1935         /* clone tool */
1936         prop = RNA_def_property(srna, "clone_image", PROP_POINTER, PROP_NONE);
1937         RNA_def_property_pointer_sdna(prop, NULL, "clone.image");
1938         RNA_def_property_flag(prop, PROP_EDITABLE);
1939         RNA_def_property_ui_text(prop, "Clone Image", "Image for clone tool");
1940         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, "rna_Brush_update");
1941
1942         prop = RNA_def_property(srna, "clone_alpha", PROP_FLOAT, PROP_NONE);
1943         RNA_def_property_float_sdna(prop, NULL, "clone.alpha");
1944         RNA_def_property_range(prop, 0.0f, 1.0f);
1945         RNA_def_property_ui_text(prop, "Clone Alpha", "Opacity of clone image display");
1946         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, "rna_Brush_update");
1947
1948         prop = RNA_def_property(srna, "clone_offset", PROP_FLOAT, PROP_XYZ);
1949         RNA_def_property_float_sdna(prop, NULL, "clone.offset");
1950         RNA_def_property_ui_text(prop, "Clone Offset", "");
1951         RNA_def_property_ui_range(prop, -1.0f, 1.0f, 10.0f, 3);
1952         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, "rna_Brush_update");
1953
1954         prop = RNA_def_property(srna, "brush_capabilities", PROP_POINTER, PROP_NONE);
1955         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1956         RNA_def_property_struct_type(prop, "BrushCapabilities");
1957         RNA_def_property_pointer_funcs(prop, "rna_Brush_capabilities_get", NULL, NULL, NULL);
1958         RNA_def_property_ui_text(prop, "Brush Capabilities", "Brush's capabilities");
1959
1960         /* brush capabilities (mode-dependent) */
1961         prop = RNA_def_property(srna, "sculpt_capabilities", PROP_POINTER, PROP_NONE);
1962         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1963         RNA_def_property_struct_type(prop, "SculptToolCapabilities");
1964         RNA_def_property_pointer_funcs(prop, "rna_Sculpt_tool_capabilities_get", NULL, NULL, NULL);
1965         RNA_def_property_ui_text(prop, "Sculpt Capabilities", "Brush's capabilities in sculpt mode");
1966
1967         prop = RNA_def_property(srna, "image_paint_capabilities", PROP_POINTER, PROP_NONE);
1968         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1969         RNA_def_property_struct_type(prop, "ImapaintToolCapabilities");
1970         RNA_def_property_pointer_funcs(prop, "rna_Imapaint_tool_capabilities_get", NULL, NULL, NULL);
1971         RNA_def_property_ui_text(prop, "Image Painting Capabilities", "Brush's capabilities in image paint mode");
1972
1973         prop = RNA_def_property(srna, "gpencil_settings", PROP_POINTER, PROP_NONE);
1974         RNA_def_property_struct_type(prop, "BrushGpencilSettings");
1975         RNA_def_property_pointer_sdna(prop, NULL, "gpencil_settings");
1976         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1977         RNA_def_property_ui_text(prop, "Gpencil Settings", "");
1978
1979 }
1980
1981 /**
1982  * A brush stroke is a list of changes to the brush that
1983  * can occur during a stroke
1984  *
1985  * - 3D location of the brush
1986  * - 2D mouse location
1987  * - Tablet pressure
1988  * - Direction flip
1989  * - Tool switch
1990  * - Time
1991  */
1992 static void rna_def_operator_stroke_element(BlenderRNA *brna)
1993 {
1994         StructRNA *srna;
1995         PropertyRNA *prop;
1996
1997         srna = RNA_def_struct(brna, "OperatorStrokeElement", "PropertyGroup");
1998         RNA_def_struct_ui_text(srna, "Operator Stroke Element", "");
1999
2000         prop = RNA_def_property(srna, "location", PROP_FLOAT, PROP_XYZ);
2001         RNA_def_property_flag(prop, PROP_IDPROPERTY);
2002         RNA_def_property_array(prop, 3);
2003         RNA_def_property_ui_text(prop, "Location", "");
2004
2005         prop = RNA_def_property(srna, "mouse", PROP_FLOAT, PROP_XYZ);
2006         RNA_def_property_flag(prop, PROP_IDPROPERTY);
2007         RNA_def_property_array(prop, 2);
2008         RNA_def_property_ui_text(prop, "Mouse", "");
2009
2010         prop = RNA_def_property(srna, "pressure", PROP_FLOAT, PROP_NONE);
2011         RNA_def_property_flag(prop, PROP_IDPROPERTY);
2012         RNA_def_property_range(prop, 0.0f, 1.0f);
2013         RNA_def_property_ui_text(prop, "Pressure", "Tablet pressure");
2014
2015         prop = RNA_def_property(srna, "size", PROP_FLOAT, PROP_NONE);
2016         RNA_def_property_flag(prop, PROP_IDPROPERTY);
2017         RNA_def_property_range(prop, 0.0f, FLT_MAX);
2018         RNA_def_property_ui_text(prop, "Brush Size", "Brush Size in screen space");
2019
2020         prop = RNA_def_property(srna, "pen_flip", PROP_BOOLEAN, PROP_NONE);
2021         RNA_def_property_flag(prop, PROP_IDPROPERTY);
2022         RNA_def_property_ui_text(prop, "Flip", "");
2023
2024         /* used in uv painting */
2025         prop = RNA_def_property(srna, "time", PROP_FLOAT, PROP_UNSIGNED);
2026         RNA_def_property_flag(prop, PROP_IDPROPERTY);
2027         RNA_def_property_ui_text(prop, "Time", "");
2028
2029         /* used for Grease Pencil sketching sessions */
2030         prop = RNA_def_property(srna, "is_start", PROP_BOOLEAN, PROP_NONE);
2031         RNA_def_property_flag(prop, PROP_IDPROPERTY);
2032         RNA_def_property_ui_text(prop, "Is Stroke Start", "");
2033
2034         /* XXX: Tool (this will be for pressing a modifier key for a different brush,
2035          *      e.g. switching to a Smooth brush in the middle of the stroke */
2036
2037         /* XXX: i don't think blender currently supports the ability to properly do a remappable modifier
2038          *      in the middle of a stroke */
2039 }
2040
2041 void RNA_def_brush(BlenderRNA *brna)
2042 {
2043         rna_def_brush(brna);
2044         rna_def_brush_capabilities(brna);
2045         rna_def_sculpt_capabilities(brna);
2046         rna_def_image_paint_capabilities(brna);
2047         rna_def_gpencil_options(brna);
2048         rna_def_brush_texture_slot(brna);
2049         rna_def_operator_stroke_element(brna);
2050 }
2051
2052 #endif