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